Es war einmal, als ich diese Frage / Antwort auf Quora las

Gibt es wirklich Programmierer mit einem Abschluss in Informatik, die den FizzBuzz-Test nicht bestehen können?

Dieser Code wird als offensichtliche Antwort gegeben

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

Natürlich FizzBuzz wurde zum Tod golfed, aber das ist nicht das, was diese Frage ist. Sie sehen, in den Kommentaren erwähnt jemand, dass diese offensichtliche Antwort großartig ist, da es einfach ist, zusätzliche Bedingungen wie print "Jazz" für ein Vielfaches von 4 hinzuzufügen ) Zeilen von Code.)

Ihre Herausforderung besteht darin, die schönste Version von FizzJazzBuzz zu schreiben, die Ihre Kollegen beurteilen.

Einige Dinge, die die Wähler beachten sollten:

1. TROCKEN
2. Effizienz von Teilungs- / Moduloperationen

Viele der Antworten auf Quora verwendeten Python, aber hier gibt es keine solche Spracheinschränkung.

In einem Monat werde ich die Antwort mit den meisten Stimmen annehmen

Beispielausgabe:

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

Die schönste Version, sagst du? Dann probieren wir diesen in ...

Shakespeare-Programmiersprache

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]

Nachdem ich hier mit SPL zu kämpfen hatte , hatte ich das Gefühl, dass ich bei jeder Herausforderung mindestens eine Einreichung damit machen musste. Und das ist es.

Also, was ist das alles dann?

Also deklarieren wir zuerst die Variablen, die wir im gesamten Programm verwenden werden und die aus Shakespeare-Stücken stammen müssen. Ich hatte die Nase voll von Romeo, Julia, Ophelia und Othello und ging mit dem Erzbischof von Canterbury und Lady Capulet hinauf . Ihre Beschreibungen sowie die Acts / Scenes-Titel werden vom Parser ignoriert, sodass Sie so ziemlich alles dort ablegen können, was Sie möchten.

Lassen Sie uns also einen König der Übersetzung zu etwas machen, das ein bisschen weniger Kauderwelsch ist .

Akt I, Szene I

Begin Lady Capulet = 0;

Act I ist ziemlich einfach: Wir initialisieren unsere Variable mit 0.

Akt I, Szene II

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

Wir erhöhen den Wert von Lady Capulet und vergleichen ihn mit 100 (ja, dieser ganze Satz dient nur dazu, die Zahl 100 zu erhalten). wenn es nicht kleiner ist, springen wir zu Szene VIII (das Ende); ansonsten fahren wir mit der nächsten Szene fort.

Akt I, Szene 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);

Zuerst sehen wir, ob der Modul der Division durch 3 0 ist; wenn nicht, springen wir zu Szene IV; Wenn dies der Fall ist, beginnen wir mit arithmetischen Operationen und speichern sie auf dem Archieperson. Sobald wir die gesuchte gefunden haben, geben wir sie in Zeichenform aus. Ja, am Ende ist die Idee zu bekommen Fizz.

Akt I, Szene 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);

Überprüft zuerst, ob der Modul der Division durch 4 0 ist, und setzt dann die gleiche Szene wie zuvor fort, z Jazz.

Akt I, Szene 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;

Funktioniert wie in den beiden vorhergehenden, prüft, ob der Modul der Division durch 5 0 ergibt, und versucht dann zu schreiben Buzz; Der einzige Unterschied ist, dass wir am Ende eine Szene überspringen.

Akt I, Szene VI

System.out.print(Lady Capulet);

Um diese Szene zu erreichen, darf die von Lady Capulet angenommene Zahl weder Fizz noch Jazz oder Buzz gewesen sein. Also geben wir es in numerischer Form aus.

Akt I, Szene 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;

Dies ist also die einzige Möglichkeit, in die nächste Zeile zu springen: Zuerst einen CR, dann einen LF ausgeben; dann kehren wir zu szene ii zurück, um mit dem programm fortzufahren.

Akt I, Szene VIII

End.

Einfach genug.

