Introdução

Em nosso recente esforço para coletar catálogos de soluções mais curtas para exercícios de programação padrão, aqui está o primeiro desafio FizzBuzz de baunilha do PPCG. Se você deseja ver outros desafios do catálogo, há "Hello World!" e "Esse número é primo?" .

Desafio

Escreva um programa que imprima os números decimais de 1 a 100 inclusive. Mas, para múltiplos de três, imprima "Fizz" em vez do número e para os múltiplos de cinco, imprima "Buzz". Para números múltiplos de três e cinco, imprima “FizzBuzz”.

Resultado

A saída será uma lista de números (e Fizzes, Buzzes e FizzBuzzes) separados por uma nova linha ( \nou \r\n). Uma nova linha final é aceitável, mas uma nova linha principal não é. Além da sua escolha de nova linha, a saída deve ser exatamente assim:

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

A única exceção a essa regra é a saída constante do intérprete do seu idioma que não pode ser suprimida, como uma saudação, códigos de cores ANSI ou recuo.

Regras adicionais

• Não se trata de encontrar o idioma com a abordagem mais curta para jogar o FizzBuzz, trata-se de encontrar a abordagem mais curta em todos os idiomas. Portanto, nenhuma resposta será marcada como aceita.

• As submissões são pontuadas em bytes em uma codificação preexistente apropriada, geralmente (mas não necessariamente) UTF-8. Alguns idiomas, como Pastas, são um pouco difíceis de pontuar - se houver dúvida, pergunte no Meta.

• Nada pode ser impresso no STDERR.

• Diferentemente de nossas regras usuais, fique à vontade para usar um idioma (ou versão do idioma), mesmo que seja mais novo que esse desafio. Se alguém quiser abusar disso, criando um idioma em que o programa vazio gere a saída do FizzBuzz, parabéns por abrir caminho para uma resposta muito chata.

  Observe que deve haver um intérprete para que o envio possa ser testado. É permitido (e até encorajado) escrever esse intérprete para um idioma anteriormente não implementado.

• Se o seu idioma de escolha for uma variante trivial de outro idioma (potencialmente mais popular) que já tenha uma resposta (pense em dialetos BASIC ou SQL, shell do Unix ou derivados triviais do Brainfuck como Alphuck e ???), considere adicionar uma nota à existente responda que a mesma solução ou uma solução muito semelhante também é a mais curta no outro idioma.

• Como a saída é fixa, você pode codificá-la (mas essa pode não ser a opção mais curta).

• Você pode usar soluções pré-existentes, desde que credite o autor original do programa.

• As brechas padrão não são permitidas.

Como uma observação lateral, por favor, não reduza as respostas chatas (mas válidas) em idiomas onde não há muito para jogar golfe; eles ainda são úteis para essa pergunta, pois ele tenta compilar um catálogo o mais completo possível. No entanto, primariamente upvote respostas em idiomas em que os autores realmente tiveram que se esforçar no golfe do código.

Catálogo

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

Hexagonia , 91 bytes

Obrigado pela recompensa :)

Uau, eu nunca imaginaria que poderia vencer a solução Hexagony de Martin . Mas - quem teria pensado nisso - eu consegui. Após vários dias de falha, porque eu não tinha o colorador Hexagony nem o EsotericIDE para verificar minha solução. Eu entendi errado vários aspectos da especificação, então produzi algumas “soluções” erradas usando caneta e papel e um editor de texto. Bem, finalmente superei minha preguiça e clonei os dois repositórios, baixei o VisualStudio e os compilei. Uau, que ferramentas úteis eles são! Como você pode ver, estou longe de ser alguém que você chamaria de programador (quer dizer, vamos lá! Eu nem tinha o VisualStudio instalado e não tenho idéia de como compilar um programa);)

Ainda demorei um pouco para encontrar uma solução de trabalho, e ela é bastante abarrotada e caótica, mas aqui está toda a sua glória:

Fizzbuzz em um hexágono tamanho 6:

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

Layout hexagonal:

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

E a bela interpretação, graças ao Hexagony Colorer de Timwi :

Então, aqui está uma animação GIF de 110 segundos a 2 qps, mostrando o fluxo do programa durante os primeiros 6 números 1, 2, Fizz, 4, Buzz, Fizz, os primeiros 220 ticks do programa (clique na imagem para ver o tamanho completo):

Meu Deus, graças ao software de composição Natron, a animação do ponteiro ainda era entediante de criar, mas administrável. Salvar 260 imagens da memória foi menos divertido. Infelizmente, o EsotericIDE não pode fazer isso automaticamente. De qualquer forma, aproveite a animação!

