El espejismo de la persona inteligente

29

Érase una vez, estaba leyendo esta pregunta / respuesta en Quora

¿Hay realmente programadores con títulos en informática que no puedan aprobar el examen FizzBuzz?

Este código se da como la respuesta obvia

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

Por supuesto, FizzBuzz ha sido golpeado hasta la muerte, pero de eso no se trata esta pregunta. Verán, en los comentarios, alguien menciona que esta respuesta obvia es excelente, ya que es fácil agregar condiciones adicionales, como imprimir "Jazz" para múltiplos de 4. (No estoy de acuerdo. Ampliar este esquema requiere O (2 ** n ) líneas de código.)

Su desafío es escribir la versión más bella de FizzJazzBuzz según lo juzguen sus compañeros.

Algunas cosas que los votantes deben considerar:

  1. SECO
  2. Eficiencia de las operaciones de división / módulo

Muchas de las respuestas en Quora estaban usando Python, pero no existe tal restricción de idioma aquí.

Aceptaré la respuesta con más votos dentro de un mes

Salida de muestra:

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
gnibbler
fuente
1
Su segundo punto es un poco vago ... ¿Qué hace que una división sea eficiente? ¿Por qué es eso importante para el desafío?
Sanchises
@sanchises, todavía existen plataformas, especialmente microcontroladores, que tienen operaciones de división muy costosas (en ciclos / tiempo). Al menos una de las respuestas a continuación evita la división / módulo por completo, pero tal vez perjudica la legibilidad. Es algo que los votantes deben considerar.
gnibbler
1
@sanchises no son vagos en absoluto, en mi humilde opinión, el punto no está usando división / módulo en absoluto Puede hacerlo simplemente manteniendo una variable para cada n = (3,4,5 ...) y restableciéndola en el momento en que coincida e imprima una palabra e incremente cuando no. La parte seca puede estar haciendo una función / método de recepción (n, palabra) y por lo tanto el "mantenimiento" de añadir más palabras de una brisa
jean

Respuestas:

101

¿La versión más bonita, dices? Entonces, probemos este en ...

Lenguaje de programación de 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]

Entonces, después de mi lucha con SPL aquí , sentí que tenía que hacer al menos una presentación con él en cualquier desafío. Y ya está.

Entonces, ¿qué es todo esto entonces?

Entonces, primero, declaramos las variables que vamos a usar en todo el programa, que deben provenir de las obras de Shakespeare. Harto de Romeo, Julieta, Ofelia y Otelo, fui con el arzobispo de Canterbury y Lady Capulet . El analizador no tiene en cuenta sus descripciones, así como los títulos de los Actos / Escenas, por lo que puede poner casi todo lo que quiera.

Entonces, hagamos un poco de traducción a algo un poco menos galimatías .

Acto I, Escena I

Begin Lady Capulet = 0;

El acto I es bastante sencillo: inicializamos nuestra variable con 0.

Acto I, Escena II

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

Incrementamos el valor de Lady Capulet y lo comparamos con 100 (sí, esa oración completa sirve únicamente para obtener el número 100); si no es más pequeño, saltamos a la escena VIII (el final); de lo contrario, continuamos a la siguiente escena.

Acto I, escena 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);

Primero, vemos si el módulo de la división por 3 es 0; si no es así, saltamos a la escena IV; si es así, comenzamos a realizar operaciones aritméticas y a almacenarlas en el Archieperson, emitiéndolas en forma de caracteres una vez que encontremos la que estamos buscando. Sí, al final, la idea es llegar Fizz.

Acto I, escena 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);

Primero verifica si el módulo de la división por 4 es 0, luego continúa como la misma escena que antes, para Jazz.

Acto I, escena 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;

Funciona como las dos anteriores, verificando si el módulo de la división por 5 devuelve 0, luego intenta escribir Buzz; la única diferencia es que, al final, nos saltamos una escena.

Acto I, escena VI

System.out.print(Lady Capulet);

