Когда-то я читал этот вопрос / ответ на Quora

Есть ли действительно программисты со степенью информатики, которые не могут пройти тест FizzBuzz

Этот код дан как очевидный ответ

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

Конечно, FizzBuzz был забит до смерти, но это не тот вопрос, о котором идет речь. Вы видите, что в комментариях кто-то упоминает, что этот очевидный ответ великолепен, поскольку легко добавить дополнительные условия, такие как print «Jazz» для кратных 4. (Я не согласен. Для расширения этой схемы требуется O (2 ** n). ) строки кода.)

Ваша задача состоит в том, чтобы написать самую красивую версию FizzJazzBuzz в соответствии с вашими коллегами.

Некоторые вещи для избирателей, чтобы рассмотреть:

1. DRY
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 здесь , я чувствовал , что я должен был сделать , по крайней мере , один представление с ним на любой вызов. И это все.

Итак, что же все это тогда?

Итак, во-первых, мы объявляем переменные, которые мы собираемся использовать в программе, которые должны исходить из пьес Шекспира. Сытый по горло Ромео, Джульеттой, Офелией и Отелло, я познакомился с архиепископом Кентерберийским и леди Капулетти . Их описания, а также названия Актов / Сцены игнорируются парсером, поэтому вы можете поместить туда практически все, что захотите.

Итак, давайте сделаем некоторый король перевода на что-то менее гибкое .

Акт I, Сцена I

Begin Lady Capulet = 0;

Действие I довольно простое: мы инициализируем нашу переменную с 0.

Акт I, Сцена 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 (конец); в противном случае мы переходим к следующей сцене.

Акт I, Сцена 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.

Акт I, Сцена 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.

Акт I, Сцена 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;

Функции, подобные предыдущим двум, проверяют, возвращает ли модуль деления на 5 0, а затем пытается записать Buzz ; единственная разница в том, что, в конце концов, мы пропускаем сцену.

Акт I, Сцена VI

System.out.print(Lady Capulet);

Чтобы достичь этой сцены, число, принятое леди Капулетти, не должно было быть ни Fizz, ни Jazz, ни Buzz; Итак, мы выводим его в числовой форме.

Акт 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, к которой мы можем продолжить программу.

Акт I, Сцена VIII

End.

Достаточно просто.

Я все еще пытаюсь увидеть, смогу ли я показать это в сети, но я не могу найти онлайн-компилятор - тот, который я знаю , кажется, плохо сочетается с какой-либо программой, кроме уже загруженной, или, может быть, есть какой-то проблемы с интерфейсом между клавиатурой и стулом ...

Обновление 1:

После комментария математики я отредактировал порядок сцен Джаза и Базза. Это должно быть сделано.

> <> (Рыба)

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

> <> - это двумерный язык программирования, в котором инструкции представляют собой одиночные символы, а указатель инструкций (IP) может перемещаться вверх, вниз, влево или вправо, в зависимости от стрелок ^>v<и зеркал /\. В нем нет переменных или строк, поэтому не повторять себя немного сложнее, но я думаю, что это хорошо по-своему.

Мы нажимаем 1и запускаем цикл. :9b*)?;проверяет, является ли число больше 99 ( 9b* = 9*11), и если да, то программа останавливается ;. В противном случае поместите 0 в регистр и переместитесь вниз vв волнистую часть.

:3%?проверяет число по модулю 3. Если оно ненулевое, то мы идем вниз vпо ряду и движемся влево <. В противном случае мы пропускаем стрелку вниз и нажимаем "Fizz", распечатываем ее ( r}oooo) и увеличиваем регистр ( &1+&), прежде чем отскакивать от правых зеркал стены, чтобы спуститься вниз. В любом случае мы в конечном итоге движемся влево по третьему ряду, пока не отскочим от зеркал левой стены. Тогда мы повторяем для 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>

Это всего лишь Интернет, говорят «цикл, пока я = конец». В LOLCODE 1.2 индексная переменная должна быть инициализирована до цикла. Здесь цикл называется «дом», потому что это делает чтение инициализации цикла звучит смешно.

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='')

болтушка

Я решил попробовать поиграть с Питом и посмотреть, какой красивый код я смог бы сделать. Я стараюсь здесь ничего не повторять, хотя, если честно, мне нужно повторить расчеты модов. Однако каждый отдельный мод (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в последнюю строку.

Haskell

Вы, ребята, не относитесь к СУХОЙ серьезно. Существуют очевидные паттерны, которые могут быть учтены в последовательности «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. ;)

Этот код также легко расширяемый. Чтобы решить проблему «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 снайперская винтовка!

Джава

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;

Преимущество этого кода в том, что каждое из правил FizzBuzz является полностью независимым: дополнительные правила могут быть добавлены в любой момент без необходимости изменять общую структуру. К сожалению, это немного повторяется, особенно с определениями фраз. Я мог бы определить оператор%, но тогда это был бы не английский. ;)

Этот код можно запустить онлайн с помощью Playfic .

Дьялог АПЛ

∇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 s, нет в то время как s или если s. Код полностью линейный.
• Обеспечивает вашу работу: вряд ли кто-то еще сможет работать над этим ...

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

Проверьте мод, строку сборки, номер печати, если пусто, или строку, если нет. Нет повторов. Нужно только добавить условие и вывод для новых требований.

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; однако он не подходит для код-гольфа, поскольку он немного строже с переменными типами, что пагубно для код-гольфа.

РЕДАКТИРОВАТЬ: до тех пор, пока подсветка синтаксиса для 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

питон

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

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

Еще одно решение без деления или модуля. fjbсоздает бесконечный список Fizzes, Jazzes, Buzzes и / или чисел. 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;

где I - таблица с одним столбцом (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 #, глупо, я знаю, но вот результат:

Игра в гольф ( 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+"");}}}}

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

Цель состояла в том, чтобы сократить любую вещь, которую мне пришлось использовать более одного раза, и в целом, чтобы сохранить код коротким при создании полной программы на 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

Я также не мог полностью применить принцип СУХОГО, так как есть две 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функции.

р

Это создает функцию, которая позволяет пользователю указывать пары слов и делителей (и, необязательно, максимальное число, со 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"    

(числа в квадратных скобках - это индексы вектора, который выводит функция)

Haskell

Модульная арифметика не используется, за исключением вычисления наименьшего общего множителя, чтобы избежать повторения ненужной работы. Конкатенации строк нужно выполнять только 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

Update: New version doesn't use any mod or division operations.

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)

If you want to add another word to the test, just throw the key/value pair into the word_dict dictionary:

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

If you want to get rid of a word, just delete it (using del) or alternatively set it to ''.

del word_dict[3]
fizz_jazz_buzz(100, word_dict)

See also the Python answers of Gnibbler and Jakube, which were posted before mine.

C#

Maintainability: Just add one line per element
I iterate over each element in the dictionary, to check if it's a divisor of the current number, and adding to the string if it is.
Once finished, print the string, unless it is still null ( using the null coalescing operator ), in which case print the number plus an empty string to make it a string. ( I could use toString, but I guess that's a personal choice )

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