A miragem da pessoa inteligente


29

Era uma vez, eu estava lendo esta pergunta / resposta no Quora

Existem realmente programadores com formação em ciência da computação que não podem passar no teste FizzBuzz

Este código é dado como a resposta óbvia

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

É claro que o FizzBuzz foi jogado até a morte, mas não é disso que se trata. Nos comentários, alguém menciona que essa resposta óbvia é ótima, pois é fácil adicionar condições extras, como imprimir "Jazz" para múltiplos de 4. (Não concordo. Estender esse esquema requer O (2 ** n ) linhas de código.)

Seu desafio é escrever a versão mais bonita do FizzJazzBuzz, conforme julgado por seus colegas.

Algumas coisas a serem consideradas pelos eleitores:

  1. SECO
  2. Eficiência das operações de divisão / módulo

Muitas das respostas no Quora estavam usando Python, mas não há essa restrição de idioma aqui.

Aceito a resposta com mais votos daqui a um mês

Saída de amostra:

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 

11
Seu segundo ponto é um pouco vago ... O que torna uma divisão eficiente? Por que isso é importante para o desafio?
Sanchises

@sanchises, ainda existem plataformas, especialmente microcontroladores, que possuem operações de divisão muito caras (em ciclos / tempo). Pelo menos uma das respostas abaixo evita completamente a divisão / módulo - mas talvez prejudique a legibilidade. É algo que os eleitores devem considerar.
gnibbler

11
@sanchises não é vago de todo IMHO o ponto não está usando divisão / módulo. Você pode fazer isso apenas mantendo uma variável para cada n = (3,4,5 ...) e redefini-la no momento em que ela corresponder e imprimir uma palavra e aumentar quando não estiver. A parte seca pode estar fazendo uma função / método de recepção (n, palavra) e, assim, a "manutenção" de adicionar mais palavras uma brisa
jean


Respostas:


101

A versão mais bonita, você diz? Então, vamos tentar este em ...

Linguagem de programação 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]

Então, depois da minha luta com a SPL aqui , senti que tinha que fazer pelo menos uma finalização em qualquer desafio. E é isso.

Então, o que é tudo isso então?

Então, primeiro, declaramos as variáveis ​​que usaremos ao longo do programa, que devem vir das peças de Shakespeare. Farto de Romeu, Julieta, Ofélia e Othello, fui com o Arcebispo de Cantuária e Lady Capulet . Suas descrições, assim como os títulos de Atos / Cenas, são desprezados pelo analisador, para que você possa colocar praticamente tudo o que quiser.

Então, vamos fazer um rei da tradução para algo um pouco menos sem sentido .

Ato I, Cena I

Begin Lady Capulet = 0;

O ato I é bem direto: inicializamos nossa variável com 0.

Ato I, Cena II

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

Nós aumentamos o valor de Lady Capulet e o comparamos com 100 (sim, essa frase inteira serve apenas para obter o número 100); se não for menor, pularemos para a cena VIII (final); caso contrário, continuamos na próxima cena.

Ato I, Cena 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);

Primeiro, vemos se o módulo da divisão por 3 é 0; caso contrário, passamos para a cena IV; se for, começamos a fazer operações aritméticas e as armazenamos no Arquieperson, produzindo-as na forma de caractere assim que encontrarmos a que procuramos. Sim, no final, a ideia é entender Fizz.

Ato I, Cena 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);

Primeiro verifica se o módulo da divisão por 4 é 0 e depois continua como a mesma cena de antes Jazz.

Ato I, Cena 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 as duas anteriores, verificando se o módulo da divisão por 5 retorna 0 e, em seguida, tenta escrever Buzz; a única diferença é que, no final, pulamos uma cena.

Ato I, Cena VI

System.out.print(Lady Capulet);

Para chegar a essa cena, o número assumido por Lady Capulet não deve ter sido nem Fizz, nem Jazz, nem Buzz; então, nós a produzimos na forma numérica.

Ato I, Cena 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;

Então, essa é a única maneira que encontrei para pular para a próxima linha: saída, primeiro, um CR, depois um LF; então, voltamos à cena II, para a qual podemos continuar com o programa.

Ato I, Cena VIII

End.

Simples o suficiente.

Ainda estou tentando ver se posso mostrar isso em execução on-line, mas não consigo encontrar um compilador on-line - aquele que eu conheço não parece combinar bem com nenhum programa, exceto o que já foi carregado, ou talvez haja algum tipo de problema com a interface entre o teclado e a cadeira ...

