Введение

В наших недавних усилиях по сбору каталогов самых коротких решений для стандартных упражнений по программированию, вот первая в истории PPCG ванильная задача FizzBuzz. Если вы хотите увидеть другие проблемы каталога, есть «Hello World!» и "Является ли это число простым?" ,

Вызов

Напишите программу, которая печатает десятичные числа от 1 до 100 включительно. Но для кратных трех выведите «Fizz» вместо числа, а для кратных пяти - «Buzz». Для чисел, кратных трем и пяти, выведите «FizzBuzz».

Выход

Выводом будет список чисел (а также Fizzes, Buzzes и FizzBuzzes), разделенных новой строкой (либо, \nлибо \r\n). Конечный перевод строки является приемлемым, но ведущий перевод строки - нет. Помимо выбора новой строки, вывод должен выглядеть точно так:

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

Единственным исключением из этого правила является постоянный вывод интерпретатора вашего языка, который не может быть подавлен, например приветствие, цветовые коды ANSI или отступы.

Дальнейшие правила

• Речь идет не о поиске языка с кратчайшим подходом для игры в FizzBuzz, а о поиске кратчайшего подхода на каждом языке. Поэтому ни один ответ не будет помечен как принятый.

• Материалы оцениваются в байтах в соответствующей существующей кодировке, обычно (но не обязательно) UTF-8. Некоторые языки, такие как папки, немного сложнее оценить - если есть сомнения, пожалуйста, спросите на Meta.

• Ничто не может быть напечатано в STDERR.

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

  Обратите внимание, что должен быть переводчик, чтобы представление можно было проверить. Разрешается (и даже поощряется) самостоятельно писать этот переводчик для ранее не реализованного языка.

• Если выбранный вами язык является тривиальным вариантом другого (потенциально более популярного) языка, на который уже есть ответ (например, диалекты BASIC или SQL, оболочки Unix или тривиальные производные Brainfuck, такие как Alphuck и ???), рассмотрите возможность добавления примечания к существующему Ответьте, что такое же или очень похожее решение является самым коротким на другом языке.

• Поскольку вывод является фиксированным, вы можете жестко закодировать вывод (но это может быть не самый короткий вариант).

• Вы можете использовать уже существующие решения, если вы указали автора оригинальной программы.

• Стандартные лазейки запрещены.

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

Каталог

var QUESTION_ID=58615;var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk";var OVERRIDE_USER=30525;var answers=[],answers_hash,answer_ids,answer_page=1,more_answers=true,comment_page;function answersUrl(index){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(index,answers){return"https://api.stackexchange.com/2.2/answers/"+answers.join(';')+"/comments?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:true,success:function(data){answers.push.apply(answers,data.items);answers_hash=[];answer_ids=[];data.items.forEach(function(a){a.comments=[];var id=+a.share_link.match(/\d+/);answer_ids.push(id);answers_hash[id]=a});if(!data.has_more)more_answers=false;comment_page=1;getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:true,success:function(data){data.items.forEach(function(c){if(c.owner.user_id===OVERRIDE_USER)answers_hash[c.post_id].comments.push(c)});if(data.has_more)getComments();else if(more_answers)getAnswers();else process()}})}getAnswers();var SCORE_REG=/<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;var OVERRIDE_REG=/^Override\s*header:\s*/i;function getAuthorName(a){return a.owner.display_name}function process(){var valid=[];answers.forEach(function(a){var body=a.body;a.comments.forEach(function(c){if(OVERRIDE_REG.test(c.body))body='<h1>'+c.body.replace(OVERRIDE_REG,'')+'</h1>'});var match=body.match(SCORE_REG);if(match)valid.push({user:getAuthorName(a),size:+match[2],language:match[1],link:a.share_link,});else console.log(body)});valid.sort(function(a,b){var aB=a.size,bB=b.size;return aB-bB});var languages={};var place=1;var lastSize=null;var lastPlace=1;valid.forEach(function(a){if(a.size!=lastSize)lastPlace=place;lastSize=a.size;++place;var answer=jQuery("#answer-template").html();answer=answer.replace("{{PLACE}}",lastPlace+".").replace("{{NAME}}",a.user).replace("{{LANGUAGE}}",a.language).replace("{{SIZE}}",a.size).replace("{{LINK}}",a.link);answer=jQuery(answer);jQuery("#answers").append(answer);var lang=a.language;lang=jQuery('<a>'+lang+'</a>').text();languages[lang]=languages[lang]||{lang:a.language,lang_raw:lang.toLowerCase(),user:a.user,size:a.size,link:a.link}});var langs=[];for(var lang in languages)if(languages.hasOwnProperty(lang))langs.push(languages[lang]);langs.sort(function(a,b){if(a.lang_raw>b.lang_raw)return 1;if(a.lang_raw<b.lang_raw)return-1;return 0});for(var i=0;i<langs.length;++i){var language=jQuery("#language-template").html();var lang=langs[i];language=language.replace("{{LANGUAGE}}",lang.lang).replace("{{NAME}}",lang.user).replace("{{SIZE}}",lang.size).replace("{{LINK}}",lang.link);language=jQuery(language);jQuery("#languages").append(language)}}

