1, 2, Fizz, 4, Buzz

148

Введение

В наших недавних усилиях по сбору каталогов самых коротких решений для стандартных упражнений по программированию, вот первая в истории 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>

Бета распад
источник
1
Nothing can be printed to STDERR. Это правда только во время работы или также при компиляции (при условии, что это отдельный шаг?)
AShelly
@AShelly Только при запуске
бета-распад
Я не уверен, что мне нравится тот факт, что вы жестко закодировали 100 в вызове. Таким образом, программа, которая просто генерирует ожидаемый результат, является допустимой записью, но не представляет интереса для этой задачи. Я думаю, что задача должна ожидать, что программа введет количество элементов для вывода.
Тимви
6
@Timwi Хотя я согласен с тем, что это сделает его (чуть-чуть) более интересным, я очень часто видел FizzBuzz строго от 1 до 100 (например, в Википедии и Rosetta Code). Если цель состоит в том, чтобы иметь «канонический» вызов FB, это имеет смысл.
Geobits
58
"Ванильное шипение" звучит восхитительно.
iamnotmaynard

Ответы:

76

Python 2, 56

i=0;exec"print i%3/2*'Fizz'+i%5/4*'Buzz'or-~i;i+=1;"*100
feersum
источник
6
Черт, это кровавый гений. Могу ли я украсть вашу идею умножить строку на результат мода?
AdmBorkBork
@TimmyD Продолжай.
Feersum
15
Другой метод 56 (из здесь ): i=1;exec"print'FizzBuzz'[i%-3&4:12&8-i%5]or i;i+=1;"*100. Кто-нибудь хочет использовать поисковые выражения грубой силы, чтобы попытаться оптимизировать обработку битов?
xnor
1
Очень хорошая техника, мне нравится деление результата по модулю, чтобы сделать его двоичным! У меня есть улучшение, позволяющее сократить ваш метод до 54 символов ... Конечно, я бы не стал публиковать его как ответ без вашего разрешения (так как это ~ 95% вашего ответа);)
Tersosauros
2
@Tersosauros Продолжай ... мой метод не очень сложен для поиска и, без сомнения, был открыт многими людьми.
feersum
76

Гексагония , 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 :

Раскрашенный раствор Hexagony FizzBuzz

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

введите описание изображения здесь

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

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

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

