从前，我在阅读有关Quora的问题/答案

真的有没有计算机科学学位的程序员无法通过FizzBu​​zz测试

此代码是显而易见的答案

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

当然，FizzBu​​zz已经被打死了，但这并不是这个问题的实质。您会在评论中看到有人提到该答案很不错，因为很容易添加额外条件，例如将“ Jazz”打印为4的倍数。（我不同意。扩展此方案需要O（2 ** n ）代码行。）

您的挑战是编写由同行判断的最漂亮的FizzJazzBuzz版本。

选民需要考虑的一些事项：

1. 干
2. 除法/模运算的效率

Quora上的许多答案都使用Python，但此处没有这种语言限制。

从现在开始一个月后，我将以最高票数接受答案

样本输出：

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

您说最美丽的版本？然后，让我们尝试一下...

莎士比亚编程语言

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]

所以，我用SPL斗争后在这里，我觉得我必须做至少一个提交它的任何挑战。就是这样。

那么，这是什么呢？

因此，首先，我们声明将在整个程序中使用的变量，这些变量必须来自莎士比亚戏剧。厌倦了罗密欧，朱丽叶，奥菲莉亚和奥赛罗，我去了坎特伯雷大主教和卡普莱特夫人。解析器不接受它们的描述以及使徒行传/场景的标题，因此您可以在其中放置几乎任何您喜欢的东西。

因此，让我们来做翻译之王，以免有些乱码。

第一幕，第一幕

Begin Lady Capulet = 0;

第一幕非常简单：我们将变量初始化为0。

第一幕第二场

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

我们增加Lady Capulet的值并将其与100进行比较（是的，整个句子仅用于获得数字100）；如果不小的话，我们跳到场景VIII（最后）；否则，我们继续下一个场景。

第一幕第三幕

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

首先，我们看除以3的模数是否为0。如果不是，我们跳到第四场景。如果是这样，我们就开始进行算术运算并将其存储在Archieperson中，一旦找到所需的字符，就以字符形式输出它们。是的，最终的想法是得到Fizz。

第一幕，第四场

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

首先检查除以4的模数是否为0，然后继续与之前相同的场景Jazz。

第一幕，第五幕

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;

类似于前两个函数，检查除以5的模是否返回0，然后尝试写入Buzz；唯一的不同是，最后，我们跳过了一个场景。

第一幕第六幕

System.out.print(Lady Capulet);

要到达此场景，Capulet夫人假定的号码一定既不是Fizz也不是Jazz也不是Buzz。因此，我们以数字形式输出它。

第一幕，第七场

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;

所以，这是我发现跳到下一行的唯一方法：输出，首先是CR，然后是LF；然后，我们返回到场景II，继续执行该程序。

第一幕，第八场

End.

直截了当。

我仍在尝试查看是否可以在线显示此编译器，但是我找不到在线编译器- 我知道的编译器似乎无法与任何程序很好地结合，除非已经加载了某个程序，或者可能是某种键盘和椅子之间的接口问题...

更新1：

在mathmandan发表评论之后，我编辑了Jazz和Buzz场景的顺序。这必须要完成。

> <>（鱼）

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

> <>是2D编程语言，其中指令是单个字符，并且指令指针（IP）可以根据箭头^>v<和镜像向上，向下，向左或向右移动/\。它没有变量或字符串，所以不重复自己会有点困难，但是我认为这很好。

我们推动1并开始循环。:9b*)?;检查该数字是否大于99（9b* = 9*11），如果大于，则程序停止;。否则，将0放入寄存器中，然后向下v移至波浪形部分。

:3%?检查模3的数字。如果它不是零，那么我们向下v一行然后向左移动<。否则，我们将跳过向下箭头并按下"Fizz"，将其打印（r}oooo）并增加寄存器（&1+&），然后从右侧壁镜上弹起以向下一行。无论哪种方式，我们最终都会沿着第三行向左移动，直到从左后视镜弹起。然后我们重复Jazz和Buzz。

这一直持续到第7行，该行检查寄存器&的值。如果非零，那么我们就下去。否则，我们先打印数字本身，n然后再下来。

最后，ao（记住，我们现在向左移动！）打印ASCII换行符并1+递增数字，然后再执行^并>再次执行循环。

^{（现在，我们等待Piet的美学回答...）}

大声笑

优雅？不。有效率吗？当然不。美丽？好吧，你知道他们在说什么：情人眼里是美丽。

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