Para llegar a esta escena, el número asumido por Lady Capulet no debe haber sido ni Fizz ni Jazz ni Buzz; entonces, lo sacamos en forma numérica.

Acto I, escena 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;

Entonces, esta es la única forma en que encontré para saltar a la siguiente línea: salida, primero, un CR, luego un LF; luego, volvemos a la escena II, a la que podemos continuar con el programa.

Acto I, escena VIII

End.

Lo suficientemente directo.

Todavía estoy tratando de ver si puedo mostrar esto ejecutándose en línea, pero no puedo encontrar un compilador en línea: el que conozco no parece combinar bien con ningún programa, excepto el que ya está cargado, o tal vez hay algún tipo de problema con la interfaz entre el teclado y la silla ...

Actualización 1:

Después del comentario de Mathmandan, edité el orden de las escenas de Jazz y Buzz. Que se tenía que hacer.

Rodolfo Dias
fuente
1
Parece que tengo problemas de DNS. Lo siento por la falsa alarma.
Rainbolt
17
Uno se pregunta por qué Shakespeare nunca se juega al código.
Sanchises
55
Esperaba que las escenas III, IV y V correspondieran a Fizz, Jazz y Buzz, respectivamente. Aún así, muy bien hecho!
Mathmandan
1
@mathmandan Maldición. Qué oportunidad desperdiciada para hacer algo brillante. ¡¡MALDITA SEA!!
Rodolfo Dias
1
Es maravilloso, pero parece que noté un error. Creo que genera el número si no es un Buzz, independientemente de si fue un Fizz o un Jazz. No lo ejecuté, pero parece que no puedo encontrar el cheque para esto. Tal vez podría verificar al final si el Arzobispo es un zy reiniciarlo antes de cada ciclo.
Matega
45

> <> (Pescado)

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

> <> es un lenguaje de programación 2D en el que las instrucciones son caracteres únicos y el puntero de instrucciones (IP) puede moverse hacia arriba, hacia abajo, hacia la izquierda o hacia la derecha, según las flechas ^>v<y los espejos /\. No tiene variables o cadenas, por lo que no repetirse es un poco más difícil, pero creo que esto es bueno a su manera.

Empujamos 1y comenzamos el ciclo. :9b*)?;comprueba si el número es mayor que 99 ( 9b* = 9*11), y si es así, el programa se detiene ;. De lo contrario, ponga un 0 en el registro y baje va la parte ondulada.

:3%?comprueba el número del módulo 3. Si no es cero, entonces bajamos vuna fila y nos movemos a la izquierda <. De lo contrario, omitimos la flecha hacia abajo y presionamos "Fizz", imprimimos ( r}oooo) e incrementamos el registro ( &1+&) antes de rebotar en los espejos de pared derechos para bajar una fila. De cualquier manera, terminamos moviéndonos hacia la izquierda a lo largo de la tercera fila, hasta que rebotamos en los espejos de la pared izquierda. Luego repetimos para Jazzy Buzz.

Esto continúa hasta la 7ma línea, que verifica el &valor del registro . Si no es cero, entonces bajamos. De lo contrario, imprimimos el número mismo nantes de bajar.

Finalmente, ao(recuerde, ¡nos estamos moviendo hacia la izquierda ahora!) Imprime una nueva línea ASCII e 1+incrementa el número, antes de subir ^y hacer el ciclo >nuevamente.

(Ahora esperamos una respuesta estética de Piet ...)

Sp3000
fuente
3
Esto es hermoso. Esto debería ir al salón de la fama para> <> respuestas.
Joshpbarron
2
Mis ojos inmediatamente saltaron a: 3.
EMBLEMA
Bueno, ese lenguaje no va a ganar ningún premio de legibilidad, pero es bastante bueno.
William T Froggard
40

LOLCODE

¿Elegante? No ¿Eficiente? Definitivamente no. ¿Hermosa? Bueno, ya sabes lo que dicen: la belleza está en el ojo del espectador.

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

Alguna explicación:

Los programas LOLCODE comienzan HAIy terminan con KTHXBYE.

