introduction

Dans notre récent effort pour rassembler des catalogues des solutions les plus courtes pour des exercices de programmation standard, voici le tout premier défi FizzBuzz à la vanille de PPCG. Si vous souhaitez voir d’autres défis du catalogue, il y a "Hello World!" et "Ce nombre est-il un nombre premier?" .

Défi

Ecrivez un programme qui imprime les nombres décimaux de 1 à 100 inclus. Mais pour des multiples de trois, imprimez «Fizz» au lieu du nombre et pour des multiples de cinq, imprimez «Buzz». Pour les nombres multiples de trois et cinq, imprimez «FizzBuzz».

Sortie

La sortie sera une liste de nombres (et Fizzes, Buzzes et FizzBuzz) séparés par une nouvelle ligne (ou \nou \r\n). Une nouvelle ligne est acceptable, mais une nouvelle ligne ne l’est pas. En dehors de votre choix de nouvelle ligne, la sortie devrait ressembler exactement à ceci:

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

La seule exception à cette règle est la sortie constante de l'interpréteur de votre langue qui ne peut pas être supprimée, telle qu'un message d'accueil, des codes de couleur ANSI ou une indentation.

Règles supplémentaires

• Il ne s'agit pas de trouver la langue avec l'approche la plus courte pour jouer à FizzBuzz, mais de trouver l'approche la plus courte dans toutes les langues. Par conséquent, aucune réponse ne sera marquée comme acceptée.

• Les soumissions sont notées en octets dans un codage préexistant approprié, généralement (mais pas nécessairement) UTF-8. Certaines langues, comme les dossiers, sont un peu difficiles à noter - en cas de doute, demandez-les sur Meta.

• Rien ne peut être imprimé sur STDERR.

• Contrairement à nos règles habituelles, n'hésitez pas à utiliser une langue (ou une version linguistique) même si c'est plus récent que ce défi. Si quelqu'un veut en abuser en créant un langage dans lequel le programme vide génère une sortie FizzBuzz, félicitations pour avoir ouvert la voie à une réponse très ennuyeuse.

  Notez qu'il doit y avoir un interprète pour que la soumission puisse être testée. Il est permis (et même encouragé) d’écrire cet interprète vous-même pour une langue non encore implémentée.

• Si votre langue de choix est une variante triviale d'une autre langue (potentiellement plus populaire) qui possède déjà une réponse (pensez aux dialectes BASIC ou SQL, aux shells Unix ou aux dérivés triviaux de Brainfuck tels qu'Alphuck et ???), envisagez d'ajouter une note au texte existant. répondez que la même solution ou une solution très similaire est également la plus courte dans l’autre langue.

• La sortie étant fixe, vous pouvez coder la sortie en dur (mais ce n'est peut-être pas l'option la plus courte).

• Vous pouvez utiliser des solutions préexistantes, à condition de créditer l'auteur original du programme.

• Les failles standard sont par ailleurs interdites.

En passant, veuillez ne pas annuler les réponses ennuyeuses (mais valables) dans des langues où il n’ya pas grand chose à jouer au golf; ceux-ci sont toujours utiles à cette question car elle tente de compiler un catalogue aussi complet que possible. Cependant, faites principalement des réponses dans des langues où les auteurs devaient réellement s’efforcer de jouer au code.

Catalogue

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

Hexagonie , 91 octets

Merci pour la prime :)

Wow, je n'aurais jamais imaginé pouvoir battre la solution de Martin Hexagony . Mais, qui l'aurait cru, je l'ai fait. Après plusieurs jours d'échec parce que je n'avais ni le colorant Hexagony ni l' EsotericIDE pour vérifier ma solution. Plusieurs aspects de la spécification étant incorrects, j'ai donc produit quelques «solutions» erronées en utilisant simplement un crayon et du papier et un éditeur de texte. Enfin, j'ai finalement surmonté ma paresse et cloné les deux référentiels, téléchargé VisualStudio et les compilé. Wow, quels outils utiles ils sont! Comme vous pouvez le constater, je suis loin d’être quelqu'un que vous appelez un programmeur (enfin, je n'ai même pas Visual Studio installé, et je n’ai pratiquement aucune idée de la façon de compiler un programme);)

