Il était une fois, je lisais cette question / réponse sur Quora

Y a-t-il vraiment des programmeurs diplômés en informatique qui ne peuvent pas passer le test FizzBuzz

Ce code est donné comme la réponse évidente

for i in range(1, 100):
    if i % 3 == 0 and i % 5 == 0:
        print "FizzBuzz"
    elif i % 3 == 0:
        print "Fizz"
    elif i % 5 == 0:
        print "Buzz"
    else:
        print i

Bien sûr, FizzBuzz a été joué au golf à mort, mais ce n'est pas de cela qu'il s'agit. Vous voyez, dans les commentaires, quelqu'un mentionne que cette réponse évidente est excellente car il est facile d'ajouter des conditions supplémentaires telles que l'impression "Jazz" pour des multiples de 4. (Je ne suis pas d'accord. L'extension de ce schéma nécessite O (2 ** n ) lignes de code.)

Votre défi est d'écrire la plus belle version de FizzJazzBuzz jugée par vos pairs.

Éléments à considérer par les électeurs:

1. SEC
2. Efficacité des opérations de division / module

Beaucoup de réponses sur Quora utilisaient Python, mais il n'y a aucune restriction de langue ici.

J'accepterai la réponse avec le plus de votes dans un mois

Exemple de sortie:

1
2
Fizz
Jazz
Buzz
Fizz
7
Jazz
Fizz
Buzz
11
FizzJazz
13
14
FizzBuzz
Jazz
17
Fizz
19
JazzBuzz
Fizz
22
23
FizzJazz
Buzz
26
Fizz
Jazz
29
FizzBuzz
31
Jazz
Fizz
34
Buzz
FizzJazz
37
38
Fizz
JazzBuzz
41
Fizz
43
Jazz
FizzBuzz
46
47
FizzJazz
49
Buzz
Fizz
Jazz
53
Fizz
Buzz
Jazz
Fizz
58
59
FizzJazzBuzz
61
62
Fizz
Jazz
Buzz
Fizz
67
Jazz
Fizz
Buzz
71
FizzJazz
73
74
FizzBuzz
Jazz
77
Fizz
79
JazzBuzz
Fizz
82
83
FizzJazz
Buzz
86
Fizz
Jazz
89
FizzBuzz
91
Jazz
Fizz
94
Buzz
FizzJazz
97
98
Fizz
JazzBuzz

La plus belle version, dites-vous? Ensuite, essayons celui-ci dans ...

Langage de programmation Shakespeare

The Marvelously Insane FizzBuzzJazz Program.

Lady Capulet, an old bossy woman that loves to count.
The Archbishop of Canterbury, an old fart who adores to spit out letters.


          Act I: The only one of them.

          Scene I: The Archbishop of Canterbury is a bastard.

[Enter The Archbishop of Canterbury and Lady Capulet]

The Archbishop of Canterbury:
 You are nothing!

          Scene II: Count, Lady Capulet, count.

The Archbishop of Canterbury:
 You are as beautiful as the sum of yourself and a cat!

Lady Capulet:
 Am I worse than the square of the product of the sum of a warm gentle flower and a rose
 and my pretty angel?

The Archbishop of Canterbury:
 If not, let us proceed to Scene VIII.

          Scene III: Fizzing to no end!

The Archbishop of Canterbury:
 Is the remainder of the quotient between yourself and the sum of a happy cow and a
 chihuahua as good as nothing?

Lady Capulet:
 If not, let us proceed to Scene IV. Thou art as handsome as the sum of the sum of
 the sweetest reddest prettiest warm gentle peaceful fair rose and a happy proud kindgom
 and a big roman. Speak thy mind!

 Thou art as fair as the sum of thyself and a honest delicious cute blossoming peaceful
 hamster. Thou art as cunning as the sum of the sum of an embroidered King and a horse
 and thyself. Speak thy mind!

 Thou art as amazing as the sum of the sum of a good happy proud rich hero and a hair and
 thyself! Speak thy mind.

 Speak your mind!

          Scene IV: Milady, there is jazz in thy robe.

The Archbishop of Canterbury:
 Is the remainder of the quotient between yourself and a proud noble kingdom as good as
 nothing?

Lady Capulet:
 If not, let us proceed to Scene V. You are as charming as the sum of the sum of a noble
 cunning gentle embroidered brave mighty King and a big warm chihuahua and an amazing
 pony! Speak your mind!

 You are as prompt as the sum of yourself and a big black sweet animal. You are as noble
 as the sum of the sum of a gentle trustworthy lantern and yourself and a hog. Speak your
 mind!

 You are as bold as the sum of the sum of yourself and a good delicious healthy sweet
 horse and my smooth cute embroidered purse. You are as peaceful as the sum of a flower
 and yourself. Speak your mind.

 Speak your mind!

          Scene V: Buzz me up, Scotty!

The Archbishop of Canterbury:
 Is the remainder of the quotient between yourself and the sum of a gentle happy cow and a
 chihuahua as good as nothing?

Lady Capulet:
 If not, let us proceed to Scene VI. Thou art as handsome as the sum of the sweetest
 reddest prettiest warm gentle peaceful fair rose and a small town. Speak your mind!

 You are as prompt as the sum of yourself and a big healthy peaceful fair rich kingdom.
 You are as loving as the sum of the sum of an embroidered King and a horse and thyself.
 You are as amazing as the sum of yourself and a cute fine smooth sweet hamster. Speak
 your mind!

 You are as prompt as the sum of the sum of yourself and an amazing cunning Lord and a
 hair. Speak your mind.

 Speak your mind!

The Archbishop of Canterbury:
 Let us proceed to Scene VII.

          Scene VI: Output or die!

