Pewnego razu czytałem to pytanie / odpowiedź na temat Quory

Czy naprawdę są programiści ze stopniem informatyki, którzy nie mogą przejść testu FizzBuzz?

Ten kod podano jako oczywistą odpowiedź

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

Oczywiście FizzBuzz został zagrany w golfa na śmierć, ale nie o to chodzi w tym pytaniu. W komentarzach ktoś wspomina, że ​​ta oczywista odpowiedź jest świetna, ponieważ łatwo jest dodać dodatkowe warunki, takie jak wydruk „Jazz” dla wielokrotności 4. (Nie zgadzam się. Rozszerzenie tego schematu wymaga O (2 ** n ) wierszy kodu.)

Twoim wyzwaniem jest napisanie najpiękniejszej wersji FizzJazzBuzz według oceny twoich rówieśników.

Kilka rzeczy do rozważenia przez wyborców:

1. SUCHY
2. Wydajność operacji podziału / modułu

Wiele odpowiedzi na Quora używało Pythona, ale tutaj nie ma takich ograniczeń językowych.

Przyjmę odpowiedź największą liczbą głosów za miesiąc

Przykładowe dane wyjściowe:

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

Najpiękniejsza wersja, mówisz? Spróbujmy tego w ...

Język programowania Szekspira

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]

Więc po mojej walce z SPL tutaj czułem, że muszę wykonać co najmniej jedno zgłoszenie przy każdym wyzwaniu. I to jest to.

Więc o co w tym wszystkim chodzi?

Po pierwsze, deklarujemy zmienne, których będziemy używać w całym programie, które muszą pochodzić ze sztuk Szekspira. Mając dość Romea, Julii, Ofelii i Othello, poszedłem z Arcybiskupem Canterbury i Lady Capulet . Ich opisy, a także tytuły Aktów / Scen, są odrzucane przez parser, więc możesz umieścić tam prawie wszystko, co chcesz.

Stwórzmy króla przekładów na coś nieco mniej bełkotliwego .

Akt I, Scena I

Begin Lady Capulet = 0;

Akt I jest dość prosty: inicjujemy naszą zmienną wartością 0.

Akt I, Scena II

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

Podnosimy wartość Lady Capulet i porównujemy ją ze 100 (tak, całe zdanie służy wyłącznie do uzyskania liczby 100); jeśli nie jest mniejszy, przeskakujemy do Sceny VIII (koniec); w przeciwnym razie przechodzimy do następnej Sceny.

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

Po pierwsze, widzimy, czy moduł dzielenia przez 3 wynosi 0; jeśli nie, przeskakujemy do Sceny IV; jeśli tak jest, zaczynamy wykonywać operacje arytmetyczne i przechowywać je na Archiepersonie, wysyłając je w postaci postaci, gdy znajdziemy tę, której szukamy. Tak, w końcu chodzi o to, żeby dostać Fizz.

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

Najpierw sprawdza, czy moduł dzielenia przez 4 wynosi 0, a następnie kontynuuje dla tej samej sceny jak poprzednio Jazz.

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

Działa podobnie jak dwa poprzednie, sprawdzając, czy moduł dzielenia przez 5 zwraca 0, a następnie próbuje zapisać Buzz; jedyną różnicą jest to, że ostatecznie pomijamy Scenę.

Akt I, Scena VI

System.out.print(Lady Capulet);

Aby dojść do tej Sceny, liczba przyjęta przez Lady Capulet nie może być ani Fizz, ani Jazz, ani Buzz; więc wyprowadzamy go w postaci liczbowej.

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

Jest to jedyny sposób, w jaki udało mi się przejść do następnego wiersza: najpierw CR, potem LF; następnie wracamy do sceny II, aby kontynuować program.

Akt I, Scena VIII

End.

Dość proste.

Wciąż próbuję sprawdzić, czy mogę pokazać to działające online, ale nie mogę znaleźć kompilatora online - ten, który znam , nie łączy się dobrze z żadnym programem oprócz tego, który już został załadowany, a może jest jakiś problemu z interfejsem między klawiaturą a krzesłem ...

Aktualizacja 1:

Po komentarzu matmandana zredagowałem kolejność scen Jazz i Buzz. To musiało być zrobione.

> <> (Ryby)

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

> <> to język programowania 2D, w którym instrukcje są pojedynczymi znakami, a wskaźnik instrukcji (IP) może przesuwać się w górę, w dół, w lewo lub w prawo, w zależności od strzałek ^>v<i luster /\. Nie ma zmiennych ani ciągów, więc nie powtarzanie się jest trochę trudniejsze, ale myślę, że jest to miłe na swój sposób.

Naciskamy 1i uruchamiamy pętlę. :9b*)?;sprawdza, czy liczba jest większa niż 99 ( 9b* = 9*11), a jeśli tak, program zatrzymuje się ;. W przeciwnym razie wpisz 0 do rejestru i przejdź vdo części falistej.

