Il miraggio della persona intelligente


29

C'era una volta, stavo leggendo questa domanda / risposta su Quora

Esistono davvero programmatori con titoli di informatica che non riescono a superare il test FizzBuzz

Questo codice viene fornito come risposta ovvia

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

Naturalmente FizzBuzz è stato colpito a morte a golf, ma non è questo il problema. Vedi, nei commenti, qualcuno menziona che questa ovvia risposta è ottima poiché è facile aggiungere condizioni extra come la stampa "Jazz" per multipli di 4. (Non sono d'accordo. L'estensione di questo schema richiede O (2 ** n ) righe di codice.)

La tua sfida è quella di scrivere la versione più bella di FizzJazzBuzz come giudicata dai tuoi colleghi.

Alcune cose che gli elettori devono considerare:

  1. ASCIUTTO
  2. Efficienza delle operazioni di divisione / modulo

Molte delle risposte su Quora stavano usando Python, ma qui non ci sono restrizioni linguistiche.

Accetterò la risposta con il maggior numero di voti tra un mese

Uscita campione:

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
popularity-contest  code-challenge  word  popularity-contest  string  grid  language-design  code-golf  source-layout  math  fastest-algorithm  assembly  code-golf  json  code-golf  arithmetic  array-manipulation  code-golf  ascii-art  code-golf  crossword  code-golf  string  restricted-complexity  code-golf  ascii-art  kolmogorov-complexity  code-golf  string  decision-problem  balanced-string  syntax  code-golf  grid  puzzle-solver  hexagonal-grid  code-golf  math  number  sequence  code-golf  string  decision-problem  code-golf  cryptography  king-of-the-hill  code-challenge  fastest-code  code-golf  number  code-golf  code-golf  string  code-golf  cryptography  king-of-the-hill  java  code-golf  number-theory  base-conversion  code-golf  code-golf  array-manipulation  code-golf  array-manipulation  sorting  code-challenge  restricted-source  quine  code-golf  tips  python  king-of-the-hill  code-golf  source-layout  fractal  code-golf  tips  game  king-of-the-hill  path-finding  grid  code-golf  kolmogorov-complexity  natural-language  code-golf  tips  python  code-golf  number  arithmetic  sequence  array-manipulation  code-golf  number  combinatorics  random  integer-partitions  code-golf  string  code-golf  vim  comment  code-golf  combinatorics  counting  code-challenge  rosetta-stone  code-golf  combinatorics  sequence  subsequence  code-golf  code-challenge  restricted-source  primes  printable-ascii  popularity-contest  graphical-output  image-processing 

1
Il tuo secondo punto elenco è un po 'vago ... Cosa rende efficiente una divisione? Perché è importante per la sfida?
Sanchises,

@sanchise, esistono ancora piattaforme, in particolare microcontrollori, che hanno operazioni di divisione molto costose (in cicli / tempo). Almeno una delle risposte di seguito evita del tutto la divisione / modulo - ma forse danneggia la leggibilità. È qualcosa che gli elettori devono considerare.
Gnibbler

1
@sanchise non è affatto vago IMHO il punto non sta usando affatto divisione / modulo. Puoi farlo semplicemente mantenendo una variabile per ogni n = (3,4,5 ...) e reimpostandola nel momento in cui non corrisponde e stampa una parola e incrementa quando no. La parte Dry può essere in grado di eseguire una funzione / metodo di ricezione (n, parola) e quindi il "mantenimento" dell'aggiunta di più parole in un gioco da ragazzi
Jean


Risposte:


101

La versione più bella, dici? Quindi, proviamo questo in ...

Linguaggio di programmazione di 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]

Quindi, dopo la mia lotta con SPL qui , mi sentivo come se dovessi fare almeno una presentazione con esso su qualsiasi sfida. E questo è tutto.

Allora, cos'è tutto questo allora?

Quindi, in primo luogo, dichiariamo le variabili che useremo durante il programma, che devono provenire dalle rappresentazioni di Shakespeare. Stufo di Romeo, Giulietta, Ofelia e Otello, ho continuato L'arcivescovo di Canterbury e Lady Capulet . Le loro descrizioni, così come i titoli degli Atti / Scene, sono disgustati dal parser, quindi puoi inserire praticamente qualsiasi cosa ti piaccia.

