Einführung

In unserem jüngsten Bestreben, Kataloge mit kürzesten Lösungen für Standard-Programmierübungen zu sammeln, ist dies die erste Vanille-FizzBuzz-Herausforderung von PPCG. Wenn Sie andere Katalogherausforderungen sehen möchten, gibt es "Hallo Welt!" und "Ist diese Zahl eine Primzahl?" .

Herausforderung

Schreiben Sie ein Programm, das die Dezimalzahlen von 1 bis einschließlich 100 ausgibt. Bei einem Vielfachen von drei wird "Fizz" anstelle der Zahl und bei einem Vielfachen von fünf "Buzz" gedruckt. Bei Zahlen, die ein Vielfaches von drei und fünf sind, wird „FizzBuzz“ gedruckt.

Ausgabe

Die Ausgabe besteht aus einer Liste von Zahlen (und Fizzes, Buzzes und FizzBuzzes), die durch einen Zeilenumbruch (entweder \noder \r\n) getrennt sind. Ein abschließender Zeilenumbruch ist akzeptabel, ein führender Zeilenumbruch jedoch nicht. Abgesehen von Ihrer Wahl von newline sollte die Ausgabe genau so aussehen:

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

Die einzige Ausnahme von dieser Regel ist die konstante Ausgabe des Interpreters Ihrer Sprache, die nicht unterdrückt werden kann, z. B. eine Begrüßung, ANSI-Farbcodes oder Einrückungen.

Weitere Regeln

• Hierbei geht es nicht darum, die Sprache mit dem kürzesten Ansatz für das Spielen von FizzBuzz zu finden, sondern darum, den kürzesten Ansatz in jeder Sprache zu finden. Daher wird keine Antwort als angenommen markiert.

• Einreichungen werden in Bytes in einer geeigneten, bereits vorhandenen Codierung bewertet, normalerweise (aber nicht unbedingt) UTF-8. Einige Sprachen, wie Ordner, sind etwas schwierig zu bewerten - im Zweifelsfall fragen Sie bitte bei Meta nach.

• In STDERR kann nichts gedruckt werden.

• Im Gegensatz zu unseren üblichen Regeln können Sie eine Sprache (oder Sprachversion) auch dann verwenden, wenn diese neuer als diese Herausforderung ist. Wenn jemand dies missbrauchen möchte, indem er eine Sprache erstellt, in der das leere Programm eine FizzBuzz-Ausgabe generiert, dann herzlichen Glückwunsch, dass er den Weg für eine sehr langweilige Antwort ebnet.

  Beachten Sie, dass ein Dolmetscher vorhanden sein muss, damit die Einreichung getestet werden kann. Es ist erlaubt (und sogar empfohlen), diesen Dolmetscher für eine zuvor nicht implementierte Sprache selbst zu schreiben.

• Wenn Ihre bevorzugte Sprache eine triviale Variante einer anderen (möglicherweise populäreren) Sprache ist, die bereits eine Antwort hat (denken Sie an BASIC- oder SQL-Dialekte, Unix-Shells oder triviale Brainfuck-Derivate wie Alphuck und ???), sollten Sie eine Anmerkung zur vorhandenen hinzufügen antworte, dass die gleiche oder eine sehr ähnliche Lösung auch in der anderen Sprache die kürzeste ist.

• Da die Ausgabe fest ist, können Sie die Ausgabe fest codieren (dies ist jedoch möglicherweise nicht die kürzeste Option).

• Sie können bereits vorhandene Lösungen verwenden, sofern Sie den ursprünglichen Autor des Programms angeben.

• Standardlücken sind ansonsten nicht zulässig.

Bitte stimmen Sie langweiligen (aber gültigen) Antworten in Sprachen nicht ab, in denen es nicht viel zum Golfen gibt. Diese sind für diese Frage nach wie vor hilfreich, da versucht wird, einen Katalog so vollständig wie möglich zusammenzustellen. Stimmen Sie Antworten jedoch in erster Linie in Sprachen ab, in denen die Autoren tatsächlich Anstrengungen unternehmen mussten, um den Code zu entwickeln.

Katalog

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

Hexagony , 91 Bytes