:3%?sprawdza liczbę modulo 3. Jeśli jest niezerowa, to schodzimy vo rząd niżej i ruszamy w lewo <. W przeciwnym razie pomijamy strzałkę w dół i pchamy "Fizz", drukujemy ją ( r}oooo) i zwiększamy wartość rejestru ( &1+&) przed odbiciem od prawego lustra ściennego, aby przejść w dół o rząd. Tak czy inaczej, w końcu ruszamy w lewo wzdłuż trzeciego rzędu, dopóki nie odbijamy się od lewych lusterek ściennych. Następnie powtarzamy dla Jazzi Buzz.

Trwa to do siódmej linii, która sprawdza wartość rejestru &. Jeśli jest niezerowy, to po prostu schodzimy. W przeciwnym razie drukujemy sam numer nprzed zejściem w dół.

Na koniec ao(pamiętajmy, że poruszamy się teraz w lewo!) Drukuje znak nowej linii ASCII i 1+zwiększa liczbę, zanim przejdziemy w górę ^i zrobimy pętlę >ponownie.

^{(Teraz czekamy na estetyczną odpowiedź Piet ...)}

LOLKOD

Elegancki? Nie. Wydajny? Absolutnie nie. Piękny? Cóż, wiesz, co mówią: piękno jest w oku patrzącego.

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

Niektóre wyjaśnienia:

Programy LOLCODE zaczynają się HAIi kończą KTHXBYE.

Zmienne są dynamicznie wpisywane i przypisywane za pomocą I HAS A <variable> ITZ <value>. Po zdefiniowaniu zmienne można również przypisać za pomocą <variable> R <value>.

Pętle w LOLCODE są nazywane. Składnia jest następująca:

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

To tylko Internet mówi „pętla do i = koniec”. W LOLCODE 1.2 zmienna indeksująca musi zostać zainicjowana przed zapętleniem. Tutaj pętla nosi nazwę „house”, ponieważ sprawia, że ​​czytanie inicjalizacji pętli wydaje się zabawne.

VISIBLEdrukuje na standardowe wyjście. Domyślnie dodawana jest nowa linia, ale dodawanie !tłumi nową linię.

Warunki są określone w następujący sposób:

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

Warunki muszą być albo wyrażeniami, które mają wartość logiczną, albo boolowską. W LOLCODE wywoływany jest typ boolowski, TROOFktóry ma wartości WIN(prawda) i FAIL(fałsz).

Komentarze jednowierszowe zaczynają się od BTW.

Nie znasz się dobrze na języku Internetz? Daj mi znać, a chętnie udzielę dalszych wyjaśnień.

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

Postanowiłem spróbować zagrać z Pietem i przekonać się, jaki ładny kod mogę zrobić. Staram się tu nic nie powtarzać, choć szczerze mówiąc muszę powtórzyć obliczenia modów. Jednak każdy odrębny mod (n% 3, n% 4 i n% 5) jest uruchamiany tylko raz na iterację kodu.

Mniejszy obraz jest właściwym źródłem i można go przesłać i uruchomić tutaj .

Cieszyć się!

Matematyka

W Mathematica możesz definiować i przeciążać funkcje dla bardzo specyficznych parametrów (nie tylko według typu, ale także dowolnych warunków logicznych). Zdefiniujmy kilka funkcji:

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

A teraz rzeczywisty program jest po prostu

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

Teraz, gdy powyższe rośnie tylko liniowo wraz z liczbą dzielników, wciąż nie jest zbyt SUCHE. Ale w rzeczywistości możemy używać zmiennych jako nazw w tych definicjach. Możemy więc napisać funkcję, która generuje te definicje funkcji:

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

Teraz wszystko, co musisz zrobić, to dodać kolejne addFunctionpołączenie i dodać nowe **zzdo ostatniej linii.

Haskell

Nie bierzecie SUCHEGO poważnie. Istnieją oczywiste wzorce, które można uwzględnić w sekwencji „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. ;)

Ten kod jest również łatwo rozszerzalny. Aby rozwiązać problem „Fizz Jazz Buzz Tizz”, wystarczy dodać Tipo Bunim ciąg. Jest to o wiele mniej niż potrzeba w jakimkolwiek innym rozwiązaniu.

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

Może to zabrzmi głupio, ale to karabin snajperski 2D!

Jawa

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

Więc Java nie jest tak naprawdę uważana za „piękną”, ale to szalone subiektywne, więc poszedłem zgodnie z wytycznymi w pytaniu:

• Nie powtarzaj się: nie ma problemu. Musisz dodać tylko jeden wiersz dla każdego numeru. Stworzyłem nawet funkcję pomocnika, abyś nie musiał tak dużo pisać, gdy to robisz (Java może być czasem trochę gadatliwa, jeśli nie wiesz).
• Wydajność operacji podziału / modułu: Doskonała wydajność, ponieważ w ogóle nie ma modułu ani podziału.