一些解释：

LOLCODE程序以HAI和开头KTHXBYE。

变量是动态类型的，并使用分配I HAS A <variable> ITZ <value>。定义后，也可以使用分配变量<variable> R <value>。

LOLCODE中的循环被命名。语法为：

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

这只是Internet上的“循环直到i =结束”。在LOLCODE 1.2中，索引变量需要在循环之前进行初始化。这里的循环被称为“ house”，因为它使读取循环初始化听起来很幽默。

VISIBLE打印到标准输出。默认情况下会添加换行符，但是添加会!禁止换行符。

条件指定如下：

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

条件必须是计算结果为布尔值或布尔值的表达式。在LOLCODE中，将调用布尔类型，并且布尔类型TROOF具有值WIN（true）和FAIL（false）。

单行注释以开头BTW。

不熟悉Internetz语言吗？请让我知道，我们将很乐意提供进一步的解释。

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一起玩，看看我能写出多么漂亮的代码。我试着在这里不重复任何内容，尽管老实说我确实必须重复mod的计算。但是，每个不同的mod（n％3，n％4和n％5）每次代码迭代仅运行一次。

较小的图像是正确的来源，可以在此处上传并运行。

请享用！

Mathematica

在Mathematica中，您可以为非常特定的参数定义和重载函数（不仅按类型，而且按任意逻辑条件）。让我们定义一些函数：

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

现在实际的程序仅仅是

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

现在，尽管上述值仅随除数的数量线性增长，但仍然不是很干燥。但是我们实际上可以在这些定义中使用变量作为名称。因此，我们实际上可以编写一个生成以下函数定义的函数：

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

现在，您要做的就是添加另一个addFunction呼叫，并将新呼叫添加**zz到最后一行。

哈斯克尔

你们没有认真对待DRY。可以在“ 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. ;)

此代码也很容易扩展。为了解决“费兹爵士巴兹Tizz”的问题，所有你需要做的就是添加Ti后Bu的的字符串中。这远远少于其他任何解决方案所需要的。

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

听起来可能很愚蠢，但这是2D狙击步枪！

爪哇

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

因此，Java在大多数情况下并没有真正被认为是“美丽的”，但是这是一个疯狂的主观想法，因此我遵循以下问题中的准则：

• 不要重复自己：没问题。您只需为每个数字添加一行。我什至创建了一个辅助函数，因此您不必在键入时输入太多（如果您不知道，有时Java可能会有些冗长）。
• 除法/模运算的效率：完美的效率，因为根本没有模数或除法。

这并不是说整个算法是最有效的（不是），但是我认为它很好地达到了要点。

通知7

Inform 7是一种设计用于交互式小说的基于规则的编程语言。它是最成功的基于自然语言的编程语言之一。有关其他示例和一些琐事，请参见Inform 7语言展示。

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;

此代码的优点是每个FizzBu​​zz规则都是完全独立的：可以随时添加其他规则，而无需更改常规框架。不幸的是，它有点重复，尤其是定义短语。我可以定义一个％运算符，但是那不是英语。;）

可以使用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
∇

• 干：没有双码
• 易于更改的条件：名称按顺序从每个除数的列表中取出，所需的更改最少
• 易于更改范围：items可以更改为任意数字列表
• 高效：利用易于并行化的基于列表的算法，该算法仅由无副作用的原语组成。
• 简单的代码流：不仅没有goto，也没有while或if。该代码是完全线性的。
• 确保您的工作：几乎没有其他人能够胜任...

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

检查mod，构建字符串，打印数字（如果为空白）或字符串（如果不是）。没有重复。只需要为新需求添加条件和输出。

Python 2.7

我试图使它富有诗意...

我不太擅长爱情诗。

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. 

如果没有初始常量：P也会更好。

Java类

算法：

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

}

这些课程：

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

当然，编写自己的循环对程序员来说很有趣，但是每个人都知道跟踪索引的真正乏味（谁for(j=i;j<n;i++)一生中至少没有在嵌套循环中编写过一次？）

MATLAB有解决方案。确实，该代码不是最高效的，当然也不是代码有效的，但是，它绝对是MATLAB更有趣的功能的良好展示。Octave是MATLAB的GNU版本；但是它不适用于代码高尔夫，因为它对变量类型的要求稍微严格一些，这对代码高尔夫不利。