Il m'a fallu encore un certain temps pour trouver une solution de travail, et elle est assez encombrée et chaotique, mais la voici dans toute sa splendeur:

Fizzbuzz dans un hexagone de taille 6:

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

Disposition hexagonale:

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

Et la belle interprétation, grâce à Hexagony Colorer de Timwi :

Voici donc une animation GIF de 110 secondes à 2 ips, montrant le déroulement du programme au cours des 6 premiers chiffres 1, 2, Fizz, 4, Buzz, Fizz, les 220 premiers ticks du programme (cliquez sur l'image pour l'agrandir):

Mon Dieu, grâce au logiciel de composition Natron, l'animation du pointeur était toujours fastidieuse à créer, mais gérable. Enregistrer 260 images de la mémoire était moins amusant. Malheureusement, EsotericIDE ne peut pas le faire automatiquement. Quoi qu'il en soit, profitez de l'animation!

Après tout, une fois que vous avez compris le modèle de mémoire et l’emballage plutôt contre-intuitif des chemins qui traversent les frontières de l’hexagone, Hexagony n’est pas si difficile à travailler. Mais jouer au golf peut être pénible. ;)

C'était amusant!

Labyrinthe , 94 octets

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

Sous-100! C'était amusant.

Explication

Commençons par une brève introduction à Labyrinth - n'hésitez pas à l'ignorer si vous êtes déjà familiarisé avec les bases:

• Le labyrinthe a deux piles - une pile principale et une pile auxiliaire. Les deux piles ont un nombre infini de zéros au bas, par exemple +, une pile vide ajoute deux zéros, poussant ainsi le zéro.

• Le flux de contrôle dans Labyrinth est décidé par les jonctions, qui regardent en haut de la pile pour déterminer la prochaine étape. Négatif signifie tourner à gauche, zéro signifie aller tout droit et positif signifie tourner à droite ... mais si nous heurtons un mur, nous inversons la direction. Par exemple, si seuls le droit devant et le virage à gauche sont possibles mais que le haut de la pile est positif, alors puisque nous ne pouvons pas tourner à droite, nous tournons plutôt à gauche.

• Les chiffres dans Labyrinth pop xet push 10*x + <digit>, ce qui facilite la création de grands nombres. Cependant, cela signifie que nous avons besoin d'une instruction pour appuyer sur 0 afin de commencer un nouveau numéro, qui est _dans Labyrinth.

Passons maintenant au code actuel!

rouge

L'exécution commence "dans le coin supérieur gauche, qui est un NOP. Next is ), qui incrémente le haut de la pile, en poussant 1 au premier passage et en augmentant nà chaque passage suivant.

Ensuite, nous dupliquons navec :. Comme il nest positif, nous tournons à droite en exécutant }(en haut de la pile principale sur auxiliaire) et :. Nous nous sommes retrouvés dans une impasse, nous avons donc fait demi-tour et exécuté }et :une fois de plus, laissant les piles comme

Main [ n n | n n ] Aux

Encore une fois, nc'est positif et on tourne à droite, on exécute _101/ce qui divise npar 101. Si nest 101 alors n/101 = 1on tourne et on @termine par le programme, qui termine le programme. Sinon, notre situation actuelle est

Main [ n 0 | n n ] Aux

Orange 1 (mod 3)

3transforme le zéro supérieur en 3 ( 10*0 + 3 = 3) et %effectue un modulo. Si n%3est positif, nous tournons à droite dans le jaune ". Sinon, nous effectuons 70.105.122:..ce qui sort Fizz. Notez que nous n'avons pas besoin de pousser de nouveaux zéros avec _puisque depuis n%3était zéro dans ce cas, nous pouvons donc exploiter les zéros infinis au bas de la pile. Les deux chemins se retrouvent en bleu clair.

Bleu clair

Le sommet de la pile est actuellement n%3, ce qui pourrait être positif. Il _;suffit donc d’appuyer sur un zéro et de le faire apparaître immédiatement pour s’assurer que nous allons tout droit au lieu de tourner dans le @. Nous =échangeons ensuite les sommets des piles principale et auxiliaire en donnant:

Main [ n | n%3 n ] Aux

Orange 2 (mod 5)