Nie oznacza to, że algorytm jako całość jest najbardziej wydajny (nie jest), ale myślę, że dobrze trafia w wypunktowane punkty.

Poinformuj 7

Inform 7 to oparty na regułach język programowania zaprojektowany do interaktywnej fikcji. Jest to jeden z najbardziej udanych języków programowania opartych na języku naturalnym. Zobacz prezentację języka Inform 7, aby zobaczyć inne przykłady i kilka drobiazgów.

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;

Zaletą tego kodu jest to, że każda z reguł FizzBuzz jest całkowicie niezależna: dodatkowe reguły można dodać w dowolnym momencie bez potrzeby zmiany ogólnych ram. Niestety jest to trochę powtarzalne, szczególnie w przypadku fraz definicji. Mógłbym zdefiniować operator%, ale wtedy nie byłby to angielski. ;)

Ten kod można uruchomić online za pomocą 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
∇

• OSUSZANIE: nie ma podwójnego kodu
• Łatwe do zmiany warunki: nazwy są pobierane z listy, w kolejności, według dzielnika, z minimalną potrzebną zmianą
• Łatwy do zmiany zakres: itemsmożna zmienić na dowolną listę liczb
• Wydajny: wykorzystuje łatwo zrównoleglony algorytm oparty na liście, składający się wyłącznie z prymitywów wolnych od efektów ubocznych.
• Prosty przepływ kodu: nie tylko nie ma goto , nie ma czasu s ani jeśli s. Kod jest całkowicie liniowy.
• Zabezpiecza twoją pracę: prawie nikt inny nie będzie w stanie nad nią pracować ...

DO#

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

Sprawdź mod, buduj ciąg, drukuj numer, jeśli jest pusty, lub ciąg, jeśli nie. Bez powtórzeń. Wystarczy dodać warunek i dane wyjściowe dla nowych wymagań.

Python 2.7

Starałem się, aby było to poetyckie ...

Nie jestem zbyt dobry w poezji miłosnej ...

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. 

Byłoby też znacznie lepiej bez początkowych stałych: P

Java z klasami

Algorytm:

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

}

Klasy:

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

Oczywiście pisanie własnych pętli jest dobrą zabawą dla programistów, ale wszyscy wiedzą, jak żmudne jest śledzenie indeksowania (kto nie pisał for(j=i;j<n;i++)w zagnieżdżonej pętli przynajmniej raz w życiu?)

MATLAB ma rozwiązanie. Naprawdę, ten kod nie jest najskuteczniejszy, a na pewno nie golfowy, ale z pewnością jest dobrą wizytówką bardziej interesujących funkcji MATLAB-a. Octave jest wersją GNU MATLAB; nie jest jednak odpowiedni do gry w golfa kodowego, ponieważ jest nieco bardziej rygorystyczny w przypadku zmiennych typów, co jest szkodliwe dla gry w golfa kodowego.

EDYCJA: do momentu podświetlenia składni dla MATLAB na SE, publikuję wersję z bardzo małą ilością komentarzy, ponieważ był to po prostu duży przerażający blok zwykłego tekstu.

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

Pyton

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)

To oczywiście zdecydowanie za długo. rozwiązanie gnibbler jest znacznie lepsze. (chociaż zastąpienie *..., sep=''go ''.joinbyłoby piękniejsze)

Jest to jednak dość wydajne pod względem operacji podziału / modułu.

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

Jeszcze inne rozwiązanie bez podziału lub modułu. fjbtworzy nieskończoną listę Fizzesów, Jazzów, Buzzów i / lub liczb. takedowolna ilość, jaką chcesz, jak widać, w print100fjbktórej drukuje pierwszych 100 elementów.

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;

gdzie I jest tabelą z jedną kolumną (id INT) zawierającą 100 liczb całkowitych.

Nie znam smaku SQL, który może łatwo wygenerować tabelę lub użyć WARTOŚCI jako podkwerend, co może uczynić go znacznie lepszym i kompletnym.

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

Być może nie jest to najbardziej efektywny sposób, ale myślę, że jest prosty i ładny <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 DRY i effin brzydki: 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);

Całkowicie głupi C #

Połowa streszczenia brzmiała: „NIE POWTÓRZ SIEBIE”, więc wziąłem to dosłownie, jak mogłem z C #, i to przypadkowo przeszło do gry w golfa. To jest mój pierwszy golf i zrobiłem to w C #, głupie wiem, ale oto wynik:

Gra w golfa ( 240 232 230 znaków):

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

Nie golfowany:

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

