むかしむかし、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は死ぬまでゴルフにかけられましたが、それはこの質問の目的ではありません。あなたはコメントで、4の倍数の印刷「ジャズ」などの追加条件を簡単に追加できるので、この明白な答えは素晴らしいと誰かが言及していることがわかります（同意しません。このスキームを拡張するにはO（2 ** n ）コード行。）

あなたの挑戦は、仲間によって判断されるようにFizzJazzBuzzの最も美しいバージョンを書くことです。

投票者が考慮すべき事項：

1. ドライ
2. 除算/モジュラス演算の効率

Quoraに関する回答の多くはPythonを使用していましたが、ここではそのような言語の制限はありません。

今から1か月後に最も投票数が多い回答を受け入れます

サンプル出力：

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との闘いの後、どんなチャレンジでも少なくとも1回は提出する必要があると感じました。そしてこれがそれです。

それで、これはすべて何ですか？

そのため、最初に、プログラム全体で使用する変数を宣言します。変数はシェークスピアの演劇からのものでなければなりません。ロミオ、ジュリエット、オフィーリア、オセロにうんざりしていた私は、カンタベリー大司教とキャピュレット夫人に会いました。それらの説明とActs / Scenesのタイトルは、パーサーによって変装されているので、好きなものをそこに置くことができます。

それでは、翻訳の王様を少しちんぷんかんぷんなものにしましょう。

第1幕、第1幕

Begin Lady Capulet = 0;

Act Iは非常に簡単です。変数を0で初期化します。

第1幕、場面II

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（最後）にジャンプします。それ以外の場合は、次のシーンに進みます。

第1幕、シーン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);

最初に、3による除算のモジュラスが0であるかどうかを確認します。そうでない場合は、シーンIVにジャンプします。そうである場合、算術演算を開始してArchiepersonに保存し、探しているものが見つかったら文字形式で出力します。はい、最終的に、アイデアは取得することFizzです。

第1幕、場面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);

最初に、4による除算のモジュラスが0であるかどうかをチェックし、その後、以前と同じシーンとして続行しJazzます。

第1幕、シーン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;

前の2つと同様に機能し、5による除算のモジュラスが0を返すかどうかをチェックしてから、書き込みを試みますBuzz。唯一の違いは、最終的にシーンをスキップすることです。

第1幕、シーンVI

System.out.print(Lady Capulet);

このシーンにたどり着くには、レディカピュレットが想定している数字がフィズでもジャズでもバズでもないはずです。そのため、数値形式で出力します。

第I幕、場面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;

したがって、これが次の行にジャンプする唯一の方法です。出力、最初にCR、次にLF。その後、シーンIIに戻り、プログラムを続行できます。

第1幕、シーンVIII

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+&）してから、右の壁のミラーを跳ね返して行を下げます。いずれにせよ、3列目に沿って左に移動し、左の壁の鏡に当たって跳ね返ります。その後、我々はのための繰り返しJazzとBuzz。

これは、レジスタ&の値をチェックする7行目まで続きます。ゼロ以外の場合は、そのままダウンします。それ以外の場合、nダウンする前に番号自体を印刷します。

最後に、ao（今、左に移動していることを思い出してください！）ASCIIの改行を出力し1+、数値をインクリメントしてから、再び^ループに>戻ります。

^{（今、私たちは審美的なピートの答えを待っています...）}

LOLCODE

エレガント？いや。効率的？絶対にありません。綺麗な？さて、あなたは彼らが言うことを知っています：美しさは見る人の目にあります。

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>

これは、「i = endまでループする」ためのインターネットの話です。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を真剣に受け止めていません。「フィズジャズバズ」シーケンスで考慮できる明らかなパターンがあります。

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

このコードも簡単に拡張できます。「Fizz Jazz Buzz 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スナイパーライフルです！

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

そのため、Javaはほとんどの場合「美しい」とは見なされていませんが、それは非常に主観的なものなので、質問のガイドラインに従ってください。