Atualização 1:

Após o comentário de mathmandan, editei a ordem das cenas de Jazz e Buzz. Tinha que ser feito.


11
Parece que tenho problemas de DNS. Desculpe pelo alarme falso.
Rainbolt

17
É de se perguntar por que Shakespeare nunca joga golfe com código.
Sanchises 5/03/2015

5
Eu esperava que as cenas III, IV e V correspondessem a Fizz, Jazz e Buzz, respectivamente. Ainda bem feito!
mathmandan

11
@mathmandan Porra. Que oportunidade desperdiçada de fazer algo brilhante. DROGA!!
Rodolfo Dias

11
É maravilhoso, mas parece que notei um bug. Eu acho que ele gera o número se não for um Buzz, independentemente de ser um Fizz ou um Jazz. Não o executei, mas não consigo encontrar o cheque para isso. Talvez você possa verificar no final se o arcebispo é um ze redefini-lo antes de cada ciclo.
Matega

45

> <> (Peixe)

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

> <> é uma linguagem de programação 2D em que as instruções são caracteres simples e o ponteiro de instruções (IP) pode mover-se para cima, baixo, esquerda ou direita, dependendo das setas ^>v<e dos espelhos /\. Ele não possui variáveis ​​ou strings, portanto, não se repetir é um pouco mais difícil, mas acho que isso é legal à sua maneira.

Empurramos 1e iniciamos o ciclo. :9b*)?;verifica se o número é maior que 99 ( 9b* = 9*11) e se o programa é interrompido ;. Caso contrário, coloque um 0 no registrador e desça vpara a parte ondulada.

:3%?verifica o número do módulo 3. Se não for zero, vamos descer vuma linha e mover para a esquerda <. Caso contrário, pulamos a seta para baixo e pressionamos "Fizz", imprimimos ( r}oooo) e incrementamos o registro ( &1+&) antes de saltar dos espelhos da parede direita para descer uma fileira. De qualquer maneira, acabamos movendo para a esquerda ao longo da terceira fila, até saltarmos dos espelhos da parede esquerda. Então repetimos para Jazze Buzz.

Isso continua até a 7ª linha, que verifica o &valor do registro . Se for diferente de zero, simplesmente caímos. Caso contrário, imprimimos o número em si nantes de descer.

Por fim, ao(lembre-se, estamos indo para a esquerda agora!) Imprime uma nova linha ASCII e 1+aumenta o número, antes de subirmos ^e fazermos o loop >novamente.

(Agora esperamos uma resposta estética Piet ...)


3
Isso é lindo. Isso deve entrar no corredor da fama para> <> respostas.
Joshpbarron

2
Meus olhos imediatamente saltaram para o: 3.
EMBLEMA

Bem, esse idioma não vai ganhar nenhum prêmio de legibilidade, mas é bem legal.
William T Froggard

40

LOLCODE

Elegante? Não. Eficiente? Definitivamente não. Lindo? Bem, você sabe o que eles dizem: a beleza está nos olhos de quem vê.

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

Alguma explicação:

Os programas LOLCODE começam HAIe terminam com KTHXBYE.

As variáveis ​​são digitadas dinamicamente e são atribuídas usando I HAS A <variable> ITZ <value>. Uma vez definidas, as variáveis ​​também podem ser atribuídas usando <variable> R <value>.

Loops em LOLCODE são nomeados. A sintaxe é:

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

Isso é apenas Internet falar por "loop até i = end". No LOLCODE 1.2, a variável de indexação precisa ser inicializada antes do loop. Aqui, o loop é chamado de "casa" porque faz com que a leitura da inicialização do loop pareça engraçada.

VISIBLEimprime em stdout. Por padrão, uma nova linha é anexada, mas a adição !suprime a nova linha.

Os condicionais são especificados da seguinte forma:

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

As condições devem ser expressões avaliadas como valores booleanos ou booleanos. Em LOLCODE, o tipo booleano é chamado TROOFe possui valores WIN(true) e FAIL(false).

Os comentários de linha única começam com BTW.

Não é bem versado no idioma da Internetz? Avise-me e, com prazer, fornecerei mais explicações.


3
Ótimo. Isto é incrível. Eu ainda estou rindo
rpax

