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 ( \n
ou \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>
fonte
Nothing can be printed to STDERR.
Isso é verdade somente quando em execução, ou ainda quando a compilação (assumindo que é um passo separado?)Respostas:
Python 2, 56
fonte
i=1;exec"print'FizzBuzz'[i%-3&4:12&8-i%5]or i;i+=1;"*100
. Alguém quer usar expressões de pesquisa de força bruta para tentar otimizar o bit bashing?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:
Layout hexagonal:
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!
fonte
3}1"$.!$>)}g4_'{$))}\<$\.\.@\;F\$/;z;u;<%<_>_..$>B/<>}))'%<>{>;e"-</_%;\/{}/>.\)(z;i;..>('
.Agora, há um extra (depois do z, que pode ser "cancelado" com a) ou colocando o z ali. Agora é a) que pressiona todos os comandos no caminho laranja 1 e depois retorna com o no-op que estava na linha 3. Btw eu também instalei o Visual Studio apenas devido ao Hexagony Colorer e Esoteric IDE: PLabirinto , 94 bytes
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
x
acionados10*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 aumentandon
a cada passagem seguinte.Em seguida, duplicamos
n
com:
. Comon
é 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 comoMais uma vez,
n
é positivo e vimos à direita, executando o_101/
que dividen
por 101. Sen
é 101, entãon/101 = 1
e nos voltamos para o@
, que finaliza o programa. Caso contrário, nossa situação atual éLaranja 1 (mod 3)
3
transforma o zero superior em um 3 (10*0 + 3 = 3
) e%
executa um módulo. Sen%3
for positivo, viramos à direita para o amarelo"
. Caso contrário, realizamos70.105.122:..
, que produzFizz
. Observe que não precisamos pressionar novos zeros com,_
pois desde entãon%3
era 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:Laranja 2 (mod 5)
Esta é uma situação semelhante à anterior, exceto que as
66.117.122:..
saídasBuzz
sen%5
é zero.Azul escuro
A seção anterior deixa as pilhas como
{
desloca asn%3
costas 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, dandoCaso 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, dandoapós o que usamos
:
para duplicarn
, 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 funcionan + 0
em 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.fonte
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, poissay
inclui automaticamente uma nova linha (obrigado @Dennis !):Perl 5, 50 bytes
fonte
say
.-E"..."
8 bytes? Espaço + Traço + Opção + Argumento (+ Citação).-E
0 bytes, mas como a resposta do primo foi classificada excluindo as aspas, optei por torná-lo justo e incluí-las nas minhas e +1 em-E
. A razão pela qual ele é aceito como livre é que o Perl geralmente é executado viaperl -e
eperl -E
não tem mais bytes (eu pensei-M5.010
ouuse 5.010
posso ser livre também, mas talvez não esteja relendo a meta post). Ao adicionar-p
ou-n
isso é contado como +1, como você executariaperl -pe
. Espero que ajude! Meta referência: meta.codegolf.stackexchange.com/a/7539Ruby, 50 bytes
Requer a versão 1.8, que parece ser popular entre os golfistas:
Em Ruby moderno, você substitui
?d
com100
uma solução de 51 byte.Este parece ser o recorde mundial.
fonte
?d
é justo100
. AFizzBuzz
string possui uma nova linha, isso é válido no Ruby.string[i, s]
é uma fatia, iniciando no caracterei
(indexado 0), continuando pors
caracteres, ignorando os índices que apontam para fora da string. Se o argumento paraputs
já possuir uma nova linha, ele será cortado. A fórmula deve ser simples de ler? Faz todo o trabalho aqui. Eu não o encontraria sem a ajuda de alguns jogadores realmente profissionais de Ruby.?e.times
.[i=n**4%-15,i+13]
parte, por favor? Parece que não pode envolver minha cabeça em torno delei==-14
a fatia está fora dos limites, chegamosnil
. Sei==-9
dividirmosi+13==4
caracteres a partir do nono caractere do final, então'Fizz'
. Sei==-5
dividirmos 8 caracteres, começando do quinto caractere do final, então'Buzz\n'
. (Tentamos dividir 8, mas existem apenas 5, então obtemos 5). Et cetera.Java, 130 bytes
Isto é para versões recentes do Java (7+). Nos mais antigos, você pode economizar um pouco mais usando o
enum
truque, mas não acho que a lógica fique mais curta do que isso (86 por dentromain
).fonte
class F{public static
->interface F{static
em java 8enum F{;public...
isso para não salvar nenhum bytes.Pyth, 30
Experimente aqui
Explicação:
fonte
Retina ,
31713913413270636055 bytesExperimente online!
Explicação
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.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 por3
pode 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, anexamosFi;
à 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 naFizz___...
posição entrez
e_
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 azz
duplicação deFizz
eBuzz
.Fazemos exatamente o mesmo para a divisibilidade por
5
eBu;
, embora não precisemos manter os_
s por esse tempo. Então teríamos resultados comoIsso facilita muito a eliminação dos sublinhados apenas nas linhas que contêm
Fizz
, além de preencher oszz
s:Ou seja, transformamos cada ponto e vírgula em,
zz
mas 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
,Buzz
eFizzBuzz
iteraçõ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.fonte
GS2 , 1
Uma citação de Mauris, o criador do gs2:
Atualização : resposta de 27 bytes adicionada que não é usada
f
.fonte
Perl 5, 45 bytes
Requer a
-E
opção, contada como uma. Isso deve ser executado na linha de comando, ou seja: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
Se as opções de linha de comando forem contadas como uma cada, você
-l
salvará um byte (substituindo$/
). Por Clássico Regras Perlgolf , no entanto, isso contaria 3: um para o-
, um para ol
, e um para o espaço necessário.fonte
say
, com o-E
comutador, a distância de edição de 1 a-e
, para que conte como 1 byte.say
, presumi que isso-E
possa ser usado no lugar, o-e
que reduziria você a 44, em vez de 46. Não acho justo que eu esteja pontuando diferentemente de você, qual é o mecanismo de pontuação preferido? Eu geralmente usoprint
para evitar isso! O mais próximo de um consenso seria esse ?say
, se o seu código puder ser escrito em uma linha, evitando separadores de SO, pontue 1 em-E
. Se você precisar usar aspas, por exemplo-E"$a||$b"
, marque 3. Se não conseguir colocá-lo em uma linha, marque 5 em-M5.01
. Mas nesse momento você provavelmente estaria melhor usando-l
. Não concordo que deva ser gratuito por padrão, por duas razões: 1) a melhoria é trivial e desinteressante e 2) não há versão do intérprete para a qual está ativado por padrão.cera de abelha ,
1048981 bytesEmbalagem mais densa permitida para cortar mais 8 bytes.
Solução mais curta (81 bytes), mesmo fluxo de programa, embalagem diferente.
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=0
Fizz for impresso e a bandeira definida. A flag é realizada simplesmente pressionando o valor lstack superior no gstack (instruçãof
).Se
n%5=0
, entãon%3=0
(caso FizzBuzz) oun%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ínhamosn%3=0
(imprimindo o estojo do Fizz, n não deve ser impresso) oun%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çãoA
). Sen%3 was 0
então, o comprimento do gstack é> 0. Sen%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 posterioresA
(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
para dentro
o que ajuda a se livrar de todo o espaço desperdiçado entre
A
e<
no final da linha a seguir na solução mais antiga abaixo:Solução de novo conceito (89 bytes), incluindo explicação animada:
Layout hexagonal:
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;)
fonte
> <> ,
68666564 bytesO ú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!
fonte
o
final da segunda linha para o espaço vazio no início da linha, acredito.foooo Buzz
?gs2 ,
2827 (semf
)Hex:
Explicação:
A incorporação de 3 e 5 na constante da string não funciona porque
\x05
termina os literais da string.Nota: Esse problema pode ser resolvido em 1 byte com o gs2 usando o built-in
f
.fonte
C, 85 bytes
-2 graças ao melindroso.
fonte
gcc
não reconhece a nova linha dentro da string como \ n. Isso me dá um erro de compilação. Preciso passar algum parâmetro para o compilador? BTW, você perdeu o<=
no seu post (eu contei 88 bytes com <= ... então estou assumindo que está faltando).main(i)
, tentei;main()
. Então você pode se livrar doi--
no início dofor()
loop. Você também não precisa da quebra de linha. Isso deve trazer o byte contagem regressiva para 85.(i%3&&i%5)*i
comi%3*i%5?i:0
Estou indo para a camaCJam, 35 bytes
Experimente on-line no intérprete CJam .
Como funciona
fonte
100{):I3%!"Fizz"*I5%!"Buzz"*+Ie|N}/
MUMPS,
5654 bytesO 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 doWRITE
comando. A sintaxecommand:condition args
é pós-condicional - "ifcondition
, then docommand 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 gravadoi
no terminal. A$X
variável - e, portanto, esse tipo de profunda inseparabilidade do terminal - é um recurso de primeira classe do MUMPS. Caramba.fonte
Geléia ,
2420 bytesExperimente online!
Como funciona
fonte
brainfuck, 206 bytes
Formatado:
Experimente online
O layout da memória é
onde
f
ciclos por 3,b
ciclos por 5,d1
é umd2
dígito,s
é um dígito de dezenas, é um sinalizador para imprimir dezenas de dígitos,d
ciclos por 10,c
é um espaço de cópia parad
,t
é um espaço de trabalho que contém 0 ou dados não desejados ou um sinalizador para não -divisible-by-3, ea
determina a finalização do programa deslocando o ponteiro após a impressão do Buzz 20 vezes.fonte
C #,
128126125124 bytes89 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.
fonte
Write
e acrescentar a nova linha diretamente à string, certo?i%3*i%5>0?i:0
vez dei%3*i%5==0?0:i
.for
declaração usandofor(var i=0;i++<100;)
$"{(i%3*i%5>0?i:0):#}...\n"
)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");}}
Clojure,
11310610110091 bytesMeu primeiro golfe!
Ungolfed:
fonte
println
mesma maneira que na solução Java , por exemplo.(doall(map #(let[t(=(mod % 3)0)](println(str(if t"Fizz""")(if(=(mod % 5)0)"Buzz"(if t""%)))))(range 1 101)))
(if t"Fizz""")
pode ser simplificado para(if t"Fizz")
. :)brainfuck ,
411 350277258bytesEditar% 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:
fonte
PowerShell,
78686154 BytesEditar: 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$t
igual 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 atualComo alternativa, também 54 bytes
Graças a TesselatingHeckler
De conceito semelhante, ele usa o
-replace
operador 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
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.
fonte
||
operador, como em C #, provavelmente poderíamos chegar a 43 bytes com algo semelhante a1..100|%{"Fizz"*!($_%3)+"Buzz"*!($_%5)||$_}
... duvidoso, pois|
é um operador especial tão importante no PowerShell, mas posso sonhar ...1..100|%{'Fizz'*!($_%3)+'Buzz'*!($_%5)-replace'^$',$_}
54?if($t){$t}else{$_}
com algo parecido($t,$_)[!$t]
1..100|%{(($t="Fizz"*!($_%3)+"Buzz"*!($_%5)),$_)[!$t]}
o que também 54 é como @ de TessellatingHeckler sugestãoJavaScript, 62 bytes
Eu acho que essa é a solução Javascript mais curta agora.
fonte
console.log
; é muito menos chato do que ter que pressionar "OK" em 100 caixas pop-up seguidas. Você poderia mudar isso? Serão apenas 62 bytes, ainda três melhores que os meus.C, 74 bytes
O
0
argumento para emprintf
vez de""
é suspeito, mas parece funcionar na maioria das plataformas em que eu experimento.puts
segfaults 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"±...)
).fonte
./fizzbuzz $(seq 40)
: PScratch,
203185 bytesOs 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 secs
seria necessário um bloco para realmente ler essa saída, mas, para os propósitos deste desafio, esse código atende aos requisitos.fonte
y =
(em ambas as ocorrências)set y to ...
falta um valorR,
8883777170 bytesTenho 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.Doefonte
x=1:100;i=!x%%3;j=!x%%5;x[i]="Fizz";x[j]="Buzz";x[i&j]="FizzBuzz";cat(x,sep="\n")
write
pouco do quecat
emborawrite
chamada pode receber um 1 em vez de uma sequência vazia, assimx=y=1:100;y[3*x]='Fizz';y[5*x]='Buzz';y[15*x]='FizzBuzz';write(y[x],1)
como um golfe trivial de 1 byte por 70 bytes.Haskell, 84 bytes
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"
quandon `mod` 3
é 0 e""
caso contrário.fonte
(%)=drop.(*4).mod n;main=mapM putStrLn[max(show n)$3%"Fizz"++5%"Buzz"|n<-[0..100]]
.n
não está no escopo. Hum.main=mapM putStrLn[max(show n)$3%"Fizz"++5%"Buzz"|n<-[0..100],(%)<-[drop.(*4).mod n]]
PHP, 54 bytes
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
-n
como emphp -n fizzbuzz.php
.Uma versão que será executada sem erros com absolutamente qualquer arquivo de configuração é de 62 bytes :
fonte
short_open_tag
está desativado,E_NOTICE
está ativado . Nenhuma dessas configurações é padrão.Código de máquina 80386 + DOS, 75 bytes
Hexdump do código:
Código fonte (sintaxe TASM):
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:É 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:
dl
dh
Quando um contador atinge 0, ele empurra a string
Fizz
ouBuzz
até o final da mensagem de saída. Se isso acontecer,bx
será diminuído ebh
será 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.
fonte
mov [mem], 'Fizz'
para armazenarFizz
nessa ordem na memória, correspondendo àsdb
diretivas. Veja meu YASM FizzBuzz "eficiente" e complicado demais, por exemplo .std
, entãostosb
/stosd
? Você teria que substituirtest bh,bh
porcmp di, 100h
algo assim. Em vez de salvar / restaurar o contador no AL, você pode mantê-lo no BL e simplesmente bater no eax sempre que quiser. Por exemplo,sub bx, 4
/mov dword ptr [bx], 'zzuB'
é de 3 + 7 bytes, certo?mov eax, 'zzuB' / stosd
é 6 + 2 bytes (prefixo do tamanho do operando em ambos). Seria bom se a resposta incluísse desmontagem para que os tamanhos das instruções fossem visíveis.stosd
mas não fui capaz de obter nenhuma redução de pontuação. Desdestosd
diminuiDI
depois você não perde osub di, 4
e então você temDI
4 bytes no final. Consegui-6 bytes
usar alguns outros pequenos ajustes que acabei postando como uma resposta separada (apenas porque eu não poderia caber em todos os comentários). Parabéns!dc,
6462 bytesUngolfed:
fonte