ML
источник
1
Очень хорошо! :) Это то, что я получаю за то, что забыл попробовать длину стороны 6 сам. ;) (Было бы интересно посмотреть, подходит ли мое решение к длине стороны 6 легче.)
Мартин Эндер
@ MartinBüttner Мне бы очень хотелось это увидеть :)
ML
2
Я менее программист, чем вы, потому что такое Visual Studio? : P
Rɪᴋᴇʀ
5
К сожалению, EsotericIDE не может сделать это автоматически. - Пожалуйста, идите прямо сейчас и
подайте
1
(к сожалению, это происходит через 6 месяцев с момента последнего ответа) Вы можете отключить 1 байт от конца программы, сдвинув серый путь на 1 байт и поместив «Отмена операции» в оранжевый путь, как. 3}1"$.!$>)}g4_'{$))}\<$\.\.@\;F\$/;z;u;<%<_>_..$>B/<>}))'%<>{>;e"-</_%;\/{}/>.\)(z;i;..>('Теперь есть дополнительные (после z, который можно «отменить» с помощью a) или поместив туда z. Теперь это а), который выдвигает все команды на оранжевом пути на 1 галочку позже и вернулся с неактивной операцией, которая была в строке 3. Кстати, я также установил Visual Studio только из-за Hexagony Colorer и Esoteric IDE: P
Sunny Pun
44

Лабиринт , 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)к вспомогательному стеку, но в противном случае мы делаем то же самое снова и снова.

Sp3000
источник
7
Люблю объяснения.
The_Basset_Hound
29

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
Дом Гастингс
источник
Вы можете сохранить несколько байтов, используя say.
Деннис
Вы сломали табло ...
LegionMammal978
@ LegionMammal978 Да. Да, я сделал ... Я постараюсь переименовать название тогда! Argh!
Дом Гастингс
Разве не -E"..."8 байтов? Пробел + Тире + Опция + Аргумент (+ Цитирование).
Эрик Outgolfer
1
@EriktheGolfer, так как с тех пор, как я это опубликовал, единодушным является то, что -Eэто 0 байт, но поскольку ответ primo был оценен без учета кавычек, я решил сделать его справедливым и включить кавычки в мою и +1 для -E. Причина это принято , как бесплатно в Perl обычно запускается с помощью perl -eи perl -Eне больше байт (я думал , -M5.010или use 5.010может быть свободным , как хорошо, но , возможно , не перечитывая мета пост). При добавлении -pили -nэто считается +1, как вы будете работать с perl -pe. Надеюсь, это поможет! Мета-ссылка: meta.codegolf.stackexchange.com/a/7539
Дом Гастингс,
27

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

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

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

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

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

Линн
источник
1
Это дьявольское, любите это.
Камден Нарзт
?dэто просто 100. FizzBuzzСтрока имеет символ новой строки в нем, это справедливо в Ruby. string[i, s]это фрагмент, начинающийся с символа i(0-индексированный), продолжающийся для sсимволов, игнорирующий индексы, указывающие вне строки. Если аргумент для putsуже имеет новую строку, он обрезается. Формула должна быть простой для чтения? Он делает всю работу здесь. Я не нашел бы это без помощи некоторых действительно профессиональных игроков в гольф Руби.
Линн
примечание: если вам было разрешено добавить 0 в начале ввода (это не так), ?e.timesвместо этого можно было бы сохранить 2 байта .
Шелваку
Можете ли вы объяснить [i=n**4%-15,i+13]часть, пожалуйста? Кажется, я не могу обернуть это вокруг себя
Piccolo
2
@Piccolo Этот фрагмент помогает? Если i==-14ломтик выходит за границы, мы получаем nil. Если i==-9мы нарезать i+13==4символы, начиная с 9-го символа в конце, так 'Fizz'. Если i==-5мы нарежем 8 символов, начиная с 5-го символа в конце, так 'Buzz\n'. (Мы пытаемся нарезать 8, но есть только 5, поэтому мы получаем 5.) И так далее.
Линн
26

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));}}
Geobits
источник
Я не думаю, что уловка блока инициализатора помогает здесь, так как вопрос определяет пустой stderr.
feersum
Хм. Я знаю статические трюки, которые выводит на stderr, но я думал, что enum работает без ошибок. Полезно знать :)
Geobits
4
побей меня на 14 байтов! Использование <1 вместо == 0 - отличный способ сэкономить!
ESP
2
class F{public static-> interface F{staticв
Ява
1
Это не совсем то, как работают перечисления. Вы должны были бы сделать enum F{;public..., чтобы вы не экономили ни одного байта.
HyperNeutrino
23

Пиф, 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
FryAmTheEggman
источник
23

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), мы просто подсчитываем количество символов, преобразуя результат в десятичное число.

Мартин Эндер
источник
20

гс2 , 1

f

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

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

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

Митч Шварц
источник
20

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и один для необходимого пространства.

Примо
источник
Вы можете использовать sayс -Eпереключателем, который имеет расстояние редактирования от 1 до -e, поэтому он должен считаться как 1 байт.
Деннис
Эй, primo, я чувствую, что я обманываю в своем ответе за использование say, я предположил, что -Eможет быть использован вместо того, -eчто приведет вас к 44, а не к 46. Я не думаю, что это справедливо, что я забил в отличие от вас, каков предпочтительный механизм подсчета очков? Я обычно использую, printчтобы избежать этого! Ближайшим к консенсусу было бы это ?
Дом Гастингс
Мой личный вывод заключается в том, что каждый дополнительный байт в командной строке должен иметь оценку 1. В частности say, если ваш код может быть записан в одну строку, избегая каких-либо разделителей ОС, оценка 1 для -E. Если вам нужно использовать кавычки, например -E"$a||$b", оценка 3. Если вы не можете получить его в одной строке, наберите 5 для -M5.01. Но в этот момент вам, вероятно, будет лучше использовать -l. Я не согласен с тем, что он должен быть бесплатным по умолчанию по двум причинам: 1) улучшение тривиально и неинтересно, и 2) нет версии интерпретатора, для которой он включен по умолчанию.
Примо
20

пчелиный воск ,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.

пчелиный воск FizzBuzz анимация


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

Программа с наложением пути

ML
источник
2
Это так же безумно и красиво, как Гексагония. +1!
ETHproductions
@ETHproductions Мне все еще нужно попробовать Гексагонию, но из того, что я могу судить по языковым спецификациям, мой пчелиный воск даже близко не подходит к сумасшествию Гексагонии.
ML
Как вы делаете эти анимации?
baordog
18

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

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

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

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

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

Аарон
источник
1
Очень хорошо в гольф, я люблю повторное использование "\" на первой линии и один на второй линии.
Коул
1
-1 байт, если вы переместите oконец второй строки в пустое место в начале строки, я считаю.
Sp3000
@ Sp3000 Действительно, я потратил так много времени на игру в гольф, я не знаю, как это не пришло в голову
Аарон
1
Кому нужен шипение, когда вы можете иметь foooo Buzz?
Caird Coneheringaahing
17

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.