body{text-align:left!important}#answer-list{padding:10px;width:290px;float:left}#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table>

Python 2, 56

i=0;exec"print i%3/2*'Fizz'+i%5/4*'Buzz'or-~i;i+=1;"*100

Гексагония , 91 байт

Спасибо за награду :)

Вау, я бы никогда не подумал, что смогу победить решение Мартина о гексагонии . Но - кто бы мог подумать - я сделал это. После нескольких дней неудачи, потому что у меня не было ни гексагонического колорера, ни эзотерики, чтобы проверить мое решение. Я неправильно понял несколько аспектов спецификации, поэтому я создал несколько неправильных «решений», просто используя ручку и бумагу и текстовый редактор. Ну, наконец-то я преодолел свою лень и клонировал оба репозитория, скачал VisualStudio и скомпилировал их. Ух, какие они полезные инструменты! Как вы можете видеть, я далеко не тот, кого вы бы назвали программистом (я имею в виду, давай! У меня даже не было установленного VisualStudio, и я почти не знаю, как скомпилировать программу);)

Мне все еще потребовалось время, чтобы найти рабочее решение, и оно довольно забито и хаотично, но вот оно во всей красе:

Fizzbuzz в размере 6 шестиугольника:

3}1"$.!$>)}g4_.{$'))\<$\.\.@\}F\$/;z;u;<%<_>_..$>B/<>}))'%<>{>;e"-</_%;\/{}/>.\;.z;i;..>(('

Гексагональная компоновка:

      3 } 1 " $ .
     ! $ > ) } g 4
    _ . { $ ' ) ) \
   < $ \ . \ . @ \ }
  F \ $ / ; z ; u ; <
 % < _ > _ . . $ > B /
  < > } ) ) ' % < > {
   > ; e " - < / _ %
    ; \ / { } / > .
     \ ; . z ; i ;
      . . > ( ( '

И прекрасное исполнение, благодаря Timwi's Hexagony Colorer :

Итак, вот 110-секундная GIF-анимация со скоростью 2 кадра в секунду, показывающая ход программы во время первых 6 чисел 1, 2, Fizz, 4, Buzz, Fizz, первых 220 тактов программы (нажмите на изображение для просмотра в полном размере):

Боже мой, благодаря программному обеспечению Natron, анимация указателя была все еще утомительной, но управляемой. Сохранение 260 изображений в памяти было менее забавным. К сожалению, EsotericIDE не может сделать это автоматически. В любом случае, наслаждайтесь анимацией!

В конце концов, как только вы обернетесь вокруг модели памяти и довольно нелогичного переноса путей, которые пересекают границы шестиугольника, с гексагонией работать не так уж и сложно. Но игра в гольф это может быть боль в заднице. ;)

Это было весело!

Лабиринт , 94 байта

"):_1
\ } 01/3%70.105
" :   @ "     .
"  =";_""..:221
+  _
"! 5%66.117
_:= "     .
="*{"..:221

Sub-100! Это было весело.

объяснение

Давайте начнем с краткого учебника по Лабиринту - не стесняйтесь пропустить это, если вы уже знакомы с основами:

• Лабиринт имеет два стека - основной и вспомогательный. Оба стека имеют бесконечное число нулей внизу, например, +в пустом стеке добавляются два нуля, что приводит к нулю.

• Поток управления в Лабиринте определяется переходами, которые смотрят на вершину стека, чтобы определить, куда идти дальше. Отрицательное означает поворот налево, ноль означает прямое движение вперед, а положительное означает поворот направо ... но если мы врезаемся в стену, мы меняем направление. Например, если возможны только прямое движение вперед и поворот налево, но вершина стека положительна, то, поскольку мы не можем повернуть направо, мы поворачиваем налево.

• Цифры в Лабиринте всплывают xи толкаются 10*x + <digit>, что позволяет легко создавать большие числа. Однако это означает, что нам нужна инструкция, чтобы нажать 0, чтобы начать новый номер, который находится _в Лабиринте.

Теперь давайте перейдем к реальному коду!

красный

Выполнение начинается "в верхнем левом углу, который является NOP. Далее идет ), который увеличивает вершину стека, нажимая 1 на первом проходе и увеличивая nна каждом следующем проходе.