Quindi, facciamo un po 'di re della traduzione in qualcosa di meno incomprensibile .

Atto I, scena I

Begin Lady Capulet = 0;

L'atto I è piuttosto semplice: inizializziamo la nostra variabile con 0.

Atto I, scena II

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

Aumentiamo il valore di Lady Capulet e lo confrontiamo con 100 (sì, l'intera frase serve solo per ottenere il numero 100); se non è più piccolo, passiamo alla scena VIII (la fine); altrimenti, proseguiamo con la scena successiva.

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

Innanzitutto, vediamo se il modulo della divisione per 3 è 0; in caso contrario, passiamo alla scena IV; se lo è, iniziamo a fare operazioni aritmetiche e memorizzandole sull'Archieperson, esponendole in forma di personaggio una volta trovata quella che stiamo cercando. Sì, alla fine, l'idea è di ottenere Fizz.

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

Prima controlla se il modulo della divisione per 4 è 0, quindi continua come la stessa scena di prima, per Jazz.

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

Funziona come i due precedenti, controllando se il modulo della divisione per 5 restituisce 0, quindi tenta di scrivere Buzz; l'unica differenza è che, alla fine, saltiamo una scena.

Atto I, scena VI

System.out.print(Lady Capulet);

Per raggiungere questa scena, il numero assunto da Lady Capulet non deve essere né Fizz né Jazz né Buzz; quindi, lo produciamo in forma numerica.

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

Quindi, questo è l'unico modo che ho trovato per passare alla riga successiva: output, prima un CR, poi un LF; poi, torniamo alla scena II, a cui possiamo continuare con il programma.

Atto I, scena VIII

End.

Abbastanza semplice.

Sto ancora cercando di vedere se posso mostrarlo in esecuzione online, ma non riesco a trovare un compilatore online - quello che conosco non sembra combinarsi bene con nessun programma tranne quello già caricato, o forse c'è qualche tipo di problemi con l'interfaccia tra la tastiera e la sedia ...

Aggiornamento 1:

Dopo il commento di Mathmandan, ho modificato l'ordine delle scene di Jazz e Buzz. Doveva essere fatto.


1
Sembra che abbia problemi con il DNS. Ci scusiamo per il falso allarme.
Rainbolt

17
Ci si chiede perché Shakespeare non ottenga mai il golf.
Sanchises,

5
Speravo che le Scene III, IV e V corrispondessero rispettivamente a Fizz, Jazz e Buzz. Comunque, ben fatto!
Mathmandan,

1
@mathmandan Damn. Che occasione sprecata per fare qualcosa di geniale. DANNAZIONE!!
Rodolfo Dias,

1
È meraviglioso, ma mi sembra di aver notato un bug. Penso che emetta il numero se non è un Buzz, indipendentemente dal fatto che fosse un Fizz o un Jazz. Non l'ho eseguito, ma non riesco a trovare il controllo per questo. Forse alla fine potresti verificare se l'Arcivescovo è un ze resettarlo prima di ogni ciclo.
matega

45

> <> (Pesce)

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

> <> è un linguaggio di programmazione 2D in cui le istruzioni sono caratteri singoli e il puntatore dell'istruzione (IP) può spostarsi verso l'alto, il basso, a sinistra o a destra, a seconda delle frecce ^>v<e dei mirror /\. Non ha variabili o stringhe, quindi non ripetersi è un po 'più difficile, ma penso che sia bello a modo suo.

Spingiamo 1 e iniziamo il ciclo. :9b*)?;controlla se il numero è maggiore di 99 ( 9b* = 9*11) e in tal caso il programma si interrompe ;. Altrimenti, inserire uno 0 nel registro e spostarsi verso vil basso nella parte ondulata.