@rpax: Excelente ... Tudo está indo conforme o planejado ...
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='')

Entre a resposta superior atual, este é o único que tem alguma forma deEfficiency of division/modulus operations
aross

@aross O que você quer dizer? Todas as respostas que eu vi usam no máximo o mesmo número de operações de divisão / módulo que esta.
Hjulle

Sério? Todas as outras respostas usam um operador de módulo para cada um (3, 4, 5). É duplicado três vezes. Essa é a única resposta principal com apenas um operador de módulo único.
Aross

11
Acabei de ler os comentários sobre a pergunta. Acho que interpretei mal a frase citada. Deveria ter se referido DRY. Além disso, essa resposta é composta pelo OP.
aross 16/03/2015

31

Piet

Visão ampliada"Origem" real

Decidi tentar brincar com Piet e ver como era um código bonito. Tento não repetir nada aqui, embora, para ser sincero, precise repetir os cálculos do mod. No entanto, cada mod distinto (n% 3, n% 4 e n% 5) é executado apenas uma vez por iteração de código.

A imagem menor é a fonte apropriada e pode ser carregada e executada aqui .

Apreciar!


4
"Existem realmente programadores com formação em ciência da computação que não podem passar no teste do FizzBuzz em Piet ?"
Sanchises 13/03/2015

26

Mathematica

No Mathematica, você pode definir e sobrecarregar funções para parâmetros muito específicos (não apenas por tipo, mas também por condições lógicas arbitrárias). Vamos definir algumas funções:

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 agora o programa atual é meramente

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

Agora, enquanto o acima cresce apenas linearmente com o número de divisores, ainda não é muito SECO. Mas podemos realmente usar variáveis ​​como nomes nessas definições. Então, na verdade, podemos escrever uma função que gere essas definições de função:

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

Agora tudo o que você precisa fazer é adicionar outra addFunctionchamada e adicionar sua nova **zzà linha final.


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

10
É apenas um JMPpara a esquerda!
MikeTheLiar

"tudo o que você precisa fazer é adicionar outra chamada addFunction." ... e adicionar a nova função à linha final?
Sparr

@Sparr oh sim isso é verdade
Martin Ender

22

Haskell

Vocês não estão levando o DRY a sério. Existem padrões óbvios que podem ser fatorados na sequência "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 também é facilmente extensível. Para resolver o problema "Fizz Jazz Buzz Tizz", basta adicionar Tiapós Bua sequência. Isso é muito menor do que o necessário em qualquer uma das outras soluções.


5
E se você tivesse que resolver o problema do Fizz-Jazz-Buzz-Sausage?
Anko

@ Anko eu poderia fazer algo assim fizzes = zip [3..] $ ((++ replicate 2 'z') <$> words "Fi Ja Bu") ++ ["Sausage"], ou apenas reverter para fizzes = zip [3..] $ words "Fizz Jazz Buzz Sausage".
Hjulle

3
replicate 2 zestá alongando um pouco. . .
Soham Chowdhury 25/03

3
@ octatoan Eu não pude resistir. ;)
Hjulle 26/03/2015

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

Pode parecer estúpido, mas é um rifle sniper 2D!


Metade disso.!!!!
Optimizer

2
Além disso, isso é engraçado - "Se você usa o modo 3"
Optimizer

Obrigado!! Eu não esperava que alguém percebe a parte modo de u 3 tão rápido
Alex

Eu não entendo por que metade disso!
Alex

Sniper é apenas metade. O alcance geralmente está no meio do atirador.
Optimizer

15

Java

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

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

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

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

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

Então o Java não é realmente considerado "bonito" pela maioria, mas isso é uma loucura subjetiva, então eu segui as orientações da pergunta:

  • Não se repita: não há problema. Você só precisa adicionar uma linha para cada número. Eu até criei uma função auxiliar para que você não precise digitar tanto quando o fizer (o Java pode ser um pouco detalhado às vezes, se você não sabia).
  • Eficiência nas operações de divisão / módulo: Eficiência perfeita, pois não há módulo ou divisão.

Isso não quer dizer que o algoritmo como um todo seja o mais eficiente (não é), mas acho que atinge bem os pontos com marcadores.


2
Não seria Java se você não definisse uma classe. : D
Adrian Leonhard

Queria gostar de uma resposta Java e gosto dessa abordagem, mas sinto que incorporar código em declarações for é ofuscação desnecessária. Java bonito é Java legível!
Alex Pritchard #