Danke für das Kopfgeld :)

Wow, ich hätte nie gedacht, dass ich Martins Hexagony-Lösung schlagen könnte . Aber - wer hätte das gedacht - ich habe es geschafft. Nach mehreren Tagen des Scheiterns, weil ich weder den Hexagony-Farbstoff noch das EsotericIDE hatte , um meine Lösung zu überprüfen. Ich habe einige Aspekte der Spezifikation falsch verstanden, deshalb habe ich ein paar falsche „Lösungen“ nur mit Stift und Papier und einem Texteditor erstellt. Nun, endlich habe ich meine Faulheit überwunden und beide Repositories geklont, VisualStudio heruntergeladen und kompiliert. Wow, was für nützliche Werkzeuge das sind! Wie Sie sehen, bin ich weit davon entfernt, jemand zu sein, den Sie als Programmierer bezeichnen würden (ich meine, komm schon! Ich hatte nicht einmal VisualStudio installiert und hatte so gut wie keine Ahnung, wie man ein Programm kompiliert);)

Ich habe noch eine Weile gebraucht, um eine funktionierende Lösung zu finden, und es ist ziemlich voll und chaotisch, aber hier ist es in seiner ganzen Pracht:

Fizzbuzz in einem Sechseck der Größe 6:

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

Sechseckiges Layout:

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

Und die schöne Wiedergabe dank Timwis Hexagony Colorer :

Hier ist also eine 110 Sekunden lange GIF-Animation mit 2 fps, die den Programmfluss während der ersten 6 Zahlen 1, 2, Fizz, 4, Buzz, Fizzund die ersten 220 Ticks des Programms zeigt (klicken Sie auf das Bild, um es in voller Größe zu sehen):

Meine Güte, dank der Natron-Compositing-Software war die Animation des Zeigers noch mühsam zu erstellen, aber überschaubar. Das Speichern von 260 Bildern des Speichers war weniger amüsant. Leider kann EsotericIDE das nicht automatisch tun. Wie auch immer, viel Spaß mit der Animation!

Schließlich ist Hexagony gar nicht so schwer zu bearbeiten, wenn Sie sich erst einmal mit dem Gedächtnismodell und dem eher intuitiven Umschließen von Pfaden befasst haben, die die Grenzen des Sechsecks überschreiten. Aber Golfen kann ein Schmerz im Hintern sein. ;)

Es hat Spaß gemacht!

Labyrinth , 94 Bytes

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

Sub-100! Dies war ein Spaß.

Erläuterung

Beginnen wir mit einer kurzen Einführung in Labyrinth - überspringen Sie diese, wenn Sie bereits mit den Grundlagen vertraut sind:

• Labyrinth hat zwei Stapel - einen Hauptstapel und einen Hilfsstapel. Beide Stapel haben eine unendliche Anzahl von Nullen am unteren Rand, z. B. +bei einem leeren Stapel werden zwei Nullen addiert, wodurch Null gedrückt wird.

• Der Kontrollfluss im Labyrinth wird durch Kreuzungen bestimmt, die oben im Stapel nachsehen, um zu bestimmen, wohin sie als nächstes führen. Negativ bedeutet links abbiegen, Null bedeutet geradeaus und Positiv bedeutet rechts abbiegen ... aber wenn wir gegen eine Wand stoßen, kehren wir die Richtung um. Wenn zum Beispiel nur geradeaus und links abbiegen möglich sind, aber die Spitze des Stapels positiv ist, dann biegen wir stattdessen links ab, da wir nicht rechts abbiegen können.

• Zahlen im Labyrinth knallen xund drücken 10*x + <digit>, wodurch es einfach ist, große Zahlen aufzubauen. Dies bedeutet jedoch, dass wir eine Anweisung zum Drücken von 0 benötigen, um eine neue Zahl zu beginnen, die sich _im Labyrinth befindet.

Kommen wir nun zum eigentlichen Code!

rot

Die Ausführung beginnt "in der oberen linken Ecke, die ein NOP ist. Als nächstes wird )der obere Teil des Stapels inkrementiert, indem beim ersten Durchgang 1 gedrückt und nbei jedem folgenden Durchgang inkrementiert wird.

