옛날 옛적에, 나는 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 는 골프를 쳤지 만 이것이이 질문에 관한 것이 아닙니다. 당신은 의견에서 누군가가 4의 배수에 대해 "재즈"인쇄와 같은 추가 조건을 쉽게 추가 할 수 있기 때문에이 명백한 대답이 훌륭하다고 언급합니다. (동의하지 않습니다. ) 코드 줄)

당신의 도전은 동료들이 판단한 가장 아름다운 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과의 투쟁 후 , 나는 도전에 대해 적어도 하나의 제출 을해야한다고 느꼈습니다 . 그리고 이것입니다.

그럼이게 다 뭐야?

먼저, 프로그램 전체에서 사용할 변수를 선언합니다. 셰익스피어 연극에서 가져와야합니다. 로미오, 줄리엣, 오펠리아, 오델로와의 연합에서 나는 캔터베리 대주교 와 레이디 캐 플릿 과 함께 일했다 . Acts / Scenes 타이틀뿐만 아니라 그들의 설명은 파서에 의해 무시되므로, 당신은 당신이 좋아하는 거의 아무것도 넣을 수 있습니다.

이제 번역의 왕을 조금 덜 우스운 것으로 바꾸자 .

제 1 막

Begin Lady Capulet = 0;

액트 I은 매우 간단합니다. 변수를 0으로 초기화합니다.

1 막 2 장

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

Lady Capulet의 값을 증가시키고 100과 비교합니다 (예, 문장 전체가 숫자 100을 얻는 데만 사용됨). 작지 않으면 Scene VIII (끝)으로 이동합니다. 그렇지 않으면 다음 장면으로 넘어갑니다.

1 막

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 막, 4 막

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;

앞의 두 개와 같은 기능으로 5의 나눗셈 계수가 0을 반환하는지 확인한 다음 쓰기를 시도합니다 Buzz. 유일한 차이점은 결국 장면을 건너 뜁니다.

1 막, 장면 VI

System.out.print(Lady Capulet);

이 장면에 도달하려면 Lady Capulet이 가정 한 숫자가 Fizz 나 Jazz, Buzz가 아니어야합니다. 따라서 숫자 형식으로 출력합니다.

1 막, 장면 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; 그런 다음 Scene 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           <                    /

> <>는 명령어가 단일 문자이고 명령어 포인터 (IP)가 화살표 ^>v<와 거울 에 따라 위, 아래, 왼쪽 또는 오른쪽으로 이동할 수있는 2D 프로그래밍 언어 /\입니다. 변수 나 문자열이 없으므로 반복하지 않는 것이 조금 더 어렵지만 자체 방식으로는 훌륭하다고 생각합니다.

1루프를 밀고 시작합니다. :9b*)?;숫자가 99 ( 9b* = 9*11) 보다 큰지 확인 하고, 있으면 프로그램이 중지 ;됩니다. 그렇지 않으면 레지스터에 0을 넣고 v물결 모양 부분 으로 아래 로 이동 하십시오.

:3%?모듈로 3의 숫자를 확인합니다. 0이 아닌 경우 v행을 내려 왼쪽으로 이동 <합니다. 그렇지 않으면 아래쪽 화살표를 건너 뛰고을 눌러 "Fizz"인쇄 ( r}oooo) 한 후 레지스터 ( &1+&)를 늘리고 오른쪽 벽면 미러를 제거하여 행을 내려갑니다. 어느 쪽이든 왼쪽 벽 거울에서 튕겨 나올 때까지 세 번째 줄을 따라 왼쪽으로 움직입니다. 그럼 우리가를 반복 Jazz하고 Buzz.

이것은 레지스터 &의 값 을 확인하는 7 번째 줄까지 계속 됩니다. 0이 아닌 경우에는 내려갑니다. 그렇지 않으면, 우리는 n내려 가기 전에 숫자 자체 를 인쇄합니다 .

마지막으로, ao(! 우리는 지금 왼쪽으로 이동하고, 기억)를 ASCII 줄 바꿈 및 인쇄 1+우리가 가기 전에, 단위 수를 ^루프을 >다시.

^{(이제 우리는 미적 인 Piet 답변을 기다립니다 ...)}

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에서는 인덱싱 변수를 루프 전에 초기화해야합니다. 여기서 루프 초기화 사운드를 유머러스하게 읽으므로 루프는 "하우스"라고합니다.

VISIBLEstdout으로 인쇄합니다. 기본적으로 줄 바꿈이 추가되지만 추가 !하면 줄 바꿈이 표시되지 않습니다.

조건은 다음과 같이 지정됩니다.