Митч Шварц
источник
16

C 85 байт

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

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

AShelly
источник
Попытка скомпилировать здесь, но gccне распознает новую строку внутри строки как \ n. Это дает мне ошибку компиляции. Нужно ли передавать какой-либо параметр компилятору? Кстати, вы пропустили <=в своем сообщении (я насчитал 88 байт с <= ..., так что я предполагаю, что он отсутствует).
wendelbsilva
упс. пропустил ошибку в предупреждениях. Добавляет 2 символа.
AShelly
Глобальные переменные инициализируются нулями, поэтому вместо этого main(i)попробуйте i;main(). Тогда вы можете избавиться от i--в начале for()цикла. Вам также не нужен разрыв строки. Это должно привести к снижению количества байтов до 85.
брезгливое оссифражирование
2
В зависимости от того, как вы хотите получить UB, вы можете сделать 73, 74 или 75 байтов. Вот мой 74-байтовый ответ .
Линн
1
О боже, я потратил, возможно, 3 часа, пытаясь получить эту вещь всего на один байт меньше. Ну вот. Заменить (i%3&&i%5)*iс i%3*i%5?i:0я собираюсь спать
Альберт Реншоу
16

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.
Деннис
источник
3
Более простое решение:100{):I3%!"Fizz"*I5%!"Buzz"*+Ie|N}/
aditsu
16

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Переменный - и , следовательно, этот вид глубокой неотделимости от терминала - это первый класс особенность свинки. Хлоп.

senshin
источник
15

Желе , 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.
Деннис
источник
опять никто не играл в гольф на Деннисе (кроме ответа в стиле HQ9 +)
noɥʇʎԀʎzɐɹƆ
15

брейкфук, 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 раз.

Митч Шварц
источник
14

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.

Пьер-Люк Пино
источник
Короче будет вызывать Writeи добавлять новую строку прямо к строке, верно?
RubberDuck
Это также один байт, чтобы написать i%3*i%5>0?i:0вместо i%3*i%5==0?0:i.
Тимви
Вы можете сохранить еще один байт в forвыражении, используяfor(var i=0;i++<100;)
Najkin
1
Вы можете сохранить еще три байта, используя строковую интерполяцию из C # 6.0 и встраивая аргументы формата в саму строку (например $"{(i%3*i%5>0?i:0):#}...\n")
LiamK
1
может сделать со 121 class A{static void Main(){for(var i=0;i<100;)System.Console.Write($"{(++i%3*i%5<1?0:i):#}{i%3:;;Fizz}{i%5:;;Buzz}\n");}}
байтом
14

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))))))
Сэм Эстеп
источник
1
Вы можете удалить 5 символов, действуя так printlnже, как в решении Java , например. (doall(map #(let[t(=(mod % 3)0)](println(str(if t"Fizz""")(if(=(mod % 5)0)"Buzz"(if t""%)))))(range 1 101)))
Resueman
1
@resueman Спасибо! На самом деле это было 7, потому что (if t"Fizz""")можно упростить до (if t"Fizz"). :)
Сэм Эстеп
+1 Хороший трюк по модулю, сначала я подумал, что у вас были отдельные ошибки.
coredump
14

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
]
Джо Кинг
источник
Молодец Джо! Я мог бы попытаться победить это когда-нибудь :)
Forcent Vintier
13

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 сортируется после числа. Затем он индексирует второй результат сортировки.

AdmBorkBork
источник
Кроме того, если бы PowerShell когда-либо реализовывал ||оператор, как в C #, мы могли бы сократить до 43 байт с чем-то похожим на 1..100|%{"Fizz"*!($_%3)+"Buzz"*!($_%5)||$_}... сомнительно, так как |это такой важный специальный оператор в PowerShell, но я могу мечтать ...
AdmBorkBork
1
Как насчет 1..100|%{'Fizz'*!($_%3)+'Buzz'*!($_%5)-replace'^$',$_}54?
TessellatingHeckler
Вы можете заменить if($t){$t}else{$_}что-то вроде($t,$_)[!$t]
Данко Дурбич
1
... так что вы получите, 1..100|%{(($t="Fizz"*!($_%3)+"Buzz"*!($_%5)),$_)[!$t]}что также 54, как предложение @ TessellatingHeckler
Данко Дурбич
@TessellatingHeckler PowerShell - ничто, если не гибкий.
AdmBorkBork
13

JavaScript, 62 байта

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

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

