1, 2, Fizz, 4, Buzz

148

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>

Beta Decay
la source
1
Nothing can be printed to STDERR. Est-ce vrai uniquement lors de l'exécution, ou également lors de la compilation (en supposant qu'il
s'agisse d'
@AShelly Uniquement en cours d'exécution
Beta Decay le
Je ne suis pas sûr d'aimer le fait que vous avez codé en dur le 100 dans le défi. De cette manière, un programme qui ne génère que la sortie attendue est une entrée valide, mais n’est pas intéressant pour ce défi. Je pense que le défi devrait s’attendre à ce que le programme saisisse le nombre d’items à produire.
Timwi
6
@ Timwi Bien que je convienne que cela rendrait (légèrement) plus intéressant, j'ai souvent vu FizzBuzz strictement compris entre 1 et 100 (sur Wikipedia et Rosetta Code, par exemple). Si le but est d'avoir un défi FB «canonique», cela a du sens.
Geobits
58
Un "fizzbuzz à la vanille" semble délicieux.
iamnotmaynard

Réponses:

76

Python 2, 56

i=0;exec"print i%3/2*'Fizz'+i%5/4*'Buzz'or-~i;i+=1;"*100
feersum
la source
6
Dang, c'est du sang, du génie. Puis-je voler votre idée pour multiplier la chaîne par le résultat de mod?
AdmBorkBork
@TimmyD Allez-y.
Feersum
15
Une autre méthode pour 56 (de ): i=1;exec"print'FizzBuzz'[i%-3&4:12&8-i%5]or i;i+=1;"*100. Quelqu'un veut-il utiliser des expressions de recherche brutales pour optimiser le bit bashing?
xnor
1
Très belle technique, j'adore la division du résultat modulo pour le rendre binaire! J'ai une amélioration à avoir pour réduire votre méthode à 54 caractères ... Bien sûr, je ne la posterais pas comme réponse sans votre permission (car c'est votre réponse à environ 95%);)
Tersosauros
2
@Tersosauros Allez-y ... ma méthode n'est pas très difficile à trouver et a sans aucun doute été découverte de manière indépendante par de nombreuses personnes.
Feersum
76

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 :

Solution FizzBuzz colorisée en hexagone

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):

entrez la description de l'image ici

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!

