introduzione

Nel nostro recente sforzo di raccogliere cataloghi delle soluzioni più brevi per esercizi di programmazione standard, ecco la prima sfida FizzBuzz alla vaniglia di PPCG. Se desideri vedere altre sfide del catalogo, c'è "Hello World!" e "Questo numero è un numero primo?" .

Sfida

Scrivi un programma che stampa i numeri decimali da 1 a 100 inclusi. Ma per multipli di tre stampa "Fizz" anziché il numero e per multipli di cinque stampa "Buzz". Per i numeri multipli di tre e cinque stampare "FizzBuzz".

Produzione

L'output sarà un elenco di numeri (e Fizzes, Buzzes e FizzBuzzes) separati da una nuova riga (o \no \r\n). Una nuova riga finale è accettabile, ma una nuova riga iniziale non lo è. A parte la scelta di newline, l'output dovrebbe apparire esattamente come questo:

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

L'unica eccezione a questa regola è l'output costante dell'interprete della tua lingua che non può essere soppresso, come un saluto, codici colore ANSI o rientro.

Ulteriori regole

• Non si tratta di trovare la lingua con l'approccio più breve per giocare a FizzBuzz, si tratta di trovare l'approccio più breve in ogni lingua. Pertanto, nessuna risposta verrà contrassegnata come accettata.

• Le iscrizioni vengono classificate in byte in una codifica preesistente appropriata, di solito (ma non necessariamente) UTF-8. Alcune lingue, come Cartelle, sono un po 'difficili da segnare - in caso di dubbi, si prega di chiedere su Meta.

• Nulla può essere stampato su STDERR.

• A differenza delle nostre solite regole, sentiti libero di usare una lingua (o versione linguistica) anche se è più recente di questa sfida. Se qualcuno vuole abusare di questo creando una lingua in cui il programma vuoto genera l'output di FizzBuzz, allora si congratula per aver spianato la strada a una risposta molto noiosa.

  Si noti che deve essere presente un interprete per poter testare l'invio. È permesso (e persino incoraggiato) di scrivere questo interprete per una lingua precedentemente non implementata.

• Se la tua lingua preferita è una variante banale di un'altra lingua (potenzialmente più popolare) che ha già una risposta (pensi a dialetti BASIC o SQL, shell Unix o banali derivati ​​Brainfuck come Alphuck e ???), considera di aggiungere una nota all'esistente rispondere che la stessa o una soluzione molto simile è anche la più breve nell'altra lingua.

• Poiché l'output è fisso, è possibile codificare l'output (ma questa potrebbe non essere l'opzione più breve).

• È possibile utilizzare soluzioni preesistenti, purché si accrediti l'autore originale del programma.

• Le scappatoie standard non sono altrimenti vietate.

Come nota a margine, si prega di non sottovalutare le risposte noiose (ma valide) in lingue in cui non c'è molto da golf; questi sono ancora utili a questa domanda in quanto tenta di compilare un catalogo il più completo possibile. Tuttavia, valuta principalmente le risposte nelle lingue in cui gli autori hanno effettivamente dovuto sforzarsi di giocare a golf con il codice.

Catalogare

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

Esagonia , 91 byte

Grazie per la generosità :)

Wow, non avrei mai immaginato di poter battere la soluzione Hexagony di Martin . Ma - chi l'avrebbe mai provato - l'ho fatto. Dopo diversi giorni di fallimento, perché non avevo né il colorante Hexagony né EsotericIDE per controllare la mia soluzione. Ho sbagliato diversi aspetti della specifica, quindi ho prodotto alcune "soluzioni" sbagliate usando solo carta e penna e un editor di testo. Bene, finalmente ho superato la mia pigrizia e clonato entrambi i repository, scaricato VisualStudio e li ho compilati. Caspita, che strumenti utili sono! Come puoi vedere, sono ben lungi dall'essere qualcuno che chiameresti un programmatore (voglio dire, dai! Non avevo nemmeno VisualStudio installato e non ho praticamente idea di come compilare un programma);)

Mi ci è voluto ancora un po 'per trovare una soluzione funzionante, ed è piuttosto stipata e caotica, ma qui è in tutto il suo splendore:

Fizzbuzz in un esagono taglia 6:

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

Layout esagonale:

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

E la bellissima interpretazione, grazie a Hexagony Colorer di Timwi :

Quindi, ecco un'animazione GIF lunga 110 secondi a 2 fps, che mostra il flusso del programma durante i primi 6 numeri 1, 2, Fizz, 4, Buzz, Fizz, i primi 220 tick del programma (fare clic sull'immagine per ingrandirla):

Mio Dio, grazie al software di composizione Natron l'animazione del puntatore era ancora noiosa da creare, ma gestibile. Salvare 260 immagini della memoria è stato meno divertente. Sfortunatamente EsotericIDE non può farlo automaticamente. Ad ogni modo, goditi l'animazione!

Dopotutto, una volta che avvolgi la testa attorno al modello di memoria e all'avvolgimento piuttosto controintuitivo di percorsi che attraversano i bordi dell'esagono, Hexagony non è così difficile da lavorare. Ma giocare a golf può essere una seccatura. ;)

È stato divertente!

Labyrinth , 94 byte

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

Sotto-100! Questo è stato divertente.

Spiegazione

Cominciamo con un breve primer su Labyrinth - sentiti libero di saltare questo se hai già familiarità con le basi:

• Labyrinth ha due pile: una pila principale e una pila ausiliaria. Entrambi gli stack hanno un numero infinito di zeri nella parte inferiore, ad esempio +su uno stack vuoto aggiunge due zero, spingendo così lo zero.

• Il flusso di controllo in Labyrinth è deciso da giunzioni, che guardano in cima allo stack per determinare dove andare dopo. Negativo significa svoltare a sinistra, zero significa andare dritto e positivo significa svoltare a destra ... ma se colpiamo un muro allora invertiamo la direzione. Ad esempio, se sono possibili solo dritto e svoltare a sinistra, ma la parte superiore della pila è positiva, quindi poiché non possiamo girare a destra, invece giriamo a sinistra.

• Cifre in Labyrinth pop x e push 10*x + <digit>, il che rende facile costruire grandi numeri. Tuttavia, ciò significa che abbiamo bisogno di un'istruzione per spingere 0 per iniziare un nuovo numero, che si trova _in Labyrinth.

Ora passiamo al codice reale!

Rosso

L'esecuzione inizia "dall'angolo in alto a sinistra, che è un NOP. Il prossimo è) , che incrementa la parte superiore dello stack, spingendo 1 al primo passaggio e incrementando nad ogni passaggio successivo.

Quindi dupliciamo ncon :. Poiché nè positivo, giriamo a destra, eseguendo }(sposta la parte superiore dello stack principale in ausiliario) e :. Raggiungiamo un vicolo cieco, quindi ci voltiamo ed eseguiamo }e :ancora una volta, lasciando le pile simili

Main [ n n | n n ] Aux

Ancora una volta, nè positivo e giriamo a destra, eseguendo il _101/quale si divide nper 101. Se nè 101, allora n/101 = 1andiamo in @, che termina il programma. Altrimenti, la nostra situazione attuale è

Main [ n 0 | n n ] Aux

Arancione 1 (mod 3)

3trasforma lo zero superiore in 3 ( 10*0 + 3 = 3) ed %esegue un modulo. Se n%3è positivo, giriamo a destra nel giallo ". Altrimenti eseguiamo 70.105.122:.., quali output Fizz. Si noti che non è necessario inviare nuovi zero con _poiché n%3era zero in questo caso, quindi possiamo sfruttare gli zero infiniti nella parte inferiore dello stack. Entrambi i percorsi si incontrano di nuovo in azzurro.

Azzurro

La parte superiore dello stack è attualmente n%3, il che potrebbe essere positivo, quindi il _;giusto spinge uno zero e lo fa immediatamente scoppiare per assicurarci di andare dritto, invece di trasformarci in @. Usiamo quindi =per scambiare le cime delle pile principali e ausiliarie, dando:

Main [ n | n%3 n ] Aux

Orange 2 (mod 5)