Afinal, depois de entender o modelo de memória e o caminho pouco intuitivo dos caminhos que cruzam as fronteiras do hexágono, não é difícil trabalhar com o hexagony. Mas jogar golfe pode ser uma dor de cabeça. ;)

Foi divertido!

Labirinto , 94 bytes

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

Sub-100! Essa foi engraçada.

Explicação

Vamos começar com uma breve cartilha sobre Labyrinth - fique à vontade para pular isso se você já estiver familiarizado com o básico:

• O labirinto possui duas pilhas - uma pilha principal e uma pilha auxiliar. Ambas as pilhas têm um número infinito de zeros na parte inferior, por exemplo, +em uma pilha vazia adiciona dois zeros, pressionando assim zero.

• O fluxo de controle no Labirinto é decidido por junções, que examinam a parte superior da pilha para determinar para onde ir a seguir. Negativo significa virar à esquerda, zero significa seguir em frente e positivo significa virar à direita ... mas se batermos em uma parede, invertemos a direção. Por exemplo, se apenas a frente e a esquerda forem possíveis, mas a parte superior da pilha for positiva, como não podemos virar à direita, vire à esquerda.

• Os dígitos no labirinto são xacionados 10*x + <digit>, o que facilita a criação de grandes números. No entanto, isso significa que precisamos de uma instrução para pressionar 0 para iniciar um novo número, que está _no Labirinto.

Agora vamos ao código real!

Vermelho

A execução começa "no canto superior esquerdo, que é um NOP. A seguir ), é incrementado o topo da pilha, pressionando 1 na primeira passagem e aumentando na cada passagem seguinte.

Em seguida, duplicamos ncom :. Como né positivo, vire à direita, executando }(desloque o topo da pilha principal para auxiliar) e :. Chegamos a um beco sem saída, então nos viramos e executamos }e :mais uma vez, deixando as pilhas como

Main [ n n | n n ] Aux

Mais uma vez, né positivo e vimos à direita, executando o _101/que divide npor 101. Se né 101, então n/101 = 1e nos voltamos para o @, que finaliza o programa. Caso contrário, nossa situação atual é

Main [ n 0 | n n ] Aux

Laranja 1 (mod 3)

3transforma o zero superior em um 3 ( 10*0 + 3 = 3) e %executa um módulo. Se n%3for positivo, viramos à direita para o amarelo ". Caso contrário, realizamos 70.105.122:.., que produz Fizz. Observe que não precisamos pressionar novos zeros com, _pois desde então n%3era zero neste caso, para que possamos explorar os zeros infinitos na parte inferior da pilha. Ambos os caminhos se reencontram em azul claro.

Azul claro

Atualmente n%3, o topo da pilha está positivo, o que pode ser positivo, então o valor _;é igual a zero e o aparece imediatamente para garantir que seguimos em frente, em vez de virar para o @. Em seguida, =trocamos os topos das pilhas principais e auxiliares, fornecendo:

Main [ n | n%3 n ] Aux

Laranja 2 (mod 5)

Esta é uma situação semelhante à anterior, exceto que as 66.117.122:..saídas Buzzsen%5 é zero.

Azul escuro

A seção anterior deixa as pilhas como

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

{desloca as n%3costas para a pilha principal e *multiplica os dois módulos.

Se um dos módulos for zero, o produto é zero, então vamos direto para o amarelo. =troca o topo das pilhas e _empurra o zero para garantir que seguimos em frente, dando

Main [ n 0 | 0 ] Aux

Caso contrário, se ambos os módulos forem diferentes de zero, o produto será diferente de zero e nós viraremos à direita em verde. =troca o topo das pilhas, dando

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

após o que usamos :para duplicar n, vire à direita e depois use !a saídan .

Roxa

Nesse ponto, a pilha principal possui um ou dois itens, dependendo de qual caminho foi seguido. Precisamos nos livrar do zero do caminho amarelo e, para fazer isso, usamos o +que funciona n + 0em alguma ordem nos dois casos. Finalmente,\ gera uma nova linha e estamos de volta ao início.

Cada iteração envia um extra (n%5)*(n%3)à pilha auxiliar, mas, caso contrário, fazemos a mesma coisa novamente.

Perl 5, 49 bytes

Script de 46 bytes + 3 bytes -E"..."

Usar say(o que requer -E"...") pode reduzir isso ainda mais para 46 bytes, pois sayinclui automaticamente uma nova linha (obrigado @Dennis !):

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

Perl 5, 50 bytes

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

Ruby, 50 bytes

Requer a versão 1.8, que parece ser popular entre os golfistas:

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

Em Ruby moderno, você substitui ?dcom 100uma solução de 51 byte.

Este parece ser o recorde mundial.

Java, 130 bytes

Isto é para versões recentes do Java (7+). Nos mais antigos, você pode economizar um pouco mais usando o enumtruque, mas não acho que a lógica fique mais curta do que isso (86 por dentro 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));}}

