FizzBuzz: Difference between revisions
→{{header|C sharp|C#}}: Refactoring |
|||
Line 2,707: | Line 2,707: | ||
===Bodyless for loop=== |
===Bodyless for loop=== |
||
<lang javascript>for(var i=1; i<=100; console.log((i%3?'':'Fizz')+(i%5?'':'Buzz')||i), i++);</lang> |
<lang javascript>for(var i=1; i<=100; console.log((i%3?'':'Fizz')+(i%5?'':'Buzz')||i), i++);</lang> |
||
===A little shorter=== |
|||
<lang javascript>for(i=0;i<100;console.log(++i%15?i%5?i%3?i:f='Fizz':b='Buzz':f+b));</lang> |
|||
===Compiled from CoffeeScript One-Liner=== |
===Compiled from CoffeeScript One-Liner=== |
Revision as of 19:27, 20 December 2013
You are encouraged to solve this task according to the task description, using any language you may know.
Write a program that prints the integers from 1 to 100. But for multiples of three print "Fizz" instead of the number and for the multiples of five print "Buzz". For numbers which are multiples of both three and five print "FizzBuzz". [1]
FizzBuzz was presented as the lowest level of comprehension required to illustrate adequacy. [2]
360 Assembly
<lang>FIZZBUZZ CSECT A SECTION OF CODE STARTS HERE, LABEL IT FIZZBUZZ
- HOUSE KEEPING AREA**********************
USING *,12 FOR THIS PROGRAM WE ARE GOING TO USE REGISTER 12 STM 14,12,12(13) SAVE REGISTERS 14,15, AND 0-12 IN CALLER'S SAVE AREA LR 12,15 PUT OUR ENTRY ADDRESS(IN R15) INTO OUR BASE REGISTER LA 15,SAVE POINT R15 AT THE *OUR* SAVE AREA (DEFINED AT THE END) ST 15,8(13) SET FORWARD CHAIN ST 13,4(15) SET BACKWARD CHAIN LR 13,15 SET R13 TO THE ADDRESS OF OUT NEW SAVE AREA
- MAIN*PROGRAM****************************
LA 10,LOOP PUT THE LOOP START ADDRESS IN R10 LA 8,100 PUT THE NUMBER OF ITERATIONS IN R8 LA 5,=F'1' INITIALIZE BINARY COUNTER TO ONE
LOOP EQU * LABEL THE LOOP START
A 5,=F'1' ADD TO BINARY LOOP COUNTER AP NUM,=PL1'1' ADD TO PACKED LOOP COUNTER B CHK15 CHECK IF COUNTER IS % 12
LCHK15 EQU * IF NOT, COME BACK
B CHK3 CHECK IF COUNTER IS % 3
LCHK3 EQU * IF NOT, COME BACK
B CHK5 CHECK IF COUNTER IS % 4
LCHK5 EQU * IF NOT, COME BACK
MVC EOUT,EMSK PREPARE TO PKD->EBCDIC EDMK EOUT,NUM PKD->EBCDIC
ENLOOP EQU * IF A TEST WAS POSITIVE RETURN HERE
WTO MF=(E,WTOSTART) PRINT RESULT OF LOOP BCTR 8,10 START OVER
- HOUSE KEEPING AREA**********************
L 13,4(13) RESTORE ADDRESS TO CALLER'S SAVE AREA LM 14,12,12(13) RESTORE REGISTERS AS ON ENTRY XR 15,15 XOR R15 SO IT IS ALL 0 (R15 CREATES THE PROGRAM RETURN CODE) BR 14 RETURN WHERE YOU CAME FROM
- SUBROUTINE AREA*************************
- ////////CHK3////////////////////////////////////*
CHK3 EQU * LABEL ENTRY POINT
LR 6,5 LOAD R6 WITH R5(THE BINARY LOOP INDEX) A 6,=F'1' ADD ONE TO R6 SRDA 6,32 SHIFT RD VAL 32 BITS RIGHT(TO R7) D 6,=F'3' DIVIDE BY 3 C 6,=F'0' IS REMAINDER 0? BE DIV3 IF SO GOTO DIV3 ROUTINE B LCHK3 IF NOT GO BACK TO LOOP
- ////////CHK15///////////////////////////////////*
CHK15 EQU * LABEL ENTRY POINT
LR 6,5 LOAD R6 WITH R5(THE BINARY LOOP INDEX) A 6,=F'1' ADD ONE TO R6 SRDA 6,32 SHIFT RD VAL 32 BITS RIGHT(TO R7) D 6,=F'15' DIVIDE BY 15 C 6,=F'0' IS REMAINDER 0? BE DIV15 IF SO GOTO DIV15 ROUTINE B LCHK15 IF NOT GO BACK TO LOOP
- ////////CHK5////////////////////////////////////*
CHK5 EQU * LABEL ENTRY POINT
LR 6,5 LOAD R6 WITH R5(THE BINARY LOOP INDEX) A 6,=F'1' ADD ONE TO R6 SRDA 6,32 SHIFT RD VAL 32 BITS RIGHT(TO R7) D 6,=F'5' DIVIDE BY 5 C 6,=F'0' IS REMAINDER 0? BE DIV5 IF SO GOTO DIV5 ROUTINE B LCHK5 IF NOT GO BACK TO LOOP
- ////////////////////////////////////////////////*
DIV3 EQU * LABEL ENRTY POINT
MVC EOUT,FIZZ SAY FIZZ B ENLOOP RETURN TO LOOP
- ////////////////////////////////////////////////*
DIV5 EQU * LABEL ENTRY POINT
MVC EOUT,BUZZ SAY BUZZ B ENLOOP RETURN TO LOOP
- ////////////////////////////////////////////////*
DIV15 EQU * LABEL ENTRY POINT
MVC EOUT,FIZZBUZ SAY FIZZBUZZ B ENLOOP RETURN TO LOOP
- VARIABLE STORAGE************************
FIZZBUZ DC CL10'FIZZBUZZ!' CREATE A STRING IN MEMORY, LABEL THE ADDRESS FIZZBUZ FIZZ DC CL10'FIZZ!' CREATE A STRING IN MEMORY, LABEL THE ADDRESS FIZZ BUZZ DC CL10'BUZZ!' CREATE A STRING IN MEMORY, LABEL THE ADDRESS BUZZ NUM DC PL3'0' CREATE A DECIMAL IN MEMORY, MAKE IT ZERO, LABEL IT NUM TEMP DS D RESERVE A DOUBLE WORD (8 BYTES) IN MEMORY, LABEL IT TEMP EMSK DC X'402020202020' CREATE A HEX ARRAY IN MEMORY, LABEL IT EMSK WTOSTART DC Y(WTOEND-*,0) LABEL THIS WTOSTART, DEFINE A CONSTANT ADDRESS EQUAL TO
- "WTOEND" MINUS HERE(*)
EOUT DS CL10 RESERVE SPACE FOR 10 CHARACTERS, LABEL THIS EOUT WTOEND EQU * THE MEMORY ADDRESS LOCATED HERE IS LABELED WTOEND
- HOUSE KEEPING AREA**********************
SAVE DS 18F
END HELLO </lang>
6502 Assembly
The modulus operation is rather expensive on the 6502, so a simple counter solution was chosen. <lang> .lf fzbz6502.lst .cr 6502 .tf fzbz6502.obj,ap1
- ------------------------------------------------------
- FizzBuzz for the 6502 by barrym95838 2013.04.04
- Thanks to sbprojects.com for a very nice assembler!
- The target for this assembly is an Apple II with
- mixed-case output capabilities and Applesoft
- BASIC in ROM (or language card)
- Tested and verified on AppleWin 1.20.0.0
- ------------------------------------------------------
- Constant Section
FizzCt = 3 ;Fizz Counter (must be < 255) BuzzCt = 5 ;Buzz Counter (must be < 255) Lower = 1 ;Loop start value (must be 1) Upper = 100 ;Loop end value (must be < 255) CharOut = $fded ;Specific to the Apple II IntOut = $ed24 ;Specific to ROM Applesoft
- ======================================================
.or $0f00
- ------------------------------------------------------
- The main program
main ldx #Lower ;init LoopCt lda #FizzCt sta Fizz ;init FizzCt lda #BuzzCt sta Buzz ;init BuzzCt next ldy #0 ;reset string pointer (y) dec Fizz ;LoopCt mod FizzCt == 0? bne noFizz ; yes: lda #FizzCt sta Fizz ; restore FizzCt ldy #sFizz-str ; point y to "Fizz" jsr puts ; output "Fizz" noFizz dec Buzz ;LoopCt mod BuzzCt == 0? bne noBuzz ; yes: lda #BuzzCt sta Buzz ; restore BuzzCt ldy #sBuzz-str ; point y to "Buzz" jsr puts ; output "Buzz" noBuzz dey ;any output yet this cycle? bpl noInt ; no: txa ; save LoopCt pha lda #0 ; set up regs for IntOut jsr IntOut ; output itoa(LoopCt) pla tax ; restore LoopCt noInt ldy #sNL-str jsr puts ;output "\n" inx ;increment LoopCt cpx #Upper+1 ;LoopCt >= Upper+1? bcc next ; no: loop back rts ; yes: end main
- ------------------------------------------------------
- Output zero-terminated string @ (str+y)
- (Entry point is puts, not outch)
outch jsr CharOut ;output string char iny ;advance string ptr puts lda str,y ;get a string char bne outch ;output and loop if non-zero rts ;return
- ------------------------------------------------------
- String literals (in '+128' ascii, Apple II style)
str: ; string base offset sFizz .az -"Fizz" sBuzz .az -"Buzz" sNL .az -#13
- ------------------------------------------------------
- Variable Section
Fizz .da #0 Buzz .da #0
- ------------------------------------------------------
.en </lang>
ACL2
<lang Lisp>(defun fizzbuzz-r (i)
(declare (xargs :measure (nfix (- 100 i)))) (prog2$ (cond ((= (mod i 15) 0) (cw "FizzBuzz~%")) ((= (mod i 5) 0) (cw "Buzz~%")) ((= (mod i 3) 0) (cw "Fizz~%")) (t (cw "~x0~%" i))) (if (zp (- 100 i)) nil (fizzbuzz-r (1+ i)))))
(defun fizzbuzz () (fizzbuzz-r 1))</lang>
ActionScript
The ActionScript solution works just like the JavaScript solution (they share the ECMAScript specification). The difference is that ActionScript has the trace command to write out to a console. <lang actionscript>for (var i:int = 1; i <= 100; i++) {
if (i % 15 == 0) trace('FizzBuzz'); else if (i % 5 == 0) trace('Buzz'); else if (i % 3 == 0) trace('Fizz'); else trace(i);
}</lang>
AutoIt
<lang AutoIt>For $i = 1 To 100 If Mod($i, 15) = 0 Then MsgBox(0, "FizzBuzz", "FizzBuzz") ElseIf Mod($i, 5) = 0 Then MsgBox(0, "FizzBuzz", "Buzz") ElseIf Mod($i, 3) = 0 Then MsgBox(0, "FizzBuzz", "Fizz") Else MsgBox(0, "FizzBuzz", $i) EndIf Next</lang>
8086 Assembly
Assembly programs that output a number on the screen are programmable in two ways: calculating the number in binary to convert it next in ASCII for output, or keeping the number in Binary Coded Decimal (BCD) notation to speed up the output to the screen, because no binary to decimal conversion needs to be applied. The first approach is the most useful because the binary number is immediately recognizable to the computer, but, in a problem where the calculations are very few and simple and the final result is mainly text on the screen, using binary numbers would speed up calculations, but will greatly slow down the output.
The BCD used is based on the ASCII text encoding: zero is the hexadecimal byte 30, and nine is the hexadecimal byte 39. The BCD number is kept in the DX register, the most significant digit in DH and the less significant digit in DL. See the comments for further explaining of the program's structure, wich is meant for speed and compactness rather than modularity: there are no subroutines reusable in another program without being edited.
This program is 102 bytes big when assembled. The program is written to be run in an IBM PC because the 8086 processor alone does not provide circuitry for any kind of direct screen output. At least, I should point out that this program is a little bugged: the biggest number representable with the BCD system chosen is 99, but the last number displayed is 100, wich would be written as :0 because the program does provide overflow detecting only for the units, not for tens (39 hex + 1 is 3A, that is the colon symbol in ASCII). However, this bug is hidden by the fact that the number 100 is a multiple of five, so the number is never displayed, because it is replaced by the string "buzz". <lang asm> ; Init the registers mov dx,03030h ; For easier printing, the number is
;kept in Binary Coded Decimal, in
;the DX register.
mov ah,0Eh ; 0Eh is the IBM PC interrupt 10h
;function that does write text on ;the screen in teletype mode.
mov bl,100d ; BL is the counter (100 numbers). xor cx,cx ; CX is a counter that will be used
;for screen printing.
xor bh,bh ; BH is the counter for counting
;multiples of three.
writeloop: ; Increment the BCD number in DX. inc dl ; Increment the low digit cmp dl,3Ah ; If it does not overflow nine, jnz writeloop1 ;continue with the program, mov dl,30h ;otherwise reset it to zero and inc dh ;increment the high digit writeloop1: inc bh ; Increment the BH counter. cmp bh,03h ; If it reached three, we did
;increment the number three times ;from the last time the number was ;a multiple of three, so the number ;is now a multiple of three now,
jz writefizz ;then we need to write "fizz" on the
;screen.
cmp dl,30h ; The number isn't a multiple of jz writebuzz ;three, so we check if it's a cmp dl,35h ;multiple of five. If it is, we jz writebuzz ;need to write "buzz". The program
;checks if the last digit is zero or ;five.
mov al,dh ; If we're here, there's no need to int 10h ;write neither "fizz" nor "buzz", so mov al,dl ;the program writes the BCD number int 10h ;in DX writespace: mov al,020h ;and a white space. int 10h dec bl ; Loop if we didn't process 100 jnz writeloop ;numbers.
programend: ; When we did reach 100 numbers, cli ;the program flow falls here, where hlt ;interrupts are cleared and the jmp programend ;program is stopped.
writefizz: ; There's need to write "fizz": mov si,offset fizz ; SI points to the "fizz" string, call write ;that is written on the screen. xor bh,bh ; BH, the counter for computing the
;multiples of three, is cleared.
cmp dl,30h ; We did write "fizz", but, if the jz writebuzz ;number is a multiple of five, we cmp dl,35h ;could need to write "buzz" also: jnz writespace ;check if the number is multiple of
;five. If not, write a space and ;return to the main loop.
writebuzz: ; (The above code falls here if
;the last digit is five, otherwise ;it jumps)
mov si,offset buzz ;SI points to the "buzz" string, call write ;that is written on the screen. jmp writespace ; Write a space to return to the main
;loop.
write: ; Write subroutine: mov cl,04h ; Set CX to the lenght of the string:
;both strings are 4 bytes long.
write1: mov al,[si] ; Load the character to write in AL. inc si ; Increment the counter SI. int 10h ; Call interrupt 10h, function 0Eh to
;write the character and advance the ;text cursor (teletype mode)
loop write1 ; Decrement CX: if CX is not zero, do ret ;loop, otherwise return from
;subroutine.
fizz: ;The "fizz" string. db "fizz"
buzz: ;The "buzz" string. db "buzz"</lang>
Ada
<lang ada>with Ada.Text_IO; use Ada.Text_IO;
procedure Fizzbuzz is begin
for I in 1..100 loop if I mod 15 = 0 then Put_Line("FizzBuzz"); elsif I mod 5 = 0 then Put_Line("Buzz"); elsif I mod 3 = 0 then Put_Line("Fizz"); else Put_Line(Integer'Image(I)); end if; end loop;
end Fizzbuzz;</lang>
ALGOL 68
<lang algol68>main:(
FOR i TO 100 DO printf(($gl$, IF i %* 15 = 0 THEN "FizzBuzz" ELIF i %* 3 = 0 THEN "Fizz" ELIF i %* 5 = 0 THEN "Buzz" ELSE i FI )) OD
)</lang> or simply: <lang algol68>FOR i TO 100 DO print(((i%*15=0|"FizzBuzz"|:i%*3=0|"Fizz"|:i%*5=0|"Buzz"|i),new line)) OD</lang>
APL
<lang apl>⎕IO←0 (L,'Fizz' 'Buzz' 'FizzBuzz')[¯1+(L×W=0)+W←(100×~0=W)+W←⊃+/1 2×0=3 5|⊂L←1+⍳100]</lang>
AppleScript
<lang AppleScript>property outputText: "" repeat with i from 1 to 100
if i mod 15 = 0 then set outputText to outputText & "FizzBuzz" else if i mod 3 = 0 then set outputText to outputText & "Fizz" else if i mod 5 = 0 then set outputText to outputText & "Buzz" else set outputText to outputText & i end if set outputText to outputText & linefeed
end repeat outputText</lang>
Arbre
<lang Arbre>fizzbuzz():
for x in [1..100] if x%5==0 and x%3==0 return "FizzBuzz" else if x%3==0 return "Fizz" else if x%5==0 return "Buzz" else return x
main():
fizzbuzz() -> io</lang>
AutoHotkey
Search autohotkey.com: [3]
<lang AutoHotkey>Loop, 100
{
If (Mod(A_Index, 15) = 0) output .= "FizzBuzz`n" Else If (Mod(A_Index, 3) = 0) output .= "Fizz`n" Else If (Mod(A_Index, 5) = 0) output .= "Buzz`n" Else output .= A_Index "`n"
} FileDelete, output.txt FileAppend, %output%, output.txt Run, cmd /k type output.txt</lang> A short example with cascading ternary operators and graphical output. Press Esc to close the window. <lang AutoHotkey>Gui, Add, Edit, r20 Gui,Show Loop, 100
Send, % (!Mod(A_Index, 15) ? "FizzBuzz" : !Mod(A_Index, 3) ? "Fizz" : !Mod(A_Index, 5) ? "Buzz" : A_Index) "`n"
Return Esc:: ExitApp</lang>
AWK
<lang AWK>BEGIN {
for (NUM=1; NUM<=100; NUM++) if (NUM % 15 == 0) {print "FizzBuzz"} else if (NUM % 3 == 0) {print "Fizz"} else if (NUM % 5 == 0) {print "Buzz"} else {print NUM}
}</lang> <lang AWK>echo {1..100} | awk ' BEGIN{RS=" "} $1 % 15 == 0 {print "FizzBuzz"} $1 % 5 == 0 {print "Buzz"} $1 % 3 == 0 {print "Fizz"} {print} '</lang> <lang AWK>seq 100 | awk '$0=NR%15?NR%5?NR%3?$0:"Fizz":"Buzz":"FizzBuzz"'</lang>
Babel
<lang babel>main:
{ { iter 1 + dup 15 % { "FizzBuzz" << zap } { dup 3 % { "Fizz" << zap } { dup 5 % { "Buzz" << zap} { %d << } if } if } if
"\n" << }
100 times }</lang>
bash
Any bash hacker would do this as a one liner at the shell, so... <lang bash> for n in {1..100}; do ([ $((n%15)) -eq 0 ] && echo 'FizzBuzz') || ([ $((n%5)) -eq 0 ] && echo 'Buzz') || ([ $((n%3)) -eq 0 ] && echo 'Fizz') || echo $n; done </lang>
For the sake of readability... <lang bash> for n in {1..100}; do
([ $((n%15)) -eq 0 ] && echo 'FizzBuzz') || ([ $((n%5)) -eq 0 ] && echo 'Buzz') || ([ $((n%3)) -eq 0 ] && echo 'Fizz') || echo $n;
done </lang>
Here's a very concise approach -- only 75 characters total. Unfortunately it relies on aspects of Bash which are rarely used. <lang bash> for i in {1..100};do((i%3))&&x=||x=Fizz;((i%5))||x+=Buzz;echo ${x:-$i};done </lang> Here's the concise approach again, this time separated into multiple lines. <lang bash>
- FizzBuzz in Bash. A concise version, but with verbose comments.
for i in {1..100} # Use i to loop from "1" to "100", inclusive. do ((i % 3)) && # If i is not divisible by 3...
x= || # ...blank out x (yes, "x= " does that). Otherwise,... x=Fizz # ...set (not append) x to the string "Fizz". ((i % 5)) || # If i is not divisible by 5, skip (there's no "&&")... x+=Buzz # ...Otherwise, append (not set) the string "Buzz" to x. echo ${x:-$i} # Print x unless it is blanked out. Otherwise, print i.
done </lang> It's a bit silly to optimize such a small & fast program, but for the sake of algorithm analysis it's worth noting that the concise approach is reasonably efficient in several ways. Each divisibility test appears in the code exactly once, only two variables are created, and the approach avoids setting variables unnecessarily. As far as I can tell, the divisibility tests only fire the minimum number of times required for the general case (e.g. where the 100/3/5 constants can be changed), unless you introduce more variables and test types. Corrections invited. I avoided analyzing the non-general case where 100/3/5 never change, because one "optimal" solution is to simply print the pre-computed answer,
BASIC
If/else ladder approach
<lang qbasic>FOR A = 1 TO 100
IF A MOD 15 = 0 THEN PRINT "FizzBuzz" ELSE IF A MOD 3 = 0 THEN PRINT "Fizz" ELSE IF A MOD 5 = 0 THEN PRINT "Buzz" ELSE PRINT A END IF
NEXT A</lang>
Concatenation approach
<lang qbasic>FOR A = 1 TO 100
OUT$ = ""
IF A MOD 3 = 0 THEN OUT$ = "Fizz" END IF
IF A MOD 5 = 0 THEN OUT$ = OUT$ + "Buzz" END IF IF OUT$ = "" THEN OUT$ = STR$(A) END IF
PRINT OUT$
NEXT A</lang> See also: RapidQ
Applesoft BASIC
<lang applesoftbasic>10 DEF FN M(N) = ((A / N) - INT (A / N)) * N 20 FOR A = 1 TO 100 30 LET O$ = "" 40 IF FN M(3) = 0 THEN O$ = "FIZZ" 50 IF FN M(5) = 0 THEN O$ = O$ + "BUZZ" 60 IF O$ = "" THEN O$ = STR$ (A) 70 PRINT O$ 80 NEXT A </lang>
Batch File
For /L version: <lang dos>@echo off for /L %%i in (1,1,100) do call :tester %%i goto :eof
- tester
set /a test = %1 %% 15 if %test% NEQ 0 goto :NotFizzBuzz echo FizzBuzz goto :eof
- NotFizzBuzz
set /a test = %1 %% 5 if %test% NEQ 0 goto :NotBuzz echo Buzz goto :eof
- NotBuzz
set /a test = %1 %% 3 if %test% NEQ 0 goto :NotFizz echo Fizz goto :eof
- NotFizz
echo %1 </lang> Loop version: <lang dos>@echo off set n=1
- loop
call :tester %n% set /a n += 1 if %n% LSS 101 goto loop goto :eof
- tester
set /a test = %1 %% 15 if %test% NEQ 0 goto :NotFizzBuzz echo FizzBuzz goto :eof
- NotFizzBuzz
set /a test = %1 %% 5 if %test% NEQ 0 goto :NotBuzz echo Buzz goto :eof
- NotBuzz
set /a test = %1 %% 3 if %test% NEQ 0 goto :NotFizz echo Fizz goto :eof
- NotFizz
echo %1</lang>
BBC BASIC
<lang bbcbasic> FOR number% = 1 TO 100
CASE TRUE OF WHEN number% MOD 15 = 0: PRINT "FizzBuzz" WHEN number% MOD 3 = 0: PRINT "Fizz" WHEN number% MOD 5 = 0: PRINT "Buzz" OTHERWISE: PRINT ; number% ENDCASE NEXT number%</lang>
bc
This solution never uses else, because bc has no else keyword (but some implementations add else as an extension).
<lang bc>for (i = 1; i <= 100; i++) { w = 0 if (i % 3 == 0) { "Fizz"; w = 1; } if (i % 5 == 0) { "Buzz"; w = 1; } if (w == 0) i if (w == 1) " " } quit</lang>
Befunge
(befunge 93) <lang befunge>55*4*v _ v v <>:1-:^
|:<$ < ,*48 < @>0"zzif">:#,_$ v
>:3%!| >0"zzub">:#,_$^
>:5%!|
v "buzz"0<>:. ^
|!%5: <
>:#,_ $> ^</lang>
Boo
<lang boo>def fizzbuzz(size):
for i in range(1, size): if i%15 == 0: print 'FizzBuzz' elif i%5 == 0: print 'Buzz' elif i%3 == 0: print 'Fizz' else: print i
fizzbuzz(101)</lang>
Bracmat
<lang bracmat>0:?i&whl'(1+!i:<101:?i&out$(mod$(!i.3):0&(mod$(!i.5):0&FizzBuzz|Fizz)|mod$(!i.5):0&Buzz|!i))</lang> Same code, pretty printed: <lang bracmat> 0:?i & whl
' ( 1+!i:<101:?i & out $ ( mod$(!i.3):0 & ( mod$(!i.5):0&FizzBuzz | Fizz ) | mod$(!i.5):0&Buzz | !i ) )</lang>
Brat
<lang brat>1.to 100 { n |
true? n % 15 == 0 { p "FizzBuzz" } { true? n % 3 == 0 { p "Fizz" } { true? n % 5 == 0 { p "Buzz" } { p n } } } }</lang>
Brainf***
<lang bf>FizzBuzz
Memory:
Zero Zero Counter 1 Counter 2
Zero ASCIIDigit 3 ASCIIDigit 2 ASCIIDigit 1
Zero Digit 3 Digit 2 Digit 1
CopyPlace Mod 3 Mod 5 PrintNumber
TmpFlag
Counters for the loop ++++++++++[>++++++++++[>+>+<<-]<-]
Number representation in ASCII >>>> ++++++++ ++++++++ ++++++++ ++++++++ ++++++++ ++++++++ [>+>+>+<<<-] <<<<
>> [
Do hundret times:
Decrement counter ->->
Increment Number > >>+> > >>+> <<<< <<<<
Check for Overflow ++++++++++ >>> >>>> >++++++++++< [-<<< <<<<->>>> >>> >-<] ++++++++++ <<< <<<<
Restore the digit [->>>> >>>-<<< <<<<] >>>> [-]+ >>>>[<<<< - >>>>[-]]<<<< <<<<
If there is an overflow >>>>[ <<<<
>>>----------> >>>----------<+<< <<+<<
Check for Overflow ++++++++++ >> >>>> >>++++++++++<< [-<< <<<<->>>> >> >>-<<] ++++++++++ << <<<<
Restore the digit [->>>> >>-<< <<<<] >>>> [-]+ >>>>[<<<< - >>>>[-]]<<<< <<<<
If there (again) is an overflow >>>>[ <<<< >>---------->> >>----------<+< <<<+<
>>>> [-] ]<<<<
>>>> [-] ]<<<<
>>>> >>>>
Set if to print the number >>>[-]+<<<
Handle the Mod 3 counter [-]+++
>>>>[-]+<<<< >+[-<->]+++< [->->>>[-]<<<<] >>>>[ <[-]>
[-] Print "Fizz" ++++++++ ++++++++ ++++++++ ++++++++ ++++++++ ++++++++ ++++++++ ++++++++ ++++++.
++++++++ ++++++++ ++++++++ ++++++++ +++. ++++++++ ++++++++ +..
[-] <<<--->>> ]<<<<
Handle the Mod 5 counter [-]+++++
>>>>[-]+<<<< >>+[-<<->>]+++++<< [->>->>[-]<<<<] >>>>[ <[-]>
[-] Print "Buzz" ++++++++ ++++++++ ++++++++ ++++++++ ++++++++ ++++++++ ++++++++ ++++++++ ++.
++++++++ ++++++++ ++++++++ ++++++++ ++++++++ ++++++++ +++. +++++..
[-] <<----->> ]<<<<
Check if to print the number (Leading zeros) >>>[ <<< <<<< <<<< >.>.>.<<< >>> >>>> >>>> [-] ]<<<
<<<< <<<<
Print New Line <<<<[-]++++ ++++ ++++ +.---.[-]>>
] <<</lang>
C
<lang c>#include<stdio.h>
int main (void) {
int i; for (i = 1; i <= 100; i++) { if (!(i % 15)) printf ("FizzBuzz"); else if (!(i % 3)) printf ("Fizz"); else if (!(i % 5)) printf ("Buzz"); else printf ("%d", i);
printf("\n"); } return 0;
}</lang> Implicit int main and return 0 (C99+): <lang c>#include <stdio.h>
main() {
int i = 1; while(i <= 100) { if(i % 15 == 0) puts("FizzBuzz"); else if(i % 3 == 0) puts("Fizz"); else if(i % 5 == 0) puts("Buzz"); else printf("%d\n", i); i++; }
}</lang> obfuscated: <lang c>#include <stdio.h>
- define F(x,y) printf("%s",i%x?"":#y"zz")
int main(int i){for(--i;i++^100;puts(""))F(3,Fi)|F(5,Bu)||printf("%i",i);return 0;}</lang>
This actually works (the array init part, saves 6 bytes of static data, whee):<lang c>#include<stdio.h>
int main () { int i; const char *s[] = { "%d\n", "Fizz\n", s[3] + 4, "FizzBuzz\n" }; for (i = 1; i <= 100; i++) printf(s[!(i % 3) + 2 * !(i % 5)], i);
return 0; }</lang>
C++
<lang cpp>#include <iostream>
using namespace std; int main () {
int i; for (i = 0; i <= 100; i++) { if ((i % 15) == 0) cout << "FizzBuzz" << endl; else if ((i % 3) == 0) cout << "Fizz" << endl; else if ((i % 5) == 0) cout << "Buzz" << endl; else cout << i << endl; } return 0;
}</lang>
Alternate version not using modulo 15:
<lang cpp>#include <iostream>
using namespace std;
int main() {
for (int i = 0; i <= 100; ++i) { bool fizz = (i % 3) == 0; bool buzz = (i % 5) == 0; if (fizz) cout << "Fizz"; if (buzz) cout << "Buzz"; if (!fizz && !buzz) cout << i; cout << endl; } return 0;
}</lang>
A version using std::transform:
<lang cpp>#include <iostream>
- include <algorithm>
- include <vector>
int main() {
std::vector<int> range(100); std::iota(range.begin(), range.end(), 1);
std::vector<std::string> values; values.resize(range.size());
auto fizzbuzz = [](int i) -> std::string { if ((i%15) == 0) return "FizzBuzz"; if ((i%5) == 0) return "Buzz"; if ((i%3) == 0) return "Fizz"; return std::to_string(i); };
std::transform(range.begin(), range.end(), values.begin(), fizzbuzz);
for (auto& str: values) std::cout << str << std::endl;
return 0;
}</lang>
Version computing FizzBuzz at compile time with metaprogramming:
<lang cpp>#include <iostream>
template <int n, int m3, int m5> struct fizzbuzz : fizzbuzz<n-1, (n-1)%3, (n-1)%5> {
fizzbuzz() { std::cout << n << std::endl; }
};
template <int n> struct fizzbuzz<n, 0, 0> : fizzbuzz<n-1, (n-1)%3, (n-1)%5> {
fizzbuzz() { std::cout << "FizzBuzz" << std::endl; }
};
template <int n, int p> struct fizzbuzz<n, 0, p> : fizzbuzz<n-1, (n-1)%3, (n-1)%5> {
fizzbuzz() { std::cout << "Fizz" << std::endl; }
};
template <int n, int p> struct fizzbuzz<n, p, 0> : fizzbuzz<n-1, (n-1)%3, (n-1)%5> {
fizzbuzz() { std::cout << "Buzz" << std::endl; }
};
template <> struct fizzbuzz<0,0,0> {
fizzbuzz() { std::cout << 0 << std::endl; }
};
template <int n> struct fb_run {
fizzbuzz<n, n%3, n%5> fb;
};
int main() {
fb_run<100> fb; return 0;
}</lang>
Hardcore templates (compile with -ftemplate-depth-9000 -std=c++0x):
<lang cpp>#include <iostream>
- include <string>
- include <cstdlib>
- include <boost/mpl/string.hpp>
- include <boost/mpl/fold.hpp>
- include <boost/mpl/size_t.hpp>
using namespace std; using namespace boost;
/////////////////////////////////////////////////////////////////////////////// // exponentiation calculations template <int accum, int base, int exp> struct POWER_CORE : POWER_CORE<accum * base, base, exp - 1>{};
template <int accum, int base> struct POWER_CORE<accum, base, 0> {
enum : int { val = accum };
};
template <int base, int exp> struct POWER : POWER_CORE<1, base, exp>{};
/////////////////////////////////////////////////////////////////////////////// // # of digit calculations template <int depth, unsigned int i> struct NUM_DIGITS_CORE : NUM_DIGITS_CORE<depth + 1, i / 10>{};
template <int depth> struct NUM_DIGITS_CORE<depth, 0> {
enum : int { val = depth};
};
template <int i> struct NUM_DIGITS : NUM_DIGITS_CORE<0, i>{};
template <> struct NUM_DIGITS<0> {
enum : int { val = 1 };
};
/////////////////////////////////////////////////////////////////////////////// // Convert digit to character (1 -> '1') template <int i> struct DIGIT_TO_CHAR {
enum : char{ val = i + 48 };
};
/////////////////////////////////////////////////////////////////////////////// // Find the digit at a given offset into a number of the form 0000000017 template <unsigned int i, int place> // place -> [0 .. 10] struct DIGIT_AT {
enum : char{ val = (i / POWER<10, place>::val) % 10 };
};
struct NULL_CHAR {
enum : char{ val = '\0' };
};
/////////////////////////////////////////////////////////////////////////////// // Convert the digit at a given offset into a number of the form '0000000017' to a character template <unsigned int i, int place> // place -> [0 .. 9]
struct ALT_CHAR : DIGIT_TO_CHAR< DIGIT_AT<i, place>::val >{};
/////////////////////////////////////////////////////////////////////////////// // Convert the digit at a given offset into a number of the form '17' to a character
// Template description, with specialization to generate null characters for out of range offsets template <unsigned int i, int offset, int numDigits, bool inRange>
struct OFFSET_CHAR_CORE_CHECKED{};
template <unsigned int i, int offset, int numDigits>
struct OFFSET_CHAR_CORE_CHECKED<i, offset, numDigits, false> : NULL_CHAR{};
template <unsigned int i, int offset, int numDigits>
struct OFFSET_CHAR_CORE_CHECKED<i, offset, numDigits, true> : ALT_CHAR<i, (numDigits - offset) - 1 >{};
// Perform the range check and pass it on template <unsigned int i, int offset, int numDigits>
struct OFFSET_CHAR_CORE : OFFSET_CHAR_CORE_CHECKED<i, offset, numDigits, offset < numDigits>{};
// Calc the number of digits and pass it on template <unsigned int i, int offset>
struct OFFSET_CHAR : OFFSET_CHAR_CORE<i, offset, NUM_DIGITS::val>{};
/////////////////////////////////////////////////////////////////////////////// // Integer to char* template. Works on unsigned ints. template <unsigned int i> struct IntToStr {
const static char str[]; typedef typename mpl::string< OFFSET_CHAR<i, 0>::val, OFFSET_CHAR<i, 1>::val, OFFSET_CHAR<i, 2>::val, OFFSET_CHAR<i, 3>::val, OFFSET_CHAR<i, 4>::val, OFFSET_CHAR<i, 5>::val, /*OFFSET_CHAR<i, 6>::val, OFFSET_CHAR<i, 7>::val, OFFSET_CHAR<i, 8>::val, OFFSET_CHAR<i, 9>::val,*/ NULL_CHAR::val>::type type;
};
template <unsigned int i> const char IntToStr::str[] = {
OFFSET_CHAR<i, 0>::val, OFFSET_CHAR<i, 1>::val, OFFSET_CHAR<i, 2>::val, OFFSET_CHAR<i, 3>::val, OFFSET_CHAR<i, 4>::val, OFFSET_CHAR<i, 5>::val, OFFSET_CHAR<i, 6>::val, OFFSET_CHAR<i, 7>::val, OFFSET_CHAR<i, 8>::val, OFFSET_CHAR<i, 9>::val, NULL_CHAR::val
};
template <bool condition, class Then, class Else> struct IF {
typedef Then RET;
};
template <class Then, class Else> struct IF<false, Then, Else> {
typedef Else RET;
};
template < typename Str1, typename Str2 >
struct concat : mpl::insert_range<Str1, typename mpl::end<Str1>::type, Str2> {};
template <typename Str1, typename Str2, typename Str3 >
struct concat3 : mpl::insert_range<Str1, typename mpl::end<Str1>::type, typename concat<Str2, Str3 >::type > {};
typedef typename mpl::string<'f','i','z','z'>::type fizz; typedef typename mpl::string<'b','u','z','z'>::type buzz; typedef typename mpl::string<'\r', '\n'>::type mpendl; typedef typename concat<fizz, buzz>::type fizzbuzz;
// discovered boost mpl limitation on some length
template <int N> struct FizzBuzz {
typedef typename concat3<typename FizzBuzz<N - 1>::type, typename IF<N % 15 == 0, typename fizzbuzz::type, typename IF<N % 3 == 0, typename fizz::type, typename IF<N % 5 == 0, typename buzz::type, typename IntToStr<N>::type >::RET >::RET >::RET, typename mpendl::type>::type type;
};
template <> struct FizzBuzz<1> {
typedef mpl::string<'1','\r','\n'>::type type;
};
int main(int argc, char** argv) {
const int n = 7; std::cout << mpl::c_str<FizzBuzz<n>::type>::value << std::endl;
return 0; }</lang> Note: it takes up lots of memory and takes several seconds to compile. To enable compilation for 7 < n <= 25, please, modify include/boost/mpl/limits/string.hpp BOOST_MPL_LIMIT_STRING_SIZE to 128 instead of 32).
C#
<lang csharp>using System; using System.Text;
namespace FizzBuzz {
class Program { static void Main() { var output = new StringBuilder(); for (var i = 1; i <= 100; i++) { output.AppendFormat("{0}{1}{2}", (i%3 == 0) ? "Fizz" : string.Empty, (i%5 == 0) ? "Buzz" : string.Empty, Environment.NewLine); } Console.WriteLine(output); } }
}</lang> <lang csharp>using System; using System.Linq;
namespace FizzBuzz {
class Program { static void Main(string[] args) { Enumerable.Range(1, 100) .Select(a => String.Format("{0}{1}", a % 3 == 0 ? "Fizz" : string.Empty, a % 5 == 0 ? "Buzz" : string.Empty)) .Select((b, i) => String.IsNullOrEmpty(b) ? (i + 1).ToString() : b) .ToList() .ForEach(Console.WriteLine); } }
}</lang> <lang csharp>using System; using System.Globalization; using System.Linq;
namespace FizzBuzz {
class Program { static void Main() { Enumerable.Range(1, 100) .GroupBy(e => e % 15 == 0 ? "FizzBuzz" : e % 5 == 0 ? "Buzz" : e % 3 == 0 ? "Fizz" : string.Empty) .SelectMany(item => item.Select(x => new { Value = x, Display = String.IsNullOrEmpty(item.Key) ? x.ToString(CultureInfo.InvariantCulture) : item.Key })) .OrderBy(x => x.Value) .Select(x => x.Display) .ToList() .ForEach(Console.WriteLine); } }
}</lang>
<lang csharp>using System; using System.Globalization;
namespace Rosettacode {
class Program { static void Main() { for (var number = 0; number < 100; number++) { if ((number % 3) == 0 & (number % 5) == 0) { //For numbers which are multiples of both three and five print "FizzBuzz". Console.WriteLine("FizzBuzz"); continue; }
if ((number % 3) == 0) Console.WriteLine("Fizz"); if ((number % 5) == 0) Console.WriteLine("Buzz"); if ((number % 3) != 0 && (number % 5) != 0) Console.WriteLine(number.ToString(CultureInfo.InvariantCulture));
if (number % 5 == 0) { Console.WriteLine(Environment.NewLine); } } } }
}</lang>
TDD using delegates.
<lang csharp>using System; using System.Collections; using System.Collections.Generic; using System.Globalization; using System.Linq; using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace FizzBuzz {
[TestClass] public class FizzBuzzTest { private FizzBuzz fizzBuzzer;
[TestInitialize] public void Initialize() { fizzBuzzer = new FizzBuzz(); }
[TestMethod] public void Give4WillReturn4() { Assert.AreEqual("4", fizzBuzzer.FizzBuzzer(4)); }
[TestMethod] public void Give9WillReturnFizz() { Assert.AreEqual("Fizz", fizzBuzzer.FizzBuzzer(9)); }
[TestMethod] public void Give25WillReturnBuzz() { Assert.AreEqual("Buzz", fizzBuzzer.FizzBuzzer(25)); }
[TestMethod] public void Give30WillReturnFizzBuzz() { Assert.AreEqual("FizzBuzz", fizzBuzzer.FizzBuzzer(30)); }
[TestMethod] public void First15() { ICollection expected = new ArrayList {"1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz"};
var actual = Enumerable.Range(1, 15).Select(x => fizzBuzzer.FizzBuzzer(x)).ToList();
CollectionAssert.AreEqual(expected, actual); }
[TestMethod] public void From1To100_ToShowHowToGet100() { const int expected = 100; var actual = Enumerable.Range(1, 100).Select(x => fizzBuzzer.FizzBuzzer(x)).ToList();
Assert.AreEqual(expected, actual.Count); } }
public class FizzBuzz { private delegate string Xzzer(int value); private readonly IList<Xzzer> _functions = new List<Xzzer>();
public FizzBuzz() { _functions.Add(x => x % 3 == 0 ? "Fizz" : ""); _functions.Add(x => x % 5 == 0 ? "Buzz" : ""); }
public string FizzBuzzer(int value) { var result = _functions.Aggregate(String.Empty, (current, function) => current + function.Invoke(value)); return String.IsNullOrEmpty(result) ? value.ToString(CultureInfo.InvariantCulture) : result; } }
}</lang>
Cduce
<lang ocaml>(* FizzBuzz in CDuce *)
let format (n : Int) : Latin1 =
if (n mod 3 = 0) || (n mod 5 = 0) then "FizzBuzz" else if (n mod 5 = 0) then "Buzz" else if (n mod 3 = 0) then "Fizz" else string_of (n);;
let fizz (n : Int, size : Int) : _ =
print (format (n) @ "\n"); if (n = size) then n = 0 (* do nothing *) else fizz(n + 1, size);;
let fizbuzz (size : Int) : _ = fizz (1, size);;
let _ = fizbuzz(100);;</lang>
Chef
This was clearly a challenge in a language without a modulus operator, a proper if statement except for checking if a variable is not exactly 0, and no way to define text except 1 character at a time on a stack. <lang chef>Irish Soda Bread with Club Soda.
This is FizzBuzz
Ingredients. 1 l buttermilk
Method. Take buttermilk from refrigerator. Shake the buttermilk.
Put buttermilk into the 6th mixing bowl. Serve with club soda. Pour contents of the 1st mixing bowl into the 1st baking dish. Clean the 1st mixing bowl.
Watch the buttermilk until shaked.
Serves 1.
Club Soda.
Gets whether to print fizz buzz fizzbuzz or number.
Ingredients. 70 g flour 105 g salt 122 ml milk 66 g sugar 117 ml vegetable oil 3 cups fizzle 5 cups seltzer 1 cup bmilk 1 cup ice 1 cup baking soda 1 g oregano 32 ml vinegar 1 g thyme 1 g sage
Method. Put milk into the 1st mixing bowl. Put salt into the 1st mixing bowl. Put flour into the 1st mixing bowl. Put vinegar into the 1st mixing bowl. Put milk into the 1st mixing bowl. Stir the 1st mixing bowl for 5 minutes. Liquify contents of the 1st mixing bowl. Put fizzle into the 3rd mixing bowl. Combine seltzer into the 3rd mixing bowl. Fold bmilk into the 6th mixing bowl. Put bmilk into the 6th mixing bowl. Put seltzer into the 6th mixing bowl. Put bmilk into the 6th mixing bowl. Serve with moist cake. Fold bmilk into the 1st mixing bowl. Fold sage into the 6th mixing bowl. Fold sage into the 6th mixing bowl. Put bmilk into the 4th mixing bowl. Remove seltzer from the 4th mixing bowl. Fold oregano into the 4th mixing bowl. Smell the oregano.
Fold bmilk into the 6th mixing bowl. Put bmilk into the 6th mixing bowl. Put fizzle into the 6th mixing bowl. Put bmilk into the 6th mixing bowl. Serve with moist cake. Fold bmilk into the 1st mixing bowl. Fold sage into the 6th mixing bowl. Fold sage into the 6th mixing bowl. Put bmilk into the 4th mixing bowl. Remove fizzle from the 4th mixing bowl. Fold oregano into the 4th mixing bowl. Crush the oregano. Clean the 1st mixing bowl. Fold bmilk into the 6th mixing bowl. Put bmilk into the 1st mixing bowl. Refrigerate. Grind until crushed. Refrigerate.
Shuffle until smelled. Clean the 1st mixing bowl. Put milk into the 1st mixing bowl. Put vegetable oil into the 1st mixing bowl. Put sugar into the 1st mixing bowl. Put vinegar into the 1st mixing bowl. Put milk into the 1st mixing bowl. Stir the 1st mixing bowl for 5 minutes. Liquify contents of the 1st mixing bowl. Fold baking soda into the 3rd mixing bowl. Fold bmilk into the 6th mixing bowl. Put bmilk into the 6th mixing bowl. Put baking soda into the 6th mixing bowl. Put bmilk into the 6th mixing bowl. Serve with moist cake. Fold bmilk into the 1st mixing bowl. Fold sage into the 6th mixing bowl. Fold sage into the 6th mixing bowl. Put bmilk into the 4th mixing bowl. Remove baking soda from the 4th mixing bowl. Fold oregano into the 4th mixing bowl. Separate the oregano.
Refrigerate.
Part until separated. Put fizzle into the 6th mixing bowl. Serve with club soda. Stir the 1st mixing bowl for 1 minute. Stir the 1st mixing bowl for 7 minutes. Stir the 1st mixing bowl for 1 minute. Stir the 1st mixing bowl for 7 minutes. Stir the 1st mixing bowl for 5 minutes. Fold the oregano into the 1st mixing bowl. Fold the oregano into the 1st mixing bowl. Fold the oregano into the 1st mixing bowl. Fold the oregano into the 1st mixing bowl. Fold the oregano into the 1st mixing bowl. Refrigerate.
Moist cake.
Mods a number
Ingredients. 1 cup chocolate 70 g wheat flour 1 cup white chocolate chips 1 cup baking powder 105 g honey 5 cups syrup 1 g vanilla 1 g rosemary
Method. Fold chocolate into the 6th mixing bowl. Fold syrup into the 6th mixing bowl. Clean the 1st mixing bowl. Put chocolate into the 5th mixing bowl. Fold wheat flour into the 5th mixing bowl. Put white chocolate chips into the 5th mixing bowl. Remove white chocolate chips from the 5th mixing bowl. Fold baking powder into the 5th mixing bowl. Put baking powder into the 5th mixing bowl. Fold honey into the 5th mixing bowl. Sift the wheat flour.
Put honey into the 5th mixing bowl. Add white chocolate chips into the 5th mixing bowl. Fold honey into the 5th mixing bowl. Put honey into the 5th mixing bowl. Remove syrup from the 5th mixing bowl. Fold vanilla into the 5th mixing bowl. Sprinkle the vanilla. Put white chocolate chips into the 5th mixing bowl. Remove white chocolate chips from the 5th mixing bowl. Fold rosemary into the 5th mixing bowl. Set aside. Move until sprinkled. Recite the rosemary. Put white chocolate chips into the 5th mixing bowl. Remove white chocolate chips from the 5th mixing bowl. Fold honey into the 5th mixing bowl. Put baking powder into the 5th mixing bowl. Add white chocolate chips into the 5th mixing bowl. Fold baking powder into the 5th mixing bowl. Set aside. Repeat until recited. Put white chocolate chips into the 5th mixing bowl. Fold rosemary into the 5th mixing bowl.
Shuffle the wheat flour until sifted. Put the baking powder into the 5th mixing bowl. Combine syrup into the 5th mixing bowl. Fold honey into the 5th mixing bowl. Put chocolate into the 5th mixing bowl. Remove honey from the 5th mixing bowl. Fold chocolate into the 5th mixing bowl. Put white chocolate chips into the 5th mixing bowl. Fold rosemary into the 5th mixing bowl. Siphon chocolate.
Put white chocolate chips into the 5th mixing bowl. Remove white chocolate chips from the 5th mixing bowl. Fold rosemary into the 5th mixing bowl. Set aside.
Gulp until siphoned. Quote the rosemary.
Put syrup into the 5th mixing bowl. Fold chocolate into the 5th mixing bowl. Set aside.
Repeat until quoted. Put chocolate into the 1st mixing bowl. Refrigerate.</lang>
Clay
<lang clay>main() {
for(i in range(1,100)) { if(i % 3 == 0 and i % 5 == 0) println("fizzbuzz"); else if(i % 3 == 0) println("fizz"); else if(i % 5 == 0) println("buzz"); else print(i); }
}</lang>
Clipper
<lang Clipper>Procedure Main()
Local n Local cFB For n := 1 to 100 cFB := "" AEval( {{3,"Fizz"},{5,"Buzz"}}, {|x| cFB += Iif((n % x[1])==0, x[2], "")}) ?? Iif(cFB == "", LTrim(Str(n)), cFB) + Iif(n == 100, ".", ", ") Next
Return</lang>
The advantage of this approach is that it is trivial to add another factor:
AEval( {{3,"Fizz"},{5,"Buzz"},{9,"Jazz"}}, {|x| cFB += Iif((n % x[1])==0, x[2], "")})
CLIPS
<lang clips>(deffacts count
(count-to 100)
)
(defrule print-numbers
(count-to ?max) => (loop-for-count (?num ?max) do (if (= (mod ?num 3) 0) then (printout t "Fizz") ) (if (= (mod ?num 5) 0) then (printout t "Buzz") ) (if (and (> (mod ?num 3) 0) (> (mod ?num 5) 0)) then (printout t ?num) ) (priint depth, unsigned int i> struct NUM_DIGITS_CORE : NUM_DIGITS_COREntout t crlf) )
)</lang>
Clojure
<lang lisp>(map (fn [x] (cond (zero? (mod x 15)) "FizzBuzz"
(zero? (mod x 5)) "Buzz" (zero? (mod x 3)) "Fizz"
:else x))
(range 1 101))</lang>
<lang lisp>(map #(let [s (str (if (zero? (mod % 3)) "Fizz") (if (zero? (mod % 5)) "Buzz"))] (if (empty? s) % s)) (range 1 101))</lang> <lang lisp>(def fizzbuzz (map
#(cond (zero? (mod % 15)) "FizzBuzz" (zero? (mod % 5)) "Buzz" (zero? (mod % 3)) "Fizz" :else %) (iterate inc 1)))</lang>
<lang lisp>(defn fizz-buzz
([] (fizz-buzz (range 1 101))) ([lst] (letfn [(fizz? [n] (zero? (mod n 3)))
(buzz? [n] (zero? (mod n 5)))]
(let [f "Fizz"
b "Buzz" items (map (fn [n] (cond (and (fizz? n) (buzz? n)) (str f b) (fizz? n) f (buzz? n) b :else n)) lst)] items))))</lang> <lang clojure>(map (fn [n]
(if-let [fb (seq (concat (when (zero? (mod n 3)) "Fizz") (when (zero? (mod n 5)) "Buzz")))] (apply str fb) n)) (range 1 101))</lang>
<lang clojure>(take 100 (map #(let [s (str %2 %3) ] (if (seq s) s (inc %)) )
(range) (cycle [ "" "" "Fizz" ]) (cycle [ "" "" "" "" "Buzz" ])))</lang>
CMake
<lang cmake>foreach(i RANGE 1 100)
math(EXPR off3 "${i} % 3") math(EXPR off5 "${i} % 5") if(NOT off3 AND NOT off5) message(FizzBuzz) elseif(NOT off3) message(Fizz) elseif(NOT off5) message(Buzz) else() message(${i}) endif()
endforeach(i)</lang>
COBOL
Canonical version
works with OpenCOBOL: <lang COBOL> * FIZZBUZZ.COB
* cobc -x -g FIZZBUZZ.COB * IDENTIFICATION DIVISION. PROGRAM-ID. fizzbuzz. DATA DIVISION. WORKING-STORAGE SECTION. 01 CNT PIC 9(03) VALUE 1. 01 REM PIC 9(03) VALUE 0. 01 QUOTIENT PIC 9(03) VALUE 0. PROCEDURE DIVISION. * PERFORM UNTIL CNT > 100 DIVIDE 15 INTO CNT GIVING QUOTIENT REMAINDER REM IF REM = 0 THEN DISPLAY "FizzBuzz " WITH NO ADVANCING ELSE DIVIDE 3 INTO CNT GIVING QUOTIENT REMAINDER REM IF REM = 0 THEN DISPLAY "Fizz " WITH NO ADVANCING ELSE DIVIDE 5 INTO CNT GIVING QUOTIENT REMAINDER REM IF REM = 0 THEN DISPLAY "Buzz " WITH NO ADVANCING ELSE DISPLAY CNT " " WITH NO ADVANCING END-IF END-IF END-IF ADD 1 TO CNT END-PERFORM DISPLAY "" STOP RUN.</lang>
Simpler version
I know this doesn't have the full-bodied, piquant flavor expected from COBOL, but it is a little shorter.
Also works with OpenCOBOL: <lang cobol> Identification division. Program-id. fizz-buzz.
Data division. Working-storage section.
01 num pic 999.
Procedure division.
Perform varying num from 1 by 1 until num > 100 if function mod (num, 15) = 0 then display "fizzbuzz" else if function mod (num, 3) = 0 then display "fizz" else if function mod (num, 5) = 0 then display "buzz" else display num end-perform. Stop run.
</lang>
CoffeeScript
<lang CoffeeScript>for i in [1..100]
if i % 15 is 0 console.log "FizzBuzz" else if i % 3 is 0 console.log "Fizz" else if i % 5 is 0 console.log "Buzz" else console.log i</lang>
<lang CoffeeScript>for i in [1..100]
console.log(['Fizz' if i % 3 is 0] + ['Buzz' if i % 5 is 0] or i)
</lang>
Common Lisp
Solution 1: <lang lisp> (defun fizzbuzz ()
(loop for x from 1 to 100 do (princ (cond ((zerop (mod x 15)) "FizzBuzz") ((zerop (mod x 3)) "Fizz") ((zerop (mod x 5)) "Buzz") (t x))) (terpri)))
</lang> Solution 2: <lang lisp> (defun fizzbuzz ()
(loop for x from 1 to 100 do (format t "~&~{~A~}" (or (append (when (zerop (mod x 3)) '("Fizz")) (when (zerop (mod x 5)) '("Buzz"))) (list x)))))
</lang> Solution 3: <lang lisp> (defun fizzbuzz ()
(loop for n from 1 to 100 do (format t "~&~[~[FizzBuzz~:;Fizz~]~*~:;~[Buzz~*~:;~D~]~]~%" (mod n 3) (mod n 5) n)))
</lang> Solution 4: <lang lisp> (loop as n from 1 to 100
as fizz = (zerop (mod n 3)) as buzz = (zerop (mod n 5)) as numb = (not (or fizz buzz)) do (format t "~&~:[~;Fizz~]~:[~;Buzz~]~:[~;~D~]~%" fizz buzz numb n))
</lang> Solution 5: <lang lisp> (format t "~{~:[~&~;~:*~:(~a~)~]~}"
(loop as n from 1 to 100 as f = (zerop (mod n 3)) as b = (zerop (mod n 5)) collect nil if f collect 'fizz if b collect 'buzz if (not (or f b)) collect n))
</lang> Solution 6: <lang lisp> (format t "~{~{~:[~;Fizz~]~:[~;Buzz~]~:[~*~;~d~]~}~%~}"
(loop as n from 1 to 100 as f = (zerop (mod n 3)) as b = (zerop (mod n 5)) collect (list f b (not (or f b)) n)))
</lang> First 16 lines of output:
1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16
Cubescript
<lang>alias fizzbuzz [ loop i 100 [ push i (+ $i 1) [ cond (! (mod $i 15)) [ echo FizzBuzz ] (! (mod $i 3)) [ echo Fizz ] (! (mod $i 5)) [ echo Buzz ] [ echo $i ] ] ] ]</lang>
Chapel
<lang chapel>proc fizzbuzz(n) { for i in 1..n do if i % 15 == 0 then writeln("FizzBuzz"); else if i % 5 == 0 then writeln("Buzz"); else if i % 3 == 0 then writeln("Fizz"); else writeln(i); }
fizzbuzz(100);</lang>
D
<lang d>import std.stdio: writeln;
// with if-else void fizzBuzz(int n) {
foreach (i; 1 .. n+1) if (!(i % 15)) writeln("FizzBuzz"); else if (!(i % 3)) writeln("Fizz"); else if (!(i % 5)) writeln("Buzz"); else writeln(i);
}
// with switch case void fizzBuzzSwitch(int n) {
foreach (i; 1 .. n+1) switch(i % 15) { case 0: writeln("FizzBuzz"); break; case 3, 6, 9, 12: writeln("Fizz"); break; case 5, 10: writeln("Buzz"); break; default: writeln(i); }
}
void main() {
fizzBuzz(100); writeln(); fizzBuzzSwitch(100);
}</lang>
Dart
<lang dart>main() {
for(int i=1;i<=100;i++) print((i%3==0?"Fizz":"")+(i%5==0?"Buzz":"")+(i%3!=0&&i%5!=0?i:""));
}</lang>
dc
<lang dc>[[Fizz]P 1 sw]sF [[Buzz]P 1 sw]sB [li p sz]sN [[ ]P]sW [
0 sw [w = 0]sz li 3 % 0 =F [Fizz if 0 == i % 3]sz li 5 % 0 =B [Buzz if 0 == i % 5]sz lw 0 =N [print Number if 0 == w]sz lw 1 =W [print neWline if 1 == w]sz li 1 + si [i += 1]sz li 100 !<L [continue Loop if 100 >= i]sz
]sL 1 si [i = 1]sz 0 0 =L [enter Loop]sz</lang>
Delphi
<lang Delphi>program FizzBuzz;
{$APPTYPE CONSOLE}
uses SysUtils;
var
i: Integer;
begin
for i := 1 to 100 do begin if i mod 15 = 0 then Writeln('FizzBuzz') else if i mod 3 = 0 then Writeln('Fizz') else if i mod 5 = 0 then Writeln('Buzz') else Writeln(i); end;
end.</lang>
DWScript
<lang delphi>var i : Integer;
for i := 1 to 100 do begin
if i mod 15 = 0 then PrintLn('FizzBuzz') else if i mod 3 = 0 then PrintLn('Fizz') else if i mod 5 = 0 then PrintLn('Buzz') else PrintLn(i);
end;</lang>
E
<lang e>for i in 1..100 {
println(switch ([i % 3, i % 5]) { match [==0, ==0] { "FizzBuzz" } match [==0, _ ] { "Fizz" } match [_, ==0] { "Buzz" } match _ { i } }) }</lang>
ECL
<lang ECL> DataRec := RECORD
STRING s;
END;
DataRec MakeDataRec(UNSIGNED c) := TRANSFORM
SELF.s := MAP ( c % 15 = 0 => 'FizzBuzz', c % 3 = 0 => 'Fizz', c % 5 = 0 => 'Buzz', (STRING)c );
END;
d := DATASET(100,MakeDataRec(COUNTER));
OUTPUT(d); </lang>
Eero
<lang objc>#import <Foundation/Foundation.h>
int main()
autoreleasepool
for int i in 1 .. 100 s := if i % 3 == 0 s << 'Fizz' if i % 5 == 0 s << 'Buzz' Log( '(%d) %@', i, s )
return 0</lang>
Ela
<lang ela>open list
prt x | x % 15 == 0 = "FizzBuzz"
| x % 3 == 0 = "Fizz" | x % 5 == 0 = "Buzz" | else = x
[1..100] |> map prt</lang>
Elixir
<lang elixir>Enum.each 1..100, fn x ->
IO.puts(case { rem(x, 5) == 0, rem(x,3) == 0 } do { true, true } -> "FizzBuzz" { true, false } -> "Fizz" { false, true } -> "Buzz" { false, false } -> x end)
end</lang>
Erlang
<lang erlang>fizzbuzz() ->
F = fun(N) when N rem 15 == 0 -> "FizzBuzz"; (N) when N rem 3 == 0 -> "Fizz"; (N) when N rem 5 == 0 -> "Buzz"; (N) -> integer_to_list(N) end, [F(N)++"\n" || N <- lists:seq(1,100)].</lang>
Euphoria
This is based on the VBScript example. <lang Euphoria>include std/utils.e
function fb( atom n ) sequence fb if remainder( n, 15 ) = 0 then fb = "FizzBuzz" elsif remainder( n, 5 ) = 0 then fb = "Fizz" elsif remainder( n, 3 ) = 0 then fb = "Buzz" else fb = sprintf( "%d", n ) end if return fb end function
function fb2( atom n ) return iif( remainder(n, 15) = 0, "FizzBuzz", iif( remainder( n, 5 ) = 0, "Fizz", iif( remainder( n, 3) = 0, "Buzz", sprintf( "%d", n ) ) ) ) end function
for i = 1 to 30 do printf( 1, "%s ", { fb( i ) } ) end for
puts( 1, "\n" )
for i = 1 to 30 do printf( 1, "%s ", { fb2( i ) } ) end for
puts( 1, "\n" )</lang>
Factor
<lang factor>USING: math kernel io math.ranges ; IN: fizzbuzz
- fizz ( n -- str ) 3 divisor? "Fizz" "" ? ;
- buzz ( n -- str ) 5 divisor? "Buzz" "" ? ;
- fizzbuzz ( n -- str ) dup [ fizz ] [ buzz ] bi append [ number>string ] [ nip ] if-empty ;
- main ( -- ) 100 [1,b] [ fizzbuzz print ] each ;
MAIN: main</lang>
F#
<lang fsharp>#light [1..100] |> List.map (fun x ->
match x with | _ when x % 15 = 0 ->"fizzbuzz" | _ when x % 5 = 0 -> "buzz" | _ when x % 3 = 0 -> "fizz" | _ -> x.ToString())
|> List.iter (fun x -> printfn "%s" x) </lang> Another example using (unnecessary) partial active pattern :D <lang fsharp>let (|MultipleOf|_|) divisors number =
if Seq.exists ((%) number >> (<>) 0) divisors then None else Some ()
let fizzbuzz = function | MultipleOf [3; 5] -> "fizzbuzz" | MultipleOf [3] -> "fizz" | MultipleOf [5] -> "buzz" | n -> string n
{ 1 .. 100 } |> Seq.iter (fizzbuzz >> printfn "%s")</lang>
Falcon
<lang falcon>for i in [1:101]
switch i % 15 case 0 : > "FizzBuzz" case 5,10 : > "Buzz" case 3,6,9,12 : > "Fizz" default : > i end
end</lang>
FALSE
<lang false>[\$@$@\/*=]d: [1\$3d;!["Fizz"\%0\]?$5d;!["Buzz"\%0\]?\[$.]?" "]f: 0[$100\>][1+f;!]#%</lang>
Fantom
<lang fantom>class FizzBuzz {
public static Void main () { for (Int i:=1; i <= 100; ++i) { if (i % 15 == 0) echo ("FizzBuzz") else if (i % 3 == 0) echo ("Fizz") else if (i % 5 == 0) echo ("Buzz") else echo (i) } }
}</lang>
FBSL
No 'MOD 15' needed. <lang qbasic>#APPTYPE CONSOLE
DIM numbers AS STRING DIM imod5 AS INTEGER DIM imod3 AS INTEGER
FOR DIM i = 1 TO 100
numbers = "" imod3 = i MOD 3 imod5 = i MOD 5 IF NOT imod3 THEN numbers = "Fizz" IF NOT imod5 THEN numbers = numbers & "Buzz" IF imod3 AND imod5 THEN numbers = i PRINT numbers, " ";
NEXT
PAUSE</lang> Output:
1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17 Fizz 19 Buzz Fiz z 22 23 Fizz Buzz 26 Fizz 28 29 FizzBuzz 31 32 Fizz 34 Buzz Fizz 37 38 Fizz Buzz 41 Fizz 43 44 FizzBuzz 46 47 Fizz 49 Buzz Fizz 52 53 Fizz Buzz 56 Fizz 58 59 Fi zzBuzz 61 62 Fizz 64 Buzz Fizz 67 68 Fizz Buzz 71 Fizz 73 74 FizzBuzz 76 77 Fizz 79 Buzz Fizz 82 83 Fizz Buzz 86 Fizz 88 89 FizzBuzz 91 92 Fizz 94 Buzz Fizz 97 98 Fizz Buzz Press any key to continue...
Forth
table-driven
<lang forth>: fizz ( n -- ) drop ." Fizz" ;
- buzz ( n -- ) drop ." Buzz" ;
- fb ( n -- ) drop ." FizzBuzz" ;
- vector create does> ( n -- )
over 15 mod cells + @ execute ;
vector .fizzbuzz
' fb , ' . , ' . , ' fizz , ' . , ' buzz , ' fizz , ' . , ' . , ' fizz , ' buzz , ' . , ' fizz , ' . , ' . ,</lang>
or the classic approach
<lang forth>: .fizzbuzz ( n -- )
0 pad c! dup 3 mod 0= if s" Fizz" pad place then dup 5 mod 0= if s" Buzz" pad +place then pad c@ if drop pad count type else . then ;
- zz ( n -- )
1+ 1 do i .fizzbuzz cr loop ;
100 zz</lang>
the well factored approach
SYNONYM is a Forth200x word.
<lang forth>SYNONYM NOT INVERT \ Bitwise boolean not
- Fizz? ( n -- ? ) 3 MOD 0= DUP IF ." Fizz" THEN ;
- Buzz? ( n -- ? ) 5 MOD 0= DUP IF ." Buzz" THEN ;
- ?print ( n ? -- ) IF . THEN ;
- FizzBuzz ( -- )
101 1 DO CR I DUP Fizz? OVER Buzz? OR NOT ?print LOOP ;
FizzBuzz</lang>
Fortran
In ANSI FORTRAN 77 or later use structured IF-THEN-ELSE (example uses some ISO Fortran 90 features): <lang fortran>program fizzbuzz_if
integer :: i do i = 1, 100 if (mod(i,15) == 0) then; print *, 'FizzBuzz' else if (mod(i,3) == 0) then; print *, 'Fizz' else if (mod(i,5) == 0) then; print *, 'Buzz' else; print *, i end if end do
end program fizzbuzz_if</lang> In ISO Fortran 90 or later use SELECT-CASE statement: <lang fortran>program fizzbuzz_select
integer :: i do i = 1, 100 select case (mod(i,15)) case 0; print *, 'FizzBuzz' case 3,6,9,12; print *, 'Fizz' case 5,10; print *, 'Buzz' case default; print *, i end select end do end program fizzbuzz_select</lang>
Frink
<lang frink> for i = 1 to 100 {
flag = false if i mod 3 == 0 { flag = true print["Fizz"] } if i mod 5 == 0 { flag = true print["Buzz"] }
if flag == false print[i]
println[]
} </lang>
GAP
<lang gap>FizzBuzz := function() local i; for i in [1 .. 100] do if RemInt(i, 15) = 0 then Print("FizzBuzz\n"); elif RemInt(i, 3) = 0 then Print("Fizz\n"); elif RemInt(i, 5) = 0 then Print("Buzz\n"); else Print(i, "\n"); fi; od; end;</lang>
Go
<lang go> package main
import "fmt"
func main() {
for i := 1; i <= 100; i++ { switch { case i%15==0: fmt.Println("FizzBuzz") case i%3==0: fmt.Println("Fizz") case i%5==0: fmt.Println("Buzz") default: fmt.Println(i) } }
} </lang>
Gosu
<lang gosu>for (i in 1..100) {
if (i % 3 == 0 && i % 5 == 0) { print("FizzBuzz") continue } if (i % 3 == 0) { print("Fizz") continue } if (i % 5 == 0) { print("Buzz") continue } // default print(i)
}</lang>
One liner version (I added new lines to better readability but when you omit them it's one liner): <lang gosu>// note that compiler reports error (I don't know why) but still it's working for (i in 1..100) {
print(i % 5 == 0 ? i % 3 == 0 ? "FizzBuzz" : "Buzz" : i % 3 == 0 ? "Fizz" : i)
}</lang>
Groovy
<lang groovy>for (i in 1..100) {
println "${i%3?:'Fizz'}${i%5?:'Buzz'}" ?: i
}</lang>
Haskell
Variant directly implementing the specification: <lang haskell>main = mapM_ (putStrLn . fizzbuzz) [1..100]
fizzbuzz x
| x `mod` 15 == 0 = "FizzBuzz" | x `mod` 3 == 0 = "Fizz" | x `mod` 5 == 0 = "Buzz" | otherwise = show x</lang>
<lang haskell> main = putStr $ concat $ map fizzbuzz [1..100]
fizzbuzz n =
"\n" ++ if null (fizz++buzz) then show n else fizz++buzz where fizz = if mod n 3 == 0 then "Fizz" else "" buzz = if mod n 5 == 0 then "Buzz" else ""
</lang>
Does not perform the mod 15 step, extesible to arbitrary addtional tests, ex: [bar| n `mod` 7 == 0]. <lang haskell>main = mapM_ (putStrLn . fizzbuzz) [1..100]
fizzbuzz n =
show n <|> [fizz| n `mod` 3 == 0] ++ [buzz| n `mod` 5 == 0]
-- A simple default choice operator. -- Defaults if both fizz and buzz fail, concats if any succeed. infixr 0 <|> d <|> [] = d _ <|> x = concat x
fizz = "Fizz" buzz = "Buzz" </lang>
Alternate implementation using lazy infinite lists and avoiding use of "mod": <lang haskell> main = mapM_ putStrLn $ take 100 $ zipWith show_number_or_fizzbuzz [1..] fizz_buzz_list
show_number_or_fizzbuzz x y = if null y then show x else y
fizz_buzz_list = zipWith (++) (cycle ["","","Fizz"]) (cycle ["","","","","Buzz"]) </lang>
Using heavy artillery (needs the mtl package): <lang haskell> import Control.Monad.State import Control.Monad.Trans import Control.Monad.Writer
main = putStr $ execWriter $ mapM_ (flip execStateT True . fizzbuzz) [1..100]
fizzbuzz :: Int -> StateT Bool (Writer String) () fizzbuzz x = do
when (x `mod` 3 == 0) $ tell "Fizz" >> put False when (x `mod` 5 == 0) $ tell "Buzz" >> put False get >>= (flip when $ tell $ show x) tell "\n"
</lang>
Using guards plus where. <lang haskell>fizzBuzz :: (Integral a) => a -> String fizzBuzz i
| fizz && buzz = "FizzBuzz" | fizz = "Fizz" | buzz = "Buzz" | otherwise = show i where fizz = i `mod` 3 == 0 buzz = i `mod` 5 == 0
main = mapM_ (putStrLn . fizzBuzz) [1..100]</lang>
HicEst
<lang hicest>DO i = 1, 100
IF( MOD(i, 15) == 0 ) THEN WRITE() "FizzBuzz" ELSEIF( MOD(i, 5) == 0 ) THEN WRITE() "Buzz" ELSEIF( MOD(i, 3) == 0 ) THEN WRITE() "Fizz" ELSE WRITE() i ENDIF
ENDDO</lang> Alternatively: <lang hicest>CHARACTER string*8
DO i = 1, 100
string = " " IF( MOD(i, 3) == 0 ) string = "Fizz" IF( MOD(i, 5) == 0 ) string = TRIM(string) // "Buzz" IF( string == " ") WRITE(Text=string) i WRITE() string
ENDDO</lang>
Icon and Unicon
<lang icon># straight-forward modulo tester procedure main()
every i := 1 to 100 do if i % 15 = 0 then write("FizzBuzz") else if i % 5 = 0 then write("Buzz") else if i % 3 = 0 then write("Fizz") else write(i)
end</lang> <lang icon># idiomatic modulo tester, 1st alternative procedure main()
every i := 1 to 100 do write((i % 15 = 0 & "FizzBuzz") | (i % 5 = 0 & "Buzz") | (i % 3 = 0 & "Fizz") | i)
end</lang> <lang icon># idiomatic modulo tester, 2nd alternative procedure main()
every i := 1 to 100 do write(case 0 of { i % 15 : "FizzBuzz" i % 5 : "Buzz" i % 3 : "Fizz" default: i })
end</lang> <lang icon># straight-forward buffer builder procedure main()
every i := 1 to 100 do { s := "" if i % 3 = 0 then s ||:= "Fizz" if i % 5 = 0 then s ||:= "Buzz" if s == "" then s := i write(s) }
end</lang> <lang icon># idiomatic buffer builder, 1st alternative procedure main() every i := 1 to 100 do write("" ~== (if i % 3 = 0 then "Fizz" else "") || (if i % 5 == 0 then "Buzz" else "") | i) end</lang> <lang icon># idiomatic buffer builder, 2nd alternative procedure main()
every i := 1 to 100 do { s := if i%3 = 0 then "Fizz" else "" s ||:= if i%5 = 0 then "Buzz" write(("" ~= s) | i) }
end</lang>
Inform 6
<lang inform6>[ Main i;
for(i = 1: i <= 100: i++) { if(i % 3 == 0) print "Fizz"; if(i % 5 == 0) print "Buzz"; if(i % 3 ~= 0 && i % 5 ~= 0) print i;
print "^"; }
];</lang>
Inform 7
<lang inform7>Home is a room.
When play begins: repeat with N running from 1 to 100: let printed be false; if the remainder after dividing N by 3 is 0: say "Fizz"; now printed is true; if the remainder after dividing N by 5 is 0: say "Buzz"; now printed is true; if printed is false, say N; say "."; end the story.</lang>
Io
Here's one way to do it: <lang io>for(a,1,100,
if(a % 15 == 0) then( "FizzBuzz" println ) elseif(a % 3 == 0) then( "Fizz" println ) elseif(a % 5 == 0) then( "Buzz" println ) else ( a println )
)</lang> And here's a port of the Ruby version, which I personally prefer: <lang io>a := 0; b := 0 for(n, 1, 100,
if(a = (n % 3) == 0, "Fizz" print); if(b = (n % 5) == 0, "Buzz" print); if(a not and b not, n print); "\n" print
)</lang> And here is another more idiomatic version: <lang Io>for (n, 1, 100,
fb := list ( if (n % 3 == 0, "Fizz"), if (n % 5 == 0, "Buzz")) select (isTrue) if (fb isEmpty, n, fb join) println
)</lang>
Ioke
<lang ioke>(1..100) each(x,
cond( (x % 15) zero?, "FizzBuzz" println, (x % 3) zero?, "Fizz" println, (x % 5) zero?, "Buzz" println )
)</lang>
Iptscrae
Written in Iptscrae, the scripting language for The Palace chat software. <lang iptscrae>; FizzBuzz in Iptscrae 1 a = {
"" b = { "fizz" b &= } a 3 % 0 == IF { "buzz" b &= } a 5 % 0 == IF { a ITOA LOGMSG } { b LOGMSG } b STRLEN 0 == IFELSE a ++
} { a 100 <= } WHILE</lang>
J
Solution _1: Using agenda (@.) as a switch: <lang j>
test =: +/@(1 2 * 0 = 3 5&|~) (":@]`('Fizz'"_)`('Buzz'"_)`('FizzBuzz'"_) @. test"0) >:i.100
</lang>
Solution 0
<lang j>> }. (<'FizzBuzz') (I.0=15|n)} (<'Buzz') (I.0=5|n)} (<'Fizz') (I.0=3|n)} ":&.> n=: i.101</lang>
Solution 1
<lang j>Fizz=: 'Fizz' #~ 0 = 3&|
Buzz=: 'Buzz' #~ 0 = 5&|
FizzBuzz=: ": [^:( -: ]) Fizz,Buzz
FizzBuzz"0 >: i.100</lang> Solution 2 (has taste of table-driven template programming) <lang j>CRT0=: 2 : ' (, 0 = +./)@(0 = m | ]) ;@# n , <@": ' NB. Rather (, 0 = +./) than (, +:/) because designed for NB. 3 5 7 CRT0 (;:'Chinese Remainder Period') "0 >: i. */3 5 7 FizzBuzz=: 3 5 CRT0 (;:'Fizz Buzz')
FizzBuzz"0 >: i.100</lang> Solution 3 (depends on an obsolete feature of @ in f`g`h@p) <lang j>'`f b fb' =: ('Fizz'"_) ` ('Buzz'"_) ` (f , b) '`cm3 cm5 cm15'=: (3&|) ` (5&|) ` (15&|) (0&=@) FizzBuzz=: ": ` f @. cm3 ` b @. cm5 ` fb @. cm15 NB. also: FizzBuzz=: ": ` f @. cm3 ` b @. cm5 ` (f,b) @. (cm3 *. cm5)
FizzBuzz"0 >: i.100</lang>
Java
If/else ladder
<lang java>public class FizzBuzz{ public static void main(String[] args){ for(int i= 1; i <= 100; i++){ if(i % 15 == 0){ System.out.println("FizzBuzz"); }else if(i % 3 == 0){ System.out.println("Fizz"); }else if(i % 5 == 0){ System.out.println("Buzz"); }else{ System.out.println(i); } } } }</lang>
Concatenation
<lang java>public class FizzBuzz{ public static void main(String[] args){ for(int i= 1; i <= 100; i++){ String output = ""; if(i % 3 == 0) output += "Fizz"; if(i % 5 == 0) output += "Buzz"; if(output.equals("")) output += i; System.out.println(output); } } }</lang>
Ternary operator
<lang java>public class FizzBuzz{ public static void main(String[] args){ for(int i= 1; i <= 100; i++){ System.out.println(i % 15 != 0 ? i % 5 != 0 ? i % 3 != 0 ? i : "Fizz" : "Buzz" : "FizzBuzz"); } } }</lang>
Recursive
<lang java>public String fizzBuzz(int n){
String s = ""; if (n == 0) return s; if((n % 5) == 0) s = "Buzz" + s; if((n % 3) == 0) s = "Fizz" + s; if (s.equals("")) s = n + ""; return fizzBuzz(n-1) + s;
}</lang>
Alternative Recursive
<lang java>public String fizzBuzz(int n){
return (n>0) ? fizzBuzz(n-1) + (n % 15 != 0? n % 5 != 0? n % 3 != 0? (n+"") :"Fizz" : "Buzz" : "FizzBuzz") : "";
}</lang>
Using an array
<lang java>class FizzBuzz {
public static void main( String [] args ) { for( int i = 1 ; i <= 100 ; i++ ) { System.out.println( new String[]{ i+"", "Fizz", "Buzz", "FizzBuzz" }[ ( i%3==0?1:0 ) + ( i%5==0?2:0 ) ]); } }
}</lang>
JavaScript
<lang javascript>for (var i = 1; i <= 100; i++) {
if (i % 15 == 0) { console.log("FizzBuzz"); } else if (i % 3 == 0) { console.log("Fizz"); } else if (i % 5 == 0) { console.log("Buzz"); } else { console.log(i); }
}
// ------------------ // functional version // ------------------ (function (n) {
var r = []; while (n--) { r.push(n + 1); } return r.reverse(); })(100).map(function (n) { return !(n % 15) ? 'FizzBuzz' : !(n % 3) ? 'Fizz' : !(n % 5) ? 'Buzz' : n; }).join('\r\n');</lang>
Alternative version (one-liner)
<lang javascript>for (var i=1; i<=100; i++) console.log( (i % 3 === 0 ? 'Fizz' : ) + (i % 5 === 0 ? 'Buzz' : ) || i );</lang>
Bodyless for loop
<lang javascript>for(var i=1; i<=100; console.log((i%3?:'Fizz')+(i%5?:'Buzz')||i), i++);</lang>
A little shorter
<lang javascript>for(i=0;i<100;console.log(++i%15?i%5?i%3?i:f='Fizz':b='Buzz':f+b));</lang>
Compiled from CoffeeScript One-Liner
<lang javascript>(function() {
var i;
for (i = 1; i <= 100; i++) { console.log([i % 3 === 0 ? 'Fizz' : void 0] + [i % 5 === 0 ? 'Buzz' : void 0] || i); }
}).call(this);</lang>
Zombie Version
Zombie -> decomposed.
Tries to avoid 'wall of code' by decomposition, creation of a solution-based language, generalization.
"Simplicity, clarity, generality" -- Pike & Kernighan
Runs under SpiderMonkey.
<lang javascript> var divs = [15, 3, 5]; var says = ['FizzBuzz', 'Fizz', 'Buzz'];
function fizzBuzz(first, last) {
for (var n = first; n <= last; n++) { print(getFizzBuzz(n)); }
}
function getFizzBuzz(n) {
var sayWhat = n; for (var d = 0; d < divs.length; d++) { if (isMultOf(n, divs[d])) { sayWhat = says[d]; break; } } return sayWhat;
}
function isMultOf(n, d) {
return n % d == 0;
}
fizzBuzz(1, 100); </lang>
Notice: This is satire. (Isn't it?)
Joy
The following program first defines a function "one", which handles the Fizz / Buzz logic, and then loops from 1 to 100 mapping the function onto each number, and printing ("put") the output.
<lang Joy> DEFINE one == [[[dup 15 rem 0 =] "FizzBuzz"] [[dup 3 rem 0 =] "Fizz"] [[dup 5 rem 0 =] "Buzz"] [dup]] cond. 1 [100 <=] [dup one put succ] while. </lang>
Julia
<lang Julia> for i = 1:100
if i % 15 == 0 println("FizzBuzz") elseif i % 3 == 0 println("Fizz") elseif i % 5 == 0 println("Buzz") else println(i) end
end </lang>
Another solution
<lang Julia> println( [ i%15 == 0? "FizzBuzz" :
i%5 == 0? "Buzz" : i%3 == 0? "Fizz" : i for i = 1:100 ] )
</lang>
K
<lang k>`0:\:{:[0=#a:{,/$(:[0=x!3;"Fizz"];:[0=x!5;"Buzz"])}@x;$x;a]}'1_!101</lang>
Kaya
<lang kaya>// fizzbuzz in Kaya program fizzbuzz;
Void fizzbuzz(Int size) {
for i in [1..size] { if (i % 15 == 0) { putStrLn("FizzBuzz"); } else if (i % 5 == 0) { putStrLn("Buzz"); } else if (i % 3 == 0) { putStrLn("Fizz"); } else { putStrLn( string(i) ); } }
}
Void main() {
fizzbuzz(100);
}</lang>
LabVIEW
This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.
Lasso
<lang lasso>with i in generateSeries(1, 100) select ((#i % 3 == 0 ? 'Fizz' | ) + (#i % 5 == 0 ? 'Buzz' | ) || #i)</lang>
Liberty BASIC
<lang lb>for i = 1 to 100
select case case i mod 15 = 0 print "FizzBuzz" case i mod 3 = 0 print "Fizz" case i mod 5 = 0 print "Buzz" case else print i end select
next i</lang>
LiveScript
See: http://livescript.net/blog/fizzbuzzbazz.html
<lang LiveScript>[1 to 100]map ->[k+\zz for k,v of{Fi:3,Bu:5}|it%v<1]*||it</lang>
Logo
<lang logo>to fizzbuzz :n
output cond [ [[equal? 0 modulo :n 15] "FizzBuzz] [[equal? 0 modulo :n 5] "Buzz] [[equal? 0 modulo :n 3] "Fizz] [else :n] ]
end
repeat 100 [print fizzbuzz #]</lang> "cond" was undefined in Joshua Bell's online interpreter. So here is a version that works there. It also works in UCB logo by using # instead of "repcount". This version also factors away modulo 15: <lang logo>to fizzbuzz :n
make "c " if equal? 0 modulo :n 5 [make "c "Buzz] if equal? 0 modulo :n 3 [make "c word "Fizz :c] output ifelse equal? :c " [:n] [:c]
end
repeat 100 [print fizzbuzz repcount]</lang>
Lhogho can use the above code, except that 'modulo' must be replaced with 'remainder'.
LOLCODE
<lang LOLCODE>HAI 1.3
IM IN YR fizz UPPIN YR i TIL BOTH SAEM i AN 100
I HAS A i ITZ SUM OF i AN 1 BTW, ALL LUPZ START AT 0 :/ I HAS A mod3 ITZ NOT MOD OF i AN 3 I HAS A mod5 ITZ NOT MOD OF i AN 5
mod3, O RLY?, YA RLY, VISIBLE "Fizz"!, OIC mod5, O RLY?, YA RLY, VISIBLE "Buzz"!, OIC
NOT EITHER OF mod3 AN mod5, O RLY? YA RLY, VISIBLE i! OIC
VISIBLE ""
IM OUTTA YR fizz
KTHXBYE</lang>
LSE
<lang LSE> 1* FIZZBUZZ en L.S.E. 10 CHAINE FB 20 FAIRE 45 POUR I_1 JUSQUA 100 30 FB_SI &MOD(I,3)=0 ALORS SI &MOD(I,5)=0 ALORS 'FIZZBUZZ' SINON 'FIZZ' SINON SI &MOD(I,5)=0 ALORS 'BUZZ' SINON 40 AFFICHER[U,/] SI FB= ALORS I SINON FB 45*FIN BOUCLE 50 TERMINER 100 PROCEDURE &MOD(A,B) LOCAL A,B 110 RESULTAT A-B*ENT(A/B) </lang>
Lua
If/else Ladder
<lang Lua>for i = 1, 100 do if i % 15 == 0 then print("FizzBuzz") elseif i % 3 == 0 then print("Fizz") elseif i % 5 == 0 then print("Buzz") else print(i) end end</lang>
Concatenation
<lang Lua>for i = 1, 100 do output = "" if i % 3 == 0 then output = output.."Fizz" end if i % 5 == 0 then output = output.."Buzz" end if(output == "") then output = output..i end print(output) end</lang>
Quasi bit field
<lang Lua>word = {"Fizz", "Buzz", "FizzBuzz"}
for i = 1, 100 do
print(word[(i % 3 == 0 and 1 or 0) + (i % 5 == 0 and 2 or 0)] or i)
end</lang>
M4
<lang M4>define(`for',
`ifelse($#,0,``$0, `ifelse(eval($2<=$3),1, `pushdef(`$1',$2)$5`'popdef(`$1')$0(`$1',eval($2+$4),$3,$4,`$5')')')')
for(`x',1,100,1,
`ifelse(eval(x%15==0),1,FizzBuzz, `ifelse(eval(x%3==0),1,Fizz, `ifelse(eval(x%5==0),1,Buzz,x)')')
')</lang>
make
<lang make>MOD3 = 0 MOD5 = 0 ALL != jot 100
all: say-100
.for NUMBER in $(ALL)
MOD3 != expr \( $(MOD3) + 1 \) % 3; true MOD5 != expr \( $(MOD5) + 1 \) % 5; true
. if "$(NUMBER)" > 1 PRED != expr $(NUMBER) - 1 say-$(NUMBER): say-$(PRED) . else say-$(NUMBER): . endif . if "$(MOD3)$(MOD5)" == "00" @echo FizzBuzz . elif "$(MOD3)" == "0" @echo Fizz . elif "$(MOD5)" == "0" @echo Buzz . else @echo $(NUMBER) . endif
.endfor</lang>
Mathematica
<lang Mathematica>Do[Print[Which[Mod[i, 15] == 0, "FizzBuzz", Mod[i, 5] == 0, "Buzz", Mod[i, 3] == 0, "Fizz", True, i]], {i, 100}]</lang> Using rules, <lang Mathematica>fizz[i_] := Mod[i, 3] == 0 buzz[i_] := Mod[i, 5] == 0 Range[100] /. {i_ /; fizz[i]&&buzz[i] :> "FizzBuzz", \
i_?fizz :> "Fizz", i_?buzz :> "Buzz"}
</lang>
Using rules, but different approach: <lang Mathematica>SetAttributes[f,Listable] f[n_ /; Mod[n, 15] == 0] := "FizzBuzz"; f[n_ /; Mod[n, 3] == 0] := "Fizz"; f[n_ /; Mod[n, 5] == 0] := "Buzz"; f[n_] := n;
f[Range[100]] </lang>
An extendible version using Table <lang Mathematica>Table[If[# === "", i, #]&@StringJoin[
Table[If[Divisible[i, First@nw], Last@nw, ""], {nw, {{3, "Fizz"}, {5, "Buzz"}}}]], {i, 1, 100}]
</lang>
Another one-liner using Map (the /@ operator shorthand of it) and a pure function with a very readable Which <lang Mathematica> Which[ Mod[#,15] == 0, "FizzBuzz", Mod[#, 3] == 0, "Fizz", Mod[#,5]==0, "Buzz", True, #]& /@ Range[1,100] </lang>
MATLAB
There are more sophisticated solutions to this task, but in the spirit of "lowest level of comprehension required to illustrate adequacy" this is what one might expect from a novice programmer (with a little variation in how the strings are stored and displayed). <lang MATLAB>function fizzBuzz()
for i = (1:100) if mod(i,15) == 0 fprintf('FizzBuzz ') elseif mod(i,3) == 0 fprintf('Fizz ') elseif mod(i,5) == 0 fprintf('Buzz ') else fprintf('%i ',i)) end end fprintf('\n');
end</lang> Here's a more extendible version that uses disp() to print the output: <lang MATLAB>function out = fizzbuzzS() nums = [3, 5]; words = {'fizz', 'buzz'}; for (n=1:100) tempstr = ; for (i = 1:2) if mod(n,nums(i))==0 tempstr = [tempstr, words{i}]; end end if length(tempstr) == 0 disp(n); else disp(tempstr); end end end</lang>
Maxima
<lang maxima>for n thru 100 do
if mod(n, 15) = 0 then disp("FizzBuzz") elseif mod(n, 3) = 0 then disp("Fizz") elseif mod(n,5) = 0 then disp("Buzz") else disp(n);</lang>
MAXScript
<lang maxscript>for i in 1 to 100 do (
case of ( (mod i 15 == 0): (print "FizzBuzz") (mod i 5 == 0): (print "Buzz") (mod i 3 == 0): (print "Fizz") default: (print i) )
)</lang>
MEL
<lang mel>for($i=1; $i<=100; $i++) {
if($i % 15 == 0) print "FizzBuzz\n"; else if ($i % 3 == 0) print "Fizz\n"; else if ($i % 5 == 0) print "Buzz\n"; else print ($i + "\n");
}</lang>
Mercury
<lang mercury>:- module fizzbuzz.
- - interface.
- - import_module io.
- - pred main(io::di, io::uo) is det.
- - implementation.
- - import_module int, string, bool.
- - func fizz(int) = bool.
- - func buzz(int) = bool.
fizz(N) = ( if N mod 3 = 0 then yes else no ). buzz(N) = ( if N mod 5 = 0 then yes else no ).
- - pred fizzbuzz(int::in, bool::in, bool::in, string::out) is det.
% 3? 5? fizzbuzz(_, yes, yes, "FizzBuzz"). fizzbuzz(_, yes, no, "Fizz"). fizzbuzz(_, no, yes, "Buzz"). fizzbuzz(N, no, no, S) :- S = from_int(N).
main(!IO) :- main(1, 100, !IO).
- - pred main(int::in, int::in, io::di, io::uo) is det.
main(N, To, !IO) :- io.write_string(S, !IO), io.nl(!IO), fizzbuzz(N, fizz(N), buzz(N), S), ( if N < To then main(N + 1, To, !IO) else !:IO = !.IO ).</lang>
Metafont
<lang metafont>for i := 1 upto 100: message if i mod 15 = 0: "FizzBuzz" & elseif i mod 3 = 0: "Fizz" & elseif i mod 5 = 0: "Buzz" & else: decimal i & fi ""; endfor end</lang>
Mirah
<lang mirah>1.upto(100) do |n|
print "Fizz" if a = ((n % 3) == 0) print "Buzz" if b = ((n % 5) == 0) print n unless (a || b) print "\n"
end
- a little more straight forward
1.upto(100) do |n|
if (n % 15) == 0 puts "FizzBuzz" elsif (n % 5) == 0 puts "Buzz" elsif (n % 3) == 0 puts "Fizz" else puts n end
end</lang>
MMIX
<lang mmix>t IS $255 Ja IS $127
LOC Data_Segment
data GREG @
fizz IS @-Data_Segment
BYTE "Fizz",0,0,0,0
buzz IS @-Data_Segment
BYTE "Buzz",0,0,0,0
nl IS @-Data_Segment
BYTE #a,0,0,0,0,0,0,0
buffer IS @-Data_Segment
LOC #1000 GREG @
% "usual" print integer subroutine printnum LOC @
OR $1,$0,0 SETL $2,buffer+64 ADDU $2,$2,data XOR $3,$3,$3 STBU $3,$2,1
loop DIV $1,$1,10
GET $3,rR ADDU $3,$3,'0' STBU $3,$2,0 SUBU $2,$2,1 PBNZ $1,loop ADDU t,$2,1 TRAP 0,Fputs,StdOut GO Ja,Ja,0
Main SETL $0,1 % i = 1 1H SETL $2,0 % fizz not taken
CMP $1,$0,100 % i <= 100 BP $1,4F % if no, go to end DIV $1,$0,3 GET $1,rR % $1 = mod(i,3) CSZ $2,$1,1 % $2 = Fizz taken? BNZ $1,2F % $1 != 0? yes, then skip ADDU t,data,fizz TRAP 0,Fputs,StdOut % print "Fizz"
2H DIV $1,$0,5
GET $1,rR % $1 = mod(i,5) BNZ $1,3F % $1 != 0? yes, then skip ADDU t,data,buzz TRAP 0,Fputs,StdOut % print "Buzz" JMP 5F % skip print i
3H BP $2,5F % skip if Fizz was taken
GO Ja,printnum % print i
5H ADDU t,data,nl
TRAP 0,Fputs,StdOut % print newline ADDU $0,$0,1 JMP 1B % repeat for next i
4H XOR t,t,t
TRAP 0,Halt,0 % exit(0)</lang>
Modula-3
<lang modula3>MODULE Fizzbuzz EXPORTS Main;
IMPORT IO;
BEGIN
FOR i := 1 TO 100 DO IF i MOD 15 = 0 THEN IO.Put("FizzBuzz\n"); ELSIF i MOD 5 = 0 THEN IO.Put("Buzz\n"); ELSIF i MOD 3 = 0 THEN IO.Put("Fizz\n"); ELSE IO.PutInt(i); IO.Put("\n"); END; END;
END Fizzbuzz.</lang>
MUMPS
<lang MUMPS>FIZZBUZZ
NEW I FOR I=1:1:100 WRITE !,$SELECT(('(I#3)&'(I#5)):"FizzBuzz",'(I#5):"Buzz",'(I#3):"Fizz",1:I) KILL I QUIT</lang>
Nemerle
The naive approach: <lang Nemerle>using System; using System.Console;
module FizzBuzz {
FizzBuzz(x : int) : string { |x when x % 15 == 0 => "FizzBuzz" |x when x % 5 == 0 => "Buzz" |x when x % 3 == 0 => "Fizz" |_ => $"$x" } Main() : void { foreach (i in [1 .. 100]) WriteLine($"$(FizzBuzz(i))") }
}</lang> A much slicker approach is posted here
NetRexx
<lang netrexx>loop j=1 for 100
select when j//15==0 then say 'FizzBuzz' when j//5==0 then say 'Buzz' when j//3==0 then say 'Fizz' otherwise say j.right(4) end
end</lang>
NewtonScript
<lang>for i := 1 to 100 do begin if i mod 15 = 0 then print("FizzBuzz") else if i mod 3 = 0 then print("Fizz") else if i mod 5 = 0 then print("Buzz") else print(i); print("\n") end</lang>
Nickle
<lang nickle>/* Fizzbuzz in nickle */
void function fizzbuzz(size) {
for (int i = 1; i < size; i++) { if (i % 15 == 0) { printf("Fizzbuzz\n"); } else if (i % 5 == 0) { printf("Buzz\n"); } else if (i % 3 == 0) { printf("Fizz\n"); } else { printf("%i\n", i); } }
}
fizzbuzz(1000);</lang>
Nimrod
<lang nimrod>for i in 1..100:
if i mod 15 == 0: echo("FizzBuzz") elif i mod 3 == 0: echo("Fizz") elif i mod 5 == 0: echo("Buzz") else: echo(i)</lang>
Without Modulus
<lang nimrod>var messages = @["", "Fizz", "Buzz", "FizzBuzz"] var acc = 810092048 for i in 1..100:
var c = acc and 3 echo(if c == 0: $i else: messages[c]) acc = acc shr 2 or c shl 28</lang>
Oberon-2
<lang oberon2>MODULE FizzBuzz;
IMPORT Out;
VAR i: INTEGER;
BEGIN
FOR i := 1 TO 100 DO IF i MOD 15 = 0 THEN Out.String("FizzBuzz"); Out.Ln; ELSIF i MOD 5 = 0 THEN Out.String("Buzz"); Out.Ln; ELSIF i MOD 3 = 0 THEN Out.String("Fizz"); Out.Ln; ELSE Out.Int(i,0); Out.Ln; END; END;
END FizzBuzz.</lang>
Objeck
<lang objeck>bundle Default {
class Fizz { function : Main(args : String[]) ~ Nil { for(i := 0; i <= 100; i += 1;) { if(i % 15 = 0) { "FizzBuzz"->PrintLine(); } else if(i % 3 = 0) { "Fizz"->PrintLine(); } else if(i % 5 = 0) { "Buzz"->PrintLine(); } else { i->PrintLine(); }; }; } }
}</lang>
Objective-C
<lang c>// FizzBuzz in Objective-C
- import <stdio.h>
main() { for (int i=1; i<=100; i++) { if (i % 15 == 0) { printf("FizzBuzz\n"); } else if (i % 3 == 0) { printf("Fizz\n"); } else if (i % 5 == 0) { printf("Buzz\n"); } else { printf("%i\n", i); } } }</lang>
OCaml
<lang ocaml>let output x =
match x mod 3 = 0, x mod 5 = 0 with true, true -> "FizzBuzz" | true, false -> "Fizz" | false, true -> "Buzz" | false, false -> string_of_int x
let _ =
for i = 1 to 100 do print_endline (output i) done</lang>
Octave
<lang octave>for i = 1:100
if ( mod(i,15) == 0 ) disp("FizzBuzz"); elseif ( mod(i, 3) == 0 ) disp("Fizz") elseif ( mod(i, 5) == 0 ) disp("Buzz") else disp(i) endif
endfor</lang>
OOC
<lang ooc>fizz: func (n: Int) -> Bool {
if(n % 3 == 0) { printf("Fizz") return true } return false
}
buzz: func (n: Int) -> Bool {
if(n % 5 == 0) { printf("Buzz") return true } return false
}
main: func {
for(n in 1..100) { fizz:= fizz(n) buzz:= buzz(n) fizz || buzz || printf("%d", n) println() }
} </lang>
Order
<lang c>#include <order/interpreter.h>
// Get FB for one number
- define ORDER_PP_DEF_8fizzbuzz ORDER_PP_FN( \
8fn(8N, \
8let((8F, 8fn(8N, 8G, \ 8is_0(8remainder(8N, 8G)))), \ 8cond((8ap(8F, 8N, 15), 8quote(fizzbuzz)) \ (8ap(8F, 8N, 3), 8quote(fizz)) \ (8ap(8F, 8N, 5), 8quote(buzz)) \ (8else, 8N)))) )
// Print E followed by a comma (composable, 8print is not a function)
- define ORDER_PP_DEF_8print_el ORDER_PP_FN( \
8fn(8E, 8print(8E 8comma)) )
ORDER_PP( // foreach instead of map, to print but return nothing
8seq_for_each(8compose(8print_el, 8fizzbuzz), 8seq_iota(1, 100))
)</lang>
Oz
<lang oz>declare
fun {FizzBuzz X} if X mod 15 == 0 then 'FizzBuzz' elseif X mod 3 == 0 then 'Fizz' elseif X mod 5 == 0 then 'Buzz' else X end end
in
for I in 1..100 do {Show {FizzBuzz I}} end</lang>
PARI/GP
<lang parigp>{for(n=1,100,
print(if(n%3, if(n%5, n , "Buzz" ) , if(n%5, "Fizz" , "FizzBuzz" ) ))
)}</lang>
Pascal
<lang pascal>program fizzbuzz(output); var
i: integer;
begin
for i := 1 to 100 do if i mod 15 = 0 then writeln('FizzBuzz') else if i mod 3 = 0 then writeln('Fizz') else if i mod 5 = 0 then writeln('Buzz') else writeln(i)
end.</lang>
Perl
<lang perl>#!/usr/bin/perl
use strict; use warnings;
use feature qw/say/;
foreach my $i (1 .. 100) {
say + (0 == $i % 15) ? "FizzBuzz" : (0 == $i % 3) ? "Fizz" : (0 == $i % 5) ? "Buzz" : $i ;
}</lang> More concisely: <lang perl>print 'Fizz'x!($_ % 3) . 'Buzz'x!($_ % 5) || $_, "\n" for 1 .. 100;</lang> For code-golfing: <lang perl>print+(Fizz)[$_%3].(Buzz)[$_%5]||$_,$/for 1..1e2</lang> For array of values: <lang perl>map((Fizz)[$_%3].(Buzz)[$_%5]||$_,1..100);</lang>
Perl 6
Most straightforwardly: <lang perl6>for 1 .. 100 {
when $_ %% (3 & 5) { say 'FizzBuzz'; } when $_ %% 3 { say 'Fizz'; } when $_ %% 5 { say 'Buzz'; } default { .say; }
}</lang> Or abusing multi subs: <lang perl6>multi sub fizzbuzz(Int $ where * %% 15) { 'FizzBuzz' } multi sub fizzbuzz(Int $ where * %% 5) { 'Buzz' } multi sub fizzbuzz(Int $ where * %% 3) { 'Fizz' } multi sub fizzbuzz(Int $number ) { $number } (1 .. 100)».&fizzbuzz.join("\n").say;</lang> Most concisely: <lang perl6>say 'Fizz' x $_ %% 3 ~ 'Buzz' x $_ %% 5 || $_ for 1 .. 100;</lang> And here's an implementation that never checks for divisibility: <lang perl6>.say for
(( xx 2, 'Fizz') xx * Z~ ( xx 4, 'Buzz') xx *) Z|| 1 .. 100;</lang>
PHL
<lang phl>module fizzbuzz;
extern printf;
@Integer main [ var i = 1; while (i <= 100) { if (i % 15 == 0) printf("FizzBuzz"); else if (i % 3 == 0) printf("Fizz"); else if (i % 5 == 0) printf("Buzz"); else printf("%d", i);
printf("\n"); i = i::inc; }
return 0; ]</lang>
PHP
if/else ladder approach
<lang php><?php for ($i = 1; $i <= 100; $i++) {
if (!($i % 15)) echo "FizzBuzz\n"; else if (!($i % 3)) echo "Fizz\n"; else if (!($i % 5)) echo "Buzz\n"; else echo "$i\n";
} ?></lang>
concatenation approach
Uses PHP's concatenation operator (.=) to build the output string. The concatenation operator allows us to add data to the end of a string without overwriting the whole string. Since Buzz will always appear if our number is divisible by five, and Buzz is the second part of "FizzBuzz", we can simply append "Buzz" to our string.
In contrast to the if-else ladder, this method lets us skip the check to see if $i is divisible by both 3 and 5 (i.e. 15). However, we get the added complexity of needing to reset $str to an empty string (not necessary in some other languages), and we also need a separate if statement to check to see if our string is empty, so we know if $i was not divisible by 3 or 5. <lang php><?php for ( $i = 1; $i <= 100; ++$i ) {
$str = "";
if (!($i % 3 ) ) $str .= "Fizz";
if (!($i % 5 ) ) $str .= "Buzz";
if ( empty( $str ) ) $str = $i;
echo $str . "\n";
} ?></lang>
One Liner Approach
<lang php><?php for($i = 1; $i <= 100 and print(($i % 15 ? $i % 5 ? $i % 3 ? $i : 'Fizz' : 'Buzz' : 'FizzBuzz') . "\n"); ++$i); ?></lang>
PicoLisp
We could simply use 'at' here: <lang PicoLisp>(for N 100
(prinl (or (pack (at (0 . 3) "Fizz") (at (0 . 5) "Buzz")) N) ) )</lang>
Or do it the standard way: <lang PicoLisp>(for N 100
(prinl (cond ((=0 (% N 15)) "FizzBuzz") ((=0 (% N 3)) "Fizz") ((=0 (% N 5)) "Buzz") (T N) ) ) )</lang>
Pike
<lang pike>int main(){
for(int i = 1; i <= 100; i++) { if(i % 15 == 0) { write("FizzBuzz\n"); } else if(i % 3 == 0) { write("Fizz\n"); } else if(i % 5 == 0) { write("Buzz\n"); } else { write(i + "\n"); } }
}</lang>
PIR
<lang pir>.sub main :main
.local int f .local int mf .local int skipnum f = 1
LOOP:
if f > 100 goto DONE skipnum = 0 mf = f % 3 if mf == 0 goto FIZZ
FIZZRET:
mf = f % 5 if mf == 0 goto BUZZ
BUZZRET:
if skipnum > 0 goto SKIPNUM print f
SKIPNUM:
print "\n" inc f goto LOOP end
FIZZ:
print "Fizz" inc skipnum goto FIZZRET end
BUZZ:
print "Buzz" inc skipnum goto BUZZRET end
DONE:
end
.end</lang>
PL/I
<lang PL/I>do i = 1 to 100;
select; when (mod(i,15) = 0) put skip list ('FizzBuzz'); when (mod(i,3) = 0) put skip list ('Fizz'); when (mod(i,5) = 0) put skip list ('Buzz'); otherwise put skip list (i); end;
end;</lang>
Pop11
<lang pop11>lvars str; for i from 1 to 100 do
if i rem 15 = 0 then 'FizzBuzz' -> str; elseif i rem 3 = 0 then 'Fizz' -> str; elseif i rem 5 = 0 then 'Buzz' -> str; else >< i -> str; endif; printf(str, '%s\n');
endfor;</lang>
PL/SQL
<lang plsql>CREATE OR REPLACE PROCEDURE FIZZBUZZ AS
i NUMBER;
BEGIN
FOR i in 1 .. 100 LOOP IF MOD(i, 15) = 0 THEN DBMS_OUTPUT.PUT_LINE('FizzBuzz'); ELSIF MOD(i, 5) = 0 THEN DBMS_OUTPUT.PUT_LINE('Buzz'); ELSIF MOD(i, 3) = 0 THEN DBMS_OUTPUT.PUT_LINE('Fizz'); ELSE DBMS_OUTPUT.PUT_LINE(i); END IF; END LOOP;
END FIZZBUZZ;</lang>
PostScript
<lang postscript>1 1 100 { /c false def dup 3 mod 0 eq { (Fizz) print /c true def } if dup 5 mod 0 eq { (Buzz) print /c true def } if
c {pop}{( ) cvs print} ifelse (\n) print
} for</lang> or... <lang postscript>/fizzdict 100 dict def fizzdict begin /notmod{ ( ) cvs } def /mod15 { dup 15 mod 0 eq { (FizzBuzz)def }{pop}ifelse} def /mod3 { dup 3 mod 0 eq {(Fizz)def}{pop}ifelse} def /mod5 { dup 5 mod 0 eq {(Buzz)def}{pop}ifelse} def 1 1 100 { mod3 } for 1 1 100 { mod5 } for 1 1 100 { mod15} for 1 1 100 { dup currentdict exch known { currentdict exch get}{notmod} ifelse print (\n) print} for end</lang>
Potion
<lang lua> 1 to 100 (a):
if (a % 15 == 0): 'FizzBuzz'. elsif (a % 3 == 0): 'Fizz'. elsif (a % 5 == 0): 'Buzz'. else: a. string print "\n" print.
</lang>
PowerShell
Straightforward, looping
<lang powershell>for ($i = 1; $i -le 100; $i++) {
if ($i % 15 -eq 0) { "FizzBuzz" } elseif ($i % 5 -eq 0) { "Buzz" } elseif ($i % 3 -eq 0) { "Fizz" } else { $i }
}</lang>
Pipeline, Switch
<lang powershell>$txt=$null 1..100 | ForEach-Object {
switch ($_) { { $_ % 3 -eq 0 } { $txt+="Fizz" } { $_ % 5 -eq 0 } { $txt+="Buzz" } $_ { if($txt) { $txt } else { $_ }; $txt=$null } }
}</lang>
Concatenation
<lang powershell>1..100 | ForEach-Object {
$s = if ($_ % 3 -eq 0) { $s += "Fizz" } if ($_ % 5 -eq 0) { $s += "Buzz" } if (-not $s) { $s = $_ } $s
}</lang>
Prolog
Maybe not the most conventional way to write this in Prolog. The fizzbuzz predicate uses a higher-order predicate and print_item uses the if-then-else construction. <lang prolog>fizzbuzz :-
foreach(between(1, 100, X), print_item(X)).
print_item(X) :-
( 0 is X mod 15 -> print('FizzBuzz') ; 0 is X mod 3 -> print('Fizz') ; 0 is X mod 5 -> print('Buzz') ; print(X) ), nl.</lang>
More conventional: <lang prolog>fizzbuzz(X) :- 0 is X mod 15, write('FizzBuzz'). fizzbuzz(X) :- 0 is X mod 3, write('Fizz'). fizzbuzz(X) :- 0 is X mod 5, write('Buzz'). fizzbuzz(X) :- write(X).
dofizzbuzz :- foreach(between(1, 100, X), (fizzbuzz(X),nl)).</lang>
Clearer: <lang prolog>% N /3? /5? V fizzbuzz(_, yes, yes, 'FizzBuzz'). fizzbuzz(_, yes, no, 'Fizz'). fizzbuzz(_, no, yes, 'Buzz'). fizzbuzz(N, no, no, N).
% Unifies V with 'yes' if D divides evenly into N, 'no' otherwise. divisible_by(N, D, V) :-
( 0 is N mod D -> V = yes ; V = no).
% Print 'Fizz', 'Buzz', 'FizzBuzz' or N as appropriate. fizz_buzz_or_n(N) :-
divisible_by(N, 3, Fizz), divisible_by(N, 5, Buzz), fizzbuzz(N, Fizz, Buzz, FB), format("~p -> ~p~n", [N, FB]).
main :-
foreach(between(1,100, N), fizz_buzz_or_n(N)).</lang>
Protium
Variable-length padded English dialect <lang html><# DEFINE USERDEFINEDROUTINE LITERAL>__FizzBuzz|<# SUPPRESSAUTOMATICWHITESPACE> <# TEST ISITMODULUSZERO PARAMETER LITERAL>1|3</#> <# TEST ISITMODULUSZERO PARAMETER LITERAL>1|5</#> <# ONLYFIRSTOFLASTTWO><# SAY LITERAL>Fizz</#></#> <# ONLYSECONDOFLASTTWO><# SAY LITERAL>Buzz</#></#> <# BOTH><# SAY LITERAL>FizzBuzz</#></#> <# NEITHER><# SAY PARAMETER>1</#></#> </#></#> <# ITERATE FORITERATION LITERAL LITERAL>100|<# ACT USERDEFINEDROUTINE POSITION FORITERATION>__FizzBuzz|...</#> </#></lang> Fixed-length English dialect <lang html><@ DEFUDRLIT>__FizzBuzz|<@ SAW> <@ TSTMD0PARLIT>1|3</@> <@ TSTMD0PARLIT>1|5</@> <@ O12><@ SAYLIT>Fizz</@></@> <@ O22><@ SAYLIT>Buzz</@></@> <@ BTH><@ SAYLIT>FizzBuzz</@></@> <@ NTH><@ SAYPAR>1</@></@> </@></@> <@ ITEFORLITLIT>100|<@ ACTUDRPOSFOR>__FizzBuzz|...</@> </@></lang>
PureBasic
<lang purebasic>OpenConsole() For x = 1 To 100
If x%15 = 0 PrintN("FizzBuzz") ElseIf x%3 = 0 PrintN("Fizz") ElseIf x%5 = 0 PrintN("Buzz") Else PrintN(Str(x)) EndIf
Next Input()</lang>
Python
<lang python>for i in xrange(1, 101):
if i % 15 == 0: print "FizzBuzz" elif i % 3 == 0: print "Fizz" elif i % 5 == 0: print "Buzz" else: print i</lang>
Little shorter : <lang python>for n in range(1,101):
msg = "" if not (n%3): msg += "Fizz" if not (n%5): msg += "Buzz" print msg or str(n)</lang>
And a shorter, but less clear version, using a list comprehension and logical expressions: <lang python>for i in range(1, 101):
words = [word for n, word in ((3, 'Fizz'), (5, 'Buzz')) if not i % n] print .join(words) or i</lang>
Purely functional (and somewhat obfuscated). <lang python>print ('\n'.join(.join(.join([ if i%3 else 'Fizz',
if i%5 else 'Buzz']) or str(i)) for i in range(1,101)))</lang>
Short and without using 'if' conditional. Relies on casting int to bool and back again. Python 2.7.3. <lang python>for i in range(1, 101):
print 'Fizz'*(not(i%3))+'Buzz'*(not(i%5)) or i</lang>
Without modulus
I came across this crazy version[4] without using the modulus operator.
<lang python>messages = [None, "Fizz", "Buzz", "FizzBuzz"] acc = 810092048 for i in xrange(1, 101):
c = acc & 3 print messages[c] if c else i acc = acc >> 2 | c << 28</lang>
- Explanation
It relies on realizing that the occurrences of Fizz, Buzz, and FizzBuzz forms a repeating pattern of length 15. Arranging two bits to mean print the number, : print Fizz, : print Buzz, and : print FizzBuzz, you can encode 30 binary bits as constant 810092048. You can decode the lowest two bits to decide what to print then rotate them to the top of the constant for successive lines of print. <lang python>>>> ' '.join(.join(.join([ if i%3 else 'F',
if i%5 else 'B']) or str('00')) for i in range(1,16))
'00 00 F 00 B F 00 00 F B 00 F 00 00 FB' >>> _ '00 00 F 00 B F 00 00 F B 00 F 00 00 FB' >>> _.replace('FB','11').replace('F','01').replace('B','10').split()[::-1] ['11', '00', '00', '01', '00', '10', '01', '00', '00', '01', '10', '00', '01', '00', '00'] >>> '0b' + .join(_) '0b110000010010010000011000010000' >>> eval(_) 810092048 >>> </lang>
Or, from @natw https://gist.github.com/4079502
<lang python>import random
for i in range(0, 100):
if not i % 15: random.seed(1178741599) print [i+1, "Fizz", "Buzz", "FizzBuzz"][random.randint(0,3)]</lang>
Given the random character of this task, this is probably the most appropriate implementation.
Lazily
You can also create a lazy, unbounded sequence by using generator expressions: <lang python>from itertools import cycle, izip, count, islice
fizzes = cycle([""] * 2 + ["Fizz"]) buzzes = cycle([""] * 4 + ["Buzz"]) both = (f + b for f, b in izip(fizzes, buzzes))
- if the string is "", yield the number
- otherwise yield the string
fizzbuzz = (word or n for word, n in izip(both, count(1)))
- print the first 100
for i in islice(fizzbuzz, 100):
print i</lang>
R
<lang R>x <- 1:100 xx <- as.character(x) xx[x%%3==0] <- "Fizz" xx[x%%5==0] <- "Buzz" xx[x%%15==0] <- "FizzBuzz" xx</lang> Or, (ab)using the vector recycling rule: <lang R>x <- paste(rep("", 100), c("", "", "Fizz"), c("", "", "", "", "Buzz"), sep="") cat(ifelse(x == "", 1:100, x), "\n")</lang>
Or, with a more straightforward use of ifelse: <lang R> x <- 1:100 ifelse(x %% 15 == 0, 'FizzBuzz',
ifelse(x %% 5 == 0, 'Buzz', ifelse(x %% 3 == 0, 'Fizz', x)))
</lang>
Racket
<lang racket> (for ([n (in-range 1 101)])
(displayln (match (gcd n 15) [15 "fizzbuzz"] [3 "fizz"] [5 "buzz"] [_ n])))
</lang>
RapidQ
The BASIC solutions work with RapidQ, too. However, here is a bit more esoteric solution using the IIF() function. <lang rapidq>FOR i=1 TO 100
t$ = IIF(i MOD 3 = 0, "Fizz", "") + IIF(i MOD 5 = 0, "Buzz", "") PRINT IIF(LEN(t$), t$, i)
NEXT i</lang>
Rascal
<lang rascal>import IO;
public void fizzbuzz() {
for(int n <- [1 .. 100]){ fb = ((n % 3 == 0) ? "Fizz" : "") + ((n % 5 == 0) ? "Buzz" : ""); println((fb == "") ?"<n>" : fb); }
}</lang>
Raven
<lang raven>100 each 1 + as n
n 3 mod 0 = if 'Fizz' cat n 5 mod 0 = if 'Buzz' cat dup empty if drop n say</lang>
REALbasic
<lang vb>
For i As Integer = 1 To 100 If i mod 3 = 0 And i mod 5 = 0 Then Print("FizzBuzz") ElseIf i mod 3 = 0 Then Print("Fizz") ElseIf i mod 5 = 0 Then Print("Buzz") Else Print(Str(i)) End If Next
</lang>
REBOL
Shortest implementation: <lang REBOL>repeat i 100 [case/all [i // 3 = 0 [print"fizz"] i // 5 = 0 [print "buzz"] 1 [print i]]]</lang> A long implementation that concatenates strings and includes a proper code header (title, date, etc.) <lang REBOL>REBOL [ Title: "FizzBuzz" Author: oofoe Date: 2009-12-10 URL: http://rosettacode.org/wiki/FizzBuzz ]
- Concatenative. Note use of 'case/all' construct to evaluate all
- conditions. I use 'copy' to allocate a new string each time through
- the loop -- otherwise 'x' would get very long...
repeat i 100 [ x: copy "" case/all [ 0 = mod i 3 [append x "Fizz"] 0 = mod i 5 [append x "Buzz"] "" = x [x: mold i] ] print x ]</lang> Here are two examples by Nick Antonaccio. <lang REBOL>repeat i 100 [
print switch/default 0 compose [ (mod i 15) ["fizzbuzz"] (mod i 3) ["fizz"] (mod i 5) ["buzz"] ][i]
]
- And minimized version
repeat i 100[j:""if 0 = mod i 3[j:"fizz"]if 0 = mod i 5[j: join j"buzz"]if j =""[j: i]print j]</lang> The following is presented as a curiosity only, not as an example of good coding practice: <lang REBOL>m: func [i d] [0 = mod i d] spick: func [t x y][either any [not t "" = t][y][x]] zz: func [i] [rejoin [spick m i 3 "Fizz" "" spick m i 5 "Buzz" ""]] repeat i 100 [print spick z: zz i z i]</lang>
Retro
This is a port of some Forth code. <lang Retro>: fizz? ( s-f ) 3 mod 0 = ;
- buzz? ( s-f ) 5 mod 0 = ;
- num? ( s-f ) dup fizz? swap buzz? or 0 = ;
- ?fizz ( s- ) fizz? [ "Fizz" puts ] ifTrue ;
- ?buzz ( s- ) buzz? [ "Buzz" puts ] ifTrue ;
- ?num ( s- ) num? &putn &drop if ;
- fizzbuzz ( s- ) dup ?fizz dup ?buzz dup ?num space ;
- all ( - ) 100 [ 1+ fizzbuzz ] iter ;</lang>
It's cleaner to use quotes and combinators though: <lang Retro>needs math'
- <fizzbuzz>
[ 15 ^math'divisor? ] [ drop "FizzBuzz" puts ] when [ 3 ^math'divisor? ] [ drop "Fizz" puts ] when [ 5 ^math'divisor? ] [ drop "Buzz" puts ] when putn ;
- fizzbuzz cr 100 [ 1+ <fizzbuzz> space ] iter ;</lang>
REXX
three IF-THEN
<lang rexx>/*REXX program displays numbers 1 ──► 100 for the FizzBuzz problem. */
do j=1 to 100; z=j if j//3 ==0 then z='Fizz' if j//5 ==0 then z='Buzz' if j//(3*5)==0 then z='FizzBuzz' say right(z,8) end /*j*/ /*stick a fork in it, we're done.*/</lang>
output
1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17 Fizz 19 Buzz Fizz 22 23 Fizz Buzz 26 Fizz 28 29 FizzBuzz 31 32 Fizz 34 Buzz Fizz 37 38 Fizz Buzz 41 Fizz 43 44 FizzBuzz 46 47 Fizz 49 Buzz Fizz 52 53 Fizz Buzz 56 Fizz 58 59 FizzBuzz 61 62 Fizz 64 Buzz Fizz 67 68 Fizz Buzz 71 Fizz 73 74 FizzBuzz 76 77 Fizz 79 Buzz Fizz 82 83 Fizz Buzz 86 Fizz 88 89 FizzBuzz 91 92 Fizz 94 Buzz Fizz 97 98 Fizz Buzz
SELECT-WHEN
<lang rexx>/*REXX program displays numbers 1 ──► 100 for the FizzBuzz problem. */
do n=1 for 100 select when n//15==0 then say 'FizzBuzz' when n//5 ==0 then say ' Buzz' when n//3 ==0 then say ' Fizz' otherwise say right(n,8) end /*select*/ end /*n*/ /*stick a fork in it, we're done.*/</lang>
output is identical to version 1.
two IF-THEN
<lang rexx>/*REXX program displays numbers 1 ──► 100 for the FizzBuzz problem. */
do n=1 for 100; _= if n//3 ==0 then _= 'Fizz' if n//5 ==0 then _=_'Buzz' say right(word(_ n,1),8) end /*n*/ /*stick a fork in it, we're done.*/</lang>
output is identical to version 1.
Ruby
<lang ruby>1.upto(100) do |n|
print "Fizz" if a = (n % 3).zero? print "Buzz" if b = (n % 5).zero? print n unless (a || b) print "\n"
end</lang> A bit more straightforward: <lang ruby>1.upto(100) do |n|
if (n % 15).zero? puts "FizzBuzz" elsif (n % 5).zero? puts "Buzz" elsif (n % 3).zero? puts "Fizz" else puts n end
end</lang> An example using string interpolation: <lang ruby>(1..100).each do |n|
v = "#{"Fizz" if n % 3 == 0}#{"Buzz" if n % 5 == 0}" puts v.empty? ? n : v
end</lang> Interpolation inspired one-liner: <lang ruby>1.upto(100) { |n| puts "#{'Fizz' if n % 3 == 0}#{'Buzz' if n % 5 == 0}#{n if n % 3 != 0 && n % 5 != 0}" }</lang> An example using append: <lang ruby>1.upto 100 do |n|
r = r << 'Fizz' if n % 3 == 0 r << 'Buzz' if n % 5 == 0 r << n.to_s if r.empty? puts r
end</lang> Yet another solution: <lang>1.upto(100) { |i| p "#{[:Fizz][i%3]}#{[:Buzz][i%5]}"[/.+/m] || i }</lang> Monkeypatch example: <lang ruby>class Integer
def fizzbuzz v = "#{"Fizz" if self % 3 == 0}#{"Buzz" if self % 5 == 0}" v.empty? ? self : v end
end
puts *(1..100).map(&:fizzbuzz)</lang>
Without mutable variables or inline printing. <lang ruby>fizzbuzz = ->(i) do
(i%15).zero? and next "FizzBuzz" (i%3).zero? and next "Fizz" (i%5).zero? and next "Buzz" i
end
puts (1..100).map(&fizzbuzz).join("\n")</lang>
Jump anywhere#Ruby has a worse example of FizzBuzz, using a continuation!
Run BASIC
<lang runbasic>for i = 1 to 100
print i; if (i mod 15) = 0 then print " FuzzBuzz"; if (i mod 3) = 0 then print " Fuzz"; if (i mod 5) = 0 then print " Buzz"; print
next i</lang>
Rust
<lang Rust>// rust 0.8
fn main() {
let mut n:uint = 1; while n <= 100 { if n % 15 == 0 { println("FizzBuzz"); } else if n % 3 == 0 { println("Fizz"); } else if n % 5 == 0 { println("Buzz"); } else { println(n.to_str()); } n += 1; }
}</lang>
or
<lang Rust>// rust 0.8
fn main() { for n in std::iter::range_inclusive(1,100) { fizzbuzz(n) }}
fn fizzbuzz(n:int) {
let mut buf = ~""; if n % 3 == 0 { buf.push_str("Fizz") } if n % 5 == 0 { buf.push_str("Buzz") } if buf != ~"" { println!("{}", buf ) } else { println!("{}", n ) }
}</lang>
Using pattern matching on ints:
<lang Rust>// rust 0.8
fn main() {
for num in std::iter::range_inclusive(1, 100) { println( match (num % 3, num % 5) { (0, 0) => ~"FizzBuzz", (0, _) => ~"Fizz", (_, 0) => ~"Buzz", (_, _) => num.to_str() } ); }
}</lang>
Using pattern matching on bools:
<lang Rust>// rust 0.8
fn main() {
for num in std::iter::range_inclusive(1, 100) { println( match (num % 3 == 0, num % 5 == 0) { (false, false) => num.to_str(), (true, false) => ~"Fizz", (false, true) => ~"Buzz", (true, true) => ~"FizzBuzz" } ); }
}</lang>
<lang Rust>
// rust 0.8
fn main() {
for num in range(1,101) { let answer = if num % 15 == 0 { ~"FizzBuzz" } else if num % 3 == 0 { ~"Fizz" } else if num % 5 == 0 { ~"Buzz" } else { num.to_str() }; println(answer); }
}
</lang>
Salmon
<lang Salmon>iterate (x; [1...100])
((x % 15 == 0) ? "FizzBuzz" : ((x % 3 == 0) ? "Fizz" : ((x % 5 == 0) ? "Buzz" : x)))!;</lang>
or <lang Salmon>iterate (x; [1...100])
{ if (x % 15 == 0) "FizzBuzz"! else if (x % 3 == 0) "Fizz"! else if (x % 5 == 0) "Buzz"! else x!; };</lang>
Sather
<lang sather>class MAIN is
main is loop i ::= 1.upto!(100); s:STR := ""; if i % 3 = 0 then s := "Fizz"; end; if i % 5 = 0 then s := s + "Buzz"; end; if s.length > 0 then #OUT + s + "\n"; else #OUT + i + "\n"; end; end; end;
end;</lang>
Scala
Idiomatic scala code
<lang scala> for (x <- 1 to 100) println(
(x % 3, x % 5) match { case (0, 0) => "FizzBuzz" case (0, _) => "Fizz" case (_, 0) => "Buzz" case _ => x })
</lang>
Geeky over-generalized solution ☺
<lang scala> def replaceMultiples(x: Int, rs: (Int, String)*) =
rs map { case (n, s) => Either cond (x % n == 0, s, x) } reduceLeft ((a, b) => a fold ((_ => b), (s => b fold ((_ => a), (t => Right(s + t))))))
def fizzbuzz(n: Int) = replaceMultiples(n, 3 -> "Fizz", 5 -> "Buzz") fold ((_ toString), identity)
1 to 100 map fizzbuzz foreach println</lang>
By a two-liners geek
<lang scala> def f(a: Int, b: Int, c: String, d: String): String = if (a % b == 0) c else d
for (i <- 1 to 100) println(f(i, 15, "FizzBuzz", f(i, 3, "Fizz", f(i, 5, "Buzz", i.toString))))</lang>
Scheme
<lang scheme>(do ((i 1 (+ i 1)))
((> i 100)) (display (cond ((= 0 (modulo i 15)) "FizzBuzz") ((= 0 (modulo i 3)) "Fizz") ((= 0 (modulo i 5)) "Buzz") (else i))) (newline))</lang>
Sed
<lang sed>#n
- doesn't work if there's no input
- initialize counters (0 = empty) and value
s/.*/ 0/
- loop
- increment counters, set carry
s/^\(a*\) \(b*\) \([0-9][0-9]*\)/\1a \2b \3@/
- propagate carry
- carry
s/ @/ 1/ s/9@/@0/ s/8@/9/ s/7@/8/ s/6@/7/ s/5@/6/ s/4@/5/ s/3@/4/ s/2@/3/ s/1@/2/ s/0@/1/ /@/b carry
- save state
h
- handle factors
s/aaa/Fizz/ s/bbbbb/Buzz/
- strip value if any factor
/z/s/[0-9]//g
- strip counters and spaces
s/[ab ]//g
- output
p
- restore state
g
- roll over counters
s/aaa// s/bbbbb//
- loop until value = 100
/100/q b loop</lang>
Seed7
<lang seed7>$ include "seed7_05.s7i";
const proc: main is func
local var integer: number is 0; begin for number range 1 to 100 do if number rem 15 = 0 then writeln("FizzBuzz"); elsif number rem 5 = 0 then writeln("Buzz"); elsif number rem 3 = 0 then writeln("Fizz"); else writeln(number); end if; end for; end func;</lang>
Slate
<lang slate>n@(Integer traits) fizzbuzz [
output ::= ((n \\ 3) isZero ifTrue: ['Fizz'] ifFalse: []) ; ((n \\ 5) isZero ifTrue: ['Buzz'] ifFalse: []). output isEmpty ifTrue: [n printString] ifFalse: [output]
]. 1 to: 100 do: [| :i | inform: i fizzbuzz]</lang>
Smalltalk
Since only GNU Smalltalk supports file-based programming, we'll be using its syntax. <lang smalltalk>Integer extend [
fizzbuzz [ | fb | fb := '%<Fizz|>1%<Buzz|>2' % { self \\ 3 == 0. self \\ 5 == 0 }. ^fb isEmpty ifTrue: [ self ] ifFalse: [ fb ] ]
] 1 to: 100 do: [ :i | i fizzbuzz displayNl ]</lang> A Squeak/Pharo example using the Transcript window: <lang smalltalk>(1 to: 100) do: [:n | ((n \\ 3)*(n \\ 5)) isZero
ifFalse: [Transcript show: n].
(n \\ 3) isZero ifTrue: [Transcript show: 'Fizz']. (n \\ 5) isZero ifTrue: [Transcript show: 'Buzz']. Transcript cr.]</lang> The Squeak/Pharo examples below present possibilities using the powerful classes available. In this example, the dictionary can have as keys pairs of booleans and in the interaction the several boolean patterns select the string to be printed or if the pattern is not found the number itself is printed. <lang smalltalk>fizzbuzz := Dictionary with: #(true true)->'FizzBuzz'
with: #(true false)->'Fizz' with: #(false true)->'Buzz'.
1 to: 100 do: [ :i | Transcript show:
(fizzbuzz at: {i isDivisibleBy: 3. i isDivisibleBy: 5}
ifAbsent: [ i ]); cr]</lang> Smalltalk does not have a case-select construct, but a similar effect can be attained using a collection and the #includes: method: <lang smalltalk>1 to: 100 do: [:n | |r| r := n rem: 15. Transcript show: (r isZero ifTrue:['fizzbuzz'] ifFalse: [(#(3 6 9 12) includes: r) ifTrue:['fizz'] ifFalse:[((#(5 10) includes: r)) ifTrue:['buzz'] ifFalse:[n]]]); cr].</lang> If the construction of the whole collection is done beforehand, Smalltalk provides a straightforward way of doing because collections can be heterogeneous (may contain any object): <lang smalltalk>fbz := (1 to: 100) asOrderedCollection.
3 to: 100 by: 3 do: [:i | fbz at: i put: 'Fizz']. 5 to: 100 by: 5 do: [:i | fbz at: i put: 'Buzz'].
15 to: 100 by: 15 do: [:i | fbz at: i put: 'FizzBuzz']. fbz do: [:i | Transcript show: i; cr].</lang> The approach building a dynamic string can be done as well: <lang smalltalk>1 to: 100 do: [:i | |fb s| fb := {i isDivisibleBy: 3. i isDivisibleBy: 5. nil}. fb at: 3 put: (fb first | fb second) not. s := '<1?Fizz:><2?Buzz:><3?{1}:>' format: {i printString}. Transcript show: (s expandMacrosWithArguments: fb); cr].</lang>
SNOBOL4
Merely posting a solution by Daniel Lyons <lang snobol4> I = 1 LOOP FIZZBUZZ = ""
EQ(REMDR(I, 3), 0) :F(TRY_5) FIZZBUZZ = FIZZBUZZ "FIZZ"
TRY_5 EQ(REMDR(I, 5), 0) :F(DO_NUM)
FIZZBUZZ = FIZZBUZZ "BUZZ"
DO_NUM IDENT(FIZZBUZZ, "") :F(SHOW)
FIZZBUZZ = I
SHOW OUTPUT = FIZZBUZZ
I = I + 1 LE(I, 100) :S(LOOP)
END</lang>
SNUSP
<lang snusp> / 'B' @=@@=@@++++#
// / 'u' @@@@@=@+++++# // // / 'z' @=@@@@+@++++# // // // / 'i' @@@@@@=+++++# // // // // / 'F' @@@=@@+++++# // // // // // / LF ++++++++++# // // // // // // / 100 @@@=@@@=++++#
$@/>@/>@/>@/>@/>@/>@/\ 0 / / ! /======= Fizz <<<.<.<..>>># / | \ \?!#->+ @\.>?!#->+ @\.>?!#->+@/.>\ | / ! ! ! / | \?!#->+ @\.>?!#->+@\ .>?!#->+@/.>\ | / ! \!===\! ! / | \?!#->+ @\.>?!#->+ @\.>?!#->+@/.>\ | / ! ! | ! / | \?!#->+@\ .>?!#->+ @\.>?!#->+@/.>\ | / \!==========!===\! ! / | \?!#->+ @\.>?!#->+ @\.>?!#->+@/>>@\.>/
! | | | /==========/ \========!\=== Buzz <<<<<<<.>.>..>>># | \!/=dup==?\>>@\<!/back?\<<<# \<<+>+>-/ | \>+<- / |
/======================/ | | /recurse\ #/?\ zero \print=!\@\>?!\@/<@\.!\-/
| \=/ \=itoa=@@@+@+++++# ! /+ !/+ !/+ !/+ \ mod10 /<+> -\!?-\!?-\!?-\!?-\! \?!\-?!\-?!\-?!\-?!\-?/\ div10 # +/! +/! +/! +/! +/</lang>
SQL
Oracle SQL
<lang sql>select (CASE
WHEN MOD(lvl,15)=0 THEN 'FizzBuzz' WHEN MOD(lvl,3)=0 THEN 'Fizz' WHEN MOD(lvl,5)=0 THEN 'Buzz' ELSE TO_CHAR(lvl) END) FizzBuzz
from (
select LEVEL lvl from dual connect by LEVEL <= 100)</lang>
Or using Oracle's DECODE and NVL:
<lang sql>select nvl(decode(mod(n,3),0,'Fizz')||decode(mod(n,5),0,'Buzz'),n) from (select level n from dual connect by level<=100)</lang>
PostgreSQL specific
<lang sql>SELECT i, fizzbuzz
FROM (SELECT i, CASE WHEN i % 15 = 0 THEN 'FizzBuzz' WHEN i % 5 = 0 THEN 'Buzz' WHEN i % 3 = 0 THEN 'Fizz' ELSE NULL END AS fizzbuzz FROM generate_series(1,100) AS i) AS fb WHERE fizzbuzz IS NOT NULL;</lang>
Recursive Common Table Expressions (MSSQL 2005+)
<lang sql>WITH nums (n, fizzbuzz ) AS ( SELECT 1, CONVERT(nvarchar, 1) UNION ALL SELECT (n + 1) as n1, CASE WHEN (n + 1) % 15 = 0 THEN 'FizzBuzz' WHEN (n + 1) % 3 = 0 THEN 'Fizz' WHEN (n + 1) % 5 = 0 THEN 'Buzz' ELSE CONVERT(nvarchar, (n + 1)) END FROM nums WHERE n < 100 ) SELECT n, fizzbuzz FROM nums ORDER BY n ASC OPTION ( MAXRECURSION 100 )</lang>
Generic SQL using a join
This should work in most RDBMSs, but you may need to change MOD(i,divisor) to i % divisor. <lang SQL>-- Load some numbers CREATE TABLE numbers(i INTEGER); INSERT INTO numbers VALUES(1); INSERT INTO numbers SELECT i + (SELECT MAX(i) FROM numbers) FROM numbers; INSERT INTO numbers SELECT i + (SELECT MAX(i) FROM numbers) FROM numbers; INSERT INTO numbers SELECT i + (SELECT MAX(i) FROM numbers) FROM numbers; INSERT INTO numbers SELECT i + (SELECT MAX(i) FROM numbers) FROM numbers; INSERT INTO numbers SELECT i + (SELECT MAX(i) FROM numbers) FROM numbers; INSERT INTO numbers SELECT i + (SELECT MAX(i) FROM numbers) FROM numbers; INSERT INTO numbers SELECT i + (SELECT MAX(i) FROM numbers) FROM numbers; -- Define the fizzes and buzzes CREATE TABLE fizzbuzz (message VARCHAR(8), divisor INTEGER); INSERT INTO fizzbuzz VALUES('fizz', 3); INSERT INTO fizzbuzz VALUES('buzz', 5); INSERT INTO fizzbuzz VALUES('fizzbuzz', 15); -- Play fizzbuzz SELECT COALESCE(max(message),CAST(i AS VARCHAR(99))) as result FROM numbers LEFT OUTER JOIN fizzbuzz ON MOD(i,divisor) = 0 GROUP BY i HAVING i <= 100 ORDER BY i; -- Tidy up DROP TABLE fizzbuzz; DROP TABLE numbers;</lang>
Squirrel
<lang javascript>function Fizzbuzz(n) {
for (local i = 1; i <= n; i += 1) { if (i % 15 == 0) print ("FizzBuzz\n") else if (i % 5 == 0) print ("Buzz\n") else if (i % 3 == 0) print ("Fizz\n") else { print (i + "\n") } }
} Fizzbuzz(100);</lang>
Standard ML
First using two helper functions, one for deciding what to output and another for performing recursion with an auxiliary argument j. <lang sml>local
fun fbstr i = case (i mod 3 = 0, i mod 5 = 0) of (true , true ) => "FizzBuzz" | (true , false) => "Fizz" | (false, true ) => "Buzz" | (false, false) => Int.toString i
fun fizzbuzz' (n, j) = if n = j then () else (print (fbstr j ^ "\n"); fizzbuzz' (n, j+1))
in
fun fizzbuzz n = fizzbuzz' (n, 1) val _ = fizzbuzz 100
end</lang>
Second using the standard-library combinator List.tabulate and a helper function, fb, that calculates and prints the output. <lang sml>local
fun fb i = let val fizz = i mod 3 = 0 andalso (print "Fizz"; true) val buzz = i mod 5 = 0 andalso (print "Buzz"; true) in fizz orelse buzz orelse (print (Int.toString i); true) end
in
fun fizzbuzz n = (List.tabulate (n, fn i => (fb (i+1); print "\n")); ()) val _ = fizzbuzz 100
end</lang>
Tcl
<lang tcl>proc fizzbuzz {n {m1 3} {m2 5}} {
for {set i 1} {$i <= $n} {incr i} { set ans "" if {$i % $m1 == 0} {append ans Fizz} if {$i % $m2 == 0} {append ans Buzz} puts [expr {$ans eq "" ? $i : $ans}] }
} fizzbuzz 100</lang> The following example shows Tcl's substitution mechanism that allows to concatenate the results of two successive commands into a string: <lang tcl>while {[incr i] < 101} {
set fb [if {$i % 3 == 0} {list Fizz}][if {$i % 5 == 0} {list Buzz}] if {$fb ne ""} {puts $fb} {puts $i}
}</lang>
TI-83 BASIC
<lang ti83b>PROGRAM:FIZZBUZZ
- For(I,1,100)
:0→N :If fPart(I/5)=0 :2→N :If fPart(I/3)=0 :1+N→N :If N=0 :Disp I :If N=1 :Disp "FIZZ" :If N=2 :Disp "BUZZ" :If N=3 :Disp "FIZZBUZZ"
- End</lang>
Turing
<lang Turing> setscreen("nocursor,noecho")
for i : 1 .. 100
if i mod 15 = 0 then put "Fizzbuzz" .. elsif i mod 5 = 0 then put "Buzz" .. elsif i mod 3 = 0 then put "Fizz" .. else put i .. end if
end for </lang>
TUSCRIPT
<lang tuscript>$$ MODE TUSCRIPT LOOP n=1,100 mod=MOD (n,15) SELECT mod CASE 0 PRINT n," FizzBuzz" CASE 3,6,9,12 PRINT n," Fizz" CASE 5,10 PRINT n," Buzz" DEFAULT PRINT n ENDSELECT ENDLOOP</lang>
UNIX Shell
This solution should work with any Bourne-compatible shell. <lang bash>i=1 while expr $i '<=' 100 >/dev/null; do w=false expr $i % 3 = 0 >/dev/null && { printf Fizz; w=true; } expr $i % 5 = 0 >/dev/null && { printf Buzz; w=true; } if $w; then echo; else echo $i; fi i=`expr $i + 1` done</lang>
Versions for specific shells
The other solutions work with fewer shells.
The next solution requires $(( )) arithmetic expansion, which is in every POSIX shell; but it also requires the seq(1) command which is not part of some systems. (If your system misses seq(1), but it has BSD jot(1), then change `seq 1 100` to `jot 100`.) <lang bash>for n in `seq 1 100`; do
if [ $((n % 15)) = 0 ]; then echo FizzBuzz elif [ $((n % 3)) = 0 ]; then echo Fizz elif [ $((n % 5)) = 0 ]; then echo Buzz else echo $n fi
done</lang>
The next solution requires the (( )) command from the Korn Shell.
<lang bash>NUM=1 until ((NUM == 101)) ; do
if ((NUM % 15 == 0)) ; then echo FizzBuzz elif ((NUM % 3 == 0)) ; then echo Fizz elif ((NUM % 5 == 0)) ; then echo Buzz else echo "$NUM" fi ((NUM = NUM + 1))
done</lang>
A version using concatenation:
<lang bash>for ((n=1; n<=100; n++)) do
fb= [ $(( n % 3 )) -eq 0 ] && fb="${fb}Fizz" [ $(( n % 5 )) -eq 0 ] && fb="${fb}Buzz" [ -n "${fb}" ] && echo "${fb}" || echo "$n"
done</lang>
A version using some of the insane overkill of Bash 4:
<lang bash>command_not_found_handle () {
local Fizz=3 Buzz=5 [ $(( $2 % $1 )) -eq 0 ] && echo -n $1 && [ ${!1} -eq 3 ]
}
for i in {1..100} do
Fizz $i && ! Buzz $i || echo -n $i echo
done</lang>
Bash one-liner <lang bash>for i in {1..100};do ((($i%15==0))&& echo FizzBuzz)||((($i%5==0))&& echo Buzz;)||((($i%3==0))&& echo Fizz;)||echo $i;done</lang>
Ursala
<lang Ursala>#import std
- import nat
fizzbuzz = ^T(&&'Fizz'! not remainder\3,&&'Buzz'! not remainder\5)|| ~&h+ %nP
- show+
main = fizzbuzz*t iota 101</lang>
V
<lang v>[fizzbuzz
1 [>=] [ [[15 % zero?] ['fizzbuzz' puts] [5 % zero?] ['buzz' puts] [3 % zero?] ['fizz' puts] [true] [dup puts] ] when succ ] while]. |100 fizzbuzz</lang>
Second try
(a compiler for fizzbuzz)
define a command that will generate a sequence <lang v>[seq [] swap dup [zero? not] [rolldown [dup] dip cons rollup pred] while pop pop].</lang> create a quote that will return a quote that returns a quote if its argument is an integer (A HOF) <lang v>[check [N X F : [[integer?] [[X % zero?] [N F cons] if] if]] view].</lang> Create a quote that will make sure that the above quote is applied correctly if given (Number Function) as arguments. <lang v>[func [[N F] : [dup N F check i] ] view map].</lang> And apply it <lang v>100 seq [
[15 [pop 'fizzbuzz' puts]] [5 [pop 'buzz' puts]] [3 [pop 'fizz' puts]] [1 [puts]]] [func dup] step [i true] map pop</lang>
the first one is much better :)
Vala
<lang vala>int main() { for(int i = 1; i < 100; i++) { if(i % 3 == 0) stdout.printf("Fizz"); if(i % 5 == 0) stdout.printf("Buzz"); if(i % 3 != 0 && i % 5 != 0) stdout.printf("%d", i); stdout.printf("\n"); } return 0; }</lang>
VBScript
Implementation
The EEF does eager evaluation. I'm still trying to figure out a lazy evaluation method using Eval(). One day ...
In the meantime, converting that to VB6 would mean using VB6's IIF() which would run a tad faster.
<lang vb>'using the IF/ELSEIF ladder function fb( n ) if n mod 15 = 0 then fb = "FizzBuzz" elseif n mod 5 = 0 then fb = "Fizz" elseif n mod 3 = 0 then fb = "Buzz" else fb = n end if end function
'the Mexican IF function eef( b, p1, p2 ) if b then eef = p1 else eef = p2 end if end function
'using the Mexican IF function fb2( n ) fb2 = eef( n mod 15 = 0, "FizzBuzz", eef( n mod 5 = 0, "Fizz", eef( n mod 3 = 0, "Buzz", n ) ) ) end function</lang>
Invocation
<lang vb>for i = 1 to 16 wscript.stdout.write fb(i) & " " next wscript.echo
for i = 1 to 16 wscript.stdout.write fb2(i) & " " next wscript.echo</lang>
Output
1 2 Buzz 4 Fizz Buzz 7 8 Buzz Fizz 11 Buzz 13 14 FizzBuzz 16 1 2 Buzz 4 Fizz Buzz 7 8 Buzz Fizz 11 Buzz 13 14 FizzBuzz 16
Visual Basic .NET
Platform: .NET
<lang vbnet>Sub Main()
For i = 1 To 100 If i Mod 15 = 0 Then Console.WriteLine("FizzBuzz") ElseIf i Mod 5 = 0 Then Console.WriteLine("Buzz") ElseIf i Mod 3 = 0 Then Console.WriteLine("Fizz") Else Console.WriteLine(i) End If Next
End Sub</lang>
Wart
<lang wart>for i 1 (i <= 100) ++i
prn (if (divides i 15) "FizzBuzz" (divides i 3) "Fizz" (divides i 5) "Buzz" :else i)</lang>
Whitespace
<lang Whitespace>
</lang>
This solution was generated from the following pseudo-Assembly.
<lang asm>push 1 ; Initialize a counter.
0:
dup dup ; Get two copies for the mod checks. push 3 mod jz 1 push 5 mod jz 2 dup onum jump 4 ; If we're still here, just print the number.
1: ; Print "Fizz", then maybe "Buzz".
push F ochr push i ochr call 3 push 5 mod jz 2 jump 4
2: ; Print "Buzz".
push B ochr push u ochr call 3 jump 4
3: ; Print "zz"; called as a function for convenient return.
push z dup ochr ochr ret
4:
push 10 ochr ; Print a newline. push 1 add dup ; Increment the counter. push 101 sub jn 0 ; Go again unless we're at 100. pop exit ; Exit clean.</lang>
Wortel
<lang wortel>@each &x!console.log x !*&x?{%%x 15 'FizzBuzz' %%x 5 'Buzz' %%x 3 'Fizz' x} @to 100</lang>
XPL0
<lang XPL0>code CrLf=9, IntOut=11, Text=12; int N; [for N:= 1 to 100 do
[if rem(N/3)=0 then Text(0,"Fizz"); if rem(N/5)=0 then Text(0,"Buzz") else if rem(N/3)#0 then IntOut(0,N); CrLf(0); ];
]</lang>
Output:
1 2 Fizz 4 Buzz Fizz 7 ... 89 FizzBuzz 91 92 Fizz 94 Buzz Fizz 97 98 Fizz Buzz
XPath 2.0
<lang XPath>for $n in 1 to 100 return
concat('fizz'[not($n mod 3)], 'buzz'[not($n mod 5)], $n[$n mod 15 = (1,2,4,7,8,11,13,14)])</lang>
...or alternatively...
<lang XPath>for $n in 1 to 100 return
($n, 'Fizz', 'Buzz', 'FizzBuzz')[number(($n mod 3) = 0) + number(($n mod 5) = 0)*2 + 1]</lang>
XSLT 1.0
Plain XSLT
<lang xml><?xml version="1.0" encoding="utf-8" ?> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> <xsl:output method="text" encoding="utf-8"/>
<xsl:template name="fizzbuzz-single"> <xsl:param name="n"/>
<xsl:variable name="s"> <xsl:if test="$n mod 3 = 0">Fizz</xsl:if> <xsl:if test="$n mod 5 = 0">Buzz</xsl:if> </xsl:variable>
<xsl:value-of select="$s"/> <xsl:if test="$s = "> <xsl:value-of select="$n"/> </xsl:if>
<xsl:value-of select="' '"/> </xsl:template>
<xsl:template name="fizzbuzz-range"> <xsl:param name="startAt" select="1"/> <xsl:param name="endAt" select="$startAt + 99"/>
<xsl:if test="$startAt <= $endAt">
<xsl:call-template name="fizzbuzz-single">
<xsl:with-param name="n" select="$startAt"/>
</xsl:call-template>
<xsl:call-template name="fizzbuzz-range"> <xsl:with-param name="startAt" select="$startAt + 1"/> <xsl:with-param name="endAt" select="$endAt"/> </xsl:call-template> </xsl:if> </xsl:template>
<xsl:template match="/"> <xsl:call-template name="fizzbuzz-range"/> </xsl:template> </xsl:stylesheet></lang>
With EXSLT
<lang xml><xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:exsl="http://exslt.org/common" exclude-result-prefixes="xsl exsl">
<xsl:output method="text"/>
<xsl:template name="FizzBuzz" match="/">
<xsl:param name="n" select="1" /> <xsl:variable name="_"> <_><xsl:value-of select="$n" /></_> </xsl:variable> <xsl:apply-templates select="exsl:node-set($_)/_" /> <xsl:if test="$n < 100"> <xsl:call-template name="FizzBuzz"> <xsl:with-param name="n" select="$n + 1" /> </xsl:call-template> </xsl:if>
</xsl:template>
<xsl:template match="_[. mod 3 = 0]">Fizz </xsl:template>
<xsl:template match="_[. mod 5 = 0]">Buzz </xsl:template>
<xsl:template match="_[. mod 15 = 0]" priority="1">FizzBuzz </xsl:template>
<xsl:template match="_">
<xsl:value-of select="concat(.,' ')" />
</xsl:template>
</xsl:stylesheet></lang>
XSLT 2.0
<lang xml><xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> <xsl:output method="text"/>
<xsl:template match="/">
<xsl:value-of separator=" " select=" for $n in 1 to 100 return concat('fizz'[not($n mod 3)], 'buzz'[not($n mod 5)], $n[$n mod 15 = (1,2,4,7,8,11,13,14)])"/>
</xsl:template>
</xsl:stylesheet></lang>
Yorick
Iterative solution
<lang yorick>for(i = 1; i <= 100; i++) {
if(i % 3 == 0) write, format="%s", "Fizz"; if(i % 5 == 0) write, format="%s", "Buzz"; if(i % 3 && i % 5) write, format="%d", i; write, "";
}</lang>
Vectorized solution
<lang yorick>output = swrite(format="%d", indgen(100)); output(3::3) = "Fizz"; output(5::5) = "Buzz"; output(15::15) = "FizzBuzz"; write, format="%s\n", output;</lang>
- Programming Tasks
- Classic CS problems and programs
- Iteration
- Recursion
- 360 Assembly
- 6502 Assembly
- ACL2
- ActionScript
- AutoIt
- 8086 Assembly
- Ada
- ALGOL 68
- APL
- AppleScript
- Arbre
- AutoHotkey
- AWK
- Babel
- Bash
- BASIC
- Applesoft BASIC
- Batch File
- BBC BASIC
- Bc
- Befunge
- Boo
- Bracmat
- Brat
- Brainf***
- C
- C++
- C sharp
- Cduce
- Chef
- Clay
- Clipper
- CLIPS
- Clojure
- CMake
- COBOL
- CoffeeScript
- Common Lisp
- Cubescript
- Chapel
- D
- Dart
- Dc
- Delphi
- DWScript
- E
- ECL
- Eero
- Ela
- Elixir
- Erlang
- Euphoria
- Factor
- F Sharp
- Falcon
- FALSE
- Fantom
- FBSL
- Forth
- Fortran
- Frink
- GAP
- Go
- Gosu
- Groovy
- Haskell
- HicEst
- Icon
- Unicon
- Inform 6
- Inform 7
- Io
- Ioke
- Iptscrae
- J
- Java
- JavaScript
- Joy
- Julia
- K
- Kaya
- LabVIEW
- Lasso
- Liberty BASIC
- LiveScript
- Logo
- LOLCODE
- LSE
- Lua
- M4
- Make
- Jot
- Mathematica
- MATLAB
- Maxima
- MAXScript
- MEL
- Mercury
- Metafont
- Mirah
- MMIX
- Modula-3
- MUMPS
- Nemerle
- NetRexx
- NewtonScript
- Nickle
- Nimrod
- Oberon-2
- Objeck
- Objective-C
- OCaml
- Octave
- OOC
- Order
- Oz
- PARI/GP
- Pascal
- Perl
- Perl 6
- PHL
- PHP
- PicoLisp
- Pike
- PIR
- PL/I
- Pop11
- PL/SQL
- PostScript
- Potion
- PowerShell
- Prolog
- Protium
- PureBasic
- Python
- R
- Racket
- RapidQ
- Rascal
- Raven
- REALbasic
- REBOL
- Retro
- REXX
- Ruby
- Run BASIC
- Rust
- Salmon
- Sather
- Scala
- Scala Implementations
- Scheme
- Sed
- Seed7
- Slate
- Smalltalk
- SNOBOL4
- SNUSP
- SQL
- SQL Implementations
- Squirrel
- Standard ML
- Tcl
- TI-83 BASIC
- Turing
- TUSCRIPT
- UNIX Shell
- Ursala
- V
- Vala
- VBScript
- Visual Basic .NET
- Wart
- Whitespace
- Wortel
- XPL0
- XPath 2.0
- XSLT 1.0
- XSLT 2.0
- Yorick