Pull to refresh

Comments 584

Смысл всей статьи в одном предложении: «При приёме на работу нового программиста дайте ему тестовое задание»
Кратк. — сес. тал.! Ловите плюс :)
Краткость — сестра нашего брата.
По слухам, автор этого выражения скатился в УГ… :(
Тут есть несколько различных мнений.
Скажем, 4duk.ru/ местами очень неплох.
UFO just landed and posted this here
Смысл всей статьи — дайте ему ПРОСТЕЙШЕЕ тестовое задание.
… прежде, чем давать более сложное.
хуже бывает, когда тестовое задание дают на несколько дней домой. если на собеседовании, то это отличная практика.
Знаете, помоему даже всё проще. Если у человека опыт работы 2-3 года по CV, но при этом там PHP/JavaScript/Python/Ruby/Java — уже можно пропускать CV :)

Я лично ненавижу задания на собеседовании, и этому несколько причин:
1. Я человек работающий, и как правило вырываюсь или на обеде, или вечером к 18. У меня нету лишних 4-х часов (или пары дней как в некоторых случаях).
2. Я не помню алгоритмы из головы (ну сортировку пузырьком конечно напишу :) ), а математику так и подавно (те вещи, которые по сложнее. Не лежит у меня к вышке).

Эти два пункта как правило то, из-за чего я просто не иду на некоторые собеседования, хотя по критериям подхожу на ура.

Прислать кусок кода если честно меня обычно тоже коробит. Просто потому, что ну пришлю я вам файл контроллера, или модели. И что? Половина там будет по стандартам фреймворка, вторая половина кастомного кода тоже в стиле фреймворка. Всё это будет завязано на события и хуки в связанных моделях и скорее всего толком ничего понятно не будет. А выслать вам целый модуль я не могу, потому что это чужой код и мне за него отвалили кучу бабла (мелочевкой я не занимаюсь, натягиванием сайтов на CMS тоже не занимаюсь).

Гораздо больше мне нравиться, когда просто спрашивают те или иные вещи и нужно просто дать ответы. Поинтересуются что я думаю по поводу тех или иных технологий, спросят о приведущих проектах, проблемах которые решал. Спросят пару базовых вещей по профилю. Всё это отвечается за 5-20 минут в зависимости от кол-ва вопросов и желания инвертирующего пообщаться по человечески. Последние 2 собеседования у меня выливались почти по часу, были очень интересные дискуссии и обмен опытом помимо стандартного интервью. Уходил с приятными ощущениями о работающих там людях и компании как таковой. Другое дело что не сложилось из-за некоторых обстоятельств (а на последнее место очень хотелось).
UFO just landed and posted this here
Даже если ищите кандидата на должность php программиста, которому все эти ваши биты и адреса до фени и он с ними никогда не сталкивается? Вообще это бредовый способ. Ответ гуглится без особых сложностей, если хотя бы примерно представлять себе суть вопроса.
UFO just landed and posted this here
По адресу или в числе 1234567?
UFO just landed and posted this here
mov dx, 1234567
mov al, [dx]
xor al, 64
mov [dx], al

так? :) (15 лет на асме не писал и честно не гуглил синтаксис)

чёрт, 1234567 это больше максимально адресуемой памяти в 8086, не говоря о том что больше размера сегмента
UFO just landed and posted this here
char *ptr = (char*)1234567;
*ptr ^= 1 << 7;
Ни хрена себе! Биты принято нумеровать справа и с нуля FYI.
С нуля? Лично никогда не слышал термина «нулевой бит».
Под «первым битом» всегда имелся ввиду самый наименее значимый бит. Аналогично первый байт, а не нулевой.
Но нумерация бит в байте, бит и байт в слове и в других многобайтовых объек-тах в различных вычислительных системах может быть различной.


www.kailib.ru/part2?start=3 — третий результат на момент написания коммента (страховка от сеошников :) ) по вашей ссылке

Вообще, всю жизнь воспринимал нормально как нумерацию битов (и байтов, и слов различной длины) как с нуля, так и с единицы (очень часто приходилось кодить параллельно на разных языках), но если по контексту не ясно, что нумерация конкретной сущности начинается с нуля, то всегда подразумевал нумерацию с единицы. Даже фраза «первый элемент массива имеет индекс ноль, а значит нулевой элемент равен первому» не вызывает диссонанса :D
Да не, понятно, что это вопрос обозначений. Можно хоть ёлочкой из середины нумеровать — главное договориться заранее. Речь идёт о том, что общепринятым обозначением является нумерация с младших битов и с нуля. Если соискатель ищет работу системного программиста и не знает, что в 99% литературы по процессорам, регистрам, портам и прочим железкам нумерация битов с нуля, то сразу делается вывод, что практики в низкоуровневом программировании у него нет. Кстати, в сетевых RFC точно такая же нумерация.

По сути, это не значит, что это плохой программист, и его надо сразу прогонять. Просто именно в данных вопросах он неопытен, надо это помнить.
Не уверен, что конструкция типа *p ^= 64; не выкинет BSOD для char *p = 1234567; (тоже по памяти), тем более не уверен, что сработает *1234567 ^= 64… :(
И про приведение типа забыл за 10 лет :( Не быть мне Си программистом, да собственно и не стремлюсь :)
Плохая задача, придумайте что-то чтобы 200 из 200 отсеивались :)
А какое правильное решение???
Лобовое решение вида:
#include <stdio.h>
int main (int argc, char **argv)
{
    unsigned char *address = (unsigned char*)1234567;
    unsigned char was = address[0];
    printf("was %i\n",was);
    unsigned char became;
    if (was < 250){
        became = was + 2;
    }
    else{
        became = was - 2;
    }
    printf("became %i\n",became);
    return 0;
}

не годится, это понятно: будет Segmentation Fault.
О том и речь — задача не должна требовать больше нескольких минут на решение, поэтому и достаточно давать тривиальную, просто чтобы посмотреть как человек умеет взять и написать код. Если он это сделать умеет — то в реальной работе ничто не мешает ему смотреть алгоритмы/формулы/best practices, не экзамен же сдается.

Кстати некоторые мудрые преподаватели сложных дисциплин разрешают пользоваться любыми материалами во время сдачи, т.к. в реальной жизни намного важнее умение быстро найти ответ, чем помнить его наизусть
Я бы сказал, что среди хороших преподавателей дисциплин, связанных с ИТ, таковых подавляющее большинство.
Верное замечание! Такое ощущение, что образование отметает все инструментальные достижения, требуя как и в средние века находить решение полностью из головы. Как будто готовят не специалистов в реальные условия, а игроков в интеллект-шоу
«приведущих»
Наконец-то я нашел человека, который пишет так же как я слышу!
Зато какой резонанс — бурные обсуждения!
Этвуд всегда так пишет, можно только выделенное жирным читать
Интересно, где обучают программистов которые не могут решить задачу FizzBuzz, или сколько они заплатили за свой диплом?
У нас в университете выпускали программистов, которые платили мне, чтобы я решал FizzBuzz за них.
У нас тоже такое было, но все-таки эти люди не шли работать программистами после ВУЗа
Аналогично! Причём, непонятно зачем они вообще шли учиться «программистами», если не собирались ими работать. По логике они должны были ещё на первом курсе поняв что не тянут перевестись на другой факультет.

PS только я тогда брал не деньгами (и нет не борзыми щенками), а дискетами. Так как дискеты от Verbatim часто дохли чуть ли не при первой попытке с них что-нибудь считать.

Странно, у меня вербатимки как на подбор были самыми качественными и долгоживущими, в отличие от остальных

У меня самыми живучими были FujuFilm и FujiKawa (FujiFilm проработал более 10 лет до самого выхода дискет из обращения, а на FujiKawa через 10 лет появился бад-сектор). А вот Verbatim — часто дох.
о! Коллега :) На первом курсе аналогично зарабатывал себе на обед.

Знаю некоторых вечерников-выпускников МИРЭА IT специальностей. Вопрос про шаблоны проектирования вешает мозг. :)
Я до четвертого курса так зарабатывал :)
На втором курсе мой «заготовок для курсача по C++» купило 15 человек. Из них только шестеро додумались его хотя бы запустить на досуге, хотя я заранее говорил, что это полуфабрикат, который нужно будет самому доделать под себя. Остальные пришли с невинным лицом с день сдачи и обнаружили, что там в разделе About написано Made by Vasya Pupkin, чему препод был несказанно рад…
Если уж продавали, можно было выдать персональные лицензии )
За те деньги, которые стоит индивидуальная домашняя работа, ее только один человек захотел купить )
IT специальность != программирование, и про шаблоны проектирования они ничего знать не должны.
уточните, пожалуйста, термин «IT специальность»
Наверное: системник пропылесосить и картридж в принтере заменить :)
Есть некоторые лицеи, которые выпускают 3-4 человек с выпуска, которые это могут решить :)
А из лицеев или институтов вообще выгоняют, если не за огромные прогулы или неуплату?
У меня сложилось мнение, что в России сколько человек пришло учиться, столько и будет выпущено с дипломами в итоге — главное хоть иногда появляться.
Ну, у меня, например, с пятого курса отчислили одногруппницу, которая получала президентскую стипендию и заняла первое место в республике по высшей математике, но при всём при этом продолжают учиться люди, для которых создать объект в С++ — проблема.
Это у вас приличное учебное заведение еще.

Я в свое время бросил НГТУ, специальность «Защита информации» (http://ciu.nstu.ru/kaf/zi) — работать нужно было. А мой одногруппник, успешно закончивший и получивший диплом инженера, недавно спросил меня, что такое SHA1. При этом он несколько лет работает в сфере webdev (правда, на ActionScript в основном, но не суть). Другие ребята, которые ушли от информатики дальше, боюсь, и того меньше знают. Печально это все.
За что отчислили, не скажете? Просто интересно.
Просто на нашей кафедре очень много вахтёров. Например, один вообще издевается, доводит людей, что они уже плачут: один человек, защищая лабу стоял перед ним, и у него уже руки тряслись (так перенервничал), а этот вахтёр — улыбался(и это хорошо всем было видно), шутил по-своему над ним, унижал, но при этом напрямую не оскорбляя. Мог назначить время пересдачи, прийти за пять минут до конца, принять у кого-то одну лабу и сразу свалить домой, при том что больше 20-ти человек висит. Он у нас 1С вёл.
Ощущение, что у него комплексы от того, что он ведет неполноценный ЯП и он их на студентах вымещает.
Нет, на самом деле он очень умный человек(постоянно ездит на конференции заграницу по нейронным сетям и занимает на них призовые места), но с ним даже другие молодые преподы не дружат и не разговаривают, ну и если он с ними первым не поздоровается, то с ним никто первым здороваться не будет(по крайней мере я такого ни разу не видел за все 5 курсов).
У него не комплексы, у него звездочка загорелась
Мне на 3-м или 4-м курсе (специальность 220100) поставили неуд на экзамене по «C++ и объектно-ориентированное программирование» за использование конструкции x?a:b; Препод сказал что такого вообще нет и это я сам всё придумал :-D

А так как это была последняя капля то через некоторое время я из универа отчслился. 2 года армии (там итшники очень востребованы), а потом работаю по специальности. Админ, программер и т.д.
UFO just landed and posted this here
Компы везде есть. Так что да.
Был связистом. Сетка довольно немаленькая. Видеонаблюдение (Videonet), охранная сигнализация и много ещё в этом духе.
Речь наверное даже не об администрировании сеток и т. п., а о «печатных машинках» где-нибудь на КП роты или в штабе батальона.
Ну, «печатные машинки» это отдельная тема. Я имел в виду именно более интересное: протяжка сетки, настройка, серваки, интернет. Серваки видеонаблюдения и охранки. Плюс начальство тоже люди — одному дома помочь что-то настроить, другому :-) Я в связисты попал когда у комбата кто-то пароль поставил на биос, он спросил у взвода «кто могёт убрать?». Ну я вызвался, быстренько сбросил парой командой в debug (на том компе DOS стояла). В результате чуть ли не карьеру там сделал :-D Но слава богу хватило ума по контракту не остаться.
Да. Любой умеющий нормально обращаться с компьютером человек может получать поблажки.
Но это всё равно армия с дисциплиной и идиотами )
Кстати дисциплина не есть плохо :-) Идиотов да, хватало.
Мне на 3-м или 4-м курсе (специальность 220100) поставили неуд на экзамене по «C++ и объектно-ориентированное программирование» за использование конструкции x?a:b; Препод сказал что такого вообще нет и это я сам всё придумал :-D

Что-то мне анекдот про крысу, хомяка и пиар вспомнился. :-)
Ни одному препаду не приходило в голову сомневаться в моих знаниях.
У меня на курс был набор 125 чел., вышло примерно 80(2 группы из 5 сократили ибо слишком маленькие группы получались).
Правда приходилось преподам помогать понять почему не работают те или иные программки из задачника на паскале :)
А на самых модных факультетах вообще был бейсик :)
Не поверишь, я когда искал людей с такими встречался каждый божий день (иногда 12-ти летние пацанята с форумов, бывает дадут фору «соискателям» с высшими образованиями и кучей страшных слов в «резюме»)
UFO just landed and posted this here
«Нормальный программист должен написать такую программу на бумажке за пару минут. „
наверное 5 минут было по их мнению слишком долго:) А может им ваш почерк не понравился, прическа или еще что-нибудь в этом роде.
Мой бывший шеф несколько лет назад размещал вакансии в службе занятости из-за каких то льгот или освобождения от какого-то налога (Украина). Вакансии естественно были липовыми. Но люди звонили, даже приходили на собеседование… Так что всякое бывает.
В СПбГУ например, у нас на кафедре Технологии Программирования, где-то четверть бы не справилась
очень странно, что с этой задачей можно вообще не справиться.
всего два условия на кратность, тут надо либо не знать про цикл for, либо не знать синтаксиса определения остатка/кратности какому-либо числу.
нет, неужели 199 из 200?
запороться можно на двойной кратности и на else, как только решишь оптимизировать (а на собеседовании же не хочется выглядеть неэффективно кодирующим) программу, чтобы не писать 4 взаимоисключающих if в лоб, ежу понятно, что раз условия взаимоисключающие, то как минимум без одного условия можно обойтись, но начинаются трудности с определением какого. Плюс явная подсказка на ещё одну оптимизацию, что FizzBuzz состоит из Fizz+Buzz и начинается путаница с двумя одновременными оптимизациями в уме. Вообще хороший тест на выявление не только тех, кто синтаксис не знает, но и на любителей преждевременной оптимизации или писать сильно вложенный код там, где можно обойтись плоским (пускай и не таким эффективным)

Даже здесь в комментах выложили нерабочие решения, что уж говорить…
у меня в группе 27 человек и из всех, помимо меня, код могут писать еще человека 4.
а в дипломе всем напишут: «профессионал в области программирования»
У нас препод вообще говорил «Чем меньше вы знаете, тем больше я стою как специалист» :)
В трех фирмах принимал людей. Солгласен. Если берете людей с опытом, то около половины не умеют писать код. Именно поэтому не задаю задачи на сообразительность (стиля микрософт), а
1. Задача на минимальное программирование (чуть посложнее чем приведенные тут). Причем можно в превдо коде, а не на каком то языке
2. Технологческая задача — придумать как что то делать — без написания кода — например придумать свою сериализацию для какой то цели

Основная причина — люди не интересуются. Пишут свой кусочек, им код ревью не делают, их вся система, технологии, качество кода не интересует. И получаются люди с опытом в 3-5-7 лет пишущие ооочень плохо и ничего не знающие.

50% заваливаются на вопросе «опишите архитектуру продукта в котором вы работали последние Х лет»
А я, честно сказать, сперва напрягся. Но проверил и уложился в минуту.
На груви. За 53 секунды :)

for (n in 1..100) {
if (n%3 == 0 && n%5 != 0) println 'Fizz'
else if (n%5 == 0 && n%3 != 0) println 'Buzz' else
if (n%5 == 0 && n%3 == 0) println 'FizzBuzz' else
println n
}
На Haskell:
fizzbuzz x | divides x 3 && divides x 5 = "FizzBuzz"
           | divides x 3 = "Fizz"
           | divides x 5 = "Buzz"
           | otherwise = show x
  where
  divides x n = x `mod` n == 0

main = mapM (putStrLn . fizzbuzz) [1..100]
у вас обоих первое условие лишнее
— если кратно трем выведем Fizz
— если кратно пяти выведем Buzz

а если кратно и трем, и пяти — FizzBuzz получится само)
В Хаскелле, чтобы оно само так получилось, надо несколько по-другому написать.
Можно конечно, но никто не может сказать, что этот вариант неправильный.
Он как раз видится мне тру-функциональным :)
возможно, я говорил о логике
С точки зрения логики тут все нормально, выполняются оба условия -> выводим FizzBuzz, а то что все условия надо проверять не более одного раза — это подразумевается в нестрогой семантике Haskell'я. И компилятор все сделает как надо.
Это лишь декларативное описание соответствия входных данных желаемым выходным не отражающее то, как оно будет вычисляться в реальности.
Простите, но ваше утверждение верно только для императивных языков.
То есть в Хаскелле, конечно, можно присобачить эту императивщину и получить грязную функцию. Но это быдлокодинг и неуважение к такому языку.
+1 такого рода оптимизации это вообще задача компилятора — надо писать максимально близко к формулировке задачи.
«надо» каждый сам для себя определяет
мне вот надо писать максимально минимально, при этом чтобы задача была решена
>> максимально минимально
o_O
Писать надо в первую очередь понятно. Минимально писать конечно круто — можно быть уверенным что вас никто не уволит, т.к. фиг кто когда то разберется в том, что вы там накодили, но это не дело.
>мне вот надо писать максимально минимально, при этом чтобы задача была решена

«Спасибо, вы нам не подходите».

В тот момент, когда количество разработчиков проекта переваливает отметку «1», писать надо не «максимально минимально», а максимально понятно. Причём без понтов вида «на самом деле это понятно, а если кому-то непонятно, то он сам идиот, а я умный».
опять же, возможно
я с хаскеллом не знаком, может быть в двух словах скажете в чем выражается «императивность» языка?
Команды выполняются последовательно, есть присваивания.

В чисто функциональных языках принципиально по другому — программа описывается, как математическая функция.
Вкратце:
императивное программирование — это когда вы описываете какие нужно выполнить действия и в каком порядке.
декларативное программирование — вы описываете что вы хотите получить задавая правила/формулы преобразования входных данных в выходные. Компилятор сам решает какие действия нужно выполнять и в каком порядке.