Pyth, 30

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

Experimente aqui

Explicação:

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 bytes

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

Experimente online!

Explicação

.100{`^
_

O .é o sinalizador silencioso global que desliga a saída implícita no final do programa. 100{agrupa o restante do programa em um loop que é executado por 100 iterações. Finalmente, o próprio estágio apenas insere um _no início da string, o que efetivamente incrementa um contador de loop unário.

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

Mais configuração. *\(agrupa o restante do programa em um grupo, imprime seu resultado com um avanço de linha à direita, mas também coloca o grupo inteiro em uma execução a seco, o que significa que seu resultado será descartado após a impressão, para que nosso contador de loop não seja realmente modificado . aé um modificador de regex personalizado que ancora o regex em toda a cadeia de caracteres (que economiza um byte no uso ^e $explicitamente).

O próprio estágio atômico cuida Fizz. A divisibilidade por 3pode ser facilmente verificada como unária: basta testar se o número pode ser escrito como uma repetição de ___. Se for esse o caso, anexamos Fi;à sequência. O ponto e vírgula é para que ainda exista um limite de palavras na frente do número para o próximo estágio. Se colocarmos a linha na Fizz___...posição entre ze _não for considerada um limite, porque o regex trata as letras e os sublinhados como caracteres de palavra. No entanto, o ponto e vírgula também nos permite remover a zzduplicação de Fizze Buzz.

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

Fazemos exatamente o mesmo para a divisibilidade por 5e Bu;, embora não precisemos manter os _s por esse tempo. Então teríamos resultados como

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

Isso facilita muito a eliminação dos sublinhados apenas nas linhas que contêm Fizz, além de preencher os zzs:

;_*
zz

Ou seja, transformamos cada ponto e vírgula em, zzmas também consumimos todos os _s logo após. Neste ponto, terminamos o FizzBuzz em unário. Mas o desafio quer saída decimal.

'_&`.

&indica um condicional: esse estágio será executado apenas se a sequência contiver um sublinhado. Portanto, Fizz, Buzze FizzBuzziterações são deixados intocados. Em todas as outras iterações (ou seja, aquelas que não são divisíveis por 3 nem 5), contamos apenas o número de caracteres, convertendo o resultado em decimal.

GS2 , 1

f

Uma citação de Mauris, o criador do gs2:

Eu queria adicionar 1 byte de gorubyHello, world! , então ... Isso imprime "1\n2\nFizz\n4\nBuzz\n...". :)

Atualização : resposta de 27 bytes adicionada que não é usada f.

Perl 5, 45 bytes

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

Requer a -Eopção, contada como uma. Isso deve ser executado na linha de comando, ou seja:

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

Aspas em torno do comando são desnecessárias, se evita usar espaços, ou quaisquer outros caracteres que podem agir como separadores de linha de comando ( |, <, >, &, etc.).

Perl 5, 48 bytes

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

Se as opções de linha de comando forem contadas como uma cada, você -lsalvará um byte (substituindo $/). Por Clássico Regras Perlgolf , no entanto, isso contaria 3: um para o -, um para o l, e um para o espaço necessário.

cera de abelha ,104 89 81 bytes

Embalagem mais densa permitida para cortar mais 8 bytes.

Solução mais curta (81 bytes), mesmo fluxo de programa, embalagem diferente.

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

Mudar o conceito me permitiu reduzir o código em 15 bytes. Eu queria me livrar do teste do double mod 5 na solução, então implementei um sinalizador.

Breve explicação:

se o n%3=0Fizz for impresso e a bandeira definida. A flag é realizada simplesmente pressionando o valor lstack superior no gstack (instrução f).

Se n%5=0, então n%3=0(caso FizzBuzz) ou n%3>0(caso Buzz). Nos dois casos, o Buzz é impresso, e o sinalizador é redefinido, estourando a pilha até que ela fique vazia (instrução ?).

Agora os casos interessantes:

Se n%5>0, então, nós tínhamos n%3=0(imprimindo o estojo do Fizz, n não deve ser impresso) ou n%3>0(o Fizz não foi impresso, então n precisa ser impresso). Hora de checar a bandeira. Isso é realizado pressionando o comprimento do gstack em cima do gstack (instrução A). Se n%3 was 0então, o comprimento do gstack é> 0. Se n%3 was >0, o comprimento do gstack for 0. Um salto condicional simples garante que n seja impresso apenas se o comprimento do gstack for 0.

