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

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.

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

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.

Python3

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

for i in range(1, 101):  
    print(*[w for w, m in lst if i % m == 0] or [i], sep='')

Piet

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!

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.

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.

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!

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.

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 .

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

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.

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

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

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

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.

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

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.

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.

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

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)

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

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

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.

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!

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.

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)

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.

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.

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