Cette situation est similaire à celle d’avant, sauf que if 66.117.122:..renvoie zéro.Buzzn%5

Bleu foncé

La section précédente laisse les piles comme

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

{décale la n%3pile principale et *multiplie les deux modulos.

Si l'un des deux modulo est égal à zéro, le produit est égal à zéro, nous passons directement au jaune. =échange le haut des piles et _pousse un zéro pour s'assurer que nous allons tout droit, donnant

Main [ n 0 | 0 ] Aux

Sinon, si les deux modulos sont non nuls, le produit est non nul et nous virons à droite en vert. =échange les sommets des piles, donnant

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

après quoi nous utilisons :pour dupliquer n, tourner à droite, puis utiliser !pour sortir n.

Violet

À ce stade, la pile principale contient un ou deux éléments, selon le chemin emprunté. Nous devons supprimer le zéro du chemin jaune et pour ce faire, nous utilisons une +méthode qui fonctionne n + 0dans un certain ordre pour les deux cas. Enfin, \sort une nouvelle ligne et nous sommes de retour au début.

Chaque itération pousse un extra (n%5)*(n%3)sur la pile auxiliaire, mais sinon on refait la même chose.

Perl 5, 49 octets

46 octets script + 3 octets -E"..."

Utiliser say(ce qui nécessite -E"...") peut réduire ce nombre à 46 octets car sayinclut automatiquement une nouvelle ligne (Merci @Dennis !):

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

Perl 5, 50 octets

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

Ruby, 50 octets

Nécessite la version 1.8, qui semble être populaire parmi les golfeurs:

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

Dans Ruby moderne, vous remplacez ?dpar 100une solution de 51 octets.

Cela semble être le record du monde.

Java, 130 octets

Ceci concerne les versions récentes de Java (7+). Chez les plus âgés, vous pouvez en dépenser un peu plus enum, mais je ne pense pas que la logique soit plus courte que celle-ci (86 à l'intérieur 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

Essayez-le ici

Explication:

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 70 63 60 55 octets

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

Essayez-le en ligne!

Explication

.100{`^
_

Le .est l'indicateur silencieux global qui désactive la sortie implicite à la fin du programme. 100{encapsule le reste du programme dans une boucle qui est exécutée pour 100 itérations. Enfin, la scène elle-même insère simplement un _au début de la chaîne, ce qui incrémente effectivement un compteur de boucle unaire.

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

Plus de configuration. *\(encapsule le reste du programme dans un groupe, imprime son résultat avec un saut de ligne final, mais place également le groupe entier dans un cycle d'essai, ce qui signifie que son résultat sera ignoré après l'impression, de sorte que notre compteur de boucle ne soit pas réellement modifié . aest un modificateur de regex personnalisé qui ancre le regex à la chaîne entière (ce qui enregistre un octet sur using ^et $explicitement).

L'étape atomique elle-même prend en charge Fizz. La divisibilité par 3peut facilement être vérifiée unaire: il suffit de vérifier si le nombre peut être écrit comme une répétition de ___. Si c'est le cas, nous ajoutons Fi;la chaîne. Le point-virgule est tel qu'il reste une limite de mot devant le nombre pour l'étape suivante. Si nous avons tourné la ligne dans Fizz___...la position entre zet _ne serait pas considérée comme une limite, car regex considère les lettres et les soulignés comme des mots. Cependant, le point-virgule nous permet également de supprimer la zzduplication de Fizzet Buzz.

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

Nous faisons exactement la même chose pour la divisibilité par 5et Bu;, bien que nous n’ayons pas besoin de garder le _s à peu près à la même heure. Donc, nous aurions un résultat comme

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

Cela rend très facile de supprimer les traits de soulignement uniquement dans les lignes qui contiennent Fizz, tout en remplissant le zzs:

;_*
zz

Autrement dit, nous transformons chaque point-virgule en zzmais nous consommons également tout le _s juste après. À ce stade, nous avons terminé avec FizzBuzz en unaire. Mais le défi veut une sortie décimale.

'_&`.

&indique une condition: cette étape n'est exécutée que si la chaîne contient un trait de soulignement. Par conséquent, Fizz, Buzzet FizzBuzzitérations sont laissées intactes. Dans toutes les autres itérations (c'est-à-dire celles qui ne sont ni divisibles par 3 ni par 5), nous comptons simplement le nombre de caractères, en convertissant le résultat en décimal.

gs2 , 1

f

Une citation de Mauris, le créateur de gs2:

Je voulais l 'octet d' un octet de gorubyHello, world! , alors ... Cela imprime "1\n2\nFizz\n4\nBuzz\n...". :)

Mise à jour : Ajout d'une réponse de 27 octets qui n'est pas utilisée f.

Perl 5, 45 octets

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

Requiert l' -Eoption, comptabilisée comme un. Cela doit être exécuté à partir de la ligne de commande, à savoir:

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

Citations autour de la commande ne sont pas nécessaires, si l' on évite d' utiliser des espaces, ou tout autre caractère qui peuvent agir comme séparateurs de ligne de commande ( |, <, >, &, etc.).

Perl 5, 48 octets

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

Si les options de ligne de commande sont comptées pour un, -lsauvegardez un octet (en le remplaçant $/). Par classique Perlgolf Règles cependant, ce compterait 3: un pour le -, un pour le l, et un pour l'espace nécessaire.

la cire d'abeille ,104 89 81 octets

Un emballage plus dense permettait de couper 8 octets supplémentaires.

La solution la plus courte (81 octets), le même déroulement du programme, une compression différente.

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

Changer le concept m'a permis de réduire le code de 15 octets. Je voulais supprimer le test du double mod 5 dans la solution et j'ai donc implémenté un drapeau.

Brève explication:

si n%3=0Fizz est imprimé et que le drapeau est défini. Le drapeau est réalisé simplement en poussant la valeur top lstack sur le gstack (instruction f).

Si n%5=0, alors n%3=0(cas FizzBuzz) ou n%3>0(cas Buzz). Dans les deux cas, Buzz est imprimé et l'indicateur réinitialisé en vidant la pile jusqu'à ce qu'elle soit vide (instruction ?).

Maintenant les cas intéressants:

Si n%5>0, alors nous avons eu n%3=0(impression du boîtier Fizz, n ne doit pas être imprimé) ou n%3>0(Fizz n'a pas été imprimé, donc n doit être imprimé). Il est temps de vérifier le drapeau. Ceci est réalisé en poussant la longueur de gstack au dessus de gstack (instruction A). Si n%3 was 0alors la longueur de gstack est> 0. Si n%3 was >0, la longueur de gstack est 0. Un simple saut conditionnel permet de s'assurer que n n'est imprimé que si la longueur de gstack était 0.

Encore une fois, après avoir imprimé n, Fizz et / ou Buzz et la nouvelle ligne, le gstack apparaît deux fois pour s’assurer qu’il est vide. gstack est vide [], ce qui conduit à une [0]instruction après A(enfoncez la longueur de gstack sur gstack), ou il contient un zéro ( [0], le résultat de n% 3), ce qui conduit à [0 1], puisque [0] a la longueur 1. une pile vide ne change pas la pile, il est donc prudent de faire double apparition.

Si vous regardez de plus près, vous pouvez voir que, en principe, je me suis couché

>      q
d`Fizz`f>

dans

<f`z`<
d`Fiz`b

ce qui permet de se débarrasser de tout l'espace gaspillé entre Aet <à la fin de la rangée suivante dans l'ancienne solution ci-dessous:

q?{@b'gA<       p      <

Nouveau concept de solution (89 octets) incluant une explication animée:

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

Disposition hexagonale:

   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 des 326 premiers ticks à 2 ips, avec des piles locales et globales, et sortie vers STDOUT.

À titre de comparaison, vous trouverez ci-dessous les recouvrements de chemin de la solution plus ancienne et plus complexe. Peut-être que c'est aussi la solution la plus jolie, d'un point de vue visuel;)

> <> , 68 66 65 64 octets

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

La seule astuce consiste à multiplier les restes pour pouvoir imprimer des chiffres. De cette façon, si l’un d’eux est 0, nous n’imprimerons pas le nombre.

Vous pouvez l'essayer ici .

Enregistré un octet grâce à Sp3000 et un autre grâce à randomra. Merci beaucoup!

gs2 , 28 27 (sans f)

Hex:

1b 2f fe cc 04 46 69 7a 7a 09 07 42 75 7a 7a 19 06 27 2d d8 62 32 ec 99 dc 61 0a

Explication:

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

L'incorporation de 3 et 5 dans la constante chaîne ne fonctionne pas car \x05termine les littéraux de chaîne.

Remarque: Ce problème peut être résolu en 1 octet avec gs2 à l'aide de la fonction intégrée f.

C, 85 octets

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

-2 grâce à squeamish.

CJam, 35 octets

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

Essayez-le en ligne dans l' interprète CJam .

Comment ça fonctionne

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 octets

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

C'est quoi ce w:$X<3 itruc, tu demandes? $Xest une variable magique ("intrinsèque") qui stocke la position horizontale du curseur de sortie (sous forme de nombre de caractères à partir du bord gauche du terminal). west la forme abrégée de la WRITEcommande. La syntaxe command:condition argsest postconditive - "si condition, alors fais command args".

Nous vérifions donc si le curseur de sortie a été avancé de plus de deux caractères (ce qui voudrait dire qu'au moins un de "Fizz"ou "Buzz"a été écrit sur le terminal), et sinon, écrit isur le terminal. La $Xvariable - et donc cette inséparabilité profonde du terminal - est une fonctionnalité de premier ordre de MUMPS. Beurk.

Gelée , 24 20 octets

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

Essayez-le en ligne!

Comment ça fonctionne

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

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

Formaté:

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

Essayez-le en ligne

La disposition de la mémoire est

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

où fcycles par 3, bcycles par 5, d1est un chiffre, un chiffre en d2dizaines, sest un indicateur pour imprimer des chiffres en dizaines, des dcycles par 10, cest un espace de copie pour d, test un espace de travail contenant 0 ou des données indésirables ou un indicateur pour ne pas -divisible-by-3, et adétermine la fin du programme en décalant le pointeur après que Buzz ait été imprimé 20 fois.

C #, 128 126 125 124 octets

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 octets sans le code standard autour.

Fait avec l'utilisation de la mise en forme conditionnelle de C # .

Avec deux séparateurs de section ;, Fizz ou Buzz sont imprimés si la valeur de leur condition est zéro.

Sauvegardé un total de 4 octets grâce à @RubberDuck, @Timwi et @Riokmij.

Clojure, 113 106 101 100 91 octets

Mon premier 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 octets

Modifications:

• -61 octets en stockant les valeurs de "Fizz Buzz" en tant que "BuziF" "BuziG" et en rétablissant la section d'impression de numéro.

• -71 octets en refaisant la section d'impression du numéro modulo, en divisant le compteur de boucles et le compteur de nombres et en réutilisant la cellule de nouvelle ligne comme valeur mod, entre autres

• -19 octets en réalisant qu'il n'y a pas de 0 dans les numéros FizzBuzz. Explication également ajoutée

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

Essayez-le en ligne!

Au lieu de vérifier si le nombre lui-même était divisible par 5 ou 3, j’avais deux compteurs gardant la trace du modulo du nombre, les décrémentant pour chaque nombre et imprimant le mot correspondant quand ils atteignaient 0.

Comment ça fonctionne:

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

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

_{Edit: 10 octets sauvegardés grâce à feersum}

_{Edit2: J'ai réalisé qu'avec le truc de feersum, je n'ai plus besoin de formuler $ t sous forme de chaîne de blocs de code}

_{Edit3: Sauvegardé de 7 octets supplémentaires grâce à Danko Durbić}

Semblable en esprit à la réponse du code Rosetta en stock , mais assez golfé.

Explication

1..100|%{...} Créez une collection de 1 à 100, puis pour chaque objet de cette collection, faites

(...,$_)créer une nouvelle collection de deux éléments: 0) $t=...définir la variable $tégale à une chaîne; 1) $_notre numéro actuel de la boucle

"Fizz"*!($_%3)prenez notre numéro actuel, modifiez-le par 3, puis PAS le résultat. Multipliez "Fizz" par cela et ajoutez-le à la chaîne (et similaire pour 5). PowerShell considère tout nombre non nul comme un $TRUE, et le NON d'un nombre différent de zéro est donc 0, ce qui signifie que si notre numéro actuel est un multiple de 3, "Fizz" sera ajouté à la chaîne.

[!$t]index dans la collection que nous venons de créer, en fonction de la valeur de la chaîne $t- non vide, imprimez-le, sinon affichez notre numéro actuel

Alternativement, aussi 54 octets

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

_{Merci à TesselatingHeckler}

De concept similaire, il utilise l' -replaceopérateur inline et une expression régulière pour échanger une chaîne vide ^$avec notre numéro actuel. Si la chaîne n'est pas vide, elle n'est pas permutée.

Alternativement, aussi 54 octets

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

C'est la même structure de boucle que ci-dessus, mais à l'intérieur, elle trie la paire (n, chaîne) et repose sur le fait qu'une chaîne vide est triée avant un nombre, alors qu'une chaîne FizzBuzz trie après un nombre. Ensuite, il indexe le résultat du deuxième tri.

JavaScript, 62 octets

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

Je pense que c'est la solution Javascript la plus courte actuellement.

C, 74 octets

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

L' 0argument de au printflieu de ""est louche, mais semble fonctionner sur la plupart des plateformes sur lesquelles je l'essaie.putssegfaults quand vous essayez la même chose, cependant. Sans cela, vous obtenez 75 octets.

Il existe des solutions de 73 octets qui fonctionnent sur le golf anarchique , et j'en ai trouvé une qui fouille aux bons endroits sur Internet, mais qui repose sur un comportement spécifique à la plate-forme. (Comme vous l'avez peut-être deviné, c'est quelque chose de la forme puts("Buzz"±...).)

Scratch, 203 185 octets

Octets comptés à partir de la représentation textuelle au golf , par ce méta post . Scratch n'est pas très efficace en termes d'espace.

sayScratch est la chose la plus proche d’une stdout: le sprite affiche une bulle contenant ce qu’elle dit. En pratique, un wait n secsbloc serait nécessaire pour lire cette sortie, mais pour les besoins de ce défi, ce code remplit les conditions requises.

R, 88 83 77 71 70 octets

Je suis sûr que cela peut être amélioré ... et c'était avec le crédit de @flodel. Quelques octets supplémentaires ont été sauvés grâce à une suggestion de @njnnja et à un autre de @ J.Doe

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

Haskell, 84 octets

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

Se rapprocher des 81 octets de henkma , mais pas encore tout à fait là.

d = drop.(*4).mod nest la clé ici: d 3 "Fizz"est drop (n`mod`3 * 4) "Fizz". C'est "Fizz"quand n `mod` 3est 0 et ""sinon.

PHP, 54 octets

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

Valable à partir de la version 5.5. Le õcaractère 245 est un peu inversé \n.

Je suppose que les paramètres par défaut de l'interpréteur sont les mêmes, sans aucune ini. Si vous avez des doutes, vous pouvez désactiver votre ini local avec -nas php -n fizzbuzz.php.

Une version qui fonctionnera sans erreur avec absolument n'importe quel fichier de configuration est de 62 octets :

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

80386 code machine + DOS, 75 octets

Hexdump du code:

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

Code source (syntaxe 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

Ce code compte de 1 à 100 en axcréant le message de sortie de la fin au début. La fin du message (nouvelle ligne et le $caractère utilisé par DOS comme indicateur de fin de message) apparaît au début du code:

db 10, 10, '$'

C'est exécuté comme une instruction inoffensive ( or ax, 240ah). Je pourrais le mettre dans un endroit plus conventionnel, comme après la fin du code, mais le faire à l'adresse 0x100 présente un avantage.

Le code utilise également 2 compteurs supplémentaires:

• Compter de 3 à 0 dans dl
• Compter de 5 à 0 dans dh

Lorsqu'un compteur atteint 0, il pousse la chaîne Fizzou Buzzjusqu'à la fin du message de sortie. Si cela se produit, bxsera diminué et bhsera égal à zéro. Ceci est utilisé comme condition pour la sortie du nombre sous forme décimale.

Remarque: j'utilise des données 32 bits ici. Cela ne fonctionnera pas sur un ordinateur antérieur à 386.

dc, 64 62 octets

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