The Archbishop of Canterbury:
 Open your heart!

          Scene VII: Oh, to jump the line.

Lady Capulet:
 You are as handsome as the sum of a proud noble rich kingdom and a rural town. Speak your
 mind! You are as gentle as the sum of the sum of yourself and a green mistletoe and my
 father. Speak your mind!

The Archbishop of Canterbury:
 We must return to Scene II.

          Scene VIII: Goodbye, cruel world!

[Exeunt]

Donc, après ma lutte avec SPL ici , j'ai senti que je devais faire au moins une soumission avec elle sur n'importe quel défi. Et c'est tout.

Alors, c'est quoi tout ça alors?

Donc, tout d'abord, nous déclarons les variables que nous allons utiliser tout au long du programme, qui doivent provenir des pièces de Shakespeare. Marre de Roméo, Juliette, Ophélie et Othello, je suis monté avec l'archevêque de Canterbury et Lady Capulet . Leurs descriptions, ainsi que les titres des Actes / Scènes, sont ignorés par l'analyseur, vous pouvez donc y mettre à peu près tout ce que vous aimez.

Alors, faisons un roi de la traduction pour quelque chose d'un peu moins charabia .

Acte I, scène I

Begin Lady Capulet = 0;

L'acte I est assez simple: nous initialisons notre variable avec 0.

Acte I, scène II

Lady Capulet += 1; if(Lady Capulet < Math.pow((2*2*1+1)*(2*1),2)) continue; else goto Scene VIII;

Nous augmentons la valeur de Lady Capulet et la comparons à 100 (oui, cette phrase entière sert uniquement à obtenir le nombre 100); si elle n'est pas plus petite, nous sautons à la scène VIII (la fin); sinon, nous passons à la scène suivante.

Acte I, scène III

if(Lady Capulet % (2+1) == 0) continue; else goto Scene IV; The Archbishop of Canterbury = 2*2*2*2*2*2*1; System.out.print((char)The Archbishop of Canterbury); The Archbishop of Canterbury += 2*2*2*2*2*1; The Archbishop of Canterbury += 2*1+1; System.out.print((char)The Archbishop of Canterbury); The Archbishop of Canterbury += 2*2*2*2*1+1; System.out.print((char)The Archbishop of Canterbury); System.out.print((char)The Archbishop of Canterbury);

Tout d'abord, nous voyons si le module de la division par 3 est 0; sinon, on passe à la scène IV; si tel est le cas, nous commençons à effectuer des opérations arithmétiques et à les stocker sur l'Archieperson, en les affichant sous forme de caractères une fois que nous avons trouvé celui que nous recherchons. Oui, au final, l'idée est de se faire Fizz.

Acte I, scène IV

if(Lady Capulet % (2*2) == 0) continue; else goto Scene V; The Archbishop of Canterbury = 2*2*2*2*2*2*1+2*2*1+2*1; System.out.print((char)The Archbishop of Canterbury); The Archbishop of Canterbury += 2*2*2*1; The Archbishop of Canterbury += 2*2*1+(-1); System.out.print((char)The Archbishop of Canterbury); The Archbishop of Canterbury += 2*2*2*2*1+2*2*2*1; The Archbishop of Canterbury += 1; System.out.print((char)The Archbishop of Canterbury); System.out.print((char)The Archbishop of Canterbury);

Vérifie d'abord si le module de la division par 4 est 0, puis continue comme la même scène que précédemment, pour Jazz.

Acte I, scène V

if(Lady Capulet % (2*2+1) == 0) continue; else goto Scene VI; The Archbishop of Canterbury = 2*2*2*2*2*2*1+2*1; System.out.print((char)The Archbishop of Canterbury); The Archbishop of Canterbury += 2*2*2*2*2*1; The Archbishop of Canterbury += 2*1+1; The Archbishop of Canterbury += 2*2*2*2*1; System.out.print((char)The Archbishop of Canterbury); The Archbishop of Canterbury += 2*2+1; System.out.print((char)The Archbishop of Canterbury); System.out.print((char)The Archbishop of Canterbury); goto Scene VII;

Fonctions comme les deux précédentes, vérifiant si le module de la division par 5 renvoie 0, puis tente d'écrire Buzz ; la seule différence est que, finalement, nous sautons une scène.

Acte I, scène VI

System.out.print(Lady Capulet);

Pour accéder à cette Scène, le nombre supposé par Lady Capulet ne doit pas être ni Fizz, ni Jazz, ni Buzz; donc, nous le sortons sous forme numérique.

Acte I, scène VII

The Archbishop of Canterbury = 2*2*2*1+2*1; System.out.print((char)The Archbishop of Canterbury); The Archbishop of Canterbury += 2*1+1; System.out.print((char)The Archbishop of Canterbury); goto Scene II;

Donc, c'est le seul moyen que j'ai trouvé pour passer à la ligne suivante: sortie, d'abord, un CR, puis un LF; ensuite, nous revenons à la scène II, à laquelle nous pouvons continuer le programme.

Acte I, scène VIII

End.

Assez simple.

J'essaie toujours de voir si je pourrais montrer cela en ligne, mais je ne trouve pas de compilateur en ligne - celui que je connais ne semble pas bien se combiner avec n'importe quel programme sauf celui déjà chargé, ou peut-être qu'il y a une sorte de problème avec l'interface entre le clavier et la chaise ...

Mise à jour 1:

Après le commentaire de mathmandan, j'ai édité l'ordre des scènes de Jazz et Buzz. Il devait être fait.

> <> (Poisson)