Als nächstes duplizieren wir nmit :. Da dies npositiv ist, biegen wir nach rechts ab und führen die Befehle }(Verschieben des oberen Bereichs des Hauptstapels nach AUX) und aus :. Wir schlagen eine Sackgasse, so dass wir umdrehen und ausführen }und :wieder, so dass die Stapel wie

Main [ n n | n n ] Aux

Ist wieder npositiv und wir biegen rechts ab und führen _101/das ndurch 101 dividierte aus. Wenn ndann 101 ist n/101 = 1, biegen wir in das ein @, was das Programm beendet. Ansonsten ist unsere aktuelle Situation

Main [ n 0 | n n ] Aux

Orange 1 (Mod 3)

3verwandelt die obere Null in eine 3 ( 10*0 + 3 = 3) und %führt ein Modulo aus. Wenn n%3positiv, biegen wir rechts ab in die gelbe ". Ansonsten führen wir aus 70.105.122:.., welche Ausgänge Fizz. Beachten Sie, dass wir in diesem Fall keine neuen Nullen mit pushen müssen, _da dies n%3Null war, sodass wir die unendlichen Nullen am unteren Rand des Stapels ausnutzen können. Beide Wege treffen sich hellblau wieder.

Hellblau

Die Spitze des Stapels ist momentan n%3, was positiv sein könnte, also _;drückt der einfach eine Null und wirft sie sofort auf, um sicherzustellen, dass wir geradeaus gehen, anstatt in die umzudrehen @. Wir =tauschen dann die Oberseiten des Haupt- und des Hilfsstapels aus, um Folgendes zu erhalten:

Main [ n | n%3 n ] Aux

Orange 2 (Mod 5)

Dies ist eine ähnliche Situation wie zuvor, mit der Ausnahme, dass nur 66.117.122:..ausgegeben wird, Buzzwenn n%5Null ist.

Dunkelblau

Der vorherige Abschnitt lässt die Stapel mögen

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