Затем мы дублируем nс :. Так nкак положительно, мы поворачиваем направо, выполняя }(смещение вершины основного стека к вспомогательному) и :. Мы зашли в тупик, поэтому мы поворачиваемся и выполняем }и :еще раз, оставляя стеки как

Main [ n n | n n ] Aux

Еще раз, nположительно, и мы поворачиваем направо, выполняя _101/который делит nна 101. Если nэто 101, то n/101 = 1и мы превращаемся в @, который завершает программу. В противном случае наша текущая ситуация

Main [ n 0 | n n ] Aux

Апельсин 1 (мод 3)

3превращает верхний ноль в 3 ( 10*0 + 3 = 3) и %выполняет по модулю. Если n%3положительный, мы поворачиваем направо в желтый ". В противном случае мы выполняем 70.105.122:.., какие выводы Fizz. Обратите внимание, что нам не нужно вставлять новые нули, _поскольку n%3в этом случае ноль был равен нулю, поэтому мы можем использовать бесконечные нули в нижней части стека. Оба пути снова встречаются в голубом.

Светло-синий

В настоящее время вершина стека находится в n%3положительном положении, поэтому _;просто нажимает ноль и сразу же выталкивает его, чтобы убедиться, что мы идем прямо вперед, а не поворачиваемся в @. Затем мы используем, =чтобы поменять вершины основного и вспомогательного стеков, давая:

Main [ n | n%3 n ] Aux

Апельсин 2 (мод 5)

Это аналогично предыдущей ситуации, за исключением того, что 66.117.122:..выводит, Buzzесли n%5равен нулю.

Темно-синий

Предыдущий раздел оставляет стеки как

Main [ n%5 | n%3 n ] Aux