1 > :9b*)?; 0& v
               \ :3%?v "Fizz" r}oooo &1+& \
               /     <                    /
               \ :4%?v "Jazz" r}oooo &1+& \
               /     <                    /
               \ :5%?v "Buzz" r}oooo &1+& \
               /     <                    /
               \   &?v :n                 \
  ^  +1 oa           <                    /

> <> est un langage de programmation 2D où les instructions sont des caractères uniques et le pointeur d'instruction (IP) peut se déplacer vers le haut, le bas, la gauche ou la droite, selon les flèches ^>v<et les miroirs /\. Il n'a pas de variables ou de chaînes, donc ne pas se répéter est un peu plus difficile, mais je pense que c'est bien à sa manière.

Nous poussons 1et commençons la boucle. :9b*)?;vérifie si le nombre est supérieur à 99 ( 9b* = 9*11), et si c'est le cas, le programme s'arrête ;. Sinon, mettez un 0 dans le registre et descendez vdans la partie ondulée.

:3%?vérifie le nombre modulo 3. S'il est différent de zéro, nous descendons vune rangée et nous nous déplaçons à gauche <. Sinon, nous sautons la flèche vers le bas et poussons "Fizz", l'imprimons ( r}oooo) et incrémentons le registre ( &1+&) avant de rebondir sur les miroirs muraux de droite pour descendre d'une rangée. Quoi qu'il en soit, nous finissons par nous déplacer vers la gauche le long de la troisième rangée, jusqu'à ce que nous rebondissions sur les miroirs du mur gauche. Ensuite, nous répétons pour Jazzet Buzz.

Cela continue jusqu'à la 7e ligne, qui vérifie la &valeur du registre . Si ce n'est pas nul, alors nous descendons. Sinon, nous imprimons le numéro lui-même navant de descendre.

Enfin, ao(rappelez-vous, nous allons maintenant vers la gauche!) Imprime une nouvelle ligne ASCII et 1+incrémente le nombre, avant de remonter ^et de refaire la boucle >.

^{(Maintenant, nous attendons une réponse esthétique Piet ...)}

LOLCODE

Élégant? Nan. Efficace? Définitivement pas. Beau? Eh bien, vous savez ce qu'ils disent: la beauté est dans l'œil du spectateur.

HAI
I HAS A kitty ITZ 1
IM IN YR house UPPIN YR kitty TIL BOTH SAEM kitty AN 100

    BTW, computin yr mods
    I HAS A d00d ITZ NOT MOD OF kitty AN 3
    I HAS A doge ITZ NOT MOD OF kitty AN 4
    I HAS A bro ITZ NOT MOD OF kitty AN 5

    ANY OF d00d bro doge MKAY, O RLY?
    YA RLY
        d00d, O RLY?
        YA RLY
            VISIBLE "Fizz"!
        OIC
        doge, O RLY?
        YA RLY
            VISIBLE "Jazz"! BTW, wow such jazz
        OIC
        bro, O RLY?
        YA RLY
            VISIBLE "Buzz"!
        OIC
    NO WAI
        VISIBLE kitty!
    OIC

    VISIBLE ""
IM OUTTA YR house
KTHXBYE

Quelques explications:

Les programmes LOLCODE commencent HAIet se terminent par KTHXBYE.

Les variables sont typées dynamiquement et attribuées à l'aide de I HAS A <variable> ITZ <value>. Une fois définies, les variables peuvent également être affectées à l'aide de <variable> R <value>.

Les boucles dans LOLCODE sont nommées. La syntaxe est:

IM IN YR <loop> UPPIN YR <index> TIL BOTH SAEM <index> AN <end>
    <stuff to do>
IM OUTTA YR <loop>

Il s'agit simplement d'Internet pour "boucle jusqu'à i = fin". Dans LOLCODE 1.2, la variable d'indexation doit être initialisée avant la boucle. Ici, la boucle est nommée "maison" car elle rend la lecture de l'initialisation de la boucle amusante.

VISIBLEimprime sur stdout. Par défaut, une nouvelle ligne est ajoutée, mais l'ajout !supprime la nouvelle ligne.

Les conditions sont spécifiées comme suit:

<condition>, O RLY?
YA RLY
    <code to execute if condition is true>
NO WAI
    <code to execute if condition is false>
OIC

Les conditions doivent être des expressions évaluées en valeurs booléennes ou booléennes. Dans LOLCODE, le type booléen est appeléTROOF et il a des valeurs WIN(true) et FAIL(false).

Les commentaires sur une seule ligne commencent par BTW.

Vous ne connaissez pas bien la langue d'Internetz? Faites-le moi savoir et je vous fournirai volontiers des explications supplémentaires.

Python3

lst = [('Fizz', 3),
       ('Jazz', 4),
       ('Buzz', 5),
       ]

for i in range(1, 101):  
    print(*[w for w, m in lst if i % m == 0] or [i], sep='')

Piet

J'ai décidé d'essayer de jouer avec Piet et de voir à quel point je pouvais créer un code. J'essaie de ne rien répéter ici, mais pour être honnête, je dois répéter les calculs du mod. Cependant, chaque mod distinct (n% 3, n% 4 et n% 5) n'est exécuté qu'une seule fois par itération de code.

La plus petite image est la source appropriée et peut être téléchargée et exécutée ici .

Prendre plaisir!

Mathematica

Dans Mathematica, vous pouvez définir et surcharger des fonctions pour des paramètres très spécifiques (non seulement par type, mais également par des conditions logiques arbitraires). Définissons quelques fonctions:

Fizz[n_, s___] := {n, s}
Fizz[n_ /; Divisible[n, 3], s___] := {n, "Fizz" <> s}
Jazz[n_, s___] := {n, s}
Jazz[n_ /; Divisible[n, 4], s___] := {n, "Jazz" <> s}
Buzz[n_, s___] := {n, s}
Buzz[n_ /; Divisible[n, 5], s___] := {n, "Buzz" <> s}
DoThe[n_] := n
DoThe[_, s_] := s

Et maintenant, le programme réel est simplement

DoThe @@@ Fizz @@@ Jazz @@@ Buzz /@ Range[100] // TableForm

Maintenant, alors que ce qui précède ne croît que linéairement avec le nombre de diviseurs, ce n'est toujours pas très SEC. Mais nous pouvons réellement utiliser des variables comme noms dans ces définitions. Nous pouvons donc réellement écrire une fonction qui génère ces définitions de fonction:

addFunction[f_, divisor_] := (
  f[n_, s___] := {n, s};
  f[n_ /; Divisible[n, divisor], s___] := {n, ToString[f] <> s}
)
addFunction[Fizz, 3];
addFunction[Jazz, 4];
addFunction[Buzz, 5];
DoThe[n_] := n
DoThe[_, s_] := s

DoThe @@@ Fizz @@@ Jazz @@@ Buzz /@ Range[100] // TableForm

Il ne vous reste plus qu'à ajouter un autre addFunctionappel et ajoutez votre nouveau **zzà la ligne finale.

Haskell

Vous ne prenez pas le DRY au sérieux. Il existe des motifs évidents qui peuvent être pris en compte dans la séquence "Fizz Jazz Buzz".

import Control.Applicative

-- All words end with "zz" and the numbers are in a sequence
fizzes = zip [3..] $ (++ replicate 2 'z') <$> words "Fi Ja Bu"

main = putStrLn . unlines $ fizzIt <$> [1..99]

-- Point free style with reader monad ((->) a) to minimize
-- unnecessary repetition of variable names
fizzIt = nonFizzy =<< fizzy

-- Show the number if no fizziness was found. Partially point free
-- with respect to n. But xs is needed to prevent the error:
-- "Equations for ‘nonFizzy’ have different numbers of arguments"
nonFizzy "" = show
nonFizzy xs = const xs

-- (Ab)use the list monad for concatenating the strings

fizzy i = snd =<< filter ((==0).mod i.fst) fizzes
-- Could also be written as:
-- > fizzy i = concat [ str | (n,str) <- fizzes, i`mod`n==0]
-- but that would be way too readable, and not pointless (ahem, point free) enough. ;)

Ce code est également facilement extensible. Pour résoudre le problème "Fizz Jazz Buzz Tizz", il vous suffit d'ajouter Tiaprès le Budans la chaîne. C'est beaucoup moins que ce qui est nécessaire dans toutes les autres solutions.

Excel VBA

             Sub scopeeeeeeeeeeeeeeee()
                     '   ||
               For u = 1 To 100
   If u Mod 3 = 0 Then yell = "Fizz"
If u Mod 4 = 0 Then yell = yell & "Jazz" '---------------------------------------------|
If u Mod 5 = 0 Then yell = yell & "Buzz" '---------------------------------------------|
            'made in USA
            If yell = "" Then yell = u
             Debug.Print yell      '\\
             yell = ""              '\\
            Next                     '\\
           End Sub                    '\\

Cela peut sembler stupide, mais c'est un fusil de sniper 2D!

Java

void fizzy(int limit){
    String[] output = new String[limit];
    Arrays.fill(output,"");

    List<SimpleEntry<Integer,String>> tests = new ArrayList<SimpleEntry<Integer,String>>();
    tests.add(newEntry(3,"Fizz"));      
    tests.add(newEntry(4,"Jazz"));      
    tests.add(newEntry(5,"Buzz"));      

    for(SimpleEntry<Integer,String> test : tests)
        for(int i=test.getKey();i<limit;i+=test.getKey())
            output[i] += test.getValue();           

    for(int i=1;i<limit;i++)
        System.out.println(output[i].length()<1 ? i : output[i]);
}   

SimpleEntry<Integer,String> newEntry(int key, String value){
    return new SimpleEntry<Integer,String>(key,value);
}

Donc Java n'est pas vraiment considéré comme "beau" par la plupart, mais c'est fou subjectif alors j'ai suivi les directives de la question:

• Ne vous répétez pas: pas de problème. Vous n'avez qu'à ajouter une ligne pour chaque numéro. J'ai même créé une fonction d'aide pour que vous n'ayez pas à taper autant lorsque vous le faites (Java peut être un peu verbeux parfois, si vous ne le saviez pas).
• Efficacité des opérations de division / module: efficacité parfaite, car il n'y a pas de module ou de division du tout.

Cela ne veut pas dire que l'algorithme dans son ensemble est le plus efficace (ce n'est pas le cas), mais je pense qu'il frappe bien les points à puces.

Informer 7

Inform 7 est un langage de programmation basé sur des règles conçu pour la fiction interactive. Il est remarquable pour être l'un des langages de programmation basés sur le langage naturel les plus réussis. Voir la vitrine du langage Inform 7 pour d'autres exemples et quelques informations.

The number printing rules are a number based rulebook.

Definition: a number is fizzy if the remainder after dividing it by 3 is 0.
Definition: a number is jazzy if the remainder after dividing it by 4 is 0.
Definition: a number is buzzy if the remainder after dividing it by 5 is 0.

A number printing rule for a fizzy number:
    say "Fizz";

A number printing rule for a jazzy number:
    say "Jazz";

A number printing rule for a buzzy number:
    say "Buzz";

A number printing rule for a number (called N):
    unless a paragraph break is pending:
        say N;
    say conditional paragraph break;