Mama Fun Roll
источник
Вау просто вау! Но все остальные ответы JS используют console.log; это намного менее раздражает, чем необходимость нажимать «ОК» на 100 всплывающих окнах подряд. Не могли бы вы изменить это? Это будет только 62 байта, все еще три лучше, чем у меня.
ETHproductions
Мне придется сделать это завтра, так как я уже отредактировал 5 своих собственных сообщений и больше не могу редактировать ...
Mama Fun Roll
2
О, я не осознавал, что редактирование было ограничено ...
ETHproductions
12

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"±...).)

Линн
источник
Хороший трюк, чтобы получить i = 1 для случая без аргументов (argc = 1). Это особенность: вы можете запустить последовательность из любой точки, выполнив ./fizzbuzz $(seq 40): P
Питер Кордес
12

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

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

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

timothymh
источник
Вам не хватает чисел после y =(в обоих случаях)
бета-распада
@BetaDecay Извините? Я не следую
Тимотимх
Внутри цикла повтора set y to ...отсутствует значение
Beta Decay
1
@BetaDecay Это пустая строка. :) если вы нажмете на изображение, вы можете просмотреть его в действии!
Тимотимх
Оооо, хаха, извини, что сомневаюсь в тебе;)
Beta Decay
12

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)
MickyT
источник
Кошачий ответ. Мышь выше :)
Сильвиу Бурча
1
Я нашел немного лучше:x=1:100;i=!x%%3;j=!x%%5;x[i]="Fizz";x[j]="Buzz";x[i&j]="FizzBuzz";cat(x,sep="\n")
Flodel
@njnnja Спасибо за предложение. Я реализовал это, writeа не catхотя
MickyT
2
Некромантия здесь! writeВызов может занять 1 вместо пустой строки так x=y=1:100;y[3*x]='Fizz';y[5*x]='Buzz';y[15*x]='FizzBuzz';write(y[x],1)тривиальный 1 байт для гольфа на 70 байт.
J.Doe
68 байтов . Bytecount включает три непечатаемых возврата, и он не работает правильно в TIO.
J.Doe
12

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 и в ""противном случае.

Линн
источник
Перестановка гольфов это до 82, я думаю (%)=drop.(*4).mod n;main=mapM putStrLn[max(show n)$3%"Fizz"++5%"Buzz"|n<-[0..100]].
ЧР Дрост
Подожди, тогда nне в поле зрения. Гектометр
ЧР Дрост
Да, это не работает, но я нашел альтернативное 85-байтовое решение, которое выглядит примерно так:main=mapM putStrLn[max(show n)$3%"Fizz"++5%"Buzz"|n<-[0..100],(%)<-[drop.(*4).mod n]]
Линн
Почему бы не использовать разрыв строки? Он такой же короткий, как точка с запятой, но менее читаемый.
dfeuer
1
Я предлагаю вам пересмотреть свои поиски читабельного кода на сайте гольф-кода :)
Линн
11

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),"
";
Примо
источник
Оператор STFU @ не обязательно означает, что код не содержит ошибок.
Ситилдж
@Kzqai ideone.com/0zRA9e short_open_tag выключен, включенE_NOTICE . Ни один из них не является настройками по умолчанию.
Примо
Я получаю кучу ошибок на 3v4l.org
кодер
@acoder соответствующий мета-пост . 3v4l.org кажется полезным.
Прим
11

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.

anatolyg
источник
TASM действительно обрабатывает многобайтовые константы символов в порядке, противоположном NASM ? В NASM вы пишете mov [mem], 'Fizz'для сохранения Fizzв этом порядке в памяти, соответствующих dbдирективам. Посмотрите мой слишком сложный "эффективный" YASM FizzBuzz, например .
Питер Кордес
1
Сохраняет ли он какие-либо байты для использования std, затем stosb/ stosd? Вы должны были бы заменить test bh,bhс cmp di, 100hили что - то. Вместо того, чтобы сохранять / восстанавливать счетчик в AL, вы можете сохранить его в BL и просто заткнуть eax, когда захотите. Например , sub bx, 4/ mov dword ptr [bx], 'zzuB'3 + 7 байт, верно? mov eax, 'zzuB' / stosdсоставляет 6 + 2 байта (префикс размера операнда на обоих). Было бы неплохо, если бы ответ включал разборку, чтобы были видны размеры инструкций.
Питер Кордес
1
Это отличный ответ - злоупотребление мягкими инструкциями для данных и использование никогда неиспользуемого пространства памяти PSP. @PeterCordes Я играл с вашими предложениями, stosdно сам не смог получить никакого снижения баллов. После последующих stosdдекрементов DIвы не потеряете, sub di, 4и DIв конце у вас будет 4 байта. Я смог -6 bytesиспользовать несколько других мелких изменений, которые я в конечном итоге опубликовал в качестве отдельного ответа (только потому, что я не мог вписаться во все комментарии). Престижность!
640KB
11

Округ Колумбия, 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
daniero
источник