Почитайте все таки про Haskell — полезно для развития кругозора.
но также нужно вывести число если условия не работают
в задаче такого не было
Да, кстати, даже если мы используем императивный язык. Если вы выбросите первое условие, вы лишитесь взаимоисключающей конструкции. И в этом случае вам все равно перед выводом числа придется дополнительно проверять, а не было ли уже что-то выведено для этого числа. Иначе ваша программа выплюнет что-то типа «FizzBuzz15».

Вот благодаря своим оптимизациям вы бы и не попали туда на работу. ;)
а зачем выводить число? я не нашел такого в задаче
уже нашел. но мне кажется что суть не меняется все-таки — число выводим отдельно, физбазз — отдельно
блин. вы победили, а я — невнимательный, не увидел слово «вместо»
Хорошо отношусь к людям, признающим свой промах, посему плюс вам. :)
Жаль, не могу добраться до того стада, которое бездумно плюсовало, не думая своей головой. ]:->
А чего до них добираться? У них и без вас будет куча провальных собеседований.
я после первого прочтения задачи подумал, что подвох будет именно в этом. Хотя, похоже, задачка вообще не задумывалась как задача с подвохом)
А куда тогда девать условие 'не кратно 3 и 5'?
По плюсам сразу видно что тема актуальна )
функция вызывается один раз для одного x. если несколько клоз удовлетворяют условию, будет использована первая. так что код правильный
perl -le '$_ % 3 ? $_ % 5 ? $_ : "Buzz" : $_ % 5 ? "Fizz" : "FizzBuzz" for 1 .. 100'
Вот за такой код в реальном проекте я готов оторвать руки, у меня нет ни малейшего желания распутывать хитросплетения воспаленного мозга автора кода, когда нужно что-то исправить или просто понять, что код делает. Сравните

foreach my $i (1..100) {
unless($i % 3) {
print «Fizz»;
}
unless($i % 5) {
print «Buzz»;
}
if($i % 3 && $i % 5) {
print $i;
}
print "\n";
}
А вы расслабьтесь, FizzBuzz это не реальный проект :)
Одна из целей FizzBuzz как раз в том, чтобы увидеть пример кода кандидата.
Если бы вы пришли ко мне на собеседование и написали решение в таком виде — вы бы не прошли :)
Цель FizzBuzz — увидеть, способен ли человек думать мозгами. Кода в этой задаче маловато для того, чтобы оценивать его красоту.
>Цель FizzBuzz — увидеть, способен ли человек думать мозгами.

А может вы недостаточно глубоко смотрите?

>Кода в этой задаче маловато для того, чтобы оценивать его красоту.

Для того, чтобы оценить стиль кода — вполне достаточно. По крайней мере ваш стиль я уже «оценил» :)
Это вообщет шутка старого перловика была.
Мдэ, все пробелы съелись

foreach my $i (1..100) {
  unless($i % 3) {
    print «Fizz»;
  }
  unless($i % 5) {
    print «Buzz»;
  }
  if($i % 3 && $i % 5) {
    print $i;
  }
  print "\n";
}
Ну что вы так близко к сердцу принимаете. Это всего лишь вопрос договоренностей.

Я вот, например, за unless руки отрываю :)
Потому что это тоже хитросплетения мозга. Потому что приводит к unless(! $a)

Посмотрите, например, Perl::Critic::Policy::ControlStructures::ProhibitUnlessBlocks.
Я использую unless только в одном единственном случае — в качестве замены простого условия if с отрицанием, т.к. в простом условии можно знак восклицания не заметить при беглом взгляде на код.
Т.е. вместо if(!$a) пишу unless($a) или вместо if(!($a > 5)) пишу unless($a > 5).
Я перл не знаю, но почему вместо if(!($a > 5)) нельзя написать if($a <= 5)?
За описанную выше конструкцию убивать надо, да. А за unless — зачем? Я её при валидации использую, очень удобно.
Ну, я, конечно, маленько шучу… но вообще-то не люблю unless. Избегаю. В целях неувеличения энтропии :)
unless(энтропия не увеличена)… ;)
Ваша программа ничего не выводит :)
Вот за это я люблю перл :)
Думаю всё же где-то так будет лучше:
perl -le 'print join "\n", map { ($_,«Fizz»,«Buzz»,«FizzBuzz»)[!($_%3)+2*!($_%5)] } 1..100'
зачем делать отдельное условие для FizzBuzz?
Да, тоже так подумал :)
На Ruby(не бейте больно, второй день трогаю — уверен, есть более лаконичный вариант)
def fizzbuzz
res=""
(1..100).to_a.each do |elem|
res+=«Fizz» if (elem%3).zero?
res+=«Buzz» if (elem%5).zero?
res+="#{elem}" unless ((elem%3).zero? or (elem%5).zero?);
res+=","
end
res
end
puts fizzbuzz
def fizzbuzz
  res=""
  (1..100).to_a.each do |elem|
    res+="Fizz" if (elem%3).zero?
    res+="Buzz" if (elem%5).zero?
    res+="#{elem}" unless ((elem%3).zero? or (elem%5).zero?);
    res+=","
  end
  res
end

puts fizzbuzz
res=""
100.times do |num|
  elem = num+1
  res+="#{elem}" unless ((elem%3).zero? or (elem%5).zero?)
  res+="Fizz" if (elem%3).zero?
  res+="Buzz" if (elem%5).zero?
  res+=","
end
puts res
      (1..100).map do |i|
        puts i, [
                (i % 3).zero? ? "Fizz" : nil,
                (i % 5).zero? ? "Buzz" : nil
        ].compact.join
      end.compact


Можно и еще более извращенными способами.
Эх, поспешил
      (1..100).each do |i|
        puts i, [
                (i % 3).zero? ? "Fizz" : nil,
                (i % 5).zero? ? "Buzz" : nil
        ].compact.join
      end
Не катит. Выводит числа 3, 5, 15 и т.д.
100.times do |i|
  num=i+1
  [ (num % 3).zero? ? "Fizz" : nil,
    (num % 5).zero? ? "Buzz" : nil
    ].compact.join.display
  num.display unless (num % 3).zero? or (num % 5).zero?
  puts
end
Да, невнимательно прочитал условие

      (1..100).each do |i|
        puts (a = [
                (i % 3).zero? ? "Fizz" : nil,
                (i % 5).zero? ? "Buzz" : nil
        ].compact.join).empty? ? i : a
      end


100.times, в вашем случае, начнет отсчет с нуля и закончит на 99.
в коде используется переменная на 1 больше счетчика.
Извиняюсь, пропустил вторую строку. Пойду спать
Обалденный вариант :)
Его можно записать с одну сроку, превратив Руби в плохой Перл :)
puts (1..100).map { |i| (a = [(i % 3).zero? ? "Fizz" : nil, (i % 5).zero? ? "Buzz" : nil].compact.join).empty? ? i : a }
UFO just landed and posted this here
UFO just landed and posted this here
Вот на Scala

println(1 to 100 map( i => if (i%3==0) "Fizz" else if (i%5==0) "Buzz" else if (i%15==0) "FizzBuzz" else i ))

У меня тоже похоже вышло. Читаемости правда никакой, зато коротко:)
1.upto(100){|i|s=i%3==0?'fizz': '';s+='buzz'if i%5==0;puts s==''?i: s}
Довел до конца ваш вариант.
100.times do |i|
  num=i+1
  [ (num % 3).zero? ? "Fizz" : nil,
    (num % 5).zero? ? "Buzz" : nil,
    ((num % 3).zero? or (num % 5).zero?) ? nil : num,
    ","
    ].compact.join.display  
end
А я так сделал:

(1..100).each do |i|  
  puts (s = "#{"Fizz" if (i % 3).zero?}#{"Buzz" if (i % 5).zero?}").empty? ? i : s 
end
Так это че за язык? Пишите все язык, плиз.
Класс у подсветки синтаксиса — ruby
Вы считаете нормальным изучать исходники страницы, для выяснения того, на каком языке написан фрагмент одного из сотен комментов? Я-то ruby опознал, но вот не уверен, что, например, отличу Scheme от CommonLisp (вернее уверен, что не отличу).

Если вы просто подсказали человеку, на каком языке этот тред, не имея в виду, что он мог сам посмотреть исходники, приношу свои искренние извинения.
вот это синтаксис! код сразу понятен и при этом очень коротко записан!
Например вот так, на перле:
for (1..100)
{
  print (  (!($_%3) && !($_%5))?'FizzBuzz':(!($_%3)?'Fizz':(!($_%5)?'Buzz':$_)) );
}


PHP — это маленькое зло, созданное некомпетентными новичками, в то время как Perl — это большое и коварное зло, созданное умелыми, но извращёнными профессионалами.
0_o Блин. Теперь perl у меня ассоциируется со смайликами $_%
Можно сделать красивее, как например тут.
А я добавил скобок, для большей читаемости %).
Эти смайлики плачут кровавыми слезами.
ну вот) опередили
Вот-вот. :) Я полагаю, именно это и имелось ввиду, когда автор говорит о том, что люди не умеют программировать…
Упомянутая недооптимизация требует дополнительной проверки того, что мы не вывели уже эти физы-базы. Из-за этого код становится менее читабельным, чем если бы содержал 4 условия.

Если бы меня не приняли из-за этого на работу, то я был бы только рад: нахер нужна ТАКАЯ работа?!
действительно — пааадумаешь, что условие задачи не выполнено :-) важно ж, чтобы красиво.
Условий вообще тут нужно ноль:
print [$_,"Fizz","Buzz","FizzBuzz"]->[!($_%3)+!($_%5)*2]."\n" foreach(1..100)

(Перл, на других языках аналогично)
А толку? Переложить условную логику (которая тут гораздо более понятно выглядит) на доступ по индексу? Так в таком случае можно писать любой код вообще без условий, только зачем?
А зачем избавляться от условия на FizzBuzz? Если цель меньше условий, то держите. А если нет такой цели, а цель просто написать работающую программу, то суть вышеуказанной претензии неясна.
Незачем избавляться вообще ни от каких условий тут, должно быть 3 условия и в итоге 4 ветки.

Просто подумал что описанный вами подход вы считаете правильным (исходя из слова «нужно» в каменте), если это была ирония, гиперболизирующая ответ предыдущего комментатора — прошу прощения, не уловил.
Я сперва тоже с тремя условиями написал, но мне тут в чате стали говорить, мол, одно условие лишнее :-)
Даже если и найдется рабочий вариант с двумя условиями — это всё равно хуже чем топорный вариант с 3-мя. Так что вам в чате врут.
Хех, сначала написал чуть выше, а потом Ваш коментарий увидел. Мысли сходны :) Тоже подумалось о том что в минимализме можно условия убрать
Если не делать отдельный if, то все равно перед выводом числа нужно будет делать проверку:
for (int i = 0; i < 100; i++) {
	bool byThree = (!(i % 3));
	bool byFive = (!(i % 6));
	
	if (byThree) std::cout << "Fizz";
	if (byFive) std::cout << "Buzz";
	if (!byThree && !byFive) std::cout << i;
	std::cout << std::endl;
}

UFO just landed and posted this here
пэхапэ

for ($i = 0; $i < 100; $i++) {
if ($i % 5 == 0 && $i % 3 == 0) print «FizzBuzz».PHP_EOL;
elseif ($i % 5 == 0) print «Buzz».PHP_EOL;
elseif ($i % 3 == 0) print «Fizz».PHP_EOL;
else print $i.PHP_EOL;
}
в условии от 1 до 100, а не от 0 до 99
это мелкая ошибочка
А потом в Африке самолеты падают!
Если пожертвовать красотой и несколькими строчками, то можно решить задачу вот так.
В Вашем варианте отдельное условие для вывода FizzBuzz необосновано.
for ($i = 1; $i <= 30; $i++)
{
    if (($i % 3 != 0) AND ($i % 5 != 0)) echo $i;
    else
    {
        if ($i % 3 == 0) echo 'Fizz';
        if ($i % 5 == 0) echo 'Buzz';
    }
    echo '
';
}
Парсер лох… Там в конце был br.
А в начале 30 вместо 100 — это у меня экран на ноуте маленький, на 100 записях скролл появится...))
Мне мой вариант кажется более человекочитаем, при том что для того чтобы поменять физзбазз на что-нибудь другое ненужно менять логику. А по производительности условия те же.
for($i = 1; $i <= 100; $i++) {
	echo ((($s = (($i%3 == 0) ? 'Fizz' : '') . (($i%5 == 0) ? 'Buzz' : '')) == '') ? $i : $s) . '<br />';
}
А, если твой скрипт вывести на консоль, задача будет решена неправильно, т.к.
никто не просил :-р
На похапе тоже ни кто не просил ^_^
Я не пойму, почему все так упрямо минусуют этот мой пост!? И никто мне не написал, за что собственно…

//////// пост ////

Задача решена и код нечитабельный, два зайца убиты :)

Console.WriteLine(
                string.Join(
                    Environment.NewLine,
                    Enumerable.Range(1, 100)
                        .Select(num =>
                            num % 5 == 0 && num % 3 == 0 ? "FizzBuzz" :
                            num % 3 == 0 ? "Fizz" :
                            num % 5 == 0 ? "Buzz" :
                            Convert.ToString(num)
                        )
                )
 );
Я не знаком с языком, но это может быть Nemerle. Говорят, интересный язык.
Не, я не о том, это был чистый C#, но программирование не в стиле C#.
генерализованный FB на F#


let divs = [(3, "Fizz"); (5, "Buzz")]

let prefix i = 
    divs 
    |> Seq.filter (fun (d, _) -> (i % d) = 0) 
    |> Seq.map snd 
    |> String.concat ""

let convert i = 
    let special = prefix i
    if special = "" then
        string i
    else
        special
     
{1..100} 
|> Seq.map convert 
|> Seq.iter (fun x -> printfn "%A" x)
почитав вопросы на том же stackoverflow.com приходишь в ужОс.
не говоря уже о недостатках логики, которая закладывается ещё в школе
Ага, что то типа «Я тут пишу свою социальную сеть, подскажите пожалуйста регулярку чтоб валидировать имя пользователя» регулярно встречается.
По моему личному опыту не более 20% выпускников, пришедших на собеседование, могут написать например поиск в бинарном дереве или перевернуть односвязный список на бумажке.
Ну тут главное не слишком углубляться все же :).

Структуру красно-черного дерева в коде напишет 5-10%.
Алгоритм построения суффиксного дерева, который тут недавно постили — напишет по памяти думаю 0.001 процент.
Хотя эти задачки решаются в несколько строчек мы потом еще упростили и уже просили например перевернуть строку или просто скопировать строку без использования библиотечных функций — но картина стала не особо лучше.
Переоцениваете. 5-10% будут знать о существовании красно-черных деревьев, а толком объяснить что они и с чем их едят сможет меньше 1%.
Знаю по опыту, проводил собеседования.
На какой уровень, если не секрет? Стоит ли гуглить на эту тему, если претендуешь на джуниора? :)
Если в ходе подготовки к собеседованию — однозначно не стоит. Даже на синьора. Задач такого уровня на собеседованиях не дают: ни смысла, ни нужды нет. 5-10% и <1% эмпирически выведенные числа, по общему впечатлению о кандидатах. Требовать красно-чёрные деревья есть смысл только на очень специфические вакансии, которых в наши дни раз, два и обчёлся. А если вы будете идти на собеседование по такой вакансии — не бойтесь, вас предупредят.

Хотя для собственного общего развития тема интересная. Могу посоветовать почитать отличную книгу Кормена о деревьях и не только.

Ну и если очень грубо — хороший джуниор должен удовлетворять первому уровню Programmer Competency Matrix.
Спасибо, еще одно подтверждение того что не зря ищу эту книгу, жаль только что 2-е издание уже не переиздается и через озон не купить, а третье будет только в 2012 (
Придется читать PDF.
На собеседование в яндекс знакомого спрашивали про красно-черные деревья. Рассказал мало, послали подучиться.
Послали думаю не через красно-черные деревья. Если конечно брали не на работу в ядро поиска, или что-нибудь другое столь же серьезное в плане производительности и вообще алгоритмов. А если именно потому — то это как раз та специфическая вакансия которых раз, два и обчелся. И ваш друг наверное был в курсе о том, куда и на какую позицию идет.
Знаете, я лично на собеседовании не напишу. В WEB такие вещи используются редко, так что вспоминаешь быстрым гуглением и реализовываешь.

ИМХО, алгоритмами нужно именно заниматься, что бы быть в состоянии их написать с ходу по памяти. А когда оно тебе надо раз в 2 года — согласитесь, без гугла или документации/книги по алгоритмам нереально :)
Главное уметь найти и быстро вспомнить! :)
Я и сам не напишу красно-черное дерево по памяти без гугла за час :) Потому и призываю адекватно смотреть.

Если только это не какой нибудь Google/ MS Research :)
Был месяц назад в гугле на собеседованиях (проводится 5 штук по 45 минут, с разными людьми) на вакансию девелопера.
Никаких задач «на сообразительность» там не было.
Задачи, конечно, сложней, чем этот FizzBuzz, но без красно-черных деревьев.
По уровню сложности типа написания двоичной сортировки, но более практичные — т.е. не надо писать функции, которые есть в стандартных библиотеках.
Да, конечно, есть такие алгоритмы, которые тяжело написать, если не знать.
Но конкретно в этих случаях можно придумать ответ самому довольно быстро, даже если не знать наперед. Вся необходимая информация давалась.
Не стоит так передёргивать :) Вам задать какой-нибудь вопрос по школьной химии, на который вы не ответите? А ведь вся информация, ну вы поняли…
Это вы передёргиваете, кандидатам было подробно обьяснено, что такое бинарное дерево или односвязный список, также была описана структура на С.
Этого и знания С в рамках любого учебника вполне достаточно, чтобы этот код написать, времени тоже давалось достаточно.
Я подумал, вы имеете в виду что «вся информация по бинарным деревьям в институтах давалась». Виноват :)
Это ерундистика. Я не занимался программированием уже года два и все забыл напрочь, но решение этих «задач», что вы тут написали можно найти за 5 минут. Дело совсем не в том, чтобы помнить наизусть кучу алгоритмов.
for i in range(1,100):
print ['fizz','',''][i%3] + ['buzz','','','',''][i%5] or i
чуть более длинный, но гораздо более неадекватный вариант :D
print' '.join(''.join(['fizz']*(1-x%3)+['buzz']*(1-x%5)or str(x))
for x in range(1,100))
[(not i%3 and 'Fizz' or '')+(not i%5 and 'Buzz' or '') or i for i in range(1,101)]
Ну, тут я, конечно, несознательно урезал длину в угоду красивому выводу. Если требуются просто числа

