Le mirage de la personne intelligente

29

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
grignoteur
la source
1
Votre deuxième puce est un peu vague ... Qu'est-ce qui rend une division efficace? Pourquoi est-ce important pour le défi?
Sanchises
@sanchises, il existe encore des plateformes, notamment des microcontrôleurs, qui ont des opérations de division très coûteuses (en cycles / temps). Au moins une des réponses ci-dessous évite complètement la division / module - mais peut-être nuit à la lisibilité. C'est quelque chose que les électeurs doivent considérer.
gnibbler
1
@sanchises pas vague du tout à mon humble avis le point n'utilise pas du tout la division / module. Vous pouvez le faire en gardant simplement une variable pour chaque n = (3,4,5 ...) et en la réinitialisant au moment où elle ne correspond pas et en imprimant un mot et en l'incrémentant dans le cas contraire. La partie sèche peut faire une fonction / méthode de réception (n, mot) et donc le "maintien" de l'ajout de plus de mots une brise
jean

Réponses:

101

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.

Rodolfo Dias
la source
1
Il semble que j'ai des problèmes DNS. Désolé pour la fausse alarme.
Rainbolt
17
On se demande pourquoi Shakespeare ne se fait jamais jouer au golf.
Sanchises
5
J'espérais que les scènes III, IV et V correspondraient respectivement à Fizz, Jazz et Buzz. Pourtant, magnifiquement fait!
mathmandan
1
@mathmandan Damn. Quelle occasion gâchée de faire quelque chose de brillant. ZUT!!
Rodolfo Dias
1
C'est merveilleux, mais il me semble avoir remarqué un bug. Je pense qu'il produit le numéro s'il ne s'agit pas d'un Buzz, qu'il s'agisse d'un Fizz ou d'un Jazz. Je ne l'ai pas exécuté, mais je n'arrive pas à trouver le chèque pour cela. Peut-être pourriez-vous vérifier à la fin si l'archevêque est un zet le réinitialiser avant chaque boucle.
matega
45

> <> (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 ...)

Sp3000
la source
3
C'est beau. Cela devrait entrer dans le Hall of Fame pour> <> réponses.
Joshpbarron
2
Mes yeux ont immédiatement sauté sur: 3.
EMBLEM
Eh bien, ce langage ne gagnera aucun prix en lisibilité, mais il est plutôt soigné.
William T Froggard
40

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.

Alex A.
la source
3
Génial. C'est incroyable. Je ris toujours
rpax
@rpax: Excellent ... Tout se passe comme prévu ...
Alex A.
33

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='')
grignoteur
la source
Parmi la meilleure réponse actuelle, c'est la seule qui ait une forme quelconqueEfficiency of division/modulus operations
autour du
@aross Que voulez-vous dire? Toutes les réponses que j'ai vues utilisent au plus le même nombre d'opérations de division / module que celle-ci.
Hjulle
Vraiment? Toutes les autres réponses utilisent un opérateur de module pour chacune (3, 4, 5). Il est dupliqué trois fois. Il s'agit de la seule meilleure réponse avec un seul opérateur de module.
2015
1
Je viens de lire les commentaires sur la question. Je suppose que j'ai mal interprété la phrase citée. Aurait dû faire référence à la DRYplace. De plus, cette réponse est composée par le PO.
2015
31

Piet

Vue plus grande"Source" réelle

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!

tfitzger
la source
4
"Y a-t-il vraiment des programmeurs diplômés en informatique qui ne peuvent pas passer le test FizzBuzz à Piet ?"
Sanchises
26

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.

Martin Ender
la source
13
DoThe @@@ Time @@@ Warp @@@ Again /@ Range[100] // TableForm
Sp3000
10
C'est juste JMPà gauche!
MikeTheLiar
"tout ce que vous avez à faire est d'ajouter un autre appel addFunction." ... et d'ajouter la nouvelle fonction à la ligne finale?
Sparr
@Sparr oh ouais c'est vrai
Martin Ender
22

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.

Hjulle
la source
5
Et si vous deviez résoudre le problème Fizz-Jazz-Buzz-Sausage?
Anko
@Anko, je pourrais faire quelque chose comme ça fizzes = zip [3..] $ ((++ replicate 2 'z') <$> words "Fi Ja Bu") ++ ["Sausage"], ou simplement revenir à fizzes = zip [3..] $ words "Fizz Jazz Buzz Sausage".
Hjulle
3
replicate 2 zl'étire un peu. . .
Soham Chowdhury
3
@octatoan Je n'ai pas pu résister. ;)
Hjulle
16

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!

Alex
la source
La moitié de ça.!!!!
Optimizer
2
Aussi, c'est drôle - "Si vous mode 3"
Optimizer
Merci!! Je ne m'attendais pas à ce que quelqu'un réalise la partie u mode 3 si rapidement
Alex
Je ne comprends pas pourquoi la moitié!
Alex
Sniper n'est qu'à moitié. La portée est généralement au milieu du tireur d'élite.
Optimizer
15

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.

Géobits
la source
2
Ce ne serait pas Java si vous ne définissiez pas de classe. : D
Adrian Leonhard
Je voulais aimer une réponse Java et j'aime cette approche, mais j'ai l'impression que l'intégration de code dans des instructions for est une obstruction inutile. Beautiful Java est Java lisible!
Alex Pritchard
@AlexPritchard Je considère que c'est un effet secondaire du golf à code.
Fixera
11

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 .

curiousdannii
la source
7

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 ...
marinus
la source
Quelles sont les valeurs de ⎕MLet ⎕IO?
FUZxxl
Ce sont les deux 1, ce qui est la valeur par défaut.
marinus
7

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.