Questa è una situazione simile a prima, eccetto che 66.117.122:..genera Buzzifn%5 è zero.

Blu scuro

La sezione precedente lascia le pile simili

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

{sposta la parte n%3posteriore nello stack principale e *moltiplica i due moduli.

Se uno dei due moduli è zero, il prodotto è zero, quindi andiamo direttamente in giallo. =scambia la parte superiore delle pile e _spinge uno zero per assicurarsi di andare dritto, dando

Main [ n 0 | 0 ] Aux

Altrimenti, se entrambi i moduli sono diversi da zero, il prodotto è diverso da zero e trasformiamo a destra in verde. =scambia le cime delle pile, dando

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

dopo di che usiamo :per duplicare n, girare a destra, quindi usare !per l'output n.

Viola

A questo punto, la pila principale ha uno o due oggetti, a seconda del percorso preso. Dobbiamo sbarazzarci dello zero dal percorso giallo, e per farlo usiamo +, che si comporta n + 0in un certo ordine per entrambi i casi. Finalmente,\ genera una nuova riga e siamo di nuovo all'inizio.

Ogni iterazione aggiunge un extra (n%5)*(n%3)allo stack ausiliario, ma per il resto facciamo di nuovo la stessa cosa.

Perl 5, 49 byte

46 byte di script + 3 byte -E"..."

L'uso say(che richiede -E"...") può ridurlo ulteriormente a 46 byte poiché sayinclude automaticamente una nuova riga (Grazie @Dennis !):

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

Perl 5, 50 byte

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

Rubino, 50 byte

Richiede la versione 1.8, che sembra essere popolare tra i golfisti:

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

Nel moderno Ruby, si sostituisce ?dcon 100una soluzione a 51 byte.

Questo sembra essere il record mondiale.

Java, 130 byte

Questo è per le recenti versioni di Java (7+). In quelli più vecchi puoi radere un po 'di più usando il enumtrucco, ma non penso che la logica si accorcia di così (86 all'interno 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

Provalo qui

Spiegazione:

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 byte

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

Provalo online!

Spiegazione

.100{`^
_

La .è la bandiera silenziosa globale che disattiva uscita implicito alla fine del programma. 100{avvolge il resto del programma in un ciclo che viene eseguito per 100 iterazioni. Infine, il palco stesso inserisce solo a_ all'inizio della stringa, il che aumenta efficacemente un contatore di loop unario.

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

Più configurazione. *\(avvolge il resto del programma in un gruppo, stampa il suo risultato con un avanzamento riga finale, ma mette anche l'intero gruppo in una fase a secco, il che significa che il suo risultato verrà scartato dopo la stampa, in modo che il nostro contatore di loop non sia effettivamente modificato . aè un modificatore regex personalizzato che ancora il regex all'intera stringa (che salva un byte sull'uso ^e in modo $esplicito).

Lo stadio atomico stesso si occupa di Fizz. La divisibilità 3può essere facilmente verificata in modo unario: basta verificare se il numero può essere scritto come ripetizione di ___. In questo caso, anteponiamo Fi;alla stringa. Il punto e virgola è in modo che ci sia ancora un limite di parole davanti al numero per la fase successiva. Se trasformassimo la linea nella Fizz___...posizione tra ze _non saremmo considerati un limite, perché regex tratta sia le lettere che i caratteri di sottolineatura come caratteri di parole. Tuttavia, il punto e virgola ci consente anche di rimuovere la zzduplicazione da Fizze Buzz.

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

Facciamo lo stesso per la divisibilità per 5e Bu;, anche se non abbiamo bisogno di mantenere la _s in questo momento. Quindi otterremmo un risultato simile

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

Questo rende molto facile sbarazzarsi dei caratteri di sottolineatura solo in quelle righe che contengono Fizz, compilando anche zzi messaggi di testo:

;_*
zz

Cioè, trasformiamo ogni punto e virgola in zzma consumiamo anche tutto il resto _subito dopo. A questo punto abbiamo finito con FizzBuzz in unario. Ma la sfida vuole un output decimale.

'_&`.

&indica un condizionale: questa fase viene eseguita solo se la stringa contiene un carattere di sottolineatura. Pertanto, Fizz, Buzze FizzBuzzle iterazioni non vengono toccati. In tutte le altre iterazioni (ovvero quelle che non sono né divisibili per 3 né 5), contiamo solo il numero di caratteri, convertendo il risultato in decimale.

gs2 , 1

f

Una citazione di Mauris, il creatore di gs2:

Volevo un byte di 1 byte di gorubyHello, world! , quindi ... Questo stampa "1\n2\nFizz\n4\nBuzz\n...". :)

Aggiornamento : aggiunta una risposta a 27 byte che non utilizza f.

Perl 5, 45 byte

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

Richiede l' -Eopzione, considerata come una. Questo deve essere eseguito dalla riga di comando, ovvero:

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

Citazioni attorno al comando sono inutili, se si evita l'uso di spazi o altri caratteri che possono agire come separatori riga di comando ( |, <,> , &, etc.).

Perl 5, 48 byte

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

Se le opzioni della riga di comando vengono conteggiate come una a testa, -lsi risparmierebbe un byte (sostituendolo $/). Secondo le regole classiche di Perlgolf , tuttavia, ciò conterrebbe 3: uno per il -, uno per il le uno per lo spazio necessario.

cera d'api ,104 89 81 byte

Imballaggio più denso consentito per tagliare altri 8 byte.

Soluzione più breve (81 byte), stesso flusso di programma, imballaggio diverso.

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

La modifica del concetto mi ha permesso di ridurre il codice di 15 byte. Volevo sbarazzarmi del doppio test mod 5 nella soluzione, quindi ho implementato una bandiera.

Breve spiegazione:

se n%3=0Fizz viene stampato e la bandiera viene impostata. La bandiera si realizza semplicemente spingendo il valore lstack superiore sul gstack (istruzioni f).

Se n%5=0, quindi n%3=0(caso FizzBuzz) o n%3>0(caso Buzz). In entrambi i casi, Buzz viene stampato e la bandiera viene ripristinata facendo scoppiare la pila fino a quando non è vuota (istruzioni ?).

Ora i casi interessanti:

Se n%5>0, allora o abbiamo avuto n%3=0(stampando la custodia Fizz, n non deve essere stampato) o n%3>0(Fizz non è stata stampata, quindi n deve essere stampato). È ora di controllare la bandiera. Questo si ottiene spingendo la lunghezza di gstack sopra gstack (istruzioni A). Se n%3 was 0la lunghezza del gstack è> 0. Se n%3 was >0la lunghezza di gstack è 0. Un semplice salto condizionale assicura che n venga stampato solo se la lunghezza di gstack era 0.

Ancora una volta, dopo aver stampato uno qualsiasi di n, Fizz e / o Buzz e la nuova riga, lo gstack viene visualizzato due volte per assicurarsi che sia vuoto. gstack è vuoto [], il che porta a [0]dopo le istruzioniA (spingere la lunghezza di gstack su gstack), oppure contiene uno zero ( [0], il risultato di n% 3), che porta a [0 1], poiché [0] ha la lunghezza 1. Popping da un la pila vuota non cambia la pila, quindi è sicuro far scoppiare due volte.

Se guardi più da vicino puoi vedere che, in linea di principio, ho piegato

>      q
d`Fizz`f>

dentro, come moto a luogo, andare da dentro a fuori: I put my hand inTO my pocket = metto la mano in tasca

<f`z`<
d`Fiz`b

che aiuta a sbarazzarsi di tutto lo spazio sprecato tra Ae <alla fine della riga seguente nella soluzione precedente di seguito:

q?{@b'gA<       p      <

Nuova soluzione concettuale (89 byte) con spiegazione animata:

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

Layout esagonale:

   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

Animazione dei primi 326 tick a 2 fps, con stack locali e globali, e output su STDOUT.

Per un confronto, di seguito sono riportati gli overlay di percorso della soluzione più vecchia e complessa. Forse è anche la soluzione più bella, dal punto di vista visivo;)

> <> , 68 66 65 64 byte

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

L'unico trucco è moltiplicare i resti come condizione per la stampa numerica. In questo modo, se uno di questi è 0, non stamperemo il numero.

Puoi provarlo qui .

Salvato un byte grazie a Sp3000 e un altro grazie a randomra. Grazie molto!

gs2 , 28 27 (senza f)

Esadecimale:

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

Spiegazione:

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

Incorporare 3 e 5 nella costante di stringa non funziona perché \x05termina i valori letterali di stringa.

Nota: questo problema può essere risolto in 1 byte con gs2 utilizzando il built-in f.

C, 85 byte

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

-2 grazie a schizzinosi.

CJam, 35 byte

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

Provalo online nell'interprete CJam .

Come funziona

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 byte

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

Cos'è questa w:$X<3 icosa, chiedi? $Xè una variabile magica (un "intrinseco") che memorizza la posizione orizzontale del cursore di output (come un numero di caratteri dal bordo sinistro del terminale). wè la forma abbreviata del WRITEcomando. La sintassi command:condition argsè post-condizionale - "if condition, then docommand args ".

Quindi stiamo verificando se il cursore di output è stato avanzato di più di due caratteri (il che significherebbe che almeno uno "Fizz"o "Buzz"è stato scritto sul terminale) e, in caso contrario, la scrittura isul terminale. La $Xvariabile - e quindi questa sorta di profonda inseparabilità dal terminale - è una caratteristica di prima classe di MUMPS. Yikes.

Gelatina , 24 20 byte

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

Provalo online!

Come funziona

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

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

formattato:

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

Provalo online

Il layout della memoria è

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

dove fcicli di 3, bcicli di 5, d1è una cifra, d2è cifra decina, sè una bandiera per se stampare la cifra di decine, dcicli per 10, cè lo spazio di copia per d, tè lo spazio di lavoro che contiene 0 o dati spazzatura o una bandiera per non -divisible-by-3 e adetermina la fine del programma spostando il puntatore dopo che Buzz è stato stampato 20 volte.

C #, 128 126 125 124 byte

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 byte senza il codice del boilerplate in giro.

Fatto con l'uso della formattazione condizionale di C # .

Con due separatori di sezione ;, Fizz o Buzz vengono stampati se il valore dalla loro condizione è zero.

Salvataggio totale di 4 byte grazie a @RubberDuck, @Timwi e @Riokmij.

Clojure, 113 106 101 100 91 byte

Il mio primo golf!

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

Ungolfed:

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

brainfuck , 411 350 277 258 byte

modifiche:

• -61 byte memorizzando i valori di "Fizz Buzz" come "BuziF" "BuziG" e ripetendo la sezione di stampa numerica.

• -71 byte ripetendo la sezione di stampa del numero di modulo, suddividendo il contatore di loop e il contatore di numeri e riutilizzando la cella newline come valore mod, tra le altre cose

• -19 byte rendendosi conto che non ci sono 0 in nessun numero FizzBuzz. Inoltre aggiunta spiegazione

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

Provalo online!

Invece di verificare se il numero era divisibile per 5 o 3 avevo due contatori che tenevano traccia del modulo del numero, diminuendoli per ciascun numero e stampando la parola corrispondente quando raggiungevano 0.

Come funziona:

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

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

_{Modifica: salvato 10 byte grazie a feersum}

_{Edit2: ho realizzato che con il trucco di feersum non ho più bisogno di formulare $ t come blocchi di stringhe di codice}

_{Edit3: salvato altri 7 byte grazie a Danko Durbić}

Simile nello spirito alla risposta del codice Rosetta di serie , ma è sceso un po 'giù.

Spiegazione

1..100|%{...} Crea una raccolta da 1 a 100, quindi esegui per ogni oggetto in quella raccolta

(...,$_)crea una nuova raccolta di due elementi: 0) $t=...imposta la variabile $tuguale a una stringa; 1) il $_nostro numero corrente del loop