Las variables se escriben dinámicamente y se asignan usando I HAS A <variable> ITZ <value>. Una vez definidas, las variables también se pueden asignar usando <variable> R <value>.

Se nombran bucles en LOLCODE. La sintaxis es:

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

Esto es solo hablar en Internet para "loop hasta i = end". En LOLCODE 1.2, la variable de indexación debe inicializarse antes del ciclo. Aquí el bucle se llama "casa" porque hace que la lectura de la inicialización del bucle suene humorística.

VISIBLEimprime en stdout. De manera predeterminada, se agrega una nueva línea, pero la adición !suprime la nueva línea.

Los condicionales se especifican de la siguiente manera:

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

Las condiciones deben ser expresiones que evalúen valores booleanos o booleanos. En LOLCODE, se llama al tipo booleano TROOFy tiene valores WIN(verdadero) y FAIL(falso).

Los comentarios de una sola línea comienzan con BTW.

¿No está bien versado en el lenguaje de Internetz? Solo avíseme y con gusto le daré más explicaciones.

Alex A.
fuente
3
Excelente. Esto es increíble. Todavía me estoy riendo
rpax
@rpax: Excelente ... Todo va según el plan ...
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='')
gnibbler
fuente
Entre la respuesta principal actual, esta es la única que tiene alguna forma deEfficiency of division/modulus operations
aross
@aross ¿Qué quieres decir? Todas las respuestas que he visto utilizan como máximo el mismo número de operaciones de división / módulo que esta.
Hjulle
De Verdad? Todas las demás respuestas usan un operador de módulo para cada uno de (3, 4, 5). Se duplica tres veces. Esta es la única respuesta superior con un solo operador de módulo.
Aross
1
Acabo de leer los comentarios sobre la pregunta. Supongo que interpreté mal la oración citada. Debería haber mencionado en su DRYlugar. Además, esta respuesta está compuesta por el OP.
Aross
31

Piet

Vista más grande"Fuente" real

Decidí intentar jugar con Piet y ver qué bonito código podía hacer. Intento no repetir nada aquí, aunque para ser honesto, tengo que repetir los cálculos de mod. Sin embargo, cada mod distinto (n% 3, n% 4 y n% 5) solo se ejecuta una vez por iteración de código.

La imagen más pequeña es la fuente adecuada, y se puede cargar y ejecutar aquí .

¡Disfrutar!

tfitzger
fuente
44
"¿Realmente hay programadores con títulos en ciencias de la computación que no pueden aprobar el examen FizzBuzz en Piet ?"
Sanchises
26

Mathematica

En Mathematica puede definir y sobrecargar funciones para parámetros muy específicos (no solo por tipo, sino también por condiciones lógicas arbitrarias). Definamos algunas funciones:

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

Y ahora el programa real es simplemente

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

Ahora, mientras que lo anterior solo crece linealmente con el número de divisores, todavía no es muy SECO. Pero en realidad podemos usar variables como nombres en estas definiciones. Entonces podemos escribir una función que genere estas definiciones de función:

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

Ahora todo lo que tiene que hacer es agregar otra addFunctionllamada y agregar la nueva **zza la línea final.

Martin Ender
fuente
13
DoThe @@@ Time @@@ Warp @@@ Again /@ Range[100] // TableForm
Sp3000
10
¡Está JMPa la izquierda!
MikeTheLiar
"todo lo que tiene que hacer es agregar otra llamada a addFunction" ... ¿y agregar la nueva función a la línea final?
Sparr
@Sparr oh sí, eso es cierto
Martin Ender
22

Haskell

Ustedes no se están tomando el SECO en serio. Hay patrones obvios que se pueden factorizar en la secuencia "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. ;)

Este código también es fácilmente extensible. Para resolver el problema "Fizz Jazz Buzz Tizz", todo lo que necesita hacer es agregar Tidespués Bude la cadena. Esto es mucho menos de lo que se necesita en cualquiera de las otras soluciones.