@AlexPritchard Considero isso um efeito colateral do código de golfe. Será corrigido quando estiver em um PC :)
Geobits

11

Informar 7

O Inform 7 é uma linguagem de programação baseada em regras projetada para ficção interativa. É notável por ser uma das linguagens de programação baseadas em linguagem natural de maior sucesso. Veja a mostra do idioma do Inform 7 para outros exemplos e algumas 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;

Esse código tem a vantagem de que cada uma das regras do FizzBuzz é completamente independente: regras adicionais podem ser adicionadas a qualquer momento sem a necessidade de alterar a estrutura geral. Infelizmente, é um pouco repetitivo, especialmente com as frases de definição. Eu poderia definir um operador%, mas não seria em inglês. ;)

Este código pode ser executado online usando o 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
∇
  • SECO: não há código duplo
  • Condições fáceis de alterar: os nomes são retirados de uma lista, em ordem, por divisor, com o mínimo de alterações necessárias
  • Faixa fácil de alterar: itemspode ser alterada para uma lista arbitrária de números
  • Eficiente: utiliza algoritmo baseado em lista facilmente paralelizado, consistindo apenas de primitivas livres de efeitos colaterais.
  • Fluxo de código simples: não apenas não há goto s, nem s while, ou se s também. O código é completamente linear.
  • Protege o seu trabalho: quase ninguém mais poderá trabalhar nele ...

Quais são os valores de ⎕MLe ⎕IO?
FUZxxl

Os dois 1são o padrão.
Marinus

7

C #

for(int i = 1; i <= 99; i++){
    string s = "";
    if (i % 3 == 0) s += "Fizz";
    if (i % 4 == 0) s += "Jazz";
    if (i % 5 == 0) s += "Buzz";
    System.Console.WriteLine(s == "" ? "" + i : s);
}

Verifique mod, construa a string, imprima o número se estiver em branco ou se não estiver. Sem repetições. Só é necessário adicionar condição e saída para novos requisitos.


2
"Não se repete"? (OK, pelo menos, o tamanho do código cresce linearmente com palavras adicionais.)
Anko

Aceitei o desafio de não repetir um pouco mais com a minha resposta em C #, mas sacrifiquei qualquer flexibilidade quando se trata de quais números usar o módulo. Eu acho que o melhor resultado seria uma estrutura de dados relacionando número e palavra.
sydän

@ Anko Não tenho certeza do que você está falando, nenhuma função é repetida. Não estou fazendo a mesma coisa duas vezes em qualquer lugar do código.
rapjr11

@ rapjr11 O código verifica i- %-algumas vezes, além de acrescentar svárias vezes. (Lotes da sintaxe é repetitivo também, mas isso é provavelmente C # 's culpa.)
Anko

7

Python 2.7

Eu tentei torná-lo poético ...

Eu não sou muito bom em poesia de amor ...

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. 

Também seria muito melhor sem as constantes iniciais: P


Criativo, mas isso não funciona para mim no Python 2.7.9. Ele diz: TypeError: 'str' object is not callable.
Alex A.

Hmmmm ... Droga ... Não inteiramente certo como eu perdi isso: /
JamJar00

5

Java com classes

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

}

As classes:

interface Condition {
    void apply();
}

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

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

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

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

static Out out = new Out();

2
+1, você realmente capturou o espírito da codificação Java com este FizzBuzzJazz de 70 linhas. É orientado a objetos e é escrito em um estilo claramente especificado, não abreviado e legível. Muito longo. Mas muito legível. ; ^)
DLosc 14/04

4

MATLAB / Octave

É claro que escrever seus próprios loops é divertido para os programadores, mas todo mundo sabe como é realmente tedioso acompanhar a indexação (quem não escreveu for(j=i;j<n;i++)em um loop aninhado pelo menos uma vez na vida?)

O MATLAB tem a solução. Realmente, esse código não é o mais eficiente, e certamente não é um código de golfe, mas é, de todo modo, uma boa demonstração das funções mais interessantes do MATLAB. Octave é a versão GNU do MATLAB; no entanto, não é adequado para o código-golfe, pois é um pouco mais rigoroso com os tipos de variáveis, o que é prejudicial para o código-golfe.