• 繰り返してはいけません：問題ありません。番号ごとに1行だけ追加する必要があります。ヘルパー関数を作成したので、入力時にそれほど入力する必要はありません（Javaがわからない場合は、少し冗長になることがあります）。
• 除算/モジュラス演算の効率：モジュラスや除算がまったくないため、完全な効率が得られます。

それは、アルゴリズム全体が最も効率的であるとは言えません（そうではありません）が、箇条書きによく当てはまると思います。

通知7

Inform 7は、インタラクティブフィクション用に設計されたルールベースのプログラミング言語です。最も成功した自然言語ベースのプログラミング言語の1つであることは注目に値します。他の例といくつかの雑学については、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
∇

• DRY：ダブルコードはありません
• 条件の変更が簡単：名前は除数ごとにリストから順番に取得され、必要な変更は最小限です
• 範囲の変更が簡単：items任意の数値リストに変更できます
• 効率的：副作用のないプリミティブのみで構成される簡単に並列化されたリストベースのアルゴリズムを使用します。
• 簡単なコードの流れは：だけでなく、何がある後藤、何秒はありませんしばらく秒または場合のいずれか。コードは完全に線形です。
• あなたの仕事を確保します：他の誰もほとんど仕事をすることができません...

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バージョンです。ただし、変数の種類が少し厳しいため、code-golfには有害であるため、code-golfには適していません。

編集：MATLABの構文強調表示がSE上に存在するまで、私は非常にコメントの少ないバージョンを投稿しています。

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)

これはもちろん長すぎます。ニブラーのソリューションははるかに優れています。（と置き換える*..., 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フィズ、ジャズ、バズ、および/または数字の無限リストを作成します。最初の100個の要素を印刷するのにtake見られるように、必要な量print100fjb。

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;

ここで、Iは100個の整数を含む1つの列（id INT）を持つテーブルです。

テーブルを簡単に生成できる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

DRYish ...;）

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

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

    console.log(str || iter);

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

    return;
})(1);

非常に愚かなC＃

ブリーフの半分は「自分を繰り返してはいけない」だったので、私はそれを文字通りC＃でできる限り取り、偶然コードのゴルフに進みました。これは私の最初のゴルフであり、私はC＃でそれをしました、私が知っている愚かですが、ここに結果があります：

ゴルフ（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

私は、言語の機能を見せびらかし、DRYの原則に準拠し、かなり読みやすいいくつかのきちんとしたPythonでこれに対する答えを書きたかったのです。

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演算子、および冗長ではあるが理解可能な3項構文を示しています。モジュロ演算子はまったく使用しません。実行時の効率のために設計されていませんが、それは目標ではありませんでした。短く、理解しやすく、保守しやすいように設計されています。

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

また、2つのforループがあるため、DRYの原則を完全に適用できませんでした。おそらくもっと賢い方法があるでしょう！

行く

コンカレント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

チェックされた番号ごとに1つのモジュラスのみを使用し、任意の数、任意の数に任意に拡張できます。

これを拡張するには、hooksマップ、FizzJazzBuzzer関数名、そしてもちろんFizzJazzBuzzer関数への呼び出しの3つの異なる場所を変更するだけです。

R

これにより、ユーザーが単語と除数のペア（およびオプションで最大数（デフォルトは100））を指定できる関数が作成されます。この関数は、1から最大数までのベクトルを作成し、「fizzbuzz」の位置の数値を「」に置き換え、最後に各単語を希望する位置に貼り付けます。この関数は、最小数が常に「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

fjbLcmwithで置き換えるfjbことは、in [1..100]およびを除いて算術演算を使用せずにまったく同じことを行いtakeます。

Python2

更新：新しいバージョンでは、modまたはdivision操作は使用されません。

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)

テストに別の単語を追加する場合は、key / valueペアを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＃

保守性：要素ごとに1行追加するだけ
で、辞書の各要素を反復処理して、現在の数値の約数かどうかを確認し、ある場合は文字列に追加します。
終了したら、まだ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 + "");
}