Hjulle
fuente
55
¿Qué pasaría si tuviera que resolver el problema de Fizz-Jazz-Buzz-Sausage?
Anko
@Anko, podría hacer algo como esto fizzes = zip [3..] $ ((++ replicate 2 'z') <$> words "Fi Ja Bu") ++ ["Sausage"]o simplemente volver a hacerlo fizzes = zip [3..] $ words "Fizz Jazz Buzz Sausage".
Hjulle
3
replicate 2 zLo está estirando un poco. . .
Soham Chowdhury
3
@octatoan No pude resistirme. ;)
Hjulle
16

Excel VBA

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

Puede sonar estúpido, ¡pero es un rifle de francotirador 2D!

Alex
fuente
La mitad.!!!!
Optimizador
2
Además, esto es gracioso - "If mode 3"
Optimizer
¡¡Gracias!! No esperaba que alguien se diera cuenta de la parte 3 del modo u tan rápido
Alex
¡No entiendo por qué la mitad!
Alex
Sniper es solo la mitad. El alcance suele estar en el medio del francotirador.
Optimizador
15

Java

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

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

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

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

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

Así que Java no es realmente considerado "hermoso" por la mayoría, pero eso es una locura subjetiva, así que seguí las pautas de la pregunta:

  • No te repitas: no hay problema. Solo necesita agregar una línea para cada número. Incluso hice una función auxiliar para que no tenga que escribir tanto cuando lo hace (Java puede ser un poco detallado a veces, si no lo sabía).
  • Eficiencia de las operaciones de división / módulo: eficiencia perfecta, ya que no hay ningún módulo o división en absoluto.

Eso no quiere decir que el algoritmo en su conjunto sea el más eficiente (no lo es), pero creo que alcanza bien los puntos con viñetas.

Geobits
fuente
2
No sería Java si no definieras una clase. : D
Adrian Leonhard
Quería recibir una respuesta de Java y me gusta este enfoque, pero siento que incrustar código en declaraciones for es una ofuscación innecesaria. ¡Beautiful Java es Java legible!
Alex Pritchard
@AlexPritchard Considero que es un efecto secundario del golf de código. Solucionará cuando en un PC :)
Geobits
11

Informar 7

Inform 7 es un lenguaje de programación basado en reglas diseñado para ficción interactiva. Es notable por ser uno de los lenguajes de programación basados ​​en lenguaje natural más exitosos. Consulte el escaparate de idiomas de Inform 7 para ver otros ejemplos y algunas curiosidades.

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;

Este código tiene la ventaja de que cada una de las reglas de FizzBuzz es completamente independiente: se pueden agregar reglas adicionales en cualquier momento sin necesidad de cambiar el marco general. Lamentablemente es un poco repetitivo, especialmente con las frases de definición. Podría definir un operador%, pero no sería inglés. ;)

Este código se puede ejecutar en línea usando Playfic .

curioso
fuente
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
∇
  • SECO: no hay código doble
  • Condiciones fáciles de cambiar: los nombres se toman de una lista, en orden, por divisor, con un cambio mínimo necesario
  • Rango fácil de cambiar: itemsse puede cambiar a una lista arbitraria de números
  • Eficiente: utiliza algoritmos basados ​​en listas fácilmente paralelizados que consisten solo en primitivas sin efectos secundarios.
  • Flujo de código simple: no solo no hay goto s, no hay while s o if s tampoco. El código es completamente lineal.
  • Asegura su trabajo: casi nadie más podrá trabajar en él ...
marinus
fuente
¿Cuáles son los valores de ⎕MLy ⎕IO?
FUZxxl
Ambos son 1, que es el valor predeterminado.
marinus
7

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

Verifique mod, cadena de compilación, imprima el número si está en blanco o la cadena si no No se repite. Solo necesita agregar condición y salida para nuevos requisitos.