:3%?controlla il numero modulo 3. Se è diverso da zero, scendiamo di vuna riga e ci spostiamo a sinistra< . Altrimenti, saltiamo la freccia giù e premiamo "Fizz", stampiamo ( r}oooo) e incrementiamo il registro ( &1+&) prima di rimbalzare dagli specchi a parete a destra per scendere di una riga. Ad ogni modo finiamo per muoverci verso sinistra lungo la terza fila, fino a quando rimbalziamo sugli specchi a parete sinistra. Quindi ripetiamo per Jazze Buzz.

Questo continua fino alla settima riga, che controlla il &valore del registro . Se è diverso da zero, scendiamo e basta. Altrimenti, stampiamo il numero stesso nprima di scendere.

Infine, ao(ricorda, ora ci stiamo spostando a sinistra!) Stampa una nuova riga ASCII e 1+incrementa il numero, prima di salire ^e >ripetere il ciclo .

(Ora aspettiamo un'estetica risposta di Piet ...)


3
Questo è bellissimo. Questo dovrebbe andare nella hall of fame per> <> risposte.
Joshpbarron,

2
I miei occhi sono immediatamente saltati su: 3.
EMBLEMA

Bene, quella lingua non vincerà alcun premio di leggibilità, ma è abbastanza pulita.
William T Froggard,

40

LOLCODE

Elegante? No. Efficiente? Sicuramente no. Bellissimo? Bene, sai cosa si dice: la bellezza è negli occhi di chi guarda.

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

Qualche spiegazione:

I programmi LOLCODE iniziano HAIe finiscono con KTHXBYE.

Le variabili vengono digitate dinamicamente e assegnate usando I HAS A <variable> ITZ <value> . Una volta definite, le variabili possono anche essere assegnate usando <variable> R <value>.

I loop in LOLCODE sono denominati. La sintassi è:

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

Questo è solo parlare in Internet per "loop fino a quando i = end". In LOLCODE 1.2, la variabile di indicizzazione deve essere inizializzata prima del ciclo. Qui il loop si chiama "house" perché rende divertente la lettura dell'inizializzazione del loop.

VISIBLEstampa su stdout. Per impostazione predefinita, viene aggiunta una nuova riga, ma aggiunta! elimina la nuova riga.

I condizionali sono specificati come segue:

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

Le condizioni devono essere espressioni che valutano valori booleani o booleani. In LOLCODE, viene chiamato il tipo booleano TROOFe ha valori WIN(true) eFAIL (false).

I commenti a riga singola iniziano con BTW .

Non hai una buona conoscenza della lingua di Internetz? Fammi sapere e fornirò felicemente ulteriori spiegazioni.


3
Grande. Questo è incredibile. Sto ancora ridendo
rpax

@rpax: Eccellente ... Tutto procede secondo i piani ...
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='')

Tra la risposta superiore corrente, questo è l'unico che ha qualche forma diEfficiency of division/modulus operations
aross

@aross Che vuoi dire? Tutte le risposte che ho visto utilizzano al massimo lo stesso numero di operazioni di divisione / modulo di questa.
Hjulle

Veramente? Tutte le altre risposte usano un operatore di modulo per ciascuno di (3, 4, 5). È duplicato tre volte. Questa è l'unica risposta principale con un solo operatore modulo.
circa il

1
Ho appena letto i commenti sulla domanda. Immagino di aver frainteso la frase citata. Avrei dovuto fare riferimento DRYinvece. Inoltre, questa risposta è composta dal PO.
circa il

31

Piet

Bigger ViewActual "Source"

Ho deciso di provare a giocare con Piet e vedere quanto un bel codice avrei potuto creare. Cerco di non ripetere nulla qui, anche se ad essere sincero devo ripetere i calcoli della mod. Tuttavia, ogni mod distinta (n% 3, n% 4 e n% 5) viene sempre eseguita una sola volta per iterazione di codice.

L'immagine più piccola è l'origine corretta e può essere caricata ed eseguita qui .

Godere!


4
"Esistono davvero programmatori con titoli di informatica che non possono superare il test FizzBuzz in Piet ?"
Sanchises,

26

matematica

In Mathematica è possibile definire e sovraccaricare le funzioni per parametri molto specifici (non solo per tipo, ma anche per condizioni logiche arbitrarie). Definiamo alcune funzioni:

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

E ora il programma attuale è semplicemente

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