"Fizz"*!($_%3)prendi il nostro numero corrente, modificalo di 3, quindi NON il risultato. Moltiplica "Fizz" per quello e aggiungilo alla stringa (e simile per 5). PowerShell considera qualsiasi numero diverso da zero come $TRUE, e quindi il NOT di un numero diverso da zero è 0, il che significa che solo se il nostro numero corrente è un multiplo di 3 "Fizz" verrà aggiunto alla stringa.

[!$t] si indicizza nella raccolta che abbiamo appena creato, in base al valore della stringa $t : non vuota, stampala, altrimenti stampa il nostro numero corrente

In alternativa, anche 54 byte

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

_{Grazie a TesselatingHeckler}

Simile nel concetto, questo utilizza l'inline -replace operatore e un'espressione regolare per scambiare una stringa vuota ^$con il nostro numero corrente. Se la stringa non è vuota, non viene scambiata.

In alternativa, anche 54 byte

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

Questa è la stessa struttura ad anello di cui sopra, ma al suo interno ordina la coppia (n, stringa) e si basa sul fatto che una stringa vuota ordina prima di un numero, ma una stringa FizzBuzz ordina dopo un numero. Quindi indicizza il risultato del secondo ordinamento.

JavaScript, 62 byte

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

Penso che questa sia la soluzione Javascript più corta ora.