rapjr11
fuente
2
"No se repite"? (OK, al menos el tamaño del código crece linealmente con palabras adicionales.)
Anko
Tomé el desafío de no repetir un poco más con mi respuesta de C #, pero sacrifiqué cualquier flexibilidad cuando se trata de qué números para modular. Creo que el mejor resultado sería una estructura de datos que relacione número y palabra.
sydan
@Anko No estoy seguro de a qué te refieres, no se repite ninguna función. No estoy haciendo lo mismo dos veces en ninguna parte del código.
rapjr11
@ rapjr11 El código verifica i- %algo muchas veces, además de agregar smuchas veces. (Gran parte de la sintaxis también es repetitiva, pero probablemente sea culpa de C #).
Anko
7

Python 2.7

Traté de hacerlo poético ...

No soy muy bueno en la poesía 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. 

También sería mucho mejor sin las constantes iniciales: P

JamJar00
fuente
Creativo, pero esto no funciona para mí en Python 2.7.9. Dice: TypeError: 'str' object is not callable.
Alex A.
Hmmmm ... Maldición ... No estoy completamente seguro de cómo me perdí eso: /
JamJar00
5

Java con clases

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

}

Las clases:

interface Condition {
    void apply();
}

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

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

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

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

static Out out = new Out();
danixon
fuente
2
+1, realmente ha capturado el espíritu de la codificación Java con este FizzBuzzJazz de 70 líneas. Está orientado a objetos y está escrito en un estilo claramente especificado, no abreviado y legible. Muy largo. Pero muy legible. ; ^)
DLosc
4

MATLAB / Octave

Por supuesto, escribir sus propios bucles es divertido para los programadores, pero todos saben cuán tedioso es realmente hacer un seguimiento de la indexación (quién no ha escrito for(j=i;j<n;i++) en un bucle anidado al menos una vez en sus vidas?)

MATLAB tiene la solución. Realmente, este código no es el más eficiente, y ciertamente no tiene código de golf, pero es un buen escaparate de las funciones más interesantes de MATLAB. Octave es la versión GNU de MATLAB; Sin embargo, no es adecuado para el golf de código, ya que es un poco más estricto con los tipos variables, lo que es perjudicial para el golf de código.

EDITAR: hasta que el resaltado de sintaxis para MATLAB exista en SE, estoy publicando una versión con muy pocos comentarios, porque de lo contrario era solo un gran bloque de texto sin formato.

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

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

    %Pretty output (although the default printing is perfectly acceptable)
    out=cellfun(@num2str,out,'UniformOutput',0);
    strjoin(out,sprintf('\n'));
end
Sanchises
fuente
2
for(j=i;j<n;i++)? Mi pregunta es: ¿quién hizo escribir esta "al menos una vez en su vida"? Si lo hiciste, tengo una mala noticia para ti ...
Bogdan Alexandru
1
@BogdanAlexandru ¿ Nunca en su vida ha incrementado accidentalmente la variable incorrecta en un forbucle (por ejemplo, al anidar bucles)? ¿Eres el tipo cuyo código se compila con éxito cada primera vez? Si es así, tengo
buenas
2
No estoy hablando de incrementar la variable incorrecta, mi código no está escrito por Dios. Estoy hablando de ese estilo de codificación, en sí mismo es muy propenso a errores. El jnombre de una variable local de bucle está bien, pero el inombre es una práctica muy mala y esa es la fuente de su error. No es puramente accidental :)
Bogdan Alexandru
@BogdanAlexandru Ah sí, estoy bastante de acuerdo; la razón por la que todavía uso este estilo de bucle es cuando implemento asignaciones dadas (soy un estudiante de maestría); Prefiero usar la notación de índice utilizada por el profesor en cuestión, que confundir al pobre viejo usando la mía.
Sanchises
1
No es problema dar nombres de una letra a los índices de un bucle, pero las otras variables deberían tener nombres más significativos.
Bogdan Alexandru
4

Pitón

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)

Por supuesto, esto es demasiado largo. La solución de gnibbler es mucho mejor. (aunque la sustitución *..., sep=''con ''.joinsería más bella)

Pero esto es bastante eficiente en términos de operaciones de división / módulo.