Ora, mentre quanto sopra cresce solo linearmente con il numero di divisori, non è ancora molto ASCIUTTO. Ma possiamo effettivamente usare le variabili come nomi in queste definizioni. Quindi possiamo effettivamente scrivere una funzione che genera queste definizioni di funzione:

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

Ora tutto ciò che devi fare è aggiungere un'altra addFunctionchiamata e aggiungere il tuo nuovo **zzalla linea finale.


13
DoThe @@@ Time @@@ Warp @@@ Again /@ Range[100] // TableForm
Sp3000,

10
È solo una JMPa sinistra!
MikeTheLiar,

"Tutto quello che devi fare è aggiungere un'altra chiamata addFunction." ... e aggiungere la nuova funzione alla riga finale?
Sparr,

@Sparr oh sì, è vero
Martin Ender,

22

Haskell

Non state prendendo sul serio il DRY. Ci sono schemi evidenti che possono essere presi in considerazione nella sequenza "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. ;)

Questo codice è anche facilmente estensibile. Per risolvere il problema "Fizz Jazz Buzz Tizz", tutto ciò che devi fare è aggiungere Tidopo Bula stringa. Questo è molto meno di quanto è necessario in una qualsiasi delle altre soluzioni.


5
E se dovessi risolvere il problema Fizz-Jazz-Buzz-Sausage?
Anko

@Anko Potrei fare qualcosa del genere fizzes = zip [3..] $ ((++ replicate 2 'z') <$> words "Fi Ja Bu") ++ ["Sausage"]o semplicemente tornare a fizzes = zip [3..] $ words "Fizz Jazz Buzz Sausage".
Hjulle

3
replicate 2 zlo sta allungando un po '. . .
Soham Chowdhury,

3
@ottatoan Non ho potuto resistere. ;)
Hjulle il

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

Potrebbe sembrare stupido, ma è un fucile da cecchino 2D!


La metà. !!!!
Ottimizzatore

2
Inoltre, questo è divertente - "Se sei in modalità 3"
Ottimizzatore

Grazie!! Non mi aspettavo che qualcuno realizzasse la parte u mode 3 così in fretta
Alex

Non capisco perché metà!
Alex

Sniper è solo la metà. Lo scopo è di solito al centro del cecchino.
Ottimizzatore

15

Giava

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

Quindi Java non è davvero considerato "bello" da molti, ma è soggettivo pazzesco, quindi ho seguito le linee guida nella domanda:

  • Non ripetere te stesso: nessun problema. Devi solo aggiungere una riga per ogni numero. Ho anche creato una funzione di supporto in modo da non dover digitare così tanto quando lo fai (a volte Java può essere un po 'prolisso, se non lo sapevi).
  • Efficienza delle operazioni di divisione / modulo: efficienza perfetta, poiché non esiste alcun modulo o divisione.

Questo non vuol dire che l'algoritmo nel suo insieme sia il più efficiente (non lo è), ma penso che colpisca bene i punti.


2
Non sarebbe Java se non definissi una classe. : D
Adrian Leonhard

Volevo una risposta Java e mi piace questo approccio, ma mi sento come incorporare il codice nelle dichiarazioni for è inutile offuscamento. Beautiful Java è Java leggibile!
Alex Pritchard,

@AlexPritchard Ritengo che un effetto collaterale del golf del codice.
Risolverà

11

Informare 7

Inform 7 è un linguaggio di programmazione basato su regole progettato per la narrativa interattiva. È noto per essere uno dei linguaggi di programmazione basati sul linguaggio naturale di maggior successo. Vedi la vetrina di Inform 7 in lingua per altri esempi e alcune curiosità.

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;

Questo codice ha il vantaggio che ciascuna delle regole di FizzBuzz è completamente indipendente: è possibile aggiungere regole aggiuntive in qualsiasi momento senza dover cambiare il quadro generale. Sfortunatamente è un po 'ripetitivo, specialmente con le frasi di definizione. Potrei definire un operatore%, ma non sarebbe l'inglese. ;)