<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의 언어에 정통하지 않습니까? 알려주세요. 추가 설명을 드리겠습니다.

파이썬 3

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 계산을 반복해야하지만 여기서는 아무것도 반복하지 않습니다. 그러나 각 개별 모드 (n % 3, n % 4 및 n % 5)는 코드 반복마다 한 번만 실행됩니다.

작은 이미지는 적절한 소스이며 여기에서 업로드하여 실행할 수 있습니다 .

즐겨!

매스 매 티카

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

이 코드는 쉽게 확장 할 수 있습니다. "Fizz Jazz Buzz Tizz"문제를 해결하려면 문자열 Ti다음 Bu에 추가 하면 됩니다. 이것은 다른 솔루션에서 필요한 것보다 훨씬 적습니다.

엑셀 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을 사용하여 온라인 으로 실행할 수 있습니다 .

디아 로그 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임의의 숫자 목록으로 변경 가능
• 효율적 : 부작용이없는 프리미티브로만 구성된 쉽게 병렬화 된 목록 기반 알고리즘을 사용합니다.
• 간단한 코드 흐름 : goto 가없고, while 또는 if 가 없습니다 . 코드는 완전히 선형입니다.
• 당신의 직업을 확보하십시오 : 다른 사람이 거의 그것을 할 수 없을 것입니다 ...

기음#

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

비어있는 경우 모드, 빌드 문자열, 인쇄 번호를 확인하고 그렇지 않으면 문자열을 인쇄하십시오. 반복하지 않습니다. 새로운 요구 사항에 대한 조건 및 출력 만 추가하면됩니다.

파이썬 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)

물론 너무 길다. gnibbler의 솔루션이 훨씬 좋습니다. (교체에도 불구하고*..., 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

분할 또는 계수가없는 또 다른 솔루션. fjbFizzes, Jazzes, Buzzes 및 / 또는 숫자의 무한 목록을 만듭니다. 처음 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 개의 정수를 포함하는 하나의 열 (ID INT)이있는 테이블입니다.

테이블을 쉽게 생성하거나 VALUES를 하위 쿼리로 사용하여 훨씬 좋고 완벽하게 만들 수있는 SQL 특징을 알지 못합니다.

루비

1.upto(100) do |i|

  rules = { 3 => 'Fizz', 4 => 'Jazz', 5 => 'Buzz' }

  print(i) unless rules.select! { |n,s| i.modulo(n) > 0 or print(s) }

  puts

end

자바 스크립트

아마도 가장 효율적인 방법은 아니지만 간단하고 예쁘다고 생각합니다. <3

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

조악한 건조 및 effin 추한 : 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)

자바 스크립트

건조 ...;)

(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 ...)
• 코드는 여전히 실제 골프에 비해 부족하거나 반복되는 것을 선호하며, 일부 반복을 피하기 위해 더 많은 문자가 추가됩니다

파이썬 2

언어의 기능을 보여주고 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연산자 및 자세하지만 이해하기 쉬운 3 원 구문을 보여줍니다 . 모듈로 연산자를 전혀 사용하지 않습니다. 런타임 효율성을 위해 설계된 것이 아니지만 목표는 아닙니다. 짧고 이해 가능하며 유지 관리가 가능하도록 설계되었습니다.

파이썬 2.7, 111 바이트

이것이 나의 첫 공헌입니다. 파이썬 코드 골프 트릭을 적용하려고했습니다 (대신 문자열 인터리빙, 튜플 인덱스 액세스 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루프 가 있기 때문에 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

그것은 확인 된 숫자 당 하나의 계수 만 사용하며 임의로 임의의 수로 확장 할 수 있습니다.

hooks맵에서 FizzJazzBuzzer함수 이름과 함수 호출을 확장하기 위해 3 개의 다른 위치 만 변경 하면 FizzJazzBuzzer됩니다.

아르 자형

이것은 사용자가 단어와 제수의 쌍을 지정할 수있는 기능을 만듭니다 (선택적으로 최대 값은 100이며 기본값은 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

교체 fjbLcm로하는 것은 fjb제외로 사용하는 연산과 정확히 같은 일을 [1..100]하고 take.

파이썬 2

업데이트 : 새 버전은 모드 또는 나누기 작업을 사용하지 않습니다.

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 답변도 참조하십시오 .

기음#

유지 관리 :
사전에 각 요소를 반복하여 요소 당 한 줄을 추가 하면 현재 숫자의 제수인지 확인하고 문자열 인 경우 문자열에 추가합니다.
완료되면, 문자열이 여전히 널 (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 + "");
}