Ich versuche immer noch zu sehen, ob ich dies online zeigen kann, aber ich kann keinen Online-Compiler finden - der, den ich kenne , scheint sich mit keinem anderen Programm als dem bereits geladenen gut kombinieren zu lassen, oder vielleicht gibt es irgendein Programm von Problem mit der Schnittstelle zwischen der Tastatur und dem Stuhl ...

Update 1:

Nach Mathemandans Kommentar habe ich die Reihenfolge der Szenen von Jazz und Buzz geändert. Es musste getan werden.

> <> (Fisch)

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

> <> ist eine 2D-Programmiersprache, in der Anweisungen einzelne Zeichen sind und der Anweisungszeiger (IP) sich je nach Pfeilen ^>v<und Spiegeln nach oben, unten, links oder rechts bewegen kann /\. Es gibt keine Variablen oder Strings, so dass es ein bisschen schwieriger ist, sich nicht zu wiederholen, aber ich denke, das ist auf seine eigene Art schön.

Wir schieben 1und starten die Schleife. :9b*)?;prüft, ob die Zahl größer als 99 ( 9b* = 9*11) ist, und wenn ja, stoppt das Programm ;. Andernfalls setzen Sie eine 0 in das Register und bewegen Sie sich vin den wellenförmigen Teil.

:3%?prüft die Zahl modulo 3. Wenn sie ungleich Null ist, gehen wir veine Reihe runter und bewegen uns nach links <. Andernfalls überspringen wir den Abwärtspfeil und drücken "Fizz", drucken ihn ( r}oooo) und erhöhen das Register ( &1+&), bevor wir von den rechten Wandspiegeln abprallen, um eine Reihe nach unten zu springen. In beiden Fällen bewegen wir uns in der dritten Reihe nach links, bis wir von den linken Wandspiegeln abprallen. Dann wiederholen wir für Jazzund Buzz.

Dies wird bis zur 7. Zeile fortgesetzt, in der der &Wert des Registers überprüft wird. Wenn es nicht Null ist, gehen wir einfach runter. Andernfalls drucken wir die Nummer selbst aus, nbevor wir nach unten gehen.

Zum Schluss ao(denken Sie daran, wir bewegen uns jetzt nach links!) Wird eine ASCII-Zeile gedruckt und 1+die Zahl erhöht, bevor wir nach oben gehen ^und die Schleife >wiederholen.

^{(Jetzt warten wir auf eine ästhetische Antwort von Piet ...)}

LOLCODE

Elegant? Nee. Effizient? Definitiv nicht. Schön? Nun, Sie wissen, was sie sagen: Schönheit liegt im Auge des Betrachters.

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

Einige Erklärungen:

LOLCODE-Programme beginnen mit HAIund enden mit KTHXBYE.

Variablen werden dynamisch typisiert und mit zugewiesen I HAS A <variable> ITZ <value>. Einmal definiert, können Variablen auch mit zugewiesen werden <variable> R <value>.

Loops in LOLCODE werden benannt. Die Syntax lautet:

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

Dies ist nur Internet für "Schleife bis i = Ende" sprechen. In LOLCODE 1.2 muss die Indexvariable vor der Schleife initialisiert werden. Hier wird die Schleife "house" genannt, weil das Lesen der Schleifeninitialisierung humorvoll klingt.

VISIBLEdruckt auf stdout. Standardmäßig wird eine neue Zeile angehängt, aber das Hinzufügen !unterdrückt die neue Zeile.

Bedingungen werden wie folgt angegeben:

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

Bedingungen müssen entweder Ausdrücke sein, die zu einem Booleschen Wert oder zu einem Booleschen Wert ausgewertet werden. In LOLCODE wird der Boolesche Typ aufgerufen TROOFund verfügt über die Werte WIN(true) und FAIL(false).

Einzeilige Kommentare beginnen mit BTW.

Sie beherrschen die Sprache des Internets nicht? Lassen Sie es mich einfach wissen und ich werde Ihnen gerne weitere Erklärungen geben.

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

Ich beschloss, mit Piet zu spielen und zu sehen, wie schön ein Code ist, den ich machen kann. Ich versuche hier nichts zu wiederholen, obwohl ich, um ehrlich zu sein, die Mod-Berechnungen wiederholen muss. Jede einzelne Modifikation (n% 3, n% 4 und n% 5) wird jedoch nur einmal pro Code-Iteration ausgeführt.