C, 74 byte

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

L' 0argomentazione printfinvece di ""è sospetta, ma sembra funzionare sulla maggior parte delle piattaforme su cui ci provo.putssegfault quando provi la stessa cosa, però. Senza di essa, si ottengono 75 byte.

Esistono soluzioni a 73 byte che funzionano sul golf dell'anarchia e ne ho trovata una che scava nei posti giusti su Internet, ma si basano su comportamenti specifici della piattaforma. (Come avrai intuito, è una specie di forma puts("Buzz"±...).)

Scratch, 203 185 byte

Byte conteggiati dalla rappresentazione testuale golfizzata , per questo meta post . Scratch non è molto efficiente in termini di spazio.

sayè la cosa più vicina a uno stdout Scratch: lo sprite mostra un fumetto contenente tutto ciò che sta dicendo. In pratica, wait n secssarebbe necessario un blocco per leggere effettivamente questo output, ma ai fini di questa sfida questo codice soddisfa i requisiti.

R, 88 83 77 71 70 byte

Sono sicuro che questo può essere migliorato ... ed è stato merito di @flodel. Un altro paio di byte salvati grazie a un suggerimento di @njnnja e un altro di @ J.Doe

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

Haskell, 84 byte

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

Avvicinarsi agli 81 byte di henkma , ma non ancora del tutto.