{сдвигает n%3назад к основному стеку и *умножает два модуля.

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

Main [ n 0 | 0 ] Aux

В противном случае, если оба модуля отличны от нуля, то произведение отлично от нуля, и мы превращаемся в зеленый. =меняет вершины стеков, давая

Main [ n | (n%5)*(n%3) ] Aux

после чего мы используем :для дублирования n, повернуть направо, а затем использовать !для вывода n.

Фиолетовый

На этом этапе основной стек имеет один или два элемента, в зависимости от того, какой путь был выбран. Нам нужно избавиться от нуля от желтого пути, и для этого мы используем +, что выполняется n + 0в некотором порядке в обоих случаях. Наконец, \выводится новая строка, и мы снова в начале.

Каждая итерация добавляет дополнительный (n%5)*(n%3)к вспомогательному стеку, но в противном случае мы делаем то же самое снова и снова.

Perl 5, 49 байт

46 байтов сценария + 3 байта -E"..."

Использование say(что требует -E"...") может уменьшить это до 46 байтов, так как sayавтоматически включает перевод строки (Спасибо @Dennis !):

say'Fizz'x!($_%3).Buzz x!($_%5)||$_ for 1..100

Perl 5, 50 байт

print'Fizz'x!($_%3).Buzz x!($_%5)||$_,$/for 1..100

Рубин, 50 байтов

Требуется версия 1.8, которая кажется популярной среди игроков в гольф:

1.upto(?d){|n|puts'FizzBuzz
'[i=n**4%-15,i+13]||n}

В современном Ruby, вы заменяете ?dс 100для раствора 51 байт.

Это, кажется, мировой рекорд.

Java, 130 байт

Это для последних версий Java (7+). В более старых вы можете побриться, используя enumтрюк, но я не думаю, что логика становится короче этой (86 внутри main).

class F{public static void main(String[]a){for(int i=0;i++<100;)System.out.println((i%3<1?"Fizz":"")+(i%5<1?"Buzz":i%3<1?"":i));}}

Пиф, 30

VS100|+*!%N3"Fizz"*!%N5"Buzz"N

Попробуй здесь

Объяснение:

VS100|+*!%N3"Fizz"*!%N5"Buzz"N
VS100                            : for N in range(1,101)
     |                           : logical short-circuiting or
      +*!%N3"Fizz"               : add "Fizz" * not(N % 3)
                                 : Since not gives True/False this is either "" or "Fizz"
                  *!%N5"Buzz"    : Same but with 5 and Buzz
                             N   : Otherwise N
                                 : The output of the | is implicitly printed with a newline

Retina , 317 139 134 132 70 63 60 55 байт

.100{`^
_
*\(a`(___)+
Fi;$&
\b(_{5})+$
Bu;
;_*
zz
'_&`.

Попробуйте онлайн!

объяснение

.100{`^
_

Это .глобальный флаг молчания, который отключает неявный вывод в конце программы. 100{оборачивает остальную часть программы в цикл, который выполняется за 100 итераций. Наконец, сам этап просто вставляет _в начало строки, что эффективно увеличивает счетчик унарного цикла.

*\(a`(___)+
Fi;$&

Больше настроек. *\(оборачивает оставшуюся часть программы в группу, печатает ее результат с завершающим переводом строки, но также помещает всю группу в пробный запуск, что означает, что ее результат будет отброшен после печати, так что наш счетчик цикла фактически не изменяется , aэто пользовательский модификатор регулярного выражения, который привязывает регулярное выражение ко всей строке (что экономит байт при использовании ^и $явно).

Сама атомная стадия заботится о себе Fizz. Делимость на 3легко проверяется в унарном порядке: просто проверьте, можно ли записать число как повторение ___. Если это так, мы добавляем Fi;к строке. Точка с запятой такова, что перед номером на следующей стадии все еще стоит граница слова. Если бы мы повернули линию в Fizz___...положение между zи _не рассматривали бы границу, потому что регулярное выражение рассматривает и буквы, и подчеркивания как символы слова. Тем не менее, точка с запятой также позволяет нам удалить zzдубликаты из Fizzи Buzz.

\b(_{5})+$
Bu;

Мы делаем то же самое для делимости на 5и Bu;, хотя нам не нужно хранить эти значения _в это время. Таким образом, мы получили бы такие результаты, как

_
__
Fi;___
____
Bu;
Fi;______
...
Fi;Bu;
...

Это позволяет очень легко избавиться от подчеркивания только в тех строках, которые содержат Fizz, а также заполнить zzs:

;_*
zz

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

'_&`.

&указывает на условие: этот этап выполняется только в том случае, если строка содержит подчеркивание. Поэтому Fizz, Buzzи FizzBuzzитерации остаются нетронутыми. Во всех других итерациях (то есть тех, которые не делятся ни на 3, ни на 5), мы просто подсчитываем количество символов, преобразуя результат в десятичное число.

гс2 , 1

f

Цитата из Mauris, создатель GS2:

Я хотел переиграть goruby «s 1 байт Hello, world!, так что ... Печатает "1\n2\nFizz\n4\nBuzz\n...". :)

Обновление : добавлен 27-байтовый ответ , который не используется f.

Perl 5, 45 байт

say((Fizz)[$_%3].(Buzz)[$_%5]or$_)for+1..100

Требуется -Eопция, которая считается за единицу. Это должно быть запущено из командной строки, то есть:

perl -Esay((Fizz)[$_%3].(Buzz)[$_%5]or$_)for+1..100

Котировки вокруг команды не нужны, если один избегает использования пробелов, или любых других символов , которые могут выступать в качестве командной строки разделителей ( |, <, >, &и т.д.).

Perl 5, 48 байт

print+(Fizz)[$_%3].(Buzz)[$_%5]||$_,$/for 1..100

Если параметры командной строки учитываются как один каждый, -lбудет сохранен один байт (путем замены $/). Однако по классическим правилам Perlgolf это будет считаться 3: один для -, один для lи один для необходимого пространства.

пчелиный воск ,104 89 81 байт

Более плотная упаковка позволила отрезать еще 8 байтов.

Самое короткое решение (81 байт), тот же программный поток, другая упаковка.

p?@<
p?{@b'gA<
p@`zzuB`d'%~5F@<f`z`<
 >~P"#"_"1F3~%'d`Fiz`b
 d;"-~@~.<
>?N@9P~0+d

Изменение концепции позволило мне сократить код на 15 байт. Я хотел избавиться от теста двойной моды 5 в решении, поэтому я применил флаг.

Краткое объяснение:

если n%3=0Fizz будет напечатан, и флаг будет установлен. Флаг реализуется простым нажатием верхнего значения lstack на gstack (инструкция f).

Если n%5=0, то либо n%3=0(случай FizzBuzz), либо n%3>0(случай Buzz). В обоих случаях печатается Buzz, а флаг сбрасывается путем выталкивания стека, пока он не опустеет (инструкция ?).

Теперь интересные случаи:

Если n%5>0, то или у нас n%3=0(печать случая Fizz, n не должен быть напечатан) или n%3>0(Fizz не был напечатан, поэтому n должен быть напечатан). Время проверить флаг. Это достигается путем нажатия длины gstack поверх gstack (инструкция A). Если n%3 was 0тогда длина gstack> 0. Если n%3 was >0длина gstack равна 0. Простой условный переход гарантирует, что n будет напечатан, только если длина gstack была 0.

Опять же, после печати любого из n, Fizz, и / или Buzz и новой строки, gstack появляется дважды, чтобы убедиться, что он пуст. gstack либо пуст [], что приводит к [0]после инструкции A(длина проталкивания gstack на gstack), либо содержит один ноль ( [0]результат n% 3), что приводит к тому [0 1], что [0] имеет длину 1. Выдавление из пустой стек не меняет стек, поэтому его можно всплывать дважды.

Если вы посмотрите поближе, то увидите, что в принципе я сложил

>      q
d`Fizz`f>

в

<f`z`<
d`Fiz`b

что помогает избавиться от всего потерянного пространства между Aи <в конце следующей строки в более старом решении ниже:

q?{@b'gA<       p      <

Новое концептуальное решение (89 байт), включая анимационное объяснение:

q?@ <
 q?{@b'gA<       p      <
p?<@`zzuB`b'%~5F@<f`zziF`b'<
>N@9P~0+.~@~-";~P"#"_"1F3~%d

Гексагональная компоновка:

   q ? @   <
    q ? { @ b ' g A <               p             <
 p ? < @ ` z z u B ` b ' % ~ 5 F @ < f ` z z i F ` b ' <
> N @ 9 P ~ 0 + . ~ @ ~ - " ; ~ P " # " _ " 1 F 3 ~ % d

Анимация первых 326 тиков со скоростью 2 кадра в секунду с локальными и глобальными стеками и выводом в STDOUT.

Для сравнения ниже приведены наложения путей более старого, более сложного решения. Может быть, это также более красивое решение, с визуальной точки зрения;)

> <> , 68 66 65 64 байта

1\2+2foooo "Buzz"<
o>:::3%:?!\$5%:?!/*?n1+:aa*)?;a
o.!o"Fizz"/oo

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

Вы можете попробовать это здесь .

Один байт сохранен благодаря Sp3000, а другой - рандоме. Большое спасибо!

GS2 , 28 27 (без f)

Hex:

1b 2f fe cc 04 46 69 7a 7a 09 07 42 75 7a 7a 19 06 27 2d d8 62 32 ec 99 dc 61 0a

Объяснение:

1b    100
2f    range1 (1..n)
fe    m: (map rest of program)

cc    put0 (pop and store in register 0)
04    string-begin
Fizz
09    9
07    string-separator
Buzz
19    25
06    string-end-array (result: ["Fizz"+chr(9) "Buzz"+chr(25)])

27    right-uncons
2d    sqrt
d8    tuck0 (insert value of register 0 under top of stack)
62    divides
32    times (string multiplication)
ec    m5 (create block from previous 5 tokens, then call map)

99    flatten
dc    show0 (convert register 0 to string and push it)
61    logical-or
0a    newline

Встраивание 3 и 5 в строковую константу не работает, потому что \x05завершает строковые литералы.

Примечание: эта проблема может быть решена в 1 байт с помощью gs2 с помощью встроенного f.

C 85 байт

i;main(){for(;i++<=99;printf("%s%s%.d\n",i%3?"":"Fizz",i%5?"":"Buzz",(i%3&&i%5)*i));}

-2 благодаря брезгливым.

CJam, 35 байт

100{)_[Z5]f%:!"FizzBuzz"4/.*s\e|N}/

Попробуйте онлайн в интерпретаторе CJam .

Как это устроено

100{)_[Z5]f%:!"FizzBuzz"4/.*s\e|N}/
100{                             }/  For each integer I between 0 and 99:
    )_                                 Increment I and push a copy.
      [Z5]                             Push [3 5].
          f%                           Map % to push [(I+1)%3 (I+1)%5].
            :!                         Apply logical NOT to each remainder.
              "FizzBuzz"4/             Push ["Fizz" "Buzz"].
                          .*           Vectorized string repetition.
                            s\         Flatten the result and swap it with I+1.
                              e|       Logical OR; if `s' pushed an empty string,
                                       replace it with I+1.
                                N      Push a linefeed.

MUMPS, 56 54 байта

f i=1:1:100 w:i#5=0 "Fizz" w:i#3=0 "Buzz" w:$X<3 i w !

w:$X<3 iВы спросите, что это за штука? $Xявляется магической переменной («встроенной»), которая хранит горизонтальную позицию выходного курсора (в виде количества символов от левого края терминала). wэто сокращенная форма WRITEкоманды. Синтаксис command:condition argsпостусловный - «если condition, то делай command args».

Таким образом, мы проверяем, был ли выходной курсор передвинут более чем на два символа (что будет означать, что по крайней мере один из "Fizz"или "Buzz"был записан в терминал), и если нет, записывает iв терминал. $XПеременный - и , следовательно, этот вид глубокой неотделимости от терминала - это первый класс особенность свинки. Хлоп.

Желе , 24 20 байт

³µ3,5ḍTị“¡Ṭ4“Ụp»ȯµ€G

Попробуйте онлайн!

Как это устроено

³µ3,5ḍTị“¡Ṭ4“Ụp»ȯµ€G  Main link. No input.

³                     Yield 100.
 µ                    Begin a new, monadic chain.
                 µ€   Apply the preceding chain to all integers n in [1, ..., 100].
  3,5ḍ                Test n for divisibility by 3 and 5.
      T               Get all truthy indices.
                      This yields [1] (mult. of 3, not 5), [2] (mult. of 5, not 3),
                      [1, 2] (mult. of 15) or [].
        “¡Ṭ4“Ụp»      Yield ['Fizz', 'Buzz'] by indexing in a dictionary.
       ị              Retrieve the strings at the corr. indices.
                ȯ     Logical OR hook; replace an empty list with n.
                   G  Grid; join the list, separating by linefeeds.

брейкфук, 206 байт

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

отформатирован:

++>+++++>>>>>
++++++++++[>+>>+>>+>+<<<[++++<-<]<,<,-<-<++<++++[<++>++++++>]++>>]
>
[
  +
  [
    [<<]
    <[>>]
    +++<
    [
      Fizz
      <.<.<..
      [>]
    ]
    <<-
    [
      >>>
      [
        ,>>[<]
        >[--.++<<]
        >
      ]
    ]
    +++++<
    [
      Buzz
      +[-----.++++<<]
      >>+..
      <-
      [>]
    ]
    <[->>,>+>>>->->.>]
    <<
  ]
  <[>+< <<,<->>>+]
  <
]

Попробуйте онлайн

Расположение памяти

0 a 122 105 70 b f 0 t d1 s d2 c d 10 0

где fциклы на 3, bциклы на 5, d1это одна цифра, d2это десятки цифр, sэто флаг для того, чтобы печатать десятки цифр, dциклы на 10, cэто пространство для копирования d, tэто рабочее пространство, которое содержит 0 или ненужные данные или флаг для не -делится на 3 и aопределяет завершение программы путем смещения указателя после того, как Buzz был напечатан 20 раз.

C #, 128 126 125 124 байтов

class A{static void Main(){for(var i=0;i++<100;)System.Console.Write("{0:#}{1:;;Fizz}{2:;;Buzz}\n",i%3*i%5>0?i:0,i%3,i%5);}}

89 байтов без кода шаблона вокруг.

Совершено с использованием условного форматирования в C # .

С двумя разделителями секций ;Fizz или Buzz печатаются, если значение из их условия равно нулю.

Сохранено всего 4 байта благодаря @RubberDuck, @Timwi и @Riokmij.

Clojure, 113 106 101 100 91 байт

Мой первый гольф!

(dotimes[i 100](println(str({2'Fizz}(mod i 3))({4'Buzz}(mod i 5)({2""}(mod i 3)(inc i))))))

Ungolfed:

(dotimes [i 100] ; account for off-by-one later
  (println (str ({2 'Fizz} ; str converts symbols to strings
                 (mod i 3))
                ({4 'Buzz} ; 4 instead of 0 because of off-by-one
                 (mod i 5)
                 ({2 ""} ; shortest way to write when-not
                  (mod i 3)
                  (inc i))))))

Brainfuck , 411 350 277 258 байт

Редактирование:

• -61 байт, сохраняя значения «Fizz Buzz» как «BuziF», «BuziG» и переделывая секцию печати чисел.

• -71 байт, переделав секцию печати чисел по модулю, разделив счетчик циклов и счетчик чисел, и, среди прочего, повторно используя ячейку новой строки в качестве значения мода

• -19 байт, понимая, что в числах FizzBuzz нет нулей. Также добавлено объяснение

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

Попробуйте онлайн!

Вместо того, чтобы проверять, делилось ли само число на 5 или 3, у меня было два счетчика, отслеживающих модуль числа, уменьшая их для каждого числа и распечатывая соответствующее слово, когда они достигли 0.

Как это устроено:

+[-[>+<<]>-]>--  Generate the number 61
[>+>++>++>++++++>+>>>++++++[<<<]>-] Set the tape to multiples of 61
TAPE: 0 0' 61  122 122 110 61  0 0 110
           "=" "z" "z" "n" "="
<+++++[>+>+>->>->++>>>-->>>++[<<<]>>>-]>[>]+++>> Modify values by multiples of 5
TAPE: 0' 5 66  117 122 105 71  3 0 100' 0 0 10
           "B" "u" "z" "i" "G"
Some info:
  5     - Buzz counter
  "Buz" - Buzz printing
  "ziG" - Fizz printing. Modifying the G in the loop is shorter than modifying it outside
  3     - Fizz counter
  0     - This is where the Fizz|Buzz check will be located
  100   - Loop counter
  0     - Number counter. It's not worth it to reuse the loop counter as this.
  0     - Sometimes a zero is just a zero
  10    - Value as a newline and to mod the number by

[ Loop 100 times
  >+<<<  Increment number counter
  -[<]<  Decrement Fizz counter
  [ If Fizz counter is 0
    >+++ Reset the Fizz counter to 3
    >+<< Set the Fizz|Buzz check to true
    -.+<.<.. Print "Fizz"
  [<]<] Sync pointers
  >>-[<<]> Decrement Buzz counter
  [ If Buzz counter is 0
    .>.>.. Print "Buzz"
    >>>>+  Set the Fizz|Buzz check to true
    [<]+++++< Reset the Buzz counter to 5
  ]
  >[>]>> Go to Fizz|Buzz check
  [ If there was no Fizz or Buzz for this number
    TAPE: 3% BuziG 5% 0 Loop Num' 0 10
    [->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]  Mod the number counter by 10
    TAPE: 3% BuziG 5% 0 Loop 0' Num 10-Num%10 Num%10 Num/10
    >[-<+>] Move Num back in place
    >,>[>]< Reset 10-Num%10
    [ For both Num/10 (if it exists) and Num%10
      >-[<+>-----]<--- Add 48 to the number to turn it into the ASCII equivilent
      .,< Print and remove
    ]
    ++++++++++> Add the 10 back
  ]
  <. Print the newline
  <<<<, Remove Fizz|Buzz check
  >- Decrement Loop counter
]

PowerShell, 78 68 61 54 байт

1..100|%{(($t="Fizz"*!($_%3)+"Buzz"*!($_%5)),$_)[!$t]}

_{Изменить: 10 байтов сохранено благодаря feersum}

_{Edit2: понял, что с трюк Feersum, мне больше не нужно формулировать $ t в виде строки кода блоков}

_{Edit3: спас еще 7 байтов благодаря Данко Дурбич}

Подобно иш по духу фондовом Rosetta Код ответа , но golfed вниз совсем немного.

объяснение

1..100|%{...} Создайте коллекцию от 1 до 100, затем для каждого объекта в этой коллекции выполните

(...,$_)создать новую коллекцию из двух элементов: 0) $t=...установить переменную $tравной строке; 1) $_наш текущий номер цикла

"Fizz"*!($_%3)возьмите наше текущее число, измените его на 3, затем НЕ результат. Умножьте «Fizz» на это и добавьте в строку (и аналогично для 5). PowerShell обрабатывает любое ненулевое число как $TRUE, и, следовательно, НЕ ненулевое число равно 0, что означает, что только если наш текущий номер кратен 3, «Fizz» будет добавлен в строку.

[!$t]индексы в коллекцию, которую мы только что создали, на основе значения строки $t- не пусто, напечатайте его, иначе напечатайте наше текущее число

Кроме того, также 54 байта

1..100|%{'Fizz'*!($_%3)+'Buzz'*!($_%5)-replace'^$',$_}

_{Благодаря TesselatingHeckler}

Схожий по концепции, он использует встроенный -replace оператор и регулярное выражение для замены пустой строки ^$с нашим текущим номером. Если строка не пустая, она не переставляется.

Кроме того, также 54 байта

1..100|%{($_,('Fizz'*!($_%3)+'Buzz'*!($_%5))|sort)[1]}

Это та же самая структура цикла, что и выше, но внутри она сортирует пару (n, строка) и полагается на тот факт, что пустая строка сортируется перед числом, а строка FizzBuzz сортируется после числа. Затем он индексирует второй результат сортировки.

JavaScript, 62 байта

for(i=0;++i<101;console.log(i%5?f||i:f+'Buzz'))f=i%3?'':'Fizz'

Я думаю, что это самое короткое решение Javascript сейчас.

C 74 байта

main(i){for(;i<101;puts(i++%5?"":"Buzz"))printf(i%3?i%5?"%d":0:"Fizz",i);}

0Аргумент printfвместо"" рыбный, но , кажется, работает на большинстве платформ я пытаюсь его. putssegfaults, когда вы пытаетесь сделать то же самое. Без этого вы получите 75 байтов.

Есть 73-байтовые решения, которые работают на анархическом гольфе , и я нашел одно, которое копается в нужных местах в Интернете, но они полагаются на поведение платформы. (Как вы уже догадались, это что-то вроде формы puts("Buzz"±...).)

Царапина, 203 185 байт

Согласно этому мета-сообщению, байты считаются из текстового представления в гольфе . Царапина не очень компактна.

sayэто самая близкая вещь к стандартному выводу Scratch: спрайт отображает речевой пузырь, содержащий все, что он говорит. На практике wait n secsпотребуется блок для фактического чтения этого вывода, но для этой задачи этот код удовлетворяет требованиям.

R, 88 83 77 71 70 байт

Я уверен, что это может быть улучшено ... и это было заслужено @flodel. Еще пара байтов сохранена благодаря предложению @njnnja и другому от @ J.Doe

x=y=1:100;y[3*x]='Fizz';y[5*x]='Buzz';y[15*x]='FizzBuzz';write(y[x],1)

Haskell, 84 байта

main=mapM f[1..100]
f n|d<-drop.(*4).mod n=putStrLn$max(show n)$d 3"Fizz"++d 5"Buzz"

Приблизиться к 81 байт henkma в , но не совсем там еще.

d = drop.(*4).mod nключ здесь: d 3 "Fizz"есть drop (n`mod`3 * 4) "Fizz". Это "Fizz"когда n `mod` 30 и в ""противном случае.

PHP, 54 байта

<?for(;$i++<100;)echo[Fizz][$i%3].[Buzz][$i%5]?:$i,~õ;

Действительно для версии 5.5 и выше. Символ õ245, немного перевернутый\n .

Я предполагаю настройки интерпретатора по умолчанию, так как они без каких-либо ini. Если вы не уверены, вы можете отключить свой локальный INI, -nкак вphp -n fizzbuzz.php .

Версия, которая будет работать без ошибок с абсолютно любым файлом конфигурации, составляет 62 байта :

<?php
for(;$i++<100;)echo@([Fizz][$i%3].[Buzz][$i%5]?:$i),"
";

80386 машинный код + DOS, 75 байтов

Hexdump кода:

0D 0A 24 B1 64 33 C0 BA-03 05 BB 00 01 40 50 FE
CE 75 0C 83 EB 04 66 C7-07 42 75 7A 7A B6 05 FE
CA 75 0C 83 EB 04 66 C7-07 46 69 7A 7A B2 03 84
FF 74 0C D4 0A 04 30 4B-88 07 C1 E8 08 75 F4 52
8B D3 B4 09 CD 21 5A 58-E2 C0 C3

Исходный код (синтаксис TASM):

    .MODEL TINY

    .CODE
    .386
    org 100h

MAIN PROC
    db 13, 10, '$'
    mov cl, 100
    xor ax, ax
    mov dx, 503h

main_loop:
    mov bx, 100h
    inc ax
    push ax

    dec dh
    jnz short buzz_done
    sub bx, 4
    mov dword ptr [bx], 'zzuB'
    mov dh, 5
buzz_done:

    dec dl
    jnz short fizz_done
    sub bx, 4
    mov dword ptr [bx], 'zziF'
    mov dl, 3
fizz_done:

    test bh, bh
    jz short num_done

decimal_loop:
    aam;
    add al, '0'
    dec bx
    mov [bx], al
    shr ax, 8
    jnz decimal_loop

num_done:
    push dx
    mov dx, bx;
    mov ah, 9
    int 21h
    pop dx
    pop ax

    loop main_loop
    ret

MAIN ENDP
    END MAIN

Этот код имеет значение от 1 до 100 ax, формируя выходное сообщение от конца к началу. Конец сообщения ( $символ новой строки и символ, который DOS использует для флага конца сообщения) появляется в начале кода:

db 10, 10, '$'

Это выполнено как безвредная инструкция ( or ax, 240ah). Я мог бы поместить его в более обычное место, например, после конца кода, но преимущество по адресу 0x100.

Код также использует 2 дополнительных счетчика:

• Считая от 3 до 0 в dl
• Считая от 5 до 0 в dh

Когда счетчик достигает 0, он выталкивает строку Fizzили Buzzв конец выходного сообщения. Если это произойдет, bxбудет уменьшено, и bhбудет ноль. Это используется как условие для вывода числа в десятичной форме.

Примечание: я использую 32-битные данные здесь. Это не будет работать на компьютере до 386.

Округ Колумбия, 64 62 байта

[[Fizz]P]sI[[Buzz]P]sU[dn]sNz[zdd3%d0=Ir5%d0=U*0<NAPz9B>L]dsLx

Ungolfed:

[[Fizz]P]sI  # macro I: print "Fizz"
[[Buzz]P]sU  # macro U: print "Buzz"
[dn]sN       # macro N: print current stack depth

z            # increase stack depth

[            # Begin macro
  zdd           # Get current stack depth and ducplicate it twice
  3%d0=I        # Check modulo 3 and leave a duplicate. If it's 0, run macro I
  r             # Rotate top two elements, bringing up the stack depth again
  5%d0=U        # Check modulo 5 and leave a duplicate. It it's 0, run macro U
  *             # Multiply the duplicates of modulos of 3 and 5 ...
  0<N           # ... if it's not 0, run macro N
  AP            # Print a newline (`A` is 10)
                # The macro leaves the stack with one more element each time
  z9B>L      # Run macro L if stack depth is less than "ninety eleven" (101)
]         # End macro

dsLx  # store the macro in register L and execute it