print ' '.join([(not i%3)*'Fizz'+(not i%5)*'Buzz' or str(i) for i in range(1,101)])
А если так?
print [('FizzBuzz', 0)[bool(i % 15)] or ('Fizz', 0)[bool(i % 3)] or ('Buzz', 0)[bool(i % 5)] or i for i in xrange(1, 101)]
в данном примере выведет до 99 ))
n=map(str, range(101))
n[::3]=['fizz']*34
n[::5]=['buzz']*21
n[::15]=['fizzbuzz']*7
print '\n'.join(n[1:])
Память расходуется неэкономно.
for x in range(100): print x%3/2*'fizz'+x%5/4*'buzz' or x+1
Проверяете число x, а выводите x+1.
Оптимальнее написать range(1,101) и выводить x, вместо того, чтобы применять 100 раз сложение
Поддерживаю подход автора.

За декабрь просмотрел тестовые задания (написание калькулятора, вычисляющего расстояния между парами городов, с веб-интерфейсом) 3-4 кандидатов, после чего предполагалось что их будут собеседовать «вживую». К сожалению, ни один не дошел до этого собеседования :(

Я добавлю еще от себя один момент. Ощущение, что многие люди в подробном тестовом задании на 2/3 страницы читают только первый абзац (или первые два). Т.е. в их работе нет ни следа того, что в задании указано как обязательный компонент.

Если будет интерес, могу потом написать топик на тему, какие ошибки и антипаттерны встречал чаще всего в тестовом задании на знание Java / J2EE / MySQL.

Если можете писать — пишите. Вы же не Толстой…
Напишите, интересно.
Как интересно. Кратчайшее расстояние по сфере между точками? Или по эллипсоиду Красовского? Или по какому-то другому приближению формы Земли? Или задача минимизации расстояния с использованием заданной сети автодорог?
«Обещанного три года ждут.»

Время вышло.
Я вот тоже как-то давал кандидатам задание — написать связанный список. Около половины не справляются.
После прочтения почувствовал себя гением.
Нечго таким людям в программировании делать.
Ага. Я вот лично считаю себя где-то средним программистом, но при этом пробные тесты SCJP прохожу на ура (увы, платить за сертификат пока не могу себе позволить), да и калькулятор выражений за пару часов напишу.
Калькулятор выражений? :D
print eval <>

(Перл)
Программирование не ограничивается перлом.
«Почему» в заголовке — вопрос риторический? А то я пришел за ответом… =)
Конечно риторический:)

Наверное, всё-таки не стоило переводить заголовок дословно, по-английски он звучит как-то более естественно
> FizzBuzz, или почему программисты не умеют программировать

А где, собственно, ответ на вопрос «почему?» :)
Дурацкий заголовок, так и непонятно почему программисты не умеют программировать. А вообще на собеседовании большинство начинающих могут просто испытывать дикий стресс и не справиться…
блин, надо было обновлять топик перед ответом :)
Поверьте, если вы можете написать цикл от 1 до 10 на всех языках, указанных в вашем резюме, если вы можете решить в уме несложный арифметический пример и если вы знаете, как применить рекурсию в несложной (но взятой из реальной жизни) задаче — то вы уже на голову выше большей части людей, вращающихся в нашей индустрии.

Хм, честно говоря, даже умея спокойно решить такие задачки, я не считаю себя программистом. Такие базовые знания алгоритмов, имхо, необходимы сейчас практически в любой области ИТ. Все таки в моем понимании программист — это человек глубоко знающий алгоритмы, математику, парадигмы и паттерны программирования.
не считать себя программистом — вообще хороший подход. А то как только начнешь себя им считать — бах — и остановился в развитии, начало распухать самооценка, и вообще превратился в незнамо что =)
уж лучше тихо скромно писать код да учиться =)
Угу согласен у нас в универе из группы програмисто 2\3 не решат эту задачу
>2\3

За обратный слэш я готов убить МС: уже и при делении его вместо прямого ставят %)
ааа… ну да… ^^' тут всетаки 2/3 хорошее замечание
я бы вообще агитировал студентов участвовать в опен сорс проектах.
Ага, чтобы эти проекты канули в лету )
Да кто ж пустит в основной репозиторий такой страшный код?
Вот интересная задачка ещё на тестирование:
Сделать кольцевой сдвиг строки из M символов на N позиций, при этом используя минимальное количество памяти и минимальное количество операций чтения/записи из строки.
Если мне сейчас не изменяет память, там для ассемблера было 7 переменных, для C — 6 переменных (размера разрядности платформы), M операций чтения из строки и M операций записи.
Интересно для чего 6. По-моему 4 хватает:
public class Main {
    static private long NOD(long n1, long n2) {
        if (n2 == 0)
            return n1;
        return NOD(n2, n1 % n2);
    }
    
    static private void shr(char[] arr, int N) {
        for (int i = 0; i < NOD(arr.length, N); i++) {
            int j = i;
            char saved = arr[j];
            do {
                j = (j + N) % arr.length;
                char nextVal = arr[j];
                arr[j] = saved;
                saved = nextVal;
            } while (i != j);
        }
    }
    
    public static void main(String[] args) {
        char[] test = {'e', '2', 'i', '/', 'o', 'e', 'u', 'i', '/', 'o'};
        shr(test, 2);
        System.out.println(test);
    }
}

Указатель на начало массива
Длина массива
N
i
j
saved
nextVal
Итого — 7.
Тогда всё сходится. Хотя, всё же, общепринято не учитывать размер входных данных при оценке требований к памяти.
Возможно.
Вообще на практике — не вижу особого смысла оценивать требования к памяти побайтно, обычно достаточно оценок «линейно», «квадратично», «константно», большой множитель зачастую скрывает в себе косвенную зависимость на непосредственно размер данных или другие характеристики, связанные с входными данными (как в radix сортировке).
Задачка на тестирование чего?
Наймешь такого, а потом внезапно у тебя куча очень быстрого кода в одной функции на 2000000 строк, а разработчика сбил автобус)
На тестирование сообразительности. Правильное решение достаточно красиво и без грязных хаков, плюс это показывает умение мыслить логически и понимание математики отчасти.
А одним тестом нельзя измерить всех параметров, так что на стиль кодирование и умение проектировать нужны свои тесты.
Тут имеет смысл не получение решения а наблюдение за его получением, к вашему правильному решению не прийдет за разумное для одного вопроса время думаю большинство нормальных программистов. Просто потому что современные программисты редко работают на таком низком уровне.
Ну вопрос к специфике работы, если не нужно тестировать такие знания — то и тесты такие не нужны, а если нужно протестировать понимание математики, а не зазубривание известных алгоритмов — задача вполне адекватная. Я пришел к решению за 30 минут, раньше никаких подобных задач не решал, никаких готовых алгоритмов для этого тоже не знал. Так что вполне для теста пойдет.
Попробуйте лучше определить, нет ли на конце односвязного списка (о-очень большого) кольца, не используя дополнительной памяти (читай: массивов), не копируя элементы списка. Сложность алгоритма должна быть O(n).

P.S. Список заканчивается кольцом, если последний элемент списка указывает на один из элементов в середине списка.
Т.е. проверить, куда указывает конец списка, и потом пробежаться по списку, проверяя указатели? Или я что-то не понял?
При сложности же указывается порядок и O(n) == O(2n) (последний вариант обычно не пишут).
Решение 1 (верное) — абстрагировать список за объектом, который всегда хранит кол-во элементов в нем и использовать метод описанный выше (я сразу и подумал, что список — целостный объект)
Решение 2 — Можно пройти кареткой K=N, запомнить адрес останова, пройти K=2N, запомнить адрес останова (в той же переменной), потом K=4N K=8N и т.д. Тогда если список закольцован, как только мы попадем в кольцо и K будет равно длине кольца — мы обнаружим совпадение.
Сложность зависит от длины списка n линейно, т.к. когда мы дойдем до конца списка (+ максимум n-1 сверху) следующий K будет больше списка. Т.о. сделаем меньше 4n операций, что укладывается в линейные ограничения. Используем 1 ячейку памяти.
>Можно пройти кареткой K=N, запомнить адрес останова, пройти K=2N, запомнить адрес останова (в той же переменной), потом K=4N K=8N и т.д. Тогда если список закольцован, как только мы попадем в кольцо и K будет равно длине кольца — мы обнаружим совпадение

У меня 2 вопроса:
а) что такое N?
б) что если K никогда не будет равно длине кольца (скажем, кольцо длины 11)?
Не стал сразу исправлять:
N — начальный «шаг», можно взять равным 1 для простоты
Для К конечно же «больше или равно».
И тогда уж исправлюсь с максимальной сложностью, она равна 3n.

Как работает:
Представим что у нас список длины n, n+1 вершина — это уже середина списка, т.е. кольцо.
Будем двигаться по указанной схеме, на каждом шаге запоминая вершину, в которой мы находимся
Возьмём тот шаг, когда мы ещё не прошли n вершин в сумме, но на следующем шаге пройдем, следовательно — попадем в кольцо.
Возьмем худший случай «оверхеда», предположим что на предыдущем шаге мы находились на самой последней вершине и (т.к. следующий шаг равен сумме всех предыдущих + 1) сделаем таким образом n+1 лишних переходов по списку.
Затем запоминаем текущее положение и делаем следующий «проход», т.к. он будет очевидно больше размера списка (т.к. мы уже прошли список, а каждый следующих ход больше всех предыдущих), то он и больше размера кольца
А раз ход больше размера кольца — то мы на нем то и наткнемся на нашу «помеченную» вершину. В данном случае худший вариант — если список закольцован на начало, тогда мы должны будем пройти весь список (n переходов), до того, как можем констатировать закольцованность.
Таким образом худший случай — 3n+1 операций чтения. Лучший случай — n операций чтения, когда при первом прохождении списка мы попадаем с последней вершины сразу на помеченную.
Ок, теперь понятно. Да, такое сработает. У меня в своё время было другое решение: запустить одновременно два «бегунка» по списку: один бежит с шагом 1, второй с шагом 2. Если они в какой-то момент втречаются — список закольцован, т.к. изначально более быстрый удаляется от медленного со скоростью 2 элемент за шаг, а при выходе обоих на кольцо он начинает догонять более медленного со скоростью 1 элемент за шаг, т.е. в конце концов догонит.
Тоже задачка на собеседовании была, или попался реальный код?
На собеседовании. За реальный код я бы «оторвал руки разработчику» и далее по тексту… :)

Хотя при использовании высокоуровневых классов/библиотек тоже нужно думать и хорошо понимать, что происходит у них внутри. Вот, буквально час назад попался шедевр (Java):

    public void setResults(long[] uids) {
        if (uids != null) {
            int length = uids.length;
            if (length > 0) {
                User user;
                User[] users = new User[0];
                for (int i = 0; i < length; i++) {
                    user = UserStorageAccessor.getUser(uids[i]);
                    Arrays.add(users, user);
                }
                setResults(users, true);
            }
        }
    }


вместо простого

    public void setResults(long[] uids) {
        if (uids != null) {
            int length = uids.length;
            if (length > 0) {
                User[] users = new User[length];
                for (int i = 0; i < length; i++) {
                    users[i] = UserStorageAccessor.getUser(uids[i]);
                }
                setResults(users, true);
            }
        }
    }


Что происходит внутри Arrays.add(...) — догадываетесь? :)
Да уж. Экономить на создании объектов этого разработчика явно не учили. Плачевно.
Хотя стоп… Тут вообще не будет работать )
Из Arrays.add() ведь нельзя изменить ссылку )
Не-не, всё работает (как раз потому, что массив передаётся по ссылке). Просто внутри Arrays.add(..) массив каждый раз пересоздаётся заново (размером +1), копируя имеющиеся элементы и добавляя ещё один. И после отработки функции ссылка указывает на валидный массив (просто он уже лежит по другому адресу). Вот так вместо того, чтобы создать массив один раз, он пересоздаётся в цикле на каждой итерации :)
Ну хоть на создании ссылок экономить научили (и тем самым немного отсрочить пробуждение GC) — и то хлеб. Видите, объявление User user; вынесено за пределы цикла? А ведь могло быть

for (int i = 0; i < length; i++) {
    User user = UserStorageAccessor.getUser(uids[i]);
    Arrays.add(users, user);
}
if (uids != null && uids.length > 0) {...}

:)

Решение 1 не подходит, т.к. список дается внешним образом, т.е. над структурой этого объекта мы не властны.
Решение 2 сработает :-)
Под первым решением я имел ввиду выделить абстракцию не в данном участке кода, а вообще по системе.
Каким образом вы «проверите, куда указывает конец списка»? На каком элементе вы остановитесь и скажете «это конец, давайте проверим, куда он указывает»?
Я выше указал ответ, просто я как-то не привык к тому, что кому-то в голову взбредёт работать сразу с начинкой списка (т.е. с лист-нодами) без абстрагирующей оболочки. А когда есть абстрагирующая оболочка — у ней чуть ли не в первую очередь будет число элементов в списке, а зачастую и указатель на начало/конец списка + указатель на «текущий» элемент.
А если кто-то написал код, работающий с начинкой списка напрямую — то советую в первую очередь оторвать ему руки, и только потом садиться решать подобные задачи.
Если кто-то написал код, работающий с начинкой списка напрямую — то советую в первую очередь оторвать ему руки, и только потом садиться решать подобные задачи

Это очень хороший ответ, за него я поставлю мысленный плюс и скажу примерно следующее: «Да, действительно, это плохая практика, поэтому давайте мысленно перенесёмся в тот момент, когда руки автору уже оторвали, и теперь нужно решить задачу, когда у вас есть „сырой“ список, где каждый элемент содержит своё значение и указатель на следующий элемент. Исходные данные — указатель на головной элемент списка».
Я понял задачу, и вроде решил её несколькими каментами выше. Мой ответ здесь был собственно объяснением моей первой реакции, с непривычки к такому вопиющему надругательству.
А решить всё-таки при наличии времени я бы посоветовал введением уровня абстракции целостного списка.
В данном случае это все-таки не реальная, а академическая задача. Как раз для случаев, когда нужно проверить, насколько у разработчика работают мозги. В реальной жизни оно вряд ли встретится при нормальном подходе к программированию (объект-оболочка + запоминание длины списка).
ага, хороший пример плохого тестового задания для выполнения на собеседовании. гораздо больше толку от приведённых в топике и пары вопросов типа что бы вы сделали если стали президентом или выиграли сто тыщ мильёнов.
Чем оно так плохо? Если стоит задача протестировать способность человека понимать математику и разрабатывать свои алгоритмы на работе?
В общем случае плохо. Мне вот например нужен разработчик на pl/sql или на php, а не для разработки драйверов, откуда у них знания про экономию памяти?

Способность более-менее алгоритмически формулировать свои мысли замечательно проверяют простенькие примеры с одним циклом и одним условием, за минуту и вне зависимости от специализации. Если ищется реально спец, то и вопросы к нему реально специальные, да и находятся они обычно адресно.
Вообще задача не на экономию памяти по сути (т.к. это зачастую абсолютное зло при цене 20$ за планку RAM), если нужен человек, от которого не требуется создание алгоритмов — то и тесты другие.
UFO just landed and posted this here
Всегда было интересно: при решении тестового занятия в присутствии собеседующих можно ли пользоваться Гуглем? С одной стороны, если человек полез в поисковик — значит, он не помнит\не знает точной команды\синтаксиса. С другой стороны, раз полез — значит, может найти и применить…
по некоторым своим знакомым могу сказать, что владение Гуглем имеет смысл тестировать отдельно :)
У меня один товарищ (5 курс факультета программирования Бауманки в Калуге) в ответ на просьбу написать сортировку любым известным ему алгоритмом попросил справочник по синтаксису PHP. Мне было даже интересно, что он с ним делать будет. Дал. Он долго листал, потом нашёл синтаксис объявления массива и феерически обосрался, не сумев перепечатать из книжки без ошибки.
Просто в Пхп настолько нереально все запомнить, что многие даже не пытаются. Ничего удивительного в этом нет.
Условие задачи ставилось так: «Реализовать любой алгоритм сортировки на любом известном вам языке. Вылизывать программу не надо, нюансы синтаксиса неважны, мы её даже компилировать не будем. Хочу просто посмотреть, как вы программируете». PHP был выбран соискателем :)
Процесс собеседований в нашей фирме требует, чтобы кандидат предоставил нам фрагмент своего кода еще до телефонного собеседования.

Абсолютно согласен по поводу тестовых заданий, но вот что мне не очень понятно, так это зачем нужно просить прислать образец кода. Что по этому образцу можно понять кроме стиля (отступов, фигурных скобок и т.д.)?
Мой код весь практически закрыт NDA, уверен как и у большинства enterprize-ников.
Дело даже не в NDA, просто когда ты посылаеш образец кода, ты не можешь послать целый проект, посылаешь какие то файлы или куски файлов с определемием классов, какие то куски с логикой. Во всех этих кусках кода вряд ли кто то будет разбираться, а если и будут, то могут и не найти реализации рекурсии или патерна.

Так что мне действительно интересно что люди хотят увидеть в образцах кода присланных даже до телефонного собеседования. Намой взгля кроме стиля форматирования там ничего увидеть нельзя.
Собственно, одного взгляда на код достаточно, чтобы понять:
— пользуется ли собеседуемый каким-либо распространенным стилем кодирования;
— умеет ли более-менее сносно проводить декомпозицию;

Если посмотреть пару-тройку функций длиной в полэкрана, можно еще и понять предпочтения по проверке пред-условий, использование вложенных конструкций или вынос в метод, и т.д.
В общем, по коду можно понять, хороший это код или плохой.
Это только звучит убедительно, что по коду можно что то сказать, а на самом деле:
— хороший программист пользуется тем стилем кодирования, который принят у него в фирме
— вы не сможете определить умеет ли он сносно проводить декомпозицию пока не проанализируете его код, что весьма сложно сделать не зная решаемой задачи, а кроме того, анализ подобного кода в данном ключе сводит на нет все преимущества получения этого кода до интервью.
Так что просить у соискателя код до интервью, врядли это хорошая практика.