Questo codice può essere eseguito online utilizzando Playfic .


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
∇
  • SECCO: non esiste un doppio codice
  • Condizioni facili da cambiare: i nomi sono presi da un elenco, in ordine, per divisore, con il minimo cambiamento necessario
  • Intervallo facile da modificare: itemspuò essere modificato in un elenco arbitrario di numeri
  • Efficiente: utilizza un algoritmo basato su elenchi facilmente parallelizzato costituito solo da primitive libere da effetti collaterali.
  • Flusso di codice semplice: non solo non ci sono goto s, non ci sono neanche while s o if s. Il codice è completamente lineare.
  • Protegge il tuo lavoro: quasi nessun altro potrà lavorarci ...

Quali sono i valori di ⎕MLe ⎕IO?
FUZxxl

Sono entrambi 1, che è l'impostazione predefinita.
Marin

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

Controlla mod, costruisci stringa, stampa numero se vuoto o stringa se no. Nessuna ripetizione È sufficiente aggiungere condizioni e output per i nuovi requisiti.


2
"Nessuna ripetizione"? (OK, almeno la dimensione del codice aumenta in modo lineare con parole aggiuntive.)
Anko

Ho preso la sfida di non ripetere più un po 'di più con la mia risposta C #, ma ho sacrificato qualsiasi flessibilità quando si tratta di quali numeri su cui modulare. Penso che il miglior risultato sarebbe una struttura dati relativa a numero e parola.
Sydney

@Anko Non sei sicuro di cosa stai arrivando, nessuna funzione viene ripetuta. Non sto facendo la stessa cosa due volte in qualsiasi parte del codice.
rapjr11

@ rapjr11 Il codice controlla i- %-qualcosa di più volte, oltre ad aggiungerlo a spiù volte. (Molta parte della sintassi è anche ripetitiva, ma probabilmente è colpa di C #.)
Anko

7

Python 2.7

Ho provato a renderlo poetico ...

Non sono molto bravo nella poesia amorosa ...

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. 

Sarebbe anche molto meglio senza le costanti iniziali: P


Creativo, ma questo non funziona per me in Python 2.7.9. Dice: TypeError: 'str' object is not callable.
Alex A.

Hmmmm ... Accidenti ... Non sono del tutto sicuro di come mi sia perso: /
JamJar00

5

Java con classi

L'algoritmo:

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

}

Le classi:

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

2
+1, hai davvero catturato lo spirito della codifica Java con questo FizzBuzzJazz a 70 righe. È orientato agli oggetti ed è scritto in uno stile chiaramente specificato, non abbreviato, leggibile. Molto lungo. Ma molto leggibile. ; ^)
DLosc,

4

MATLAB / Octave

Naturalmente, scrivere i propri loop è divertente per i programmatori, ma tutti sanno quanto sia noioso tenere traccia dell'indicizzazione (chi non ha scritto for(j=i;j<n;i++) in un ciclo annidato almeno una volta nella vita?)

MATLAB ha la soluzione. In realtà, questo codice non è il più efficiente, e certamente non codificato, ma è sicuramente una buona vetrina delle funzioni più interessanti di MATLAB. Octave è la versione GNU di MATLAB; non è tuttavia adatto per il code-golf poiché è leggermente più rigido con tipi variabili, il che è dannoso per il code-golf.

EDIT: fino a quando l'evidenziazione della sintassi per MATLAB non esiste su SE, sto pubblicando una versione con pochissimi commenti, perché altrimenti era solo un grande blocco spaventoso di testo normale.

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

2
for(j=i;j<n;i++)? La mia domanda è: chi l' ha scritto "almeno una volta nella vita"? Se lo facessi, ho una brutta notizia per te ...
Bogdan Alexandru,

1
@BogdanAlexandru Non hai mai incrementato inavvertitamente la variabile sbagliata in un forloop (ad es. Quando si annidano i loop)? Sei il ragazzo il cui codice viene compilato correttamente ogni prima volta? Se lo sei, ho delle notizie su Dio per te ...
Sanchises,

2
Non sto parlando di incrementare la variabile sbagliata, il mio codice non è scritto da dio. Sto parlando di quello stile di codifica, è di per sé molto soggetto a errori. Il jnome per una variabile locale del ciclo va bene, ma il inome è una brutta pratica e questa è la fonte del tuo errore. Non è solo per caso :)
Bogdan Alexandru,