rapjr11
la source
2
"Pas de répétitions"? (OK, au moins la taille du code augmente linéairement avec des mots supplémentaires.)
Anko
J'ai pris le défi de ne pas répéter un peu plus loin avec ma réponse C #, mais j'ai sacrifié toute flexibilité en ce qui concerne les nombres à moduler. Je pense que le meilleur résultat serait une structure de données reliant le nombre et le mot.
sydan
@Anko Vous ne savez pas où vous voulez en venir, aucune fonction n'est répétée. Je ne fais pas la même chose deux fois n'importe où dans le code.
rapjr11
@ rapjr11 Le code vérifie i- %-quelque chose plusieurs fois, ainsi que l'ajout de snombreuses fois. (Une grande partie de la syntaxe est également répétitive, mais c'est probablement la faute de C #.)
Anko
7

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

JamJar00
la source
Créatif, mais cela ne fonctionne pas pour moi dans Python 2.7.9. Il dit: TypeError: 'str' object is not callable.
Alex A.
Hmmmm ... Merde ... Je ne sais pas trop comment j'ai raté ça: /
JamJar00
5

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();
danixon
la source
2
+1, vous avez vraiment capturé l'esprit du codage Java avec ce FizzBuzzJazz de 70 lignes. Il est orienté objet et est écrit dans un style lisible clairement spécifié, non abrégé. Très long. Mais très lisible. ; ^)
DLosc
4

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
Sanchises
la source
2
for(j=i;j<n;i++)? Ma question est: qui a écrit ceci "au moins une fois dans leur vie"? Si vous l'avez fait, j'ai une mauvaise nouvelle pour vous ...
Bogdan Alexandru
1
@BogdanAlexandru Vous n'avez jamais jamais accidentellement incrémenté la mauvaise variable dans une forboucle (par exemple lors de l'imbrication de boucles)? Êtes-vous le gars dont le code compile avec succès chaque première fois? Si vous l'êtes, j'ai des nouvelles de Dieu pour vous ...
Sanchises
2
Je ne parle pas d'incrémenter la mauvaise variable, mon code n'est pas écrit par Dieu. Je parle de ce style de codage, il est en soi très sujet aux erreurs. Le jnom d'une variable locale de boucle est correct, mais le inom est une très mauvaise pratique et c'est la source de votre erreur. Ce n'est pas purement accidentel :)
Bogdan Alexandru
@BogdanAlexandru Ah oui, je suis tout à fait d'accord; la raison pour laquelle j'utilise toujours ce style de boucle est lors de la mise en œuvre de devoirs donnés (je suis un étudiant à la maîtrise); J'utilise plutôt la notation d'index utilisée par le professeur en question, que de confondre le pauvre vieil homme en utilisant la mienne.
Sanchises
1
Ce n'est pas un problème de donner des noms d'une lettre aux index d'une boucle, mais les autres variables devraient avoir des noms plus significatifs.
Bogdan Alexandru
4

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.

Jakube
la source
1
Pourquoi utilisez-vous sorted(lst), pourquoi ne pas simplement le mettre dans l'ordre dont vous avez besoin lorsque vous le définissez?
mbomb007
Ou triez-le en place avant la boucle. lst.sort()
Davidmh
4

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
Poignée de porte
la source
On dirait que c'est des multiples de 2,3 et 4?
gnibbler
@gnibbler Oups, oui c'est ça. Fixé.
Poignée de porte
4

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.

nimi
la source
4

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.

jimmy23013
la source
1
Vous pouvez utiliser des variables dans mysql. SELECT @i:= (@i + 1) FROM mysql.help_relation, (SELECT @i:=0) v WHERE @i < 100;
slicedtoad
@slicedtoad a SELECT DISTINCT help_keyword_id FROM mysql.help_relation WHERE help_keyword_id>0 AND help_keyword_id<=100également fonctionné. Mais si 100 est changé en 10000, les deux seront cassés.
jimmy23013
1
Rejoignez-le simplement si vous avez besoin de plus de lignes.
slicedtoad
Pour autant que je sache, MySQL est le seul dialecte SQL qui ne dispose pas d'une option de générateur de ligne facile. La plupart peuvent simplement utiliser une expression de table commune récursive.
Ben
@Ben Mais les méthodes récursives ne semblent pas toujours bonnes. Je ne corrigerai pas ma réponse en changeant le dialecte car il existe déjà une réponse Oracle SQL.
jimmy23013
3

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
histocrate
la source
3

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)

soundyogi
la source
8
Pourquoi le double espacement?
Anko
Convention personnelle. Je pense que c'est plus agréable à lire.
soundyogi
stevelosh.com/blog/2012/10/why-i-two-space Je ne le fais pas, cependant.
Soham Chowdhury
Je le fais uniquement dans des projets personnels et pour le plaisir. La plupart des équipes ne l'aiment pas.
soundyogi
2

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);
Michel
la source
2

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
Sydney
la source
2

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.

Logic Knight
la source
Pourquoi ne pas utiliser set(group[...])dans les règles?
gnibbler
J'allais vers l'élégance plutôt que la vitesse. Bien entendu, l'utilisation de set () serait plus rapide dans les applications réelles.
Logic Knight
2

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!

Népho
la source
Je peux probablement aussi utiliser un tuple dans la première fordéclaration. Mettra à jour quand je peux!
Nepho
D'accord, cela fonctionne donc avec les deux variables dans la même boucle, mais je passe de 111 octets à 145: gist.github.com/Neph0/ddc7a5ad04aa083d44af5cab3f90550f
Népho
1

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.

Kristoffer Sall-Storgaard
la source
1

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)

ping
la source
1

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.

Cirdec
la source
C'est essentiellement la même que la solution de Nimi , que je n'avais pas remarquée auparavant.
Cirdec
1

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.

mathmandan
la source
1

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 + "");
}
Jack Baker
la source