Но за ответ спасибо, вы мне открыли глаза на логику которой пользуются когда практикуют подобную шему при принятии на работу.
Я лично не собеседую, поэтому комментарий выше — это мое мнение, зачем это могло бы понадобиться.
А почему просите именно образцы кода, а не даёте тестовое задание? Во втором случае у вас же уже будет «идеальное» решение с которым можно реально сравнивать код собеседуемого? Сможете понять учёл ли он, например, все требования, граничные условия и т. п.
Удалённое тестовое задание не гарантирует, что его писал сам соискатель. Всё равно придётся перепроверять знания при личной встрече. Образцы кода в этом смысле — это элемент уважения к соискателю.
Так же как образцы кода не гарантируют, что его писал сам соискатель. Они это ещё меньше гарантируют. В чём уважение не понимаю. Я бы понял, если бы требовали или образцы кода, или выполнить тестовое задание, но требуют, как правило, что-то одно, а то и обязательно оба варианта, а вот честное «или» не встречал.
> Так же как образцы кода не гарантируют, что его писал сам соискатель. Они это ещё меньше гарантируют.
Естественно, не гарантируют. Всё равно придётся на собеседовании выяснять, что он из себя представляет. Образцы кода, тестовые задания (когда их программист удалённо делает) — это быстрый отсев программистов от непрограммистов. И требовать трудозатрат от соискателя ещё до того, как обязался платить ему зарплату, я считаю некорректным. Вы для соискателя не один такой. Если каждый будет просить потратить часок времени, это создаст много неудобств кандидату.
Требовать, да, некорректно (тем более известны случаи мошенничества, когда соискатели под видом тестовых заданий целые проекты выполняли), но так же некорректно, имхо, требовать образцов кода. Написать в вакансии: «плюсом будут образцы вашего хорошего кода и/или выполнение тестового задания + линк на задание» — и корректно, и работодателю удобно, и соискатель может показать себя с той стороны, которую он считает лучшей. Ну, например, не было принято на предыдущей работе покрывать код тестами, а он тестовое задание покроет. Это не говоря о том, что вообще код с работы отдавать потенциальным конкурентам как минимум не очень этично.
Предложить на выбор — вполне разумно. Что касается «покрыть тестами или не покрыть», вы видимо не представляете, какого качества 90% приходящих примеров кода. Там такое, что волосы под мышками шевелятся. Одного взгляда достаточно, чтобы отсеять бОльшую часть кандидатов и сэкономить кучу времени на собеседования. Если там что-то вменяемое, это сразу видно, и человека можно в офис звать. О том, чтобы код был покрыт тестами, можно и не мечтать. А если уж кто-то покроет, то всё равно это пустая трата времени, т.к. заведомо неизвестно, он сам писал или нет.
Кода «для себя» вы не пишите в принципе?
Оный вполне может подойти в качестве примера.
Верите-нет, но на том языке, на котором больше всего писал непрерывно на работе и, видимо, как следствие, на котором я заработал больше всего денег, ни строчки для себя или на своём компе не написал. Мне тот язык показался наиболее подходящим для решения поставленной задачи, я его изучил с нуля (ну, если не считать, что практически все языки на которых я писал большее, чем «hello world», кроме семейства ведущего род от SGML, были императивными, хотя не все реализовывали даже цикл — приходилось применять IF и GOTO), задачу решил в обозначенные сроки (поэтапно, шаг ~2-3 недели, да и задача уточнялась с шагом ~2 месяца), заказчик доволен до сих пор.

Похожая ситуация с языком на среднее владение которым я претендую в резюме: для себя писал только прототипы, которые сам увидев на продакшене назвал бы «быдлокодом» ещё 10 лет назад (пускай такого термина и не было тогда) — никакой проверки пользовательских данных, никакой проверки на результаты операций с внешними сервисами типа БД или чужих сайтов, про архитектуру или хайлоад вообще молчу, мне были интересны либо практическая возможность реализации моих идей, либо привлечение инвестиций (то, что с некоторых пор в рунете стал модно называть «стартап»). Всегда подразумевалось, что в конечной реализации останется, максимум, то, что я сейчас называю «сценарии пользования». Всегда подразумевался корректный ввод и ожидаемая по типичному сценарию реакция (вплоть до того, что запрос к БД не может не вернуть хотя бы одну запись, а запрос к чужому сайту что-то отличное от того, что я вижу в браузере, заходя как реальный пользователь).

Что мне слать в качестве образца кода — то, что я сам считаю быдлокодом не только теперь, но и на момент написания?
Интересно, сколько пройдет такое собеседование, если попросить написать FizzBuzz на прологе?
А вот и решение на SWI-Prolog:

fizzBuzz(100).
fizzBuzz(N) :-
	I3 is N mod 3,
	I5 is N mod 5,
	print( I3, I5, N ), nl,
	N2 is N + 1,
	fizzBuzz(N2).

print( 0, 0, _ ) :-
	write( 'FizzBuzz' ).
print( 0, _, _ ) :-
	write( 'Fizz' ).
print( _, 0, _ ) :-
	write( 'Buzz' ).
print( _, _, N ) :-
	write(N).


Запускать: fizzBuzz(1).
Через write как-то не слишком по-прологовски :) Вариант на gprolog:

fizzlist(0, [], M).
fizzlist(N, [H|T], M) :- N > 0, N1 is N - 1, M1 is M - N + 1, fizzbuzz(M1, H), fizzlist(N1, T, M).
fizzlist(N, L) :- fizzlist(N, L, N).

fizzbuzz(N, N) :- N mod 3 > 0, N mod 5 > 0.
fizzbuzz(N, 'Fizz') :- 0 is N mod 3, N mod 5 > 0.
fizzbuzz(N, 'Buzz') :- 0 is N mod 5, N mod 3 > 0.
fizzbuzz(N, 'FizzBuzz') :- 0 is N mod 3, 0 is N mod 5.


Соответственно,

?- fizzlist(100, L).
Если через список, то так проще ;)


fizzBuzz(100, []).
fizzBuzz(N, [H|T]) :-
	I3 is N mod 3,
	I5 is N mod 5,
	val( I3, I5, N, H ),
	N2 is N + 1,
	fizzBuzz(N2, T).

val( 0, 0, _, 'FizzBuzz' ).
val( 0, _, _, 'Fizz' ).
val( _, 0, _, 'Buzz' ).
val( _, _, N, N ).


? fizzBuzz(1, L).
Проще, но я сохранил возможность сформировать список произвольной длины.
тогда вот на mercury

:- module fizzbuzz.

:- interface.

:- import_module io.

:- pred main(io, io).
:- mode main(di, uo) is det.

:- implementation.

:- import_module int.

main --> fizzbuzz(1).

fizzbuzz(N) --> 
	( {N =< 100} ->
		print_fizzbuzz(N),
		print(" "),
		fizzbuzz(N + 1)
	; []
	).
	
print_fizzbuzz(N) --> 
	( {N mod 3 = 0} ->
		( {N mod 5 = 0} ->
			print("fizzbuzz")
		; print("fizz")
		)
	; {N mod 5 = 0} ->
		print("buzz")
	; print(N)
	).


D:\TEST\mercury>mercury --infer-all fizzbuzz.m
fizzbuzz.m:016: Inferred :- pred fizzbuzz(int, io.state, io.state).
fizzbuzz.m:016: Inferred :- mode fizzbuzz(di, di, uo) is det.
fizzbuzz.m:024: Inferred :- pred print_fizzbuzz(int, io.state, io.state).
fizzbuzz.m:024: Inferred :- mode print_fizzbuzz(in, di, uo) is det.
D:\TEST\mercury>fizzbuzz.exe
1 2 fizz 4 buzz fizz 7 8 fizz buzz 11 fizz 13 14 fizzbuzz 16 17 fizz 19 buzz fiz
z 22 23 fizz buzz 26 fizz 28 29 fizzbuzz 31 32 fizz 34 buzz fizz 37 38 fizz buzz
41 fizz 43 44 fizzbuzz 46 47 fizz 49 buzz fizz 52 53 fizz buzz 56 fizz 58 59 fi
zzbuzz 61 62 fizz 64 buzz fizz 67 68 fizz buzz 71 fizz 73 74 fizzbuzz 76 77 fizz
79 buzz fizz 82 83 fizz buzz 86 fizz 88 89 fizzbuzz 91 92 fizz 94 buzz fizz 97
98 fizz buzz
Еще такое замечание — очень, ОЧЕНЬ много людей не разбираются в трех типах вещей. Не то, чтобы это была труъ Computer Science, но опытный программист… ну можно ожидать, что он это будет знать.

1) Это внутренности той платформы, с которой человек проработал 3-5-7 лет. Вызвано тем, что нет мотивации и интереса копаться, или тем, что человек не сталкивался с сложными багами, проблемами при high-load, инфраструктурными задачами.

Например, (примеры из мира Java) мало кто внятно рассказывает следующее:

— Класслоадеры
— Сборка мусора подробнее, чем «это отслеживание мертвых ссылок и очистка памяти». Алгоритмы, generation-based подход.
— hot-swop кода
— чуть-чуть про архитектуру JVM и как она вообще работает (байткод, стековая машина, фреймы, стек операндов, пул констант и прочее)
— Некоторые ключи запуска JVM, из популярных (для управления памятью, например)
— из каких компонентов состоит сервер приложений? Тот, который использовал в своем резюме соискатель. Какие фичи появились в его последнем крупном релизе?

2) Язык / стандартная библиотека в тех частях, которые не используются в простом коде и простых проектах, и которые не описаны в некоторые книгах типа «Освой за 21 день».

Пример из Java:

— что такое soft / weak / phantom references?
— аннотации и их процессинг
— generics (вот это вообще kill-question)
— что такое неблокируюший (lock-free, wait-free) ввод-вывод?
— и т.д.

3) Инструменты, используемые в проектах и инфраструктура. Системы контроля версий, Ant, Maven, Continuous Integration серверы, скриптинг (простейший!) для Windows CMD / unix bash, профайлеры, инструменты для мониторинга и прочее.

— Что такое распределенная / централизованная система контроля версий?
— Что такое бранчевание, как сделать бранч / бекмерж в той системе, про которую вы написали, что вы с — ней работали?
— Что такое трехстороннее разрешение конфликта при коммите?

— Что такое антовский таск, таджет. Можете ли вы написать собственный таск, который делает что-то примитивное.

— Что такое управление зависимостями, что такое артефакт, репозиторий.

— Какие CI серверы их использовали? Если человек пишет про них в резюме, спросить про них.

— Пользовались ли вы когда-либо профайлером (каким?), какие результаты вы получали? Попросить рассказать об этом.

Плюсую стоя!

С PHP та же ситуация. Только у нас вообще наверно 99.99% смотрят на тебя огромными лемурными глазами, когда начинаешь спрашивать особенности работы. Про внутренности я вообще молчу.
Вопрос 2^7 вообще повергает народ в шок, а должно от зубов автоматом отскакивать :)
Т.е. вы думаете, большинство людей кто пишет на PHP 3-5 лет, ничего не могут сказать о внутренностях апача, о реализации PHP и прочее?
Многие даже не знают нормально ООП PHP, его особенностей и если спросить правила приведения типов в PHP — будут тупить. Это реальность :)
Как человек может знать особенности ООП в PHP (или вообще особенности чего-то), если он на других языках не писал или писал не ОО код (C, ASM — самые банальные примеры)?

Навскидку для меня особенности ООП в PHP — нет перегрузки методов по сигнатуре и нет переопределения операторов. Ну и нет множественного наследования, не так давно это частично компенсировано интерфейсами, равно как и появились абстрактные классы/методы (в php4 их, кажется, не было). Наконец-то появилось позднее связывание. Какие ещё там особенности?
Я вам даже больше скажу — многие даже не знают, как устроен HTTP, как например, происходит GET или POST запрос.
Я тоже, 7-й уровень OSI более-менее знаю (хотя все заголовки и методы HTTP наизусть не помню, только простенький запрос и без кодирования урла и тела запроса смогу написать в телнете), 6-й и 5-й как-то оказываются выше 7-го, 4-й смутно представляю, 3-й ещё более смутно, а уж 2-й и 1-й очень-очень смутное представление и то, всё это только для частного случая HTTP over Ethernet
Я кстати с некоторых пор не спрашиваю таких вещей. Они настолько базовые и фундаментальные, что я удивлялся, как может человек идти работать веб-программистом, не зная их. Оказывается, что есть много талантливых программистов, которые не знают, потому что ни разу не приходилось знать. Эти знания можно получить в общих чертах за 5 минут, а детально — за час чтения RFC, если мозги на месте. А вот если человек не может выбрать максимальный элемент их массива, это уже клиника. Таких лучше подальше посылать.
Это скорее вопросы, чтобы посмотретЬ, чего стоит опыт, описанный в резюме. И как сам человек его оценивает.

В этот раз пример из мира БД и оракла.

Если человек сдал на 5 курс по разработке БД, и прочитал книжку о программировании под оракл, и пишет в резюме «Имею опыт работы с оракл, разработка схемы бд, написание стандартных запросов» — очень хорошо.

Если человек сдал на 5 курс по разработке БД, и прочитал книжку о программировании под оракл, и пишет в резюме — «знаю оракл, или владею ораклом» — плохо. Он не понимает, что его знания — это 0.1 процент того, что в оракле есть. завышенное ЧСВ.

Если человек пишет в резюме, что был ведущим Oracle-разработчиком / главным админом в проекте для крупного банка / какой то иной нагруженной и сложной системы, и пишет об этом факте — хорошо. Но это он должен подтвердить. Сертификатами и / или на собеседовании.

Знакомый техлид рассказывал об одном случае, пришедший «ораклоид» в возрасте 40 лет, с указанным опытом работы с ораклом 5 лет, на собеседовании не смог написать умеренно-сложный запрос с having.
Это да. В резюме такого понаписать могут… Проверять надо, конечно. Обычно после вопроса «что конкретно вы делали на ***», соискатель признаётся «в институте на лабах у нас было». Пара вопросов после этого ставит все точки над i.
Как представитель работодателей посоветуйте, пожалуйста, стоит ли упоминать в резюме языки, которые «на лабах были», «писал just for fun», «писал коммерчески, но с первой строчки за код стыдно было», «как-то пришлось» и т. п.? В общем те языки, знания основного синтаксиса которых можно восстановить буквально за один взгляд на произвольный листинг, в котором употребляются общепринятые конструкции хорошо знакомой парадигмы программирования? А если стоит, то как?
Однозначно стоит. Так и пометьте, что «just for fun». Это вас охарактеризует как человека, интересующегося программированием не просто в рамках работы от звонка до звонка, а желающего постоянно развиваться и профессионально расти.

Вообще, по моему скромному мнению, лучше для каждой технологии, перечисленной в резюме добавлять пару слов — что конкретно на этой технологии делали и в какой роли. Например:
Visual Basic — разработал архитектуру CRM для компании в 300 человек, потом реализовали проект коллективом в 5 человек;
Oracle — лабы в институте.
Это куда информативнее, чем просто Oracle, VB. Если написать «Oracle, VB», вас пригласят на собеседования по Ораклу, где вы провалитесь. А если распишете подробно, то даже пусть там VB, который никому нахрен не нужен, вас запросто могут взять. Очередной императивный язык выучить — дело нехитрое, а умение проектировать большие коммерческие системы на дороге не валяется. Мне вот нужны перловые программисты, но если написать в требованиях «Perl», соискателей мало. А если не писать, а приглашать всех, то оказывается, что хороших программистов в разы больше, а Perl изучается по ходу дела на ура. И если у соискателя будет много-много всего перечислено в резюме с пометкой «just for fun», он 100% легко разберётся с любой незнакомой ему технологией.
Спасибо за подробный ответ
Очень хороший набор вопросов, именно их мне в основном на собеседованиях и задавали, и именно поэтому я на них со временем «натаскалась» и других натаскивала:)
Поэтому, к сожалению, хорошие ответы на такие вопросы тоже не всегда показатель — разве что того, что человек к собеседованию готовился.
window.onload = function () {
for (var i = 1; i < 101; i++) {
document.write(((q=((0==i%3?'fizz':'')+(0==i%5?'buzz':'')))?q:i)+'<br>');
}
};
да чтож такое-то… чего минусите?
<br> в задании не было — может поэтому? :)
\n тоже в задаче не было. И пробелов тоже. Но все же как-то форматируют перед выводом…
я только предположил, может код не отформатировали…

<source lang=«javascript»>ваш код</source> дал бы
window.onload = function () {
  for (var i = 1; i < 101; i++) {
    document.write(((q=((0==i%3?'fizz':'')+(0==i%5?'buzz':'')))?q:i+'<br>'));
  }
};
И не поэтому… Тут полно вообще без <code>...</code> Ладно, забейте :-)
Это больше риторический вопрос… Тем ленивцам, которым поставить минус не влом, а написать почему — влом.
Опа, вот я и узнал, как на хабре нативно форматировать код.
Об этом было написано где-нибудь в справке? Когда нужно было — не нашёл.
Над формой комментария есть ссылка «можно использовать html-теги»
Там с самого начала:
<source lang="язык"></source>
подсвечивает код программы (поддерживается bash, cpp, cs, xml, html, java, javascript, lisp, lua, php, perl, python, ruby, sql, scala, tex)
burdakovd, ну лично я с легкостью ориентируюсь по пиктограммам в редакторе текста, если мне нужно выполнить какое-либо действие. А вы разве нет?
Хорошо себя зарекомендовали 2 задачи, которые я предлагал претендентам на вакансию:

1. Придумать алгоритм отрисовки «прямой» линии, соединяющей 2 точки на растре.
1.1. Для тех кто вспоминал про тангенс объяснялось что это как минимум медленно и предлагалось отказатся о тригонометрии.
2. Даны одномерные координаты N отрезков на прямой. Придумать алгоритм нахождения количества наложений отрезков и оценить его сложность.

Не вижу смысла иметь дело с людьми не способных попытаться решить подобные задачи. Многие даже не пытались. Так и говорили, что не могу, пробовать не буду.