To print a series of numbers from (min - a number) to (max - a number):
    repeat with N running from min to max:
        follow the number printing rules for N;

Ce code a l'avantage que chacune des règles FizzBuzz est complètement indépendante: des règles supplémentaires peuvent être ajoutées à tout moment sans avoir besoin de changer le cadre général. Malheureusement, c'est un peu répétitif, surtout avec les phrases de définition. Je pourrais définir un opérateur%, mais ce ne serait pas l'anglais. ;)

Ce code peut être exécuté en ligne à l'aide de Playfic .

Dyalog APL

∇FizzJazzBuzz;list;items;names
   items ← ⍳100    
   list  ← ↑('Fizz' 3) ('Jazz' 4) ('Buzz' 5)   

   names ← (,/ ↑(↓0=⍉list[;2]∘.|items) /¨ ⊂list[;1]) ~¨ ' '
   ⎕← ↑,/↑names ,¨ (∊0=⍴¨names) ⍴¨ ⊂¨⍕¨items
∇

• SEC: il n'y a pas de double code
• Conditions faciles à modifier: les noms sont tirés d'une liste, dans l'ordre, par diviseur, avec un minimum de changement nécessaire
• Gamme facile à changer: items peut être modifiée en une liste arbitraire de nombres
• Efficace: utilise un algorithme basé sur une liste facilement parallélisé composé uniquement de primitives libres d'effets secondaires.
• Flux de code simple: non seulement il n'y a pas de goto s, il n'y a pas de while ou si s non plus. Le code est complètement linéaire.
• Sécurise votre travail: presque personne d'autre ne pourra y travailler ...

C #

for(int i = 1; i <= 99; i++){
    string s = "";
    if (i % 3 == 0) s += "Fizz";
    if (i % 4 == 0) s += "Jazz";
    if (i % 5 == 0) s += "Buzz";
    System.Console.WriteLine(s == "" ? "" + i : s);
}

Vérifiez le mod, créez la chaîne, imprimez le numéro si vide ou la chaîne sinon. Pas de répétitions. Il suffit d'ajouter une condition et une sortie pour les nouvelles exigences.

Python 2.7

J'ai essayé de le rendre poétique ...

Je ne suis pas très douée en poésie amoureuse ...

of = 1
my_love = 100
youre = "ever"

#You are
for ever in range(of, my_love) :
    never = "out my mind"
    for I,am in[#audibly
                (3, "Fizzing"),
                (4, "Jazzing"),
                #and
                (5, "Buzzing")]:
        if( ever % I ==0):# near you
            never += am #I lonely.
    #because
    youre = ever #in my mind.
    if( youre, never == ever,"out my mind" ):
        never += str(youre) #(I gave up with this line...)
    #then our foot-
    print"""s will"""( never [11:3])# part. 

Ce serait aussi beaucoup mieux sans les constantes initiales: P

Java avec classes

L'algorithme:

public static void main(String... args) {

    List<Condition> conditions = new ArrayList<Condition>();
    conditions.add(new TerminatingCondition(100));
    conditions.add(new ModuloCondition(3, "Fizz"));
    conditions.add(new ModuloCondition(4, "Jazz"));
    conditions.add(new ModuloCondition(5, "Buzz"));
    conditions.add(new EchoCondition());

    while (true) {
        for (Condition c : conditions){
            c.apply();
        }
    }

}

Les classes:

interface Condition {
    void apply();
}

static class ModuloCondition implements Condition {
    int modulo, count = 0;
    String message;
    ModuloCondition(int modulo, String message){
        this.modulo = modulo;
        this.message = message;
    }
    public void apply() {
        count++;
        if (count == modulo) {
            out.append(message);
            count = 0;
        }
    }
}

static class TerminatingCondition implements Condition {
    int limit, count = 0;
    TerminatingCondition(int limit) {
        this.limit = limit;
    }
    public void apply() {
        count++;
        if (count > limit) {
            System.exit(0);
        }
    }
}

static class EchoCondition implements Condition {
    int count = 0, lastOutCount = 0;
    public void apply() {
        count++;
        out.println((lastOutCount == out.count) ? String.valueOf(count) : "");
        lastOutCount = out.count;
    }
}

static class Out {
    int count = 0;
    void append(String s) {
        System.out.append(s);
        count++;
    }
    void println(String s){
        append(s + System.lineSeparator());
    }
}

static Out out = new Out();

MATLAB / Octave

Bien sûr, écrire vos propres boucles est amusant pour les programmeurs, mais tout le monde sait à quel point le suivi de l'indexation est vraiment fastidieux (qui n'a pas écrit for(j=i;j<n;i++)dans une boucle imbriquée au moins une fois dans sa vie?)

MATLAB a la solution. Vraiment, ce code n'est pas le plus efficace, et certainement pas le golf de code, mais c'est certainement une bonne vitrine des fonctions les plus intéressantes de MATLAB. Octave est la version GNU de MATLAB; il n'est cependant pas adapté au code-golf car il est légèrement plus strict avec des types variables, ce qui est préjudiciable au code-golf.

EDIT: jusqu'à ce que la coloration syntaxique pour MATLAB existe sur SE, je poste une version avec très peu de commentaires, car sinon c'était juste un gros bloc effrayant de texte brut.