EDIT: até que exista a sintaxe do MATLAB no SE, estou publicando uma versão com muito poucos comentários, porque, além disso, era apenas um grande bloco assustador de texto sem formatação.

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++)? A minha pergunta é: quem fez escrever este "pelo menos uma vez na vida"? Se você fez, eu tenho mau novo para você ...
Bogdan Alexandru

11
@BogdanAlexandru Você nunca na sua vida incrementou acidentalmente a variável errada em um forloop (por exemplo, ao aninhar loops)? Você é o cara cujo código é compilado com êxito pela primeira vez? Se você for, eu tenho notícias deus para você ...
Sanchises

2
Não estou falando de incrementar a variável errada, meu código não é escrito por Deus. Estou falando desse estilo de codificação, que por si só é propenso a erros. O jnome para uma variável local do loop é bom, mas o inome é uma prática muito ruim e essa é a fonte do seu erro. Não é puramente acidental :)
Bogdan Alexandru

@BogdanAlexandru Ah sim, concordo plenamente; a razão pela qual ainda uso esse estilo de loop é ao implementar determinadas tarefas (eu sou um estudante de mestrado); Prefiro usar a notação de índice usada pelo professor em questão do que confundir o pobre velho usando a minha.
Sanchises 7/03/2015

11
Não há problema em atribuir nomes de uma letra aos índices de um loop, mas as outras variáveis ​​devem ter nomes mais significativos.
Bogdan Alexandru

4

Python

from collections import defaultdict

lst = [(3, 'Fizz'),
       (5, 'Buzz'),
       (4, 'Jazz')]

word_list = defaultdict(list)

for d, w in sorted(lst):
    for i in range(d, 100, d):
        word_list[i].append(w)

for i in range(1, 100):
    print(''.join(word_list[i]) or i)

Claro que isso é muito longo. A solução do gnibbler é muito melhor. (embora substituir *..., sep=''por ''.joinseria mais bonito)

Mas isso é bastante eficiente em termos de operações de divisão / módulo.


11
Por que você usa sorted(lst), por que não apenas colocá-lo na ordem que você precisa quando o define?
mbomb007

Ou ordene-o no lugar antes do loop. lst.sort()
Davidmh

4

Rubi

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

Parece que isso é múltiplo de 2,3 e 4?
gnibbler

@gnibbler Opa, sim é. Fixo.
Maçaneta

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

Mais uma solução sem divisão ou módulo. fjbcria uma lista infinita de Fizzes, Jazzes, Buzzes e / ou números. takequalquer quantia que você desejar, como visto na print100fjbqual imprime os 100 primeiros elementos.


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;

onde eu é uma tabela com uma coluna (id INT) contendo os 100 números inteiros.

Não conheço um sabor SQL que possa gerar a tabela facilmente, ou use VALUES como subconsultas, o que pode torná-la muito melhor e completa.


11
Você pode usar variáveis ​​no 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<=100também funcionou. Mas se 100 for alterado para 10000, ambos serão quebrados.
precisa saber é o seguinte

11
Apenas se junte a ele se precisar de mais linhas.
Slicedtoad 7/03/15

Tanto quanto sei, o MySQL é o único dialeto SQL que não possui uma opção fácil de gerador de linhas. A maioria pode apenas usar uma expressão de tabela comum recursiva.
217 Ben

@ Ben Mas maneiras recursivas nem sempre parecem boas. Não corrigirei minha resposta alterando o dialeto, porque já existe uma resposta Oracle SQL.
precisa saber é o seguinte

3

Rubi

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


Talvez não seja a maneira mais eficiente, mas acho que é simples e 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 e feio: 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
Por que o espaçamento duplo?
Anko

Convenção pessoal. Eu acho que é melhor ler.
soundyogi


Eu faço isso apenas em projetos pessoais e por diversão. A maioria das equipes não gosta disso.
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);

2

C # totalmente estúpido

Metade do resumo foi 'NÃO SE REPETE', então eu entendi o mais literalmente possível com o C # e que acidentalmente progrediu no golfe do código. Este é o meu primeiro golfe e eu fiz em C #, estúpido eu sei, mas aqui está o resultado:

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

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

O objetivo era reduzir qualquer coisa que eu tivesse que usar mais de uma vez e, em geral, para manter o código curto enquanto produzia um programa C # completo. Para isso, você precisará usar o VisualStudio e definir o objeto StartUp como 'P'. Também será necessário procurar a saída na janela de saída da depuração.