{verschiebt den n%3Rücken zum Hauptstapel und *multipliziert die beiden Module.

Wenn eines der beiden Module Null ist, ist das Produkt Null, und wir gehen direkt zu Gelb über. =tauscht die Oberseite der Stapel und _drückt eine Null, um sicherzustellen, dass wir geradeaus gehen und geben

Main [ n 0 | 0 ] Aux

Wenn andernfalls beide Module ungleich Null sind, ist das Produkt ungleich Null und wir biegen rechts in grün ab. =tauscht die Oberseiten der Stapel und gibt

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

wonach wir verwenden :zu duplizieren n, biegen Sie rechts ab, dann verwenden Sie !die Ausgabe n.

Lila

Zu diesem Zeitpunkt verfügt der Hauptstapel über ein oder zwei Elemente, je nachdem, welcher Pfad genommen wurde. Wir müssen die Null aus dem gelben Pfad entfernen und das tun +, was n + 0in beiden Fällen in einer bestimmten Reihenfolge funktioniert . Endlich \gibt eine neue Zeile aus und wir sind wieder am Start.

Bei jeder Iteration wird ein zusätzliches Element (n%5)*(n%3)in den Zusatzstapel verschoben, ansonsten wird das Gleiche erneut ausgeführt.

Perl 5, 49 Bytes

46 Bytes Skript + 3 Bytes -E"..."

Mit say(was erfordert -E"...") kann dies weiter auf 46 Byte reduziert werden, da sayautomatisch eine neue Zeile eingefügt wird (Danke @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

Benötigt die Version 1.8, die bei Golfern sehr beliebt zu sein scheint:

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

In der modernen Rubin, ersetzen Sie ?dmit 100einer 51-Byte - Lösung.

Dies scheint der Weltrekord zu sein.

Java, 130 Bytes

Dies gilt für neuere Java-Versionen (7+). Bei älteren kann man sich mit dem enumTrick etwas mehr abschneiden , aber ich glaube, die Logik wird nicht kürzer als diese (86 im Inneren 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

Probieren Sie es hier aus

Erläuterung:

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
'_&`.

Probieren Sie es online!

Erläuterung

.100{`^
_

Dies .ist das globale stille Flag, das die implizite Ausgabe am Ende des Programms ausschaltet. 100{Wickelt den Rest des Programms in eine Schleife, die für 100 Iterationen ausgeführt wird. Schließlich fügt die Bühne selbst nur ein _am Anfang der Zeichenfolge, was effektiv einen unären Schleifenzähler erhöht.

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

Mehr Konfiguration. *\(Bricht den Rest des Programms in eine Gruppe ein, druckt das Ergebnis mit einem nachgestellten Zeilenvorschub, versetzt aber auch die gesamte Gruppe in einen Probelauf, was bedeutet, dass das Ergebnis nach dem Drucken verworfen wird, sodass unser Schleifenzähler nicht geändert wird . aist ein benutzerdefinierter Regex-Modifizierer, der den Regex an der gesamten Zeichenfolge verankert (wodurch ein Byte bei der Verwendung von ^und $explizit gespart wird ).

Die Atomstufe selbst kümmert sich darum Fizz. Die Teilbarkeit durch 3kann leicht unärgerlich überprüft werden: Testen Sie einfach, ob die Zahl als Wiederholung von geschrieben werden kann ___. In diesem Fall stellen wir Fi;die Zeichenfolge voran . Das Semikolon ist so, dass vor der Zahl noch eine Wortgrenze für die nächste Stufe steht. Wenn wir die Linie in Fizz___...die Position zwischen drehen zund _sie nicht als Grenze betrachten würden, würde Regex sowohl Buchstaben als auch Unterstriche als Wortzeichen behandeln. Das Semikolon ermöglicht es uns jedoch auch, die zzDuplizierung von Fizzund zu entfernen Buzz.

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

Wir machen genau dasselbe für die Teilbarkeit durch 5und Bu;, obwohl wir die _s diesmal nicht aufbewahren müssen . So würden wir ein Ergebnis wie bekommen

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

Dies macht es sehr einfach, die Unterstriche nur in den Zeilen zu entfernen Fizz, die enthalten , und gleichzeitig das zzs auszufüllen:

;_*
zz

Das heißt, wir verwandeln jedes Semikolon in zz, verbrauchen aber auch alle _s direkt danach. An diesem Punkt sind wir mit FizzBuzz in Unary fertig. Aber die Herausforderung will eine dezimale Ausgabe.

'_&`.

&Gibt eine Bedingung an: Diese Phase wird nur ausgeführt, wenn der String einen Unterstrich enthält. Deshalb Fizz, Buzzund FizzBuzzsind Iterationen unberührt gelassen. Bei allen anderen Iterationen (dh solchen, die weder durch 3 noch durch 5 teilbar sind) wird nur die Anzahl der Zeichen gezählt und das Ergebnis in eine Dezimalzahl umgewandelt.

gs2 , 1

f

Ein Zitat von Mauris, dem Schöpfer von gs2:

Ich wollte Gorubys 1-Byte hochrechnenHello, world! , also ... Das wird gedruckt "1\n2\nFizz\n4\nBuzz\n...". :)

Update : 27-Byte- Antwort hinzugefügt , die nicht verwendet wird f.

Perl 5, 45 Bytes

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

Benötigt die -EOption, als eins gezählt. Dies muss von der Kommandozeile ausgeführt werden, dh:

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

Anführungszeichen um den Befehl sind nicht erforderlich, wenn man vermeidet , unter Verwendung von Leerzeichen oder andere Zeichen , die als Befehlszeilentrenner fungieren können ( |, <, >, &, etc.).

Perl 5, 48 Bytes

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

Wenn die Befehlszeilenoptionen jeweils als eine gezählt werden, -lwürde ein Byte gespart (durch Ersetzen $/). Nach den klassischen Perlgolfregeln zählt dies jedoch 3: eine für den -, eine für den lund eine für den erforderlichen Platz.

Bienenwachs ,104 89 81 Bytes

Die dichtere Packung ermöglichte das Abschneiden von 8 weiteren Bytes.

Kürzeste Lösung (81 Byte), gleicher Programmablauf, unterschiedliche Packung.

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

Durch die Änderung des Konzepts konnte ich den Code um 15 Byte reduzieren. Ich wollte den Double Mod 5 Test in der Lösung loswerden, also habe ich ein Flag implementiert.

Kurze Erklärung:

wenn n%3=0Fizz gedruckt wird und das Flag gesetzt wird. Das Flag wird einfach durch Aufschieben des obersten Stapelwerts auf den gstack (Befehl f) realisiert.

Wenn ja n%5=0, dann entweder n%3=0(FizzBuzz-Fall) oder n%3>0(Buzz-Fall). In beiden Fällen wird Buzz gedruckt, und das Flag wird zurückgesetzt, indem der Stapel so lange geöffnet wird, bis er leer ist (Anweisung ?).

Nun die interessanten Fälle:

Wenn n%5>0, dann hatten wir entweder n%3=0(Fizz-Fall drucken, n muss nicht gedruckt werden) oder n%3>0(Fizz wurde nicht gedruckt, also muss n gedruckt werden). Zeit, die Flagge zu überprüfen. Dies wird realisiert, indem die Länge des Stapels auf den Stapel geschoben wird (Anweisung A). Wenn n%3 was 0dann die gstack-Länge> 0 ist. Wenn n%3 was >0, ist die Stapellänge 0. Ein einfacher bedingter Sprung stellt sicher, dass n nur gedruckt wird, wenn die Länge von gstack 0 war.

Nachdem n, Fizz und / oder Buzz und / oder die Newline gedruckt wurden, wird der Stapel erneut zweimal aufgerissen, um sicherzustellen, dass er leer ist. gstack ist entweder leer [], was zu [0]after instruction führt A(Länge von gstack auf gstack schieben), oder es enthält eine Null ( [0]das Ergebnis von n% 3), was dazu führt [0 1], dass [0] die Länge 1 hat leerer Stapel ändert den Stapel nicht, daher ist es sicher, zweimal zu platzieren.

Wenn Sie genauer hinschauen, können Sie sehen, dass ich im Prinzip gefoldet habe

>      q
d`Fizz`f>

in

<f`z`<
d`Fiz`b

Dies hilft, den verschwendeten Platz zwischen Aund <am Ende der folgenden Zeile in der älteren Lösung unten zu beseitigen:

q?{@b'gA<       p      <

Neue Konzeptlösung (89 Byte) mit animierter Erklärung:

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

Sechseckiges Layout:

   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

Animation der ersten 326 Ticks mit 2 fps mit lokalen und globalen Stapeln und Ausgabe an STDOUT.

Zum Vergleich sind im Folgenden die Pfadüberlagerungen der älteren, komplexeren Lösung aufgeführt. Vielleicht ist es auch optisch die schönere Lösung;)

> <> , 68 66 65 64 Bytes

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

Der einzige Trick besteht darin, die Reste als Bedingung für das Drucken von Zahlen zu multiplizieren. Auf diese Weise wird die Nummer nicht gedruckt, wenn eine von ihnen 0 ist.

Sie können es hier ausprobieren .

Speichert ein Byte dank Sp3000 und ein anderes dank Randomra. Danke vielmals!

gs2 , 28 27 (ohne f)

Verhexen:

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

Erläuterung:

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

Das Einbetten von 3 und 5 in die String-Konstante funktioniert nicht, da \x05String-Literale enden.

Hinweis: Dieses Problem kann in 1 Byte mit gs2 mit dem eingebauten gelöst werden 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 dank squeamish.

CJam, 35 Bytes

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

Probieren Sie es online im CJam-Interpreter aus .

Wie es funktioniert

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 !

Was ist das für ein w:$X<3 iDing, fragst du? $Xist eine magische Variable (eine "intrinsische" Variable), die die horizontale Position des Ausgabe-Cursors (als Anzahl von Zeichen vom linken Rand des Terminals) speichert. wist die abgekürzte Form des WRITEBefehls. Die Syntax command:condition argsist eine nachbedingte - "wenn condition, dann tun command args".

Wir sind also zu prüfen , ob die Ausgabe Cursor mehr als zwei Zeichen sind vorverlegt worden (was bedeuten würde , dass mindestens eine der "Fizz"oder "Buzz"ist an das Terminal geschrieben wurde), und wenn nicht, das Schreiben ian das Terminal. Die $XVariable - und damit diese Art der tiefen Untrennbarkeit vom Terminal - ist ein erstklassiges Merkmal von MUMPS. Huch.

Gelee , 24 20 Bytes

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

Probieren Sie es online!

Wie es funktioniert

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

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

Formatiert:

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

Probieren Sie es online aus

Das Speicherlayout ist

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

Wobei fZyklen um 3, bZyklen um 5, d1eine Ziffer sind, d2eine Zehnerstelle sind, sein Kennzeichen dafür ist, ob Zehnerstellen gedruckt werden sollen, dZyklen um 10, cein Kopierbereich für d, tein Arbeitsbereich, der 0 oder Junk-Daten enthält, oder ein Kennzeichen für nicht -divisible-by-3, und abestimmt die Programmbeendigung durch Versetzen des Zeigers, nachdem Buzz 20 Mal gedruckt wurde.

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 ohne den Kesselschildcode herum.

Fertig mit der Verwendung der bedingten Formatierung von C # .

Bei Trennzeichen mit zwei Abschnitten ;werden Fizz oder Buzz gedruckt, wenn der Wert aus ihrer Bedingung Null ist.

Insgesamt 4 Bytes dank @RubberDuck, @Timwi und @Riokmij gespeichert.

Clojure, 113 106 101 100 91 Bytes

Mein erstes 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 Bytes

Bearbeitungen:

• -61 Bytes durch Speichern der Werte von "Fizz Buzz" als "BuziF" "BuziG" und Wiederholen des Nummerndruckabschnitts.

• -71 Bytes durch Wiederholen des Modulo-Nummer-Druckabschnitts, Aufteilen des Schleifenzählers und des Nummerzählers und Wiederverwenden der Newline-Zelle unter anderem als Mod-Wert

• -19 Bytes, indem erkannt wird, dass in FizzBuzz-Zahlen keine Nullen sind. Auch Erklärung hinzugefügt

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

Probieren Sie es online!

Anstatt zu überprüfen, ob die Zahl selbst durch 5 oder 3 teilbar war, ließ ich zwei Zähler das Modulo der Zahl verfolgen, dekrementierte sie für jede Zahl und druckte das entsprechende Wort aus, wenn sie 0 erreichten.

Wie es funktioniert:

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

_{Edit: 10 Bytes dank feersum gespeichert}

_{Edit2: Es wurde mir klar, dass ich mit Feersums Trick $ t nicht mehr als Code-Block-Zeichenfolge formulieren muss}

_{Edit3: Weitere 7 Bytes dank Danko Durbić gespeichert}

Im Geiste ähnlich wie die serienmäßige Rosetta Code- Antwort , aber einiges heruntergespielt.

Erläuterung

1..100|%{...} Erstellen Sie eine Sammlung von 1 bis 100, und führen Sie dann für jedes Objekt in dieser Sammlung Folgendes aus

(...,$_)erstelle eine neue Sammlung von zwei Elementen: 0) $t=...setze die Variable $tgleich einer Zeichenkette; 1) $_Unsere-aktuelle-Nummer der Schleife

"Fizz"*!($_%3)nimm unsere-aktuelle-nummer, modifiziere sie um 3, dann NICHT das ergebnis. Multiplizieren Sie "Fizz" damit und fügen Sie es der Zeichenkette hinzu (und ähnlich für 5). PowerShell behandelt jede Zahl ungleich Null als $TRUE, und daher ist das NICHT einer Zahl ungleich Null 0, was bedeutet, dass "Fizz" nur dann zur Zeichenfolge hinzugefügt wird, wenn unsere aktuelle Zahl ein Vielfaches von 3 ist.

[!$t]Indexe in die soeben erstellte Auflistung, basierend auf dem Wert der Zeichenfolge $t- nicht leer, drucken Sie sie aus, ansonsten drucken Sie unsere aktuelle Nummer aus

Alternativ auch 54 Bytes

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

_{Danke an TesselatingHeckler}

In ähnlicher Weise wird der Inline- -replaceOperator und ein regulärer Ausdruck verwendet, um eine leere Zeichenfolge ^$mit unserer aktuellen Nummer auszutauschen. Wenn der String nicht leer ist, wird er nicht ausgetauscht.

Alternativ auch 54 Bytes

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

Dies ist die gleiche Schleifenstruktur wie oben, aber innerhalb dieser Struktur wird das Paar (n, Zeichenfolge) sortiert. Dabei wird davon ausgegangen, dass eine leere Zeichenfolge vor einer Zahl sortiert wird, eine FizzBuzz-Zeichenfolge jedoch nach einer Zahl. Dann indiziert es das zweite Sortierergebnis.

JavaScript, 62 Bytes

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

Ich denke, das ist jetzt die kürzeste Javascript-Lösung.

C 74 Bytes

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

Das 0Argument zu printfstatt ""ist faul, scheint aber auf den meisten Plattformen zu funktionieren, auf denen ich es anprobiere. putsSegfaults, wenn Sie das Gleiche versuchen. Ohne es erhalten Sie 75 Bytes.

Es gibt 73-Byte-Lösungen, die auf Anarchie-Golf funktionieren , und ich habe eine gefunden, die an den richtigen Stellen im Internet herumgräbt, aber sie basieren auf plattformspezifischem Verhalten. (Wie Sie vielleicht erraten haben, ist es etwas von der Form puts("Buzz"±...).)

Scratch, 203 185 Bytes

Bytes aus dem golfed gezählt Textdarstellung , pro dieser Meta Post . Scratch ist nicht sehr platzsparend.

sayist das, was Scratch am nächsten kommt: Das Sprite zeigt eine Sprechblase an, die alles enthält, was es sagt. In der Praxis wait n secswäre ein Block erforderlich, um diese Ausgabe tatsächlich zu lesen, aber für die Zwecke dieser Herausforderung erfüllt dieser Code die Anforderungen.

R 88 83 77 71 70 Bytes

Ich bin mir sicher, dass dies verbessert werden kann ... und das mit Dank an @flodel. Ein paar weitere Bytes wurden dank eines Vorschlags von @njnnja und eines weiteren von @ J.Doe gespeichert

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"

Annäherung an Henkmas 81 Bytes , aber noch nicht ganz da.

d = drop.(*4).mod nist der Schlüssel hier: d 3 "Fizz"ist drop (n`mod`3 * 4) "Fizz". Dies ist, "Fizz"wenn n `mod` 30 und ""sonst ist.

PHP, 54 Bytes

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

Gültig ab v5.5. Dasõ ist Zeichen 245, ein bisschen invertiert \n.

Ich gehe von den Standardeinstellungen des Interpreters aus, da diese ohne ini sind. Wenn Sie sich nicht sicher sind, können Sie Ihre lokale INI mit deaktivieren-n as inphp -n fizzbuzz.php .

Eine Version, die mit absolut jeder Konfigurationsdatei fehlerfrei läuft, hat 62 Bytes :

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

80386 Maschinencode + DOS, 75 Bytes

Hexdump des Codes:

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

Quellcode (TASM-Syntax):

    .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

Dieser Code zählt von 1 bis 100 in axund erstellt die Ausgabenachricht vom Ende bis zum Anfang. Das Ende der Nachricht (Zeilenvorschub und das von $DOS für das Nachrichtenende-Flag verwendete Zeichen) wird am Anfang des Codes angezeigt:

db 10, 10, '$'

Es wird als harmlose Anweisung ausgeführt ( or ax, 240ah). Ich könnte es an einem konventionelleren Ort platzieren, wie nach dem Ende des Codes, aber es hat einen Vorteil, es an der Adresse 0x100 zu haben.

Der Code verwendet außerdem 2 zusätzliche Leistungsindikatoren:

• Zählen von 3 bis 0 in dl
• Zählen von 5 bis 0 in dh

Wenn ein Zähler 0 erreicht, wird die Zeichenfolge Fizzoder Buzzdas Ende der Ausgabenachricht verschoben. In diesem bxFall werden und verringertbh wird Null sein. Dies wird als Bedingung für die Ausgabe der Zahl in Dezimalform verwendet.

Hinweis: Ich verwende hier 32-Bit-Daten. Auf einem Computer vor 386 funktioniert dies nicht.

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