Jakube
fuente
1
¿Por qué lo usas sorted(lst), por qué no solo lo pones en el orden que necesitas cuando lo defines?
mbomb007
O ordénelo en su lugar antes del bucle. lst.sort()
Davidmh
4

Rubí

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
Pomo de la puerta
fuente
Parece que esto es múltiplos de 2,3 y 4?
gnibbler
@gnibbler Vaya, sí lo es. Fijo.
Pomo de la puerta
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

Otra solución más sin división ni módulo. fjbcrea una lista infinita de Fizzes, Jazzes, Buzzes y / o números. takecualquier cantidad que desee, como se ve en la print100fjbque imprime los primeros 100 elementos.

nimi
fuente
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;

donde I es una tabla con una columna (id INT) que contiene los 100 enteros.

No conozco un sabor SQL que pueda generar la tabla fácilmente, o puedo usar VALUES como subconsultas, lo que puede hacer que sea mucho mejor y completa.

jimmy23013
fuente
1
Puedes usar variables en mysql. SELECT @i:= (@i + 1) FROM mysql.help_relation, (SELECT @i:=0) v WHERE @i < 100;
slicedtoad
@slicedtoad SELECT DISTINCT help_keyword_id FROM mysql.help_relation WHERE help_keyword_id>0 AND help_keyword_id<=100también funcionó. Pero si 100 se cambia a 10000, ambos se romperán.
jimmy23013
1
Solo únete a ti mismo si necesitas más filas.
rodajas de maíz
Hasta donde sé, MySQL es el único dialecto SQL que no tiene una opción fácil de generador de filas. La mayoría solo puede usar una expresión de tabla común recursiva.
Ben
@Ben Pero las formas recursivas no siempre se ven bien. No arreglaré mi respuesta cambiando el dialecto porque ya hay una respuesta Oracle SQL.
jimmy23013
3

Rubí

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
histocrat
fuente
3

JavaScript


Quizás no sea la forma más eficiente, pero creo que es simple y bonita <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 SECO y efin feo: C

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

    (function isMod(_str,val){

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


        if(val >= 5) return str = _str


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


    console.log(str || iter)


    if(iter >= 100) return

    
    fizzBuzz(++iter)
})(1)

soundyogi
fuente
8
¿Por qué el doble espacio?
Anko
Convención personal. Creo que es mejor leerlo.
soundyogi
stevelosh.com/blog/2012/10/why-i-two-space Sin embargo, no lo hago.
Soham Chowdhury
Lo hago solo en proyectos personales y por diversión. A la mayoría de los equipos no les gusta.
soundyogi
2

JavaScript

SECO ...;)

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

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

    console.log(str || iter);

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

    return;
})(1);
Michel
fuente
2

Totalmente estúpido C #

La mitad del resumen era 'NO SE REPITA', así que lo tomé tan literalmente como pude con C # y eso accidentalmente progresó en el golf. Este es mi primer golf y lo hice en C #, estúpido, lo sé, pero aquí está el resultado:

Golfizado ( 240 232 230 caracteres):

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

Sin golf:

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

El objetivo era acortar cualquier cosa que tuviera que usar más de una vez y, en general, para mantener el código corto mientras producía un programa C # completo. Para esto, necesitará usar VisualStudio y establecer el objeto StartUp en 'P', también deberá buscar la salida en la ventana de salida de depuración.

Aquí hay algunas limitaciones serias:

  • El código supone que todas las palabras terminarán en 'zz'
  • El código supone que el módulo sucederá consecutivamente (3,4,5,6 ...)
  • El código aún favorece la falta o la repetición sobre el verdadero golf, se agregan más caracteres para evitar algunas repeticiones.
sydan
fuente
2

Python 2

Quería escribir una respuesta para esto en algún Python ordenado que mostrara las características del lenguaje, cumpla con el principio DRY y sea bastante legible.

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

Este pequeño ejemplo muestra el corte, el inoperador y la sintaxis ternaria detallada pero comprensible. No utiliza el operador de módulo en absoluto. No está diseñado para la eficiencia en tiempo de ejecución, pero ese no era el objetivo. Está diseñado para ser corto, comprensible y fácil de mantener.