Только после этого шёл разговор о технологиях и высоких материях.
Я конечно не супер гений, но при чём тут тангенс в 1.1? o_O Может вы имели ввиду что числа с точкой это медленно и просили написать целочисленный алгоритм (Брезенхемом)? :)
Потому что самое часто предлагаемое решение — посчитать угол через арктангенс, а потом пройтись в цикле по координатам одной из сторон треугольника и найти координаты точек на гипотенузе как произведение текущей координаты на тангенс найденного угла.

Но вы правы, предлагалось отказатся от плавающей точки и предложить реализацию в целых числах.

И что касается целочисленного алгоритма то знание конкретного алгоритма (Брезенхемом) не важно, важно начать думать и предлагать идеи.
важно начать думать и предлагать идеи

Это умение, по моему мнению, более значительный показатель, чем безоговорочное знание каких-либо, пусть даже некоторых базовых понятий. Конечно с оговоркой, что кандидат не абсолютный ноль в обсуждаемой области.
Мне нравится бывать на собеседованиях, где ставят подобные задачи и начинают обсуждать и расширять с тобой предлагаемую реализацию, в отличие от тех, которые проходят в виде анкетирования: вопрос из бумажки — ответ — галочка и молчаливое укоризненное покачивание головой: не угадал.
Хорошие задачи. возьму на вооружение
вообще, вроде как тангенс там это (y2-y1)/(x2-x1). Вроде как, совсем не тригонометрия.
Давайте так одно дело задача, другое что — это наиболее часто предлагаемое решение. За второе я никак не отвечаю.
заинтересовался, на бумажке набросал треугольник. в начале сделал через пропорцию (ну да, тот же тангенс), потом задумался — а что если посчитать приращения координат? типа, x увеличивается каждый раз, а y — через раз. тогда можно обойтись без деления, только сложением. дальше додумать не получилось, пора спать :)
А если не секрет, каков процент решивших был?
UFO just landed and posted this here
UFO just landed and posted this here
Чуть покороче
foreach (range(1,100) as $i) 
{
    if(!($i%3)) echo "Fizz";
    if(!($i%5)) echo "Buzz";
    if(($i%3)&&($i%5)) echo $i;
    echo "<br />";
}
UFO just landed and posted this here
Тогда просто ссылку дам. Что-то вообще не получается вставить.
Так тож вариант, работает.
imm.io/38IJ
На ruby за 3 минуты
(1..100).each do |i|
  bf = ((i.to_f % 3).zero? ? 'Buzz':'') + ((i.to_f % 5).zero? ? 'Fuzz':'')
  puts bf.empty? ? i:bf
end
Таки почему программисты не умеют программировать?
А как быть, если кандидата (выпусника технического вуза по компьютерной специальности, с двухлетним опытом проф.разработки) подвешивает вопрос «напишите пожалуйста таблицу истинности для исключающего ИЛИ»? Это показатель чего-то, или нет?
Если двухлетний опыт, то показатель. Если больше — нужно задачу переводить в бытовые термины вроде XOR =)
Собственно, первое что говорится — именно для xOR, а если человек немного подвисает — то говорится что «исключающее ИЛИ». Вот было не раз, что человек совсем подвисает.
Меня больше забеспокоило «таблица истинности», кстати.
Я бы на собеседовании скорее спросил «как работает».
А ещё лучше конкретную задачу, где это используется.

Ну реально его можно подвесить Шрихом Шифера или Стрелкой Пирса ну или же сравнением по модулю 2 ^_^ Я и сам уже по памяти не вспомню их ТИ
Главное вспомнить их эквивалент в базисе И, ИЛИ, НЕ, а там уже легко построить ТИ. Я вот все время путаю штрих Шеффера и стрелку Пирса.
Мне обычно их эквивалента и хватает. Просто смотрю, что мне нужно получить, а дальше пара логических преобразований и любая нужная ТИ будет.
Попробуйте разные вопросы задавать все же. Мне вот например никогда не нужны были таблицы истинности и я с трудом помню что это вообще такое и на собеседовании естественно ничего бы не написал. Но это ведь опять вопрос из тех вопросов, ответы на которые можно найти в поисковике за 5 минут…
Разумеется, вопросы задаются самые разные. Но просто когда человек не может ответить на такой вопрос, то это косвенно свидетельствует о том, что университетскую программу он не помнит. Соответственно, если позадавать вопросы по дискретной математике/графам — там будет тоже все «не здорово». А для вакансии/задач это может быть очень важно, все-таки в мире разработки софта существуют задачи значительно сложнее «написания» сайтов на Битриксе.
Уже копий немало сломано на эту тему, но вот это:
«ничего сверхсложного, просто небольшое упражнение на час-полтора» — просто шедевр.
Если упражнение небольшое, то почему оно должно занимать полтора часа — слабо придумать упражнение на 10 минут?
Извините, но если человек не в состоянии за полчаса определить уровень соискателя, значит, он сам недостотачно профессионален для проведения интервью и нефиг ему давать «мариновать» людей часами.


Я так понимаю, что в оригинале имелось в виду не решение чисто алгоритмической задачи, а написание какой-нибудь законченной программы, с простейшим интерфейсом, вразумительной обработкой ошибок ввода, и т.д.

Алгоритмическую задачу на полтора часа я даже боюсь представить:)
Как-то попался на такую, наверное, задачу. Алгоритмически тривиальная (типа формы регистрации нового пользователя), но практических нюансов столько в таких задачах…

Я решил показать себя с лучшей, имхо (сформированного в частности чтением статей и комментов на хабре о поддержке кода, внесении новых требований и т. п.), стороны, написал за 3 часа чуть-ли не фреймворк по обработке форм: я бы без костылей вписал к нему любое изменение формы в рамках одного «экрана», фиксированного набора полей, модели РСУБД со связми 1-1 и 1-М (при условии, что вводится сущность на первой стороне и, при необходимости, на второй) и валидации по регуляркам и целостности БД.

Отказ по причине: «слишком много написали, а значит долго это писали, код во многом излишен»
А мне не нравится тот вариант, где нет отдельного условия на деление 15 и предполагают, что сработают оба условия и выведется нужная строка.
Наверно написавших такой код зовут истинными программистами, но я бы таких не взял. Такой код будет гораздо сложнее отлаживать, ибо правильное течение программы предполагает магию в своей работе.
У нас есть три четких требования. В нормальном варианте все три требования будут отражены в коде. Если их нет — более сложна система спрограммированная таким вот программером будет опираться на магические штуки, известные только самому разработчику. Думаю, много кому тут ясно, что эта за система будет в итоге.
Поддерживаю, особенно убивают программисты, выполняющие оптимизации, которые 100% сделает сам компилятор.
А ещё они потом удивляются, что же этот их «мега-быстрый» код на реальных машинах выполняется дольше «неоптимизированного».
на php:
echo '1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 
FizzBuzz 16 17 Fizz 19 Buzz Fizz 22 23 Fizz Buzz 26 Fizz 28 29
FizzBuzz 31 32 Fizz 34 Buzz Fizz 37 38 Fizz Buzz 41 Fizz 43 44
FizzBuzz 46 47 Fizz 49 Buzz Fizz 52 53 Fizz Buzz 56 Fizz 58 59 
FizzBuzz 61 62 Fizz 64 Buzz Fizz 67 68 Fizz Buzz 71 Fizz 73 74 
FizzBuzz 76 77 Fizz 79 Buzz Fizz 82 83 Fizz Buzz 86 Fizz 88 89 
FizzBuzz 91 92 Fizz 94 Buzz Fizz 97 98 Fizz Buzz ';
Можно сделать меньше букав
echo str_replace(array('f','b','!'),
array('Fizz ','Buzz ','FizzBuzz '),
'1 2 f4 bf7 8 fb11 f13 14 
!16 17 f19 bf22 23 fb26 f28 29
!31 32 f34 bf37 38 fb41 f43 44
!46 47 f49 bf52 53 fb56 f58 59 
!61 62 f64 bf67 68 fb71 f73 74 
!76 77 f79 bf82 83 fb86 f88 89 
!91 92 f94 bf97 98 fb ';
Производительностю в угоду читаемости жертвовать ненужно.
а почему половина fb, а половина bf, если можно только fb?
fb — два числа друг за другом, первое делится на 3, второе на 5
bf — то же самое, но первое делится на 5, второе на 3
может, тогда на «f » и «b » менять надо было?
«f» меняется на «Fizz », то же самое с «Buzz ». Обратите внимание на пробелы. Все ок.
Прокручивая каменты, до последнего надеялся, что смогу опередить :)
Прсили вывести «FizzBuzz», а не «Fizz Buzz». Вы не приняты.
вы невнимательны — почему вас плюсуют? я принят, вы нет
Прекрасно:) Вынес ссылку на ваш коммент в тело поста
«Project Euler» — на сайте много небольших задач по математике для программистов. Если вы не хотите запороться на FizzBuzz задачах, то вам сюда.
var ss = new[]
{
null, null, «Fiz», null, «Buzz», «Fiz», null, null, «Fiz», «Buzz», null, «Fiz», null,
null, «FizBuzz»
};
for (int i = 1; i < 101; ++i)
{
Console.Write((ss[(i — 1) % 15] ?? i.ToString()) + " ");
}
Пятнашки. Одна пятнашка включает в себя повторяющуся серию из чисел, кратных 3, 5 и 15. дальше тупо повтор.
Может статья про вас?
 static void Main(string[] args)
        {
            for (int i = 1; i <= 100; i++)
            {
                string symbol = i.ToString();

                if (i % 3 == 0)
                    symbol = "Fizz";

                if (i % 5 == 0)
                    symbol = "Buzz";

                if ((i % 3 + i % 5) == 0)
                    symbol = "FizzBuzz";

                Console.WriteLine(symbol);
            }
        }
Так, по-моему, тело цикла читабельней и немного быстрей (я знаю, что преждевременная оптимизация зло :) ):
string symbol; /* можно вынести из цикла, можно в for объявить */

if ((i % 3 ==0) && (i % 5 == 0))
  symbol = "FizzBuzz";
else if (i % 3 == 0)
  symbol = "Fizz";
else if (i % 5 == 0)
  symbol = "Buzz";
else 
  symbol = i.ToString();

Console.WriteLine(symbol);

если условие выполняется, то остальные не проверяются, лишних присваиваний нет, если число выводить не нужно, то преобразования не происходит, невнятная операция сложения остатков заменена на обычную логическую. да и визулаьно понятно, что условия взаимоисключающие
Более быстро должно выполнятся :)
А я хотел без «if-else» написать. Правда можно провалиться в какое-нибудь лишнее присваивание, будь условие задачи посложнее.
без else if можно было красиво и эффективно обойтись если вывод FizzBuzz делать через конкатенацию :) как-то так
string symbol = ""; /* можно в for */

if (i % 3 ==0))
  symbol = "Fizz";
if (i % 5 == 0)
  symbol += "Buzz"; /* не помню, можно ли так, но смысл понятен надеюсь */
if (symbol == "") 
  symbol = i.ToString();
Вот это уже красиво. После недели непонятного кодинга, про конкатенацию забываешь ;)
bash:

#!/bin/bash

for i in `seq 1 100`
do
if [ `expr $i % 3` = 0 ] && [ `expr $i % 5` = 0 ]; then
echo FizzBuzz
elif [ `expr $i % 3` = 0 ]; then
echo Fizz
elif [ `expr $i % 5` = 0 ]; then
echo Buzz
else
echo $i
fi

done

:)
Bash с массивами:

#!/usr/local/bin/bash


for i in $(seq 100); do
    array[${i}]=${i};
done

i=3
while [ $i -le 101 ]
do
    array[${i}]="Fizz"
    i=$(( $i + 3 ))
done

i=5
while [ $i -le 101 ]
do
    array[${i}]="Buzz"
    i=$(( $i + 5 ))
done

i=15
while [ $i -le 101 ]
do
    array[${i}]="FizzBuzz"
    i=$(( $i + 15 ))
done

echo ${array[*]}

Более bash-way вроде должен выглядеть как-то так
for i in {1..100}
do
    ([ `expr $i % 3` == "0" ] && [ `expr $i % 5` == "0" ] && echo "FizzBuzz") ||
    ([ `expr $i % 3` == "0" ] && echo "Fizz") ||
    ([ `expr $i % 5` == "0" ] && echo "Buzz") || echo $i
done
И с массивами как-то так короче:

for i in {1..100}
do
 [ `expr $i % 3` == "0" ] && ARRAY[$i]="Fizz"
 [ `expr $i % 5` == "0" ] && ARRAY[$i]+="Buzz"
 echo ${ARRAY[$i]:-$i}
done

Оптимизацию вообще никто не вспомнил…
Pascal:
for i := 1 to 100 do
if i mod 3 = 0 then
if i mod 5 <> 0 then
print('Fizz')
else
print('FizzBuzz')
else
if i mod 5 <> 0 then
print(i)
else
print('Buzz');
Ранняя оптимизация — зло :)
Оптимизацию за нас сделает компилятор, причем чем менее запутанн наш код — тем лучше он её сделает.
Может быть, но я, блин, не доверяю этому оптимизатору, вернее, тем кто его написал :)
Это просто смешно.
Я (и думаю меня многие поддержат) совершенно не доверяю программистам, делающим такие оптимизации, оптимизации могут быть только на уровне архитектуру и не в ущерб понятности системы.

Это уж если после профилирования приложения выяснится что ваш код — слабое место, тогда и надо переписать.
Если только это не (n+1) SQL-запрос :-) Об этом нужно думать сразу по возможности
Эта ситуация не относится к описанной в топике и каменте оптимизации, это уже принцип минимизации интерфейса, который сам по себе больше относится к архитектуре чем к оптимизации кода.
>> оптимизации могут быть только на уровне архитектуру и не в ущерб понятности системы.
В embedded программировании или консолях — есть жесткие требования по производительности.
Не влезаем во фрейм — задача не решена. На понятность системы можно насрать, так как код обновляется довольно часто.
Нужна 100-строковая простыня на SIMD интринсиках вместо 10 строчек тормозного С-кода — она там будет без вопросов. Комплятор (gcc) не умеет вообще ничего, даже элементарщины. Векторизовать простейший цикл и применить modulo sheduling тем более. Я уже не говорю о распараллеливании какой-нить сложной обработки данных.

Не напомните процент embedded разработчиков? Я к тому, что для подавляющего большинства программистов совет не оптимизировать всё сразу — верен, а универсальных советов, чтобы удовлетворить всех — всё равно не существует.
>> а универсальных советов, чтобы удовлетворить всех — всё равно не существует.

правильно, посему ваш совет
«оптимизации могут быть только на уровне архитектуру и не в ущерб понятности системы» не корректнен если не известна предметная область
Не соглашусь.

Согласно вашей логике, ваш собственный предыдущий комментарий некорректен, т.к.
В embedded программировании или консолях — есть жесткие требования по производительности.
На понятность системы можно насрать.
Нужна 100-строковая простыня на SIMD интринсиках вместо 10 строчек тормозного С-кода — она там будет без вопросов.
Верно не для 100% embedded задач, бывает что и железка достаточно мощная, да и много можно придумать вариантов, когда понятность системы ставится гораздо выше производительности.

Так что когда мы говорим о предмете в общем — советы касаются предмета в общем, и нет нужды в конце каждого сообщения дописывать «Это верно только если вы не: ...».
Это как мне один раз предъявил товарищ — «я везде пишу в SQL хинты, указывая порядок джойнов таблиц, т.к. не доверяю оптимизатору Oracle»
Расскажите, пожалуйста, какой диалект Паскаля имеет встроенную процедуру «print» и чем она лучше стандартной «write»?
Ну хоть еще кто то заметил. Но могу вас всех заверить — такая ситуация не только в программировании — она ВЕЗДЕ: в бухгалтерии, в автомастерских, в правительстве и т.д.
И если вы директор конторы, которая занимается программированием, ваша задача набрать таких балбесов и сделать так, что бы они давали результат
А в чем подвох-то?

public class FizzBuzz
{
  public static void main ( final String[] args )
  {
    for ( int i = 1; i <= 100; i++ )
      if ( ( i % 15 ) == 0 )
        System.out.print ( "FizzBuzz " );
      else if ( ( i % 3 ) == 0 )
        System.out.print ( "Fizz " );
      else if ( ( i % 5 ) == 0 )
        System.out.print ( "Buzz " );
      else
        System.out.print ( i + " " );
  }
}

Как минимум половина людей с нашего факультета в жизни не напишут это.
Остальным потребуется день или два.
В принципе, если меня попросят «выписать рецепт на аспирин» — я тоже «зависну» на пару дней, потому что заканчивал вовсе не медицинский факультет. Да и на перле, руби, питоне этот пример не напишу сходу. Да что там говорить — на бейсике не смогу, так как последний раз писал на бейсике 20 лет назад на ямахе MSX. Специалист подобен флюсу — он однобок. Я лично не пытаюсь перечислить в CV языки, на которых я могу написать только «Hello, World»
Не верю! Что ж это за факультет-то такой хреновый?
Компьютерных технологий, конечно :)
Ведущего ВУЗ-а Украины!
Присоединяюсь. С моей группы быстро напишут максимум 5 человек. Быстро, это до часу. Двое из этих 5 должны написать за минуту :). В группе 20 человек. 4 курс.
PHP:for($i=0;$i++<100;)
{
$f=$i%3?'':'Fizz';
$b=$i%5?'':'Buzz';
echo$f.$b?$f.$b:$i,',';
}
Честно говоря мне всё равно, какие вопросы будут мне задавать на собеседовании: в нашем городе другая проблема — нет опыта работы и нет знакомых в IT-фирме, куда ты хочешь попасть — значит, ты даже и на собеседование не попадёшь.
Звонить пробовали?
Звонишь с одного телефона — говорят, что вакансий уже нет. Через полчаса звонит другой человек, с другого телефона и вакансия магическим образом появляется. При том, что им требуются студенты 3-5 курса.
Вижу ты из Бреста. Напиши мне в личку
Вообще, в любом собеседовании необходимо учитывать, что «жертва» находится под весьма серьёзным психологическим давлением. Особенно, если у него мало опыта в хождениях по собеседованиям. Поэтому результаты могут быть не слишком показательными.
а уж на проекте-то какое психологическое давление. Особенно на дедлайнах :-)
Оно разное. На собеседовании давит необходимость «показать себя с лучшей стороны» и «сделать так. чтобы тобой остались довольны», тогда как на проекте, в основном, необходимость сделать то, что ты уже умеешь, но быстрее и лучше. Опять же, при работе в хорошей команде ПМ большинство давления должен на себя брать и «экранировать» команду от влияния «боссов».
В нормальных конторах такого не должно быть. Вообще тогда какой смысл постоянно на износ жить?
Вопрос философии труда. На самом деле, напрягать ничего не должно — ни тесты, ни работа. Но решается это не тем, кто напрягает, а тем, кто работает. Чем меньше нервов уходит впустую непонятно на что, тем больше полезного будет вложено в труд.
Вот сижу жду пока код на brainfuck-е выложат =)
UFO just landed and posted this here
Я конечно не супер программист, и занимаюсь C++ меньше года, но вот:

#include
#include
int main()
{
int i;
for (i=1; i
Что-то оно как-то не скопировалось :)
Вот

hvmnd.org/c0002q

буду очень признателен если укажете на ошибки и покажете как надо.
Это не С++ и даже не Си. Это borland!!!
тьфуты блин
Эм, т.е. получается что в универе нас обманывают?
ИМЕННО. Во первых тут нет ни единой строчки из С++, в С++ вывод производится по феншую через cout, во вторых, даже если воспринимать этот код как Сишный, то он тупо не валидный.
Во первых в стандарте Си нету <conio.h> это уже дос какой-то.
Во вторых main по феншую должен содержать передаваемые аргументы int argc, char *argv[]
и третьих он должен содержать return 0 в случае корректного завершения или же содержать код ошибки вместо нуля в случае возникновения нештатной ситуации.
В общем в универе вам херню преподают.
Не совсем.
У вас в инклюдах conio.h — я надеюсь вы не думаете что это есть обязательным для всех программ на С? ) Это всего лишь заголовок, с помощью которого некоторые допотопные компиляторы 90-х(самого начала 90-х) годов создают текстовый интерфейс. И да, в частности старые версии borland.
Функция getch() — такой же анахронизм(собственно она входит в состав conio.h). Дабы окошко не закрывалось после выполнения программы обычно используют std::cin.get() входящую в состав iostream.h

И да, это не C++, это вполне себе С. Например stdio.h в С++ уже не используется, хотя и включается в состав для обратной совместимости, а вместо printf используется std::cout.
Если тебе интересны плюсы, то я предлагаю выкинуть из головы всё то, что преподают, и заняться их изучением самостоятельно. И то пользы больше будет.
Спасибо большое за ответы!
ЗЫ. Только вот не понимаю, за что кто-то насрал в карму :(
Уж лучше QtCreator поставить, чем с этим борландовским мраком воевать.
Ну, помимо всего вышесказанного, оно еще не очень работает. Для числа кратного 15, оно выведет Fizz Buzz FizzBuzz
На AS3:

var s:String;
for (var i:uint = 1; i<=100; i++) {
	(i%3 == 0 && i%5 == 0)?s = ("FuzzBuzz"):(i%3 == 0)?s = ("Fuzz"):(i%5 == 0)?s = ("Buzz"):s = String (i);
	trace(s);
}


Потратил 15 минут… =)
Пил кофе, читал хабр, сделал 2 ошибки при написании, долго любовался результатом.
Upd:

FuzzBuzz v 0.01:

function FuzzBuzz(arg1, arg2, num) {
	var s:String;
	for (var i:uint = 1; i<=num; i++) {
		(i%arg1 == 0 && i%arg2 == 0)?s = ("FuzzBuzz"):(i%arg1 == 0)?s = ("Fuzz"):(i%arg2 == 0)?s = ("Buzz"):s = String (i);
		trace(s);
	}
}
FuzzBuzz(3, 5, 100);
Ждем-с на BrainFuck'е… =)) Кто смелый?
Вот почему эти FuzzBuzz тесты превращаются на форумах всегда в конкурс юных петросянов, каждый из которых ставит своей целью выложить решение на самом эзотерическом языке программирования или же в нормальном ЯП решить задачу самым нетривиальным образом? Оо
И главное куда потом все эти люди деваются, они что-ли по собеседованиям не ходят?

*интересно, а что если попробовать задачу на голых шаблонах решить, теоретически все в compile time известно*
template<int T>
const char *FuzzBuzz()
{
  if(T %15)
    return "FuzzBuzz";
  else if(T % 3)
    return "Fuzz";
  else
    return "Buzz";
}
//а дальше нужно видимо рекурсивный шаблон делать или фигачить variadic template, у кого какие идеи?

* This source code was highlighted with Source Code Highlighter.
вы уверены в правильности этого решения?:)
Нет. Это даже не решение, это так пара мыслей.
У вас совсем не шаблонная программа, а самая обычная. Шаблонная будет как-то так: pastebin.com/CjT0iSRw. Только из-за какого-то внутреннего ограничения мне не удалось завести её при значении параметра больше 7.
Вы монстр. Расскажите, такие подобные знания на практике часто бывают нужны? В каких областях?
Пытаюсь раскурить магию…
Нда… всё же когда что-то сложное на шаблонах делаешь синтаксис становится невыносимым. Особенно строки и их конкатенация доставляет %)
:) особо нигде не нужно, just for fun. У меня на машине это компилится 26 секунд и кушает гиг памяти, что довольно непрактично.
)))) Помню, что студия вроде больше 128 вложеных ифов не обрабатывает. Чую здесь где-то аналогичный подвох
Сверху был ответ Sannis. В данном случае есть ограничение на длину строки boost::mpl, но оно тоже имеет верхний предел. Я описал на rosettacode.org/wiki/FizzBuzz#C.2B.2B, что необходимо в include/boost/mpl/limits/string.hpp поменять значение BOOST_MPL_LIMIT_STRING_SIZE на 128 вместо 32, тогда удастся собрать это при бóльших значениях параметра. Кстати, там же есть более простая реализация, с несколькими cout'ами.
Эти люди работают и читают хабрахабр
Но на собеседования же они ходили перед тем как работать начали.
я на 2х работах проходил собеседование без всяких там задачек. Мои познания проверялись прямо по ходу работы. Я думаю, у большинства также
Я дважды устраивался на работу. Оба раза взяли без всяких собеседований и резюме. Оба раза не пожалели :D
Да, еще все пытаются код сделать мегакомпактным, используя вместо if — (?:), типа все такие крутые, непонятно для лохов пишут, а то, что с такими конструкциями, когда вложенных условий много, код получается нечитабельным, это конечно никто не думает, чем непонятнее, тем более «по-джедайски».

И ваще эти написания кода на бумажке подбешивают, если ты реально пишешь на 5 языках, тебе иногда надо 5-10 минут, чтобы загрузить в мозг конкретный синтаксис, путем заглядывания в ранее написанный код или получения пары ошибок от компиллятора )
Лично я бы не стал на собеседовании выпендриваться, а решил бы задачу максимально простым способом.
Вот на JavaScript (поместилось в твит):
for (var i = 1; i <= 100; i ++) {
var x = '';
if (i % 3 == 0) x += 'Fizz';
if (i % 5 == 0) x += 'Buzz';
console.log(x || i);
}
За x || i — зачет, а вот 100 вызовов console.log — это неэффективно. Как по мне — лучше писать в строку, а потом выводить.
<script>
i = 1, s = '';
do{
	s += ((i %3 ? '':'Fizz') + (i %5 ? '':'Buzz') || i)+'\n';
}while(i++ <20);
alert(s)</script>
Windows CMD:
@echo off
rem 14:06

for /L %%n in (1,1,100) do call :PrintFizzBuzz %%n
goto :EOF

:PrintFizzBuzz
set /A aa3=%1 %% 3
set /A aa5=%1 %% 5

if NOT 0==%aa3% IF NOT 0==%aa5% set /P dummy="%1"<NUL
if 0==%aa3% set /P dummy="Fizz"<NUL
if 0==%aa5% set /P dummy="Buzz"<NUL

rem 14:49 и меня отвлекали! :)


И да! Я не программист. :)
Трое из показавших свой код уже не сдали экзамен, спутав Fizz с Fuzz.
Ага! Я тоже. Но перед окончательным постингом еще раз прочел задание!
И вообще, все, кто выводил пробелы, бэеры и переводы строк, решили задачу неправильно ))
12Fizz4Buzz...99Buzz
вот правильный вывод по условиям)
ок, ошибка )
12Fizz4Buzz...FizzBuzz
Все пишут эту задачку на основе вычисления остатка от деления, а вот вам код на JS без делений (только инкременты и сравнения):

(function() {
    var str = '';
    for(var i = j = k = 1;i<=100;i++, j++, k++) {
        if (k != 5 && j != 3) {
            str += ' ' + i + ' ';
        }
        else {
            if (j == 3) {
                str += 'Fizz';
                j = 0;
            }
            if (k == 5) {
                str += 'Buzz';
                k = 0;
            }
        }
    }
    console.log(str);
}());
Все пишут эту задачку на основе вычисления остатка от деления, а вот вам код на JS без делений (только инкременты и сравнения):

(function() {
    var str = '';
    for(var i = j = k = 1;i<=100;i++, j++, k++) {
        if (k != 5 && j != 3) {
            str +=i;
        }
        else {
            if (j == 3) {
                str += 'Fizz';
                j = 0;
            }
            if (k == 5) {
                str += 'Buzz';
                k = 0;
            }
        }
    }
    console.log(str);
}());


Это вариант без пробелов
Мой вариант решения «FizzBuzz» для JavaScript с минимумом переменных.
console.log(
(new Array(102)).join(' ').split('').map(function (i, j) {
    return !(j%5||j%3) ? 'FizzBuzz' : !(j%5) ? 'Buzz' : !(j%3) ? 'Fizz' : j;
}).splice(1).join(' ')
);
console.log(
(''+new Array(102)).split('').map(function (i, j) {
    return j%15 ? j%5 ? j%3 ? j : 'Fizz' : 'Buzz' : 'FizzBuzz';
}).splice(1).join(' ')
)
Если гнаться за минимумом переменных, то можно и обычным циклом обойтись

for (var i=1, str = '';i<=100;i++){
    str += (i%15 ? i%5 ? i%3 ? i : 'Fizz' : 'Buzz' : 'FizzBuzz');
}

Здорово, только конструкция (''+new Array(102)).split('') некошерна, ИМХО.

console.log (
  Array.apply(null, Array 101).map (i,j) ->
    unless j%15 then 'FizzBuzz'
    else unless j%5 then 'Buzz'
    else unless j%3 then 'Fizz'
    else j
).splice(1).join ' '

Вот так можно с дырками обходится.
Воот! Я ждал этого ответа! Особенно учитывая то, что деление более затратная операция, по тактам процессора, чем инкремент. Начал тут тыкать Rust и разумеется первое что написал…
fn main() {
    let (fizz, buzz) = (3, 5);
    let mut c_fizz = 3;
    let mut c_buzz = 5;
    for idx in 1..101 {
        if idx == c_fizz && idx == c_buzz {
            println!("FizzBuzz");
            c_fizz = c_fizz + fizz;
            c_buzz = c_buzz + buzz;
        }
        else if idx == c_fizz {
            println!("Fizz");
            c_fizz = c_fizz + fizz;
        }
        else if idx == c_buzz {
            println!("Buzz");
            c_buzz = c_buzz + buzz;
        }
        else {
            println!("{}", idx);
        }    
    }
}
UFO just landed and posted this here
листая комменты — ожидал внизу увидеть код в одну строчку, который захватит мир
не захватывает мир =(
for( int i = 1; i <= 100; i++ ) if( i % 3 ) if( i % 5 ) printf( "%d ", i ); else printf( «Buzz » ); else if( i % 5 ) printf( «Fizz » ); else printf( «FizzBuzz » );
http сожрал редактор)
<=100, а то ща тут 50 комментариев на эту тему будет
Меня можно на таблице умножения завалить. Чем дальше от школы, тем больше элементарных вещей забывается. Взамен приобретаются навыки, которые позволяют вполне успешно работать программистом.
Эффективно пользоваться поиском и документацией.
Знать наизусть все операторы не всегда представляется возможным, т.к. часто приходится выбирать какой-то новый инструмент, а то и новый язык.
Школьнику придётся изучать учебники, либо брать курсы, специалисту же достаточно воспользоваться краткой справкой и примерами кода.
И более глобально:
«Почему Х не умеет Х-ть»
Никто еще на лиспе не привел, ха!

(iterate (for i from 1 upto 100)
         (with divides = (composition zero? mod))
         (when (divides 3 i) (print "Fizz"))
         (when (divides 5 i) (print "Buzz")))
Вы не понимаете природу лиспа.

«Lisp is Not an Acceptable Lisp» — Steve Yegge
А где происходит вывод i?
И правда… пропустил строчку в условии ^_^

(iterate (for i from 1 upto 100)
         (with divides = (composition zero? mod))
         (when (divides 3 i) (print "Fizz")
               (when (divides 5 i) (print "Buzz"))
               (continue))
         (when (divides 5 i) (print "Buzz")
               (continue))
         (print i))


Как вариант можно придумать макрос проверки условий в стиле императивного С-шного switch case break

(iterate (for i from 1 upto 100)
         (with divides = (composition zero? mod))
         (switch-cond ((divides 3 i) (print "Fizz"))
                      ((divides 5 i) (print "Buzz") (continue))
                      (default (print i))))
Clojure

(let [divides? (comp zero? rem)]
(println (map #(cond
(divides? % 3) «Fizz»
(divides? % 5) «Buzz»
(divides? % 15) «FizzBuzz»
:else %) (range 1 101))))
C++
Написал первое, что пришло в голову, вложенными ифами.
Можно тупо 4 условия подряд. Даже не знаю, какой вариант читабельнее.
Любой одногруппник способен написать такую прогу. Максимум — по невнимательности ошибется.
#include <iostream>

int main(){
    for(int i=1;i<=100;++i){
        if(i%15==0){
            std::cout << "FizzBuzz";
        }else{
            if(i%5==0){
                std::cout<<"Buzz";
            }else{
                if(i%3==0){
                    std::cout<<"Fizz";
                }else{
                    std::cout<<i;
                }
            }
        }
        if(i!=100)std::cout<<" "; // !!! ??
    }
}
Будте по-аккуратнее с "??" :)
Болван!
s/Будте/Будьте
#include <iostream>

int main(int argc, char* argv[]) {
	for ( int i = 1; i <= 100; ++i ) {
		if ( i % 3 != 0 && i % 5 != 0 ) {
			std::cout << i << " ";
		}
		else {
			std::cout << ( i % 3 == 0 ? "Fizz" : "") << ( i % 5 == 0 ? "Buzz" : "") << " ";
		}
	}
	std::cout << std::endl;
	return 0;
}
Почему нет лиспа? Вот вариант на схеме.
(define (f x)

  (define (test x y)
    (zero? (modulo x y)))

  (cond ((test x 15) "FizzBuzz")
        ((test x 5) "Buzz")
        ((test x 3) "Fizz")
        (else x)))

(define (range start stop)
  (if (<= start stop)
      (cons start (range (+ start 1) stop))
      '()))

(display (map f (range 1 100)))
Любителю рекурсии слабо через игрек-комбинатор?
ZX Spectrum Basic :-)

10 FOR i=1 TO 100
20 LET a$=""
30 IF i/3=INT (i/3) THEN a$=«Fizz»
40 IF i/5=INT (i/5) THEN a$=a$+«Buzz»
50 IF NOT LEN a$ THEN a$=STR$ i
60 PRINT a$
70 NEXT i

Я не пррограммист, но за минуту уложился :-)
UFO just landed and posted this here
Какой же он, все-таки, зануда!
Там в комментариях решение на BrainFuck'е.
Scala:
(0 to 100).toList.map((x: Int) => {
      if (x % 3 == 0) print("Fizz")
      if (x % 5 == 0) print("Buzz")
      if (x % 15 != 0) print(x)
      println
    })
Это все же не совсем функциональный подход :) Я выше написал Scala-way решение :)
Отличия с вашим вариантом минимальны. И у вас, и у меня те же самые три затратных операции деления, и тот же самый (даже более длинный) условный оператор. И да, это не совсем ФП, согласен.
У Вас, кстати, ошибка в коде :) Посмотрите, например, что оно выведет для 3 или для 5 :)
Да, спасибо, вы — молодец :) Ваш условный оператор победил :)
Опыт собеседования программистов — 5 лет. Готов подписаться под каждым словом.
>Но меня просто выводит из себя тот факт, что человек, не умеющий писать даже
>простейшие программы, имеет наглость называть себя программистом. Я считаю это
>оскорблением для тех, кто носит это звание по праву.

Эмоциональное заявление, но оно имеет право на жизнь :) По-моему, дело всего лишь в том, что речь идёт о разных программистах. Программисты (и не только, это любой профессии свойственно) есть по факту, а есть по должности. Я до сих пор с умилением вспоминаю одного “инженера-программиста” (одну, если уж честно :), которая как-то представила мне в непонятках программу свою на посмотреть в чём проблема. Как эта “инженер-программист” инициализировала массив на фортране:
     REAL ARRAY(4,50)

     ARRAY(1,1)=0.0
     ARRAY(1,2)=0.0
     ARRAY(1,3)=0.0

... 200 строк такого “кода”

     ARRAY(4,49)=0.0
     ARRAY(4,50)=0.0


А ведь программист :)
Фортран не помню, но кто знает, может у неё очень жёсткие требования на производительность были и инициализировать двумя вложенными циклами было недопустимо :D
Ну, я-то знаю, какие у неё были требования :)
Инженеров-программистов в Советском Союзе было море разливанное. Законодательство такое. Ещё один пример из воспоминаний тех времён — в конторе был супер-головастик с золотыми руками на должности техника, ибо самоучка. И был куда менее сообразительный инженер-электронщик с образованием историка. А причина такого перекоса в должностях скрывалась именно в законодательстве страны советов — человека с высшим образованием нельзя было поставить на должность ниже инженерной. И пофигу, что образование его к предметной области не имело никакого отношения.

Вот и эта программистка была из той же области примерно — конструкции на фортране ваять могла, но программировать — увы.
А человека без высшего образования нельзя было поставить на должность инженера…
Именно так. Сегодня-то куда лучше — я у соискателей даже дипломов не спрашиваю, тем более, что они продаются на каждом углу :)
Иногда всё же дипломы нужны, например для получения лицензий и/или участия в тендерах/конкурсах. На моей памяти было, что для этого руководство фирмы работникам дипломы покупало «на углу» :)
Иного коммента, кроме «ААААААААААААААААААААААААААААААА!!!!!!!!!!!!!!!!!!» не возникает=)
The purpose is the reduction of the size of the bytecode. Consider creating a three element Object[] with null values:
*
*  ANEWARRAY java/lang/Object    
*  DUP
*  ICONST_0
*  ACONST_NULL
*  AASTORE
*  DUP
*  ICONST_1
*  ACONST_NULL
*  AASTORE
*  DUP
*  ICONST_2
*  ACONST_NULL
*  AASTORE
* 