ML
la source
1
Très agréable! :) C’est ce que j’ai eu pour avoir oublié d’essayer moi-même de côté 6. ;) (Il serait intéressant de voir si ma solution s'intègre plus facilement dans la longueur de côté 6).
Martin Ender
@ MartinBüttner, j'aimerais bien le voir :)
ML
2
Je suis moins programmeur que vous, car qu'est-ce que Visual Studio? : P
Rɪᴋᴇʀ
5
Malheureusement, EsotericIDE ne peut pas le faire automatiquement. - S'il vous plaît allez-y et déposer une suggestion de fonctionnalité , je pourrais arriver à le faire un jour :)
Timwi
1
(oups, cela revient après 6 mois de la dernière réponse) Vous pouvez jouer au golf 1 octet à partir de la fin du programme en déplaçant le chemin gris de 1 octet et en plaçant un "Annulation de l'opération" dans le chemin orange, comme 3}1"$.!$>)}g4_'{$))}\<$\.\.@\;F\$/;z;u;<%<_>_..$>B/<>}))'%<>{>;e"-</_%;\/{}/>.\)(z;i;..>('suit. (après le z, qui peut être "annulé" avec a) ou en y mettant le z. Maintenant c'est a) qui pousse toutes les commandes du chemin orange 1 tick plus tard et qui revient avec le no-op qui était sur la ligne 3. Btw, j'ai aussi installé Visual Studio juste à cause de Hexagony Colorer et Esoteric IDE: P
Sunny Pun
44

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!

entrez la description de l'image ici

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.

Sp3000
la source
7
Aimer l'explication.
The_Basset_Hound le
29

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
Dom Hastings
la source
Vous pouvez économiser quelques octets en utilisant say.
Dennis
Vous avez cassé le tableau de bord ...
LegionMammal978
@ LegionMammal978 Oui. Oui je l'ai fait ... Je vais essayer de reformuler le titre alors! Argh!
Dom Hastings
N'est-ce pas -E"..."8 octets? Espace + Dash + Option + Argument (+ Citation).
Erik the Outgolfer
1
@EriktheGolfer donc depuis que j'ai posté ceci, le consensus est que -Ec'est 0 octet, mais puisque la réponse de primo a été marquée en excluant les guillemets, j'ai choisi de le rendre juste et d'inclure les guillemets dans le mien et +1 pour -E. La raison pour laquelle il est accepté comme étant gratuit est que Perl est généralement exécuté via perl -eet perl -En'est plus d'octets (je pensais -M5.010ou pouvais use 5.010être libre aussi, mais peut-être pas relire le méta-post). Lorsque vous ajoutez -pou que -nceci est compté comme +1, comme vous le feriez avec perl -pe. J'espère que ça t'as aidé! Référence méta: meta.codegolf.stackexchange.com/a/7539
Dom Hastings
27

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.

Lynn
la source
1
C'est diabolique, adore ça.
Camden Narzt
?dest juste 100. La FizzBuzzchaîne contient une nouvelle ligne, elle est valide en Ruby. string[i, s]est une tranche, commençant au caractère i(indexé à 0), passe aux scaractères, ignorant les index pointant en dehors de la chaîne. Si l'argument à a putsdéjà une nouvelle ligne, il est coupé. La formule devrait être simple à lire? Il fait tout le travail ici. Je ne l'aurais pas trouvé sans l'aide de certains golfeurs vraiment professionnels.
Lynn
note latérale: si vous étiez autorisé à ajouter 0 au début de la saisie (vous ne l'êtes pas), vous pouvez enregistrer 2 octets en utilisant à la ?e.timesplace.
Shelvacu
Pouvez-vous expliquer la [i=n**4%-15,i+13]partie s'il vous plaît? Je n'arrive pas à comprendre ce qui se passe
Piccolo
2
@Piccolo Cet extrait aide- t- il ? Si i==-14la tranche est hors limites, nous obtenons nil. Si i==-9nous découpons des i+13==4caractères à partir du 9ème caractère à partir de la fin, alors 'Fizz'. Si i==-5nous coupons 8 caractères à partir du 5ème caractère à partir de la fin, alors 'Buzz\n'. (Nous essayons de couper 8 mais il n'y en a que 5, donc nous en avons 5.) Et cetera.
Lynn
26

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));}}
Géobits
la source
Je ne pense pas que l'astuce relative au bloc d'initialisation soit utile ici, car la question spécifie un stderr vide.
Feersum
Hmm. Je sais que l'astuce statique s'imprime sur stderr, mais je pensais qu'énum fonctionnait proprement. Bon à savoir :)
Geobits
4
battez-moi de 14 octets! Utiliser <1 au lieu de == 0 est un excellent moyen de sauvegarder!
ESP
2
class F{public static-> interface F{staticen java 8
TheNumberOne
1
Ce n'est pas tout à fait comme ça que les énums fonctionnent. Vous devez le faire enum F{;public...pour ne pas économiser d’octets.
HyperNeutrino
23

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
FryAmTheEggman
la source
23

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.

Martin Ender
la source
20

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.

Mitch Schwartz
la source
20

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.

primo
la source
Vous pouvez utiliser say, avec le -Ecommutateur, la distance de modification 1 à -e, elle doit donc compter pour 1 octet.
Dennis
Hé primo, je sens que je triche dans ma réponse pour utiliser say, je suppose que cela -Epeut être utilisé à la place de -ece qui vous ramènerait à 44 plutôt qu'à 46. Je ne pense pas que ce soit juste que je marque différemment pour vous, quel est le mécanisme de notation préféré? J'utilise généralement printpour éviter cela! Plus proche d'un consensus serait- ce ?
Dom Hastings
Mon point de vue personnel est que chaque octet supplémentaire sur la ligne de commande doit avoir un score de 1. En particulier say, si votre code peut être écrit sur une seule ligne en évitant les séparateurs de système d’exploitation, marquez 1 -E. Si vous devez utiliser des guillemets, par exemple -E"$a||$b", marquer 3. Si vous ne pouvez pas le faire sur une ligne, marquez 5 pour -M5.01. Mais à ce stade, vous feriez probablement mieux d'utiliser -l. Je ne suis pas d'accord pour dire qu'il devrait être gratuit par défaut, pour deux raisons: 1) l'amélioration est triviale et sans intérêt, et 2) il n'y a pas de version de l'interpréteur pour laquelle il est activé par défaut.
Primo
20

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.

cire d'abeille animation FizzBuzz


À 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;)