Novamente, depois de imprimir n, Fizz e / ou Buzz e a nova linha, o gstack é exibido duas vezes para garantir que esteja vazio. O gstack está vazio [], o que leva a [0]instruções posteriores A(tamanho do push do gstack no gstack) ou contém um zero ( [0]o resultado de n% 3), o que leva a [0 1]que [0] tenha o comprimento 1. Popping from a pilha vazia não altera a pilha, por isso é seguro aparecer duas vezes.

Se você olhar mais de perto, verá que, em princípio, dobrei

>      q
d`Fizz`f>

para dentro

<f`z`<
d`Fiz`b

o que ajuda a se livrar de todo o espaço desperdiçado entre Ae <no final da linha a seguir na solução mais antiga abaixo:

q?{@b'gA<       p      <

Solução de novo conceito (89 bytes), incluindo explicação animada:

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

Layout hexagonal:

   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

Animação dos primeiros 326 ticks a 2 qps, com pilhas locais e globais, e saída para STDOUT.

Para comparação, abaixo estão as sobreposições de caminho da solução mais antiga e complexa. Talvez seja também a solução mais bonita, do ponto de vista visual;)

> <> , 68 66 65 64 bytes

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

O único truque é multiplicar os restantes como condição para imprimir números. Dessa forma, se um deles for 0, não imprimiremos o número.

Você pode tentar aqui .

Economizou um byte graças ao Sp3000 e outro graças ao randomra. Muito Obrigado!

gs2 , 28 27 (sem 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

Explicação:

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

A incorporação de 3 e 5 na constante da string não funciona porque \x05termina os literais da string.

Nota: Esse problema pode ser resolvido em 1 byte com o gs2 usando o built-in f.

C, 85 bytes

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

-2 graças ao melindroso.

CJam, 35 bytes

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

Experimente on-line no intérprete CJam .

Como funciona

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 bytes

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

O que é isso w:$X<3 i, você pergunta? $Xé uma variável mágica (uma "intrínseca") que armazena a posição horizontal do cursor de saída (como um número de caracteres da borda esquerda do terminal). wé a forma abreviada do WRITEcomando. A sintaxe command:condition argsé pós-condicional - "if condition, then do command args".

Portanto, estamos verificando se o cursor de saída avançou mais de dois caracteres (o que significaria que pelo menos um de "Fizz"ou "Buzz"foi gravado no terminal) e, se não, foi gravado ino terminal. A $Xvariável - e, portanto, esse tipo de profunda inseparabilidade do terminal - é um recurso de primeira classe do MUMPS. Caramba.

Geléia , 24 20 bytes

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

Experimente online!

Como funciona

³µ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.

brainfuck, 206 bytes

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

Formatado:

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

Experimente online

O layout da memória é

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

onde fciclos por 3, bciclos por 5, d1é um d2dígito, sé um dígito de dezenas, é um sinalizador para imprimir dezenas de dígitos, dciclos por 10, cé um espaço de cópia para d, té um espaço de trabalho que contém 0 ou dados não desejados ou um sinalizador para não -divisible-by-3, e adetermina a finalização do programa deslocando o ponteiro após a impressão do Buzz 20 vezes.

C #, 128 126 125 124 bytes

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 bytes sem o código padrão.

Feito com o uso da formatação condicional do C # .

Com dois separadores de seção ; , Fizz ou Buzz são impressos se o valor de sua condição for zero.

Economizou um total de 4 bytes graças a @RubberDuck, @Timwi e @Riokmij.

Clojure, 113 106 101 100 91 bytes

Meu primeiro golfe!

(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 350277258 bytes

Editar% s:

• -61 bytes, armazenando os valores de "Fizz Buzz" como "BuziF" "BuziG" e refazendo a seção de impressão de números.

• -71 bytes refazendo a seção de impressão do número do módulo, dividindo o contador de loop e o contador de números e reutilizando a célula da nova linha como valor mod, entre outras coisas

• -19 bytes ao perceber que não há 0s em nenhum número do FizzBuzz. Também acrescentou explicação

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

Experimente online!

Em vez de verificar se o número em si era divisível por 5 ou 3, eu tinha dois contadores controlando o módulo do número, diminuindo-os para cada número e imprimindo a palavra correspondente quando atingissem 0.

Como funciona:

+[-[>+<<]>-]>--  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 Bytes

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

_{Editar: salvou 10 bytes graças a feersum}

_{Edit2: Percebi que com o truque de feersum, não preciso mais formular $ t como uma cadeia de blocos de código}

_{Edit3: salvou outros 7 bytes graças a Danko Durbić}

Espírito similar ao estoque Código Rosetta Resposta do padrão do , mas diminuiu bastante.

Explicação

1..100|%{...} Crie uma coleção de 1 a 100 e, para cada objeto nessa coleção, faça

(...,$_)crie uma nova coleção de dois elementos: 0) $t=...defina a variável $tigual a uma string; 1)$_ nosso número atual do loop