* with ArrayUtils you can have it like this:
*
*  ACONST_NULL
*  ACONST_NULL
*  ACONST_NULL
*  INVOKESTATIC ArrayUtils.createArray(Object,Object,Object)
* 

* The number of needed instructions is thus reduced from 15 to 4. For every entry we save 3 bytecode instructions.
* This allows better readable bytecode and it allows the JIT to see less bytecode to optimize, helping under the
* inlining threshold here or there.


Ну чтож, разумно :) А вы исходники Javac читали? Там тоже есть прикольные места.
Вполне допускаю, что в целях отпимизации под конкретную платформу (а зачастую — под конкретный релиз конкретной платформы) возможно и не такое. У одной из версий Watcom C (кажется, 9.0) был глюк в оптимизаторе, который давал идиотский (но к счастью рабочий!) код: C-конструкция ~~~~~~int порождала соответствующее количество NOT'ов в коде :) Для того, чтобы избежать этого абсурда, потребовалось бы макрос, который и порождал ~~~~~, превратить в чудовище или функцию. Но всё же я уже лет триста придерживаюсь позиции “Исходный код — для человека, а не для машины” :)
а что, собственно вас смутило в этом коде?

я сперва по привычке пролистнул комментарий в начале класса и просто начал читать методы.

на четвёртом методе понял, что меня дурачат, пролистал вниз (и вправо), на 5 секунд задумался о том, зачем это нужно было автору, прикинул что единственный известный мне резон поступать так — это оптимизировать то, что по каким-то причинам не оптимизируется компилятором/обфускатором.

вернулся на начало текста, прокитал комментарий и подтвердился в своей правоте (хотя еще проверю потом сам в помощью java-декомпилятора). может быть и воспользуюсь сам таким фокусом в моей программ, ибо как в некоторых случаях (в моем случае по крайней мере) я соглашусь на некоторую потерю «читабельности» кода ради выигрыша по памяти, объему, [скорости].

так что у меня к этому комментарий «УУУУУУУУУУУУУ!!!!!!»
Да, собственно, ничего не смутило. Просто к слову пришлось. Хотя, я полагаю, если воспользоваться переменным списком аргументов в Java, то результат будет не хуже. Типа
public static Object[] createArray(Object... arg0)
{
    return arg0;
}

Но такая фича появилась в JDK 1.5. Возможно, авторам требуется совместимость с более ранними версиями (либо писалось раньше).
Впрочем, неправ. Такой createArray генерирует тот же длинный байткод, что и явное создание. Так что действительно ничего не смущает :-)
я живу в мире, в котором используется jdk1.3 и jdk1.4
имя этому миру — j2me

да в общем-то не в этом примере дело — подобные подходы, когда за счет какого-то ловкого фокуса можно достичь определенного результата существуют в разных языках (и даже сферах отличных от айти). если заранее в формулировке задания про ФиззБузз работодатель не сообщает дополнительные сведения, то соискатель с очень большой долей вероятности «промахнется» мимо того решения, которое предполагал работодатель как идеальное.
Мне кажется, у некоторых еще проявляется т.н. боязнь чистого листа. Люди привыкли копипастить куски кода из интернета/чужих проектов/своих предыдущих проектов. Причем даже если этот код вообще не имеет ничего общего с тем, что требуется написать. Наблюдала как-то за одним товарищем: он копипастил код предыдущей лабораторки в новый файл, стирал все, кроме int main() {} и начинал писать новую. И еще обязательно оставлял закомментированными какие-то куски типа готовых printf, while, for, чтобы потом использовать и их. Так что вполне может быть, что большая часть времени тратится кандидатом на мучительные попытки вспомнить синтаксис нужных конструкций, которые он, по идее, должен писать на автомате.
Я иногда впадаю в ступор, когда просят (или приходится) написать простейшую программу на бумажке или в блокноте, в общем без IDE или, хотя бы, транслятора — легко могу ошибиться в таких вещах как точки с запятой, баланс скобок и т. п., а то и ключевые слова из разных языков перепутать, вместо throw написать raise например :)

Расскажите своему товарищу про шаблоны новых файлов в IDE или даже прямо в ОС :)
Бывает полезно писать вообще с чистого листа и без подключения к Интернету :) Нужно уметь преодолевать этот психологический барьер. Я начинаю с развернутого комментария о том, что будет делать этот код, когда ничего в голову не идет.
Когда-то давно так и писал, и собирал проекты ручками, потом IDE разбаловали с хелпами, потом и Интернет, вплоть до того, что сейчас решаю задачу, сдаю, а что там внутри происходит и не знаю (в частности на Java когда пришлось писать недавно или сейчас на PyQt)
Очевидно, что за неточно воспроизведенный синтаксис команды никто не будет снимать вам кучу баллов и выгонять с собеседования. Важно, чтобы идея решения была правильной.

Кстати, у меня синтаксис плюсов стал просто от зубов отскакивать, когда после Visual Studio с ее автодополнением и сниппетами перелез на vim:)
Также, по-моему, очевидно, что при прочих равных предпочтение отдадут тому, у кого код будет транслироваться без syntax error и код будет без исправлений (при наборе кода в редакторе никто, наверное, не обратит внимание на нажатие BS, а вот исправления «пером» сразу обращают на себя внимание). В принципе, боязнь допустить ошибку в процессе создания кода очень сильно для меня влияет на скорость создания «пререлиза» (кода, который я готов попытаться оттранслировать) — в реальной жизни я могу себе позволить удалять блоки строк или даже очищать файл целиком, если вижу, что понесло куда-то не туда (в этом топике уже так поступал в комменте, где комментировал в стиле «а я добился» неудачный, имхо, код, на малознакомом ЯП, который признали удачным :) ). На собеседовании же (или ином тестировании), где над процессом создания наблюдают, сначала считаю необходимым представить весь код с точностью, хотя бы, до строки (в случае задач подобных сабжу топика), а уж потом писать — не то, что зачеркивания на бумажке считаю недопустимым, но даже нажатие BS при работе в IDE — скорость падает в разы, если не на порядки. В принципе не только кода это касается, но и вопросов на собеседовании типа «чем измеряется труд врача?… а чем таксиста? а почему вы выбрали нашу фирму, чтобы послать резюме» — сначала прикидываю возможные варианты ответов, потом в чём подвох в вопросе, как вопрос соотносится с ИТ вообще, и с программированием в частности, откидываю на мой взгляд неудачные, оставив один единственный думаю, а есть ли альтернативы, которые ещё не рассмотрел, если есть то гоуту к «в чём подвох», потом выдаю ответ. Скорость ответа тоже падает в разы, если не на порядки, даже если первый вариант оказался тем, который в итоге выдал (причем никакого фидбэка, был мой ответ плюсом или минусом, надо было отвечать не думая, или анализировать ситуацию ещё глубже)
Эх, выходные, гости, спиртное… Кучу написал, а похоливарить насчёт vim vs IDE (да пускай даже nano) забыл :)
Brainfuck ^_^
>+++++++[<+++++++>-]<.-----------------.>+++[<++++++>-]<.>+++[<------>
-]<.>++++++[<++++++>-]<++.>+++++[<+++++++>-]<.+++++++++++++++++..>++++
+++++[<---------->-]<.>++++[<+++++>-]<.>++++[<----->-]<.>+++++[<++++++
+>-]<-.>+++++[<++++++++++>-]<+.+++++..>+++++++++[<---------->-]<.>++++
++[<++++++>-]<++.>+++++[<+++++++>-]<.+++++++++++++++++..>+++++++++[<--
-------->-]<.>++++[<++++++>-]<-.>++++[<------>-]<+.>++++[<++++++>-]<.>
++++[<------>-]<.>++++++[<++++++>-]<++.>+++++[<+++++++>-]<.+++++++++++
++++++..>+++++++++[<---------->-]<.>+++++[<+++++++>-]<-.>+++++[<++++++
++++>-]<+.+++++..>+++++++++[<---------->-]<.+++++++++++++++++..-------
----------.>++++++[<++++++>-]<++.>+++++[<+++++++>-]<.+++++++++++++++++
..>+++++++++[<---------->-]<.+++++++++++++++++.++.>+++[<------>-]<-.++
+++++++++++++++.+++.>++++[<----->-]<.>++++++[<++++++>-]<++.>+++++[<+++
++++>-]<.+++++++++++++++++..>+++++++[<-------->-]<.>+++++[<++++++++++>
-]<+.+++++..>+++++++++[<---------->-]<.+++++++++++++++++.+++++.>+++[<-
------>-]<-.+++++++++++++++++.++++++.>++++[<------>-]<+.>++++++[<+++++
+>-]<++.>+++++[<+++++++>-]<.+++++++++++++++++..>+++++++++[<---------->
-]<.+++++++++++++++++.++++++++.>+++++[<----->-]<.>+++++[<+++++++>-]<-.
>+++++[<++++++++++>-]<+.+++++..>+++++++++[<---------->-]<.>++++++[<+++
+++>-]<++.>+++++[<+++++++>-]<.+++++++++++++++++..>+++++++++[<---------
->-]<.>+++[<++++++>-]<..>+++[<------>-]<.>+++[<++++++>-]<.+.>+++[<----
-->-]<-.>++++++[<++++++>-]<++.>+++++[<+++++++>-]<.+++++++++++++++++..>
+++++++++[<---------->-]<.>+++++[<+++++++>-]<-.>+++++[<++++++++++>-]<+
.+++++..>+++++++++[<---------->-]<.>+++[<++++++>-]<.++++.>+++[<-------
>-]<-.>++++++[<++++++>-]<++.>+++++[<+++++++>-]<.+++++++++++++++++..>++
+++++++[<---------->-]<.>+++[<++++++>-]<.++++++.>++++[<------>-]<.>+++
[<++++++>-]<.+++++++.>+++++[<----->-]<.>++++++[<++++++>-]<++.>+++++[<+
++++++>-]<.+++++++++++++++++..>+++++++[<-------->-]<.>+++++[<+++++++++
+>-]<+.+++++..>+++++++++[<---------->-]<.>+++[<++++++>-]<+.--.--------
---------.>+++[<++++++>-]<+.-.>+++[<------>-]<.>++++++[<++++++>-]<++.>
+++++[<+++++++>-]<.+++++++++++++++++..>+++++++++[<---------->-]<.>+++[
<++++++>-]<+.+.>++++[<----->-]<.>+++++[<+++++++>-]<-.>+++++[<+++++++++
+>-]<+.+++++..>+++++++++[<---------->-]<.>++++++[<++++++>-]<++.>+++++[
<+++++++>-]<.+++++++++++++++++..>+++++++++[<---------->-]<.>+++[<+++++
+>-]<+.++++.>++++[<------>-]<+.>+++[<++++++>-]<+.+++++.>++++[<------>-
]<.>++++++[<++++++>-]<++.>+++++[<+++++++>-]<.+++++++++++++++++..>+++++
++++[<---------->-]<.>+++++[<+++++++>-]<-.>+++++[<++++++++++>-]<+.++++
+..>+++++++++[<---------->-]<.>++++[<+++++>-]<.---.-----------------.>
++++++[<++++++>-]<++.>+++++[<+++++++>-]<.+++++++++++++++++..>+++++++++
[<---------->-]<.>++++[<+++++>-]<.-.>+++[<------>-]<-.>++++[<+++++>-]<
..>++++[<----->-]<.>++++++[<++++++>-]<++.>+++++[<+++++++>-]<.+++++++++
++++++++..>+++++++[<-------->-]<.>+++++[<++++++++++>-]<+.+++++..>+++++
++++[<---------->-]<.>++++[<+++++>-]<.++.>+++[<------->-]<-.>++++[<+++
++>-]<.+++.>++++[<------>-]<+.>++++++[<++++++>-]<++.>+++++[<+++++++>-]
<.+++++++++++++++++..>+++++++++[<---------->-]<.>++++[<+++++>-]<.+++++
.>+++++[<----->-]<.>+++++[<+++++++>-]<-.>+++++[<++++++++++>-]<+.+++++.
.>+++++++++[<---------->-]<.>++++++[<++++++>-]<++.>+++++[<+++++++>-]<.
+++++++++++++++++..>+++++++++[<---------->-]<.>+++[<+++++++>-]<.---.>+
++[<------>-]<.>+++[<+++++++>-]<.--.>+++[<------>-]<-.>++++++[<++++++>
-]<++.>+++++[<+++++++>-]<.+++++++++++++++++..>+++++++++[<---------->-]
<.>+++++[<+++++++>-]<-.>+++++[<++++++++++>-]<+.+++++..>+++++++++[<----
------>-]<.>+++[<+++++++>-]<.+.>+++[<------->-]<-.>++++++[<++++++>-]<+
+.>+++++[<+++++++>-]<.+++++++++++++++++..>+++++++++[<---------->-]<.>+
++[<+++++++>-]<.+++.>++++[<------>-]<.>+++[<+++++++>-]<.++++.>+++++[<-
---->-]<.>++++++[<++++++>-]<++.>+++++[<+++++++>-]<.+++++++++++++++++..
>+++++++[<-------->-]<.>+++++[<++++++++++>-]<+.+++++..>+++++++++[<----
------>-]<.>+++[<+++++++>-]<+.-----.-----------------.>+++[<+++++++>-]
<+.----.>+++[<------>-]<.>++++++[<++++++>-]<++.>+++++[<+++++++>-]<.+++
++++++++++++++..>+++++++++[<---------->-]<.>+++[<+++++++>-]<+.--.>++++
[<----->-]<.>+++++[<+++++++>-]<-.>+++++[<++++++++++>-]<+.+++++..>+++++
++++[<---------->-]<.>++++++[<++++++>-]<++.>+++++[<+++++++>-]<.+++++++
++++++++++..>+++++++++[<---------->-]<.>+++[<+++++++>-]<+.+.>++++[<---
--->-]<+.>+++[<+++++++>-]<+.++.>++++[<------>-]<.>++++++[<++++++>-]<++
.>+++++[<+++++++>-]<.+++++++++++++++++..>+++++++++[<---------->-]<.>++
+++[<+++++++>-]<-.>+++++[<++++++++++>-]<+.+++++..>+++++++++[<---------
->-]<.>++++[<++++++>-]<-.------.-----------------.>++++++[<++++++>-]<+
+.>+++++[<+++++++>-]<.+++++++++++++++++..>+++++++++[<---------->-]<.>+
+++[<++++++>-]<-.----.>+++[<------>-]<-.>++++[<++++++>-]<-.---.>++++[<
----->-]<.>++++++[<++++++>-]<++.>+++++[<+++++++>-]<.+++++++++++++++++.
.>+++++++[<-------->-]<.>+++++[<++++++++++>-]<+.+++++..>+++++++++[<---
------->-]<.>++++[<++++++>-]<-.-.>+++[<------->-]<-.>++++[<++++++>-]<-
..>++++[<------>-]<+.>++++++[<++++++>-]<++.>+++++[<+++++++>-]<.+++++++
++++++++++..>+++++++++[<---------->-]<.>++++[<++++++>-]<-.++.>+++++[<-
---->-]<.>+++++[<+++++++>-]<-.>+++++[<++++++++++>-]<+.+++++..>++++++++
+[<---------->-]<.>++++++[<++++++>-]<++.>+++++[<+++++++>-]<.++++++++++
+++++++..>+++++++++[<---------->-]<.>++++[<++++++>-]<.------.>+++[<---
--->-]<.>++++[<++++++>-]<.-----.>+++[<------>-]<-.>++++++[<++++++>-]<+
+.>+++++[<+++++++>-]<.+++++++++++++++++..>+++++++++[<---------->-]<.>+
++++[<+++++++>-]<-.>+++++[<++++++++++>-]<+.+++++..>+++++++++[<--------
-->-]<.>++++[<++++++>-]<.--.>+++[<------->-]<-.>++++++[<++++++>-]<++.>
+++++[<+++++++>-]<.+++++++++++++++++..>+++++++++[<---------->-]<.>++++
[<++++++>-]<..>++++[<------>-]<.>++++[<++++++>-]<.+.>+++++[<----->-]<.
>++++++[<++++++>-]<++.>+++++[<+++++++>-]<.+++++++++++++++++..>+++++++[
<-------->-]<.>+++++[<++++++++++>-]<+.+++++..>+++++++++[<---------->-]
<.>+++++[<+++++>-]<.--------.-----------------.>+++++[<+++++>-]<.-----
--.>+++[<------>-]<.>++++++[<++++++>-]<++.>+++++[<+++++++>-]<.++++++++
+++++++++..>+++++++++[<---------->-]<.>+++++[<+++++>-]<.-----.>++++[<-
---->-]<.>+++++[<+++++++>-]<-.>+++++[<++++++++++>-]<+.+++++..>++++++++
+[<---------->-]<.>++++++[<++++++>-]<++.>+++++[<+++++++>-]<.++++++++++
+++++++..>+++++++++[<---------->-]<.>+++++[<+++++>-]<.--.>++++[<------
>-]<+.>+++++[<+++++>-]<.-.>++++[<------>-]<.>++++++[<++++++>-]<++.>+++
++[<+++++++>-]<.+++++++++++++++++..>+++++++++[<---------->-]<.>+++++[<
+++++++>-]<-.>+++++[<++++++++++>-]<+.+++++..
Даже реализация на APL или на ассемблере не сравнится с вашей.
Снимаю шляпу.
Честно признаюсь, это не руками написанный код. Правильную версию я пока не осилил, это просто код который автоматически сгенерирован по результирующей строке.
Это не спортивно. Текстовый генератор что угодно вывести может. Вот честная реализация:

>++++++++++>+++++++++<[>>[-]++++++++++>>[-]++++++++++<<<<[>>->>->+<<<<
<-]>>>>>[<<<<<+>>>>>-]<<<<<>>>[-]++++++++++>>[-]++++++++++<<<<[>>->>->
+<<<<<-]>>>>>[<<<<<+>>>>>-]<<<<<>>>>>>>>>>+<<<<<<<<<<>>>[>+<-]>[>+<-[>
+<-[>--<-[>+<-[>+<-[>--<-[>+<-[>+<-[>--<-[>+<-[>+<-[>--<-[>+<-[>+<-[>-
-<-[>+<-[>+<-[>--<-]]]]]]]]]]]]]]]]]]>>+<[>-<[-]]>[>>>>[-]<<<<++++++++
++++++++++++++++++++++++++++++++++++++++++.[-]]<<<<<[>>+>+<<<-]>>>[<<<
+>>>-]<<[>>+>+<<<-]>>>[<<<+>>>-]+<----------[>-<[-]]>[>>>>>[-]<<<<<+++
++++++++++++++++++++++++++++++++++++++++++++.[-]]<<[-]<[>+>+<<-]>>[<<+
>>-]+<-----[>-<[-]]>[>>>>>>[-]<<<<<<++++++++++++++++++++++++++++++++++
+++++++++++++.[-]]>>>>>>[<<<<<<<<<++++++++++++++++++++++++++++++++++++
++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++.>>>>>>>
>-]<<<<<<<<[-]<[-]<-[>+>+<<-]>>[<<+>>-]+<+[>-<[-]]>[<<++++++++++<->>>[
-]]++++++++++.[-]<<<] 

Она правда не слова выводит, а цифры. 3 если кратно 3, 0 если 5 и 30 если и то и то.
Jсталось реализовать это на malbolge ^^
Я обычно давал простейшую задачку на реверс строки… как только ее не решали — в одном случае четырьмя вложенными циклами, в другом двумерным массивом, в третьем перевыделяли строку на каждой итерации (теряя все содержимое).

Вторая задачка, которую я всегда давал С++ программерам, это написание оператора присваивания шаблонного класса-контейнера (вектора) — сразу все видно — часть просто не знала, что это, еще часть понятия не имела, как выделять память, еще часть не проверяла входной параметр на нули, подавляющее большинство забывало освободить старый указатель. Зато были единицы, с кем можно было поговорить про оптимизацию инициализации копий по умолчанию и обработку исключительных ситуаций в процессе копирования.

Собственно, это не значит, что мы принимали только последних. Если человек писал хотя-бы простой вариант решения, и при обсуждении адекватно реагировал на намеки на недостатки, то это уже был неплохой кандидат (обучаемый, по крайней мере).
В догонку…

Давно уже использую резюме только для поиска нужных ключевых слов. Ну максимум опыт человека посмотреть (где работал). Далее — телефонное собеседование (от 5 до 20 мин) и только по его результатам живое интервью (с тестовыми заданиями, написанием кода FizzBuzz-ом и прочим, the whole 9 yards).

Так что совет всем начинающим «принимающим на работу» — забейте на резюме, общайтесь с человеком и попытайтесь максимально создать для него «боевые условия» (при этом абсолютно не давя на психику). Бывает попадаются настоящие гуру с одностраничным нелепо написанным резюме и люди, которых близко подпускать нельзя с 5-тистраничным офигенно составленным CV. Хотя и наоборот. В общем, резюме — это так, бумажка. Никогда не составляйте мнение по сему документу.
А как составлять резюме совет дадите? набор ключевых слов и контакты, максимум опыт указать? :)
Ну с четырьмя условиями понятно, как написать, тут подали идею конкатенации, но мне не понравилось использование переменной и её модификация, так что:

for i in xrange(1, 100): print ("" if i % 3 else "Fizz") + ("" if i % 5 else "Buzz") or i


Расплачиваться за уменьшение количества условий приходится бОльшим количеством (возможно снижающим читаемость) действий со строками.
Дурная у меня пехепешная привычка разделять «бизнес-логику» и «представление» :) пускай даже внутри цикла
Не только PHP-шная. Кстати, привычка полезная в реальной жизни, хотя короткие примеры при этом получаются длиннее )
Ну, в С и VB у меня такой привычки не было, а вот php приучил :)
Рекурсивно на ruby:
def fizzbuzz(i=1)
  return if i > 100
  if (i%15).zero?; puts "FizzBuzz"
  elsif (i%3).zero?; puts "Fizz"
  elsif (i%5).zero?; puts "Buzz"
  else; puts i; end

  fizzbuzz(i+1)
end
Где ещё, кроме хабра, увидишь больше 10-ка самых разнообразных, изысканных, галантных, извращённых и просто порой странных решений такой простой задачи…
ну пожалуйста, можно я скажу?
хабр — торт!
Вот XSLT здесь еще не было :) Поэтому вот он:
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
	<xsl:output method="text" encoding="UTF-8"/>

	<xsl:template match="/">
		<xsl:variable name="set" select="//node()"/>

		<xsl:for-each select="$set[position() <= 100]">
			<xsl:choose>
				<xsl:when test="position() mod 3 = 0 and position() mod 5 = 0">FizzBuzz</xsl:when>
				<xsl:when test="position() mod 5 = 0">Buzz</xsl:when>
				<xsl:when test="position() mod 3 = 0">Fizz</xsl:when>
				<xsl:otherwise>
					<xsl:value-of select="position()"/>
				</xsl:otherwise>
			</xsl:choose>
			<xsl:text> </xsl:text>
		</xsl:for-each>		
	</xsl:template>
</xsl:stylesheet>

Для краткости кода использован метод Пиза, поэтому число узлов в обрабатываемом xml должно быть не менее ста.
Лучше уж тогда рекурсивно вызывать:
<xsl:template name="FizzBuzz">
    <xsl:param name="index" select="1"/>
    <xsl:param name="index_end" select="100"/>
    <xsl:choose>
        <xsl:when test="$index mod 3 = 0 and $index mod 5 = 0">FizzBuzz</xsl:when>
        <xsl:when test="$index mod 3 = 0">Fizz</xsl:when>
        <xsl:when test="$index mod 5 = 0">Buzz</xsl:when>
        <xsl:otherwise><xsl:value-of select="$index"/></xsl:otherwise>
    </xsl:choose>
    <xsl:text> </xsl:text>
    <xsl:if test="($index + 1) &lt;= $index_end">
        <xsl:call-template name="FizzBuzz">
            <xsl:with-param name="index" select="$index + 1"/>
            <xsl:with-param name="index_end" select="$index_end"/>
        </xsl:call-template>
    </xsl:if>
</xsl:template>
Фу, какой безвкусный и извращенный лисп.
Для многих задач вкусный, для вышеприведенной не очень.
Рекурсия это более распростаненный метод организации цикла со счетчиком в XSLT.
Однако он же и более ресурсоемкий.

Метод Пиза позволяет избавиться от рекурсии и тем самым оптимизировать выполнение шаблона. При этом, надо учитывать, что в реальных задачах можно в качестве содержимого переменной $set использовать не набор узлов обрабатываемого XML-документа, а набор узлов самого шаблона, записав переменную как
<xsl:variable name="set" select="document('')//node()"/>
, и тогда наш цикл не будет зависеть от обрабатываемого документа.
(В данной, чисто условной задаче, это к сожалению, невозможно, из-за малого числа узлов в XSL-шаблоне цикл доходит только до 36. Но тут можно вспомнить о том, что каждый комментарий в шаблоне тоже считается узлом. Поэтому можно написать комментариев к каждой строке, и добить всеь шаблон пустыми комментариями в конце, чтобы цикл дошел до ста, пример ниже)

Ну и если уж совсем удариться в оптимизацию, то имеет смысл вынести деление в отдельные переменные и оптимизировать первое условие, проверяя в нем сначала делимость на 5 а потом только делимость на 3.

Тогда получится следующее:
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
	<xsl:output method="text" encoding="UTF-8"/>

	<!--Программа FizzBuzz-->

	<xsl:template match="/">

		<!--Выберем все узлы текущего документа-->
		<xsl:variable name="set" select="document('')//node()"/>

		<!--Создадим цикл со счетчиком-->
		<xsl:for-each select="$set[position() <= 100]">

			<!--Вычислим значение остатка от деления текущего числа на 5-->
			<xsl:variable name="mod5" select="position() mod 5"/>

			<!--Вычислим значение остатка от деления текущего числа на 3-->
			<xsl:variable name="mod3" select="position() mod 3"/>

			<!--Проверим выполение условий задачи-->
			<xsl:choose>

				<!--Если число кратно и пяти и трем то выведем "FizzBuzz"-->
				<xsl:when test="$mod5 = 0 and $mod3 = 0">FizzBuzz</xsl:when>

				<!--Если число кратно трем то выведем "Buzz"-->
				<xsl:when test="$mod3 = 0">Buzz</xsl:when>

				<!--Если число кратно пяти то выведем "Fizz"-->
				<xsl:when test="$mod5 = 0">Fizz</xsl:when>

				<!--Во всех остальных случаях выведем само число-->
				<xsl:otherwise>
					<xsl:value-of select="position()"/>
				</xsl:otherwise>
			</xsl:choose>

			<!--Выведем пробел-->
			<xsl:text> </xsl:text>

		</xsl:for-each>

	</xsl:template>
 <!-- -->
 <!-- -->
 <!-- -->
 <!-- -->
 <!-- -->
 <!-- -->
 <!-- -->
 <!-- -->
 <!-- -->
 <!-- -->
 <!-- -->
 <!-- -->
 <!-- -->
 <!-- -->
 <!-- -->
 <!-- -->
 <!-- -->
 <!-- -->
 <!-- -->
 <!-- -->
 <!-- --> 
</xsl:stylesheet>

Да, это извращение чистой воды, но… на профайлере ваш способ выполняется примерно 0,0184 с, а мой — 0,0104 с. При этом глубина стека в вашем варианте составляет 301, а в моем — 4.
По-моему это профит, однозначно! :)

Ну то есть я понимаю что именно в данной задаче подобная оптимизация не имеет никакого практического смысла, но мои рассуждения вообще-то к тому, что не стоит всегда пользоваться только стандартными походами. В одном из проектов учет подобных нюансов серёзно облегчил жизнь серверу, а в конечном итоге и мне :-)
В некоторых задачах хвостовая рекурсия дает поразительную производительность. Например, если требуется сделать конвертер из плоского представления в древовидное (например преобразовать структуру заголовков XHTML документа — h1, h2 и т.д.). В случае же с простым циклом конечно же хвостовая рекурсия проиграет, но лишь совсем немного, хотя это зависит от оптимизатора XSLT процессора.

Вот из-за того, что в XSLT нет нормального цикла по количеству итераций, приходится извращаться с методом Пиза, а если нужно обработать миллион итераций, будете формировать гигантский документ, состоящий из миллиона узлов? Хотя, XSLТ не предназначен для таких задач, лучше при формировании обрабатываемого документа сделать это более легким способом, и дать на обработку уже эти данные.
Если _действительно_ требуется целый миллион итераций в XSLT, то вероятнее всего имеет место быть некая серьезная ошибка в постороении системы.
Потому что в таком случае действительно единственно верный способ — это учесть такую потребность еще на этапе формирования документа. Тут я с вами совершенно согласен.
А вот так не нужно делать, никто не оценит твои знания jQuery:
<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.4.4/jquery.min.js"></script>
<script>
$(function() {
$.fn.FizzBuzz = function() {
  var index = $(this).data('FizzBuzzIndex');
  if ( ! index) index = 1;
  var index_end = $(this).data('FizzBuzz');
  var out = '';
  if (index % 3 == 0) out += 'Fizz';
  if (index % 5 == 0) out += 'Buzz';
  if (out == '') out = index;
  $(this).append(out + ' ');
  index ++;
  $(this).data('FizzBuzzIndex', index);
  if (index <= index_end) $(this).FizzBuzz();
}
$('.FizzBuzz').FizzBuzz();
});
</script>
<div class="FizzBuzz" data-FizzBuzz="100"></div>

Вот, PERL, попросил запостить 8-))
use 5.010;
say join ' ', map {
  sub {
    return 'FizzBuzz' unless $_ % 3 or $_ % 5;
    return 'Fizz'   unless $_ % 3;
    return 'Buzz'   unless $_ % 5;
    return $_;
  }->();
} 1..100;

* This source code was highlighted with Source Code Highlighter.
OCaml тоже просил
let fizzbuzz n =
  let fb n =
    match n mod 3, n mod 5 with
      | 00 -> "FizzBuzz"
      | 0, _ -> "Fizz"
      | _, 0 -> "Buzz"
      | _, _ -> string_of_int n in
  let rec loop = function
    | n' when n'<=->  fb n' :: loop (n'+1)
    | _ -> [] 
  in loop 1
 
let _ = print_endline (String.concat " " (fizzbuzz 100))
 
Ну на решения я уже насмотрелся. Покажите мне уже, что же пишут люди, которые не умеют программировать?
VB
For i = 1 To 101: Print IIf((i Mod 3)*(i Mod 5), i, IIf((i Mod 5), "Fizz", "Buzz")): Next

Посту уже 2 года, никто и не заметит мой след в истории
неудержался чтобы не откапать мамонта в истори
for i in ("FizzBuzz" if i % 3 + i % 5 == 0 else "Fizz" if i % 3 == 0 else "Buzz" if i % 5 == 0 else i for i in xrange(100)):
    print i
Попинаем мамонта однострочниками. Да, вариант не для собеседования по следующим причинам: легко запутаться кандидату, легко придраться работодателю.
[{(1, 1): 'FizzBuzz', (1, 0): 'Fizz', (0, 1): 'Buzz'}.get( tuple([not x%y for y in (3, 5)]), x ) for x in xrange(1, 101)]
Я вообще дизайнер, но вот, вроде, решил задачку на Go:

package main

import "fmt"

func main() {
    for i := 1; i <= 100; i++ {
        if i % 3 == 0 && i % 5 > 0 {
            fmt.Println("Fizz")
        } else if i % 3 > 0 && i % 5 == 0 {
            fmt.Println("Buzz")                
        } else if i % 3 == 0 && i % 5 == 0 {
            fmt.Println("FizzBuzz")
        } else {
            fmt.Println(i)
        }
    }   
}


Ушло минут пять.
Объясните, пожалуйста, в чем подвох, т. к. у меня практически нулевой опыт в программировании.

Ты просто слишком умный дизайнер.

Вообще задачка не на кодинг даже, а на элементарную логику. Нужно всего лишь выразить логическую цепочку в коде.
Я еще только учусь, набросал работающий вариант за 5 минут. Могу ли я претендовать на место junior'а в IT-компании? :)
T-SQL с извращениями и без
with a(id)
	as (select 1 as id
	union all
	select id + 1 from a where id < 100)
select
	isnull(
		nullif(case when id % 3 = 0 then 'fizz' else '' end
				+ case when id % 5 = 0 then 'buzz' else '' end,
			''),
		id) as v1,
	case
		when id % 15 = 0 then 'fizzbuzz'
		when id % 5 = 0 then 'buzz'
		when id % 3 = 0 then 'fizz'
		else cast(id as varchar(3)) end as v2
from a
order by id;
UFO just landed and posted this here
Не удержался, 134 секунды :)
for (let i = 1; i < 100 + 1; i++) {
	let o3 = i % 3;
	let o5 = i % 5;
	let output = false;
	output = (o3 === 0) ? 'Fizz' : '';
	output += (o5 === 0) ? 'Buzz' : '';
	output = (!output) ? i : output;
	console.log(output);
}
UFO just landed and posted this here
Раз речь идёт о задании на собеседовании, то важно, чтобы код был читаемый, а вывод — тестируемый. Ещё неплохо бы показать возможности языка.
Вот мой вариант: в виде функции с доктестами. Входные значения: верхний предел и словарь вида 'слово': делитель для возможностью расширения значений для замены. Вывод в виде списка. Python.
def fizzbuzz(substitutes={'Fizz': 3, 'Buzz': 5}, upper_limit=100):
    """
    Replaces the numbers divisible
        by 3 with Fizz
        by 5 with Buzz
        by both by FizzBuzz
        and so on...
    >>> fizzbuzz({'Fizz': 3, 'Buzz': 5}, 15)[5:]
    ['Fizz', 7, 8, 'Fizz', 'Buzz', 11, 'Fizz', 13, 14, 'FizzBuzz']

    >>> fizzbuzz({'Fizz': 3, 'Buzz': 5, 'Fuzz': 7}, 200)[100:110]
    [101, 'Fizz', 103, 104, 'FizzBuzzFuzz', 106, 107, 'Fizz', 109, 'Buzz']
    """
    result = []
    for number in range(1, upper_limit + 1):
        replacement = ''
        for substitute, divisor in substitutes.items():
            replacement += substitute if number % divisor == 0 else ''
            number_or_replacement = number if not replacement else replacement
        result.append(number_or_replacement)
    return result

UFO just landed and posted this here
UFO just landed and posted this here

Я не знаю, может я один такой, когда я прочитал про задание с числами кратными 3 и 5 я сразу представил что надо просто проверять на остаток от деления, но я не вспомнил как записать эту операцию(точнее сказать не сразу вспомнил). Я точно знаю что не вспомнил я ее просто потому что за ближайшие два месяца не использовал в коде. Я точно знаю что мне достаточно легкого намека и я вспомню что это %, но почему-то думаю что на собеседовании я растерялся бы

UFO just landed and posted this here

Да это все понятно, я просто не храню это в своей голове если долго не использую. Так и получается что порой впадаю в ступор от элементарных вещей, хотя секунду назад писал более сложный код

Люди! Где правда?! С одной стороны меня пугают что куда ни приди - везде гуглояндекс где ты должен отстоять 10 раундов против МС олимпиадного программирования, ПриМата-токсика (ессно, без шансов). С другой - вот этими циклами 1-10. А как на самом деле-то?

// звиняйте ежели байан :)
IntStream.iterate(1, n -> n + 1).limit(100)
  .forEach(n -> {
    if (n % 3 == 0 && n % 5 == 0) System.out.println("FizzBuzz");
    else if (n % 3 == 0) System.out.println("Fizz");
    else if (n % 5 == 0) System.out.println("Buzz");
    else System.out.println(n);
  });

Прочитал статью, продумал в голове код, посмотрел ответы - сходится. А все равно страшно, что я "ни в зуб ногой" в программирование - рекурсии я например никогда не использовал, с ней могут быть трудности, мой основной язык - шарп, и иногда мне даже приходится сверяться в гугле как писать циклы например на питоне, потому что я хоть и имею с ним опыт, но я даже PowerShell язык чаще использую чем его. Обидно

Если задача решена рекурсией, это минус, потому что это не оптимально.
Лучше без неё.
Например — факториал.

Articles