Programme avec recouvrement de chemin

ML
la source
2
C'est aussi fou et beau que Hexagony. Avoir un +1!
ETHproductions
@ETHproductions J'ai encore besoin d'essayer Hexagony, mais d'après ce que je peux dire d'après les spécifications linguistiques, ma cire d'abeille n'approche même pas de la folie d'Hexagony.
ML
Comment faites-vous ces animations?
baordog
18

> <> , 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!

Aaron
la source
1
Très bien joué au golf, j'adore la réutilisation du "\" sur la première ligne et celui sur la deuxième ligne.
cole
1
-1 octet si vous déplacez la ofin de la deuxième ligne vers l'espace vide au début de la ligne, je crois.
Sp3000
@ Sp3000 En effet, j'ai passé tellement de temps à jouer au golf que je ne sais pas comment cela ne m'est pas venu à l'esprit
Aaron
1
Qui a besoin de fizz buzz quand vous pouvez avoir foooo Buzz?
Caird coinheringaahing
17

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.

Mitch Schwartz
la source
16

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.

AShelly
la source
Essayer de compiler ici mais ne gccreconnaît pas la nouvelle ligne dans la chaîne en tant que \ n. Cela me donne une erreur de compilation. Dois-je transmettre un paramètre au compilateur? BTW, vous avez manqué le <=dans votre message (j'ai compté 88 octets avec <= ... donc im en supposant qu'il manque).
wendelbsilva
Oops. raté l'erreur dans les avertissements. Ajoute 2 caractères.
AShelly
Les variables globales sont initialisées à zéro main(i), essayez donc plutôt que d' essayer i;main(). Ensuite, vous pouvez vous en débarrasser i--au début de la for()boucle. Vous n'avez pas besoin du saut de ligne non plus. Cela devrait ramener le nombre d'octets à 85.
ossifrage
2
Selon le type d'UB que vous souhaitez obtenir, vous pouvez utiliser 73, 74 ou 75 octets. Voici ma réponse de 74 octets .
Lynn
1
OMG, j'ai passé peut-être 3 heures à essayer de réduire cette taille d'un octet. Voici. Remplacer (i%3&&i%5)*ipar i%3*i%5?i:0Je vais au lit
Albert Renshaw
16

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.
Dennis
la source
3
Solution plus simple:100{):I3%!"Fizz"*I5%!"Buzz"*+Ie|N}/
Aditsu
16

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.

senshin
la source
15

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.
Dennis
la source
à nouveau, personne n'a joué au golf dennis (à l'exception de la réponse de style HQ9 +)
nozɐɹƆ
15

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

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.

Mitch Schwartz
la source
14

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.