"Fizz"*!($_%3)pegue nosso número atual, modifique-o por 3 e depois NÃO o resultado. Multiplique "Fizz" por isso e adicione-o à string (e similar para 5). O PowerShell trata qualquer número diferente de zero como$TRUE e, portanto, o NOT de um número diferente de zero é 0, o que significa que somente se nosso número atual for um múltiplo de 3, o "Fizz" será adicionado à string.

[!$t]índices na coleção que acabamos de criar, com base no valor da sequência $t- não vazia, imprima, ou imprima nosso número atual

Como alternativa, também 54 bytes

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

_{Graças a TesselatingHeckler}

De conceito semelhante, ele usa o -replaceoperador inline e uma expressão regular para trocar uma string vazia ^$pelo nosso número atual. Se a sequência não estiver vazia, ela não será trocada.

Como alternativa, também 54 bytes

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

Essa é a mesma estrutura de loop que acima, mas por dentro ele classifica o par (n, string) e depende do fato de que uma string vazia é classificada antes de um número, mas uma sequência do FizzBuzz é classificada após um número. Em seguida, indexa o resultado da segunda classificação.

JavaScript, 62 bytes

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

Eu acho que essa é a solução Javascript mais curta agora.

C, 74 bytes

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

O 0argumento para em printfvez de ""é suspeito, mas parece funcionar na maioria das plataformas em que eu experimento. putssegfaults quando você tenta a mesma coisa, no entanto. Sem ele, você recebe 75 bytes.

Existem soluções de 73 bytes que funcionam no golfe anárquico , e eu encontrei uma pesquisando nos lugares certos na Internet, mas elas se baseiam no comportamento específico da plataforma. (Como você deve ter adivinhado, é algo assim puts("Buzz"±...)).

Scratch, 203 185 bytes

Os bytes contados a partir da representação textual em golf , de acordo com esta meta postagem . O risco não é muito eficiente em termos de espaço.

sayé a coisa mais próxima de um Scratch stdout: o sprite exibe um balão contendo o que quer que esteja dizendo. Na prática, wait n secsseria necessário um bloco para realmente ler essa saída, mas, para os propósitos deste desafio, esse código atende aos requisitos.

R, 88 83 77 71 70 bytes

Tenho certeza de que isso pode ser melhorado ... e foi com crédito para @flodel. Mais alguns bytes salvos, graças a uma sugestão de @njnnja e outra de @ J.Doe

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

Haskell, 84 bytes

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

Aproximando-se de 81 bytes de henkma , mas não completamente lá ainda.

d = drop.(*4).mod né a chave aqui: d 3 "Fizz"é drop (n`mod`3 * 4) "Fizz". É "Fizz"quando n `mod` 3é 0 e ""caso contrário.

PHP, 54 bytes

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

Válido para v5.5 em diante. O õcaractere é 245, um pouco invertido \n.

Eu assumo as configurações padrão do intérprete, pois são sem ini. Se você não tiver certeza, poderá desativar o seu ini local -ncomo em php -n fizzbuzz.php.

Uma versão que será executada sem erros com absolutamente qualquer arquivo de configuração é de 62 bytes :

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

Código de máquina 80386 + DOS, 75 bytes

Hexdump do código:

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

Código fonte (sintaxe 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

Esse código conta de 1 a 100 pol ax, criando a mensagem de saída do fim ao início. O final da mensagem (nova linha e o $caractere que o DOS usa para o sinalizador de final de mensagem) aparece no início do código:

db 10, 10, '$'

É executado como uma instrução inofensiva ( or ax, 240ah). Eu poderia colocá-lo em um local mais convencional, como após o final do código, mas tê-lo no endereço 0x100 tem um benefício.

O código também usa 2 contadores adicionais:

• Contando de 3 a 0 em dl
• Contando de 5 a 0 em dh

Quando um contador atinge 0, ele empurra a string Fizzou Buzzaté o final da mensagem de saída. Se isso acontecer, bxserá diminuído e bhserá zero. Isso é usado como uma condição para a saída do número na forma decimal.

Nota: estou usando dados de 32 bits aqui. Isso não funcionará em um computador pré-386.

dc, 64 62 bytes

[[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