function out = fizzjazzbuzz(n)
    %Initialization
    numberlist=1:n;
    fizz=cell(1,100);
    jazz=fizz;buzz=jazz;

    %Complex loops - no, wait, easy logical indexing.
    fizz(~mod(numberlist,3))={'Fizz'}; 
    jazz(~mod(numberlist,4))={'Jazz'};
    buzz(~mod(numberlist,5))={'Buzz'};
    out=strcat(fizz,buzz,jazz);
    %Fill with numbers
    out(cellfun(@isempty,out))=num2cell(numberlist(cellfun(@isempty,out)));

    %Pretty output (although the default printing is perfectly acceptable)
    out=cellfun(@num2str,out,'UniformOutput',0);
    strjoin(out,sprintf('\n'));
end

Python

from collections import defaultdict

lst = [(3, 'Fizz'),
       (5, 'Buzz'),
       (4, 'Jazz')]

word_list = defaultdict(list)

for d, w in sorted(lst):
    for i in range(d, 100, d):
        word_list[i].append(w)

for i in range(1, 100):
    print(''.join(word_list[i]) or i)

C'est bien sûr trop long. La solution de gnibbler est bien meilleure. (bien que remplaçant *..., sep=''par''.join serait plus beau)

Mais c'est assez efficace en termes d'opérations de division / module.

Rubis

100.times do |n|
  l = [nil, 'Fizz', 'Jazz', 'Buzz'].select.with_index{|x, i| x && (n % (i+2)) == 0 }
  puts l.empty? ? n : l * ''
end

Haskell

inp = [(3, "Fizz"), (4, "Jazz"), (5, "Buzz")]

mkList (n, str) = cycle $ replicate (n-1) "" ++ [str]

merge lists = (head =<< lists) : merge (map tail lists)

checkFJB "" n = show n
checkFJB s  _ = s

fjb = zipWith checkFJB (merge $ map mkList inp) [1..]

print100fjb = mapM_ putStrLn $ take 100 fjb

Encore une autre solution sans division ni module. fjbcrée une liste infinie de Fizzes, Jazzes, Buzzes et / ou nombres. taketout montant que vous voulez, comme on le voit dans print100fjbqui imprime les 100 premiers éléments.

SQL (MySQL)

SELECT COALESCE(GROUP_CONCAT(FizzJazzBuzz.str ORDER BY FizzJazzBuzz.n SEPARATOR ''), I.id)
FROM I
    LEFT JOIN (
        SELECT 3 n,'Fizz' str
        UNION SELECT 4, 'Jazz'
        UNION SELECT 5, 'Buzz'
    ) FizzJazzBuzz ON I.id MOD FizzJazzBuzz.n = 0
GROUP BY I.id
ORDER BY I.id;

où I est une table avec une colonne (id INT) contenant les 100 entiers.

Je ne connais pas de saveur SQL qui puisse générer facilement la table I, ou peut utiliser VALUES comme sous-requêtes, ce qui peut la rendre bien meilleure et complète.

Rubis

1.upto(100) do |i|

  rules = { 3 => 'Fizz', 4 => 'Jazz', 5 => 'Buzz' }

  print(i) unless rules.select! { |n,s| i.modulo(n) > 0 or print(s) }

  puts

end

Javascript

Peut-être pas le moyen le plus efficace, mais je pense que c'est simple et joli <3

(function fizzBuzz(iter){
    var str = '';
    

    if(!(iter % 3)) str += 'Fizz'
    if(!(iter % 4)) str += 'Jazz'
    if(!(iter % 5)) str += 'Buzz'


    console.log(str || iter)


    if(iter >= 100) return

    
    fizzBuzz(++iter)
})(1)

Moar SEC et effin laid: C

(function fizzBuzz(iter){
    var 
        str,
        fijabu = ['Fi','Ja','Bu']
    ;
    

    (function isMod(_str,val){

        if(!(iter % val)) _str += fijabu[val-3] + 'zz'


        if(val >= 5) return str = _str


        isMod(_str,++val)
    })('',3)


    console.log(str || iter)


    if(iter >= 100) return

    
    fizzBuzz(++iter)
})(1)

Javascript

SEC ...;)

(function FizzJazzBuzz(iter) {
    var output = ["Fi", "Ja", "Bu"];
    var str = "";

    output.map(function(v,i,a) {
        if(!(iter%(i+3))) str += output[i] + "zz";
    });

    console.log(str || iter);

    if(iter < 100) FizzJazzBuzz(++iter);

    return;
})(1);

C # absolument stupide

La moitié du mémoire était «NE PAS RÉPÉTER VOUS-MÊME», alors j'ai pris cela aussi littéralement que possible avec C # et cela a accidentellement progressé en jouant au code. C'est mon premier golf et je l'ai fait en C #, stupide je sais mais voici le résultat:

Golfé ( 240 232 230 caractères):

namespace System{using Diagnostics;using i=Int32;using s=String;class P{static void Main(){s[] z=new s[]{"Fi","Ja","Bu"};for(i a=1;a<100;a++){s l="";for(i b=3;b<6;b++)if(a%b==0)l+=z[b-3]+"zz";Trace.WriteLine((l!="")?l:a+"");}}}}

Non golfé:

namespace System
{
   using Diagnostics;
   using i = Int32;
   using s = String;
   class P 
   { 
      static void Main() 
      {
         s[] z = new s[] { "Fi","Ja","Bu" }; 
         for(i a = 1;a < 100;a++) 
         { 
            s l = ""; 
            for(i b = 3;b < 6;b++)
               if(a % b == 0)
                  l += z[b - 3] + "zz"; 
            Trace.WriteLine((l != "") ? l : a+""); 
         } 
      } 
   }
}

Le but était de raccourcir tout ce que je devais utiliser plus d'une fois et en général de garder le code court tout en produisant un programme C # complet. Pour cela, vous devrez utiliser VisualStudio et définir l'objet StartUp sur «P», vous devrez également rechercher la sortie dans la fenêtre de sortie de débogage.