Pierre-Luc Pineault
la source
Il serait plus court d'appeler Writeet d'ajouter la nouvelle ligne directement à la chaîne, n'est-ce pas?
RubberDuck
C'est aussi un octet plus court pour écrire i%3*i%5>0?i:0au lieu de i%3*i%5==0?0:i.
Timwi
Vous pouvez enregistrer un autre octet sur la fordéclaration en utilisantfor(var i=0;i++<100;)
Najkin
1
Vous pouvez économiser trois octets supplémentaires en utilisant l' interpolation de chaînes de C # 6.0 et en incorporant les arguments de format dans la chaîne elle-même (par exemple $"{(i%3*i%5>0?i:0):#}...\n")
LiamK
1
peut faire avec 121 octets aujourd'hui -class A{static void Main(){for(var i=0;i<100;)System.Console.Write($"{(++i%3*i%5<1?0:i):#}{i%3:;;Fizz}{i%5:;;Buzz}\n");}}
Jerri Kangasniemi
14

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))))))
Sam Estep
la source
1
Vous pouvez supprimer 5 caractères en procédant de la printlnmême manière que dans la solution Java , par exemple. (doall(map #(let[t(=(mod % 3)0)](println(str(if t"Fizz""")(if(=(mod % 5)0)"Buzz"(if t""%)))))(range 1 101)))
resueman
1
@resueman Merci! En fait, il s’agit de 7, car (if t"Fizz""")on peut simplifier (if t"Fizz"). :)
Sam Estep
+1 Bon tour modulo, au début, je pensais que vous aviez des erreurs uniques.
Coredump
14

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
]
Jo King
la source
Bravo Jo! J'essaierai peut-être de le battre un jour :)
Forcent Vintier
13

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.

AdmBorkBork
la source
En passant, si PowerShell implémentait l’ ||opérateur, comme en C #, nous pourrions probablement passer à 43 octets avec quelque chose de similaire à 1..100|%{"Fizz"*!($_%3)+"Buzz"*!($_%5)||$_}... douteux, car |c’est un opérateur spécial aussi important dans PowerShell, mais je peux rêver ...
AdmBorkBork
1
Que diriez-vous 1..100|%{'Fizz'*!($_%3)+'Buzz'*!($_%5)-replace'^$',$_}de 54?
TessellatingHeckler
Vous pouvez remplacer if($t){$t}else{$_}par quelque chose comme($t,$_)[!$t]
Danko Durbić
1
... donc vous obtenez 1..100|%{(($t="Fizz"*!($_%3)+"Buzz"*!($_%5)),$_)[!$t]}ce qui est aussi 54 comme la suggestion de @ TessellatingHeckler
Danko Durbić
@TessellatingHeckler PowerShell est tout sauf flexible.
AdmBorkBork
13

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.

Maman Fun Roll
la source
Wow, juste waouh! Mais toutes les autres réponses JS utilisent console.log; c'est beaucoup moins ennuyeux que d'avoir à appuyer sur "OK" sur 100 boîtes de dialogue qui s'affichent à la suite. Pourriez-vous s'il vous plaît changer cela? Ce ne sera que 62 octets, trois encore mieux que le mien.
ETHproductions
J'aurai à le faire demain, car j'ai déjà édité 5 de mes propres posts et je ne peux plus les éditer ...
Mama Fun Roll
2
Oh, je n'avais pas réalisé qu'il y avait une limite à l'édition ...
ETHproductions
12

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"±...).)

Lynn
la source
Belle astuce pour obtenir i = 1 pour le cas no args (argc = 1). C'est une fonctionnalité: vous pouvez démarrer la séquence à partir de n'importe quel point en exécutant ./fizzbuzz $(seq 40): P
Peter Cordes
12

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.