@BogdanAlexandru Ah sì, sono abbastanza d'accordo; il motivo per cui utilizzo ancora questo stile di loop è quando eseguo determinati incarichi (sono uno studente di master); Preferisco usare la notazione dell'indice usata dal professore in questione, piuttosto che confondere il povero vecchio usando il mio.
Sanchises

1
Non è un problema dare nomi di una lettera agli indici di un ciclo, ma le altre variabili dovrebbero avere nomi più significativi.
Bogdan Alexandru,

4

Pitone

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)

Questo è ovviamente troppo lungo. La soluzione di gnibbler è molto migliore. (anche se sostituirlo *..., sep=''con ''.joinsarebbe più bello)

Ma questo è abbastanza efficiente in termini di operazioni di divisione / modulo.


1
Perché lo usi sorted(lst), perché non lo metti semplicemente nell'ordine che ti serve quando lo definisci?
mbomb007,

O ordinalo in posizione prima del ciclo. lst.sort()
Davidmh,

4

Rubino

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

Sembra che questo sia multipli di 2,3 e 4?
Gnibbler,

@gnibbler Whoops, sì, lo è. Fisso.
Maniglia della porta

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

Ancora un'altra soluzione senza divisione o modulo. fjbcrea un elenco infinito di Fizzes, Jazz, Buzz e / o numeri. takequalsiasi importo desiderato, come si vede in print100fjbcui stampa i primi 100 elementi.


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;

dove I è una tabella con una colonna (id INT) contenente i 100 numeri interi.

Non conosco un sapore SQL in grado di generare facilmente la tabella o di utilizzare VALORI come sottoquery, che può renderlo molto migliore e completo.


1
Puoi usare le variabili in mysql. SELECT @i:= (@i + 1) FROM mysql.help_relation, (SELECT @i:=0) v WHERE @i < 100;
slicedtoad

Anche @slicedtoad SELECT DISTINCT help_keyword_id FROM mysql.help_relation WHERE help_keyword_id>0 AND help_keyword_id<=100ha funzionato. Ma se 100 viene modificato in 10000, entrambi verranno interrotti.
jimmy23013

1
Unisciti a te se hai bisogno di più righe.
slicedtoadad

Per quanto ne so, MySQL è l'unico dialetto SQL che non ha un'opzione di generatore di righe facile. La maggior parte può semplicemente usare un'espressione di tabella comune ricorsiva.
Ben

@Ben Ma i modi ricorsivi non sono sempre belli. Non aggiusterò la mia risposta cambiando il dialetto perché esiste già una risposta Oracle SQL.
jimmy23013,

3

Rubino

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

3

JavaScript


Forse non è il modo più efficiente, ma penso che sia semplice e carino <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 ed effin brutto: 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)


8
Perché la doppia spaziatura?
Anko

Convenzione personale. Penso che sia più bello da leggere.
soundyogi


Lo faccio solo in progetti personali e per divertimento. Alla maggior parte delle squadre non piace.
soundyogi,

2

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

2

C # assolutamente stupido

La metà del brief è stata "NON RIPETERE TE STESSO", quindi l'ho preso nel modo più letterale che potevo con C # e che per sbaglio ho progredito nel golf del codice. Questo è il mio primo golf e l'ho fatto in C #, stupido lo so ma ecco il risultato:

Golfato ( 240 232 230 caratteri):

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

Lo scopo era quello di abbreviare qualsiasi cosa che dovessi usare più di una volta e in generale per mantenere breve il codice durante la produzione di un programma C # completo. Per questo dovrai usare VisualStudio e impostare l'oggetto StartUp su 'P' dovrai anche cercare l'output nella finestra dell'output di debug.

Ci sono alcune gravi limitazioni qui:

  • Il codice presuppone che tutte le parole finiscano in 'zz'
  • Il codice presuppone che il modulo accada consecutivamente (3,4,5,6 ...)
  • Il codice favorisce ancora la mancanza o la ripetizione rispetto al vero golf, vengono aggiunti più caratteri per evitare alcune ripetizioni