Das kleinere Bild ist die richtige Quelle und kann hier hochgeladen und ausgeführt werden .

Genießen!

Mathematica

In Mathematica können Sie Funktionen für sehr spezifische Parameter definieren und überladen (nicht nur nach Typ, sondern auch nach beliebigen logischen Bedingungen). Definieren wir ein paar Funktionen:

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

Und jetzt ist das eigentliche Programm nur

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

Jetzt, wo das Obige nur linear mit der Anzahl der Teiler wächst, ist es immer noch nicht sehr TROCKEN. Aber wir können tatsächlich Variablen als Namen in diesen Definitionen verwenden. Wir können also eine Funktion schreiben, die diese Funktionsdefinitionen erzeugt:

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

Jetzt müssen Sie nur noch einen addFunctionAnruf tätigen und Ihren neuen Anruf **zzin die letzte Zeile einfügen.

Haskell

Ihr nehmt den DRY nicht ernst. Es gibt offensichtliche Muster, die in der Sequenz "Fizz Jazz Buzz" herausgerechnet werden können.

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

Dieser Code ist auch leicht erweiterbar. Um das "Fizz Jazz Buzz Tizz" -Problem zu lösen, müssen Sie nur Tinach dem Buin der Zeichenfolge hinzufügen . Dies ist viel weniger als bei allen anderen Lösungen erforderlich.

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                    '\\

Es klingt vielleicht dumm, aber es ist ein 2D-Scharfschützengewehr!

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

Java wird von den meisten nicht wirklich als "schön" angesehen, aber das ist verrückt subjektiv, also habe ich mich an die Richtlinien in der Frage gehalten:

• Wiederholen Sie sich nicht: Kein Problem. Sie müssen nur eine Zeile für jede Nummer hinzufügen. Ich habe sogar eine Hilfsfunktion erstellt, damit Sie nicht so viel eingeben müssen (Java kann manchmal etwas ausführlich sein, wenn Sie es nicht wissen).
• Effizienz von Teilungs- / Moduloperationen: Perfekte Effizienz, da es überhaupt keinen Modul oder keine Teilung gibt.

Das heißt nicht, dass der Algorithmus insgesamt am effizientesten ist (nicht), aber ich denke, er trifft die Aufzählungspunkte gut.

7 informieren

Inform 7 ist eine regelbasierte Programmiersprache für interaktive Belletristik. Es ist bemerkenswert, dass es eine der erfolgreichsten natürlichen Programmiersprachen ist. Siehe die Inform 7 Sprache Vitrine für andere Beispiele und ein paar Bits von Nebensächlichkeiten.

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;

Dieser Code hat den Vorteil, dass jede der FizzBuzz-Regeln völlig unabhängig ist: Zusätzliche Regeln können jederzeit hinzugefügt werden, ohne dass das allgemeine Framework geändert werden muss. Leider ist es ein wenig repetitiv, besonders bei den Definitionsphrasen. Ich könnte einen% -Operator definieren, aber dann wäre es nicht Englisch. ;)

Dieser Code kann online mit Playfic ausgeführt werden .

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
∇

• DRY: Es gibt keinen Doppelcode
• Leicht zu ändernde Bedingungen: Die Namen werden der Reihe nach je Divisor aus einer Liste entnommen, wobei nur minimale Änderungen erforderlich sind
• Leicht zu ändernder Bereich: itemsKann in eine beliebige Liste von Nummern geändert werden
• Effizient: Verwendet einen einfach zu parallelisierenden listenbasierten Algorithmus, der nur aus nebenwirkungsfreien Grundelementen besteht.
• Einfacher Code-Fluss: Es gibt nicht nur keine goto s, sondern auch keine while s oder if s. Der Code ist vollständig linear.
• Sichert Ihren Arbeitsplatz: Kaum jemand kann daran arbeiten ...

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

Überprüfe den Mod, baue den String, drucke die Nummer wenn leer oder den String wenn nicht. Keine Wiederholungen. Müssen nur Bedingung & Ausgabe für neue Anforderungen hinzufügen.