timothymh
la source
Il vous manque des numéros après le y =(dans les deux occurrences)
Beta Decay
@BetaDecay Désolé? Je ne suis pas
Timothymh
Dans la boucle de répétition, il set y to ...manque une valeur
Beta Decay,
1
@BetaDecay C'est la chaîne vide. :) si vous cliquez sur l'image, vous pouvez la voir en action!
Timothymh
Ohhh haha, désolé de te douter;)
Beta Decay
12

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)
MickyT
la source
Un chat répond. La souris est au-dessus :)
Silviu Burcea
1
J'ai trouvé un peu mieux:x=1:100;i=!x%%3;j=!x%%5;x[i]="Fizz";x[j]="Buzz";x[i&j]="FizzBuzz";cat(x,sep="\n")
Flodel
@njnnja Merci pour cette suggestion. Je l'ai implémenté avec un writeplutôt que catsi
MickyT
2
Nécromancie ici! L' writeappel peut prendre un 1 au lieu d'une chaîne vide. Il x=y=1:100;y[3*x]='Fizz';y[5*x]='Buzz';y[15*x]='FizzBuzz';write(y[x],1)s'agit donc d' un golf trivial sur 1 octet pour 70 octets.
J.Doe
68 octets . Le décompte inclut trois espaces de retour non imprimables et ne fonctionne pas correctement dans TIO.
J.Doe
12

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.

Lynn
la source
Réagencement jusqu'à ce joue au golf 82, je pense: (%)=drop.(*4).mod n;main=mapM putStrLn[max(show n)$3%"Fizz"++5%"Buzz"|n<-[0..100]].
CR Drost
Attendez, alors nn'est pas dans la portée. Hm.
CR Drost
Ouais, ça ne marche pas, mais j'ai trouvé une solution alternative à 85 octets qui lui ressemble beaucoup:main=mapM putStrLn[max(show n)$3%"Fizz"++5%"Buzz"|n<-[0..100],(%)<-[drop.(*4).mod n]]
Lynn
Pourquoi ne pas utiliser un saut de ligne? C'est aussi court qu'un point-virgule mais moins illisible.
dfeuer le
1
Je vous suggère de reconsidérer votre quête de code lisible sur un site Web de golf de code :)
Lynn
11

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),"
";
primo
la source
L'opérateur STFU @ ne signifie pas nécessairement que le code est sans erreur.
sitilge
@Kzqai ideone.com/0zRA9e short_open_tag est désactivé, activéE_NOTICE . Aucun de ceux-ci sont les paramètres par défaut.
Primo
Je reçois un tas d'erreurs sur 3v4l.org
un codeur, le
@acoder méta post pertinent . 3v4l.org semble utile.
Primo
11

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.

anatolyg
la source
TASM gère-t-il vraiment les constantes de caractères multi-octets dans l'ordre inverse de NASM ? Dans NASM, vous écrivez mov [mem], 'Fizz'pour stocker Fizzdans la mémoire, dans cet ordre, des dbdirectives correspondantes . Voir mon casse-tête "efficace" YASM FizzBuzz par exemple .
Peter Cordes
1
Est-ce qu'il enregistre les octets à utiliser std, puis stosb/ stosd? Vous devrez remplacer test bh,bhpar cmp di, 100hou quelque chose. Au lieu de sauvegarder / restaurer le compteur en AL, vous pouvez le conserver en BL et simplement claquer eax quand vous le souhaitez. Par exemple , sub bx, 4/ mov dword ptr [bx], 'zzuB'est de 3 + 7 octets, non? mov eax, 'zzuB' / stosdest 6 + 2 octets (préfixe de taille d'opérande sur les deux). Ce serait bien si la réponse incluait le désassemblage afin que la taille des instructions soit visible.
Peter Cordes
1
C’est une excellente réponse: abuser des instructions bénignes pour les données et utiliser l’espace mémoire PSP jamais utilisé. @PeterCordes J'ai joué avec vos suggestions, stosdmais je n'ai pas réussi à réduire moi-même mon score. Depuis stosddécréments DIaprès, vous ne perdez pas le sub di, 4et alors vous avez DI4 octets à la fin. J'ai pu -6 bytesutiliser quelques autres modifications mineures que j'ai publiées en tant que réponse distincte (uniquement parce que je ne pouvais pas intégrer tous les commentaires). Gloire!
640 Ko
11

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
Daniero
la source