Celem było skrócenie wszystkiego, czego musiałem użyć więcej niż raz i ogólnie, aby kod był krótki podczas tworzenia kompletnego programu w języku C #. W tym celu należy użyć VisualStudio i ustawić obiekt StartUp na „P”, należy również poszukać danych wyjściowych w oknie wyników debugowania.

Istnieją tutaj poważne ograniczenia:

• Kod zakłada, że ​​wszystkie słowa zakończą się na „zz”
• Kod zakłada, że ​​moduł będzie się pojawiał kolejno (3,4,5,6 ...)
• Kod nadal faworyzuje brak lub powtarzanie w stosunku do prawdziwego golfa, dodano więcej znaków, aby uniknąć powtórzeń

Python 2

Chciałem napisać na to odpowiedź w schludnym Pythonie, który pokazywałby cechy języka, był zgodny z zasadą DRY i byłby dość czytelny.

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

Ten mały przykład pokazuje krojenie, inoperator i pełną, ale zrozumiałą składnię trójskładnikową. W ogóle nie używa operatora modulo. Nie jest przeznaczony do wydajności w czasie wykonywania, ale nie taki był cel. Jest krótki, zrozumiały i łatwy w utrzymaniu.

Python 2.7, 111 bajtów

To mój pierwszy wkład. Próbowałem zastosować kilka sztuczek do kodowania w Pythonie (przeplatanie łańcuchów, dostęp do indeksu krotek zamiast if). Jeśli masz jakieś sugestie, podziel się nimi!

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

Wyjście:

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

Nie mogłem też w pełni zastosować zasady DRY, ponieważ istnieją dwie forpętle. Prawdopodobnie jest na to lepszy sposób!

Udać się

Równoległy 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()
}

Wypróbuj tutaj: http://play.golang.org/p/lxaZF_oOax

Wykorzystuje tylko jeden moduł na sprawdzoną liczbę i może być dowolnie rozszerzony na dowolną liczbę, no cóż ... liczb.

Musisz tylko wprowadzić zmiany w 3 różnych miejscach, aby to rozszerzyć, w hooks mapie, FizzJazzBuzzernazwę funkcji i, oczywiście, wywołanie FizzJazzBuzzerfunkcji.

R

Tworzy to funkcję, która pozwala użytkownikowi określić pary słów i dzielników (i opcjonalnie maksymalną liczbę, z domyślną liczbą 100). Funkcja tworzy wektor od 1 do liczby maksymalnej, a następnie zastępuje dowolne liczby w pozycjach „fizzbuzz” literą „”, a na koniec wkleja każde słowo w żądanej pozycji. Funkcja porządkuje listę od najniższej do największej liczby, dzięki czemu najniższa liczba będzie zawsze pierwszą częścią „fizzbuzz”. Pozycje są obliczane za pomocą seqtworzenia wektora rozpoczynającego się od określonej liczby i rosnącego w przyrostach tej liczby, aż do osiągnięcia maksymalnej pożądanej liczby.

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

Nie sądzę, że jest bardzo piękny, ale łatwo go ponownie użyć z różnymi parametrami.

przykłady użycia:

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

Dane wyjściowe fizzbuzzer(fizz=3, buzz=5)to:

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

(liczby w nawiasach kwadratowych są wskaźnikami wektora, z którego funkcja wychodzi)

Haskell

Nie stosuje się arytmetyki modułowej, z wyjątkiem obliczania najmniejszej wspólnej wielokrotności, aby uniknąć powtarzania niepotrzebnej pracy. Łączenie łańcuchów należy wykonać tylko 60 razy, bez względu na to, co ustalimy dla górnej granicy.

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

Zastąpienie fjbLcmprzez fjbrobi dokładnie to samo, bez użycia arytmetyki, z wyjątkiem w [1..100]i take.

Python2

Aktualizacja: Nowa wersja nie używa żadnych operacji mod ani podziałów.

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)

Jeśli chcesz dodać kolejne słowo do testu, po prostu wrzuć parę klucz / wartość do słownika word_dict:

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

Jeśli chcesz się pozbyć słowa, po prostu usuń je (używając del) lub alternatywnie ustaw na ''.

del word_dict[3]
fizz_jazz_buzz(100, word_dict)

Zobacz także odpowiedzi Gnibblera i Jakube'a w języku Python , które zostały opublikowane przed moim.

DO#

Utrzymywalność: Wystarczy dodać jedną linię do każdego elementu
Ieruję po każdym elemencie w słowniku, aby sprawdzić, czy jest to dzielnik bieżącej liczby, i dodać do ciągu, jeśli tak jest.
Po zakończeniu wydrukuj ciąg, chyba że nadal jest pusty (używając operatora koalescencji zerowej), w takim przypadku wydrukuj liczbę plus pusty ciąg, aby stał się ciągiem. (Mógłbym użyć toString, ale myślę, że to osobisty wybór)

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