Python 2.7

Ich habe versucht, es poetisch zu machen ...

Ich bin nicht sehr gut in Liebesdichtung ...

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. 

Es wäre auch viel besser ohne die Anfangskonstanten: P

Java mit Klassen

Der Algorithmus:

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();
        }
    }

}

Die Klassen:

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

Natürlich macht es Programmierern Spaß, eigene Schleifen zu schreiben, aber jeder weiß, wie mühsam es ist, die Indizierung wirklich im Auge zu behalten (wer hat nicht for(j=i;j<n;i++)mindestens einmal in seinem Leben in einer verschachtelten Schleife geschrieben ?)

MATLAB hat die Lösung. In der Tat ist dieser Code nicht der effizienteste und mit Sicherheit auch nicht codegolfingfähig, aber er ist auf jeden Fall ein gutes Beispiel für die interessanteren Funktionen von MATLAB. Octave ist die GNU-Version von MATLAB; es ist jedoch nicht für Code-Golf geeignet, da es bei variablen Typen etwas strenger ist, was für Code-Golf nachteilig ist.

BEARBEITEN: Bis die Syntaxhervorhebung für MATLAB in SE vorhanden ist, veröffentliche ich eine Version mit sehr wenigen Kommentaren, da es sich ansonsten nur um einen großen, beängstigenden Klartextblock handelte.

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)

Das ist natürlich viel zu lang. Gnibbler-Lösung ist viel besser. (obwohl das Ersetzen *..., sep=''durch ''.joinschöner wäre)

Dies ist jedoch in Bezug auf Divisions- / Moduloperationen sehr effizient.

Rubin

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

Noch eine andere Lösung ohne Teilung oder Modul. fjbErstellt eine unendliche Liste von Fizzes, Jazzes, Buzzes und / oder Zahlen. takeBeliebige Anzahl, wie in print100fjbden ersten 100 Elementen angezeigt.

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;

Dabei ist I eine Tabelle mit einer Spalte (ID INT), die die 100 Ganzzahlen enthält.

Ich kenne keine SQL-Variante, mit der ich die Tabelle leicht generieren oder VALUES als Unterabfragen verwenden kann, wodurch sie viel besser und vollständiger wird.

Rubin

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

Vielleicht nicht der effizienteste Weg, aber ich finde es einfach und hübsch <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 trocken und effin hässlich: 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

DRYish ...;)

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

Äußerst dummes C #

Die Hälfte des Briefs war "NICHT WIEDERHOLEN", also habe ich das so wörtlich wie möglich mit C # genommen und das hat sich versehentlich zum Golfen des Codes entwickelt. Dies ist mein erstes Golf und ich habe es in C # gemacht, dumm, ich weiß, aber hier ist das Ergebnis:

Golf ( 240 232 230 Zeichen):

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+"");}}}}

Ungolfed:

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+""); 
         } 
      } 
   }
}

Ziel war es, alles zu verkürzen, was ich mehr als einmal verwenden musste, und im Allgemeinen den Code kurz zu halten, während ich ein vollständiges C # -Programm erstellte. Dazu müssen Sie VisualStudio verwenden und das StartUp-Objekt auf 'P' setzen. Außerdem müssen Sie im Debugging-Ausgabefenster nach der Ausgabe suchen.

Hier gibt es einige gravierende Einschränkungen:

• Der Code geht davon aus, dass alle Wörter mit "zz" enden.
• Der Code geht davon aus, dass der Modul nacheinander auftritt (3,4,5,6 ...)
• Der Code bevorzugt immer noch das Fehlen oder die Wiederholung gegenüber dem echten Golfen. Es werden mehr Zeichen hinzugefügt, um einige Wiederholungen zu vermeiden

Python 2

Ich wollte eine Antwort darauf in ein ordentliches Python schreiben, das die Merkmale der Sprache hervorhebt, dem DRY-Prinzip entspricht und ziemlich lesbar ist.

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

Dieses kleine Beispiel zeigt Slicing, den inOperator und die ausführliche, aber verständliche ternäre Syntax. Der Modulo-Operator wird überhaupt nicht verwendet. Es ist nicht auf Laufzeiteffizienz ausgelegt, aber das war nicht das Ziel. Es soll kurz, verständlich und wartbar sein.