编辑：在SE上存在针对MATLAB的语法高亮显示之前，我发布的注释很少，因为否则它只是纯文本的一大恐怖。

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

蟒蛇

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)

当然，这太长了。咬人的解决方案要好得多。（尽管替换*..., sep=''为''.join会比较漂亮）

但这在除法/模运算方面非常有效。

红宝石

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

哈斯克尔

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

没有除法或模数的另一种解决方案。fjb创建无限的嘶嘶声，爵士乐，嗡嗡声和/或数字列表。take您想要的任何数量，如print100fjb可打印前100个元素的数量。

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;

其中，我是一张表，其中一列（id INT）包含100个整数。

我不知道哪种SQL风格可以轻松生成表，也可以将VALUES用作子查询，从而使其变得更好和更完整。

红宝石

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

也许这不是最有效的方法，但我认为它简单而漂亮<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)

磨干，有效：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

干...;）

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

简短的一半内容是“不要重复自己”，所以我在C＃中尽可能地理解了这一点，后来意外地发展为编写代码。这是我的第一场高尔夫比赛，我是用C＃进行的，虽然很愚蠢，但是结果如下：

Golfed（240 232 230个字符）：

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

取消高尔夫：

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

目的是为了缩短我不得不多次使用的所有内容，并且通常在生成完整的C＃程序时要使代码简短。为此，您将需要使用VisualStudio并将StartUp对象设置为“ P”，还需要在调试输出窗口中查找输出。

这里有一些严重的限制：

• 该代码假定所有单词均以“ zz”结尾
• 该代码假定模量将连续发生（3,4,5,6 ...）
• 该代码仍然偏向于缺少或重复而不是真正的高尔夫球，添加了更多字符以避免重复

Python 2

我想用一些整洁的Python为此写一个答案，以展示该语言的功能，遵守DRY原则并且相当易读。

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

这个小例子显示了切片，in运算符和冗长但可理解的三元语法。它根本不使用模运算符。它不是为提高运行时效率而设计的，但这不是目标。它被设计为简短，可理解和可维护的。

Python 2.7，111字节

这是我的第一项贡献。我尝试应用一些Python代码编程技巧（字符串交织，而不是的元组索引访问if）。如果您有任何建议，请分享！

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

输出：

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

我也不能完全应用DRY原理，因为有两个for循环。可能有更聪明的方法！

走

并发的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()
}

在这里尝试：http : //play.golang.org/p/lxaZF_oOax

每检查一个数字，它仅使用一个模数，并且可以任意扩展到任意数量的，以及...数字。

您只需要在3个不同的地方进行更改即可扩展它，在hooks映射中，FizzJazzBuzzer函数名称，当然还有对FizzJazzBuzzer函数的调用。

[R

这将创建一个函数，该函数允许用户指定成对的单词和除数（以及可选的最大数量，默认为100）。该函数创建一个从1到最大数字的向量，然后将“ fizzbuzz”位置的所有数字替换为“”，最后将每个单词粘贴到所需位置。该功能将列表从最低编号到最高编号排序，以便最低编号始终是“嘶嘶声”的第一部分。使用seq创建矢量的位置来计算位置，该矢量从给定数字开始，并以该数字为增量递增，直到达到所需的最大数字为止。

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

我认为它不是很漂亮，但是可以很容易地使用不同的参数来重复使用。

用法示例：

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

输出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"    

（方括号中的数字是函数输出的向量的索引）

哈斯克尔

除计算最小公倍数以避免重复不必要的工作外，不使用模块化算法。无论我们将上限设置为什么，字符串连接都只需执行60次。

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

替换fjbLcm与fjb完全相同，除了[1..100]和中不使用任何算术take。

Python2

更新：新版本不使用任何mod或除法操作。

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)

如果要在测试中添加另一个单词，只需将键/值对放入word_dict字典中：

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

如果您想摆脱一个单词，只需将其删除（使用del）或将其设置为即可''。

del word_dict[3]
fizz_jazz_buzz(100, word_dict)

另请参阅在我之前发布的Gnibbler和Jakube的Python答案。

C＃

可维护性：只需为每个元素添加一行
，然后对字典中的每个元素进行迭代，以检查它是否为当前数的除数，然后将其添加到字符串中。
完成后，打印字符串，除非它仍然为null（使用null合并运算符），在这种情况下，请打印数字和一个空字符串以使其成为字符串。（我可以使用toString，但是我想这是个人选择）

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