Caballero Lógico
fuente
¿Por qué no usar set(group[...])en las reglas?
gnibbler
Iba por la elegancia en lugar de la velocidad. Usar set () sería más rápido en aplicaciones reales, por supuesto.
Logic Knight
2

Python 2.7, 111 bytes

Esta es mi primera contribución. Traté de aplicar algunos trucos de codegolfing de Python (entrelazado de cadenas, acceso al índice de tuplas en lugar de if). Si tiene alguna sugerencia, ¡compártala!

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

Salida:

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

Tampoco pude aplicar completamente el principio DRY, ya que hay dos forbucles. ¡Probablemente haya una forma más inteligente de hacerlo!

Nepho
fuente
Probablemente también pueda usar una tupla en la primera fordeclaración. Se actualizará cuando pueda!
Nepho
Bien, entonces funciona con las dos variables en el mismo bucle, pero voy de 111 bytes a 145: gist.github.com/Neph0/ddc7a5ad04aa083d44af5cab3f90550f
Nepho
1

Ir

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

Pruébelo aquí: http://play.golang.org/p/lxaZF_oOax

Solo usa un módulo por número marcado y puede ampliarse arbitrariamente a cualquier número de, bueno ... números.

Solo tiene que hacer cambios en 3 lugares diferentes para extender esto, en el hooksmapa, el FizzJazzBuzzernombre de la función y, por supuesto, la llamada a la FizzJazzBuzzerfunción.

Kristoffer Sall-Storgaard
fuente
1

R

Esto crea una función que permite al usuario especificar pares de palabras y divisores (y, opcionalmente, un número máximo, con 100 como valor predeterminado). La función crea un vector del 1 al número máximo, luego reemplaza cualquier número en las posiciones "fizzbuzz" con "", y finalmente pega cada palabra en la posición deseada. La función ordena la lista del número más bajo al más alto para que el número más bajo siempre sea la primera parte del "fizzbuzz". Las posiciones se calculan usando seqpara crear un vector que comienza en un número dado y aumenta en incrementos de ese número hasta alcanzar el número máximo deseado.

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

No creo que sea muy bonito, pero es fácil de reutilizar con diferentes parámetros.

ejemplos de uso:

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

La salida de fizzbuzzer(fizz=3, buzz=5)es:

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

(los números entre corchetes son los índices del vector que genera la función)

silbido
fuente
1

Haskell

No se utiliza aritmética modular, excepto en el cálculo del múltiplo menos común para evitar repetir trabajos innecesarios. Las concatenaciones de cadenas solo deben hacerse 60 veces, sin importar a qué establezcamos el límite superior.

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

Reemplazar fjbLcmcon fjbhace exactamente lo mismo, sin aritmética, excepto en [1..100]y take.

Cirdec
fuente
Esto es esencialmente lo mismo que la solución de Nimi , que no noté antes.
Cirdec
1

Python2

Actualización: la nueva versión no utiliza ninguna operación de mod o división.

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

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

fizz_jazz_buzz(100, word_dict)

Si desea agregar otra palabra a la prueba, simplemente arroje el par clave / valor en el diccionario word_dict:

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

Si desea deshacerse de una palabra, simplemente elimínela (usando del) o, alternativamente, configúrela en ''.

del word_dict[3]
fizz_jazz_buzz(100, word_dict)

Vea también las respuestas de Python de Gnibbler y Jakube , que se publicaron antes que las mías.

Mathmandan
fuente
1

DO#

Mantenibilidad: simplemente agregue una línea por elemento
que repita sobre cada elemento en el diccionario, para verificar si es un divisor del número actual, y agregue a la cadena si es así.
Una vez finalizado, imprima la cadena, a menos que siga siendo nula (utilizando el operador de fusión nula), en cuyo caso imprima el número más una cadena vacía para convertirla en una cadena. (Podría usar toString, pero supongo que es una elección personal)

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