2

Python 2

Volevo scrivere una risposta per questo in un ordinato Python che mettesse in mostra le caratteristiche del linguaggio, rispettasse il principio DRY ed fosse abbastanza leggibile.

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

Questo piccolo esempio mostra lo slicing, l' inoperatore e la sintassi ternaria dettagliata ma comprensibile. Non utilizza affatto l'operatore modulo. Non è progettato per l'efficienza di runtime, ma non era questo l'obiettivo. È progettato per essere breve, comprensibile e mantenibile.


Perché non utilizzare set(group[...])nelle regole?
Gnibbler,

Stavo cercando l'eleganza piuttosto che la velocità. Naturalmente set () sarebbe più veloce nelle applicazioni reali.
Logic Knight,

2

Python 2.7, 111 byte

Questo è il mio primo contributo. Ho provato ad applicare alcuni trucchi di codegolfing di Python (interlacciamento di stringhe, accesso all'indice di tupla anziché if). Se hai qualche suggerimento, condividili!

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

Produzione :

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

Inoltre non ho potuto applicare completamente il principio DRY, poiché ci sono due forloop. C'è probabilmente un modo più intelligente per farlo!


Probabilmente posso anche usare una tupla nella prima foraffermazione. Aggiornerò quando posso!
Nepho,

Va bene, quindi funziona con le due variabili nello stesso loop, ma vado da 111 byte a 145: gist.github.com/Neph0/ddc7a5ad04aa083d44af5cab3f90550f
Nepho

1

Partire

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

Provalo qui: http://play.golang.org/p/lxaZF_oOax

Utilizza solo un modulo per numero verificato e può essere arbitrariamente esteso a qualsiasi numero di, beh ... numeri.

Devi solo apportare modifiche in 3 luoghi diversi per estenderlo, nella hooksmappa, nel FizzJazzBuzzernome della funzione e, ovviamente, nella chiamata alla FizzJazzBuzzerfunzione.


1

R

Questo crea una funzione che consente a un utente di specificare coppie di parole e divisori (e facoltativamente un numero massimo, con 100 come predefinito). La funzione crea un vettore da 1 al numero massimo, quindi sostituisce tutti i numeri nelle posizioni "fizzbuzz" con "" e infine incolla ogni parola nella posizione desiderata. La funzione ordina l'elenco dal numero più basso al più alto in modo che il numero più basso sia sempre la prima parte del "fizzbuzz". Le posizioni vengono calcolate usando seqper creare un vettore a partire da un dato numero e aumentando in incrementi di quel numero fino a raggiungere il numero massimo desiderato.

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

Non credo sia molto bello, ma è facile da riutilizzare con parametri diversi.

esempi di utilizzo:

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

L'output di fizzbuzzer(fizz=3, buzz=5)è:

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

(i numeri tra parentesi quadre sono gli indici del vettore che la funzione genera)


1

Haskell

Non viene utilizzata l'aritmetica modulare, tranne nel calcolo del multiplo meno comune per evitare di ripetere il lavoro non necessario. Le concatenazioni di stringhe devono essere eseguite solo 60 volte, indipendentemente dal limite massimo impostato.

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

La sostituzione fjbLcmcon fjbfa esattamente la stessa cosa, senza aritmetica usata se non in [1..100]e take.


This is essentially the same as Nimi's solution, which I didn't notice before.
Cirdec

1

Python2

Update: New version doesn't use any mod or division operations.

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)

If you want to add another word to the test, just throw the key/value pair into the word_dict dictionary:

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

If you want to get rid of a word, just delete it (using del) or alternatively set it to ''.

del word_dict[3]
fizz_jazz_buzz(100, word_dict)

See also the Python answers of Gnibbler and Jakube, which were posted before mine.


1

C#

Maintainability: Just add one line per element
I iterate over each element in the dictionary, to check if it's a divisor of the current number, and adding to the string if it is.
Once finished, print the string, unless it is still null ( using the null coalescing operator ), in which case print the number plus an empty string to make it a string. ( I could use toString, but I guess that's a personal choice )

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 + "");
}
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.