Python 2.7, 111 Byte

Dies ist mein erster Beitrag. Ich habe versucht, einige Python-Codegolf-Tricks anzuwenden (String-Interleaving, Tupel-Index-Zugriff statt if). Wenn Sie Vorschläge haben, teilen Sie diese bitte mit!

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

Ausgabe :

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

Ich konnte das DRY-Prinzip auch nicht vollständig anwenden, da es zwei forSchleifen gibt. Es gibt wahrscheinlich einen intelligenteren Weg, dies zu tun!

Gehen

Der gleichzeitige FizzJazzBuzzer

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

Versuchen Sie es hier: http://play.golang.org/p/lxaZF_oOax

Es wird nur ein Modul pro überprüfter Zahl verwendet und kann beliebig auf eine beliebige Anzahl von, gut ... Zahlen erweitert werden.

Sie müssen nur 3 verschiedene Stellen ändern, um dies zu erweitern, in der hooksKarte den FizzJazzBuzzerFunktionsnamen und natürlich den Aufruf der FizzJazzBuzzerFunktion.

R

Dadurch wird eine Funktion erstellt, mit der ein Benutzer Wort- und Teilerpaare (und optional eine maximale Anzahl mit 100 als Standard) angeben kann. Die Funktion erstellt einen Vektor von 1 bis zur maximalen Zahl, ersetzt dann alle Zahlen an den "Fizzbuzz" -Positionen durch "" und fügt schließlich jedes Wort an der gewünschten Position ein. Die Funktion ordnet die Liste von der niedrigsten zur höchsten Zahl, so dass die niedrigste Zahl immer der erste Teil des "Fizzbuzz" ist. Die Positionen werden berechnet, indem seqein Vektor erstellt wird, der bei einer bestimmten Zahl beginnt und in Schritten von dieser Zahl zunimmt, bis die maximal gewünschte Zahl erreicht ist.

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

Ich finde es nicht sehr schön, aber es ist einfach mit verschiedenen Parametern wiederzuverwenden.

Anwendungsbeispiele:

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

Die Ausgabe von fizzbuzzer(fizz=3, buzz=5)ist:

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

(Zahlen in eckigen Klammern sind die Indizes des Vektors, den die Funktion ausgibt)

Haskell

Es wird keine modulare Arithmetik verwendet, es sei denn, es wird das am wenigsten verbreitete Vielfache berechnet, um unnötige Wiederholungen zu vermeiden. Die Verkettung der Zeichenfolgen muss nur 60 Mal durchgeführt werden, unabhängig davon, auf welche Obergrenze wir sie festgelegt haben.

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

Durch Ersetzen fjbLcmmit fjbwird genau das Gleiche erreicht, wobei außer in [1..100]und keine Arithmetik verwendet wird take.

Python2

Update: Neue Version verwendet keine Mod- oder Divisionsoperationen.

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)

Wenn Sie dem Test ein weiteres Wort hinzufügen möchten, werfen Sie das Schlüssel / Wert-Paar einfach in das word_dict-Wörterbuch:

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

Wenn Sie ein Wort entfernen möchten, löschen Sie es einfach (mit del) oder setzen Sie es auf ''.

del word_dict[3]
fizz_jazz_buzz(100, word_dict)

Siehe auch die Python-Antworten von Gnibbler und Jakube , die vor mir gepostet wurden.

C #

Wartbarkeit:
Fügen Sie einfach eine Zeile pro Element hinzu, das ich über jedes Element im Wörterbuch iteriere, um zu überprüfen, ob es ein Teiler der aktuellen Zahl ist, und fügen Sie der Zeichenfolge hinzu, wenn dies der Fall ist.
Wenn Sie fertig sind, drucken Sie die Zeichenfolge, es sei denn, sie ist immer noch null (mit dem Nullkoaleszenzoperator). In diesem Fall drucken Sie die Zahl plus eine leere Zeichenfolge, um sie zu einer Zeichenfolge zu machen. (Ich könnte toString verwenden, aber ich denke, das ist eine persönliche Wahl)

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 + "");
}