Il y a de sérieuses limitations ici:

• Le code suppose que tous les mots se termineront par «zz»
• Le code suppose que le module se produira consécutivement (3,4,5,6 ...)
• Le code favorise toujours le manque ou la répétition par rapport au vrai golf, plus de caractères sont ajoutés pour éviter certaines répétitions

Python 2

Je voulais écrire une réponse à cela dans un Python bien rangé qui montrerait les caractéristiques du langage, se conformerait au principe DRY et serait assez lisible.

group = range(100)
rules = [('fizz', group[::3]), ('jazz', group[::4]), ('buzz', group[::5])]
for number in group[1:]:
    labelset = ''
    for label, matches in rules:
        if number in matches:
            labelset += label
    print labelset if labelset else number

Ce petit exemple montre le découpage, l' inopérateur et la syntaxe ternaire détaillée mais compréhensible. Il n'utilise pas du tout l'opérateur modulo. Il n'est pas conçu pour une efficacité d'exécution, mais ce n'était pas le but. Il est conçu pour être court, compréhensible et maintenable.

Python 2.7, 111 octets

Ceci est ma première contribution. J'ai essayé d'appliquer quelques astuces de golf Python (entrelacement de chaînes, accès à l'index de tuple au lieu de if). Si vous avez des suggestions, partagez-les!

for i in range(1,101):
 p=""
 for x in 3,4,5:
  if not(i%x):p+="FJBiauzzzzzz"[x-3::3]
 print((p,i)[not len(p)])

Sortie:

1
2
Fizz
Jazz
Buzz
Fizz
7
Jazz
Fizz
Buzz
11
FizzJazz
13
14
FizzBuzz
Jazz
17
Fizz
19
JazzBuzz
Fizz
22
23
FizzJazz
Buzz
26
Fizz
Jazz
29
FizzBuzz
31
Jazz
Fizz
34
Buzz
FizzJazz
37
38
Fizz
JazzBuzz
41
Fizz
43
Jazz
FizzBuzz
46
47
FizzJazz
49
Buzz
Fizz
Jazz
53
Fizz
Buzz
Jazz
Fizz
58
59
FizzJazzBuzz
61
62
Fizz
Jazz
Buzz
Fizz
67
Jazz
Fizz
Buzz
71
FizzJazz
73
74
FizzBuzz
Jazz
77
Fizz
79
JazzBuzz
Fizz
82
83
FizzJazz
Buzz
86
Fizz
Jazz
89
FizzBuzz
91
Jazz
Fizz
94
Buzz
FizzJazz
97
98
Fizz
JazzBuzz

Je n'ai pas non plus pu appliquer pleinement le principe DRY, car il y a deux forboucles. Il y a probablement une façon plus intelligente de le faire!

Aller

Le FizzJazzBuzzer simultané

package main

import (
    "fmt"
    "sort"
    "sync"
)

var hooks map[int]string = map[int]string{
    3: "Fizz",
    4: "Jazz",
    5: "Buzz"}

type candidate struct {
    num     int
    message string
}

func FizzJazzBuzzer(hooks map[int]string) (chan<- int, *sync.WaitGroup) {
    var wg *sync.WaitGroup = new(sync.WaitGroup)
    final := func(c chan candidate) {
        for i := range c {
            if i.message == "" {
                fmt.Println(i.num)
            } else {
                fmt.Println(i.message)
            }
            wg.Done()
        }
    }
    prev := make(chan candidate)
    go final(prev)
    var keys []int = make([]int, 0)
    for k := range hooks {
        keys = append(keys, k)
    }
    sort.Sort(sort.Reverse(sort.IntSlice(keys)))
    for _, mod := range keys {
        c := make(chan candidate)
        s := hooks[mod]
        go (func(in chan candidate, next chan candidate, mod int, s string) {
            for i := range in {
                if i.num%mod == 0 {
                    i.message += s
                }
                next <- i
            }
        })(c, prev, mod, s)
        prev = c
    }
    in := make(chan int)
    go (func(in <-chan int) {
        for i := range in {
            prev <- candidate{i, ""}
        }
    })(in)
    return in, wg
}

func main() {
    in, wg := FizzJazzBuzzer(hooks)
    for i := 1; i < 20; i++ {
        wg.Add(1)
        in <- i
    }
    wg.Wait()
}

Essayez-le ici: http://play.golang.org/p/lxaZF_oOax

Il n'utilise qu'un seul module par nombre vérifié et peut être étendu arbitrairement à n'importe quel nombre de, eh bien ... nombres.

Il suffit de modifier 3 endroits différents pour étendre cela, dans la hookscarte, le FizzJazzBuzzernom de la fonction et, bien sûr, l'appel à la FizzJazzBuzzerfonction.

R

Cela crée une fonction qui permet à un utilisateur de spécifier des paires de mots et de diviseurs (et éventuellement un nombre maximum, avec 100 par défaut). La fonction crée un vecteur de 1 au nombre maximum, puis remplace tous les nombres aux positions "fizzbuzz" par "", et colle enfin chaque mot à sa position souhaitée. La fonction ordonne la liste du plus petit au plus grand afin que le plus petit nombre soit toujours la première partie du "fizzbuzz". Les positions sont calculées en utilisant seqpour créer un vecteur commençant à un nombre donné et augmentant par incréments de ce nombre jusqu'à ce que le nombre maximum souhaité soit atteint.

fizzbuzzer = function(max.num=100, ...){

input = list(...)
input = input[order(unlist(input))] #reorder input list by number
words = names(input)

#vector containing the result
output = seq_len(max.num)

#remove numbers at positions to contain a "fizzbuzz"
sapply(input, function(x) output[seq(x, max.num, x)] <<- "")

#add words at required points
sapply(seq_len(length(input)), function(i) output[seq(input[[i]], max.num, input[[i]])] <<- paste0(output[seq(input[[i]], max.num, input[[i]])], words[i]))

return(output)
}    

Je ne pense pas que ce soit très beau, mais il est facile de le réutiliser avec différents paramètres.

exemples d'utilisation:

fizzbuzzer(fizz=3, buzz=5)
fizzbuzzer(fizz=3, buzz=5, jazz=4)
fizzbuzzer(max.num=10000, golf=10, stack=100, code=1, exchange=1000)

La sortie de fizzbuzzer(fizz=3, buzz=5)est:

[1] "1"        "2"        "fizz"     "4"        "buzz"     "fizz"    
[7] "7"        "8"        "fizz"     "buzz"     "11"       "fizz"    
[13] "13"       "14"       "fizzbuzz" "16"       "17"       "fizz"    
[19] "19"       "buzz"     "fizz"     "22"       "23"       "fizz"    
[25] "buzz"     "26"       "fizz"     "28"       "29"       "fizzbuzz"
[31] "31"       "32"       "fizz"     "34"       "buzz"     "fizz"    
[37] "37"       "38"       "fizz"     "buzz"     "41"       "fizz"    
[43] "43"       "44"       "fizzbuzz" "46"       "47"       "fizz"    
[49] "49"       "buzz"     "fizz"     "52"       "53"       "fizz"    
[55] "buzz"     "56"       "fizz"     "58"       "59"       "fizzbuzz"
[61] "61"       "62"       "fizz"     "64"       "buzz"     "fizz"    
[67] "67"       "68"       "fizz"     "buzz"     "71"       "fizz"    
[73] "73"       "74"       "fizzbuzz" "76"       "77"       "fizz"    
[79] "79"       "buzz"     "fizz"     "82"       "83"       "fizz"    
[85] "buzz"     "86"       "fizz"     "88"       "89"       "fizzbuzz"
[91] "91"       "92"       "fizz"     "94"       "buzz"     "fizz"    
[97] "97"       "98"       "fizz"     "buzz"    

(les nombres entre crochets sont les indices du vecteur émis par la fonction)

Haskell

Aucune arithmétique modulaire n'est utilisée, sauf dans le calcul du multiple le moins commun pour éviter de répéter des travaux inutiles. Les concaténations de chaînes ne doivent être effectuées que 60 fois, quel que soit le paramètre que nous fixons à la limite supérieure.

-- Don't repeat `transpose` from `Data.List`
import Data.List (transpose)

-- The desired problem
lst = [(3, "Fizz"), (4, "Jazz"), (5, "Buzz")]

-- Map a function over both sides of a tuple.
-- We could also get this from importing Bifunctor (bimap), bit it's not in the core libraries
bimap f g (x, y) = (f x, g y)

-- Make infinite lists with the word occuring only once every n items, starting with the first
fizzify = map (cycle . uncurry take . bimap id (:repeat ""))

-- Reorganize the lists so there's a single infinite list, smash the words together, and drop the first set.
fjb = tail . map concat . transpose . fizzify

-- The following two functions avoid repeating work building the lists
-- Computes the least common multiple of a list of numbers
lcms = foldr lcm 1

-- fjbLcm is just a more efficient version of fjb; they can be used interchangably
fjbLcm lst = cycle . take (lcms . map fst $ lst) . fjb $ lst

-- show the number if there aren't any words
result = zipWith (\x y -> if null x then show y else x) (fjbLcm lst) [1..100]

main = print result

Remplacer fjbLcmpar fjbfait exactement la même chose, sans arithmétique utilisée sauf dans [1..100]et take.

Python2

Mise à jour: la nouvelle version n'utilise aucune opération de mod ou de division.

word_dict = {3: 'Fizz', 4: 'Jazz', 5: 'Buzz'}

def fizz_jazz_buzz(n, d):
    counters = {k: k for k in d}
    for i in xrange(1, n + 1):
        u = ''
        for k in d:
            if counters[k] == i:
                u += d[k]
                counters[k] += k
        print u or i

fizz_jazz_buzz(100, word_dict)

Si vous souhaitez ajouter un autre mot au test, jetez simplement la paire clé / valeur dans le dictionnaire word_dict:

word_dict[7] = 'Razz'
fizz_jazz_buzz(100, word_dict)

Si vous voulez vous débarrasser d'un mot, supprimez-le simplement (à l'aide de del) ou définissez-le sur ''.

del word_dict[3]
fizz_jazz_buzz(100, word_dict)

Voir aussi les réponses Python de Gnibbler et Jakube , qui ont été postées avant les miennes.

C #

Maintenabilité: il suffit d'ajouter une ligne par élément
que j'itère sur chaque élément du dictionnaire, pour vérifier s'il s'agit d'un diviseur du nombre actuel, et l'ajouter à la chaîne s'il l'est.
Une fois terminé, imprimez la chaîne, sauf si elle est toujours nulle (en utilisant l'opérateur de coalescence nul), auquel cas imprimez le nombre plus une chaîne vide pour en faire une chaîne. (Je pourrais utiliser toString, mais je suppose que c'est un choix personnel)

Dictionary<int, string> dict = new Dictionary<int, string>()
{
    {3, "Fizz"},
    {4, "Jazz"},
    {5, "Buzz"}
};
for (int i = 0; i < 100; i++)
{
    string msg = null;
    foreach (var pair in dict)
        if (i % pair.Key == 0)
            msg += pair.Value;
    Console.WriteLine(msg ?? i + "");
}