d = drop.(*4).mod nè la chiave qui: d 3 "Fizz"è drop (n`mod`3 * 4) "Fizz". Questo è "Fizz"quando n `mod` 3è 0 e in caso ""contrario.

PHP, 54 byte

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

Valido per v5.5 in poi. Il õpersonaggio è 245, un po 'invertito\n .

Presumo le impostazioni predefinite dell'interprete, in quanto sono senza ini. Se non si è sicuri, è possibile disabilitare la propria ini locale con-n come in php -n fizzbuzz.php.

Una versione che verrà eseguita senza errori con qualsiasi file di configurazione è di 62 byte :

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

80386 codice macchina + DOS, 75 byte

Hexdump del codice:

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

Codice sorgente (sintassi 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

Questo codice conta da 1 a 100 pollici ax, costruendo il messaggio di output dalla fine all'inizio. La fine del messaggio (newline e il $carattere che DOS usa per il flag di fine messaggio) appare all'inizio del codice:

db 10, 10, '$'

Viene eseguito come un'istruzione innocua (or ax, 240ah ). Potrei metterlo in un posto più convenzionale, come dopo la fine del codice, ma averlo all'indirizzo 0x100 ha un vantaggio.

Il codice utilizza anche 2 contatori aggiuntivi:

• Conteggio da 3 a 0 pollici dl
• Conteggio da 5 a 0 pollici dh

Quando un contatore raggiunge 0, invia la stringa Fizzo Buzzalla fine del messaggio di output. Se ciò accade, bxverrà ridotto ebh sarà zero. Questo è usato come condizione per emettere il numero in forma decimale.

Nota: sto usando i dati a 32 bit qui. Questo non funzionerà su un computer pre-386.

dc, 64 62 byte

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