Existem algumas limitações sérias aqui:

  • O código assume que todas as palavras terminarão em 'zz'
  • O código pressupõe que o módulo ocorra consecutivamente (3,4,5,6 ...)
  • O código ainda favorece a falta ou repetição em relação ao verdadeiro jogo de golfe, mais caracteres são adicionados para evitar algumas repetições

2

Python 2

Eu queria escrever uma resposta para isso em algum Python organizado que mostrasse os recursos da linguagem, cumprisse o princípio DRY e fosse bastante legível.

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 pequeno exemplo mostra o fatiamento, o inoperador e a sintaxe ternária detalhada, mas compreensível. Ele não usa o operador módulo. Ele não foi projetado para eficiência em tempo de execução, mas esse não era o objetivo. Ele foi projetado para ser curto, compreensível e sustentável.


Por que não usar set(group[...])nas regras?
gnibbler

Eu estava buscando mais elegância do que velocidade. Usar set () seria mais rápido em aplicativos reais, é claro.
Logic Knight

2

Python 2.7, 111 bytes

Esta é a minha primeira contribuição. Tentei aplicar alguns truques de codegolfing do Python (intercalação de strings, acesso ao índice de tuplas em vez de if). Se você tem alguma sugestão, compartilhe-a!

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

Saída:

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

Também não pude aplicar completamente o princípio DRY, pois existem dois forloops. Provavelmente existe uma maneira mais inteligente de fazer isso!


Provavelmente também posso usar uma tupla na primeira fordeclaração. Será atualizado quando eu puder!
nepho

Ok, então ele funciona com as duas variáveis ​​no mesmo loop, mas eu vou de 111 bytes para 145: gist.github.com/Neph0/ddc7a5ad04aa083d44af5cab3f90550f
Nepho

1

Vai

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

Experimente aqui: http://play.golang.org/p/lxaZF_oOax

Ele usa apenas um módulo por número verificado e pode ser arbitrariamente estendido a qualquer número de, bem ... números.

Você só precisa fazer alterações em três locais diferentes para estender isso, no hooksmapa, o FizzJazzBuzzernome da função e, é claro, a chamada para a FizzJazzBuzzerfunção.


1

R

Isso cria uma função que permite ao usuário especificar pares de palavras e divisores (e, opcionalmente, um número máximo, com 100 como padrão). A função cria um vetor de 1 ao número máximo, substitui quaisquer números nas posições "fizzbuzz" por "" e, finalmente, cola cada palavra na posição desejada. A função ordena a lista do menor para o maior número, de modo que o número mais baixo sempre seja a primeira parte do "fizzbuzz". As posições são calculadas usando seqpara criar um vetor começando em um determinado número e aumentando em incrementos desse número até que o número máximo desejado seja alcançado.

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

Não acho muito bonito, mas é fácil reutilizar com parâmetros diferentes.

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

A saída de 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"    

(números entre colchetes são os índices do vetor que a função gera)


1

Haskell

Nenhuma aritmética modular é usada, exceto na computação do múltiplo menos comum para evitar a repetição de trabalho desnecessário. As concatenações de strings precisam ser feitas apenas 60 vezes, não importa o que definimos como o limite 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

Substituir fjbLcmpor fjbfaz exatamente a mesma coisa, sem aritmética usada, exceto em [1..100]e take.


Isso é essencialmente o mesmo que a solução de Nimi , que eu não havia notado antes.
Cirdec 6/03/15

1

Python2

Atualização: A nova versão não usa nenhuma operação de modificação ou divisão.

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)

Se você quiser adicionar outra palavra ao teste, basta jogar o par de chave / valor no dicionário word_dict:

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

Se você deseja se livrar de uma palavra, exclua-a (usando del) ou defina-a como alternativa ''.

del word_dict[3]
fizz_jazz_buzz(100, word_dict)

Veja também as respostas Python de Gnibbler e Jakube , que foram postadas antes das minhas.


1

C #

Manutenção: Basta adicionar uma linha por elemento que
eu itere sobre cada elemento do dicionário, para verificar se é um divisor do número atual e, se for o caso, adicionar a string.
Depois de concluída, imprima a sequência, a menos que ainda seja nula (usando o operador coalescente nulo); nesse caso, imprima o número mais uma sequência vazia para torná-la uma sequência. (Eu poderia usar o toString, mas acho que é uma escolha pessoal)

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 + "");
}
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.