FizzBuzz: Difference between revisions
→{{header|C++}}: Alternate version not using modulo 15 |
|||
Line 1: | Line 1: | ||
{{task|Classic CS problems and programs}} |
|||
[[Category:Recursion]]{{puzzle}}Write a program that prints the numbers 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". [http://weblog.raganwald.com/2007/01/dont-overthink-fizzbuzz.html] |
|||
[[Category:Iteration]] |
|||
[[Category:Recursion]] |
|||
[[Category:Simple]] |
|||
;Task: |
|||
FizzBuzz was presented as the lowest level of comprehension required to illustrate adequacy. [http://www.codinghorror.com/blog/archives/000804.html] |
|||
Write a program that prints the integers from '''1''' to '''100''' (inclusive). |
|||
But: |
|||
:* for multiples of three, print '''Fizz''' instead of the number; |
|||
:* for multiples of five, print '''Buzz''' instead of the number; |
|||
:* for multiples of both three and five, print '''FizzBuzz''' instead of the number. |
|||
The ''FizzBuzz'' problem was presented as the lowest level of comprehension required to illustrate adequacy. |
|||
;Also see: |
|||
* (a blog) [http://weblog.raganwald.com/2007/01/dont-overthink-fizzbuzz.html dont-overthink-fizzbuzz] |
|||
* (a blog) [http://blog.codinghorror.com/fizzbuzz-the-programmers-stairway-to-heaven/ fizzbuzz-the-programmers-stairway-to-heaven] |
|||
<br><br> |
|||
=={{header|11l}}== |
|||
{{trans|Python3: Simple}} |
|||
<syntaxhighlight lang="11l">L(i) 1..100 |
|||
I i % 15 == 0 |
|||
print(‘FizzBuzz’) |
|||
E I i % 3 == 0 |
|||
print(‘Fizz’) |
|||
E I i % 5 == 0 |
|||
print(‘Buzz’) |
|||
E |
|||
print(i)</syntaxhighlight> |
|||
=={{header|360 Assembly}}== |
|||
See [[FizzBuzz/Assembly]] |
|||
=={{header|6502 Assembly}}== |
|||
See [[FizzBuzz/Assembly]] |
|||
=={{header|68000 Assembly}}== |
|||
See [[FizzBuzz/Assembly]] |
|||
=={{header|8080 Assembly}}== |
|||
See [[FizzBuzz/Assembly]] |
|||
=={{header|8086 Assembly}}== |
|||
See [[FizzBuzz/Assembly]] |
|||
=={{header|8th}}== |
|||
<syntaxhighlight lang="forth"> |
|||
with: n |
|||
: num? \ n f -- ) |
|||
if drop else . then ; |
|||
\ is m mod n 0? leave the result twice on the stack |
|||
: div? \ m n -- f f |
|||
mod 0 = dup ; |
|||
: fizz? \ n -- n f |
|||
dup 3 |
|||
div? if "Fizz" . then ; |
|||
: buzz? \ n f -- n f |
|||
over 5 |
|||
div? if "Buzz" . then or ; |
|||
\ print a message as appropriate for the given number: |
|||
: fizzbuzz \ n -- |
|||
fizz? buzz? num? |
|||
space ; |
|||
\ iterate from 1 to 100: |
|||
' fizzbuzz 1 100 loop |
|||
cr bye |
|||
</syntaxhighlight> |
|||
=={{header|AArch64 Assembly}}== |
|||
{{works with|as|Raspberry Pi 3B version Buster 64 bits}} |
|||
<syntaxhighlight lang="aarch64 assembly"> |
|||
/* ARM assembly AARCH64 Raspberry PI 3B */ |
|||
/* program FizzBuzz64.s */ |
|||
/*******************************************/ |
|||
/* Constantes file */ |
|||
/*******************************************/ |
|||
/* for this file see task include a file in language AArch64 assembly*/ |
|||
.include "../includeConstantesARM64.inc" |
|||
/*******************************************/ |
|||
/* Initialized data */ |
|||
/*******************************************/ |
|||
.data |
|||
szMessFizz: .asciz "Fizz\n" |
|||
szMessBuzz: .asciz "Buzz\n" |
|||
szMessFizzBuzz: .asciz "FizzBuzz\n" |
|||
szMessNumber: .asciz "Number : @ " |
|||
szCarriageReturn: .asciz "\n" |
|||
/*******************************************/ |
|||
/* UnInitialized data */ |
|||
/*******************************************/ |
|||
.bss |
|||
sZoneConv: .skip 24 |
|||
/*******************************************/ |
|||
/* code section */ |
|||
/*******************************************/ |
|||
.text |
|||
.global main |
|||
main: // entry of program |
|||
mov x10,3 // divisor 3 |
|||
mov x11,5 // divisor 5 |
|||
mov x12,15 // divisor 15 |
|||
mov x13,1 // indice |
|||
1: // loop begin |
|||
udiv x14,x13,x12 // multiple 15 |
|||
msub x15,x14,x12,x13 // remainder |
|||
cbnz x15,2f // zero ? |
|||
mov x0,x13 |
|||
ldr x1,qAdrszMessFizzBuzz |
|||
bl displayResult |
|||
b 4f |
|||
2: // multiple 3 |
|||
udiv x14,x13,x10 |
|||
msub x15,x14,x10,x13 // remainder |
|||
cbnz x15,3f // zero ? |
|||
mov x0,x13 |
|||
ldr x1,qAdrszMessFizz |
|||
bl displayResult |
|||
b 4f |
|||
3: // multiple 5 |
|||
udiv x14,x13,x11 |
|||
msub x15,x14,x11,x13 // remainder |
|||
cbnz x15,4f // zero ? |
|||
mov x0,x13 |
|||
ldr x1,qAdrszMessBuzz |
|||
bl displayResult |
|||
4: |
|||
add x13,x13,1 // increment indice |
|||
cmp x13,100 // maxi ? |
|||
ble 1b |
|||
100: // standard end of the program |
|||
mov x8,EXIT // request to exit program |
|||
svc 0 // perform the system call |
|||
qAdrszMessFizzBuzz: .quad szMessFizzBuzz |
|||
qAdrszMessFizz: .quad szMessFizz |
|||
qAdrszMessBuzz: .quad szMessBuzz |
|||
/******************************************************************/ |
|||
/* Display résult */ |
|||
/******************************************************************/ |
|||
/* x0 contains the number*/ |
|||
/* x1 contains display string address */ |
|||
displayResult: |
|||
stp x2,lr,[sp,-16]! // save registers |
|||
mov x2,x1 |
|||
ldr x1,qAdrsZoneConv // conversion number |
|||
bl conversion10S // decimal conversion |
|||
ldr x0,qAdrszMessNumber |
|||
ldr x1,qAdrsZoneConv |
|||
bl strInsertAtCharInc // insert result at @ character |
|||
bl affichageMess // display message final |
|||
mov x0,x2 |
|||
bl affichageMess |
|||
ldp x2,lr,[sp],16 // restaur 2 registers |
|||
ret // return to address lr x30 |
|||
qAdrsZoneConv: .quad sZoneConv |
|||
qAdrszMessNumber: .quad szMessNumber |
|||
/********************************************************/ |
|||
/* File Include fonctions */ |
|||
/********************************************************/ |
|||
/* for this file see task include a file in language AArch64 assembly */ |
|||
.include "../includeARM64.inc" |
|||
</syntaxhighlight> |
|||
=={{header|ABAP}}== |
|||
===Impure Functional 1=== |
|||
{{works with|ABAP|7.4 SP05 or Above only}} |
|||
<syntaxhighlight lang="abap">DATA: tab TYPE TABLE OF string. |
|||
tab = VALUE #( |
|||
FOR i = 1 WHILE i <= 100 ( |
|||
COND string( LET r3 = i MOD 3 |
|||
r5 = i MOD 5 IN |
|||
WHEN r3 = 0 AND r5 = 0 THEN |FIZZBUZZ| |
|||
WHEN r3 = 0 THEN |FIZZ| |
|||
WHEN r5 = 0 THEN |BUZZ| |
|||
ELSE i ) ) ). |
|||
cl_demo_output=>write( tab ). |
|||
cl_demo_output=>display( ).</syntaxhighlight> |
|||
===Impure Functional 2=== |
|||
{{works with|ABAP|7.4 SP05 or Above only}} |
|||
<syntaxhighlight lang="abap">cl_demo_output=>display( value stringtab( for i = 1 until i > 100 |
|||
let fizz = cond #( when i mod 3 = 0 then |fizz| else space ) |
|||
buzz = cond #( when i mod 5 = 0 then |buzz| else space ) |
|||
fb = |{ fizz }{ buzz }| in |
|||
( switch #( fb when space then i else fb ) ) ) ).</syntaxhighlight> |
|||
=={{header|ABC}}== |
|||
<syntaxhighlight lang="ABC">HOW TO RETURN fizzbuzz num: |
|||
PUT "" IN result |
|||
PUT {[3]: "Fizz"; [5]: "Buzz"} IN divwords |
|||
FOR div IN keys divwords: |
|||
IF num mod div=0: |
|||
PUT result^divwords[div] IN result |
|||
IF result="": |
|||
PUT num>>0 IN result |
|||
RETURN result |
|||
FOR i IN {1..100}: |
|||
WRITE fizzbuzz i/</syntaxhighlight> |
|||
=={{header|ACL2}}== |
|||
<syntaxhighlight 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))</syntaxhighlight> |
|||
=={{header|Action!}}== |
|||
<syntaxhighlight lang="action!">PROC Main() |
|||
BYTE i,d3,d5 |
|||
d3=1 d5=1 |
|||
FOR i=1 TO 100 |
|||
DO |
|||
IF d3=0 AND d5=0 THEN |
|||
Print("FizzBuzz") |
|||
ELSEIF d3=0 THEN |
|||
Print("Fizz") |
|||
ELSEIF d5=0 THEN |
|||
Print("Buzz") |
|||
ELSE |
|||
PrintB(i) |
|||
FI |
|||
Put(32) |
|||
d3==+1 d5==+1 |
|||
IF d3=3 THEN d3=0 FI |
|||
IF d5=5 THEN d5=0 FI |
|||
OD |
|||
RETURN</syntaxhighlight> |
|||
{{out}} |
|||
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/FizzBuzz.png Screenshot from Atari 8-bit computer] |
|||
<pre> |
|||
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 |
|||
</pre> |
|||
=={{header|ActionScript}}== |
|||
The [[ActionScript]] solution works just like the [[FizzBuzz#JavaScript|JavaScript]] solution (they share the [[ECMAScript]] specification). The difference is that ActionScript has the ''trace'' command to write out to a console. |
|||
<syntaxhighlight 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); |
|||
}</syntaxhighlight> |
|||
=={{header|Ada}}== |
=={{header|Ada}}== |
||
<syntaxhighlight 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;</syntaxhighlight> |
|||
=={{header|Agda}}== |
|||
<syntaxhighlight lang="agda"> |
|||
module FizzBuzz where |
|||
open import Agda.Builtin.IO using (IO) |
|||
open import Agda.Builtin.Unit renaming (⊤ to Unit) |
|||
open import Data.Bool using (Bool ; false ; true ; if_then_else_) |
|||
open import Data.Nat using (ℕ ; zero ; suc ; _≡ᵇ_ ; _%_) |
|||
open import Data.Nat.Show using (show) |
|||
open import Data.List using (List ; [] ; _∷_ ; map) |
|||
open import Data.String using (String ; _++_ ; unlines) |
|||
postulate putStrLn : String -> IO Unit |
|||
{-# FOREIGN GHC import qualified Data.Text as T #-} |
|||
{-# COMPILE GHC putStrLn = putStrLn . T.unpack #-} |
|||
fizz : String |
|||
fizz = "Fizz" |
|||
buzz : String |
|||
buzz = "Buzz" |
|||
_isDivisibleBy_ : (n : ℕ) -> (m : ℕ) -> Bool |
|||
n isDivisibleBy zero = false |
|||
n isDivisibleBy (suc k) = ((n % (suc k)) ≡ᵇ 0) |
|||
getTerm : (n : ℕ) -> String |
|||
getTerm n = |
|||
if (n isDivisibleBy 15) then (fizz ++ buzz) |
|||
else if (n isDivisibleBy 3) then fizz |
|||
else if (n isDivisibleBy 5) then buzz |
|||
else (show n) |
|||
range : (a : ℕ) -> (b : ℕ) -> List (ℕ) |
|||
range k zero = [] |
|||
range k (suc m) = k ∷ (range (suc k) m) |
|||
getTerms : (n : ℕ) -> List (String) |
|||
getTerms n = map getTerm (range 1 n) |
|||
fizzBuzz : String |
|||
fizzBuzz = unlines (getTerms 100) |
|||
main : IO Unit |
|||
main = putStrLn fizzBuzz |
|||
</syntaxhighlight> |
|||
=={{header|ALGOL 68}}== |
=={{header|ALGOL 68}}== |
||
<syntaxhighlight lang="algol68">main:( |
|||
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 |
|||
)</syntaxhighlight> |
|||
) |
|||
or simply: |
|||
<syntaxhighlight lang="algol68">FOR i TO 100 DO print(((i%*15=0|"FizzBuzz"|:i%*3=0|"Fizz"|:i%*5=0|"Buzz"|i),new line)) OD</syntaxhighlight> |
|||
or only testing for divisibility by 3 and 5 (AND does not shortcut in Algol 68), as suggested in the [[#NewLISP]] second sample: |
|||
<syntaxhighlight> |
|||
FOR i TO 100 DO |
|||
IF IF i MOD 3 = 0 THEN print( "Fizz" ); FALSE ELSE TRUE FI |
|||
AND IF i MOD 5 = 0 THEN print( "Buzz" ); FALSE ELSE TRUE FI |
|||
THEN |
|||
print( ( whole( i, 0 ) ) ) |
|||
FI; |
|||
print( ( newline ) ) |
|||
OD |
|||
</syntaxhighlight> |
|||
=={{header|ALGOL-M}}== |
|||
<syntaxhighlight lang="algolm">BEGIN |
|||
INTEGER FUNCTION DIVBY(N, D); |
|||
INTEGER N; |
|||
INTEGER D; |
|||
BEGIN |
|||
DIVBY := 1 - (N - D * (N / D)); |
|||
END; |
|||
INTEGER I; |
|||
FOR I := 1 STEP 1 UNTIL 100 DO |
|||
BEGIN |
|||
IF DIVBY(I, 15) = 1 THEN |
|||
WRITE("FizzBuzz") |
|||
ELSE IF DIVBY(I, 5) = 1 THEN |
|||
WRITE("Buzz") |
|||
ELSE IF DIVBY(I, 3) = 1 THEN |
|||
WRITE("Fizz") |
|||
ELSE |
|||
WRITE(I); |
|||
END; |
|||
END</syntaxhighlight> |
|||
=={{header|ALGOL W}}== |
|||
<syntaxhighlight lang="algolw"> |
|||
begin |
|||
i_w := 1; % set integers to print in minimum space % |
|||
for i := 1 until 100 do begin |
|||
if i rem 15 = 0 then write( "FizzBuzz" ) |
|||
else if i rem 5 = 0 then write( "Buzz" ) |
|||
else if i rem 3 = 0 then write( "Fizz" ) |
|||
else write( i ) |
|||
end for_i |
|||
end.</syntaxhighlight> |
|||
=={{header|AntLang}}== |
|||
<syntaxhighlight lang="antlang">n:{1+ x}map range[100] |
|||
s:{a:0eq x mod 3;b:0eq x mod 5;concat apply{1elem x}map{0elem x}hfilter seq[1- max[a;b];a;b]merge seq[str[x];"Fizz";"Buzz"]}map n |
|||
echo map s</syntaxhighlight> |
|||
=={{header|APEX}}== |
|||
<syntaxhighlight lang="apex"> |
|||
for(integer i=1; i <= 100; i++){ |
|||
String output = ''; |
|||
if(math.mod(i, 3) == 0) output += 'Fizz'; |
|||
if(math.mod(i, 5) == 0) output += 'Buzz'; |
|||
if(output != ''){ |
|||
System.debug(output); |
|||
} else { |
|||
System.debug(i); |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|APL}}== |
=={{header|APL}}== |
||
<syntaxhighlight 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] |
|||
</syntaxhighlight> |
|||
=={{header|AWK}}== |
|||
Slightly different approach that makes use of the Decode function (⊥): |
|||
BEGIN { |
|||
<syntaxhighlight lang="apl"> |
|||
for (NUM=1; NUM<=100; NUM++) |
|||
A[I]←1+I←(0⍷A)/⍳⍴A←('FIZZBUZZ' 'FIZZ’ 'BUZZ' 0)[2⊥¨×(⊂3 5)|¨1+⍳100] |
|||
if (NUM % 15 == 0) |
|||
</syntaxhighlight> |
|||
{print "FizzBuzz"} |
|||
else if (NUM % 3 == 0) |
|||
The idea is to first calculate the residues for all numbers 1..100 after |
|||
{print "Fizz"} |
|||
division with both 3 and 5. This generates 100 pairs of numbers a b, where |
|||
else if (NUM % 5 == 0) |
|||
a is either 0,1,2 and b is either 0,1,2,3,4. |
|||
{print "Buzz"} |
|||
These pairs are then put through the sign function which returns 0 for a 0, |
|||
and a 1 for anything greater than 0. Now we have binary pairs. |
|||
The binary pairs are encoded with a left argument of 2 resulting in 0,1,2,3. |
|||
These are treated as indices for the "FizzBuzz vector" where 0 is in position 3. |
|||
Variable A holds this new vector of words and zeros. |
|||
Variable I is assigned the zeros' positions. |
|||
Finally A[I] is replaced with corresponding indices. |
|||
If you have an aversion against mixed vectors, consider inserting ⍕¨ before the |
|||
final (i.e. left-most) assignment. |
|||
{{works with|Dyalog_APL}} |
|||
Here's a Dyalog-specific solution taking advantage of its anonymous function extension: |
|||
<syntaxhighlight lang="apl">{ ⍵ 'Fizz' 'Buzz' 'FizzBuzz'[ +/1 2×0=3 5|⍵] }¨1+⍳100</syntaxhighlight> |
|||
A slightly different version that works both in Dyalog and GNU APL -- credit to Aniket Bhattacharyea, posted on codeburst.io (https://codeburst.io/fizzbuzz-in-apl-a193d1954b4b): |
|||
<syntaxhighlight lang="apl">{(‘FizzBuzz’ ‘Fizz’ ‘Buzz’,⍵)[(0=15 3 5|⍵)⍳1]}¨⍳100</syntaxhighlight> |
|||
Yet another solution, excessively commented: |
|||
{{works with|GNU_APL}} (and Dyalog, with [http://course.dyalog.com/autumn2021/Quirks/ ⎕ML ← 2]) |
|||
<syntaxhighlight lang="apl"> ∇ sv ← fizzbuzz n; t;d |
|||
[1] ⍝⍝ Solve the popular 'fizzbuzz' problem in APL. |
|||
[2] ⍝⍝ \param n - highest number to compute (≥0) |
|||
[3] ⍝⍝ \returns sv - a vector of strings representing the fizzbuzz solution for ⍳n |
|||
[4] ⍝⍝ (note we return a string vector to avoid a mixed-type result; remove the |
|||
[5] ⍝⍝ ⍕ function from the (⍕t[⍵]) term to see the difference). |
|||
[6] ⍝⍝⍝⍝ |
|||
[7] t←⍳n ⍝ the sequence 1..n itself which we'll pick from |
|||
[8] ⍝ ... or the words 'fizz', 'buzz', 'fizzbuzz' depending on |
|||
[9] ⍝ ... divisibility by 3 and/or 5 |
|||
[10] ⍝⎕←t ⍝ (Uncomment to see during call) |
|||
[11] |
|||
[12] d←1+(+⌿ ⊃ {((0=3|⍵)) (2×(0=5|⍵))} ⍳n) |
|||
[13] ⍝ || || | | | ↓↓ |
|||
[14] ⍝ || || | | | ⍳n: generate range (1..n) |
|||
[15] ⍝ || || | ↓.....................↓ ↓↓ |
|||
[16] ⍝ || || | A dfn (lambda) taking its right arg (⍵, ⍳n here) to compute two boolean |
|||
[17] ⍝ || || | vectors(v12): divisibility by 3 and 5, respectively, for each of ⍳n |
|||
[18] ⍝ || || ↓ |
|||
[19] ⍝ || || ⊃: Disclose ('lift-up' and pad w/zeros) the 'ragged' matrix of vectors (v12) |
|||
[20] ⍝ || || holding divisibility by 3 and 5 of each ⍳n |
|||
[21] ⍝ || ↓↓ |
|||
[22] ⍝ || +⌿: Sum (v12) row-wise to count divisibility (0=neither 3 nor 5, 1=3, 2=3 and 5) |
|||
[23] ⍝ ↓↓ |
|||
[24] ⍝ 1+: Add one to (v12) to make them 1-based for indexing below: |
|||
[25] ⍝⎕←d |
|||
[26] |
|||
[27] sv ← { ((⍕t[⍵]) 'Fizz' 'Buzz' 'FizzBuzz') [d[⍵]]}¨ ⍳n |
|||
[28] ⍝ | | | | | | |
|||
[29] ⍝ | | | ↓....↓ | |
|||
[30] ⍝ | |................................↓ idx | |
|||
[31] ⍝ | ( lookup output vector ) | |
|||
[32] ⍝ ↓...........................................↓ |
|||
[33] ⍝ A dfn (lambda) taking as its right arg (⍵) ⍳n and using the 'each' (¨) |
|||
[34] ⍝ operator to apply the lambda to each (idx) of ⍳n. |
|||
[35] |
|||
[36] ⍝⍝ USAGE |
|||
[37] ⍝⍝ ⎕ ← ,fizzbuzz 15 |
|||
[38] ⍝ 1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz |
|||
∇</syntaxhighlight> |
|||
I prefer the DRYness of solutions that don't have "FizzBuzz" as a separate case; here's such a solution that works with both Dyalog and GNU. You may want to prepend `⍬⊣` to the whole thing in GNU to keep it from returning the list as the value of the expression, causing the interpreter to print it out a second time. |
|||
{{works with|Dyalog APL}} |
|||
{{works with|GNU APL}} |
|||
<syntaxhighlight lang="apl">⎕io←1 |
|||
{⎕←∊'Fizz' 'Buzz'⍵/⍨d,⍱/d←0=3 5|⍵}¨⍳100</syntaxhighlight> |
|||
Explanation: |
|||
<pre> |
|||
⎕io←1 Set the index origin to 1; if it were set to 0, the next |
|||
step would count from 0 to 99 instead of 1 to 100. |
|||
{ }¨⍳100 Do the thing in braces for each integer from 1 through 100. |
|||
3 5|⍵ Make a list of the remainders when the current number is |
|||
divided by 3 and 5. |
|||
d←0= Make it a Boolean vector: true for remainder=0, false |
|||
otherwise. Name it d. |
|||
d,⍱/ Prepend d to the result of reducing itself with XNOR, |
|||
yielding a three-element Boolean vector. The first element |
|||
is true if the number is divisible by 3; the second if it's |
|||
divisible by 5; and the third only if it's divisible by |
|||
neither. |
|||
'Fizz' 'Buzz'⍵/⍨ Use the Boolean vector as a mask to select elements from |
|||
a new triple consisting of 'Fizz', 'Buzz', and the current |
|||
number. Each of the three elements will be included in the |
|||
selection only if the corresponding Boolean is true. |
|||
∊ Combine the selected elements into one vector/string |
|||
⎕← And print it out.</pre> |
|||
=={{header|AppleScript}}== |
|||
===Procedural=== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
---- |
|||
If this were a useful task requiring a degree of efficiency, it would be better to replace the cumulative text concatenations with additions to a fast-to-access list and coerce this list to text in one go at the end. Less critically, the <tt>(i mod … = 0)</tt> tests could be nested to reduce the number of these performed from 261 to 200: |
|||
<syntaxhighlight lang="applescript">on fizzBuzz(n) |
|||
script o |
|||
property output : {} |
|||
end script |
|||
repeat with i from 1 to n |
|||
if (i mod 3 = 0) then |
|||
if (i mod 15 = 0) then |
|||
set end of o's output to "FizzBuzz" |
|||
else |
|||
set end of o's output to "Fizz" |
|||
end if |
|||
else if (i mod 5 = 0) then |
|||
set end of o's output to "Buzz" |
|||
else |
else |
||
set end of o's output to i |
|||
end if |
|||
} |
|||
end repeat |
|||
set astid to AppleScript's text item delimiters |
|||
set AppleScript's text item delimiters to linefeed |
|||
set output to o's output as text |
|||
set AppleScript's text item delimiters to astid |
|||
return output |
|||
end fizzBuzz |
|||
fizzBuzz(100)</syntaxhighlight> |
|||
Another alternative would be simply to fill the list with numbers and then go through it again three times overwriting the relevant slots with the appropriate words: |
|||
<syntaxhighlight lang="applescript">on fizzBuzz(n) |
|||
script o |
|||
property output : {} |
|||
end script |
|||
repeat with i from 1 to n |
|||
set end of o's output to i |
|||
end repeat |
|||
repeat with x in {{3, "Fizz"}, {5, "Buzz"}, {15, "FizzBuzz"}} |
|||
set {m, t} to x |
|||
repeat with i from m to n by m |
|||
set item i of o's output to t |
|||
end repeat |
|||
end repeat |
|||
set astid to AppleScript's text item delimiters |
|||
set AppleScript's text item delimiters to linefeed |
|||
set output to o's output as text |
|||
set AppleScript's text item delimiters to astid |
|||
return output |
|||
end fizzBuzz |
|||
fizzBuzz(100)</syntaxhighlight> |
|||
With the number of numbers raised from 100 to 10,000, the two scripts inserted here take around 0.051 seconds to execute on my current machine, the original AppleScript above around 0.25 seconds, and the one below (originally described as "functional composition") 3.52 seconds. |
|||
---- |
|||
===Functional=== |
|||
For simplicity, and more efficient use of the scripter's time: |
|||
<syntaxhighlight lang="applescript">------------------------- FIZZBUZZ ------------------------- |
|||
-- fizz :: Int -> Bool |
|||
on fizz(n) |
|||
n mod 3 = 0 |
|||
end fizz |
|||
-- buzz :: Int -> Bool |
|||
on buzz(n) |
|||
n mod 5 = 0 |
|||
end buzz |
|||
-- fizzAndBuzz :: Int -> Bool |
|||
on fizzAndBuzz(n) |
|||
n mod 15 = 0 |
|||
end fizzAndBuzz |
|||
-- fizzBuzz :: Int -> String |
|||
on fizzBuzz(x) |
|||
caseOf(x, [[my fizzAndBuzz, "FizzBuzz"], ¬ |
|||
[my fizz, "Fizz"], ¬ |
|||
[my buzz, "Buzz"]], x as string) |
|||
end fizzBuzz |
|||
--------------------------- TEST --------------------------- |
|||
on run |
|||
intercalate(linefeed, ¬ |
|||
map(fizzBuzz, enumFromTo(1, 100))) |
|||
end run |
|||
-------------------- GENERIC FUNCTIONS --------------------- |
|||
-- caseOf :: a -> [(predicate, b)] -> Maybe b -> Maybe b |
|||
on caseOf(e, lstPV, default) |
|||
repeat with lstCase in lstPV |
|||
set {p, v} to contents of lstCase |
|||
if mReturn(p)'s |λ|(e) then return v |
|||
end repeat |
|||
return default |
|||
end caseOf |
|||
-- enumFromTo :: Int -> Int -> [Int] |
|||
on enumFromTo(m, n) |
|||
if m > n then |
|||
set d to -1 |
|||
else |
|||
set d to 1 |
|||
end if |
|||
set lst to {} |
|||
repeat with i from m to n by d |
|||
set end of lst to i |
|||
end repeat |
|||
return lst |
|||
end enumFromTo |
|||
-- intercalate :: Text -> [Text] -> Text |
|||
on intercalate(strText, lstText) |
|||
set {dlm, my text item delimiters} to {my text item delimiters, strText} |
|||
set strJoined to lstText as text |
|||
set my text item delimiters to dlm |
|||
return strJoined |
|||
end intercalate |
|||
-- map :: (a -> b) -> [a] -> [b] |
|||
on map(f, xs) |
|||
tell mReturn(f) |
|||
set lng to length of xs |
|||
set lst to {} |
|||
repeat with i from 1 to lng |
|||
set end of lst to |λ|(item i of xs, i, xs) |
|||
end repeat |
|||
return lst |
|||
end tell |
|||
end map |
|||
-- Lift 2nd class handler function into 1st class script wrapper |
|||
-- mReturn :: Handler -> Script |
|||
on mReturn(f) |
|||
if class of f is script then |
|||
f |
|||
else |
|||
script |
|||
property |λ| : f |
|||
end script |
|||
end if |
|||
end mReturn</syntaxhighlight> |
|||
=={{header|Applesoft BASIC}}== |
|||
See [[FizzBuzz/Basic]] |
|||
=={{header|Arbre}}== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
=={{header|Arc}}== |
|||
===Arc 3.1 Base=== |
|||
<syntaxhighlight lang="lisp">(for n 1 100 |
|||
(prn:if |
|||
(multiple n 15) 'FizzBuzz |
|||
(multiple n 5) 'Buzz |
|||
(multiple n 3) 'Fizz |
|||
n))</syntaxhighlight> |
|||
<syntaxhighlight lang="lisp">(for n 1 100 |
|||
(prn:check (string (when (multiple n 3) 'Fizz) |
|||
(when (multiple n 5) 'Buzz)) |
|||
~empty n)) ; check created string not empty, else return n</syntaxhighlight> |
|||
===Waterhouse Arc=== |
|||
<syntaxhighlight lang="lisp">(for n 1 100 |
|||
(prn:case (gcd n 15) |
|||
1 n |
|||
3 'Fizz |
|||
5 'Buzz |
|||
'FizzBuzz))</syntaxhighlight> |
|||
=={{header|ARM Assembly}}== |
|||
<syntaxhighlight lang="arm_assembly"> |
|||
/ * linux GAS */ |
|||
.global _start |
|||
.data |
|||
Fizz: .ascii "Fizz\n" |
|||
Buzz: .ascii "Buzz\n" |
|||
FizzAndBuzz: .ascii "FizzBuzz\n" |
|||
numstr_buffer: .skip 3 |
|||
newLine: .ascii "\n" |
|||
.text |
|||
_start: |
|||
bl FizzBuzz |
|||
mov r7, #1 |
|||
mov r0, #0 |
|||
svc #0 |
|||
FizzBuzz: |
|||
push {lr} |
|||
mov r9, #100 |
|||
fizzbuzz_loop: |
|||
mov r0, r9 |
|||
mov r1, #15 |
|||
bl divide |
|||
cmp r1, #0 |
|||
ldreq r1, =FizzAndBuzz |
|||
moveq r2, #9 |
|||
beq fizzbuzz_print |
|||
mov r0, r9 |
|||
mov r1, #3 |
|||
bl divide |
|||
cmp r1, #0 |
|||
ldreq r1, =Fizz |
|||
moveq r2, #5 |
|||
beq fizzbuzz_print |
|||
mov r0, r9 |
|||
mov r1, #5 |
|||
bl divide |
|||
cmp r1, #0 |
|||
ldreq r1, =Buzz |
|||
moveq r2, #5 |
|||
beq fizzbuzz_print |
|||
mov r0, r9 |
|||
bl make_num |
|||
mov r2, r1 |
|||
mov r1, r0 |
|||
fizzbuzz_print: |
|||
mov r0, #1 |
|||
mov r7, #4 |
|||
svc #0 |
|||
sub r9, #1 |
|||
cmp r9, #0 |
|||
bgt fizzbuzz_loop |
|||
pop {lr} |
|||
mov pc, lr |
|||
make_num: |
|||
push {lr} |
|||
ldr r4, =numstr_buffer |
|||
mov r5, #4 |
|||
mov r6, #1 |
|||
mov r1, #100 |
|||
bl divide |
|||
cmp r0, #0 |
|||
subeq r5, #1 |
|||
movne r6, #0 |
|||
add r0, #48 |
|||
strb r0, [r4, #0] |
|||
mov r0, r1 |
|||
mov r1, #10 |
|||
bl divide |
|||
cmp r0, #0 |
|||
movne r6, #0 |
|||
cmp r6, #1 |
|||
subeq r5, #1 |
|||
add r0, #48 |
|||
strb r0, [r4, #1] |
|||
add r1, #48 |
|||
strb r1, [r4, #2] |
|||
mov r2, #4 |
|||
sub r0, r2, r5 |
|||
add r0, r4, r0 |
|||
mov r1, r5 |
|||
pop {lr} |
|||
mov pc, lr |
|||
divide: |
|||
udiv r2, r0, r1 |
|||
mul r3, r1, r2 |
|||
sub r1, r0, r3 |
|||
mov r0, r2 |
|||
mov pc, lr |
|||
</syntaxhighlight> |
|||
=={{header|Arturo}}== |
|||
<syntaxhighlight lang="rebol">loop 1..100 [x][ |
|||
case [] |
|||
when? [0=x%15] -> print "FizzBuzz" |
|||
when? [0=x%3] -> print "Fizz" |
|||
when? [0=x%5] -> print "Buzz" |
|||
else -> print x |
|||
]</syntaxhighlight> |
|||
{{out}} |
|||
<pre>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</pre> |
|||
=={{header|AsciiDots}}== |
|||
See [[FizzBuzz/EsoLang#AsciiDots]] |
|||
=={{header|ASIC}}== |
|||
See [[FizzBuzz/Basic]] |
|||
=={{header|Asymptote}}== |
|||
<syntaxhighlight lang="asymptote">for(int number = 1; number <= 100; ++number) { |
|||
if (number % 15 == 0) { |
|||
write("FizzBuzz"); |
|||
} else { |
|||
if (number % 3 == 0) { |
|||
write("Fizz"); |
|||
} else { |
|||
if (number % 5 == 0) { |
|||
write("Buzz"); |
|||
} else { |
|||
write(number); |
|||
} |
|||
} |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|ATS}}== |
|||
<syntaxhighlight lang="ats">#include "share/atspre_staload.hats" |
|||
implement main0() = loop(1, 100) where { |
|||
fun loop(from: int, to: int): void = |
|||
if from > to then () else |
|||
let |
|||
val by3 = (from % 3 = 0) |
|||
val by5 = (from % 5 = 0) |
|||
in |
|||
case+ (by3, by5) of |
|||
| (true, true) => print_string("FizzBuzz") |
|||
| (true, false) => print_string("Fizz") |
|||
| (false, true) => print_string("Buzz") |
|||
| (false, false) => print_int(from); |
|||
print_newline(); |
|||
loop(from+1, to) |
|||
end |
|||
}</syntaxhighlight> |
|||
=={{header|AutoHotkey}}== |
|||
{{AutoHotkey case}} |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
A short example with cascading ternary operators and graphical output. Press Esc to close the window. |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
=={{header|AutoIt}}== |
|||
===Example1=== |
|||
Output via MsgBox(): |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
===Example2=== |
|||
Output via console, logfile and/or messagebox: |
|||
<syntaxhighlight lang="autoit">#include <Constants.au3> |
|||
; uncomment how you want to do the output |
|||
Func Out($Msg) |
|||
ConsoleWrite($Msg & @CRLF) |
|||
;~ FileWriteLine("FizzBuzz.Log", $Msg) |
|||
;~ $Btn = MsgBox($MB_OKCANCEL + $MB_ICONINFORMATION, "FizzBuzz", $Msg) |
|||
;~ If $Btn > 1 Then Exit ; Pressing 'Cancel'-button aborts the program |
|||
EndFunc ;==>Out |
|||
Out("# FizzBuzz:") |
|||
For $i = 1 To 100 |
|||
If Mod($i, 15) = 0 Then |
|||
Out("FizzBuzz") |
|||
ElseIf Mod($i, 5) = 0 Then |
|||
Out("Buzz") |
|||
ElseIf Mod($i, 3) = 0 Then |
|||
Out("Fizz") |
|||
Else |
|||
Out($i) |
|||
EndIf |
|||
Next |
|||
Out("# Done.")</syntaxhighlight> |
|||
=={{header|Avail}}== |
|||
<syntaxhighlight lang="avail">For each i from 1 to 100 do [ |
|||
Print: |
|||
if i mod 15 = 0 then ["FizzBuzz"] |
|||
else if i mod 3 = 0 then ["Fizz"] |
|||
else if i mod 5 = 0 then ["Buzz"] |
|||
else [“i”] |
|||
++ "\n"; |
|||
];</syntaxhighlight> |
|||
=={{header|AWK}}== |
|||
See [[FizzBuzz/AWK]] |
|||
=={{header|Axe}}== |
|||
<syntaxhighlight lang="axe">For(I,1,100) |
|||
!If I^3??I^5 |
|||
Disp "FIZZBUZZ",i |
|||
Else!If I^3 |
|||
Disp "FIZZ",i |
|||
Else!If I^5 |
|||
Disp "BUZZ",i |
|||
Else |
|||
Disp I▶Dec,i |
|||
End |
|||
.Pause to allow the user to actually read the output |
|||
Pause 1000 |
|||
End</syntaxhighlight> |
|||
=={{header|Babel}}== |
|||
<syntaxhighlight lang="babel">main: |
|||
{ { iter 1 + dup |
|||
15 % |
|||
{ "FizzBuzz" << |
|||
zap } |
|||
{ dup |
|||
3 % |
|||
{ "Fizz" << |
|||
zap } |
|||
{ dup |
|||
5 % |
|||
{ "Buzz" << |
|||
zap} |
|||
{ %d << } |
|||
if } |
|||
if } |
|||
if |
|||
"\n" << } |
|||
100 times }</syntaxhighlight> |
|||
=={{header|BabyCobol}}== |
|||
<syntaxhighlight lang="cobol"> |
|||
* NB: ANY does not exist in BabyCobol so the elegant |
|||
* EVALUATE-based COBOL-style solution is impossible here. |
|||
* Note the subtly unbalanced IF/ENDs yet valid END at the end. |
|||
IDENTIFICATION DIVISION. |
|||
PROGRAM-ID. FIZZBUZZ. |
|||
DATA DIVISION. |
|||
01 INT PICTURE IS 9(3). |
|||
01 REM LIKE INT. |
|||
01 TMP LIKE INT. |
|||
PROCEDURE DIVISION. |
|||
LOOP VARYING INT TO 100 |
|||
DIVIDE 3 INTO INT GIVING TMP REMAINDER REM |
|||
IF REM = 0 |
|||
THEN DISPLAY "Fizz" WITH NO ADVANCING |
|||
DIVIDE 5 INTO INT GIVING TMP REMAINDER REM |
|||
IF REM = 0 |
|||
THEN DISPLAY "Buzz" WITH NO ADVANCING |
|||
DIVIDE 15 INTO INT GIVING TMP REMAINDER REM |
|||
IF REM = 0 |
|||
THEN DISPLAY "" |
|||
ELSE DISPLAY INT |
|||
END. |
|||
</syntaxhighlight> |
|||
=={{header|BaCon}}== |
|||
See [[FizzBuzz/Basic#BaCon]] |
|||
=={{header|bash}}== |
|||
Any bash hacker would do this as a one liner at the shell, so... |
|||
<syntaxhighlight lang="bash">for n in {1..100}; do ((( n % 15 == 0 )) && echo 'FizzBuzz') || ((( n % 5 == 0 )) && echo 'Buzz') || ((( n % 3 == 0 )) && echo 'Fizz') || echo $n; done</syntaxhighlight> |
|||
For the sake of readability... |
|||
<syntaxhighlight lang="bash">for n in {1..100}; do |
|||
((( n % 15 == 0 )) && echo 'FizzBuzz') || |
|||
((( n % 5 == 0 )) && echo 'Buzz') || |
|||
((( n % 3 == 0 )) && echo 'Fizz') || |
|||
echo $n; |
|||
done</syntaxhighlight> |
|||
Here's a very concise approach, with only 75 characters total. |
|||
Unfortunately it relies on aspects of Bash which are rarely used. |
|||
<syntaxhighlight lang="bash">for i in {1..100};do((i%3))&&x=||x=Fizz;((i%5))||x+=Buzz;echo ${x:-$i};done</syntaxhighlight> |
|||
Here's the concise approach again, this time separated into multiple lines. |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
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, |
|||
=={{header|BASIC}}== |
=={{header|BASIC}}== |
||
See [[FizzBuzz/Basic]] |
|||
{{works with|QuickBasic|4.5}} |
|||
===If/else ladder approach=== |
|||
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 |
|||
=={{header|Basic09}}== |
|||
===Concatenation approach=== |
|||
See [[FizzBuzz/Basic]] |
|||
FOR A = 1 TO 100 |
|||
OUT$ = "" |
|||
=={{header|BASIC256}}== |
|||
IF A MOD 3 = 0 THEN |
|||
See [[FizzBuzz/Basic]] |
|||
OUT$ = OUT& + "Fizz" |
|||
END IF |
|||
=={{header|Batch File}}== |
|||
FOR /L version: |
|||
<syntaxhighlight 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 |
|||
</syntaxhighlight> |
|||
Loop version: |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
FOR /L with a block instead of very-high-overhead subroutine call: |
|||
<syntaxhighlight lang="dos">@echo off & setlocal enabledelayedexpansion |
|||
for /l %%i in (1,1,100) do ( |
|||
set /a m5=%%i %% 5 |
|||
set /a m3=%%i %% 3 |
|||
set s= |
|||
if !m5! equ 0 set s=!s!Fizz |
|||
if !m3! equ 0 set s=!s!Buzz |
|||
if "!s!"=="" set s=%%i |
|||
echo !s! |
|||
)</syntaxhighlight> |
|||
=={{header|BBC BASIC}}== |
|||
See [[FizzBuzz/Basic]] |
|||
=={{header|bc}}== |
|||
This solution never uses <tt>else</tt>, because bc has no <tt>else</tt> keyword (but some implementations add <tt>else</tt> as an extension). |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
=={{header|BCPL}}== |
|||
<syntaxhighlight lang="bcpl">GET "libhdr" |
|||
LET start() BE $( |
|||
FOR i=1 TO 100 DO $( |
|||
TEST (i REM 15) = 0 THEN |
|||
writes("FizzBuzz") |
|||
ELSE TEST (i REM 3) = 0 THEN |
|||
writes("Fizz") |
|||
ELSE TEST (i REM 5) = 0 THEN |
|||
writes("Buzz") |
|||
ELSE |
|||
writen(i, 0) |
|||
newline() |
|||
$) |
|||
$) |
|||
</syntaxhighlight> |
|||
=={{header|beeswax}}== |
|||
Also see on [[FizzBuzz/EsoLang]] |
|||
“Ordinary” FizzBuzz solution: |
|||
<syntaxhighlight lang="beeswax"> > q |
|||
>@F5~%"d@F{ > @F q |
|||
_1>F3~%'d`Fizz`@F5~%'d >`Buzz`@FNp |
|||
;bL@~.~4~.5~5@ P<</syntaxhighlight> |
|||
Example without double mod 5 check, using a flag instead, to check if Fizz already got printed (in this case the number n must not be printed if mod 5 is > 0): |
|||
<syntaxhighlight lang="beeswax"> >@?q |
|||
> q >Ag'd@{?p |
|||
_>"1F3~%'d`Fizz`f>@F5~%'d`Buzz`@p |
|||
b P~;"-~@~.+0~P9@N?<</syntaxhighlight> |
|||
=={{header|Befunge}}== |
|||
See [[FizzBuzz/EsoLang]] |
|||
=={{header|blz}}== |
|||
<syntaxhighlight lang="blz">for i = 0; i <= 100; i++ |
|||
out = "" |
|||
if i % 3 == 0 |
|||
out = "Fizz" |
|||
end |
|||
if i % 5 == 0 |
|||
out = out + "Buzz" |
|||
end |
|||
if out == "" |
|||
out = i |
|||
end |
|||
print(out) |
|||
end</syntaxhighlight> |
|||
=={{header|Boo}}== |
|||
<syntaxhighlight 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)</syntaxhighlight> |
|||
=={{header|BQN}}== |
|||
<syntaxhighlight lang="bqn">(∾´∾⟜"Fizz"‿"Buzz"/˜·(¬∨´)⊸∾0=3‿5|⊢)¨1+↕100</syntaxhighlight> |
|||
Using the Catch modifier for flow control |
|||
<syntaxhighlight lang="bqn">((∾´"fizz"‿"buzz"/˜0=3‿5|⊢)⎊⊢)¨1+↕100</syntaxhighlight> |
|||
Using the Choose Combonator with a rank 2 array |
|||
<syntaxhighlight lang="bqn">(3‿5 (0=|)◶[⊢‿"fizz","buzz"‿"fizzbuzz"] ⊢)¨ 1+↕100</syntaxhighlight> |
|||
=={{header|Bracmat}}== |
|||
<syntaxhighlight 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))</syntaxhighlight> |
|||
Same code, pretty printed: |
|||
<syntaxhighlight 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 |
|||
) |
|||
)</syntaxhighlight> |
|||
=={{header|Brainf***}}== |
|||
See [[FizzBuzz/EsoLang]] |
|||
=={{header|Brat}}== |
|||
<syntaxhighlight 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 } |
|||
} |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|BrightScript (for Roku)}}== |
|||
<syntaxhighlight lang="brightscript">FOR i = 1 TO 100 |
|||
fz = i MOD 3 = 0 |
|||
bz = i MOD 5 = 0 |
|||
IF fz OR bz |
|||
IF fz AND NOT bz: str = "Fizz" |
|||
ELSEIF bz AND NOT fz: str = "Buzz" |
|||
ELSE str = "FizzBuzz" |
|||
END IF |
|||
ELSE |
|||
str = i.ToStr() |
|||
END IF |
|||
? str |
|||
END FOR</syntaxhighlight> |
|||
=={{header|Bruijn}}== |
|||
<syntaxhighlight lang="bruijn"> |
|||
:import std/Combinator . |
|||
:import std/String . |
|||
:import std/Number . |
|||
main [y [[0 =? (+101) case-end case-rec]] (+1)] |
|||
case-rec str ++ "\n" ++ (1 ++0) |
|||
str fizzbuzz "FizzBuzz" (fizz "Fizz" (buzz "Buzz" (number→string 0))) |
|||
fizz =?(0 % (+3)) |
|||
buzz =?(0 % (+5)) |
|||
fizzbuzz fizz buzz fizz |
|||
case-end empty |
|||
</syntaxhighlight> |
|||
=={{header|C}}== |
|||
For 2 prime numbers and based on a similar minimal [[#JavaScript|JavaScript]] solution with low signal-to-noise, the C code is: |
|||
<syntaxhighlight lang="c"> int i = 0 ; char B[88] ; |
|||
while ( i++ < 100 ) |
|||
!sprintf( B, "%s%s", i%3 ? "":"Fizz", i%5 ? "":"Buzz" ) |
|||
? sprintf( B, "%d", i ):0, printf( ", %s", B );</syntaxhighlight> |
|||
With 4 prime numbers: |
|||
<syntaxhighlight lang="c"> int i = 0 ; char B[88] ; |
|||
while ( i++ < 100 ) |
|||
!sprintf( B, "%s%s%s%s", |
|||
i%3 ? "":"Fiz", i%5 ? "":"Buz", i%7 ? "":"Goz", i%11 ? "":"Kaz" ) |
|||
? sprintf( B, "%d", i ):0, printf( ", %s", B );</syntaxhighlight> |
|||
<syntaxhighlight lang="c">Output: ..., 89, FizBuz, Goz, 92, Fiz, 94, Buz, Fiz, 97, Goz, FizKaz, Buz</syntaxhighlight> |
|||
One line version, with pretty printing |
|||
<syntaxhighlight lang="c">#include <stdio.h> |
|||
int main() { |
|||
for (int i=1; i<=105; i++) if (i%3 && i%5) printf("%3d ", i); else printf("%s%s%s", i%3?"":"Fizz", i%5?"":"Buzz", i%15?" ":"\n"); |
|||
} |
|||
</syntaxhighlight> |
|||
This actually works (the array init part, saves 6 bytes of static data, whee):<syntaxhighlight lang="c">#include<stdio.h> |
|||
int main () |
|||
IF A MOD 5 = 0 THEN |
|||
{ |
|||
OUT$ = OUT$ + "Buzz" |
|||
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; |
|||
END IF |
|||
}</syntaxhighlight> |
|||
<syntaxhighlight 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; |
|||
}</syntaxhighlight> |
|||
Implicit int main and return 0 (C99+): |
|||
<syntaxhighlight lang="c">#include <stdio.h> |
|||
main() { |
|||
PRINT OUT$ |
|||
int i = 1; |
|||
NEXT A |
|||
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++; |
|||
} |
|||
}</syntaxhighlight> |
|||
obfuscated: |
|||
<syntaxhighlight 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;}</syntaxhighlight> |
|||
With numbers theory: <syntaxhighlight lang="c">#include <stdio.h> |
|||
See also: [[FizzBuzz#RapidQ|RapidQ]] |
|||
int main(void) |
|||
=={{header|C}}== |
|||
{ |
|||
for (int i = 1; i <= 100; ++i) { |
|||
if (i % 3 == 0) printf("fizz"); |
|||
if (i % 5 == 0) printf("buzz"); |
|||
if (i * i * i * i % 15 == 1) printf("%d", i); |
|||
puts(""); |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
Without conditionals, anything in the loop body gcc compiles with branching, duplicate tests or duplicate strings. Depends on ASCII and two's complement arithmetic: |
|||
#include<stdio.h> |
|||
<syntaxhighlight lang="c">#include <stdio.h> |
|||
int main() |
|||
{ |
|||
for (int i=0;++i<101;puts("")) |
|||
{ |
|||
char f[] = "FizzBuzz%d"; |
|||
f[8-i%5&12]=0; |
|||
printf (f+(-i%3&4+f[8]/8), i); |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|C sharp|C#}}== |
|||
<syntaxhighlight lang="csharp">class Program |
|||
{ |
|||
public void FizzBuzzGo() |
|||
{ |
|||
Boolean Fizz = false; |
|||
Boolean Buzz = false; |
|||
for (int count = 1; count <= 100; count ++) |
|||
{ |
|||
Fizz = count % 3 == 0; |
|||
Buzz = count % 5 == 0; |
|||
if (Fizz && Buzz) |
|||
{ |
|||
Console.WriteLine("Fizz Buzz"); |
|||
listBox1.Items.Add("Fizz Buzz"); |
|||
} |
|||
else if (Fizz) |
|||
{ |
|||
Console.WriteLine("Fizz"); |
|||
listBox1.Items.Add("Fizz"); |
|||
} |
|||
else if (Buzz) |
|||
{ |
|||
Console.WriteLine("Buzz"); |
|||
listBox1.Items.Add("Buzz"); |
|||
} |
|||
else |
|||
{ |
|||
Console.WriteLine(count); |
|||
listBox1.Items.Add(count); |
|||
} |
|||
} |
|||
} |
|||
}</syntaxhighlight> |
|||
<syntaxhighlight lang="csharp">class Program |
|||
{ |
|||
static void Main() |
|||
{ |
|||
for (uint i = 1; i <= 100; i++) |
|||
{ |
|||
string s = null; |
|||
if (i % 3 == 0) |
|||
int main (void) |
|||
s = "Fizz"; |
|||
{ |
|||
int i; |
|||
if (i % 5 == 0) |
|||
s += "Buzz"; |
|||
{ |
|||
if (!(i % 15)) |
|||
System.Console.WriteLine(s ?? i.ToString()); |
|||
} |
|||
} |
|||
printf ("Fizz\n"); |
|||
}</syntaxhighlight> |
|||
else if (!(i % 5)) |
|||
printf ("Buzz\n"); |
|||
<syntaxhighlight lang="csharp">using System; |
|||
else |
|||
using System.Linq; |
|||
printf ("%d\n", i); |
|||
} |
|||
namespace FizzBuzz |
|||
return 0; |
|||
{ |
|||
} |
|||
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); |
|||
} |
|||
} |
|||
}</syntaxhighlight> |
|||
<syntaxhighlight 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); |
|||
} |
|||
} |
|||
}</syntaxhighlight> |
|||
<syntaxhighlight lang="csharp">using System; |
|||
namespace FizzBuzz |
|||
{ |
|||
class Program |
|||
{ |
|||
static void Main(string[] args) |
|||
{ |
|||
for (int i = 1; i <= 100; i++) |
|||
{ |
|||
if (i % 15 == 0) |
|||
{ |
|||
Console.WriteLine("FizzBuzz"); |
|||
} |
|||
else if (i % 3 == 0) |
|||
{ |
|||
Console.WriteLine("Fizz"); |
|||
} |
|||
else if (i % 5 == 0) |
|||
{ |
|||
Console.WriteLine("Buzz"); |
|||
} |
|||
else |
|||
{ |
|||
Console.WriteLine(i); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
}</syntaxhighlight> |
|||
<syntaxhighlight 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); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
}</syntaxhighlight> |
|||
<syntaxhighlight lang="csharp">using System; |
|||
using System.Linq; |
|||
namespace FizzBuzz |
|||
{ |
|||
class Program |
|||
{ |
|||
static void Main(string[] args) |
|||
{ |
|||
Enumerable.Range(1, 100).ToList().ForEach(i => Console.WriteLine(i % 5 == 0 ? string.Format(i % 3 == 0 ? "Fizz{0}" : "{0}", "Buzz") : string.Format(i%3 == 0 ? "Fizz" : i.ToString()))); |
|||
} |
|||
} |
|||
}</syntaxhighlight> |
|||
===With C#8 switch expressions=== |
|||
<syntaxhighlight lang="csharp">class Program |
|||
{ |
|||
public static string FizzBuzzIt(int n) => |
|||
(n % 3, n % 5) switch |
|||
{ |
|||
(0, 0) => "FizzBuzz", |
|||
(0, _) => "Fizz", |
|||
(_, 0) => "Buzz", |
|||
(_, _) => $"{n}" |
|||
}; |
|||
static void Main(string[] args) |
|||
{ |
|||
foreach (var n in Enumerable.Range(1, 100)) |
|||
{ |
|||
Console.WriteLine(FizzBuzzIt(n)); |
|||
} |
|||
} |
|||
}</syntaxhighlight> |
|||
===TDD using delegates=== |
|||
<syntaxhighlight 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; |
|||
} |
|||
} |
|||
}</syntaxhighlight> |
|||
===Good old C ways=== |
|||
<syntaxhighlight lang="csharp">using System; |
|||
int max = 100; |
|||
for(int i=0; |
|||
++i<=max; |
|||
Console.WriteLine("{0}{1}{2}", i%3==0 ? "Fizz" : "", i%5==0 ? "Buzz" : "", i%3!=0 && i%5!=0 ? i.ToString() : "") |
|||
){} |
|||
</syntaxhighlight> |
|||
=={{header|C++}}== |
=={{header|C++}}== |
||
===minimal conditions=== |
|||
<cpp> |
|||
#include <iostream> |
<syntaxhighlight lang="cpp">#include <iostream> |
||
#include <chrono> |
|||
int main() |
|||
using namespace std; |
|||
{ |
|||
int main () { |
|||
int fizz = 0, buzz = 0, fizzbuzz = 0; |
|||
for (i = 0; i <= 100; i++) { |
|||
bool isFizz = false; |
|||
if (!(i % 15)) |
|||
cout << "FizzBuzz" << endl; |
|||
auto startTime = std::chrono::high_resolution_clock::now(); |
|||
else if (!(i % 3)) |
|||
cout << "Fizz" << endl; |
|||
for (unsigned int i = 1; i <= 4000000000; i++) { |
|||
else if (!(i % 5)) |
|||
isFizz = false; |
|||
cout << "Buzz" << endl; |
|||
if (i % 3 == 0) { |
|||
isFizz = true; |
|||
fizz++; |
|||
} |
|||
if (i % 5 == 0) { |
|||
if (isFizz) { |
|||
fizz--; |
|||
fizzbuzz++; |
|||
} |
|||
else { |
|||
buzz++; |
|||
} |
|||
} |
|||
} |
|||
auto endTime = std::chrono::high_resolution_clock::now(); |
|||
auto totalTime = endTime - startTime; |
|||
printf("\t fizz : %d, buzz: %d, fizzbuzz: %d, duration %lld milliseconds\n", fizz, buzz, fizzbuzz, (totalTime / std::chrono::milliseconds(1))); |
|||
return 0; |
|||
} |
|||
</syntaxhighlight> |
|||
===with modulo=== |
|||
<syntaxhighlight lang="cpp">#include <iostream> |
|||
using namespace std; |
|||
int main () |
|||
{ |
|||
for (int i = 1; i <= 100; i++) |
|||
{ |
|||
if ((i % 15) == 0) |
|||
cout << "FizzBuzz\n"; |
|||
else if ((i % 3) == 0) |
|||
cout << "Fizz\n"; |
|||
else if ((i % 5) == 0) |
|||
cout << "Buzz\n"; |
|||
else |
else |
||
cout << i << |
cout << i << "\n"; |
||
} |
} |
||
return 0; |
return 0; |
||
}</syntaxhighlight> |
|||
} |
|||
===without modulo 15=== |
|||
</cpp> |
|||
<syntaxhighlight lang="cpp">#include <iostream> |
|||
using namespace std; |
|||
Alternate version not using modulo 15: |
|||
<cpp> |
|||
#include <iostream> |
|||
int main() |
int main() |
||
Line 143: | Line 1,934: | ||
for (int i = 0; i <= 100; ++i) |
for (int i = 0; i <= 100; ++i) |
||
{ |
{ |
||
bool fizz = |
bool fizz = (i % 3) == 0; |
||
bool buzz = |
bool buzz = (i % 5) == 0; |
||
if (fizz) |
if (fizz) |
||
cout << "Fizz"; |
|||
if (buzz) |
if (buzz) |
||
cout << "Buzz"; |
|||
if (!fizz && !buzz) |
if (!fizz && !buzz) |
||
cout << i; |
|||
cout << "\n"; |
|||
} |
} |
||
return 0; |
|||
}</syntaxhighlight> |
|||
===without modulo=== |
|||
Modulo can be expensive on some architectures. |
|||
<syntaxhighlight lang="cpp">#include <iostream> |
|||
int main() |
|||
{ |
|||
int i, f = 2, b = 4; |
|||
for ( i = 1 ; i <= 100 ; ++i, --f, --b ) |
|||
{ |
|||
if ( f && b ) { std::cout << i; } |
|||
if ( !f ) { std::cout << "Fizz"; f = 3; } |
|||
if ( !b ) { std::cout << "Buzz"; b = 5; } |
|||
std::cout << std::endl; |
|||
} |
|||
return 0; |
|||
} |
} |
||
</syntaxhighlight> |
|||
</cpp> |
|||
===using std::transform=== |
|||
{{works with|C++11}} |
|||
<syntaxhighlight lang="cpp">#include <iostream> |
|||
#include <algorithm> |
|||
#include <vector> |
|||
int main() |
|||
=={{header|Common Lisp}}== |
|||
{ |
|||
std::vector<int> range(100); |
|||
std::iota(range.begin(), range.end(), 1); |
|||
std::vector<std::string> values; |
|||
(defun fizzbuzz () |
|||
values.resize(range.size()); |
|||
(loop for x from 1 to 100 do |
|||
(print (cond ((zerop (mod x 15)) "FizzBuzz") |
|||
((zerop (mod x 3)) "Fizz") |
|||
((zerop (mod x 5)) "Buzz") |
|||
(t x))))) |
|||
auto fizzbuzz = [](int i) -> std::string { |
|||
if ((i%15) == 0) return "FizzBuzz"; |
|||
(loop for x from 1 to 100 do |
|||
( |
if ((i%5) == 0) return "Buzz"; |
||
if ((i%3) == 0) return "Fizz"; |
|||
return std::to_string(i); |
|||
(when (zerop (mod x 5)) '("Buzz"))) |
|||
}; |
|||
(list x))))) |
|||
std::transform(range.begin(), range.end(), values.begin(), fizzbuzz); |
|||
=={{header|D}}== |
|||
<pre>module fizzbuzz; |
|||
import std.stdio; |
|||
import std.string ; |
|||
for (auto& str: values) std::cout << str << std::endl; |
|||
// if-else |
|||
void fizzBuzz(int n) { |
|||
return 0; |
|||
for(int i = 1 ; i <= n; i++) |
|||
}</syntaxhighlight> |
|||
if (!(i%15)) |
|||
===metaprogramming=== |
|||
writef("FizzBuzz") ; |
|||
Version computing FizzBuzz at compile time with metaprogramming: |
|||
else if (!(i%3)) |
|||
<syntaxhighlight lang="cpp">#include <iostream> |
|||
writef("Fizz") ; |
|||
else if (!(i%5)) |
|||
template <int n, int m3, int m5> |
|||
writef("Buzz") ; |
|||
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; |
|||
}</syntaxhighlight> |
|||
===hardcore templates=== |
|||
Compile with -ftemplate-depth-9000 -std=c++0x: |
|||
<syntaxhighlight 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<i>::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<i>::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; |
|||
}</syntaxhighlight> |
|||
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). |
|||
=={{header|Casio BASIC}}== |
|||
See [[FizzBuzz/Basic]] |
|||
=={{header|Cduce}}== |
|||
<syntaxhighlight 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 |
else |
||
fizz(n + 1, size);; |
|||
writefln() ; |
|||
let fizbuzz (size : Int) : _ = fizz (1, size);; |
|||
let _ = fizbuzz(100);;</syntaxhighlight> |
|||
=={{header|Ceylon}}== |
|||
<syntaxhighlight lang="ceylon">shared void run() => {for (i in 1..100) {for (j->k in [3->"Fizz", 5->"Buzz"]) if (j.divides(i)) k}.reduce(plus) else i}.each(print);</syntaxhighlight> |
|||
=={{header|Chapel}}== |
|||
<syntaxhighlight 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);</syntaxhighlight> |
|||
// use switch case |
|||
void fizzBuzz_s(int n) { |
|||
=={{header|Chef}}== |
|||
for(int i = 1 ; i <= n; i++) |
|||
See [[FizzBuzz/EsoLang]] |
|||
switch(i%15) { |
|||
case 0: |
|||
=={{header|Cherrycake}}== |
|||
writef("FizzBuzz") ; break ; |
|||
<syntaxhighlight lang="cherrycake"> |
|||
case 3,6,9,12: |
|||
# Route with custom number of iterations |
|||
writef("Fizz") ; break ; |
|||
cached get ~/:n { |
|||
case 5,10: |
|||
writef("Buzz") ; break ; |
|||
# Get the Number of Iterations from the URL Params |
|||
default: |
|||
int n = req.params.n || 100 |
|||
# Loop through each iteration |
|||
for (i in range(n)) { |
|||
if (i % 2 == 0 && i % 3 == 0) { res.write("FizzBuzz\n") continue } |
|||
if (i % 2 == 0) { res.write("Fizz\n"); continue; } |
|||
if (i % 3 == 0) { res.write("Buzz\n"); continue; } |
|||
res.write(i + "\n"); |
|||
} |
} |
||
writefln() ; |
|||
# Close the connection |
|||
res.end(); |
|||
} |
} |
||
</syntaxhighlight> |
|||
=={{header|Clay}}== |
|||
<syntaxhighlight 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); |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|Clipper}}== |
|||
Also compiles with Harbour (Harbour 3.2.0dev (r1405201749)) |
|||
<syntaxhighlight 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 |
|||
</syntaxhighlight> |
|||
The advantage of this approach is that it is trivial to add another factor: |
|||
<pre>AEval( {{3,"Fizz"},{5,"Buzz"},{9,"Jazz"}}, {|x| cFB += Iif((n % x[1])==0, x[2], "")})</pre> |
|||
=={{header|CLIPS}}== |
|||
<syntaxhighlight 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) |
|||
) |
|||
)</syntaxhighlight> |
|||
=={{header|Clojure}}== |
|||
<syntaxhighlight lang="clojure"> |
|||
(doseq [x (range 1 101)] (println x (str (when (zero? (mod x 3)) "fizz") (when (zero? (mod x 5)) "buzz")))) |
|||
</syntaxhighlight> |
|||
<syntaxhighlight lang="clojure"> |
|||
(defn fizzbuzz [start finish] |
|||
(map (fn [n] |
|||
(cond |
|||
(zero? (mod n 15)) "FizzBuzz" |
|||
(zero? (mod n 3)) "Fizz" |
|||
(zero? (mod n 5)) "Buzz" |
|||
:else n)) |
|||
(range start finish))) |
|||
(fizzbuzz 1 100) |
|||
</syntaxhighlight> |
|||
<syntaxhighlight 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))</syntaxhighlight> |
|||
<syntaxhighlight lang="lisp">(map #(let [s (str (if (zero? (mod % 3)) "Fizz") (if (zero? (mod % 5)) "Buzz"))] (if (empty? s) % s)) (range 1 101))</syntaxhighlight> |
|||
<syntaxhighlight lang="lisp">(def fizzbuzz (map |
|||
#(cond (zero? (mod % 15)) "FizzBuzz" |
|||
(zero? (mod % 5)) "Buzz" |
|||
(zero? (mod % 3)) "Fizz" |
|||
:else %) |
|||
(iterate inc 1)))</syntaxhighlight> |
|||
<syntaxhighlight 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))))</syntaxhighlight> |
|||
<syntaxhighlight 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))</syntaxhighlight> |
|||
<syntaxhighlight lang="clojure">(take 100 (map #(let [s (str %2 %3) ] (if (seq s) s (inc %)) ) |
|||
(range) |
|||
(cycle [ "" "" "Fizz" ]) |
|||
(cycle [ "" "" "" "" "Buzz" ])))</syntaxhighlight> |
|||
<syntaxhighlight lang="lisp">(map #(nth (conj (cycle [% % "Fizz" % "Buzz" "Fizz" % % "Fizz" "Buzz" % "Fizz" % % "FizzBuzz"]) %) %) (range 1 101))</syntaxhighlight> |
|||
<syntaxhighlight lang="clojure">(let [n nil fizz (cycle [n n "fizz"]) buzz (cycle [n n n n "buzz"]) nums (iterate inc 1)] |
|||
(take 20 (map #(if (or %1 %2) (str %1 %2) %3) fizz buzz nums)))</syntaxhighlight> |
|||
<syntaxhighlight lang="clojure">(take 100 |
|||
(map #(if (pos? (compare %1 %2)) %1 %2) |
|||
(map str (drop 1 (range))) |
|||
(map str (cycle ["" "" "Fizz"]) (cycle ["" "" "" "" "Buzz"])))) |
|||
</syntaxhighlight> |
|||
<syntaxhighlight lang="clojure"> |
|||
;;Using clojure maps |
|||
(defn fizzbuzz |
|||
[n] |
|||
(let [rule {3 "Fizz" |
|||
5 "Buzz"} |
|||
divs (->> rule |
|||
(map first) |
|||
sort |
|||
(filter (comp (partial = 0) |
|||
(partial rem n))))] |
|||
(if (empty? divs) |
|||
(str n) |
|||
(->> divs |
|||
(map rule) |
|||
(apply str))))) |
|||
(defn allfizzbuzz |
|||
[max] |
|||
(map fizzbuzz (range 1 (inc max)))) |
|||
</syntaxhighlight> |
|||
<syntaxhighlight lang="clojure"> |
|||
(take 100 |
|||
(map #(str %1 %2 (if-not (or %1 %2) %3)) |
|||
(cycle [nil nil "Fizz"]) |
|||
(cycle [nil nil nil nil "Buzz"]) |
|||
(rest (range)) |
|||
)) |
|||
</syntaxhighlight> |
|||
<syntaxhighlight lang="clojure"> |
|||
(take 100 |
|||
( |
|||
(fn [& fbspec] |
|||
(let [ |
|||
fbseq #(->> (repeat nil) (cons %2) (take %1) reverse cycle) |
|||
strfn #(apply str (if (every? nil? (rest %&)) (first %&)) (rest %&)) |
|||
] |
|||
(->> |
|||
fbspec |
|||
(partition 2) |
|||
(map #(apply fbseq %)) |
|||
(apply map strfn (rest (range))) |
|||
) ;;endthread |
|||
) ;;endlet |
|||
) ;;endfn |
|||
3 "Fizz" 5 "Buzz" 7 "Bazz" |
|||
) ;;endfn apply |
|||
) ;;endtake |
|||
</syntaxhighlight> |
|||
<syntaxhighlight lang="clojure"> |
|||
(take 100 |
|||
(map-indexed |
|||
#(case %2 14 "FizzBuzz" (2 5 8 11) "Fizz" (4 9) "Buzz" (inc %1)) |
|||
(cycle (range 15)) |
|||
) |
|||
) |
|||
</syntaxhighlight> |
|||
<syntaxhighlight lang="clojure"> |
|||
(take 100 |
|||
(->> |
|||
(map str (cycle [nil nil "Fizz"]) (cycle [nil nil nil nil "Buzz"])) |
|||
(map-indexed #(if (empty? %2) (inc %1) %2)) |
|||
) |
|||
) |
|||
</syntaxhighlight> |
|||
<syntaxhighlight lang="clojure"> |
|||
(take 100 |
|||
(map-indexed |
|||
#(if (number? %2) (+ %1 %2) %2) |
|||
(cycle [1 1 "Fizz" 1 "Buzz" "Fizz" 1 1 "Fizz" "Buzz" 1 "Fizz" 1 1 "FizzBuzz"]) |
|||
) |
|||
) |
|||
</syntaxhighlight> |
|||
=={{header|CLU}}== |
|||
<syntaxhighlight lang="clu">start_up = proc () |
|||
po: stream := stream$primary_output() |
|||
for i: int in int$from_to(1, 100) do |
|||
out: string := "" |
|||
if i // 3 = 0 then out := out || "Fizz" end |
|||
if i // 5 = 0 then out := out || "Buzz" end |
|||
if string$empty(out) then out := int$unparse(i) end |
|||
stream$putl(po, out) |
|||
end |
|||
end start_up</syntaxhighlight> |
|||
=={{header|CMake}}== |
|||
<syntaxhighlight 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)</syntaxhighlight> |
|||
=={{header|COBOL}}== |
|||
===Canonical version=== |
|||
{{works with|OpenCOBOL}}<!-- http://www.opencobol.org/ --> |
|||
<syntaxhighlight 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.</syntaxhighlight> |
|||
===Simpler version=== |
|||
I know this doesn't have the full-bodied, piquant flavor |
|||
expected from COBOL, but it is a little shorter. |
|||
{{works with|OpenCOBOL}} |
|||
<syntaxhighlight 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.</syntaxhighlight> |
|||
===Evaluate Version=== |
|||
I think this shows clearly that it's resolving the problem and illuminating the rules specified |
|||
{{works with|OpenCOBOL}} |
|||
<syntaxhighlight lang="cobol"> |
|||
IDENTIFICATION DIVISION. |
|||
PROGRAM-ID. FIZZBUZZ. |
|||
ENVIRONMENT DIVISION. |
|||
DATA DIVISION. |
|||
WORKING-STORAGE SECTION. |
|||
01 X PIC 999. |
|||
01 Y PIC 999. |
|||
01 REM3 PIC 999. |
|||
01 REM5 PIC 999. |
|||
PROCEDURE DIVISION. |
|||
PERFORM VARYING X FROM 1 BY 1 UNTIL X > 100 |
|||
DIVIDE X BY 3 GIVING Y REMAINDER REM3 |
|||
DIVIDE X BY 5 GIVING Y REMAINDER REM5 |
|||
EVALUATE REM3 ALSO REM5 |
|||
WHEN ZERO ALSO ZERO |
|||
DISPLAY "FizzBuzz" |
|||
WHEN ZERO ALSO ANY |
|||
DISPLAY "Fizz" |
|||
WHEN ANY ALSO ZERO |
|||
DISPLAY "Buzz" |
|||
WHEN OTHER |
|||
DISPLAY X |
|||
END-EVALUATE |
|||
END-PERFORM |
|||
STOP RUN |
|||
. |
|||
</syntaxhighlight> |
|||
===Chase the Fizz=== |
|||
{{works with|OpenCOBOL}} |
|||
A solution that simply evaluates and adds. |
|||
<syntaxhighlight lang="cobol"> >>SOURCE FORMAT FREE |
|||
identification division. |
|||
program-id. fizzbuzz. |
|||
data division. |
|||
working-storage section. |
|||
01 i pic 999. |
|||
01 fizz pic 999 value 3. |
|||
01 buzz pic 999 value 5. |
|||
procedure division. |
|||
start-fizzbuzz. |
|||
perform varying i from 1 by 1 until i > 100 |
|||
evaluate i also i |
|||
when fizz also buzz |
|||
display 'fizzbuzz' |
|||
add 3 to fizz |
|||
add 5 to buzz |
|||
when fizz also any |
|||
display 'fizz' |
|||
add 3 to fizz |
|||
when buzz also any |
|||
display 'buzz' |
|||
add 5 to buzz |
|||
when other |
|||
display i |
|||
end-evaluate |
|||
end-perform |
|||
stop run |
|||
. |
|||
end program fizzbuzz. |
|||
</syntaxhighlight> |
|||
=={{header|Coco}}== |
|||
<syntaxhighlight lang="coco">for i from 1 to 100 |
|||
console.log do |
|||
if i % 15 == 0 then 'FizzBuzz' |
|||
else if i % 3 == 0 then 'Fizz' |
|||
else if i % 5 == 0 then 'Buzz' |
|||
else i</syntaxhighlight> |
|||
<syntaxhighlight lang="coco">for i from 1 to 100 |
|||
console.log(['Fizz' unless i % 3] + ['Buzz' unless i % 5] or String(i))</syntaxhighlight> |
|||
=={{header|Coconut}}== |
|||
<syntaxhighlight lang="coconut">def fizzbuzz(n): |
|||
case (n % 3, n % 5): |
|||
match (0, 0): return "FizzBuzz" |
|||
match (0, _): return "Fizz" |
|||
match (_, 0): return "Buzz" |
|||
else: return n |> str |
|||
range(1,101)|> map$(fizzbuzz)|> x -> '\n'.join(x)|> print</syntaxhighlight> |
|||
=={{header|CoffeeScript}}== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
<syntaxhighlight lang="coffeescript">for i in [1..100] |
|||
console.log \ |
|||
if i % 15 is 0 |
|||
"FizzBuzz" |
|||
else if i % 3 is 0 |
|||
"Fizz" |
|||
else if i % 5 is 0 |
|||
"Buzz" |
|||
else |
|||
i</syntaxhighlight> |
|||
<syntaxhighlight lang="coffeescript">for i in [1..100] |
|||
console.log(['Fizz' if i % 3 is 0] + ['Buzz' if i % 5 is 0] or i)</syntaxhighlight> |
|||
=={{header|ColdFusion}}== |
|||
<syntaxhighlight lang="cfm"><Cfloop from="1" to="100" index="i"> |
|||
<Cfif i mod 15 eq 0>FizzBuzz |
|||
<Cfelseif i mod 5 eq 0>Fizz |
|||
<Cfelseif i mod 3 eq 0>Buzz |
|||
<Cfelse><Cfoutput>#i# </Cfoutput> |
|||
</Cfif> |
|||
</Cfloop></syntaxhighlight> |
|||
cfscript version |
|||
<syntaxhighlight lang="cfm"><cfscript> |
|||
result = ""; |
|||
for(i=1;i<=100;i++){ |
|||
result=ListAppend(result, (i%15==0) ? "FizzBuzz": (i%5==0) ? "Buzz" : (i%3 eq 0)? "Fizz" : i ); |
|||
} |
|||
WriteOutput(result); |
|||
</cfscript></syntaxhighlight> |
|||
=={{header|Comal}}== |
|||
<syntaxhighlight lang="comal">0010 FOR i#:=1 TO 100 DO |
|||
0020 IF i# MOD 15=0 THEN |
|||
0030 PRINT "FizzBuzz" |
|||
0040 ELIF i# MOD 5=0 THEN |
|||
0050 PRINT "Buzz" |
|||
0060 ELIF i# MOD 3=0 THEN |
|||
0070 PRINT "Fizz" |
|||
0080 ELSE |
|||
0090 PRINT i# |
|||
0100 ENDIF |
|||
0110 ENDFOR i# |
|||
0120 END</syntaxhighlight> |
|||
=={{header|Comefrom0x10}}== |
|||
<syntaxhighlight lang="cf0x10">fizzbuzz |
|||
mod_three = 3 |
|||
mod_five = 5 |
|||
comefrom fizzbuzz |
|||
n |
|||
comefrom fizzbuzz if n is mod_three |
|||
comefrom fizzbuzz if n is mod_five |
|||
n = n + 1 |
|||
fizz |
|||
comefrom fizzbuzz if n is mod_three |
|||
'Fizz'... |
|||
mod_three = mod_three + 3 |
|||
linebreak |
|||
# would like to write "unless mod_three is mod_five" |
|||
comefrom fizz if mod_three - mod_five - 3 |
|||
'' |
|||
buzz |
|||
comefrom fizzbuzz if n is mod_five |
|||
'Buzz' |
|||
mod_five = mod_five + 5 |
|||
comefrom fizzbuzz if n is 100</syntaxhighlight> |
|||
=={{header|Commodore BASIC}}== |
|||
See [[FizzBuzz/Basic]] |
|||
=={{header|Common Lisp}}== |
|||
Solution 1: |
|||
<syntaxhighlight 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)))</syntaxhighlight> |
|||
Solution 2: |
|||
<syntaxhighlight 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)))))</syntaxhighlight> |
|||
Solution 3: |
|||
<syntaxhighlight 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)))</syntaxhighlight> |
|||
Solution 4: |
|||
<syntaxhighlight 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))</syntaxhighlight> |
|||
Solution 5: |
|||
<syntaxhighlight 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))</syntaxhighlight> |
|||
Solution 6: |
|||
<syntaxhighlight 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)))</syntaxhighlight> |
|||
Solution 7: |
|||
<syntaxhighlight lang="lisp">(defun core (x) |
|||
(mapcar |
|||
#'(lambda (a b) (if (equal 0 (mod x a)) b x)) |
|||
'(3 5) |
|||
'("fizz" "buzz"))) |
|||
(defun filter-core (x) |
|||
(if (equal 1 (length (remove-duplicates x))) |
|||
(list (car x)) |
|||
(remove-if-not #'stringp x))) |
|||
(defun fizzbuzz (x) |
|||
(loop for a from 1 to x do |
|||
(print (format nil "~{~a~}" (filter-core (core a)))))) |
|||
(fizzbuzz 100)</syntaxhighlight> |
|||
Solution 8: |
|||
<syntaxhighlight lang="lisp">(defun range (min max) |
|||
(loop |
|||
:for x :from min :to max |
|||
:collect x)) |
|||
(defun fizzbuzz () |
|||
(map 'nil #'(lambda (n) |
|||
(princ |
|||
(cond |
|||
((zerop (mod n 15)) "FizzBuzz!") |
|||
((zerop (mod n 5)) "Buzz!") |
|||
((zerop (mod n 3)) "Fizz!") |
|||
(t n)) |
|||
(terpri))) |
|||
(range 1 100)))</syntaxhighlight> |
|||
First 16 lines of output: |
|||
<pre> |
|||
1 |
|||
2 |
|||
Fizz |
|||
4 |
|||
Buzz |
|||
Fizz |
|||
7 |
|||
8 |
|||
Fizz |
|||
Buzz |
|||
11 |
|||
Fizz |
|||
13 |
|||
14 |
|||
FizzBuzz |
|||
16 |
|||
</pre> |
|||
=== Alternate solution === |
|||
I use [https://franz.com/downloads/clp/survey Allegro CL 10.1] |
|||
<syntaxhighlight lang="lisp"> |
|||
;; Project : FizzBuzz |
|||
(defun fizzbuzz (&optional n) |
|||
(let ((n (or n 1))) |
|||
(if (> n 100) |
|||
nil |
|||
(progn |
|||
(let ((mult-3 (is-mult-p n 3)) |
|||
(mult-5 (is-mult-p n 5))) |
|||
(if mult-3 |
|||
(princ "Fizz")) |
|||
(if mult-5 |
|||
(princ "Buzz")) |
|||
(if (not (or mult-3 mult-5)) |
|||
(princ n)) |
|||
(princ #\linefeed) |
|||
(fizzbuzz (+ n 1))))))) |
|||
(defun is-mult-p (n multiple) |
|||
(= (rem n multiple) 0)) |
|||
(fizzbuzz 1) |
|||
</syntaxhighlight> |
|||
Output: |
|||
<pre> |
|||
1 |
|||
2 |
|||
Fizz |
|||
4 |
|||
Buzz |
|||
Fizz |
|||
7 |
|||
8 |
|||
Fizz |
|||
Buzz |
|||
11 |
|||
Fizz |
|||
13 |
|||
14 |
|||
FizzBuzz |
|||
16 |
|||
17 |
|||
Fizz |
|||
19 |
|||
Buzz |
|||
</pre> |
|||
=={{header|Coq}}== |
|||
<syntaxhighlight lang="coq"> |
|||
Require Import Coq.Lists.List. |
|||
(* https://coq.inria.fr/library/Coq.Lists.List.html *) |
|||
Require Import Coq.Strings.String. |
|||
(* https://coq.inria.fr/library/Coq.Strings.String.html *) |
|||
Require Import Coq.Strings.Ascii. |
|||
(* https://coq.inria.fr/library/Coq.Strings.Ascii.html *) |
|||
Require Import Coq.Init.Nat. |
|||
(* https://coq.inria.fr/library/Coq.Init.Nat.html *) |
|||
(** Definition of [string_of_nat] to convert natural numbers to strings. *) |
|||
Definition ascii_of_digit (n : nat) : ascii := |
|||
ascii_of_nat (n + 48). |
|||
Definition is_digit (n : nat) : bool := |
|||
andb (0 <=? n) (n <=? 9). |
|||
Fixpoint rec_string_of_nat (counter : nat) (n : nat) (acc : string) : string := |
|||
match counter with |
|||
| 0 => EmptyString |
|||
| S c => |
|||
if (is_digit n) |
|||
then String (ascii_of_digit n) acc |
|||
else rec_string_of_nat c (n / 10) (String (ascii_of_digit (n mod 10)) acc) |
|||
end. |
|||
(** The counter is only used to ensure termination. *) |
|||
Definition string_of_nat (n : nat) : string := |
|||
rec_string_of_nat n n EmptyString. |
|||
(** The FizzBuzz problem. *) |
|||
Definition fizz : string := |
|||
"Fizz". |
|||
Definition buzz : string := |
|||
"Buzz". |
|||
Definition new_line : string := |
|||
String (ascii_of_nat 10) EmptyString. |
|||
Definition is_divisible_by (n : nat) (k : nat) : bool := |
|||
(n mod k) =? 0. |
|||
Definition get_term (n : nat) : string := |
|||
if (is_divisible_by n 15) then fizz ++ buzz |
|||
else if (is_divisible_by n 3) then fizz |
|||
else if (is_divisible_by n 5) then buzz |
|||
else (string_of_nat n). |
|||
Definition range (a : nat) (b : nat) : list nat := |
|||
seq a b. |
|||
Definition get_terms (n : nat) : list string := |
|||
map get_term (range 1 n). |
|||
Definition fizz_buzz : string := |
|||
concat new_line (get_terms 100). |
|||
(** This shows the string. *) |
|||
Eval compute in fizz_buzz. |
|||
</syntaxhighlight> |
|||
Output |
|||
<pre> |
|||
= "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"%string |
|||
: string |
|||
</pre> |
|||
=={{header|Cowgol}}== |
|||
===Straightforward version=== |
|||
<syntaxhighlight lang="cowgol">include "cowgol.coh"; |
|||
var i: uint8 := 1; |
|||
while i <= 100 loop |
|||
if i % 15 == 0 then |
|||
print("FizzBuzz"); |
|||
elseif i % 5 == 0 then |
|||
print("Buzz"); |
|||
elseif i % 3 == 0 then |
|||
print("Fizz"); |
|||
else |
|||
print_i8(i); |
|||
end if; |
|||
print_nl(); |
|||
i := i + 1; |
|||
end loop;</syntaxhighlight> |
|||
===No division=== |
|||
When targeting small systems, it is generally a good idea not to use division |
|||
if you don't have to. Most of the processors Cowgol targets do not have |
|||
hardware division, requiring the use of slow and bulky software division routines. |
|||
This is not helped by the fact that these processors are not fast to begin with, |
|||
and memory is usually scarce. |
|||
Avoiding division requires not only that <code>%</code> be avoided, but also |
|||
<code>print_i8</code> cannot be used, as printing integers in decimal format |
|||
is also done by division. Instead, this code keeps separate 'fizz' and 'buzz' |
|||
counters around, as well as keeping the number ready in ASCII format for printing. |
|||
Nevertheless, the following code compiles to a |
|||
252-byte 8080 executable, whereas the naive version above compiles to a 755-byte |
|||
executable. (Compare to the 8080 assembly program above, which assembles to a |
|||
98-byte executable.) |
|||
<syntaxhighlight lang="cowgol">include "cowgol.coh"; |
|||
var i: uint8 := 100; |
|||
var fizz: uint8 := 3; |
|||
var buzz: uint8 := 5; |
|||
var dh: uint8 := '0'; |
|||
var dl: uint8 := '1'; |
|||
var prnum: uint8; |
|||
while i != 0 loop |
|||
fizz := fizz - 1; |
|||
buzz := buzz - 1; |
|||
prnum := 1; |
|||
if fizz == 0 then |
|||
print("Fizz"); |
|||
fizz := 3; |
|||
prnum := 0; |
|||
end if; |
|||
if buzz == 0 then |
|||
print("Buzz"); |
|||
buzz := 5; |
|||
prnum := 0; |
|||
end if; |
|||
if prnum != 0 then |
|||
if dh != '0' then |
|||
print_char(dh); |
|||
end if; |
|||
print_char(dl); |
|||
end if; |
|||
dl := dl + 1; |
|||
if dl == ('9' + 1) then |
|||
dl := '0'; |
|||
dh := dh + 1; |
|||
end if; |
|||
print_nl(); |
|||
i := i - 1; |
|||
end loop; |
|||
</syntaxhighlight> |
|||
=={{header|Craft Basic}}== |
|||
See [[FizzBuzz/Basic]] |
|||
=={{header|Crystal}}== |
|||
<syntaxhighlight lang="ruby">1.upto(100) do |v| |
|||
p fizz_buzz(v) |
|||
end |
|||
def fizz_buzz(value) |
|||
word = "" |
|||
word += "fizz" if value % 3 == 0 |
|||
word += "buzz" if value % 5 == 0 |
|||
word += value.to_s if word.empty? |
|||
word |
|||
end</syntaxhighlight> |
|||
A more natural solution with the string building: |
|||
<syntaxhighlight lang="ruby">1.upto(100) do |n| |
|||
case |
|||
when n % 15 == 0 |
|||
puts "FizzBuzz" |
|||
when n % 5 == 0 |
|||
puts "Buzz" |
|||
when n % 3 == 0 |
|||
puts "Fizz" |
|||
else |
|||
puts n |
|||
end |
|||
end</syntaxhighlight> |
|||
=={{header|CSS}}== |
|||
// recursive with concatenation |
|||
<pre style="font-size:84%;height:75ex"> |
|||
string fizzBuzz_r(int n){ |
|||
<!DOCTYPE html> |
|||
string s = "" ; |
|||
<html xmlns="http://www.w3.org/1999/xhtml" lang="en"> |
|||
if (n == 0) |
|||
<head> |
|||
return s ; |
|||
<style> |
|||
if(!(n % 5)) |
|||
li { |
|||
s = "Buzz"~ s ; |
|||
list-style-position: inside; |
|||
if(!(n % 3)) |
|||
} |
|||
s = "Fizz" ~ s ; |
|||
li:nth-child(3n), li:nth-child(5n) { |
|||
if (s == "") |
|||
list-style-type: none; |
|||
s = toString(n) ; |
|||
} |
|||
return fizzBuzz_r(n-1) ~ s ; |
|||
li:nth-child(3n)::before { |
|||
content:'Fizz'; |
|||
} |
|||
li:nth-child(5n)::after { |
|||
content:'Buzz'; |
|||
} |
|||
</style> |
|||
</head> |
|||
<body> |
|||
<ol> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
<li></li> |
|||
</ol> |
|||
</body> |
|||
</html> |
|||
</pre> |
|||
=={{header|Cubescript}}== |
|||
<syntaxhighlight lang="text">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 |
|||
] |
|||
] |
|||
] |
|||
]</syntaxhighlight> |
|||
=={{header|D}}== |
|||
<syntaxhighlight lang="d">import std.stdio, std.algorithm, std.conv; |
|||
/// With if-else. |
|||
void fizzBuzz(in uint n) { |
|||
foreach (immutable i; 1 .. n + 1) |
|||
if (!(i % 15)) |
|||
"FizzBuzz".writeln; |
|||
else if (!(i % 3)) |
|||
"Fizz".writeln; |
|||
else if (!(i % 5)) |
|||
"Buzz".writeln; |
|||
else |
|||
i.writeln; |
|||
} |
|||
/// With switch case. |
|||
void fizzBuzzSwitch(in uint n) { |
|||
foreach (immutable i; 1 .. n + 1) |
|||
switch (i % 15) { |
|||
case 0: |
|||
"FizzBuzz".writeln; |
|||
break; |
|||
case 3, 6, 9, 12: |
|||
"Fizz".writeln; |
|||
break; |
|||
case 5, 10: |
|||
"Buzz".writeln; |
|||
break; |
|||
default: |
|||
i.writeln; |
|||
} |
|||
} |
} |
||
void fizzBuzzSwitch2(in uint n) { |
|||
// alternative recursive |
|||
foreach (immutable i; 1 .. n + 1) |
|||
string fizzBuzz_r2(int n){ |
|||
(i % 15).predSwitch( |
|||
return (n>0) ? fizzBuzz_r2(n-1) ~ |
|||
0, "FizzBuzz", |
|||
3, "Fizz", |
|||
5, "Buzz", |
|||
6, "Fizz", |
|||
9, "Fizz", |
|||
10, "Buzz", |
|||
12, "Fizz", |
|||
/*else*/ i.text).writeln; |
|||
} |
} |
||
void main() { |
void main() { |
||
100.fizzBuzz; |
|||
fizzBuzz(100) ; |
|||
writeln; |
|||
fizzBuzz_s(100) ; |
|||
100.fizzBuzzSwitch; |
|||
writefln(fizzBuzz_r(100)) ; |
|||
writeln; |
|||
writefln(fizzBuzz_r2(100)) ; |
|||
100.fizzBuzzSwitch2; |
|||
for(int i = 1 ; i <= 100;i++) |
|||
}</syntaxhighlight> |
|||
writef("%s", i % 15 ? i % 5 ? i % 3 ? toString(i) :"Fizz" : "Buzz" : "FizzBuzz") ; |
|||
Alternate version calculating values at compile time: |
|||
<syntaxhighlight lang="d">import std; |
|||
void main() |
|||
{ |
|||
auto fizzbuzz(in uint i) |
|||
{ |
|||
string r; |
|||
if (i % 3 == 0) r ~= "fizz"; |
|||
if (i % 5 == 0) r ~= "buzz"; |
|||
if (r.length == 0) r ~= i.to!string; |
|||
return r; |
|||
} |
|||
enum r = 1.iota(101).map!fizzbuzz; |
|||
r.each!writeln; |
|||
}</syntaxhighlight> |
|||
=={{header|Dart}}== |
|||
<syntaxhighlight lang="dart"> |
|||
main() { |
|||
for (int i = 1; i <= 100; i++) { |
|||
List<String> out = []; |
|||
if (i % 3 == 0) |
|||
out.add("Fizz"); |
|||
if (i % 5 == 0) |
|||
out.add("Buzz"); |
|||
print(out.length > 0 ? out.join("") : i); |
|||
} |
|||
} |
} |
||
</syntaxhighlight> |
|||
</pre> |
|||
=={{header| |
=={{header|dc}}== |
||
{{trans|bc}} |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
The bc translation written in dc style. |
|||
<syntaxhighlight lang="dc"> |
|||
# dc is stack based, so we use the stack instead of a variable for our |
|||
# current number. |
|||
1 # Number = 1 |
|||
for i in 1..100 { |
|||
[[Fizz]n 1 sw]sF # Prints "Fizz" prevents Number from printing |
|||
[[Buzz]n 1 sw]sB # Prints "Buzz" prevents Number from printing |
|||
[dn]sN # Prints Number |
|||
[ |
|||
dd # Put two extra copies of Number on stack |
|||
0 sw # w = 0 |
|||
3% 0=F # Fizz if 0 == Number % 3 (destroys 1st copy) |
|||
5% 0=B # Buzz if 0 == Number % 5 (destroys 2nd copy) |
|||
lw 0=N # Print Number if 0 == w |
|||
[ |
|||
]n # Print new line |
|||
1+d # Number += 1 and put extra copy on stack |
|||
100!<L # Continue Loop if 100 >= Number (destroys copy) |
|||
]dsLx # Enter Loop</syntaxhighlight> |
|||
=={{header|Delphi}}== |
|||
<syntaxhighlight 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.</syntaxhighlight> |
|||
=={{header|DeviousYarn}}== |
|||
<syntaxhighlight lang="deviousyarn">each { x range(1 100) |
|||
? { divisible(x 3) |
|||
p:'Fizz' } |
|||
? { divisible(x 5) |
|||
p:'Buzz' } |
|||
-? { !:divisible(x 3) |
|||
p:x } |
|||
o |
|||
}</syntaxhighlight> |
|||
=={{header|Draco}}== |
|||
<syntaxhighlight lang="draco">proc nonrec main() void: |
|||
byte i; |
|||
for i from 1 upto 100 do |
|||
if i % 15 = 0 then writeln("FizzBuzz") |
|||
elif i % 5 = 0 then writeln("Buzz") |
|||
elif i % 3 = 0 then writeln("Fizz") |
|||
else writeln(i) |
|||
fi |
|||
od |
|||
corp</syntaxhighlight> |
|||
=={{header|DUP}}== |
|||
FizzBuzz, realized using two different methods for string/character output: |
|||
Output to STDOUT via single character output. |
|||
<syntaxhighlight lang="dup">[$$3/%$[]['F,'i,'z,'z,]?\5/%$[]['B,'u,'z,'z,]?*[$.][]?10,]c: {define function c: mod 3, mod 5 tests, print proper output} |
|||
0[$100<][1+c;!]# {loop from 1 to 100}</syntaxhighlight> |
|||
Output to STDOUT, using stored strings and a separately defined string output operator: |
|||
<syntaxhighlight lang="dup">[\[^^>][$;,1+]#%%]⇒P {define operator P: print stored string} |
|||
[$$3/%$[][0$"Fizz"P]?\5/%$[][0$"Buzz"P]?*[$.][]?10,]c: {define function c: mod 3, mod 5 tests, print according output} |
|||
0[$100<][1+c;!]# {loop from 1 to 100}</syntaxhighlight> |
|||
=={{header|DWScript}}== |
|||
<syntaxhighlight 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;</syntaxhighlight> |
|||
=={{header|Dyalect}}== |
|||
<syntaxhighlight lang="dyalect">var n = 1 |
|||
while n < 20 { |
|||
if n % 15 == 0 { |
|||
print("fizzbuzz") |
|||
} else if n % 3 == 0 { |
|||
print("fizz") |
|||
} else if n % 5 == 0 { |
|||
print("buzz") |
|||
} else { |
|||
print(n) |
|||
} |
|||
n = n + 1 |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre>1 |
|||
2 |
|||
fizz |
|||
4 |
|||
buzz |
|||
fizz |
|||
7 |
|||
8 |
|||
fizz |
|||
buzz |
|||
11 |
|||
fizz |
|||
13 |
|||
14 |
|||
fizzbuzz |
|||
16 |
|||
17 |
|||
fizz |
|||
19</pre> |
|||
=={{header|Déjà Vu}}== |
|||
<syntaxhighlight lang="dejavu">for i range 1 100: |
|||
if = 0 % i 15: |
|||
"FizzBuzz" |
|||
elseif = 0 % i 3: |
|||
"Fizz" |
|||
elseif = 0 % i 5: |
|||
"Buzz" |
|||
else: |
|||
i |
|||
!print</syntaxhighlight> |
|||
=={{header|E}}== |
|||
<syntaxhighlight lang="e">for i in 1..100 { |
|||
println(switch ([i % 3, i % 5]) { |
println(switch ([i % 3, i % 5]) { |
||
match [==0, ==0] { "FizzBuzz" } |
match [==0, ==0] { "FizzBuzz" } |
||
Line 247: | Line 3,573: | ||
match _ { i } |
match _ { i } |
||
}) |
}) |
||
}</syntaxhighlight> |
|||
} |
|||
=={{header|EasyLang}}== |
|||
<syntaxhighlight lang="text">for i = 1 to 100 |
|||
if i mod 15 = 0 |
|||
print "FizzBuzz" |
|||
elif i mod 5 = 0 |
|||
print "Buzz" |
|||
elif i mod 3 = 0 |
|||
print "Fizz" |
|||
else |
|||
print i |
|||
. |
|||
.</syntaxhighlight> |
|||
=={{header|ECL}}== |
|||
<syntaxhighlight 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);</syntaxhighlight> |
|||
=={{header|Ecstasy}}== |
|||
<syntaxhighlight lang="java"> |
|||
module FizzBuzz { |
|||
void run() { |
|||
@Inject Console console; |
|||
for (Int x : 1..100) { |
|||
console.print(switch (x % 3, x % 5) { |
|||
case (0, 0): "FizzBuzz"; |
|||
case (0, _): "Fizz"; |
|||
case (_, 0): "Buzz"; |
|||
case (_, _): x.toString(); |
|||
}); |
|||
} |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|Ed}}== |
|||
<syntaxhighlight lang="bash">H |
|||
a |
|||
100 |
|||
. |
|||
# iota.ed |
|||
g/[^0-9]{1,}/s///g |
|||
,p |
|||
# decimal -> unary |
|||
g/^0+([0-9])/s//\1/ |
|||
g/^9([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiiii/ |
|||
g/^8([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiii/ |
|||
g/^7([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiii/ |
|||
g/^6([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiii/ |
|||
g/^5([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiii/ |
|||
g/^4([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiii/ |
|||
g/^3([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iii/ |
|||
g/^2([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2ii/ |
|||
g/^1([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2i/ |
|||
g/^0([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2/ |
|||
g/^9([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiiii/ |
|||
g/^8([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiii/ |
|||
g/^7([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiii/ |
|||
g/^6([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiii/ |
|||
g/^5([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiii/ |
|||
g/^4([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiii/ |
|||
g/^3([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iii/ |
|||
g/^2([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2ii/ |
|||
g/^1([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2i/ |
|||
g/^0([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2/ |
|||
g/^9([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiiii/ |
|||
g/^8([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiii/ |
|||
g/^7([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiii/ |
|||
g/^6([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiii/ |
|||
g/^5([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiii/ |
|||
g/^4([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiii/ |
|||
g/^3([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iii/ |
|||
g/^2([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2ii/ |
|||
g/^1([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2i/ |
|||
g/^0([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2/ |
|||
g/^9([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiiii/ |
|||
g/^8([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiii/ |
|||
g/^7([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiii/ |
|||
g/^6([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiii/ |
|||
g/^5([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiii/ |
|||
g/^4([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiii/ |
|||
g/^3([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iii/ |
|||
g/^2([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2ii/ |
|||
g/^1([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2i/ |
|||
g/^0([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2/ |
|||
g/^9([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiiii/ |
|||
g/^8([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiii/ |
|||
g/^7([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiii/ |
|||
g/^6([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiii/ |
|||
g/^5([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiii/ |
|||
g/^4([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiii/ |
|||
g/^3([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iii/ |
|||
g/^2([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2ii/ |
|||
g/^1([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2i/ |
|||
g/^0([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2/ |
|||
# iota logic |
|||
s/\B/\ |
|||
/g |
|||
a |
|||
. |
|||
y |
|||
d |
|||
g/i/x\ |
|||
s/.*/&i/\ |
|||
-1d\ |
|||
y |
|||
# fizzbuzz |
|||
g/^(i{15})+$/s//FizzBuzz/ |
|||
g/^(i{5})+$/s//Buzz/ |
|||
g/^(i{3})+$/s//Fizz/ |
|||
# unary -> decimal (for 0-10000 range) |
|||
g/i{9000}(i{0,999})/s//9\1/ |
|||
g/i{8000}(i{0,999})/s//8\1/ |
|||
g/i{7000}(i{0,999})/s//7\1/ |
|||
g/i{6000}(i{0,999})/s//6\1/ |
|||
g/i{5000}(i{0,999})/s//5\1/ |
|||
g/i{4000}(i{0,999})/s//4\1/ |
|||
g/i{3000}(i{0,999})/s//3\1/ |
|||
g/i{2000}(i{0,999})/s//2\1/ |
|||
g/i{1000}(i{0,999})/s//1\1/ |
|||
v/^[0-9]i*$/s/.*/0&/ |
|||
g/i{900}(i{0,99})/s//9\1/ |
|||
g/i{800}(i{0,99})/s//8\1/ |
|||
g/i{700}(i{0,99})/s//7\1/ |
|||
g/i{600}(i{0,99})/s//6\1/ |
|||
g/i{500}(i{0,99})/s//5\1/ |
|||
g/i{400}(i{0,99})/s//4\1/ |
|||
g/i{300}(i{0,99})/s//3\1/ |
|||
g/i{200}(i{0,99})/s//2\1/ |
|||
g/i{100}(i{0,99})/s//1\1/ |
|||
v/^[0-9]{2}i*$/s/^([0-9])(i*)$/\10\2/ |
|||
g/i{90}(i{0,9})/s//9\1/ |
|||
g/i{80}(i{0,9})/s//8\1/ |
|||
g/i{70}(i{0,9})/s//7\1/ |
|||
g/i{60}(i{0,9})/s//6\1/ |
|||
g/i{50}(i{0,9})/s//5\1/ |
|||
g/i{40}(i{0,9})/s//4\1/ |
|||
g/i{30}(i{0,9})/s//3\1/ |
|||
g/i{20}(i{0,9})/s//2\1/ |
|||
g/i{10}(i{0,9})/s//1\1/ |
|||
v/^[0-9]{3}i*$/s/^([0-9]{2})(i*)$/\10\2/ |
|||
g/i{9}/s//9/ |
|||
g/i{8}/s//8/ |
|||
g/i{7}/s//7/ |
|||
g/i{6}/s//6/ |
|||
g/i{5}/s//5/ |
|||
g/i{4}/s//4/ |
|||
g/i{3}/s//3/ |
|||
g/i{2}/s//2/ |
|||
g/i{1}/s//1/ |
|||
v/^[0-9]{4}i*$/s/^([0-9]{3})(i*)$/\10\2/ |
|||
g/^0+([0-9])/s//\1/ |
|||
g/0F1zz/s//Fizz/ |
|||
g/0Buzz/s//Buzz/ |
|||
,p |
|||
Q |
|||
</syntaxhighlight> |
|||
=={{header|Eero}}== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
=={{header|Egel}}== |
|||
<syntaxhighlight lang="egel"> |
|||
import "prelude.eg" |
|||
import "io.ego" |
|||
using System |
|||
using IO |
|||
def fizzbuzz = |
|||
[ 100 -> print "100\n" |
|||
| N -> |
|||
if and ((N%3) == 0) ((N%5) == 0) then |
|||
let _ = print "fizz buzz, " in fizzbuzz (N+1) |
|||
else if (N%3) == 0 then |
|||
let _ = print "fizz, " in fizzbuzz (N+1) |
|||
else if (N%5) == 0 then |
|||
let _ = print "buzz, " in fizzbuzz (N+1) |
|||
else |
|||
let _ = print N ", " in fizzbuzz (N+1) ] |
|||
def main = fizzbuzz 1 |
|||
</syntaxhighlight> |
|||
=={{header|Eiffel}}== |
|||
<syntaxhighlight lang="eiffel"> |
|||
class |
|||
APPLICATION |
|||
create |
|||
make |
|||
feature |
|||
make |
|||
do |
|||
fizzbuzz |
|||
end |
|||
fizzbuzz |
|||
--Numbers up to 100, prints "Fizz" instead of multiples of 3, and "Buzz" for multiples of 5. |
|||
--For multiples of both 3 and 5 prints "FizzBuzz". |
|||
do |
|||
across |
|||
1 |..| 100 as c |
|||
loop |
|||
if c.item \\ 15 = 0 then |
|||
io.put_string ("FIZZBUZZ%N") |
|||
elseif c.item \\ 3 = 0 then |
|||
io.put_string ("FIZZ%N") |
|||
elseif c.item \\ 5 = 0 then |
|||
io.put_string ("BUZZ%N") |
|||
else |
|||
io.put_string (c.item.out + "%N") |
|||
end |
|||
end |
|||
end |
|||
end |
|||
</syntaxhighlight> |
|||
=={{header|Ela}}== |
|||
<syntaxhighlight lang="ela">open list |
|||
prt x | x % 15 == 0 = "FizzBuzz" |
|||
| x % 3 == 0 = "Fizz" |
|||
| x % 5 == 0 = "Buzz" |
|||
| else = x |
|||
[1..100] |> map prt</syntaxhighlight> |
|||
=={{header|Elixir}}== |
|||
===Standard approaches=== |
|||
used case |
|||
<syntaxhighlight lang="elixir">Enum.each 1..100, fn x -> |
|||
IO.puts(case { rem(x,3) == 0, rem(x,5) == 0 } do |
|||
{ true, true } -> "FizzBuzz" |
|||
{ true, false } -> "Fizz" |
|||
{ false, true } -> "Buzz" |
|||
{ false, false } -> x |
|||
end) |
|||
end</syntaxhighlight> |
|||
Alternate approach using pipes and cond: |
|||
<syntaxhighlight lang="elixir">#!/usr/bin/env elixir |
|||
1..100 |> Enum.map(fn i -> |
|||
cond do |
|||
rem(i,3*5) == 0 -> "FizzBuzz" |
|||
rem(i,3) == 0 -> "Fizz" |
|||
rem(i,5) == 0 -> "Buzz" |
|||
true -> i |
|||
end |
|||
end) |> Enum.each(fn i -> IO.puts i end)</syntaxhighlight> |
|||
used Stream.cycle version: |
|||
<syntaxhighlight lang="elixir">defmodule RC do |
|||
def fizzbuzz(limit \\ 100) do |
|||
fizz = Stream.cycle(["", "", "Fizz"]) |
|||
buzz = Stream.cycle(["", "", "", "", "Buzz"]) |
|||
Stream.zip(fizz, buzz) |
|||
|> Enum.take(limit) |
|||
|> Enum.with_index |
|||
|> Enum.each(fn {{f,b},i} -> |
|||
IO.puts if f<>b=="", do: i+1, else: f<>b |
|||
end) |
|||
end |
|||
end |
|||
RC.fizzbuzz</syntaxhighlight> |
|||
Yet another approach: |
|||
<syntaxhighlight lang="elixir">defmodule FizzBuzz do |
|||
def fizzbuzz(n) when rem(n, 15) == 0, do: "FizzBuzz" |
|||
def fizzbuzz(n) when rem(n, 5) == 0, do: "Buzz" |
|||
def fizzbuzz(n) when rem(n, 3) == 0, do: "Fizz" |
|||
def fizzbuzz(n), do: n |
|||
end |
|||
Enum.each(1..100, &IO.puts FizzBuzz.fizzbuzz &1)</syntaxhighlight> |
|||
used anonymous function |
|||
<syntaxhighlight lang="elixir">f = fn(n) when rem(n,15)==0 -> "FizzBuzz" |
|||
(n) when rem(n,5)==0 -> "Fizz" |
|||
(n) when rem(n,3)==0 -> "Buzz" |
|||
(n) -> n |
|||
end |
|||
for n <- 1..100, do: IO.puts f.(n)</syntaxhighlight> |
|||
Enum.at version: Returns nil if index is out of bounds. |
|||
<syntaxhighlight lang="elixir">Enum.each(1..100, fn i -> |
|||
str = "#{Enum.at([:Fizz], rem(i,3))}#{Enum.at([:Buzz], rem(i,5))}" |
|||
IO.puts if str=="", do: i, else: str |
|||
end)</syntaxhighlight> |
|||
===A macro too far=== |
|||
The Stream.cycle version above, but as an overpowered FizzBuzz DSL. |
|||
<syntaxhighlight lang="elixir">defmodule BadFizz do |
|||
# Hand-rolls a bunch of AST before injecting the resulting FizzBuzz code. |
|||
defmacrop automate_fizz(fizzers, n) do |
|||
# To begin, we need to process fizzers to produce the various components |
|||
# we're using in the final assembly. As told by Mickens telling as Antonio |
|||
# Banderas, first you must specify a mapping function: |
|||
build_parts = (fn {fz, n} -> |
|||
ast_ref = {fz |> String.downcase |> String.to_atom, [], __MODULE__} |
|||
clist = List.duplicate("", n - 1) ++ [fz] |
|||
cycle = quote do: unquote(ast_ref) = unquote(clist) |> Stream.cycle |
|||
{ast_ref, cycle} |
|||
end) |
|||
# ...and then a reducing function: |
|||
collate = (fn |
|||
({ast_ref, cycle}, {ast_refs, cycles}) -> |
|||
{[ast_ref | ast_refs], [cycle | cycles]} |
|||
end) |
|||
# ...and then, my love, when you are done your computation is ready to run |
|||
# across thousands of fizzbuzz: |
|||
{ast_refs, cycles} = fizzers |
|||
|> Code.eval_quoted([], __ENV__) |> elem(0) # Gotta unwrap this mystery code~ |
|||
|> Enum.sort(fn ({_, ap}, {_, bp}) -> ap < bp end) # Sort so that Fizz, 3 < Buzz, 5 |
|||
|> Enum.map(build_parts) |
|||
|> Enum.reduce({[], []}, collate) |
|||
# Setup the anonymous functions used by Enum.reduce to build our AST components. |
|||
# This was previously handled by List.foldl, but ejected because reduce/2's |
|||
# default behavior reduces repetition. |
|||
# |
|||
# ...I was tempted to move these into a macro themselves, and thought better of it. |
|||
build_zip = fn (varname, ast) -> |
|||
quote do: Stream.zip(unquote(varname), unquote(ast)) |
|||
end |
|||
build_tuple = fn (varname, ast) -> |
|||
{:{}, [], [varname, ast]} |
|||
end |
|||
build_concat = fn (varname, ast) -> |
|||
{:<>, |
|||
[context: __MODULE__, import: Kernel], # Hygiene values may change; accurate to Elixir 1.1.1 |
|||
[varname, ast]} |
|||
end |
|||
# Toss cycles into a block by hand, then smash ast_refs into |
|||
# a few different computations on the cycle block results. |
|||
cycles = {:__block__, [], cycles} |
|||
tuple = ast_refs |> Enum.reduce(build_tuple) |
|||
zip = ast_refs |> Enum.reduce(build_zip) |
|||
concat = ast_refs |> Enum.reduce(build_concat) |
|||
# Finally-- Now that all our components are assembled, we can put |
|||
# together the fizzbuzz stream pipeline. After quote ends, this |
|||
# block is injected into the caller's context. |
|||
quote do |
|||
unquote(cycles) |
|||
unquote(zip) |
|||
|> Stream.with_index |
|||
|> Enum.take(unquote(n)) |
|||
|> Enum.each(fn |
|||
{unquote(tuple), i} -> |
|||
ccats = unquote(concat) |
|||
IO.puts if ccats == "", do: i + 1, else: ccats |
|||
end) |
|||
end |
|||
end |
|||
@doc ~S""" |
|||
A fizzing, and possibly buzzing function. Somehow, you feel like you've |
|||
seen this before. An old friend, suddenly appearing in Kafkaesque nightmare... |
|||
...or worse, during a whiteboard interview. |
|||
""" |
|||
def fizz(n \\ 100) when is_number(n) do |
|||
# In reward for all that effort above, we now have the latest in |
|||
# programmer productivity: |
|||
# |
|||
# A DSL for building arbitrary fizzing, buzzing, bazzing, and more! |
|||
[{"Fizz", 3}, |
|||
{"Buzz", 5}#, |
|||
#{"Bar", 7}, |
|||
#{"Foo", 243}, # -> Always printed last (largest number) |
|||
#{"Qux", 34} |
|||
] |
|||
|> automate_fizz(n) |
|||
end |
|||
end |
|||
BadFizz.fizz(100) # => Prints to stdout</syntaxhighlight> |
|||
=={{header|Elm}}== |
|||
A bit too simple: |
|||
<syntaxhighlight lang="elm">import Html exposing (text) |
|||
import List exposing (map) |
|||
main = |
|||
[1..100] |> map getWordForNum |> text |
|||
getWordForNum num = |
|||
if num % 15 == 0 then |
|||
"FizzBuzz" |
|||
else if num % 3 == 0 then |
|||
"Fizz" |
|||
else if num % 5 == 0 then |
|||
"Buzz" |
|||
else |
|||
String.fromInt num</syntaxhighlight> |
|||
A bit too clever: |
|||
<syntaxhighlight lang="elm">import Html exposing (text) |
|||
import List exposing (map) |
|||
import String exposing (join, fromInt) |
|||
main : Html.Html |
|||
main = |
|||
[1..100] |> map fizzbuzz |> join " " |> text |
|||
fizzbuzz : Int -> String |
|||
fizzbuzz num = |
|||
let |
|||
fizz = if num % 3 == 0 then "Fizz" else "" |
|||
buzz = if num % 5 == 0 then "Buzz" else "" |
|||
in |
|||
if fizz == buzz then |
|||
fromInt num |
|||
else |
|||
fizz ++ buzz</syntaxhighlight> |
|||
=={{header|Emacs Lisp}}== |
|||
<syntaxhighlight lang="lisp">(defun fizzbuzz (n) |
|||
(cond ((and (zerop (% n 5)) (zerop (% n 3))) "FizzBuzz") |
|||
((zerop (% n 3)) "Fizz") |
|||
((zerop (% n 5)) "Buzz") |
|||
(t n))) |
|||
;; loop & print from 0 to 100 |
|||
(dotimes (i 101) |
|||
(message "%s" (fizzbuzz i)))</syntaxhighlight> |
|||
=={{header|EMal}}== |
|||
<syntaxhighlight lang="emal"> |
|||
logic isFizz, isBuzz |
|||
for int count = 1; count <= 100; ++count |
|||
isFizz = count % 3 == 0 |
|||
isBuzz = count % 5 == 0 |
|||
if isFizz and isBuzz do writeLine("Fizz Buzz") |
|||
else if isFizz do writeLine("Fizz") |
|||
else if isBuzz do writeLine("Buzz") |
|||
else do writeLine(count) |
|||
end |
|||
end |
|||
</syntaxhighlight> |
|||
=={{header|Emojicode}}== |
|||
===Simple 1=== |
|||
<syntaxhighlight lang="emojicode">🏁🍇 |
|||
🔂 i 🆕⏩ 1 101 1 ❗ 🍇 |
|||
↪️ i 🚮 15 🙌 0 🍇 |
|||
😀 🔤FizzBuzz🔤 ❗ |
|||
🍉 |
|||
🙅↪️ i 🚮 3 🙌 0 🍇 |
|||
😀 🔤Fizz🔤 ❗ |
|||
🍉 |
|||
🙅↪️ i 🚮 5 🙌 0 🍇 |
|||
😀 🔤Buzz🔤 ❗ |
|||
🍉🙅🍇 |
|||
😀 🔤🧲i🧲🔤 ❗ |
|||
🍉 |
|||
🍉 |
|||
🍉</syntaxhighlight> |
|||
===Simple 2=== |
|||
<syntaxhighlight lang="emojicode">🏁🍇 |
|||
🔂 i 🆕⏩ 1 101 1 ❗ 🍇 |
|||
🔤🔤 ➡️ 🖍🆕 msg |
|||
↪️ i 🚮 3 🙌 0 🍇 |
|||
🔤Fizz🔤 ➡️ 🖍 msg |
|||
🍉 |
|||
↪️ i 🚮 5 🙌 0 🍇 |
|||
🔤🧲msg🧲Buzz🔤 ➡️ 🖍 msg |
|||
🍉 |
|||
↪️ msg 🙌 🔤🔤 🍇 |
|||
😀 🔤🧲i🧲🔤 ❗ |
|||
🍉🙅🍇 |
|||
😀 🔤🧲msg🧲🔤 ❗ |
|||
🍉 |
|||
🍉 |
|||
🍉</syntaxhighlight> |
|||
=={{header|Enguage}}== |
|||
<syntaxhighlight lang="Enguage">FizzBuzz</syntaxhighlight> |
|||
This source code is supposed to look like plain old English but is, in fact, executable. When used in an Android app, it gives the user direct access to computational abilities of your phone. |
|||
It is taken from [https://bitbucket.org/martinwheatman/enguage/src/develop/etc/dict/f/fizzbuzz.entry the dictionary entry for fizzbuzz] |
|||
This shows the interpretation of two utterances, the latter of which are called recursively. Enguage is not very efficient, but that's not its goal! |
|||
NB. Any line beginning with a '#' is a comment, like Unix shells, but any comment following the ']' character are unit tests exercising this code. |
|||
<pre> |
|||
On "what is the fizzbuzz of N": |
|||
is N divisible by 5 and 3; |
|||
if so, reply "fizzbuzz"; |
|||
is N divisible by 5; |
|||
if so, reply "buzz"; |
|||
is N divisible by 3; |
|||
if so, reply "fizz"; |
|||
reply "N". |
|||
On "do fizzbuzz between N and LIMIT": |
|||
what is the fizzbuzz of N; |
|||
remember this; |
|||
set next to the evaluation of N + 1; |
|||
NEXT is equal to LIMIT; |
|||
if so, what is the fizzbuzz of LIMIT; |
|||
if not, do fizzbuzz between NEXT and LIMIT. |
|||
#] what is the fizzbuzz of 1: 1. |
|||
#] what is the fizzbuzz of 12: fizz. |
|||
#] what is the fizzbuzz of 25: buzz. |
|||
#] what is the fizzbuzz of 75: fizzbuzz. |
|||
#] set limit to 5. |
|||
#] do fizzbuzz between 1 and LIMIT. |
|||
</pre> |
|||
On downloading this repo, if git and make are installed, this unit test can be run with: |
|||
<pre> |
|||
$ git clone https://github.com/martinwheatman/enguage.git |
|||
$ cd enguage |
|||
$ make jar |
|||
$ export PATH=$PATH:./sbin |
|||
$ java -jar lib/enguage.jar -T fizzbuzz |
|||
</pre> |
|||
Output: |
|||
<pre> |
|||
TEST: fizzbuzz |
|||
============== |
|||
user> what is the fizzbuzz of 1. |
|||
enguage> 1. |
|||
user> what is the fizzbuzz of 12. |
|||
enguage> fizz. |
|||
user> what is the fizzbuzz of 25. |
|||
enguage> buzz. |
|||
user> what is the fizzbuzz of 75. |
|||
enguage> fizzbuzz. |
|||
user> set limit to 5. |
|||
enguage> ok , limit is set to 5. |
|||
user> do fizzbuzz between 1 and LIMIT. |
|||
enguage> 1 . 2 . fizz . 4 . buzz. |
|||
1 test group(s) found |
|||
+++ PASSED 6 tests in 442ms +++ |
|||
</pre> |
|||
=={{header|Erlang}}== |
|||
<syntaxhighlight lang="erlang">-spec fizzbuzz() -> Result :: string(). |
|||
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, |
|||
lists:flatten([[F(N)] ++ ["\n"] || N <- lists:seq(1,100)]).</syntaxhighlight> |
|||
=={{header|ERRE}}== |
|||
<syntaxhighlight lang="erre"> |
|||
PROGRAM FIZZ_BUZZ |
|||
! |
|||
! for rosettacode.org |
|||
! |
|||
BEGIN |
|||
FOR A=1 TO 100 DO |
|||
IF A MOD 15=0 THEN |
|||
PRINT("FizzBuzz") |
|||
ELSIF A MOD 3=0 THEN |
|||
PRINT("Fizz") |
|||
ELSIF A MOD 5=0 THEN |
|||
PRINT("Buzz") |
|||
ELSE |
|||
PRINT(A) |
|||
END IF |
|||
END FOR |
|||
END PROGRAM |
|||
</syntaxhighlight> |
|||
=={{header|Euler}}== |
|||
The original Euler implementations did not allow "long" strings, hence the use of a list here to print FizzBuzz. |
|||
'''begin''' '''new''' i; '''label''' iLoop; |
|||
i <- 0; |
|||
iLoop: '''if''' [ i <- i + 1 ] <= 100 '''then''' '''begin''' |
|||
'''out''' '''if''' i '''mod''' 15 = 0 '''then''' ( "Fizz", "Buzz" ) |
|||
'''else''' '''if''' i '''mod''' 5 = 0 '''then''' "Buzz" |
|||
'''else''' '''if''' i '''mod''' 3 = 0 '''then''' "Fizz" |
|||
'''else''' i; |
|||
'''goto''' iLoop |
|||
'''end''' '''else''' 0 |
|||
'''end''' $ |
|||
=={{header|Euphoria}}== |
|||
{{works with|Euphoria|4.0.0}} |
|||
This is based on the [[VBScript]] example. |
|||
<syntaxhighlight 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" )</syntaxhighlight> |
|||
=={{header|F Sharp|F#}}== |
|||
<syntaxhighlight lang="fsharp">let fizzbuzz n = |
|||
match n%3 = 0, n%5 = 0 with |
|||
| true, false -> "fizz" |
|||
| false, true -> "buzz" |
|||
| true, true -> "fizzbuzz" |
|||
| _ -> string n |
|||
let printFizzbuzz() = |
|||
[1..100] |> List.iter (fizzbuzz >> printfn "%s")</syntaxhighlight> |
|||
<syntaxhighlight lang="fsharp">[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) </syntaxhighlight> |
|||
Another example using (unnecessary) partial active pattern :D |
|||
<syntaxhighlight 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")</syntaxhighlight> |
|||
=={{header|Factor}}== |
=={{header|Factor}}== |
||
<syntaxhighlight lang="factor">USING: math kernel io math.functions math.parser math.ranges ; |
|||
IN: fizzbuzz |
|||
IN: fizzbuzz |
|||
USING: math kernel io ; |
|||
: 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</syntaxhighlight> |
|||
: main ( -- ) 100 [ 1+ fizzbuzz print ] each ; |
|||
MAIN: main |
|||
More flexible variant without divisibility tests. |
|||
<syntaxhighlight lang="factor"> |
|||
USING: kernel sequences arrays generalizations fry math math.parser prettyprint ; |
|||
IN: fizzbuzz |
|||
: zz ( m seq -- v ) dup length 1 <array> V{ } clone 4 -nrot 1 4 -nrot 3 nrot |
|||
'[ dup _ <= ] |
|||
3 -nrot |
|||
'[ |
|||
"" _ [ _ [ swap execute( str n -- str n ) ] change-nth ] each-index |
|||
dup empty? [ drop dup number>string ] [ ] if swapd suffix! swap 1 + |
|||
] |
|||
while drop ; |
|||
: fizz ( str n -- str n ) dup 3 < [ 1 + ] [ drop "Fizz" append 1 ] if ; |
|||
: buzz ( str n -- str n ) dup 5 < [ 1 + ] [ drop "Buzz" append 1 ] if ; |
|||
: quxx ( str n -- str n ) dup 7 < [ 1 + ] [ drop "Quxx" append 1 ] if ; |
|||
: FizzBuzzQuxx ( m -- v ) { fizz buzz quxx } zz ; |
|||
: FizzBuzzQuxx-100 ( -- ) 100 FizzBuzzQuxx . ; |
|||
MAIN: FizzBuzzQuxx-100 |
|||
</syntaxhighlight> |
|||
Another approach is leverage Factor's [https://docs.factorcode.org/content/article-predicates.html predicate] and [https://docs.factorcode.org/content/article-intersections.html intersection] classes. |
|||
<syntaxhighlight lang="factor"> |
|||
USING: io kernel math math.functions math.parser ranges |
|||
sequences ; |
|||
IN: rosetta-code.fizz-buzz |
|||
PREDICATE: fizz < integer 3 divisor? ; |
|||
PREDICATE: buzz < integer 5 divisor? ; |
|||
INTERSECTION: fizzbuzz fizz buzz ; |
|||
GENERIC: fizzbuzz>string ( n -- str ) |
|||
M: fizz fizzbuzz>string |
|||
drop "Fizz" ; |
|||
M: buzz fizzbuzz>string |
|||
drop "Buzz" ; |
|||
M: fizzbuzz fizzbuzz>string |
|||
drop "FizzBuzz" ; |
|||
M: integer fizzbuzz>string |
|||
number>string ; |
|||
MAIN: [ 1 100 [a..b] [ fizzbuzz>string print ] each ] |
|||
</syntaxhighlight> |
|||
=={{header|Falcon}}== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
=={{header|FALSE}}== |
|||
See [[FizzBuzz/EsoLang]] |
|||
=={{header|Fantom}}== |
|||
<syntaxhighlight 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) |
|||
} |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|FBSL}}== |
|||
'''No 'MOD 15' needed.''' |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
{{out}} |
|||
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... |
|||
=={{header|Fe}}== |
|||
There is no built-in ''mod'' function, but you can add it via the C API. |
|||
<syntaxhighlight lang="c"> |
|||
static fe_Object *mod(fe_Context *ctx, fe_Object *args) { |
|||
fe_Number n = fe_tonumber(ctx, fe_nextarg(ctx, &args)); |
|||
return fe_number(ctx, fmod(n, fe_tonumber(ctx, fe_nextarg(ctx, &args)))); |
|||
} |
|||
</syntaxhighlight> |
|||
Then, you can solve 'FizzBuzz' the traditional way: |
|||
<syntaxhighlight lang="clojure"> |
|||
(= i 0) |
|||
(while (< i 100) |
|||
(= i (+ i 1)) |
|||
(print |
|||
(if (is (mod i 15) 0) "FizzBuzz" |
|||
(is (mod i 3) 0) "Fizz" |
|||
(is (mod i 5) 0) "Buzz" |
|||
i))) |
|||
</syntaxhighlight> |
|||
Of course, you can solve this without ''mod'': |
|||
<syntaxhighlight lang="clojure"> |
|||
(= i 0) |
|||
(= fizz 0) |
|||
(= buzz 0) |
|||
(= fizzbuzz 0) |
|||
(while (< i 100) |
|||
(= i (+ i 1)) |
|||
(= fizz (+ fizz 1)) |
|||
(= buzz (+ buzz 1)) |
|||
(= fizzbuzz (+ fizzbuzz 1)) |
|||
; check and reset counters |
|||
(print |
|||
(if (is fizzbuzz 15) (do (= fizzbuzz 0) (= fizz 0) (= buzz 0) "fizzbuzz") |
|||
(is fizz 3) (do (= fizz 0) "fizz") |
|||
(is buzz 5) (do (= buzz 0) "buzz") |
|||
i))) |
|||
</syntaxhighlight> |
|||
=={{header|Fennel}}== |
|||
<syntaxhighlight lang="fennel">(for [i 1 100] |
|||
(print (if (= (% i 15) 0) :FizzBuzz |
|||
(= (% i 3) 0) :Fizz |
|||
(= (% i 5) 0) :Buzz |
|||
i)))</syntaxhighlight> |
|||
Use pattern matching and recursive function: |
|||
<syntaxhighlight lang="fennel">(fn fizz-buzz [from to] |
|||
(print (match [(% from 3) (% from 5)] |
|||
[0 0] :FizzBuzz |
|||
[0 _] :Fizz |
|||
[_ 0] :Buzz |
|||
_ from)) |
|||
(when (< from to) |
|||
(fizz-buzz (+ from 1) to))) |
|||
(fizz-buzz 1 100)</syntaxhighlight> |
|||
Alternative matching pattern:{{trans|D}} |
|||
<syntaxhighlight lang="fennel">(for [i 1 100] |
|||
(print (match (% i 15) |
|||
0 :FizzBuzz |
|||
(where (or 3 6 9 12)) :Fizz |
|||
(where (or 5 10) :Buzz |
|||
_ i)))</syntaxhighlight> |
|||
=={{header|FOCAL}}== |
|||
<tt>FITR</tt> is a built-in function that truncates a floating-point number to an integer. Note that FOCAL uses an arithmetic (three-way) <tt>IF</tt> statement, rather like early Fortran. |
|||
<syntaxhighlight lang="focal">01.10 FOR I=1,100; DO 2.0 |
|||
01.20 QUIT |
|||
02.10 SET ZB=I/15 - FITR(I/15) |
|||
02.20 IF (ZB) 2.4, 2.3, 2.4 |
|||
02.30 TYPE "FizzBuzz" ! |
|||
02.35 RETURN |
|||
02.40 SET Z=I/3 - FITR(I/3) |
|||
02.50 IF (Z) 2.7, 2.6, 2.7 |
|||
02.60 TYPE "Fizz" ! |
|||
02.65 RETURN |
|||
02.70 SET B=I/5 - FITR(I/5) |
|||
02.80 IF (B) 2.99, 2.9, 2.99 |
|||
02.90 TYPE "Buzz" ! |
|||
02.95 RETURN |
|||
02.99 TYPE %3, I, !</syntaxhighlight> |
|||
=={{header|Fermat}}== |
|||
<syntaxhighlight lang="fermat"> |
|||
for i = 1 to 100 do if i|15=0 then !'FizzBuzz ' else if i|5=0 then !'Buzz ' else if i|3=0 then !'Fizz ' else !i;!' ' fi fi fi od</syntaxhighlight> |
|||
{{out}}<pre> |
|||
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</pre> |
|||
=={{header|Fish}}== |
|||
See [[FizzBuzz/EsoLang#Fish]] |
|||
=={{header|Forth}}== |
=={{header|Forth}}== |
||
===table-driven=== |
===table-driven=== |
||
<syntaxhighlight 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 , ' . , ' . ,</syntaxhighlight> |
|||
===or the classic approach=== |
===or the classic approach=== |
||
<syntaxhighlight 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</syntaxhighlight> |
|||
===the well factored approach=== |
|||
SYNONYM is a Forth200x word. |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
===the unrolled approach=== |
|||
<syntaxhighlight lang="forth">: n ( n -- n+1 ) dup . 1+ ; |
|||
: f ( n -- n+1 ) ." Fizz " 1+ ; |
|||
: b ( n -- n+1 ) ." Buzz " 1+ ; |
|||
: fb ( n -- n+1 ) ." FizzBuzz " 1+ ; |
|||
: fb10 ( n -- n+10 ) n n f n b f n n f b ; |
|||
: fb15 ( n -- n+15 ) fb10 n f n n fb ; |
|||
: fb100 ( n -- n+100 ) fb15 fb15 fb15 fb15 fb15 fb15 fb10 ; |
|||
: .fizzbuzz ( -- ) 1 fb100 drop ;</syntaxhighlight> |
|||
=={{header|Fortran}}== |
=={{header|Fortran}}== |
||
In ANSI FORTRAN |
In ANSI FORTRAN 77 or later use structured IF-THEN-ELSE (example uses some ISO Fortran 90 features): |
||
<syntaxhighlight 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</syntaxhighlight> |
|||
This example uses If statements to print "Fizz" and "Buzz" next to each other if the number is divisible by 3 and 5 by waiting to use a line break until after the If statements. |
|||
<syntaxhighlight lang="fortran">program FizzBuzz |
|||
implicit none |
|||
integer :: i = 1 |
|||
do i = 1, 100 |
|||
if (Mod(i,3) == 0)write(*,"(A)",advance='no') "Fizz" |
|||
if (Mod(i,5) == 0)write(*,"(A)",advance='no') "Buzz" |
|||
if (Mod(i,3) /= 0 .and. Mod(i,5) /=0 )write(*,"(I3)",advance='no') i |
|||
print *, "" |
|||
end do |
|||
end program FizzBuzz |
|||
</syntaxhighlight> |
|||
In ISO Fortran 90 or later use SELECT-CASE statement: |
In ISO Fortran 90 or later use SELECT-CASE statement: |
||
<syntaxhighlight 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</syntaxhighlight> |
|||
=={{header|FreeBASIC}}== |
|||
See [[FizzBuzz/Basic]] |
|||
=={{header|Frege}}== |
|||
<syntaxhighlight lang="frege">gen n word = cycle (take (n - 1) (repeat "") ++ [word]) |
|||
pattern = zipWith (++) (gen 3 "fizz") (gen 5 "buzz") |
|||
fizzbuzz = zipWith combine pattern [1..] where |
|||
combine word number = if null word |
|||
then show number |
|||
else word |
|||
show $ take 100 fizzbuzz</syntaxhighlight> |
|||
=={{header|Frink}}== |
|||
<syntaxhighlight 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[] |
|||
}</syntaxhighlight> |
|||
=={{header|FutureBasic}}== |
|||
<syntaxhighlight lang="futurebasic">include "NSLog.incl" |
|||
long fizz, buzz, i |
|||
for i = 1 to 100 |
|||
fizz = (i mod 3 ) |
|||
buzz = (i mod 5 ) |
|||
if fizz + buzz == 0 then NSLog(@"FizzBuzz") : continue |
|||
if fizz == 0 then NSLog(@"Fizz") : continue |
|||
if buzz == 0 then NSLog(@"Buzz") : continue |
|||
NSLog(@"%ld",i) |
|||
next i |
|||
HandleEvents</syntaxhighlight> |
|||
Output: |
|||
<pre> |
|||
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 |
|||
</pre> |
|||
=={{header|Fōrmulæ}}== |
|||
{{FormulaeEntry|page=https://formulae.org/?script=examples/FizzBuzz}} |
|||
'''Solution''' |
|||
[[File:Fōrmulæ - FizzBuzz 01.png]] |
|||
[[File:Fōrmulæ - FizzBuzz 01a.png]] |
|||
[[File:Fōrmulæ - FizzBuzz 02.png]] |
|||
=={{header|Gambas}}== |
|||
'''[https://gambas-playground.proko.eu/?gist=efbe83377a1eabe475d8eba13965cfde Click this link to run this code]''' |
|||
<syntaxhighlight lang="gambas">Public Sub Main() |
|||
Dim siCount As Short |
|||
Dim sText As String |
|||
For siCount = 1 To 100 |
|||
sText = "" |
|||
If siCount Mod 3 = 0 Then sText = "Fizz" |
|||
If siCount Mod 5 = 0 Then sText = "Buzz" |
|||
If siCount Mod 15 = 0 Then sText = "FizzBuzz" |
|||
If sText Then Print sText Else Print siCount |
|||
Next |
|||
End</syntaxhighlight> |
|||
Output: |
|||
<pre> |
|||
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 |
|||
</pre> |
|||
=={{header|GAP}}== |
|||
<syntaxhighlight 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;</syntaxhighlight> |
|||
=={{header|GDScript}}== |
|||
<syntaxhighlight lang="gdscript"> |
|||
extends Node |
|||
func _ready(): |
|||
for i in range(1, 101): |
|||
if i % 15 == 0: |
|||
print("FizzBuzz") |
|||
elif i % 3 == 0: |
|||
print("Fizz") |
|||
elif i % 5 == 0: |
|||
print("Buzz") |
|||
else: |
|||
print(i) |
|||
get_tree().quit() |
|||
</syntaxhighlight> |
|||
=={{header|Genyris}}== |
|||
<syntaxhighlight lang="genyris"> |
|||
@prefix u "http://www.genyris.org/lang/utilities#" |
|||
def fizzbuzz (n) |
|||
map-left ^((3 = 'fizz') (5 = 'buzz')) |
|||
lambda (d) |
|||
cond |
|||
(equal? 0 (% n d!left)) |
|||
d!right |
|||
else |
|||
'' |
|||
for n in (range 1 100) |
|||
define fb (''(.join (fizzbuzz n))) |
|||
u:format "%a\n" |
|||
cond |
|||
(equal? fb '') |
|||
n |
|||
else |
|||
fb |
|||
</syntaxhighlight> |
|||
=={{header|GFA Basic}}== |
|||
<syntaxhighlight lang="text"> |
|||
' Fizz Buzz |
|||
' |
|||
FOR i%=1 TO 100 |
|||
IF i% MOD 15=0 |
|||
PRINT "FizzBuzz" |
|||
ELSE IF i% MOD 3=0 |
|||
PRINT "Fizz" |
|||
ELSE IF i% MOD 5=0 |
|||
PRINT "Buzz" |
|||
ELSE |
|||
PRINT i% |
|||
ENDIF |
|||
NEXT i% |
|||
</syntaxhighlight> |
|||
=={{header|Gleam}}== |
|||
<syntaxhighlight lang="text">import gleam/int |
|||
import gleam/io |
|||
import gleam/iterator |
|||
pub fn main() { |
|||
iterator.range(1, 101) |
|||
|> iterator.map(to_fizzbuzz) |
|||
|> iterator.map(io.println) |
|||
|> iterator.run |
|||
} |
|||
fn to_fizzbuzz(n: Int) -> String { |
|||
case n % 3, n % 5 { |
|||
0, 0 -> "FizzBuzz" |
|||
0, _ -> "Fizz" |
|||
_, 0 -> "Buzz" |
|||
_, _ -> int.to_string(n) |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|Go}}== |
|||
===switch/case approach=== |
|||
<syntaxhighlight 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) |
|||
} |
|||
} |
|||
}</syntaxhighlight> |
|||
===map approach=== |
|||
<syntaxhighlight lang="go">package main |
|||
import "fmt" |
|||
func main() { |
|||
for i := 1; i <= 100; i++ { |
|||
fmt.Println(map[bool]map[bool]interface{}{ |
|||
false: {false: i, true: "Fizz"}, true: {false: "Buzz", true: "FizzBuzz"}, |
|||
}[i%5 == 0][i%3 == 0]) |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|Golfscript}}== |
|||
<syntaxhighlight lang="golfscript">100,{)6,{.(&},{1$1$%{;}{4*35+6875*25base{90\-}%}if}%\or}%n*</syntaxhighlight> |
|||
=={{header|Golo}}== |
|||
<syntaxhighlight lang="golo">module FizzBuzz |
|||
augment java.lang.Integer { |
|||
function getFizzAndOrBuzz = |this| -> match { |
|||
when this % 15 == 0 then "FizzBuzz" |
|||
when this % 3 == 0 then "Fizz" |
|||
when this % 5 == 0 then "Buzz" |
|||
otherwise this |
|||
} |
|||
} |
|||
function main = |args| { |
|||
foreach i in [1..101] { |
|||
println(i: getFizzAndOrBuzz()) |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|Gosu}}== |
|||
<syntaxhighlight 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) |
|||
}</syntaxhighlight> |
|||
One liner version (I added new lines to better readability but when you omit them it's one liner): |
|||
<syntaxhighlight 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) |
|||
}</syntaxhighlight> |
|||
=={{header|Groovy}}== |
=={{header|Groovy}}== |
||
<syntaxhighlight lang="groovy">1.upto(100) { i -> println "${i % 3 ? '' : 'Fizz'}${i % 5 ? '' : 'Buzz'}" ?: i }</syntaxhighlight> |
|||
<pre>for (i in 1..100) { |
|||
println "${i%3?'':'Fizz'}${i%5?'':'Buzz'}" ?: i |
|||
}</pre> |
|||
=={{header| |
=={{header|GW-BASIC}}== |
||
See [[FizzBuzz/Basic]] |
|||
=={{header|Hare}}== |
|||
<syntaxhighlight lang="hare"> |
|||
use fmt; |
|||
export fn main() void = { |
|||
for (let i = 1z; i <= 100; i += 1) { |
|||
fmt::println( |
|||
if (i % 15 == 0) "FizzBuzz" |
|||
else if (i % 3 == 0) "Fizz" |
|||
else if (i % 5 == 0) "Buzz" |
|||
else i |
|||
)!; |
|||
}; |
|||
}; |
|||
</syntaxhighlight> |
|||
=={{header|Haskell}}== |
|||
Variant directly implementing the specification: |
Variant directly implementing the specification: |
||
<syntaxhighlight lang="haskell">fizzbuzz :: Int -> String |
|||
fizzbuzz x |
|||
| f 15 = "FizzBuzz" |
|||
| f 3 = "Fizz" |
|||
| f 5 = "Buzz" |
|||
| otherwise = show x |
|||
where |
|||
f = (0 ==) . rem x |
|||
main :: IO () |
|||
output x | x3 && x5 = "FizzBuzz" |
|||
main = mapM_ (putStrLn . fizzbuzz) [1 .. 100]</syntaxhighlight> |
|||
| x3 = "Fizz" |
|||
| x5 = "Buzz" |
|||
<syntaxhighlight lang="haskell">fizzbuzz :: Int -> String |
|||
| otherwise = show x |
|||
fizzbuzz n = |
|||
where |
|||
'\n' : |
|||
x3 = x `mod` 3 == 0 |
|||
if null (fizz ++ buzz) |
|||
x5 = x `mod` 5 == 0 |
|||
then show n |
|||
else fizz ++ buzz |
|||
answer = map output [1..100] |
|||
where |
|||
fizz = |
|||
if mod n 3 == 0 |
|||
then "Fizz" |
|||
else "" |
|||
buzz = |
|||
if mod n 5 == 0 |
|||
then "Buzz" |
|||
else "" |
|||
main :: IO () |
|||
main = putStr $ concatMap fizzbuzz [1 .. 100]</syntaxhighlight> |
|||
Does not perform the mod 15 step, extesible to arbitrary addtional tests, ex: [bar| n `mod` 7 == 0]. |
|||
<syntaxhighlight 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"</syntaxhighlight> |
|||
Alternate implementation using lazy infinite lists and avoiding use of "mod": |
|||
<syntaxhighlight 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"])</syntaxhighlight> |
|||
Or in terms (still without '''mod''' or '''rem''') of an applicative '''ZipList''': |
|||
<syntaxhighlight lang="haskell">import Control.Applicative ( ZipList(ZipList, getZipList) ) |
|||
fizzBuzz :: [String] |
|||
fizzBuzz = |
|||
getZipList $ go <$> |
|||
ZipList (cycle $ replicate 2 [] <> ["fizz"]) <*> |
|||
ZipList (cycle $ replicate 4 [] <> ["buzz"]) <*> |
|||
ZipList (show <$> [1 ..]) |
|||
go :: String -> String -> String -> String |
|||
go f b n |
|||
| null f && null b = n |
|||
| otherwise = f <> b |
|||
main :: IO () |
|||
main = mapM_ putStrLn $ take 100 fizzBuzz</syntaxhighlight> |
|||
or using an applicative test: |
|||
<syntaxhighlight lang="haskell">import Data.Bool (bool) |
|||
fizzBuzz :: [String] |
|||
fizzBuzz = |
|||
let fb n k = cycle $ replicate (pred n) [] <> [k] |
|||
in zipWith |
|||
(flip . bool <*> null) |
|||
(zipWith (<>) (fb 3 "fizz") (fb 5 "buzz")) |
|||
(show <$> [1 ..]) |
|||
main :: IO () |
|||
main = mapM_ putStrLn $ take 100 fizzBuzz |
|||
</syntaxhighlight> |
|||
Using heavy artillery (needs the mtl package): |
|||
<syntaxhighlight 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"</syntaxhighlight> |
|||
Using guards plus where. |
|||
<syntaxhighlight 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]</syntaxhighlight> |
|||
An elegant solution exploiting monoidal and applicative properties of functions: |
|||
<syntaxhighlight lang="haskell">import Data.Monoid |
|||
fizzbuzz = max |
|||
<$> show |
|||
<*> "fizz" `when` divisibleBy 3 |
|||
<> "buzz" `when` divisibleBy 5 |
|||
<> "quxx" `when` divisibleBy 7 |
|||
where |
|||
when m p x = if p x then m else mempty |
|||
divisibleBy n x = x `mod` n == 0 |
|||
main = mapM_ (putStrLn . fizzbuzz) [1..100]</syntaxhighlight> |
|||
And pattern matching approach: |
|||
<syntaxhighlight lang="haskell">fizzbuzz n = case (rem n 3, rem n 5) of |
|||
(0, 0) -> "FizzBuzz" |
|||
(0, _) -> "Fizz" |
|||
(_, 0) -> "Buzz" |
|||
(_, _) -> show n |
|||
main = mapM_ (putStrLn . fizzbuzz) [1..100]</syntaxhighlight> |
|||
Generalised solution: |
|||
<syntaxhighlight lang="haskell">wordthing :: [(Int, String)] -> Int -> String |
|||
wordthing lst n = |
|||
if matches == [] then |
|||
show n |
|||
else |
|||
concat $ map snd matches |
|||
where matches = filter (\x -> n `mod` (fst x) == 0) lst |
|||
fizzbuzz :: Int -> String |
|||
fizzbuzz = wordthing [(3, "Fizz"), (5, "Buzz")] |
|||
main = do |
|||
mapM_ (putStrLn . fizzbuzz) [1..100]</syntaxhighlight> |
|||
=={{header|hexiscript}}== |
|||
<syntaxhighlight lang="hexiscript">for let i 1; i <= 100; i++ |
|||
if i % 3 = 0 && i % 5 = 0; println "FizzBuzz" |
|||
elif i % 3 = 0; println "Fizz" |
|||
elif i % 5 = 0; println "Buzz" |
|||
else println i; endif |
|||
endfor</syntaxhighlight> |
|||
=={{header|HicEst}}== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
Alternatively: |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
=={{header|HolyC}}== |
|||
<syntaxhighlight lang="holyc">U8 i; |
|||
for (i = 1; i <= 100; i++) { |
|||
if (!(i % 15)) |
|||
Print("FizzBuzz"); |
|||
else if (!(i % 3)) |
|||
Print("Fizz"); |
|||
else if (!(i % 5)) |
|||
Print("Buzz"); |
|||
else |
|||
Print("%d", i); |
|||
Print("\n"); |
|||
}</syntaxhighlight> |
|||
=={{header|Hoon}}== |
|||
<syntaxhighlight lang="hoon">:- %say |
|||
|= [^ ~ ~] |
|||
:- %noun |
|||
%+ turn (gulf [1 101]) |
|||
|= a=@ |
|||
=+ q=[=(0 (mod a 3)) =(0 (mod a 5))] |
|||
?+ q <a> |
|||
[& &] "FizzBuzz" |
|||
[& |] "Fizz" |
|||
[| &] "Buzz" |
|||
==</syntaxhighlight> |
|||
=={{header|Huginn}}== |
|||
<syntaxhighlight lang="huginn">import Algorithms as algo; |
|||
main( argv_ ) { |
|||
if ( size( argv_ ) < 2 ) { |
|||
throw Exception( "usage: fizzbuzz {NUM}" ); |
|||
} |
|||
top = integer( argv_[1] ); |
|||
for ( i : algo.range( 1, top + 1 ) ) { |
|||
by3 = ( i % 3 ) == 0; |
|||
by5 = ( i % 5 ) == 0; |
|||
if ( by3 ) { |
|||
print( "fizz" ); |
|||
} |
|||
if ( by5 ) { |
|||
print( "buzz" ); |
|||
} |
|||
if ( ! ( by3 || by5 ) ) { |
|||
print( i ); |
|||
} |
|||
print( "\n" ); |
|||
} |
|||
return ( 0 ); |
|||
}</syntaxhighlight> |
|||
=={{header|Hy}}== |
|||
<syntaxhighlight lang="lisp">(for [i (range 1 101)] (print (cond |
|||
[(not (% i 15)) "FizzBuzz"] |
|||
[(not (% i 5)) "Buzz"] |
|||
[(not (% i 3)) "Fizz"] |
|||
[True i])))</syntaxhighlight> |
|||
=={{header|i}}== |
|||
<syntaxhighlight lang="i">software { |
|||
for each 1 to 100 |
|||
if i % 15 = 0 |
|||
print("FizzBuzz") |
|||
else if i % 3 = 0 |
|||
print("Fizz") |
|||
else if i % 5 = 0 |
|||
print("Buzz") |
|||
else |
|||
print(i) |
|||
end |
|||
end |
|||
}</syntaxhighlight> |
|||
=={{header|Icon}} and {{header|Unicon}}== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
=={{header|Idris}}== |
|||
<syntaxhighlight lang="idris">partial |
|||
fizzBuzz : Nat -> String |
|||
fizzBuzz n = if (n `modNat` 15) == 0 then "FizzBuzz" |
|||
else if (n `modNat` 3) == 0 then "Fizz" |
|||
else if (n `modNat` 5) == 0 then "Buzz" |
|||
else show n |
|||
main : IO () |
|||
main = sequence_ $ map (putStrLn . fizzBuzz) [1..100]</syntaxhighlight> |
|||
=={{header|Inform 6}}== |
|||
<syntaxhighlight 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 "^"; |
|||
} |
|||
];</syntaxhighlight> |
|||
=={{header|Inform 7}}== |
|||
(Does not work in the current version of Inform 7) |
|||
<syntaxhighlight 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.</syntaxhighlight> |
|||
(Version which is less "programmy", and more in the natural English style of interactive fiction.) |
|||
<syntaxhighlight lang="inform7">The space is a room. An item is a kind of thing. In the space are 100 items. |
|||
To say the name: |
|||
let the count be the number of items carried by the player; |
|||
say "[if the count is the count to the nearest 15]fizzbuzz.[otherwise if the count is the count to the nearest 3]fizz.[otherwise if the count is the count to the nearest 5]buzz.[otherwise][the count in words].". |
|||
To count: |
|||
if an item is in the space |
|||
begin; |
|||
let the next one be a random item in the space; silently try taking the next one; |
|||
say "[the name]" in sentence case; |
|||
count; |
|||
end the story; |
|||
end if. |
|||
When play begins: count. Use no scoring.</syntaxhighlight> |
|||
=={{header|Insitux}}== |
|||
<syntaxhighlight lang="insitux">(function fizzbuzz n |
|||
(match (map (rem n) [3 5]) |
|||
[0 0] "FizzBuzz" |
|||
[0 _] "Fizz" |
|||
[_ 0] "Buzz" |
|||
n)) |
|||
(loop 100 i |
|||
(-> i inc fizzbuzz print))</syntaxhighlight> |
|||
=={{header|Io}}== |
|||
Here's one way to do it: |
|||
<syntaxhighlight 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 |
|||
) |
|||
)</syntaxhighlight> |
|||
And here's a port of the Ruby version, which I personally prefer: |
|||
<syntaxhighlight 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 |
|||
)</syntaxhighlight> |
|||
And here is another more idiomatic version: |
|||
<syntaxhighlight 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 |
|||
)</syntaxhighlight> |
|||
=={{header|Ioke}}== |
|||
<syntaxhighlight lang="ioke">(1..100) each(x, |
|||
cond( |
|||
(x % 15) zero?, "FizzBuzz" println, |
|||
(x % 3) zero?, "Fizz" println, |
|||
(x % 5) zero?, "Buzz" println |
|||
) |
|||
)</syntaxhighlight> |
|||
=={{header|Iptscrae}}== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
=={{header|IS-BASIC}}== |
|||
See [[FizzBuzz/Basic]] |
|||
=={{header|J}}== |
=={{header|J}}== |
||
Solution 0 |
|||
> }. (<'FizzBuzz') (I.0=15|n)} (<'Buzz') (I.0=5|n)} (<'Fizz') (I.0=3|n)} ":&.> n=: i.101 |
|||
Perhaps the most concise approach would be [https://jsoftware.github.io/j-playground/bin/html/emj.html#code=%3E((2%23.3%20q%3A15%26%2B.)%7B(%7C.(%3B~%2C%26%3B)%3B%3A'Fizz%20Buzz')%3B~%22%3A)%26%3E1%2Bi.100 >((2#.3 q:15&+.){(|.(;~,&;);:'Fizz Buzz');~":)&>1+i.100] |
|||
(The above is a live link to a browser based implementation of fizzbuzz in J. To see how this expression works, remove the leading > leaving items in boxes rather than on lines by themselves. And, then, replace the { with ; which means that instead of using the left argument to select (index) from a list of boxes, the left argument is appended in a box to the left of those boxes. Perhaps also replace the 100 with 20 to shrink the result size. If you remove the 1+i.20 (or 1+i.100) entirely, that would display as the verb (function) which is applied to each number.) |
|||
Other approaches are possible: |
|||
Solution _1: Using agenda (@.) as a switch: |
|||
<syntaxhighlight lang="j"> |
|||
classify =: +/@(1 2 * 0 = 3 5&|~) |
|||
(":@]`('Fizz'"_)`('Buzz'"_)`('FizzBuzz'"_) @. classify "0) >:i.100 |
|||
</syntaxhighlight> |
|||
Solution 0 |
|||
<syntaxhighlight lang="j">> }. (<'FizzBuzz') (I.0=15|n)} (<'Buzz') (I.0=5|n)} (<'Fizz') (I.0=3|n)} ":&.> n=: i.101</syntaxhighlight> |
|||
Solution 1 |
Solution 1 |
||
<syntaxhighlight lang="j">Fizz=: 'Fizz' #~ 0 = 3&| |
|||
Buzz=: 'Buzz' #~ 0 = 5&| |
|||
FizzBuzz=: ": [^:('' -: ]) Fizz,Buzz |
|||
FizzBuzz"0 >: i.100</syntaxhighlight> |
|||
Solution 2 (has taste of table-driven template programming) |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
Solution 3 (depends on an obsolete feature of @ in f`g`h@p) |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
Solution 4 (relatively concise): |
|||
<syntaxhighlight lang="j"> ;:inv}.(":&.> [^:(0 = #@])&.> [: ,&.>/ (;:'Fizz Buzz') #&.>~ 0 = 3 5 |/ ])i.101 |
|||
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 Fiz...</syntaxhighlight> |
|||
Here's some intermediate results for subexpressions of this last version (but with a shorter list of numbers): |
|||
<syntaxhighlight lang="j"> i.10 |
|||
0 1 2 3 4 5 6 7 8 9 |
|||
(3 5 |/ ])i.10 |
|||
0 1 2 0 1 2 0 1 2 0 |
|||
0 1 2 3 4 0 1 2 3 4 |
|||
(0=3 5 |/ ])i.10 |
|||
1 0 0 1 0 0 1 0 0 1 |
|||
1 0 0 0 0 1 0 0 0 0 |
|||
(;:'Fizz Buzz') |
|||
┌────┬────┐ |
|||
│Fizz│Buzz│ |
|||
└────┴────┘ |
|||
((;:'Fizz Buzz') #&.>~0=3 5 |/ ])i.10 |
|||
┌────┬┬┬────┬┬────┬────┬┬┬────┐ |
|||
│Fizz│││Fizz││ │Fizz│││Fizz│ |
|||
├────┼┼┼────┼┼────┼────┼┼┼────┤ |
|||
│Buzz│││ ││Buzz│ │││ │ |
|||
└────┴┴┴────┴┴────┴────┴┴┴────┘ |
|||
([: ,&.>/ (;:'Fizz Buzz') #&.>~0=3 5 |/ ])i.10 |
|||
┌────────┬┬┬────┬┬────┬────┬┬┬────┐ |
|||
│FizzBuzz│││Fizz││Buzz│Fizz│││Fizz│ |
|||
└────────┴┴┴────┴┴────┴────┴┴┴────┘ |
|||
(":&.>)i.10 |
|||
┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐ |
|||
│0│1│2│3│4│5│6│7│8│9│ |
|||
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘ |
|||
(":&.> [^:(0 = #@])&.> [: ,&.>/ (;:'Fizz Buzz') #&.>~0=3 5 |/ ])i.10 |
|||
┌────────┬─┬─┬────┬─┬────┬────┬─┬─┬────┐ |
|||
│FizzBuzz│1│2│Fizz│4│Buzz│Fizz│7│8│Fizz│ |
|||
└────────┴─┴─┴────┴─┴────┴────┴─┴─┴────┘ |
|||
}.(":&.> [^:(0 = #@])&.> [: ,&.>/ (;:'Fizz Buzz') #&.>~0=3 5 |/ ])i.10 |
|||
┌─┬─┬────┬─┬────┬────┬─┬─┬────┐ |
|||
│1│2│Fizz│4│Buzz│Fizz│7│8│Fizz│ |
|||
└─┴─┴────┴─┴────┴────┴─┴─┴────┘ |
|||
;:inv}.(":&.> [^:(0 = #@])&.> [: ,&.>/ (;:'Fizz Buzz') #&.>~0=3 5 |/ ])i.10 |
|||
1 2 Fizz 4 Buzz Fizz 7 8 Fizz</syntaxhighlight> |
|||
=={{header|Janet}}== |
|||
<syntaxhighlight lang="janet"> |
|||
(loop [i :range [1 101] |
|||
:let [fizz (zero? (% i 3)) |
|||
buzz (zero? (% i 5))]] |
|||
(print (cond |
|||
(and fizz buzz) "fizzbuzz" |
|||
fizz "fizz" |
|||
buzz "buzz" |
|||
i))) |
|||
</syntaxhighlight> |
|||
=={{header|Java}}== |
=={{header|Java}}== |
||
<syntaxhighlight lang="java"> |
|||
===If/else ladder=== |
|||
public class FizzBuzz { |
|||
public static void main(String[] args) { |
|||
for (int number = 1; number <= 100; number++) { |
|||
if (number % 15 == 0) { |
|||
System.out.println("FizzBuzz"); |
|||
} else if (number % 3 == 0) { |
|||
System.out.println("Fizz"); |
|||
} else if (number % 5 == 0) { |
|||
System.out.println("Buzz"); |
|||
} else { |
|||
System.out.println(number); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
'''Or: ''' |
|||
<syntaxhighlight lang="java"> |
|||
public class FizzBuzz { |
|||
public static void main(String[] args) { |
|||
int number = 1; |
|||
while (number <= 100) { |
|||
if (number % 15 == 0) { |
|||
System.out.println("FizzBuzz"); |
|||
} else if (number % 3 == 0) { |
|||
System.out.println("Fizz"); |
|||
} else if (number % 5 == 0) { |
|||
System.out.println("Buzz"); |
|||
} else { |
|||
System.out.println(number); |
|||
} |
|||
number++; |
|||
} |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
'''Or: ''' |
|||
<syntaxhighlight lang="java"> |
|||
public class FizzBuzz { |
|||
public static void main(String[] args) { |
|||
int number = 1; |
|||
while (number <= 100) { |
|||
System.out.println(number % 15 == 0 ? "FizzBuzz" : number % 3 == 0 ? "Fizz" : number % 5 == 0 ? "Buzz" : number); |
|||
number++; |
|||
} |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
'''Or: ''' |
|||
<syntaxhighlight lang="java"> |
|||
import java.util.stream.IntStream; |
|||
class FizzBuzzJdk12 { |
|||
public static void main(String[] args) { |
|||
IntStream.range(1,101) |
|||
.mapToObj(i->switch (i%15) { |
|||
case 0 -> "FizzBuzz"; |
|||
case 3, 6, 9, 12 -> "Fizz"; |
|||
case 5, 10 -> "Buzz"; |
|||
default -> Integer.toString(i); |
|||
}) |
|||
.forEach(System.out::println) |
|||
; |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
'''Or: ''' |
|||
<syntaxhighlight lang="java"> |
|||
import java.util.stream.IntStream; |
|||
class FizzBuzzJdk12 { |
|||
static final int FIZZ_FLAG = 0x8000_0000; |
|||
static final int BUZZ_FLAG = 0x4000_0000; |
|||
static final int FIZZ_BUZZ_FLAG = FIZZ_FLAG|BUZZ_FLAG; |
|||
static final int[] FLAGS = new int[] { |
|||
FIZZ_BUZZ_FLAG|0, 1, 2, FIZZ_FLAG|3, 4, |
|||
BUZZ_FLAG|5, FIZZ_FLAG|6, 7, 8, FIZZ_FLAG|9, |
|||
BUZZ_FLAG|10, 11, FIZZ_FLAG|12, 13, 14 |
|||
}; |
|||
public static void main(String[] args) { |
|||
IntStream.iterate(0,i->++i) |
|||
.flatMap(i -> IntStream.range(0,15).map(j->FLAGS[j]+15*i)) |
|||
.mapToObj( |
|||
// JDK12 switch expression ... |
|||
n-> switch(n & FIZZ_BUZZ_FLAG) { |
|||
case FIZZ_BUZZ_FLAG -> "fizzbuzz"; |
|||
case FIZZ_FLAG -> "fizz"; |
|||
case BUZZ_FLAG -> "buzz"; |
|||
default -> Integer.toString(~FIZZ_BUZZ_FLAG & n); |
|||
} |
|||
) |
|||
.skip(1) |
|||
.limit(100) |
|||
.forEach(System.out::println) |
|||
; |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|JavaScript}}== |
|||
===ES5=== |
|||
<syntaxhighlight lang="javascript">var fizzBuzz = function () { |
|||
var i, output; |
|||
for (i = 1; i < 101; i += 1) { |
|||
output = ''; |
|||
if (!(i % 3)) { output += 'Fizz'; } |
|||
if (!(i % 5)) { output += 'Buzz'; } |
|||
console.log(output || i);//empty string is false, so we short-circuit |
|||
} |
|||
};</syntaxhighlight> |
|||
Alternate version with ghetto pattern matching |
|||
<syntaxhighlight lang="javascript">for (var i = 1; i <= 100; i++) { |
|||
console.log({ |
|||
truefalse: 'Fizz', |
|||
falsetrue: 'Buzz', |
|||
truetrue: 'FizzBuzz' |
|||
}[(i%3==0) + '' + (i%5==0)] || i) |
|||
}</syntaxhighlight> |
|||
Or very tersely: |
|||
<syntaxhighlight lang="javascript">for(i=1;i<101;i++)console.log((x=(i%3?'':'Fizz')+(i%5?'':'Buzz'))?x:i);</syntaxhighlight> |
|||
Or with even less characters: |
|||
<syntaxhighlight lang="javascript">for(i=1;i<101;i++)console.log((i%3?'':'Fizz')+(i%5?'':'Buzz')||i)</syntaxhighlight> |
|||
Or, in a more functional style, without mutations |
|||
<syntaxhighlight lang="javascript">(function rng(i) { |
|||
return i ? rng(i - 1).concat(i) : [] |
|||
})(100).map( |
|||
function (n) { |
|||
return n % 3 ? ( |
|||
n % 5 ? n : "Buzz" |
|||
) : ( |
|||
n % 5 ? "Fizz" : "FizzBuzz" |
|||
) |
|||
} |
|||
).join(' ')</syntaxhighlight> |
|||
===ES6=== |
|||
<syntaxhighlight lang="javascript">(() => { |
|||
// FIZZBUZZ -------------------------------------------------------------- |
|||
// fizzBuzz :: Int -> String |
|||
const fizzBuzz = n => |
|||
caseOf(n, [ |
|||
[x => x % 15 === 0, "FizzBuzz"], |
|||
[x => x % 3 === 0, "Fizz"], |
|||
[x => x % 5 === 0, "Buzz"] |
|||
], n.toString()); |
|||
// GENERIC FUNCTIONS ----------------------------------------------------- |
|||
// caseOf :: a -> [(a -> Bool, b)] -> b -> b |
|||
const caseOf = (e, pvs, otherwise) => |
|||
pvs.reduce((a, [p, v]) => |
|||
a !== otherwise ? a : (p(e) ? v : a), otherwise); |
|||
// enumFromTo :: Int -> Int -> [Int] |
|||
const enumFromTo = (m, n) => |
|||
Array.from({ |
|||
length: Math.floor(n - m) + 1 |
|||
}, (_, i) => m + i); |
|||
// map :: (a -> b) -> [a] -> [b] |
|||
const map = (f, xs) => xs.map(f); |
|||
// unlines :: [String] -> String |
|||
const unlines = xs => xs.join('\n'); |
|||
// TEST ------------------------------------------------------------------ |
|||
return unlines( |
|||
map(fizzBuzz, enumFromTo(1, 100)) |
|||
); |
|||
})();</syntaxhighlight> |
|||
A functional implementation: |
|||
<syntaxhighlight lang="javascript">const factors = [[3, 'Fizz'], [5, 'Buzz']] |
|||
const fizzBuzz = num => factors.map(([factor,text]) => (num % factor)?'':text).join('') || num |
|||
const range1 = x => [...Array(x+1).keys()].slice(1) |
|||
const outputs = range1(100).map(fizzBuzz) |
|||
console.log(outputs.join('\n'))</syntaxhighlight> |
|||
Or composing generic functions, and without use of modulo (or other) numeric tests: |
|||
{{Trans|Python}} |
|||
{{Trans|Haskell}} |
|||
<syntaxhighlight lang="javascript">(() => { |
|||
'use strict'; |
|||
// main :: IO () |
|||
const main = () => { |
|||
// FIZZBUZZ --------------------------------------- |
|||
// fizzBuzz :: Generator [String] |
|||
const fizzBuzz = () => { |
|||
const fb = n => k => cycle( |
|||
replicate(n - 1)('').concat(k) |
|||
); |
|||
return zipWith( |
|||
liftA2(flip)(bool)(isNull) |
|||
)( |
|||
zipWith(append)(fb(3)('fizz'))(fb(5)('buzz')) |
|||
)(fmap(str)(enumFrom(1))); |
|||
}; |
|||
// TEST ------------------------------------------- |
|||
console.log( |
|||
unlines( |
|||
take(100)( |
|||
fizzBuzz() |
|||
) |
|||
) |
|||
); |
|||
}; |
|||
// GENERIC FUNCTIONS ---------------------------------- |
|||
// Just :: a -> Maybe a |
|||
const Just = x => ({ |
|||
type: 'Maybe', |
|||
Nothing: false, |
|||
Just: x |
|||
}); |
|||
// Nothing :: Maybe a |
|||
const Nothing = () => ({ |
|||
type: 'Maybe', |
|||
Nothing: true, |
|||
}); |
|||
// Tuple (,) :: a -> b -> (a, b) |
|||
const Tuple = a => b => ({ |
|||
type: 'Tuple', |
|||
'0': a, |
|||
'1': b, |
|||
length: 2 |
|||
}); |
|||
// append (++) :: [a] -> [a] -> [a] |
|||
// append (++) :: String -> String -> String |
|||
const append = xs => ys => xs.concat(ys); |
|||
// bool :: a -> a -> Bool -> a |
|||
const bool = f => t => p => |
|||
p ? t : f; |
|||
// cycle :: [a] -> Generator [a] |
|||
function* cycle(xs) { |
|||
const lng = xs.length; |
|||
let i = 0; |
|||
while (true) { |
|||
yield(xs[i]) |
|||
i = (1 + i) % lng; |
|||
} |
|||
} |
|||
// enumFrom :: Int => Int -> [Int] |
|||
function* enumFrom(x) { |
|||
let v = x; |
|||
while (true) { |
|||
yield v; |
|||
v = 1 + v; |
|||
} |
|||
} |
|||
// flip :: (a -> b -> c) -> b -> a -> c |
|||
const flip = f => |
|||
x => y => f(y)(x); |
|||
// fmap <$> :: (a -> b) -> Gen [a] -> Gen [b] |
|||
const fmap = f => |
|||
function*(gen) { |
|||
let v = take(1)(gen); |
|||
while (0 < v.length) { |
|||
yield(f(v[0])) |
|||
v = take(1)(gen) |
|||
} |
|||
}; |
|||
// fst :: (a, b) -> a |
|||
const fst = tpl => tpl[0]; |
|||
// isNull :: [a] -> Bool |
|||
// isNull :: String -> Bool |
|||
const isNull = xs => |
|||
1 > xs.length; |
|||
// Returns Infinity over objects without finite length. |
|||
// This enables zip and zipWith to choose the shorter |
|||
// argument when one is non-finite, like cycle, repeat etc |
|||
// length :: [a] -> Int |
|||
const length = xs => |
|||
(Array.isArray(xs) || 'string' === typeof xs) ? ( |
|||
xs.length |
|||
) : Infinity; |
|||
// liftA2 :: (a0 -> b -> c) -> (a -> a0) -> (a -> b) -> a -> c |
|||
const liftA2 = op => f => g => |
|||
// Lift a binary function to a composition |
|||
// over two other functions. |
|||
// liftA2 (*) (+ 2) (+ 3) 7 == 90 |
|||
x => op(f(x))(g(x)); |
|||
// replicate :: Int -> a -> [a] |
|||
const replicate = n => x => |
|||
Array.from({ |
|||
length: n |
|||
}, () => x); |
|||
// snd :: (a, b) -> b |
|||
const snd = tpl => tpl[1]; |
|||
// str :: a -> String |
|||
const str = x => x.toString(); |
|||
// take :: Int -> [a] -> [a] |
|||
// take :: Int -> String -> String |
|||
const take = n => xs => |
|||
'GeneratorFunction' !== xs.constructor.constructor.name ? ( |
|||
xs.slice(0, n) |
|||
) : [].concat.apply([], Array.from({ |
|||
length: n |
|||
}, () => { |
|||
const x = xs.next(); |
|||
return x.done ? [] : [x.value]; |
|||
})); |
|||
// The first argument is a sample of the type |
|||
// allowing the function to make the right mapping |
|||
// uncons :: [a] -> Maybe (a, [a]) |
|||
const uncons = xs => { |
|||
const lng = length(xs); |
|||
return (0 < lng) ? ( |
|||
lng < Infinity ? ( |
|||
Just(Tuple(xs[0])(xs.slice(1))) // Finite list |
|||
) : (() => { |
|||
const nxt = take(1)(xs); |
|||
return 0 < nxt.length ? ( |
|||
Just(Tuple(nxt[0])(xs)) |
|||
) : Nothing(); |
|||
})() // Lazy generator |
|||
) : Nothing(); |
|||
}; |
|||
// unlines :: [String] -> String |
|||
const unlines = xs => xs.join('\n'); |
|||
// zipWith :: (a -> b -> c) Gen [a] -> Gen [b] -> Gen [c] |
|||
const zipWith = f => ga => gb => { |
|||
function* go(ma, mb) { |
|||
let |
|||
a = ma, |
|||
b = mb; |
|||
while (!a.Nothing && !b.Nothing) { |
|||
let |
|||
ta = a.Just, |
|||
tb = b.Just |
|||
yield(f(fst(ta))(fst(tb))); |
|||
a = uncons(snd(ta)); |
|||
b = uncons(snd(tb)); |
|||
} |
|||
} |
|||
return go(uncons(ga), uncons(gb)); |
|||
}; |
|||
// MAIN --- |
|||
return main(); |
|||
})();</syntaxhighlight> |
|||
=={{header|Joy}}== |
|||
The following program first defines a function "out", that handles the Fizz / Buzz logic, and then loops from 1 to 100 mapping the function onto each number, and printing ("put") the output. |
|||
<syntaxhighlight lang="joy">DEFINE out == [[[15 rem null] "FizzBuzz"] |
|||
[[ 3 rem null] "Fizz"] |
|||
[[ 5 rem null] "Buzz"] |
|||
[]] cond |
|||
[putchars pop] [put] ifstring '\n putch. |
|||
100 [] [out] primrec.</syntaxhighlight> |
|||
=={{header|jq}}== |
|||
<syntaxhighlight lang="jq">range(1;101) |
|||
| if . % 15 == 0 then "FizzBuzz" |
|||
elif . % 5 == 0 then "Buzz" |
|||
elif . % 3 == 0 then "Fizz" |
|||
else . |
|||
end</syntaxhighlight> |
|||
Another solution: |
|||
<syntaxhighlight lang="jq">range(100) + 1 | [( |
|||
(select(. % 3 == 0) | "Fizz"), |
|||
(select(. % 5 == 0) | "Buzz") |
|||
) // tostring] | join("") |
|||
</syntaxhighlight> |
|||
=={{header|Julia}}== |
|||
{{works with|Julia|1.8.5}} |
|||
One basic solution: |
|||
<syntaxhighlight lang="julia">for i in 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</syntaxhighlight> |
|||
Another possible solution: |
|||
<syntaxhighlight lang="julia">collect(i % 15 == 0 ? "FizzBuzz" : i % 5 == 0 ? "Buzz" : i % 3 == 0 ? "Fizz" : i for i in 1:100) |> println</syntaxhighlight> |
|||
A 3rd possible solution: |
|||
<syntaxhighlight lang="julia">fb(i::Integer) = "Fizz" ^ (i % 3 == 0) * "Buzz" ^ (i % 5 == 0) * string(i) ^ (i % 3 != 0 && i % 5 != 0) |
|||
for i in 1:100 println(fb(i)) end</syntaxhighlight> |
|||
A 4th one: |
|||
<syntaxhighlight lang="julia">println.(map(fb, 1:100))</syntaxhighlight> |
|||
A fifth (DRY, Don't Repeat Yourself) possible solution: |
|||
<syntaxhighlight lang="julia">for i in 1:100 |
|||
msg = "Fizz" ^ (i % 3 == 0) * "Buzz" ^ (i % 5 == 0) |
|||
println(isempty(msg) ? i : msg) |
|||
end</syntaxhighlight> |
|||
=={{header|K}}== |
|||
===Solution 0=== |
|||
<syntaxhighlight lang="k">`0:\:{:[0=#a:{,/$(:[0=x!3;"Fizz"];:[0=x!5;"Buzz"])}@x;$x;a]}'1_!101</syntaxhighlight> |
|||
===Solution 1=== |
|||
<syntaxhighlight lang="k"> |
|||
fizzbuzz:{:[0=x!15;`0:,"FizzBuzz";0=x!3;`0:,"Fizz";0=x!5;`0:,"Buzz";`0:,$x]} |
|||
fizzbuzz' 1+!100 |
|||
</syntaxhighlight> |
|||
===Solution 2=== |
|||
<syntaxhighlight lang="k">fizzbuzz:{ |
|||
v:1+!x |
|||
i:(&0=)'v!/:3 5 15 |
|||
r:@[v;i 0;{"Fizz"}] |
|||
r:@[r;i 1;{"Buzz"}] |
|||
@[r;i 2;{"FizzBuzz"}]} |
|||
`0:$fizzbuzz 100</syntaxhighlight> |
|||
===Solution 3=== |
|||
For kona: <syntaxhighlight lang="k">{,/$(s;x)@~#s:`Fizz`Buzz@&~x!'3 5}'1+!30</syntaxhighlight> |
|||
For k6 and oK, change <code>x!'3 5</code> to <code>3 5!'x</code>. |
|||
=={{header|Kamailio Script}}== |
|||
To run it, send a SIP message to the server and FizzBuzz will appear in the logs. |
|||
This will only work up to 100 because Kamailio terminates all while loops after 100 iterations. |
|||
<syntaxhighlight lang="kamailio"># FizzBuzz |
|||
log_stderror=yes |
|||
loadmodule "pv" |
|||
loadmodule "xlog" |
|||
route { |
|||
$var(i) = 1; |
|||
while ($var(i) <= 1000) { |
|||
if ($var(i) mod 15 == 0) { |
|||
xlog("FizzBuzz\n"); |
|||
} else if ($var(i) mod 5 == 0) { |
|||
xlog("Buzz\n"); |
|||
} else if ($var(i) mod 3 == 0) { |
|||
xlog("Fizz\n"); |
|||
} else { |
|||
xlog("$var(i)\n"); |
|||
} |
|||
$var(i) = $var(i) + 1; |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|Kaya}}== |
|||
<syntaxhighlight 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); |
|||
}</syntaxhighlight> |
|||
=={{header|KL1}}== |
|||
<syntaxhighlight lang="prolog"> |
|||
:- module main. |
|||
main :- |
|||
nats(100, Nats), |
|||
fizzbuzz(Nats, Output), |
|||
display(Output). |
|||
nats(Max, Out) :- |
|||
nats(Max, 1, Out). |
|||
nats(Max, Count, Out) :- Count =< Max | |
|||
Out = [Count|NewOut], |
|||
NewCount := Count + 1, |
|||
nats(Max, NewCount, NewOut). |
|||
nats(Max, Count, Out) :- Count > Max | |
|||
Out = []. |
|||
fizzbuzz([N|Rest], Out) :- N mod 3 =:= 0, N mod 5 =:= 0 | |
|||
Out = ['FizzBuzz' | NewOut], |
|||
fizzbuzz(Rest, NewOut). |
|||
fizzbuzz([], Out) :- |
|||
Out = []. |
|||
alternatively. |
|||
fizzbuzz([N|Rest], Out) :- N mod 3 =:= 0 | |
|||
Out = ['Fizz' | NewOut], |
|||
fizzbuzz(Rest, NewOut). |
|||
fizzbuzz([N|Rest], Out) :- N mod 5 =:= 0 | |
|||
Out = ['Buzz' | NewOut], |
|||
fizzbuzz(Rest, NewOut). |
|||
alternatively. |
|||
fizzbuzz([N|Rest], Out) :- |
|||
Out = [N | NewOut], |
|||
fizzbuzz(Rest, NewOut). |
|||
display([Message|Rest]) :- |
|||
io:outstream([print(Message), nl]), |
|||
display(Rest). |
|||
display([]). |
|||
</syntaxhighlight> |
|||
=={{header|Klong}}== |
|||
<syntaxhighlight lang="k"> |
|||
{:[0=x!15;:FizzBuzz:|0=x!5;:Buzz:|0=x!3;:Fizz;x]}'1+!100 |
|||
</syntaxhighlight> |
|||
=={{header|Kotlin}}== |
|||
===Imperative solution=== |
|||
<syntaxhighlight lang="scala">fun fizzBuzz() { |
|||
for (number in 1..100) { |
|||
println( |
|||
when { |
|||
number % 15 == 0 -> "FizzBuzz" |
|||
number % 3 == 0 -> "Fizz" |
|||
number % 5 == 0 -> "Buzz" |
|||
else -> number |
|||
} |
|||
) |
|||
} |
|||
}</syntaxhighlight> |
|||
===Functional solution 1=== |
|||
<syntaxhighlight lang="scala">fun fizzBuzz1() { |
|||
fun fizzBuzz(x: Int) = if (x % 15 == 0) "FizzBuzz" else x.toString() |
|||
fun fizz(x: Any) = if (x is Int && x % 3 == 0) "Buzz" else x |
|||
fun buzz(x: Any) = if (x is Int && x.toInt() % 5 == 0) "Fizz" else x |
|||
(1..100).map { fizzBuzz(it) }.map { fizz(it) }.map { buzz(it) }.forEach { println(it) } |
|||
}</syntaxhighlight> |
|||
===Functional solution 2=== |
|||
<syntaxhighlight lang="scala">fun fizzBuzz2() { |
|||
fun fizz(x: Pair<Int, StringBuilder>) = if(x.first % 3 == 0) x.apply { second.append("Fizz") } else x |
|||
fun buzz(x: Pair<Int, StringBuilder>) = if(x.first % 5 == 0) x.apply { second.append("Buzz") } else x |
|||
fun none(x: Pair<Int, StringBuilder>) = if(x.second.isBlank()) x.second.apply { append(x.first) } else x.second |
|||
(1..100).map { Pair(it, StringBuilder()) } |
|||
.map { fizz(it) } |
|||
.map { buzz(it) } |
|||
.map { none(it) } |
|||
.forEach { println(it) } |
|||
}</syntaxhighlight> |
|||
===Short version with mapOf=== |
|||
<syntaxhighlight lang="scala"> |
|||
fun fizzBuzz() { |
|||
(1..100).forEach { println(mapOf(0 to it, it % 3 to "Fizz", it % 5 to "Buzz", it % 15 to "FizzBuzz")[0]) } |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|KQL}}== |
|||
<syntaxhighlight lang="kql"> |
|||
range i from 1 to 100 step 1 |
|||
| project Result = |
|||
case( |
|||
i % 15 == 0, "FizzBuzz", |
|||
i % 3 == 0, "Fizz", |
|||
i % 5 == 0, "Buzz", |
|||
tostring(i) |
|||
) |
|||
</syntaxhighlight> |
|||
=={{header|KSI}}== |
|||
<syntaxhighlight lang="ksi"> |
|||
`plain |
|||
[1 100] `for pos : n ~ |
|||
out = [] |
|||
n `mod 3 == 0 ? out.# = 'Fizz' ; |
|||
n `mod 5 == 0 ? out.# = 'Buzz' ; |
|||
(out `or n) #write_ln # |
|||
; |
|||
</syntaxhighlight> |
|||
=={{header|LabVIEW}}== |
|||
{{VI snippet}}<br/> |
|||
[[file:LabVIEW_FizzBuzz.png]] |
|||
=={{header|Lambdatalk}}== |
|||
<syntaxhighlight lang="scheme"> |
|||
1. direct: |
|||
{S.map |
|||
{lambda {:i} |
|||
{if {= {% :i 15} 0} |
|||
then fizzbuzz |
|||
else {if {= {% :i 3} 0} |
|||
then fizz |
|||
else {if {= {% :i 5} 0} |
|||
then buzz |
|||
else :i}}}} |
|||
{S.serie 1 100}} |
|||
-> 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 |
|||
2. via a function |
|||
{def fizzbuzz |
|||
{lambda {:i :n} |
|||
{if {> :i :n} |
|||
then . |
|||
else {if {= {% :i 15} 0} |
|||
then fizzbuzz |
|||
else {if {= {% :i 3} 0} |
|||
then fizz |
|||
else {if {= {% :i 5} 0} |
|||
then buzz |
|||
else :i}}} {fizzbuzz {+ :i 1} :n} |
|||
}}} |
|||
-> fizzbuzz |
|||
{fizzbuzz 1 100} |
|||
-> same as above. |
|||
</syntaxhighlight> |
|||
=={{header|Lang}}== |
|||
<syntaxhighlight lang="lang"> |
|||
$i = 1 |
|||
while($i <= 100) { |
|||
if($i % 15 == 0) { |
|||
fn.println(FizzBuzz) |
|||
}elif($i % 5 == 0) { |
|||
fn.println(Buzz) |
|||
}elif($i % 3 == 0) { |
|||
fn.println(Fizz) |
|||
}else { |
|||
fn.println($i) |
|||
} |
} |
||
}</java> |
|||
$i += 1 |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|langur}}== |
|||
<syntaxhighlight lang="langur"> |
|||
for i of 100 { |
|||
writeln switch(0; i rem 15: "FizzBuzz"; i rem 5: "Buzz"; i rem 3: "Fizz"; i) |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|Lasso}}== |
|||
<syntaxhighlight lang="lasso">with i in generateSeries(1, 100) |
|||
select ((#i % 3 == 0 ? 'Fizz' | '') + (#i % 5 == 0 ? 'Buzz' | '') || #i)</syntaxhighlight> |
|||
=={{header|LaTeX}}== |
|||
{{libheader|ifthen}} |
|||
{{libheader|intcalc}} |
|||
This version uses the ifthen and intcalc packages. There sure are more native solutions including solutions in plain TeX, but for me this is a readable and comprehensible one. |
|||
<syntaxhighlight lang="latex">\documentclass{minimal} |
|||
\usepackage{ifthen} |
|||
\usepackage{intcalc} |
|||
\newcounter{mycount} |
|||
\newboolean{fizzOrBuzz} |
|||
\newcommand\fizzBuzz[1]{% |
|||
\setcounter{mycount}{1}\whiledo{\value{mycount}<#1} |
|||
{ |
|||
\setboolean{fizzOrBuzz}{false} |
|||
\ifthenelse{\equal{\intcalcMod{\themycount}{3}}{0}}{\setboolean{fizzOrBuzz}{true}Fizz}{} |
|||
\ifthenelse{\equal{\intcalcMod{\themycount}{5}}{0}}{\setboolean{fizzOrBuzz}{true}Buzz}{} |
|||
\ifthenelse{\boolean{fizzOrBuzz}}{}{\themycount} |
|||
\stepcounter{mycount} |
|||
\\ |
|||
} |
|||
} |
|||
\begin{document} |
|||
\fizzBuzz{101} |
|||
\end{document}</syntaxhighlight> |
|||
=={{header|LDPL}}== |
|||
<syntaxhighlight lang="ldpl">data: |
|||
i is number |
|||
n is number |
|||
procedure: |
|||
for i from 1 to 101 step 1 do |
|||
modulo i by 15 in n |
|||
if n is equal to 0 then |
|||
display "FizzBuzz" lf |
|||
continue |
|||
end if |
|||
modulo i by 5 in n |
|||
if n is equal to 0 then |
|||
display "Buzz" lf |
|||
continue |
|||
end if |
|||
modulo i by 3 in n |
|||
if n is equal to 0 then |
|||
display "Fizz" lf |
|||
continue |
|||
end if |
|||
display i lf |
|||
repeat |
|||
</syntaxhighlight> |
|||
=={{header|Lean}}== |
|||
Lean 4: |
|||
<syntaxhighlight lang="lean"> |
|||
def fizz : String := |
|||
"Fizz" |
|||
def buzz : String := |
|||
"Buzz" |
|||
def newLine : String := |
|||
"\n" |
|||
def isDivisibleBy (n : Nat) (m : Nat) : Bool := |
|||
match m with |
|||
| 0 => false |
|||
| (k + 1) => (n % (k + 1)) = 0 |
|||
def getTerm (n : Nat) : String := |
|||
if (isDivisibleBy n 15) then (fizz ++ buzz) |
|||
else if (isDivisibleBy n 3) then fizz |
|||
else if (isDivisibleBy n 5) then buzz |
|||
else toString (n) |
|||
def range (a : Nat) (b : Nat) : List (Nat) := |
|||
match b with |
|||
| 0 => [] |
|||
| m + 1 => a :: (range (a + 1) m) |
|||
def getTerms (n : Nat) : List (String) := |
|||
(range 1 n).map (getTerm) |
|||
def addNewLine (accum : String) (elem : String) : String := |
|||
accum ++ elem ++ newLine |
|||
def fizzBuzz : String := |
|||
(getTerms 100).foldl (addNewLine) ("") |
|||
def main : IO Unit := |
|||
IO.println (fizzBuzz) |
|||
#eval main |
|||
</syntaxhighlight> |
|||
=={{header|Liberty BASIC}}== |
|||
See [[FizzBuzz/Basic]] |
|||
=={{header|LIL}}== |
|||
<syntaxhighlight lang="tcl"># fizzbuzz in LIL |
|||
for {set i 1} {$i <= 100} {inc i} { |
|||
set show "" |
|||
if {[expr $i % 3 == 0]} {set show "Fizz"} |
|||
if {[expr $i % 5 == 0]} {set show $show"Buzz"} |
|||
if {[expr [length $show] == 0]} {set show $i} |
|||
print $show |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre>prompt$ lil fizzbuzz.lil | sed -n '1,16p' |
|||
1 |
|||
2 |
|||
Fizz |
|||
4 |
|||
Buzz |
|||
Fizz |
|||
7 |
|||
8 |
|||
Fizz |
|||
Buzz |
|||
11 |
|||
Fizz |
|||
13 |
|||
14 |
|||
FizzBuzz |
|||
16</pre> |
|||
=={{header|LiveCode}}== |
|||
<syntaxhighlight lang="livecode">repeat with i = 1 to 100 |
|||
switch |
|||
case i mod 15 = 0 |
|||
put "FizzBuzz" & cr after fizzbuzz |
|||
break |
|||
case i mod 5 = 0 |
|||
put "Buzz" & cr after fizzbuzz |
|||
break |
|||
case i mod 3 = 0 |
|||
put "Fizz" & cr after fizzbuzz |
|||
break |
|||
default |
|||
put i & cr after fizzbuzz |
|||
end switch |
|||
end repeat |
|||
put fizzbuzz</syntaxhighlight> |
|||
=={{header|LiveScript}}== |
|||
See: http://livescript.net/blog/fizzbuzzbazz.html |
|||
<syntaxhighlight lang="livescript">[1 to 100] map -> [k + \zz for k, v of {Fi: 3, Bu: 5} | it % v < 1] * '' || it</syntaxhighlight> |
|||
=={{header|LLVM}}== |
|||
<syntaxhighlight lang="llvm">; ModuleID = 'fizzbuzz.c' |
|||
; source_filename = "fizzbuzz.c" |
|||
; target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" |
|||
; target triple = "x86_64-pc-windows-msvc19.21.27702" |
|||
; This is not strictly LLVM, as it uses the C library function "printf". |
|||
; LLVM does not provide a way to print values, so the alternative would be |
|||
; to just load the string into memory, and that would be boring. |
|||
; Additional comments have been inserted, as well as changes made from the output produced by clang such as putting more meaningful labels for the jumps |
|||
$"\01??_C@_09NODAFEIA@FizzBuzz?6?$AA@" = comdat any |
|||
$"\01??_C@_05KEBFOHOF@Fizz?6?$AA@" = comdat any |
|||
$"\01??_C@_05JKJENPHA@Buzz?6?$AA@" = comdat any |
|||
$"\01??_C@_03PMGGPEJJ@?$CFd?6?$AA@" = comdat any |
|||
;--- String constant defintions |
|||
@"\01??_C@_09NODAFEIA@FizzBuzz?6?$AA@" = linkonce_odr unnamed_addr constant [10 x i8] c"FizzBuzz\0A\00", comdat, align 1 |
|||
@"\01??_C@_05KEBFOHOF@Fizz?6?$AA@" = linkonce_odr unnamed_addr constant [6 x i8] c"Fizz\0A\00", comdat, align 1 |
|||
@"\01??_C@_05JKJENPHA@Buzz?6?$AA@" = linkonce_odr unnamed_addr constant [6 x i8] c"Buzz\0A\00", comdat, align 1 |
|||
@"\01??_C@_03PMGGPEJJ@?$CFd?6?$AA@" = linkonce_odr unnamed_addr constant [4 x i8] c"%d\0A\00", comdat, align 1 |
|||
;--- The declaration for the external C printf function. |
|||
declare i32 @printf(i8*, ...) |
|||
; Function Attrs: noinline nounwind optnone uwtable |
|||
define i32 @main() #0 { |
|||
%1 = alloca i32, align 4 |
|||
store i32 1, i32* %1, align 4 |
|||
;--- It does not seem like this branch can be removed |
|||
br label %loop |
|||
;--- while (i <= 100) |
|||
loop: |
|||
%2 = load i32, i32* %1, align 4 |
|||
%3 = icmp sle i32 %2, 100 |
|||
br i1 %3, label %divisible_15, label %finished |
|||
;--- if (i % 15 == 0) |
|||
divisible_15: |
|||
%4 = load i32, i32* %1, align 4 |
|||
%5 = srem i32 %4, 15 |
|||
%6 = icmp eq i32 %5, 0 |
|||
br i1 %6, label %print_fizzbuzz, label %divisible_3 |
|||
;--- Print 'FizzBuzz' |
|||
print_fizzbuzz: |
|||
%7 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @"\01??_C@_09NODAFEIA@FizzBuzz?6?$AA@", i32 0, i32 0)) |
|||
br label %next |
|||
;--- if (i % 3 == 0) |
|||
divisible_3: |
|||
%8 = load i32, i32* %1, align 4 |
|||
%9 = srem i32 %8, 3 |
|||
%10 = icmp eq i32 %9, 0 |
|||
br i1 %10, label %print_fizz, label %divisible_5 |
|||
;--- Print 'Fizz' |
|||
print_fizz: |
|||
%11 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @"\01??_C@_05KEBFOHOF@Fizz?6?$AA@", i32 0, i32 0)) |
|||
br label %next |
|||
;--- if (i % 5 == 0) |
|||
divisible_5: |
|||
%12 = load i32, i32* %1, align 4 |
|||
%13 = srem i32 %12, 5 |
|||
%14 = icmp eq i32 %13, 0 |
|||
br i1 %14, label %print_buzz, label %print_number |
|||
;--- Print 'Buzz' |
|||
print_buzz: |
|||
%15 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @"\01??_C@_05JKJENPHA@Buzz?6?$AA@", i32 0, i32 0)) |
|||
br label %next |
|||
;--- Print the number |
|||
print_number: |
|||
%16 = load i32, i32* %1, align 4 |
|||
%17 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @"\01??_C@_03PMGGPEJJ@?$CFd?6?$AA@", i32 0, i32 0), i32 %16) |
|||
;--- It does not seem like this branch can be removed |
|||
br label %next |
|||
;--- i = i + 1 |
|||
next: |
|||
%18 = load i32, i32* %1, align 4 |
|||
%19 = add nsw i32 %18, 1 |
|||
store i32 %19, i32* %1, align 4 |
|||
br label %loop |
|||
;--- exit main |
|||
finished: |
|||
ret i32 0 |
|||
} |
|||
attributes #0 = { noinline nounwind optnone uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" } |
|||
!llvm.module.flags = !{!0, !1} |
|||
!llvm.ident = !{!2} |
|||
!0 = !{i32 1, !"wchar_size", i32 2} |
|||
!1 = !{i32 7, !"PIC Level", i32 2} |
|||
!2 = !{!"clang version 6.0.1 (tags/RELEASE_601/final)"}</syntaxhighlight> |
|||
=={{header|Lobster}}== |
|||
<syntaxhighlight lang="lobster">include "std.lobster" |
|||
forbias(100, 1) i: |
|||
fb := (i % 3 == 0 and "fizz" or "") + |
|||
(i % 5 == 0 and "buzz" or "") |
|||
print fb.length and fb or "" + i</syntaxhighlight> |
|||
=={{header|Logo}}== |
|||
<syntaxhighlight 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 #]</syntaxhighlight> |
|||
"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: |
|||
<syntaxhighlight 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]</syntaxhighlight> |
|||
Lhogho can use the above code, except that 'modulo' must be replaced with 'remainder'. |
|||
=={{header|LOLCODE}}== |
|||
See [[FizzBuzz/EsoLang]] |
|||
=={{header|LSE}}== |
|||
<syntaxhighlight 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)</syntaxhighlight> |
|||
=={{header|Lua}}== |
|||
===If/else Ladder=== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
===Concatenation=== |
===Concatenation=== |
||
<syntaxhighlight lang="lua">for i = 1, 100 do |
|||
<java>public class FizzBuzz{ |
|||
output = "" |
|||
public static void main(String[] args){ |
|||
if i % 3 == 0 then |
|||
output = output.."Fizz" |
|||
end |
|||
if(i % 3 == 0) output += "Fizz"; |
|||
if i % 5 == 0 then |
|||
output = output.."Buzz" |
|||
end |
|||
System.out.println(output); |
|||
if(output == "") then |
|||
} |
|||
output = i |
|||
} |
|||
end |
|||
}</java> |
|||
print(output) |
|||
===Ternary operator=== |
|||
end</syntaxhighlight> |
|||
<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" ;); |
|||
} |
|||
} |
|||
}</java> |
|||
===Recursive=== |
|||
<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; |
|||
}</java> |
|||
=== |
===Quasi bit field=== |
||
<syntaxhighlight lang="lua">word = {"Fizz", "Buzz", "FizzBuzz"} |
|||
<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") |
|||
: ""; |
|||
}</java> |
|||
for i = 1, 100 do |
|||
=={{header|JavaScript}}== |
|||
print(word[(i % 3 == 0 and 1 or 0) + (i % 5 == 0 and 2 or 0)] or i) |
|||
{{works with|NJS|0.2.5}} |
|||
end</syntaxhighlight> |
|||
for (var i = 1; i <= 100; i++) { |
|||
if (i % 15 == 0) { |
|||
===Lookup table=== |
|||
print("FizzBuzz"); |
|||
<syntaxhighlight lang="lua">local t = { |
|||
} else if (i % 3 == 0) { |
|||
[0] = "FizzBuzz", |
|||
[3] = "Fizz", |
|||
[5] = "Buzz", |
|||
[6] = "Fizz", |
|||
} else { |
|||
[9] = "Fizz", |
|||
[10] = "Buzz", |
|||
} |
|||
[12] = "Fizz" |
|||
} |
|||
} |
|||
for i = 1, 100 do |
|||
print(t[i%15] or i) |
|||
end</syntaxhighlight> |
|||
=== Metatable insertion === |
|||
Sets any numeric key to its fizzbuzz value so that fizzbuzz[30] is "fizzbuzz" |
|||
<syntaxhighlight lang="lua">local mt = { |
|||
__newindex = (function (t, k, v) |
|||
if type(k) ~= "number" then rawset(t, k, v) |
|||
elseif 0 == (k % 15) then rawset(t, k, "fizzbuzz") |
|||
elseif 0 == (k % 5) then rawset(t, k, "fizz") |
|||
elseif 0 == (k % 3) then rawset(t, k, "buzz") |
|||
else rawset(t, k, k) end |
|||
return t[k] |
|||
end) |
|||
} |
|||
local fizzbuzz = {} |
|||
setmetatable(fizzbuzz, mt) |
|||
for i=1,100 do fizzbuzz[i] = i end |
|||
for i=1,100 do print(fizzbuzz[i]) end |
|||
</syntaxhighlight> |
|||
=== Fast Version without Modulo === |
|||
<syntaxhighlight lang="lua"> |
|||
#!/usr/bin/env luajit |
|||
local to=arg[1] or tonumber(arg[1]) or 100 |
|||
local CF,CB=3,5 |
|||
local cf,cb=CF,CB |
|||
for i=1,to do |
|||
cf,cb=cf-1,cb-1 |
|||
if cf~=0 and cb~=0 then |
|||
io.write(i) |
|||
else |
|||
if cf==0 then |
|||
cf=CF |
|||
io.write("Fizz") |
|||
end |
|||
if cb==0 then |
|||
cb=CB |
|||
io.write("Buzz") |
|||
end |
|||
end |
|||
io.write(", ") |
|||
end |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
> ./fizzbuzz.lua |
|||
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, % |
|||
</pre> |
|||
=={{header|Luck}}== |
|||
<syntaxhighlight lang="luck">for i in range(1,101) do ( |
|||
if i%15 == 0 then print("FizzBuzz") |
|||
else if i%3 == 0 then print("Fizz") |
|||
else if i%5 == 0 then print("Buzz") |
|||
else print(i) |
|||
)</syntaxhighlight> |
|||
=={{header|M2000 Interpreter}}== |
|||
<syntaxhighlight lang="m2000 interpreter"> |
|||
\\ one line, hard to read |
|||
For i=1 to 100 {If i mod 3=0 Then {if i mod 5=0 Then Print "FizzBuzz", Else Print "Fizz",} Else {if i mod 5=0 Then Print "Buzz", else print i, } } : Print |
|||
\\ Better code |
|||
For i=1 to 100 { |
|||
Push str$(i,0)+". "+if$(i mod 3=0->"Fizz","")+if$(i mod 5=0->"Buzz","") |
|||
If stackitem$()="" then Drop : Continue |
|||
Print Letter$ |
|||
} |
|||
\\ Far Better Code |
|||
For i=1 to 100 { |
|||
Printme(if$(i mod 3=0->"Fizz","")+if$(i mod 5=0->"Buzz","")) |
|||
} |
|||
Print |
|||
Sub Printme(a$) |
|||
If a$<>"" Then Print a$, else Print i, |
|||
End Sub |
|||
</syntaxhighlight> |
|||
=={{header|M4}}== |
|||
<syntaxhighlight 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)')') |
|||
')</syntaxhighlight> |
|||
=={{header|MACRO-11}}== |
|||
<syntaxhighlight lang="macro11"> .TITLE FIZBUZ |
|||
.MCALL .TTYOUT,.EXIT |
|||
FIZBUZ::MOV #1,R2 ; COUNTER |
|||
MOV #3,R3 ; FIZZ COUNTER |
|||
MOV #5,R4 ; BUZZ COUNTER |
|||
NUMBER: CLR R5 |
|||
CHKFIZ: DEC R3 |
|||
BNE CHKBUZ |
|||
MOV #FIZZ,R1 |
|||
JSR PC,PRSTR |
|||
MOV #3,R3 |
|||
INC R5 |
|||
CHKBUZ: DEC R4 |
|||
BNE CHKNUM |
|||
MOV #BUZZ,R1 |
|||
JSR PC,PRSTR |
|||
MOV #5,R4 |
|||
INC R5 |
|||
CHKNUM: TST R5 |
|||
BNE NEXNUM |
|||
MOV R2,R0 |
|||
JSR PC,PR0 |
|||
NEXNUM: MOV #NL,R1 |
|||
JSR PC,PRSTR |
|||
INC R2 |
|||
CMP R2,#^D100 |
|||
BLE NUMBER |
|||
.EXIT |
|||
; STRING DATA |
|||
FIZZ: .ASCIZ /FIZZ/ |
|||
BUZZ: .ASCIZ /BUZZ/ |
|||
NL: .BYTE 15,12,0 |
|||
.EVEN |
|||
; PRINT NUMBER IN R0 AS DECIMAL |
|||
PR0: MOV R2,-(SP) |
|||
MOV #4$,R1 |
|||
1$: MOV #-1,R2 |
|||
2$: INC R2 |
|||
SUB #12,R0 |
|||
BCC 2$ |
|||
ADD #72,R0 |
|||
MOVB R0,-(R1) |
|||
MOV R2,R0 |
|||
BNE 1$ |
|||
3$: MOVB (R1)+,R0 |
|||
.TTYOUT |
|||
BNE 3$ |
|||
MOV (SP)+,R2 |
|||
RTS PC |
|||
.ASCII /...../ |
|||
4$: .BYTE 0 |
|||
; PRINT STRING IN R1 |
|||
PRSTR: MOVB (R1)+,R0 |
|||
.TTYOUT |
|||
BNE PRSTR |
|||
RTS PC |
|||
.END FIZBUZ</syntaxhighlight> |
|||
=={{header|MAD}}== |
|||
<syntaxhighlight lang="mad"> NORMAL MODE IS INTEGER |
|||
VECTOR VALUES FIZZ = $4HFIZZ*$ |
|||
VECTOR VALUES BUZZ = $4HBUZZ*$ |
|||
VECTOR VALUES FIBU = $8HFIZZBUZZ*$ |
|||
VECTOR VALUES NUM = $I2*$ |
|||
INTERNAL FUNCTION REM.(A,B) = A-(A/B)*B |
|||
THROUGH LOOP, FOR I = 1, 1, I .G. 100 |
|||
WHENEVER REM.(I,15).E.0 |
|||
PRINT FORMAT FIBU |
|||
OR WHENEVER REM.(I,5).E.0 |
|||
PRINT FORMAT BUZZ |
|||
OR WHENEVER REM.(I,3).E.0 |
|||
PRINT FORMAT FIZZ |
|||
OTHERWISE |
|||
PRINT FORMAT NUM,I |
|||
LOOP END OF CONDITIONAL |
|||
END OF PROGRAM</syntaxhighlight> |
|||
=={{header|make}}== |
|||
{{works with|BSD make}} |
|||
{{libheader|jot}} |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
=={{header|Maple}}== |
|||
One line: |
|||
<syntaxhighlight lang="maple">seq(print(`if`(modp(n,3)=0,`if`(modp(n,15)=0,"FizzBuzz","Fizz"),`if`(modp(n,5)=0,"Buzz",n))),n=1..100):</syntaxhighlight> |
|||
With a fizzbuzz function defined: |
|||
<syntaxhighlight lang="maple">fizzbuzz1 := n->`if`(modp(n,3)=0,`if`(modp(n,15)=0,"FizzBuzz","Fizz"),`if`(modp(n,5)=0,"Buzz",n)): |
|||
for i to 100 do fizzbuzz1(i); od;</syntaxhighlight> |
|||
Using piecewise: |
|||
<syntaxhighlight lang="maple">fizzbuzz2 := n->piecewise(modp(n,15)=0,"FizzBuzz",modp(n,3)=0,"Fizz",modp(n,5)=0,"Buzz",n): |
|||
for i to 100 do fizzbuzz2(i); od;</syntaxhighlight> |
|||
Using conventional if/then branches: |
|||
<syntaxhighlight lang="maple">fizzbuzz3 := proc(n) local r; |
|||
r:=map2(modp,n,[3,5]); |
|||
if r=[0,0] then "FizzBuzz" |
|||
elif r[1]=0 then "Fizz" |
|||
elif r[2]=0 then "Buzz" |
|||
else n fi; |
|||
end proc: |
|||
for i to 100 do fizzbuzz3(i); od;</syntaxhighlight> |
|||
=={{header|Mathematica}} / {{header|Wolfram Language}}== |
|||
<syntaxhighlight lang="mathematica">Do[Print[Which[Mod[i, 15] == 0, "FizzBuzz", Mod[i, 5] == 0, "Buzz", Mod[i, 3] == 0, "Fizz", True, i]], {i, 100}]</syntaxhighlight> |
|||
Using rules, |
|||
<syntaxhighlight 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"}</syntaxhighlight> |
|||
Using rules, but different approach: |
|||
<syntaxhighlight 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]]</syntaxhighlight> |
|||
An extendible version using Table |
|||
<syntaxhighlight lang="mathematica">Table[If[# === "", i, #]&@StringJoin[ |
|||
Table[If[Divisible[i, First@nw], Last@nw, ""], |
|||
{nw, {{3, "Fizz"}, {5, "Buzz"}}}]], |
|||
{i, 1, 100}]</syntaxhighlight> |
|||
Another one-liner using Map (the /@ operator shorthand of it) and a pure function with a very readable Which |
|||
<syntaxhighlight lang="mathematica"> Which[ Mod[#,15] == 0, "FizzBuzz", Mod[#, 3] == 0, "Fizz", Mod[#,5]==0, "Buzz", True, #]& /@ Range[1,100] </syntaxhighlight> |
|||
Additional examples using DownValue pattern matching, the first without Mod'ing 15: |
|||
<syntaxhighlight lang="mathematica">f[n_] := f[n, Mod[n, {3, 5}]] |
|||
f[_, {0, 0}] := "FizzBuzz" |
|||
f[_, {0, _}] := "Fizz" |
|||
f[_, {_, 0}] := "Buzz" |
|||
f[n_, {_, _}] := n |
|||
f /@ Range[100]</syntaxhighlight> |
|||
<syntaxhighlight lang="mathematica">f[n_] := f[n, Mod[n, 15]] |
|||
f[_, 0] := "FizzBuzz" |
|||
f[n_, _] := f[n, Mod[n, {3, 5}]] |
|||
f[_, {0, _}] := "Fizz" |
|||
f[_, {_, 0}] := "Buzz" |
|||
f[n_, {_, _}] := n |
|||
f /@ Range[100]</syntaxhighlight> |
|||
=={{header|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). |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
Here's a more extendible version that uses disp() to print the output: |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
'''straightforward''' |
|||
<syntaxhighlight lang="matlab"> |
|||
x = string(1:100); |
|||
x(3:3:$) = 'Fizz'; |
|||
x(5:5:$) = 'Buzz'; |
|||
x(3*5:3*5:$) = 'FizzBuzz' |
|||
</syntaxhighlight> |
|||
=={{header|Maxima}}== |
|||
<syntaxhighlight lang="maxima">for n:1 thru 100 do |
|||
if mod(n, 15) = 0 then (sprint("FizzBuzz"), newline()) |
|||
elseif mod(n, 3) = 0 then (sprint("Fizz"), newline()) |
|||
elseif mod(n,5) = 0 then (sprint("Buzz"), newline()) |
|||
else (sprint(n), newline());</syntaxhighlight> |
|||
=={{header|MAXScript}}== |
=={{header|MAXScript}}== |
||
<syntaxhighlight 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) |
|||
) |
|||
)</syntaxhighlight> |
|||
) |
|||
=={{header|MEL}}== |
|||
<syntaxhighlight 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"); |
|||
}</syntaxhighlight> |
|||
=={{header|Mercury}}== |
|||
<syntaxhighlight 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. |
|||
fizz(N) = ( if N mod 3 = 0 then yes else no ). |
|||
:- func buzz(int) = bool. |
|||
buzz(N) = ( if N mod 5 = 0 then yes else no ). |
|||
% N 3? 5? |
|||
:- func fizzbuzz(int, bool, bool) = string. |
|||
fizzbuzz(_, yes, yes) = "FizzBuzz". |
|||
fizzbuzz(_, yes, no) = "Fizz". |
|||
fizzbuzz(_, no, yes) = "Buzz". |
|||
fizzbuzz(N, no, no) = 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(fizzbuzz(N, fizz(N), buzz(N)), !IO), |
|||
io.nl(!IO), |
|||
( if N < To then |
|||
main(N + 1, To, !IO) |
|||
else |
|||
true |
|||
).</syntaxhighlight> |
|||
=={{header|Metafont}}== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
=={{header|Microsoft Small Basic}}== |
|||
{{trans|GW-BASIC}} |
|||
<syntaxhighlight lang="microsoftsmallbasic"> |
|||
For n = 1 To 100 |
|||
op = "" |
|||
If Math.Remainder(n, 3) = 0 Then |
|||
op = "Fizz" |
|||
EndIf |
|||
IF Math.Remainder(n, 5) = 0 Then |
|||
op = text.Append(op, "Buzz") |
|||
EndIf |
|||
If op = "" Then |
|||
TextWindow.WriteLine(n) |
|||
Else |
|||
TextWindow.WriteLine(op) |
|||
EndIf |
|||
EndFor |
|||
</syntaxhighlight> |
|||
=={{header|min}}== |
|||
{{works with|min|0.19.3}} |
|||
<syntaxhighlight lang="min">0 ( |
|||
succ false :hit |
|||
(3 mod 0 ==) ("Fizz" print! true @hit) when |
|||
(5 mod 0 ==) ("Buzz" print! true @hit) when |
|||
(hit) (print) unless newline |
|||
) 100 times</syntaxhighlight> |
|||
=={{header|Minimal BASIC}}== |
|||
See [[FizzBuzz/Basic]] |
|||
=={{header|MiniScript}}== |
|||
<syntaxhighlight lang="miniscript">for i in range(1,100) |
|||
if i % 15 == 0 then |
|||
print "FizzBuzz" |
|||
else if i % 3 == 0 then |
|||
print "Fizz" |
|||
else if i % 5 == 0 then |
|||
print "Buzz" |
|||
else |
|||
print i |
|||
end if |
|||
end for</syntaxhighlight> |
|||
=={{header|MIPS Assembly}}== |
|||
<syntaxhighlight lang="mips"> |
|||
################################# |
|||
# Fizz Buzz # |
|||
# MIPS Assembly targetings MARS # |
|||
# By Keith Stellyes # |
|||
# August 24, 2016 # |
|||
################################# |
|||
# $a0 left alone for printing |
|||
# $a1 stores our counter |
|||
# $a2 is 1 if not evenly divisible |
|||
.data |
|||
fizz: .asciiz "Fizz\n" |
|||
buzz: .asciiz "Buzz\n" |
|||
fizzbuzz: .asciiz "FizzBuzz\n" |
|||
newline: .asciiz "\n" |
|||
.text |
|||
loop: |
|||
beq $a1,100,exit |
|||
add $a1,$a1,1 |
|||
#test for counter mod 15 ("FIZZBUZZ") |
|||
div $a2,$a1,15 |
|||
mfhi $a2 |
|||
bnez $a2,loop_not_fb #jump past the fizzbuzz print logic if NOT MOD 15 |
|||
#### PRINT FIZZBUZZ: #### |
|||
li $v0,4 #set syscall arg to PRINT_STRING |
|||
la $a0,fizzbuzz #set the PRINT_STRING arg to fizzbuzz |
|||
syscall #call PRINT_STRING |
|||
j loop #return to start |
|||
#### END PRINT FIZZBUZZ #### |
|||
loop_not_fb: |
|||
div $a2,$a1,3 #divide $a1 (our counter) by 3 and store remainder in HI |
|||
mfhi $a2 #retrieve remainder (result of MOD) |
|||
bnez $a2, loop_not_f #jump past the fizz print logic if NOT MOD 3 |
|||
#### PRINT FIZZ #### |
|||
li $v0,4 |
|||
la $a0,fizz |
|||
syscall |
|||
j loop |
|||
#### END PRINT FIZZ #### |
|||
loop_not_f: |
|||
div $a2,$a1,5 |
|||
mfhi $a2 |
|||
bnez $a2,loop_not_b |
|||
#### PRINT BUZZ #### |
|||
li $v0,4 |
|||
la $a0,buzz |
|||
syscall |
|||
j loop |
|||
#### END PRINT BUZZ #### |
|||
loop_not_b: |
|||
#### PRINT THE INTEGER #### |
|||
li $v0,1 #set syscall arg to PRINT_INTEGER |
|||
move $a0,$a1 #set PRINT_INTEGER arg to contents of $a1 |
|||
syscall #call PRINT_INTEGER |
|||
### PRINT THE NEWLINE CHAR ### |
|||
li $v0,4 #set syscall arg to PRINT_STRING |
|||
la $a0,newline |
|||
syscall |
|||
j loop #return to beginning |
|||
exit: |
|||
li $v0,10 |
|||
syscall |
|||
</syntaxhighlight> |
|||
=={{header|Mirah}}== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
A little more straight forward: |
|||
<syntaxhighlight lang="mirah">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</syntaxhighlight> |
|||
=={{header|Miranda}}== |
|||
<syntaxhighlight lang="miranda">main :: [sys_message] |
|||
main = [Stdout (lay (map fizzbuzz [1..100]))] |
|||
fizzbuzz :: num->[char] |
|||
fizzbuzz n = "FizzBuzz", if n mod 15 = 0 |
|||
= "Fizz", if n mod 3 = 0 |
|||
= "Buzz", if n mod 5 = 0 |
|||
= show n, otherwise</syntaxhighlight> |
|||
=={{header|ML}}== |
|||
==={{header|Standard ML}}=== |
|||
First using two helper functions, one for deciding what to output and another for performing recursion with an auxiliary argument j. |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
Second using the standard-library combinator List.tabulate and a helper function, fb, that calculates and prints the output. |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
==={{header|mLite}}=== |
|||
<syntaxhighlight lang="ocaml">local |
|||
fun fizzbuzz' |
|||
(x mod 15 = 0) = "FizzBuzz" |
|||
| (x mod 5 = 0) = "Buzz" |
|||
| (x mod 3 = 0) = "Fizz" |
|||
| x = ntos x |
|||
in |
|||
fun fizzbuzz |
|||
([], s) = rev s |
|||
| (x :: xs, s) = fizzbuzz (xs, fizzbuzz' x :: s) |
|||
| (x :: xs) = fizzbuzz (x :: xs, []) |
|||
end |
|||
; |
|||
println ` fizzbuzz ` iota 100; |
|||
</syntaxhighlight> |
|||
=={{header|MMIX}}== |
|||
<syntaxhighlight 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)</syntaxhighlight> |
|||
=={{header|Modula-2}}== |
|||
<syntaxhighlight lang="modula2">MODULE Fizzbuzz; |
|||
FROM FormatString IMPORT FormatString; |
|||
FROM Terminal IMPORT WriteString,WriteLn,ReadChar; |
|||
TYPE CB = PROCEDURE(INTEGER); |
|||
PROCEDURE Fizz(n : INTEGER); |
|||
BEGIN |
|||
IF n MOD 3 = 0 THEN |
|||
WriteString("Fizz"); |
|||
Buzz(n,Newline) |
|||
ELSE |
|||
Buzz(n,WriteInt) |
|||
END |
|||
END Fizz; |
|||
PROCEDURE Buzz(n : INTEGER; f : CB); |
|||
BEGIN |
|||
IF n MOD 5 = 0 THEN |
|||
WriteString("Buzz"); |
|||
WriteLn |
|||
ELSE |
|||
f(n) |
|||
END |
|||
END Buzz; |
|||
PROCEDURE WriteInt(n : INTEGER); |
|||
VAR buf : ARRAY[0..9] OF CHAR; |
|||
BEGIN |
|||
FormatString("%i\n", buf, n); |
|||
WriteString(buf) |
|||
END WriteInt; |
|||
PROCEDURE Newline(n : INTEGER); |
|||
BEGIN |
|||
WriteLn |
|||
END Newline; |
|||
VAR i : INTEGER; |
|||
BEGIN |
|||
FOR i:=1 TO 30 DO |
|||
Fizz(i) |
|||
END; |
|||
ReadChar |
|||
END Fizzbuzz.</syntaxhighlight> |
|||
=={{header|Modula-3}}== |
|||
<syntaxhighlight 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.</syntaxhighlight> |
|||
=={{header|Monte}}== |
|||
<syntaxhighlight lang="monte">def fizzBuzz(top): |
|||
var t := 1 |
|||
while (t < top): |
|||
if ((t % 3 == 0) || (t % 5 == 0)): |
|||
if (t % 15 == 0): |
|||
traceln(`$t FizzBuzz`) |
|||
else if (t % 3 == 0): |
|||
traceln(`$t Fizz`) |
|||
else: |
|||
traceln(`$t Buzz`) |
|||
t += 1 |
|||
fizzBuzz(100) |
|||
</syntaxhighlight> |
|||
=={{header|MontiLang}}== |
|||
<syntaxhighlight lang="montilang">&DEFINE LOOP 100& |
|||
1 VAR i . |
|||
FOR LOOP |
|||
|| VAR ln . |
|||
i 5 % 0 == |
|||
IF : . |
|||
ln |Buzz| + VAR ln . |
|||
ENDIF |
|||
i 3 % 0 == |
|||
IF : . |
|||
ln |Fizz| + VAR ln . |
|||
ENDIF |
|||
ln || == |
|||
IF : . |
|||
i PRINT . |
|||
ENDIF |
|||
ln || != |
|||
IF : . |
|||
ln PRINT . |
|||
ENDIF |
|||
i 1 + VAR i . |
|||
ENDFOR</syntaxhighlight> |
|||
=={{header|MoonScript}}== |
|||
<syntaxhighlight lang="moonscript">for i = 1,100 |
|||
print ((a) -> a == "" and i or a) table.concat { |
|||
i % 3 == 0 and "Fizz" or "" |
|||
i % 5 == 0 and "Buzz" or ""}</syntaxhighlight> |
|||
=={{header|MUMPS}}== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
<syntaxhighlight lang="mumps">fizzbuzz |
|||
for i=1:1:100 do write ! |
|||
. write:(i#3)&(i#5) i write:'(i#3) "Fizz" write:'(i#5) "Buzz"</syntaxhighlight> |
|||
=={{header|Nanoquery}}== |
|||
<syntaxhighlight lang="nanoquery">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 |
|||
println i |
|||
end |
|||
end</syntaxhighlight> |
|||
=={{header|NATURAL}}== |
|||
<syntaxhighlight lang="natural"> |
|||
DEFINE DATA |
|||
LOCAL |
|||
1 #I (I4) |
|||
1 #MODULO (I4) |
|||
1 #DIVISOR (I4) |
|||
1 #OUT (A10) |
|||
END-DEFINE |
|||
* |
|||
FOR #I := 1 TO 100 |
|||
#DIVISOR := 15 |
|||
#OUT := 'FizzBuzz' |
|||
PERFORM MODULO |
|||
* |
|||
#DIVISOR := 5 |
|||
#OUT := 'Buzz' |
|||
PERFORM MODULO |
|||
* |
|||
#DIVISOR := 3 |
|||
#OUT := 'Fizz' |
|||
PERFORM MODULO |
|||
* |
|||
WRITE #I |
|||
END-FOR |
|||
* |
|||
DEFINE SUBROUTINE MODULO |
|||
#MODULO := #I - (#I / #DIVISOR) * #DIVISOR |
|||
IF #MODULO = 0 |
|||
WRITE NOTITLE #OUT |
|||
ESCAPE TOP |
|||
END-IF |
|||
END-SUBROUTINE |
|||
* |
|||
END |
|||
</syntaxhighlight> |
|||
=={{header|Neko}}== |
|||
<syntaxhighlight lang="neko">var i = 1 |
|||
while(i < 100) { |
|||
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"); |
|||
} |
|||
i ++= 1 |
|||
}</syntaxhighlight> |
|||
=={{header|Nemerle}}== |
|||
The naive approach: |
|||
<syntaxhighlight 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))") |
|||
} |
|||
}</syntaxhighlight> |
|||
A much slicker approach is [http://www.dreamincode.net/forums/blog/217/entry-3539-fizzbuzz-in-nemerle/ posted here] |
|||
=={{header|NetRexx}}== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
=={{header|Never}}== |
|||
<syntaxhighlight lang="fsharp">func fizz_buzz() -> int |
|||
{ |
|||
var i = 1; |
|||
for (i = 1; i <= 100; i = i + 1) |
|||
{ |
|||
/* if (i % 15 == 0) */ |
|||
if (i % 3 == 0 && i % 5 == 0) |
|||
{ |
|||
prints("Fizz Buzz\n") |
|||
} |
|||
else if (i % 3 == 0) |
|||
{ |
|||
prints("Fizz\n") |
|||
} |
|||
else if (i % 5 == 0) |
|||
{ |
|||
prints("Buzz\n") |
|||
} |
|||
else |
|||
{ |
|||
prints(i + "\n") |
|||
} |
|||
}; |
|||
0 |
|||
} |
|||
func main() -> int { |
|||
fizz_buzz(); |
|||
0 |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre>prompt$ never -f fizzbuzz.nev 2>/dev/null |
|||
1 |
|||
2 |
|||
Fizz |
|||
4 |
|||
Buzz |
|||
Fizz |
|||
7 |
|||
8 |
|||
Fizz |
|||
Buzz |
|||
11 |
|||
Fizz |
|||
13 |
|||
14 |
|||
Fizz Buzz |
|||
16 |
|||
... |
|||
89 |
|||
Fizz Buzz |
|||
91 |
|||
92 |
|||
Fizz |
|||
94 |
|||
Buzz |
|||
Fizz |
|||
97 |
|||
98 |
|||
Fizz |
|||
Buzz</pre> |
|||
=={{header|NewLISP}}== |
|||
<syntaxhighlight lang="newlisp">(dotimes (i 100) |
|||
(println |
|||
(cond |
|||
((= 0 (% i 15)) "FizzBuzz") |
|||
((= 0 (% i 3)) "Fizz") |
|||
((= 0 (% i 5)) "Buzz") |
|||
('t i))))</syntaxhighlight> |
|||
Solution 2. |
|||
Many of the solutions have a command to print "fizzbuzz". Since the programs can print "fizz" and "buzz", why not print "fizz" followed immediately by "buzz"? This also removes the need to check for divisibility by 15. |
|||
It would be nice to have a very easy way to know whether a word was actually printed (because we otherwise have to print the number). I mean a way that doesn't involve checking for divisibility again or setting a flag. |
|||
We want a macro or function that is somewhat like "or" but that evaluates all of the expressions even if the first yields true. Like "or", it returns a true value (a number) if any of the expressions yielded true. In newLISP, it seems that a function suffices, but in some languages a macro may be necessary because the arguments to a function are not always evaluated from left to right. |
|||
I believe that this method makes it easier to modify the program when the list of words to be printed is extended. |
|||
<syntaxhighlight lang="newlisp"> |
|||
(define (try-all) ;; The arguments are in (args) or $args. |
|||
(let (cnt (length (filter true? $args))) |
|||
(if (zero? cnt) nil cnt))) |
|||
(define (fizz) |
|||
(define (say? n s) (if (= 0 (% i n)) (print s))) ;; Dynamic scoping. |
|||
(for (i 1 21) |
|||
(unless |
|||
(try-all |
|||
(say? 3 'fizz) |
|||
(say? 5 'buzz) |
|||
(say? 7 'boom) |
|||
(say? 11 'crux)) |
|||
(print i)) |
|||
(println))) |
|||
(fizz) |
|||
1 |
|||
2 |
|||
fizz |
|||
4 |
|||
buzz |
|||
fizz |
|||
boom |
|||
8 |
|||
fizz |
|||
buzz |
|||
crux |
|||
fizz |
|||
13 |
|||
boom |
|||
fizzbuzz |
|||
16 |
|||
17 |
|||
fizz |
|||
19 |
|||
buzz |
|||
fizzboom |
|||
</syntaxhighlight> |
|||
Solution 3. |
|||
Instead of explicitly including the numbers 3, 5, 7, etc., let's tell the computer to use the prime numbers starting with 3. |
|||
<syntaxhighlight lang="newlisp"> |
|||
(define (m-prime-gen) |
|||
(fn ( , n) ;; Unused parameter n is our local variable. |
|||
;; Self-modifying code. |
|||
(until (= 1 (length (factor (setf n (++ 2)))))) |
|||
n)) |
|||
(define (try-all) ;; The arguments are in (args) or $args. |
|||
(let (cnt (length (filter true? $args))) |
|||
(if (zero? cnt) nil cnt))) |
|||
(define (fizz) |
|||
(define (say? n s) (if (= 0 (% i n)) (print s))) ;; Dynamic scoping. |
|||
(for (i 1 21) |
|||
(let (p (m-prime-gen)) |
|||
(unless |
|||
(try-all |
|||
(say? (p) 'fizz) |
|||
(say? (p) 'buzz) |
|||
(say? (p) 'boom) |
|||
(say? (p) 'crux) |
|||
(say? (p) 'ZAP)) |
|||
(print i)) |
|||
(println)))) |
|||
(fizz) |
|||
1 |
|||
2 |
|||
fizz |
|||
4 |
|||
buzz |
|||
fizz |
|||
boom |
|||
8 |
|||
fizz |
|||
buzz |
|||
crux |
|||
fizz |
|||
ZAP |
|||
boom |
|||
fizzbuzz |
|||
16 |
|||
17 |
|||
fizz |
|||
19 |
|||
buzz |
|||
fizzboom |
|||
</syntaxhighlight> |
|||
=={{header|NewtonScript}}== |
|||
<syntaxhighlight lang="newton">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</syntaxhighlight> |
|||
=={{header|Nickle}}== |
|||
<syntaxhighlight 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);</syntaxhighlight> |
|||
=={{header|Nim}}== |
|||
{{trans|Python}} |
|||
<syntaxhighlight lang="nim">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)</syntaxhighlight> |
|||
===Without Modulus=== |
|||
<syntaxhighlight lang="nim">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</syntaxhighlight> |
|||
===Using macro=== |
|||
Computes everything at compile time. |
|||
<syntaxhighlight lang="nim">import macros |
|||
macro FizzBuzz(N): untyped = |
|||
var source = "" |
|||
for i in 1..N.intVal: |
|||
source &= "echo \"" |
|||
if i mod 15 == 0: |
|||
source &= "FizzBuzz" |
|||
elif i mod 3 == 0: |
|||
source &= "Fizz" |
|||
elif i mod 5 == 0: |
|||
source &= "Buzz" |
|||
else: |
|||
source &= $i |
|||
source &= "\"\n" |
|||
result = parseStmt(source) |
|||
FizzBuzz(100)</syntaxhighlight> |
|||
=={{header|Nix}}== |
|||
<syntaxhighlight lang="nix">with (import <nixpkgs> { }).lib; |
|||
with builtins; |
|||
let |
|||
fizzbuzz = { x ? 1 }: |
|||
'' |
|||
${if (mod x 15 == 0) then |
|||
"FizzBuzz" |
|||
else if (mod x 3 == 0) then |
|||
"Fizz" |
|||
else if (mod x 5 == 0) then |
|||
"Buzz" |
|||
else |
|||
(toString x)} |
|||
'' + (if (x < 100) then |
|||
fizzbuzz { x = x + 1; } else ""); |
|||
in |
|||
fizzbuzz { }</syntaxhighlight> |
|||
=={{header|Nu}}== |
|||
<syntaxhighlight lang="nu"> |
|||
(1..100 |
|||
| each {|i| $"(if $i mod 3 == 0 {"Fizz"})(if $i mod 5 == 0 {"Buzz"})" |
|||
| if ($in == "") {$i} else {$in}} |
|||
| str join "\n") |
|||
</syntaxhighlight> |
|||
=={{header|Oberon-2}}== |
=={{header|Oberon-2}}== |
||
<syntaxhighlight lang="oberon2">MODULE FizzBuzz; |
|||
<pre> |
|||
MODULE FizzBuzz; |
|||
IMPORT Out; |
IMPORT Out; |
||
Line 439: | Line 7,805: | ||
FOR i := 1 TO 100 DO |
FOR i := 1 TO 100 DO |
||
IF i MOD 15 = 0 THEN |
IF i MOD 15 = 0 THEN |
||
Out.String("FizzBuzz") |
Out.String("FizzBuzz") |
||
Out.Ln; |
|||
ELSIF i MOD 5 = 0 THEN |
ELSIF i MOD 5 = 0 THEN |
||
Out.String("Buzz") |
Out.String("Buzz") |
||
Out.Ln; |
|||
ELSIF i MOD 3 = 0 THEN |
ELSIF i MOD 3 = 0 THEN |
||
Out.String("Fizz") |
Out.String("Fizz") |
||
Out.Ln; |
|||
ELSE |
ELSE |
||
Out.Int(i,0) |
Out.Int(i,0) |
||
Out.Ln; |
|||
END; |
END; |
||
Out.Ln |
|||
END |
|||
END FizzBuzz. |
|||
END FizzBuzz.</syntaxhighlight> |
|||
</pre> |
|||
=={{header|Objeck}}== |
|||
<syntaxhighlight 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(); |
|||
}; |
|||
}; |
|||
} |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|Objective-C}}== |
|||
<syntaxhighlight lang="c">// FizzBuzz in Objective-C |
|||
#import <Foundation/Foundation.h> |
|||
int main(int argc, char* argv[]) { |
|||
for (NSInteger i=1; I <= 101; i++) { |
|||
if (i % 15 == 0) { |
|||
NSLog(@"FizzBuzz\n"); |
|||
} else if (i % 3 == 0) { |
|||
NSLog(@"Fizz\n"); |
|||
} else if (i % 5 == 0) { |
|||
NSLog(@"Buzz\n"); |
|||
} else { |
|||
NSLog(@"%li\n", i); |
|||
} |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|OCaml}}== |
=={{header|OCaml}}== |
||
Idiomatic OCaml to solve the stated problem: |
|||
<ocaml>let output x = |
|||
match x mod 3 = 0, x mod 5 = 0 with |
|||
<syntaxhighlight lang="ocaml">let fizzbuzz i = |
|||
true, true -> "FizzBuzz" |
|||
match i mod 3, i mod 5 with |
|||
0, 0 -> "FizzBuzz" |
|||
| |
| 0, _ -> "Fizz" |
||
| _, 0 -> "Buzz" |
|||
| _ -> string_of_int i |
|||
let _ = |
let _ = |
||
for i = 1 to 100 do print_endline ( |
for i = 1 to 100 do print_endline (fizzbuzz i) done</syntaxhighlight> |
||
With a view toward extensibility, there are many approaches: monadic, list of rules, ... here we'll use a piped sequence of rules to define a new "fizzbuzz" function: |
|||
<syntaxhighlight lang="ocaml">(* Useful rule declaration: "cond => f", 'cond'itionally applies 'f' to 'a'ccumulated value *) |
|||
let (=>) cond f a = if cond then f a else a |
|||
let append s a = a^s |
|||
let fizzbuzz i = |
|||
"" |> (i mod 3 = 0 => append "Fizz") |
|||
|> (i mod 5 = 0 => append "Buzz") |
|||
|> (function "" -> string_of_int i |
|||
| s -> s)</syntaxhighlight> |
|||
=={{header|Octave}}== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
=={{header|Oforth}}== |
|||
<syntaxhighlight lang="oforth">: fizzbuzz |
|||
| i | |
|||
100 loop: i [ |
|||
null |
|||
i 3 mod ifZero: [ "Fizz" + ] |
|||
i 5 mod ifZero: [ "Buzz" + ] |
|||
dup ifNull: [ drop i ] . |
|||
] ; </syntaxhighlight> |
|||
=={{header|Ol}}== |
|||
<syntaxhighlight lang="scheme"> |
|||
(for-each (lambda (x) |
|||
(print (cond |
|||
((and (zero? (mod x 3)) (zero? (mod x 5))) |
|||
"FizzBuzz") |
|||
((zero? (mod x 3)) |
|||
"Fizz") |
|||
((zero? (mod x 5)) |
|||
"Buzz") |
|||
(else |
|||
x)))) |
|||
(iota 100)) |
|||
</syntaxhighlight> |
|||
=={{header|Onyx (wasm)}}== |
|||
<syntaxhighlight lang="C"> |
|||
use core { * } |
|||
fizzbuzz :: (len: u32) -> void { |
|||
for i in 1..len+1 { |
|||
msg : str; |
|||
if (i%3 == 0 && i%5 == 0) { msg = "FizzBuzz !!!"; } |
|||
elseif (i%3 == 0) { msg = "Fizz"; } |
|||
elseif (i%5 == 0) { msg = "Buzz"; } |
|||
else { msg = tprintf("{}", i); } |
|||
printf("{}\n", msg); |
|||
} |
|||
} |
|||
main :: () { |
|||
fizzbuzz(100); |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|OOC}}== |
|||
<syntaxhighlight 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() |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|Order}}== |
|||
<syntaxhighlight 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)) |
|||
)</syntaxhighlight> |
|||
=={{header|Oz}}== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
=={{header|Palo Alto Tiny BASIC}}== |
|||
See [[FizzBuzz/Basic#Palo Alto Tiny BASIC|FizzBuzz/Basic]]. |
|||
=={{header|PARI/GP}}== |
|||
<syntaxhighlight lang="parigp">{for(n=1,100, |
|||
print(if(n%3, |
|||
if(n%5, |
|||
n |
|||
, |
|||
"Buzz" |
|||
) |
|||
, |
|||
if(n%5, |
|||
"Fizz" |
|||
, |
|||
"FizzBuzz" |
|||
) |
|||
)) |
|||
)}</syntaxhighlight> |
|||
=={{header|Pascal}}== |
|||
<syntaxhighlight 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.</syntaxhighlight> |
|||
=={{header|PascalABC.NET}}== |
|||
<syntaxhighlight lang="delphi"> |
|||
begin |
|||
for var i:=1 to 100 do |
|||
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) |
|||
end. |
|||
</syntaxhighlight> |
|||
=={{header|PDP-8 Assembly}}== |
|||
{{works with| PAL-D}} |
|||
Runs on SimH, or any PDP-8 with an EAE |
|||
<syntaxhighlight lang="assembly"> |
|||
/-------------------------------------------------------- |
|||
/THIS PROGRAM PRINTS THE INTEGERS FROM 1 TO 100 (INCL). |
|||
/WITH THE FOLLOWING RESTRICTIONS: |
|||
/ FOR MULTIPLES OF THREE, PRINT 'FIZZ' |
|||
/ FOR MULTIPLES OF FIVE, PRINT 'BUZZ' |
|||
/ FOR MULTIPLES OF BOTH THREE AND FIVE, PRINT 'FIZZBUZZ' |
|||
/-------------------------------------------------------- |
|||
/-------------------------------------------------------- |
|||
/DEFINES |
|||
/-------------------------------------------------------- |
|||
SWBA=7447 /EAE MODE A INSTRUCTION |
|||
DVI=7407 /EAE DIVIDE INSTRUCTION |
|||
AIX0=0010 /AUTO INDEX REGISTER 0 |
|||
CR=0215 /CARRIAGE RETURN |
|||
LF=0212 /LINEFEED |
|||
EOT=0000 /END OF TEXT NUL |
|||
FIZMOD=0003 /CONSTANT DECIMAL 3 (FIZZ) |
|||
BUZMOD=0005 /CONSTANT DECIMAL 5 (BUZZ) |
|||
K10=0012 /CONSTANT DECIMAL 10 |
|||
LAST=0144 /FIZZBUZZ THE NUMBERS 1..LAST |
|||
/0144 OCTAL == 100 DECIMAL |
|||
/CAN BE ANY FROM [0001...7777] |
|||
/-------------------------------------------------------- |
|||
/FIZZBUZZ START=0200 |
|||
/-------------------------------------------------------- |
|||
*200 /START IN MEMORY AT 0200 OCTAL |
|||
FZZBZZ, CLA /CLEAR AC |
|||
TAD (-LAST-1 /LOAD CONSTANT -(LAST+1) |
|||
DCA CNTR /SET UP MAIN COUNTER |
|||
TAD (-FIZMOD /SET UP FIZZ COUNTER |
|||
DCA FIZCTR /TO -3 |
|||
TAD (-BUZMOD /SET UP BUZZ COUNTER |
|||
DCA BUZCTR /TO -5 |
|||
LOOP, ISZ CNTR /READY? |
|||
SKP /NO: CONTINUE |
|||
JMP I [7600 /YES: RETURN TO OS/8, REPLACE BY |
|||
/'HLT' IF NOT ON OS/8 |
|||
CHKFIZ, ISZ FIZCTR /MULTIPLE OF 3? |
|||
JMP CHKBUZ /NO: CONTINUE |
|||
TAD FIZSTR /YES: LOAD ADDRESS OF 'FIZZ' |
|||
JMS STROUT /PRINT IT TO TTY |
|||
TAD (-FIZMOD /RELOAD THE |
|||
DCA FIZCTR /MOD 3 COUNTER |
|||
CHKBUZ, ISZ BUZCTR /MULTIPLE OF 5? |
|||
JMP CHKNUM /NO: CONTINUE |
|||
TAD BUZSTR /YES: LOAD ADDRESS OF 'BUZZ' |
|||
JMS STROUT /PRINT IT TO TTY |
|||
TAD (-BUZMOD /RELOAD THE |
|||
DCA BUZCTR /MOD 5 COUNTER |
|||
JMP NXTLIN /PRINT NEWLINE AND CONTINUE |
|||
CHKNUM, TAD FIZCTR /CHECK WHETHER MOD 3 COUNTER |
|||
TAD (FIZMOD /IS RELOADED |
|||
SNA /DID WE JUST PRINT 'FIZZ'? |
|||
JMP NXTLIN /YES: PRINT NEWLINE AND CONTINUE |
|||
CLA /ZERO THE AC |
|||
NUM, TAD CNTR /LOAD THE MAIN NUMBER COUNTER |
|||
TAD (LAST+1 /OFFSET IT TO A POSITIVE VALUE |
|||
JMS NUMOUT /PRINT IT TO THE TTY |
|||
NXTLIN, TAD LINSTR /LOAD THE ADDRESS OF THE NEWLINE |
|||
JMS STROUT /PRINT IT TO TTY |
|||
JMP LOOP /CONTINUE WITH THE NEXT NUMBER |
|||
CNTR, 0 /MAIN COUNTER |
|||
FIZCTR, 0 /FIZZ COUNTER |
|||
BUZCTR, 0 /BUZZ COUNTER |
|||
/-------------------------------------------------------- |
|||
/WRITE ASCII CHARACTER IN AC TO TTY |
|||
/PRE : AC=ASCII CHARACTER |
|||
/POST: AC=0 |
|||
/-------------------------------------------------------- |
|||
CHROUT, .-. |
|||
TLS /SEND CHARACTER TO TTY |
|||
TSF /IS TTY READY FOR NEXT CHARACTER? |
|||
JMP .-1 /NO TRY AGAIN |
|||
CLA /AC=0 |
|||
JMP I CHROUT /RETURN |
|||
/-------------------------------------------------------- |
|||
/WRITE NUL TERMINATED ASCII STRING TO TTY |
|||
/PRE : AC=ADDRESS OF STRING MINUS 1 |
|||
/POST: AC=0 |
|||
/-------------------------------------------------------- |
|||
STROUT, .-. |
|||
DCA AIX0 /STORE POINTER IN AUTO INDEX 0 |
|||
STRLOP, TAD I AIX0 /GET NEXT CHARACTER FROM STRING |
|||
SNA /SKIP IF NOT EOT |
|||
JMP I STROUT /RETURN |
|||
JMS CHROUT /PRINT CHARACTER |
|||
JMP STRLOP /GO GET NEXT CHARACTER |
|||
/-------------------------------------------------------- |
|||
/WRITE NUMBER IN AC TO TTY AS DECIMAL |
|||
/PRE : AC=UNSIGNED NUMBER BETWEEN 0000 AND 7777 |
|||
/POST: AC=0 |
|||
/-------------------------------------------------------- |
|||
NUMOUT, .-. |
|||
SWBA /SET EAE IN MODE A |
|||
MQL /MQ=NUM; AC=0 |
|||
TAD BUFFER /LOAD END OF BUFFER |
|||
DCA BUFPTR /IN BUFPTR |
|||
SKP /NUM IS ALREADY IN MQ |
|||
NUMLOP, MQL /MQ=NUM; AC=0 |
|||
DVI /MQ=NUM/10; AC=NUM-(NUM/10)*10 |
|||
K10 /DECIMAL 10 |
|||
TAD ("0 /ADD ASCII ZERO |
|||
DCA I BUFPTR /STORE CHAR BUFFER, BACK TO FRONT |
|||
CMA /AC=-1 |
|||
TAD BUFPTR /DECREMENT |
|||
DCA BUFPTR /BUFFER POINTER |
|||
MQA /MQ -> AC |
|||
SZA /READY IF ZERO |
|||
JMP NUMLOP /GET NEXT DIGIT |
|||
TAD BUFPTR /LOAD START OF CONVERTED NUMBER |
|||
JMS STROUT /SEND IT TO TTY |
|||
JMP I NUMOUT /RETURN |
|||
BUFFER, .+4 /ADDRESS OF BUFFER |
|||
*.+4 /RESERVE 4 LOCATIONS (MAX=4095) |
|||
EOT /END OF BUFFER |
|||
BUFPTR, 0 /POINTER IN BUFFER |
|||
/-------------------------------------------------------- |
|||
/STRINGS |
|||
/-------------------------------------------------------- |
|||
FIZSTR, . /FIZZ STRING |
|||
"F; "I; "Z; "Z; EOT |
|||
BUZSTR, . /BUZZ STRING |
|||
"B; "U; "Z; "Z; EOT |
|||
LINSTR, . /NEWLINE STIRNG |
|||
CR; LF; EOT |
|||
$ |
|||
</syntaxhighlight> |
|||
Output: |
|||
<pre> |
|||
. |
|||
.PAL FIZBUZ.PA |
|||
ERRORS DETECTED: 0 |
|||
LINKS GENERATED: 0 |
|||
.LOAD FIZBUZ.BN |
|||
.START |
|||
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 |
|||
. |
|||
</pre> |
|||
=={{header|Peloton}}== |
|||
Variable-length padded English dialect |
|||
<syntaxhighlight lang="sgml"><# 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|...</#> </#></syntaxhighlight> |
|||
Fixed-length English dialect |
|||
<syntaxhighlight lang="sgml"><@ 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|...</@> </@></syntaxhighlight> |
|||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
<syntaxhighlight lang="perl"> |
|||
<perl>foreach (1 .. 100) { |
|||
use strict; |
|||
if (0 == $_ % 15) { |
|||
use warnings; |
|||
print "FizzBuzz\n"; |
|||
use feature qw(say); |
|||
} elsif (0 == $_ % 3) { |
|||
print "Fizz\n"; |
|||
for my $i (1..100) { |
|||
say $i % 15 == 0 ? "FizzBuzz" |
|||
: $i % 3 == 0 ? "Fizz" |
|||
} else { |
|||
: $i % 5 == 0 ? "Buzz" |
|||
: $i; |
|||
}</syntaxhighlight> |
|||
};</perl> |
|||
More concisely: |
More concisely: |
||
<syntaxhighlight lang="perl">print 'Fizz'x!($_ % 3) . 'Buzz'x!($_ % 5) || $_, "\n" for 1 .. 100;</syntaxhighlight> |
|||
<perl>sub f { $_[0] % $_[1] ? '' : $_[2] } |
|||
print f($_, 3, 'Fizz') . f($_, 5, 'Buzz') || $_, "\n" |
|||
For code-golfing: |
|||
foreach 1 .. 100;</perl> |
|||
<syntaxhighlight lang="perl">print+(Fizz)[$_%3].(Buzz)[$_%5]||$_,$/for 1..1e2</syntaxhighlight> |
|||
For array of values: |
|||
<syntaxhighlight lang="perl">map((Fizz)[$_%3].(Buzz)[$_%5]||$_,1..100);</syntaxhighlight> |
|||
Cheating: |
|||
<syntaxhighlight lang="perl"> |
|||
use feature "say"; |
|||
@a = ("FizzBuzz", 0, 0, "Fizz", 0, "Buzz", "Fizz", 0, 0, "Fizz", "Buzz", 0, "Fizz"); |
|||
say $a[$_ % 15] || $_ for 1..100;</syntaxhighlight> |
|||
as a subroutine: |
|||
<syntaxhighlight lang="perl"> |
|||
sub fizz_buzz { |
|||
join("\n", map { |
|||
sub mult {$_ % shift == 0}; |
|||
my @out; |
|||
if (mult 3) { push @out, "Fizz"; } |
|||
if (mult 5) { push @out, "Buzz"; } |
|||
if (!@out) {push @out, $_; } |
|||
join('', @out); |
|||
} (1..100))."\n"; |
|||
} |
|||
print fizz_buzz; |
|||
</syntaxhighlight> |
|||
By transforming a list: |
|||
<syntaxhighlight lang="perl"> |
|||
@FB1 = (1..100); |
|||
@FB2 = map{!($_%3 or $_%5)?'FizzBuzz': $_}@FB1; |
|||
@FB3 = map{(/\d/ and !($_%3))?'Fizz': $_}@FB2; |
|||
@FB4 = map{(/\d/ and !($_%5))?'Buzz': $_}@FB3; |
|||
@FB5 = map{$_."\n"}@FB4; |
|||
print @FB5; |
|||
</syntaxhighlight> |
|||
=={{header|Phix}}== |
|||
{{libheader|Phix/basics}} |
|||
{{trans|C}} |
|||
<!--<syntaxhighlight lang="phix">--> |
|||
<span style="color: #008080;">constant</span> <span style="color: #000000;">x</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{<span style="color: #008000;">"%d\n"<span style="color: #0000FF;">,<span style="color: #008000;">"Fizz\n"<span style="color: #0000FF;">,<span style="color: #008000;">"Buzz\n"<span style="color: #0000FF;">,<span style="color: #008000;">"FizzBuzz\n"<span style="color: #0000FF;">}</span> |
|||
<span style="color: #008080;">for</span> <span style="color: #000000;">i<span style="color: #0000FF;">=<span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">100</span> <span style="color: #008080;">do</span> |
|||
<span style="color: #7060A8;">printf<span style="color: #0000FF;">(<span style="color: #000000;">1<span style="color: #0000FF;">,<span style="color: #000000;">x<span style="color: #0000FF;">[<span style="color: #000000;">1<span style="color: #0000FF;">+<span style="color: #0000FF;">(<span style="color: #7060A8;">remainder<span style="color: #0000FF;">(<span style="color: #000000;">i<span style="color: #0000FF;">,<span style="color: #000000;">3<span style="color: #0000FF;">)<span style="color: #0000FF;">=<span style="color: #000000;">0<span style="color: #0000FF;">)<span style="color: #0000FF;">+<span style="color: #000000;">2<span style="color: #0000FF;">*<span style="color: #0000FF;">(<span style="color: #7060A8;">remainder<span style="color: #0000FF;">(<span style="color: #000000;">i<span style="color: #0000FF;">,<span style="color: #000000;">5<span style="color: #0000FF;">)<span style="color: #0000FF;">=<span style="color: #000000;">0<span style="color: #0000FF;">)<span style="color: #0000FF;">]<span style="color: #0000FF;">,<span style="color: #000000;">i<span style="color: #0000FF;">)</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">for |
|||
<!--</syntaxhighlight>--> |
|||
Two variants with tabulated output: |
|||
<!--<syntaxhighlight lang="phix">--> |
|||
<span style="color: #008080;">function</span> <span style="color: #000000;">f<span style="color: #0000FF;">(<span style="color: #004080;">integer</span> <span style="color: #000000;">i<span style="color: #0000FF;">)</span> |
|||
<span style="color: #004080;">integer</span> <span style="color: #000000;">idx</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1<span style="color: #0000FF;">+<span style="color: #0000FF;">(<span style="color: #7060A8;">remainder<span style="color: #0000FF;">(<span style="color: #000000;">i<span style="color: #0000FF;">,<span style="color: #000000;">3<span style="color: #0000FF;">)<span style="color: #0000FF;">=<span style="color: #000000;">0<span style="color: #0000FF;">)<span style="color: #0000FF;">+<span style="color: #000000;">2<span style="color: #0000FF;">*<span style="color: #0000FF;">(<span style="color: #7060A8;">remainder<span style="color: #0000FF;">(<span style="color: #000000;">i<span style="color: #0000FF;">,<span style="color: #000000;">5<span style="color: #0000FF;">)<span style="color: #0000FF;">=<span style="color: #000000;">0<span style="color: #0000FF;">)</span> |
|||
<span style="color: #008080;">return</span> <span style="color: #7060A8;">sprintf<span style="color: #0000FF;">(<span style="color: #0000FF;">{<span style="color: #008000;">"%-8d"<span style="color: #0000FF;">,<span style="color: #008000;">"Fizz "<span style="color: #0000FF;">,<span style="color: #008000;">"Buzz "<span style="color: #0000FF;">,<span style="color: #008000;">"FizzBuzz"<span style="color: #0000FF;">}<span style="color: #0000FF;">[<span style="color: #000000;">idx<span style="color: #0000FF;">]<span style="color: #0000FF;">,<span style="color: #000000;">i<span style="color: #0000FF;">)</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span> |
|||
<span style="color: #7060A8;">printf<span style="color: #0000FF;">(<span style="color: #000000;">1<span style="color: #0000FF;">,<span style="color: #7060A8;">join_by<span style="color: #0000FF;">(<span style="color: #7060A8;">apply<span style="color: #0000FF;">(<span style="color: #7060A8;">tagset<span style="color: #0000FF;">(<span style="color: #000000;">100<span style="color: #0000FF;">)<span style="color: #0000FF;">,<span style="color: #000000;">f<span style="color: #0000FF;">)<span style="color: #0000FF;">,<span style="color: #000000;">10<span style="color: #0000FF;">,<span style="color: #000000;">10<span style="color: #0000FF;">)<span style="color: #0000FF;">) |
|||
<!--</syntaxhighlight>--> |
|||
(output same as below) |
|||
<!--<syntaxhighlight lang="phix">--> |
|||
<span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">apply<span style="color: #0000FF;">(<span style="color: #004600;">true<span style="color: #0000FF;">,<span style="color: #7060A8;">sprintf<span style="color: #0000FF;">,<span style="color: #0000FF;">{<span style="color: #0000FF;">{<span style="color: #008000;">"%-8d"<span style="color: #0000FF;">}<span style="color: #0000FF;">,<span style="color: #7060A8;">tagset<span style="color: #0000FF;">(<span style="color: #000000;">100<span style="color: #0000FF;">)<span style="color: #0000FF;">}<span style="color: #0000FF;">)</span> |
|||
<span style="color: #008080;">for</span> <span style="color: #000000;">i<span style="color: #0000FF;">=<span style="color: #000000;">3</span> <span style="color: #008080;">to</span> <span style="color: #000000;">100</span> <span style="color: #008080;">by</span> <span style="color: #000000;">3</span> <span style="color: #008080;">do</span> <span style="color: #000000;">s<span style="color: #0000FF;">[<span style="color: #000000;">i<span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"Fizz "</span> <span style="color: #008080;">end</span> <span style="color: #008080;">for</span> |
|||
<span style="color: #008080;">for</span> <span style="color: #000000;">i<span style="color: #0000FF;">=<span style="color: #000000;">5</span> <span style="color: #008080;">to</span> <span style="color: #000000;">100</span> <span style="color: #008080;">by</span> <span style="color: #000000;">5</span> <span style="color: #008080;">do</span> <span style="color: #000000;">s<span style="color: #0000FF;">[<span style="color: #000000;">i<span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"Buzz "</span> <span style="color: #008080;">end</span> <span style="color: #008080;">for</span> |
|||
<span style="color: #008080;">for</span> <span style="color: #000000;">i<span style="color: #0000FF;">=<span style="color: #000000;">15</span> <span style="color: #008080;">to</span> <span style="color: #000000;">100</span> <span style="color: #008080;">by</span> <span style="color: #000000;">15</span> <span style="color: #008080;">do</span> <span style="color: #000000;">s<span style="color: #0000FF;">[<span style="color: #000000;">i<span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"FizzBuzz"</span> <span style="color: #008080;">end</span> <span style="color: #008080;">for</span> |
|||
<span style="color: #7060A8;">printf<span style="color: #0000FF;">(<span style="color: #000000;">1<span style="color: #0000FF;">,<span style="color: #7060A8;">join_by<span style="color: #0000FF;">(<span style="color: #000000;">s<span style="color: #0000FF;">,<span style="color: #000000;">10<span style="color: #0000FF;">,<span style="color: #000000;">10<span style="color: #0000FF;">)<span style="color: #0000FF;">) |
|||
<!--</syntaxhighlight>--> |
|||
{{out}} |
|||
<pre> |
|||
1 11 Fizz 31 41 Fizz 61 71 Fizz 91 |
|||
2 Fizz 22 32 Fizz 52 62 Fizz 82 92 |
|||
Fizz 13 23 Fizz 43 53 Fizz 73 83 Fizz |
|||
4 14 Fizz 34 44 Fizz 64 74 Fizz 94 |
|||
Buzz FizzBuzz Buzz Buzz FizzBuzz Buzz Buzz FizzBuzz Buzz Buzz |
|||
Fizz 16 26 Fizz 46 56 Fizz 76 86 Fizz |
|||
7 17 Fizz 37 47 Fizz 67 77 Fizz 97 |
|||
8 Fizz 28 38 Fizz 58 68 Fizz 88 98 |
|||
Fizz 19 29 Fizz 49 59 Fizz 79 89 Fizz |
|||
Buzz Buzz FizzBuzz Buzz Buzz FizzBuzz Buzz Buzz FizzBuzz Buzz |
|||
</pre> |
|||
Grotesquely inefficient (non-tabulated output), just for fun. Can you do worse, yet keep it semi-plausibile that someone might have actually earnestly written it? |
|||
<!--<syntaxhighlight lang="phix">--> |
|||
<span style="color: #008080;">constant</span> <span style="color: #000000;">threes</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">tagset<span style="color: #0000FF;">(<span style="color: #000000;">100<span style="color: #0000FF;">,<span style="color: #000000;">0<span style="color: #0000FF;">,<span style="color: #000000;">3<span style="color: #0000FF;">)<span style="color: #0000FF;">,</span> |
|||
<span style="color: #000000;">fives</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">tagset<span style="color: #0000FF;">(<span style="color: #000000;">100<span style="color: #0000FF;">,<span style="color: #000000;">0<span style="color: #0000FF;">,<span style="color: #000000;">5<span style="color: #0000FF;">)<span style="color: #0000FF;">,</span> |
|||
<span style="color: #000000;">fifteens</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">tagset<span style="color: #0000FF;">(<span style="color: #000000;">100<span style="color: #0000FF;">,<span style="color: #000000;">0<span style="color: #0000FF;">,<span style="color: #000000;">15<span style="color: #0000FF;">)</span> |
|||
<span style="color: #008080;">for</span> <span style="color: #000000;">i<span style="color: #0000FF;">=<span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">100</span> <span style="color: #008080;">do</span> |
|||
<span style="color: #008080;">if</span> <span style="color: #008080;">not</span> <span style="color: #7060A8;">find<span style="color: #0000FF;">(<span style="color: #000000;">i<span style="color: #0000FF;">,<span style="color: #000000;">threes<span style="color: #0000FF;">)</span> <span style="color: #008080;">and</span> <span style="color: #008080;">not</span> <span style="color: #7060A8;">find<span style="color: #0000FF;">(<span style="color: #000000;">i<span style="color: #0000FF;">,<span style="color: #000000;">fives<span style="color: #0000FF;">)</span> <span style="color: #008080;">and</span> <span style="color: #008080;">not</span> <span style="color: #7060A8;">find<span style="color: #0000FF;">(<span style="color: #000000;">i<span style="color: #0000FF;">,<span style="color: #000000;">fifteens<span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span> |
|||
<span style="color: #7060A8;">printf<span style="color: #0000FF;">(<span style="color: #000000;">1<span style="color: #0000FF;">,<span style="color: #008000;">"%d"<span style="color: #0000FF;">,<span style="color: #000000;">i<span style="color: #0000FF;">)</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span> |
|||
<span style="color: #008080;">if</span> <span style="color: #7060A8;">find<span style="color: #0000FF;">(<span style="color: #000000;">i<span style="color: #0000FF;">,<span style="color: #000000;">threes<span style="color: #0000FF;">)</span> <span style="color: #008080;">and</span> <span style="color: #008080;">not</span> <span style="color: #7060A8;">find<span style="color: #0000FF;">(<span style="color: #000000;">i<span style="color: #0000FF;">,<span style="color: #000000;">fives<span style="color: #0000FF;">)</span> <span style="color: #008080;">and</span> <span style="color: #008080;">not</span> <span style="color: #7060A8;">find<span style="color: #0000FF;">(<span style="color: #000000;">i<span style="color: #0000FF;">,<span style="color: #000000;">fifteens<span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span> |
|||
<span style="color: #7060A8;">printf<span style="color: #0000FF;">(<span style="color: #000000;">1<span style="color: #0000FF;">,<span style="color: #008000;">"Fizz"<span style="color: #0000FF;">)</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span> |
|||
<span style="color: #008080;">if</span> <span style="color: #008080;">not</span> <span style="color: #7060A8;">find<span style="color: #0000FF;">(<span style="color: #000000;">i<span style="color: #0000FF;">,<span style="color: #000000;">threes<span style="color: #0000FF;">)</span> <span style="color: #008080;">and</span> <span style="color: #7060A8;">find<span style="color: #0000FF;">(<span style="color: #000000;">i<span style="color: #0000FF;">,<span style="color: #000000;">fives<span style="color: #0000FF;">)</span> <span style="color: #008080;">and</span> <span style="color: #008080;">not</span> <span style="color: #7060A8;">find<span style="color: #0000FF;">(<span style="color: #000000;">i<span style="color: #0000FF;">,<span style="color: #000000;">fifteens<span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span> |
|||
<span style="color: #7060A8;">printf<span style="color: #0000FF;">(<span style="color: #000000;">1<span style="color: #0000FF;">,<span style="color: #008000;">"Buzz"<span style="color: #0000FF;">,<span style="color: #000000;">i<span style="color: #0000FF;">)</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span> |
|||
<span style="color: #008080;">if</span> <span style="color: #7060A8;">find<span style="color: #0000FF;">(<span style="color: #000000;">i<span style="color: #0000FF;">,<span style="color: #000000;">threes<span style="color: #0000FF;">)</span> <span style="color: #008080;">and</span> <span style="color: #7060A8;">find<span style="color: #0000FF;">(<span style="color: #000000;">i<span style="color: #0000FF;">,<span style="color: #000000;">fives<span style="color: #0000FF;">)</span> <span style="color: #008080;">and</span> <span style="color: #7060A8;">find<span style="color: #0000FF;">(<span style="color: #000000;">i<span style="color: #0000FF;">,<span style="color: #000000;">fifteens<span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span> |
|||
<span style="color: #7060A8;">printf<span style="color: #0000FF;">(<span style="color: #000000;">1<span style="color: #0000FF;">,<span style="color: #008000;">"FizzBuzz"<span style="color: #0000FF;">)</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span> |
|||
<span style="color: #7060A8;">printf<span style="color: #0000FF;">(<span style="color: #000000;">1<span style="color: #0000FF;">,<span style="color: #008000;">"\n"<span style="color: #0000FF;">)</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">for |
|||
<!--</syntaxhighlight>--> |
|||
=={{header|Phixmonti}}== |
|||
<syntaxhighlight lang="Phixmonti">/# Rosetta Code problem: http://rosettacode.org/wiki/FizzBuzz |
|||
by Galileo, 10/2022 #/ |
|||
100 for |
|||
dup print " " print dup |
|||
3 mod not if "Fizz" print endif |
|||
5 mod not if "Buzz" print endif |
|||
nl |
|||
endfor</syntaxhighlight> |
|||
{{out}} |
|||
<pre>1 |
|||
2 |
|||
3 Fizz |
|||
4 |
|||
5 Buzz |
|||
6 Fizz |
|||
7 |
|||
8 |
|||
9 Fizz |
|||
10 Buzz |
|||
11 |
|||
12 Fizz |
|||
13 |
|||
14 |
|||
15 FizzBuzz |
|||
16 |
|||
17 |
|||
18 Fizz |
|||
19 |
|||
20 Buzz |
|||
21 Fizz |
|||
22 |
|||
23 |
|||
24 Fizz |
|||
25 Buzz |
|||
26 |
|||
27 Fizz |
|||
28 |
|||
29 |
|||
30 FizzBuzz |
|||
31 |
|||
32 |
|||
33 Fizz |
|||
34 |
|||
35 Buzz |
|||
36 Fizz |
|||
37 |
|||
38 |
|||
39 Fizz |
|||
40 Buzz |
|||
41 |
|||
42 Fizz |
|||
43 |
|||
44 |
|||
45 FizzBuzz |
|||
46 |
|||
47 |
|||
48 Fizz |
|||
49 |
|||
50 Buzz |
|||
51 Fizz |
|||
52 |
|||
53 |
|||
54 Fizz |
|||
55 Buzz |
|||
56 |
|||
57 Fizz |
|||
58 |
|||
59 |
|||
60 FizzBuzz |
|||
61 |
|||
62 |
|||
63 Fizz |
|||
64 |
|||
65 Buzz |
|||
66 Fizz |
|||
67 |
|||
68 |
|||
69 Fizz |
|||
70 Buzz |
|||
71 |
|||
72 Fizz |
|||
73 |
|||
74 |
|||
75 FizzBuzz |
|||
76 |
|||
77 |
|||
78 Fizz |
|||
79 |
|||
80 Buzz |
|||
81 Fizz |
|||
82 |
|||
83 |
|||
84 Fizz |
|||
85 Buzz |
|||
86 |
|||
87 Fizz |
|||
88 |
|||
89 |
|||
90 FizzBuzz |
|||
91 |
|||
92 |
|||
93 Fizz |
|||
94 |
|||
95 Buzz |
|||
96 Fizz |
|||
97 |
|||
98 |
|||
99 Fizz |
|||
100 Buzz |
|||
=== Press any key to exit ===</pre> |
|||
=={{header|PHL}}== |
|||
{{trans|C}} |
|||
<syntaxhighlight 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; |
|||
]</syntaxhighlight> |
|||
=={{header|PHP}}== |
=={{header|PHP}}== |
||
===if/else ladder approach=== |
===if/else ladder approach=== |
||
<syntaxhighlight lang="php"><?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"; |
|||
} |
|||
?></syntaxhighlight> |
|||
?> |
|||
=== |
===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. |
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. |
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. |
||
<syntaxhighlight lang="php"><?php |
|||
for ( $i = 1; $i <= 100; ++$i ) |
|||
{ |
|||
$str = ""; |
|||
if (!($i % 3 ) ) |
|||
<?php |
|||
$str .= "Fizz"; |
|||
{ |
|||
$ |
if (!($i % 5 ) ) |
||
$str .= "Buzz"; |
|||
if (!($i % 3 ) ) |
|||
if ( empty( $str ) ) |
|||
$str = $i; |
|||
if (!($i % 5 ) ) |
|||
echo $str . "\n"; |
|||
} |
|||
?></syntaxhighlight> |
|||
===Concatenation approach without if-s=== |
|||
<syntaxhighlight lang="php"><?php |
|||
for ( |
|||
$i = 0; |
|||
$i++ < 100; |
|||
$o = ($i % 3 ? '' : 'Fizz') . ($i % 5 ? '' : 'Buzz') |
|||
) |
|||
echo $o ? : $i, PHP_EOL; |
|||
?></syntaxhighlight> |
|||
===One Liner Approach=== |
|||
<syntaxhighlight lang="php"><?php |
|||
for($i = 1; $i <= 100 and print(($i % 15 ? $i % 5 ? $i % 3 ? $i : 'Fizz' : 'Buzz' : 'FizzBuzz') . "\n"); ++$i); |
|||
?></syntaxhighlight> |
|||
===Compact One Liner Approach=== |
|||
<syntaxhighlight lang="php">for($i=0;$i++<100;)echo($i%3?'':'Fizz').($i%5?'':'Buzz')?:$i,"\n";</syntaxhighlight> |
|||
===Array One Liner Approach=== |
|||
<syntaxhighlight lang="php">for($i = 0; $i++ < 100;) echo [$i, 'Fizz', 'Buzz', 'FizzBuzz'][!($i % 3) + 2 * !($i % 5)], "\n";</syntaxhighlight> |
|||
=={{header|Picat}}== |
|||
Picat supports different programming styles/paradigms. |
|||
First some "standalone" predicates. |
|||
===Using a map=== |
|||
<syntaxhighlight lang="picat">fizzbuzz_map => |
|||
println(fizzbuzz_map), |
|||
FB = [I : I in 1..100], |
|||
Map = [(3="Fizz"),(5="Buzz"),(15="FizzBuzz")], |
|||
foreach(I in FB, K=V in Map) |
|||
if I mod K == 0 then |
|||
FB[I] := V |
|||
end |
|||
end, |
|||
println(FB).</syntaxhighlight> |
|||
===Using a template for the pattern=== |
|||
<syntaxhighlight lang="picat">fizzbuzz_template1 => |
|||
println(fizzbuzz_template1), |
|||
N = 100, |
|||
F = [_,_,fizz,_,buzz,fizz,_,_,fizz,buzz,_,fizz,_,_,fizzbuzz], |
|||
FF = [F : _I in 1..1+N div F.length].flatten(), |
|||
foreach(I in 1..N) |
|||
(var(FF[I]) -> print(I) ; print(FF[I])), |
|||
print(" ") |
|||
end, |
|||
nl.</syntaxhighlight> |
|||
===Another version with templates=== |
|||
<syntaxhighlight lang="picat">fizzbuzz_template2 => |
|||
println(fizzbuzz_template2), |
|||
N = 100, |
|||
F = new_list(N), |
|||
FV = [3,5,15], |
|||
FN = ["Fizz","Buzz","FizzBuzz"], |
|||
foreach(I in 1..N, {Val,Name} in zip(FV,FN)) |
|||
if I mod Val == 0 then F[I] := Name end |
|||
end, |
|||
foreach(I in 1..N) |
|||
printf("%w ", cond(var(F[I]),I, F[I])) |
|||
end, |
|||
nl.</syntaxhighlight> |
|||
Below are some versions for identifying the FizzBuzziness of a number. |
|||
To be used with the following general wrapper: |
|||
<syntaxhighlight lang="picat">fizzbuzz(Goal) => |
|||
println(Goal), |
|||
foreach(I in 1..100) |
|||
printf("%w ", apply(Goal,I)) |
|||
end, |
|||
nl.</syntaxhighlight> |
|||
===Plain imperative approach: if/else=== |
|||
<syntaxhighlight lang="picat">fb1(I) = V => |
|||
V = I.to_string(), |
|||
if I mod 15 == 0 then V := "FizzBuzz" |
|||
elseif I mod 3 == 0 then V := "Fizz" |
|||
elseif I mod 5 == 0 then V := "Buzz" |
|||
end.</syntaxhighlight> |
|||
===Pattern matching + conditions in head=== |
|||
<syntaxhighlight lang="picat">fb2(I) = "FizzBuzz", I mod 15 == 0 => true. |
|||
fb2(I) = "Fizz", I mod 3 == 0 => true. |
|||
fb2(I) = "Buzz", I mod 5 == 0 => true. |
|||
fb2(I) = I.to_string() => true.</syntaxhighlight> |
|||
===Another pattern matching approach=== |
|||
<syntaxhighlight lang="picat">fb3(I) = fb3b(I, I mod 3, I mod 5). |
|||
fb3b(_I,0,0) = "FizzBuzz". |
|||
fb3b(_I,_,0) = "Buzz". |
|||
fb3b(_I,0,_) = "Fizz". |
|||
fb3b(I,_,_) = I.</syntaxhighlight> |
|||
===Using cond/3 and string concatenation=== |
|||
<syntaxhighlight lang="picat">fb4(I) = cond(I mod 3 == 0, "Fizz", "") ++ |
|||
cond(I mod 5 == 0, "Buzz", "") ++ |
|||
cond(not ((I mod 3 == 0; I mod 5==0)), I.to_string(), "").</syntaxhighlight> |
|||
===Recursive function (conditions in head)=== |
|||
<syntaxhighlight lang="picat">fizzbuzz_rec => |
|||
print(fizzbuzz_rec), |
|||
fb5(100,[],L), |
|||
println(L). |
|||
fb5(N,L1,L), N = 0 ?=> |
|||
L = L1.reverse(). |
|||
fb5(N,L1,L),N mod 15 == 0 ?=> |
|||
fb5(N-1,L1 ++ ["FizzBuzz"], L). |
|||
fb5(N,L1,L), N mod 5 == 0 ?=> |
|||
fb5(N-1,L1 ++ ["Buzz"], L). |
|||
fb5(N,L1,L), N mod 3 == 0 ?=> |
|||
fb5(N-1,L1 ++ ["Fizz"], L). |
|||
fb5(N,L1,L), N mod 3 > 0, N mod 5 > 0 => |
|||
fb5(N-1,L1 ++ [N.to_string()], L).</syntaxhighlight> |
|||
===Golfing style=== |
|||
<syntaxhighlight lang="picat">fizzbuzz_golf => |
|||
println(fizzbuzz_golf), |
|||
[cond(P=="",I,P):I in 1..100,(I mod 3==0->P="Fizz";P=""),(I mod 5==0->P:=P++"Buzz";true)].println(). |
|||
</syntaxhighlight> |
|||
===Planner version=== |
|||
Picat has support for "classic" planning problems. The <code>planner</code> module must be imported. |
|||
<syntaxhighlight lang="picat">import planner. |
|||
fizzbuzz_planner => |
|||
println(fizzbuzz_planner), |
|||
plan(100,Plan), |
|||
println(Plan.reverse()), |
|||
nl. |
|||
final(Goal) => Goal == 0. |
|||
action(H,To,Move,Cost) ?=> |
|||
H mod 15 == 0, |
|||
Move = "FizzBuzz", |
|||
To = H-1, |
|||
Cost = 1. |
|||
action(H,To,Move,Cost) ?=> |
|||
H mod 5 == 0, |
|||
Move = "Buzz", |
|||
To = H-1, |
|||
Cost = 1. |
|||
action(H,To,Move,Cost) ?=> |
|||
H mod 3 == 0, |
|||
Move = "Fizz", |
|||
To = H-1, |
|||
Cost = 1. |
|||
action(H,To,Move,Cost) => |
|||
H mod 3 > 0, |
|||
H mod 5 > 0, |
|||
Move = H.to_string(), |
|||
To = H-1, |
|||
Cost = 1.</syntaxhighlight> |
|||
Here we test everything. |
|||
<syntaxhighlight lang="picat">go => |
|||
fizzbuzz_map, |
|||
fizzbuzz_template1, |
|||
fizzbuzz_template2, |
|||
fizzbuzz_planner, |
|||
fizzbuzz_rec, |
|||
fizzbuzz_golf, |
|||
FBs = [fb1,fb2,fb3,fb4], |
|||
foreach(FB in FBs) |
|||
call(fizzbuzz,FB) |
|||
end, |
|||
nl.</syntaxhighlight> |
|||
=={{header|PicoLisp}}== |
|||
We could simply use '[http://software-lab.de/doc/refA.html#at at]' here: |
|||
<syntaxhighlight lang="picolisp">(for N 100 |
|||
(prinl |
|||
(or (pack (at (0 . 3) "Fizz") (at (0 . 5) "Buzz")) N) ) ) |
|||
# Above, we simply count till 100 'prin'-ting number 'at' 3rd ('Fizz'), 5th ('Buzz') and 'pack'-ing 15th number ('FizzBuzz'). |
|||
# Rest of the times 'N' is printed as it loops in 'for'. |
|||
</syntaxhighlight> |
|||
Or do it the standard way: |
|||
<syntaxhighlight lang="picolisp">(for N 100 |
|||
(prinl |
|||
(cond |
|||
((=0 (% N 15)) "FizzBuzz") |
|||
((=0 (% N 3)) "Fizz") |
|||
((=0 (% N 5)) "Buzz") |
|||
(T N) ) ) )</syntaxhighlight> |
|||
=={{header|Piet}}== |
|||
See [[FizzBuzz/EsoLang#Piet]] |
|||
=={{header|Pike}}== |
|||
<syntaxhighlight 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"); |
|||
} |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|PILOT}}== |
|||
<syntaxhighlight lang="pilot">C :i = 0 |
|||
*loop |
|||
C :i = i + 1 |
|||
J ( i > 100 ) : *finished |
|||
C :modulo = i % 15 |
|||
J ( modulo = 0 ) : *fizzbuzz |
|||
C :modulo = i % 3 |
|||
J ( modulo = 0 ) : *fizz |
|||
C :modulo = i % 5 |
|||
J ( modulo = 0 ) : *buzz |
|||
T :#i |
|||
J : *loop |
|||
*fizzbuzz |
|||
T :FizzBuzz |
|||
J : *loop |
|||
*fizz |
|||
T :Fizz |
|||
J : *loop |
|||
*buzz |
|||
T :Buzz |
|||
J : *loop |
|||
*finished |
|||
END:</syntaxhighlight> |
|||
=={{header|PIR}}== |
|||
{{works with|Parrot|tested with 2.4.0}} |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
=={{header|PL/I}}== |
|||
<syntaxhighlight 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;</syntaxhighlight> |
|||
=={{header|PL/M}}== |
|||
<syntaxhighlight lang="plm">100H: |
|||
/* DECLARE OUTPUT IN TERMS OF CP/M - |
|||
PL/M DOES NOT COME WITH ANY STANDARD LIBRARY */ |
|||
BDOS: PROCEDURE(FUNC, ARG); |
|||
DECLARE FUNC BYTE, ARG ADDRESS; |
|||
GO TO 5; |
|||
END BDOS; |
|||
PUT$STRING: PROCEDURE(STR); |
|||
DECLARE STR ADDRESS; |
|||
CALL BDOS(9, STR); |
|||
CALL BDOS(9, .(13,10,'$')); |
|||
END PUT$STRING; |
|||
/* PRINT A NUMBER */ |
|||
PUT$NUMBER: PROCEDURE(N); |
|||
DECLARE S (5) BYTE INITIAL ('...$'); |
|||
DECLARE P ADDRESS; |
|||
DECLARE (N, D, C BASED P) BYTE; |
|||
P = .S(3); |
|||
DIGIT: |
|||
P = P-1; |
|||
C = (N MOD 10) + '0'; |
|||
N = N/10; |
|||
IF N > 0 THEN GO TO DIGIT; |
|||
CALL PUT$STRING(P); |
|||
END PUT$NUMBER; |
|||
/* FIZZBUZZ */ |
|||
DECLARE N BYTE; |
|||
DO N = 1 TO 100; |
|||
IF N MOD 15 = 0 THEN |
|||
CALL PUT$STRING(.'FIZZBUZZ$'); |
|||
ELSE IF N MOD 5 = 0 THEN |
|||
CALL PUT$STRING(.'BUZZ$'); |
|||
ELSE IF N MOD 3 = 0 THEN |
|||
CALL PUT$STRING(.'FIZZ$'); |
|||
ELSE |
|||
CALL PUT$NUMBER(N); |
|||
END; |
|||
/* EXIT TO CP/M */ |
|||
CALL BDOS(0,0); |
|||
EOF</syntaxhighlight> |
|||
=={{header|PL/SQL}}== |
|||
<syntaxhighlight lang="plsql">begin |
|||
for i in 1 .. 100 |
|||
loop |
|||
case |
|||
when mod(i, 15) = 0 then |
|||
dbms_output.put_line('FizzBuzz'); |
|||
when mod(i, 5) = 0 then |
|||
dbms_output.put_line('Buzz'); |
|||
when mod(i, 3) = 0 then |
|||
dbms_output.put_line('Fizz'); |
|||
else |
|||
dbms_output.put_line(i); |
|||
end case; |
|||
end loop; |
|||
end;</syntaxhighlight> |
|||
=={{header|Plain English}}== |
|||
<syntaxhighlight lang="text"> |
|||
To play FizzBuzz up to a number: |
|||
Put "" into a string. |
|||
Loop. |
|||
If a counter is past the number, exit. |
|||
If the counter is evenly divisible by 3, append "Fizz" to the string. |
|||
If the counter is evenly divisible by 5, append "Buzz" to the string. |
|||
If the string is blank, append the counter then "" to the string. |
|||
Write the string to the console. |
|||
Clear the string. |
|||
Repeat. |
|||
To run: |
|||
Start up. |
|||
Play FizzBuzz up to 100. |
|||
Wait for the escape key. |
|||
Shut down. |
|||
</syntaxhighlight> |
|||
=={{header|Pointless}}== |
|||
<syntaxhighlight lang="pointless"> |
|||
output = |
|||
range(1, 100) |
|||
|> map(fizzBuzz) |
|||
|> printLines |
|||
fizzBuzz(n) = |
|||
if result == "" then n else result |
|||
where result = fizzBuzzString(n) |
|||
fizzBuzzString(n) = |
|||
(if n % 3 == 0 then "Fizz" else "") |
|||
+ (if n % 5 == 0 then "Buzz" else "") |
|||
</syntaxhighlight> |
|||
=={{header|Pony}}== |
|||
<syntaxhighlight lang="pony">use "collections" |
|||
actor Main |
|||
if ( empty( $str ) ) |
|||
new create(env: Env) => |
|||
$str = $i; |
|||
for i in Range[I32](1, 100) do |
|||
env.out.print(fizzbuzz(i)) |
|||
end |
|||
fun fizzbuzz(n: I32): String => |
|||
echo "$str\n"; |
|||
if (n % 15) == 0 then |
|||
} |
|||
"FizzBuzz" |
|||
?> |
|||
elseif (n % 5) == 0 then |
|||
"Buzz" |
|||
elseif (n % 3) == 0 then |
|||
"Fizz" |
|||
else |
|||
n.string() |
|||
end</syntaxhighlight> |
|||
=={{header|Pop11}}== |
=={{header|Pop11}}== |
||
<syntaxhighlight lang="pop11">lvars str; |
|||
<pre> |
|||
lvars str; |
|||
for i from 1 to 100 do |
for i from 1 to 100 do |
||
if i rem 15 = 0 then |
if i rem 15 = 0 then |
||
Line 540: | Line 9,044: | ||
endif; |
endif; |
||
printf(str, '%s\n'); |
printf(str, '%s\n'); |
||
endfor; |
endfor;</syntaxhighlight> |
||
</pre> |
|||
=={{header|PostScript}}== |
=={{header|PostScript}}== |
||
<syntaxhighlight lang="postscript">1 1 100 { |
|||
<pre> |
|||
1 1 100 { |
|||
/c false def |
/c false def |
||
dup 3 mod 0 eq { (Fizz) print /c true def } if |
dup 3 mod 0 eq { (Fizz) print /c true def } if |
||
Line 551: | Line 9,053: | ||
c {pop}{( ) cvs print} ifelse |
c {pop}{( ) cvs print} ifelse |
||
(\n) print |
(\n) print |
||
} for |
} for</syntaxhighlight> |
||
</pre> |
|||
or... |
or... |
||
<syntaxhighlight lang="postscript">/fizzdict 100 dict def |
|||
<pre> |
|||
/fizzdict 100 dict def |
|||
fizzdict begin |
fizzdict begin |
||
/notmod{ ( ) cvs } def |
/notmod{ ( ) cvs } def |
||
Line 565: | Line 9,065: | ||
1 1 100 { mod15} for |
1 1 100 { mod15} for |
||
1 1 100 { dup currentdict exch known { currentdict exch get}{notmod} ifelse print (\n) print} for |
1 1 100 { dup currentdict exch known { currentdict exch get}{notmod} ifelse print (\n) print} for |
||
end</syntaxhighlight> |
|||
end |
|||
=={{header|Potion}}== |
|||
<syntaxhighlight 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.</syntaxhighlight> |
|||
=={{header|PowerShell}}== |
|||
===Straightforward, looping=== |
|||
<syntaxhighlight 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 |
|||
} |
|||
}</syntaxhighlight> |
|||
===Pipeline, Switch=== |
|||
<syntaxhighlight 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 } |
|||
} |
|||
}</syntaxhighlight> |
|||
===Concatenation=== |
|||
{{trans|C#}} |
|||
<syntaxhighlight lang="powershell">1..100 | ForEach-Object { |
|||
$s = '' |
|||
if ($_ % 3 -eq 0) { $s += "Fizz" } |
|||
if ($_ % 5 -eq 0) { $s += "Buzz" } |
|||
if (-not $s) { $s = $_ } |
|||
$s |
|||
}</syntaxhighlight> |
|||
===Piping, Evaluation, Concatenation=== |
|||
<syntaxhighlight lang="powershell"> |
|||
1..100 | % {write-host("$(if(($_ % 3 -ne 0) -and ($_ % 5 -ne 0)){$_})$(if($_ % 3 -eq 0){"Fizz"})$(if($_ % 5 -eq 0){"Buzz"})")} |
|||
</syntaxhighlight> |
|||
===Filter, Piping, Regex Matching, Array Auto-Selection=== |
|||
<syntaxhighlight lang="powershell"> |
|||
filter fizz-buzz{ |
|||
@( |
|||
$_, |
|||
"Fizz", |
|||
"Buzz", |
|||
"FizzBuzz" |
|||
)[ |
|||
2 * |
|||
($_ -match '[05]$') + |
|||
($_ -match '(^([369][0369]?|[258][147]|[147][258]))$') |
|||
] |
|||
} |
|||
1..100 | fizz-buzz |
|||
</syntaxhighlight> |
|||
===String Manipulation with Regex=== |
|||
<syntaxhighlight lang="powershell"> |
|||
(1..100 -join "`n") + "`nFizzBuzz" -replace '(?ms)(^([369]([369]|(?=0|$))|[258][147]|[147]([28]|(?=5))))(?=[05]?$.*(Fizz))|(((?<=[369])|[^369])0+|((?<=[147\s])|[^147\s])5)(?=$.*(Buzz))|FizzBuzz', '$5$9' |
|||
</syntaxhighlight> |
|||
=={{header|Processing}}== |
|||
===Console & Visualization=== |
|||
Reserved variable "width" in Processing is 100 pixels by default, suitable for this FizzBuzz exercise. |
|||
Accordingly, range is pixel index from 0 to 99. |
|||
<syntaxhighlight lang="processing">for (int i = 0; i < width; i++) { |
|||
if (i % 3 == 0 && i % 5 == 0) { |
|||
stroke(255, 255, 0); |
|||
println("FizzBuzz!"); |
|||
} |
|||
else if (i % 5 == 0) { |
|||
stroke(0, 255, 0); |
|||
println("Buzz"); |
|||
} |
|||
else if (i % 3 == 0) { |
|||
stroke(255, 0, 0); |
|||
println("Fizz"); |
|||
} |
|||
else { |
|||
stroke(0, 0, 255); |
|||
println(i); |
|||
} |
|||
line(i, 0, i, height); |
|||
}</syntaxhighlight> |
|||
===Console & Visualization, Ternary=== |
|||
<syntaxhighlight lang="processing">for (int i = 0; i < width; i++) { |
|||
stroke((i % 5 == 0 && i % 3 == 0) ? #FFFF00 : (i % 5 == 0) ? #00FF00 : (i % 3 == 0) ? #FF0000 : #0000FF); |
|||
line(i, 0, i, height); |
|||
println((i % 5 == 0 && i % 3 == 0) ? "FizzBuzz!" : (i % 5 == 0) ? "Buzz" : (i % 3 == 0) ? "Fizz" : i); |
|||
}</syntaxhighlight> |
|||
===Console=== |
|||
<syntaxhighlight lang="processing">for (int 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("\n"); |
|||
}</syntaxhighlight> |
|||
===Console, "Futureproof"=== |
|||
<syntaxhighlight lang="processing">for(int i = 1; i <= 100; i++){ |
|||
String output = ""; |
|||
if(i % 3 == 0) output += "Fizz"; |
|||
if(i % 5 == 0) output += "Buzz"; |
|||
// copy & paste above line to add more tests |
|||
if(output == "") output = str(i); |
|||
println(output); |
|||
}</syntaxhighlight> |
|||
All examples produce the same console output: |
|||
{{out}} |
|||
<pre style="height:35ex"> |
|||
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 |
|||
</pre> |
</pre> |
||
=={{header|Prolog}}== |
|||
{{works with|SWI Prolog|4.8.0}} |
|||
{{works with|Ciao Prolog|1.21.0}} |
|||
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. |
|||
<syntaxhighlight lang="prolog">fizzbuzz :- |
|||
forall(between(1, 100, X), print_item(X)). |
|||
print_item(X) :- |
|||
( X mod 15 =:= 0 |
|||
-> write('FizzBuzz') |
|||
; X mod 3 =:= 0 |
|||
-> write('Fizz') |
|||
; X mod 5 =:= 0 |
|||
-> write('Buzz') |
|||
; write(X) |
|||
), |
|||
nl.</syntaxhighlight> |
|||
More conventional, doing the loop this time failure driven: |
|||
<syntaxhighlight lang="prolog">fizzbuzz(X) :- X mod 15 =:= 0, !, write('FizzBuzz'). |
|||
fizzbuzz(X) :- X mod 3 =:= 0, !, write('Fizz'). |
|||
fizzbuzz(X) :- X mod 5 =:= 0, !, write('Buzz'). |
|||
fizzbuzz(X) :- write(X). |
|||
dofizzbuzz :-between(1, 100, X), fizzbuzz(X), nl, fail. |
|||
dofizzbuzz.</syntaxhighlight> |
|||
Clearer, doing the loop this time tail recursive, quite declarative: |
|||
<syntaxhighlight 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, yes) :- N mod D =:= 0. |
|||
divisible_by(N, D, no) :- N mod D =\= 0. |
|||
% Print 'Fizz', 'Buzz', 'FizzBuzz' or N as appropriate. |
|||
fizz_buzz_or_n(N) :- N > 100. |
|||
fizz_buzz_or_n(N) :- N =< 100, |
|||
divisible_by(N, 3, Fizz), |
|||
divisible_by(N, 5, Buzz), |
|||
fizzbuzz(N, Fizz, Buzz, FB), |
|||
write(FB), nl, |
|||
M is N+1, fizz_buzz_or_n(M). |
|||
main :- |
|||
fizz_buzz_or_n(1).</syntaxhighlight> |
|||
Using modern Prolog techniques, resulting in idiomatic, highly declarative code: |
|||
{{works with|SWI Prolog|8.2.1}} {{works with|Scryer Prolog|0.7.8}} |
|||
<syntaxhighlight lang="prolog"> |
|||
% This implementation uses modern Prolog techniques |
|||
% in order to be an idiomatic solution that uses logical purity, generality and determinism wherever possible: |
|||
% - CLP(Z): constraint logic programming on integers. |
|||
% - library(reif): efficient logical predicates based on 'Indexing dif/2'. |
|||
:- module(fizz_buzz, [main/0, integer_fizzbuzz_below_100/2, integer_fizzbuzz/2]). |
|||
:- use_module(library(reif)). |
|||
% for Scryer-Prolog: |
|||
:- use_module(library(clpz)). |
|||
:- use_module(library(between)). |
|||
:- use_module(library(iso_ext)). |
|||
:- use_module(library(si)). |
|||
% for SWI-Prolog: |
|||
% :- use_module(library(clpfd)). |
|||
% Prints all solutions to `integer_fizzbuzz_below_100` each on a separate line, in order. |
|||
% Logically-impure shell, as currently there is no logically-pure way to write to a filestream. |
|||
main :- |
|||
forall(integer_fizzbuzz_below_100(_, FizzBuzz), write_line(FizzBuzz)). |
|||
write_line(Value) :- |
|||
write(Value), |
|||
nl. |
|||
% Constrains FizzBuzz results to the range 1 <= X <= 100, |
|||
% and (for the 'most general query' where neither X or FizzBuzz is concrete) |
|||
% ensures results are traversed in order low -> high X. |
|||
% |
|||
% ?- integer_fizzbuzz_below_100(X, FizzBuzz) % generate all the results in order |
|||
% ?- integer_fizzbuzz_below_100(27, Result) % Find out what output `27` will produce (it's 'Fizz'.) |
|||
% ?- integer_fizzbuzz_below_100(X, 'Fizz') % generate all the numbers which would print 'Fizz' in order (3, 6, 9, etc). |
|||
% ?- integer_fizzbuzz_below_100(X, Res), integer_si(Res) % generate all the numbers which would print themselves in order (1, 2, 4, 6, 7, 8, 11, etc). |
|||
% ?- integer_fizzbuzz_below_100(X, Res), is_of_type(integer, Res) % SWI-Prolog version doing the same. |
|||
integer_fizzbuzz_below_100(X, FizzBuzz) :- |
|||
between(1, 100, X), |
|||
integer_fizzbuzz(X, FizzBuzz). |
|||
% States the relationship between a number |
|||
% and its FizzBuzz representation. |
|||
% |
|||
% Because constraints are propagated lazily, |
|||
% prompting this predicate without having constrained `Num` |
|||
% to a particular integer value will give you its definition back. |
|||
% Put differently: This predicate returns the whole solution space at once, |
|||
% and external labeling techniques are required to traverse and concretize this solution space |
|||
% in an order that we like. |
|||
integer_fizzbuzz(Num, FizzBuzz) :- |
|||
if_(Num mod 15 #= 0, FizzBuzz = 'FizzBuzz', |
|||
if_(Num mod 5 #= 0, FizzBuzz = 'Buzz', |
|||
if_(Num mod 3 #= 0, FizzBuzz = 'Fizz', |
|||
Num = FizzBuzz) |
|||
) |
|||
). |
|||
% Reifiable `#=`. |
|||
#=(X, Y, T) :- |
|||
X #= X1, |
|||
Y #= Y1, |
|||
zcompare(C, X1, Y1), |
|||
eq_t(C, T). |
|||
eq_t(=, true). |
|||
eq_t(<, false). |
|||
eq_t(>, false). |
|||
</syntaxhighlight> |
|||
=={{header|PureBasic}}== |
|||
See [[FizzBuzz/Basic]] |
|||
=={{header|Pyret}}== |
|||
<syntaxhighlight lang="pyret">fun fizzbuzz(n :: NumPositive) -> String: |
|||
doc: ```For positive input which is multiples of three return 'Fizz', for the multiples of five return 'Buzz'. |
|||
For numbers which are multiples of both three and five return 'FizzBuzz'. Otherwise, return the number itself.``` |
|||
ask: |
|||
| num-modulo(n, 15) == 0 then: "FizzBuzz" |
|||
| num-modulo(n, 3) == 0 then: "Fizz" |
|||
| num-modulo(n, 5) == 0 then: "Buzz" |
|||
| otherwise: num-to-string(n) |
|||
end |
|||
where: |
|||
fizzbuzz(1) is "1" |
|||
fizzbuzz(101) is "101" |
|||
fizzbuzz(45) is "FizzBuzz" |
|||
fizzbuzz(33) is "Fizz" |
|||
fizzbuzz(25) is "Buzz" |
|||
end |
|||
range(1, 101).map(fizzbuzz).each(print)</syntaxhighlight> |
|||
=={{header|Python}}== |
=={{header|Python}}== |
||
===Python2: Simple=== |
|||
<pre> |
|||
for i in |
<syntaxhighlight lang="python">for i in range(1, 101): |
||
if i % 15 == 0: |
if i % 15 == 0: |
||
print "FizzBuzz" |
print "FizzBuzz" |
||
Line 577: | Line 9,454: | ||
print "Buzz" |
print "Buzz" |
||
else: |
else: |
||
print i |
print i</syntaxhighlight> |
||
</pre> |
|||
===Python3: Simple=== |
|||
And a shorter version with less duplication: |
|||
<syntaxhighlight lang="python">for i in range(1, 101): |
|||
<pre> |
|||
if i % 15 == 0: |
|||
print("FizzBuzz") |
|||
words = [word for n, word in ((3, 'Fizz'), (5, 'Buzz')) if not i % n] |
|||
elif i % 3 == 0: |
|||
print ''.join(words) or i |
|||
print("Fizz") |
|||
</pre> |
|||
elif i % 5 == 0: |
|||
print("Buzz") |
|||
else: |
|||
print(i)</syntaxhighlight> |
|||
===Python: Simple - no duplication === |
|||
<syntaxhighlight lang="python">for n in range(1,101): |
|||
response = '' |
|||
if not n%3: |
|||
response += 'Fizz' |
|||
if not n%5: |
|||
response += 'Buzz' |
|||
print(response or n) |
|||
</syntaxhighlight> |
|||
One liner using string concatenation: |
|||
<syntaxhighlight lang="python">for i in range(1,101): print("Fizz"*(i%3==0) + "Buzz"*(i%5==0) or i)</syntaxhighlight> |
|||
One liner another code: |
|||
<syntaxhighlight lang="python">for i in range(100):print(i%3//2*'Fizz'+i%5//4*'Buzz'or i+1)</syntaxhighlight> |
|||
List Comprehensions: |
|||
<syntaxhighlight lang="python"> |
|||
for n in range(1, 100): |
|||
fb = ''.join([ denom[1] if n % denom[0] == 0 else '' for denom in [(3,'fizz'),(5,'buzz')] ]) |
|||
print fb if fb else n |
|||
</syntaxhighlight> |
|||
Another list comprehension: |
|||
<syntaxhighlight lang="python"> |
|||
print (', '.join([(x%3<1)*'Fizz'+(x%5<1)*'Buzz' or str(x) for x in range(1,101)])) |
|||
</syntaxhighlight> |
|||
===Python: List Comprehension (Python 3)=== |
|||
<syntaxhighlight lang="python">[print("FizzBuzz") if i % 15 == 0 else print("Fizz") if i % 3 == 0 else print("Buzz") if i % 5 == 0 else print(i) for i in range(1,101)]</syntaxhighlight> |
|||
===Python: Lazily=== |
|||
You can also create a lazy, unbounded sequence by using generator expressions: |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
Or equivalently, in terms of map, and Python 3 libraries: |
|||
{{Works with|Python|3.7}} |
|||
<syntaxhighlight lang="python">'''Fizz buzz''' |
|||
from itertools import count, cycle, islice |
|||
# fizzBuzz :: () -> Generator [String] |
|||
def fizzBuzz(): |
|||
'''A non-finite stream of fizzbuzz terms. |
|||
''' |
|||
return map( |
|||
lambda f, b, n: (f + b) or str(n), |
|||
cycle([''] * 2 + ['Fizz']), |
|||
cycle([''] * 4 + ['Buzz']), |
|||
count(1) |
|||
) |
|||
# ------------------------- TEST ------------------------- |
|||
def main(): |
|||
'''Display of first 100 terms of the fizzbuzz series. |
|||
''' |
|||
print( |
|||
'\n'.join( |
|||
list(islice( |
|||
fizzBuzz(), |
|||
100 |
|||
)) |
|||
) |
|||
) |
|||
if __name__ == '__main__': |
|||
main()</syntaxhighlight> |
|||
===Python3.8: With walrus operator=== |
|||
<syntaxhighlight lang="python">print(*map(lambda n: 'Fizzbuzz '[(i):i+13] if (i := n**4%-15) > -14 else n, range(1,100)))</syntaxhighlight> |
|||
===Python: Math tricks=== |
|||
Numbers ending in 5 or 0 are divisible by 5. Numbers whose digits recursively summed to a single-digit number == 3,6 or 9 are divisible by 3. |
|||
<syntaxhighlight lang="python"> |
|||
def numsum(n): |
|||
''' The recursive sum of all digits in a number |
|||
unit a single character is obtained''' |
|||
res = sum([int(i) for i in str(n)]) |
|||
if res < 10: return res |
|||
else : return numsum(res) |
|||
for n in range(1,101): |
|||
response = 'Fizz'*(numsum(n) in [3,6,9]) + \ |
|||
'Buzz'*(str(n)[-1] in ['5','0'])\ |
|||
or n |
|||
print(response) |
|||
</syntaxhighlight> |
|||
===Python3: Super concise: 1 line=== |
|||
<syntaxhighlight lang="python"> |
|||
print(*((lambda x=x: ''.join(chr(c) for c in (102, 105)) + (2 * chr(122)) + ''.join(chr(c) for c in (98, 117)) + (2 * chr(122)) + '\n' if x % (30 >> 1) == 0 else ''.join(chr(c) for c in (102, 105)) + (2 * chr(122)) + '\n' if x % (6 >> 1) == 0 else ''.join(chr(c) for c in (98, 117)) + (2 * chr(122)) + '\n' if x % (10 >> 1) == 0 else str(x) + '\n')() for x in range(1, 101))) |
|||
</syntaxhighlight> |
|||
=={{header|q}}== |
|||
q is the query language for '''kdb+'''. |
|||
<syntaxhighlight lang="q"> |
|||
{(`$string x)^`fizzbuzz`buzz`fizz`(x mod\:15 5 3)?'0}</syntaxhighlight> |
|||
Usage: |
|||
<syntaxhighlight lang="q"> |
|||
q)/ Fizzbuzz |
|||
q)fb:{(`$string x)^`fizzbuzz`buzz`fizz`(x mod\:15 5 3)?'0} |
|||
q)fb 1+til 20 |
|||
`1`2`fizz`4`buzz`fizz`7`8`fizz`buzz`11`fizz`13`14`fizzbuzz`16`17`fizz`19`buzz</syntaxhighlight> |
|||
https://https://q201.org/apply-fizzbuzz//<br> |
|||
https://code.kx.com/q/ref/mod/<br> |
|||
https://code.kx.com/q/ref/fill |
|||
Explanation: |
|||
<syntaxhighlight lang="q"> |
|||
q)show x:1+til 20 |
|||
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
|||
q)x mod\:15 5 3 |
|||
1 1 1 |
|||
2 2 2 |
|||
3 3 0 |
|||
4 4 1 |
|||
5 0 2 |
|||
6 1 0 |
|||
.. |
|||
q)(x mod\:15 5 3)?'0 |
|||
3 3 2 3 1 2 3 3 2 1 3 2 3 3 0 3 3 2 3 1 |
|||
q)`fizzbuzz`buzz`fizz`(x mod\:15 5 3)?'0 / substitutions |
|||
```fizz``buzz`fizz```fizz`buzz``fizz```fizzbuzz```fizz``buzz |
|||
q)`$string x / numbers => symbols |
|||
`1`2`3`4`5`6`7`8`9`10`11`12`13`14`15`16`17`18`19`20 |
|||
q)(`$string x)^`fizzbuzz`buzz`fizz`(x mod\:15 5 3)?'0 / replace nulls with numbers |
|||
`1`2`fizz`4`buzz`fizz`7`8`fizz`buzz`11`fizz`13`14`fizzbuzz`16`17`fizz`19`buzz</syntaxhighlight> |
|||
=={{header|QB64}}== |
|||
<syntaxhighlight lang="qb64">For n = 1 To 100 |
|||
If n Mod 15 = 0 Then |
|||
Print "FizzBuzz" |
|||
ElseIf n Mod 5 = 0 Then |
|||
Print "Buzz" |
|||
ElseIf n Mod 3 = 0 Then |
|||
Print "Fizz" |
|||
Else |
|||
Print n |
|||
End If |
|||
Next</syntaxhighlight> |
|||
=={{header|Quackery}}== |
|||
<syntaxhighlight lang="quackery"> 100 times |
|||
[ i^ 1+ true |
|||
over 3 mod not |
|||
if [ say "fizz" drop false ] |
|||
over 5 mod not |
|||
if [ say "buzz" drop false ] |
|||
iff echo else drop |
|||
sp ] |
|||
</syntaxhighlight> |
|||
=={{header|R}}== |
|||
<syntaxhighlight lang="rsplus">xx <- x <- 1:100 |
|||
xx[x %% 3 == 0] <- "Fizz" |
|||
xx[x %% 5 == 0] <- "Buzz" |
|||
xx[x %% 15 == 0] <- "FizzBuzz" |
|||
xx</syntaxhighlight> |
|||
Or, without directly checking for divisibility by 15: |
|||
<syntaxhighlight lang="rsplus">xx <- rep("", 100) |
|||
x <- 1:100 |
|||
xx[x %% 3 == 0] <- paste0(xx[x %% 3 == 0], "Fizz") |
|||
xx[x %% 5 == 0] <- paste0(xx[x %% 5 == 0], "Buzz") |
|||
xx[xx == ""] <- x[xx == ""] |
|||
xx</syntaxhighlight> |
|||
Or, (ab)using the vector recycling rule: |
|||
<syntaxhighlight lang="rsplus">x <- paste0(rep("", 100), c("", "", "Fizz"), c("", "", "", "", "Buzz")) |
|||
cat(ifelse(x == "", 1:100, x), sep = "\n")</syntaxhighlight> |
|||
Or, for an abuse of the recycling rules that could be generalised: |
|||
<syntaxhighlight lang="rsplus">x <- paste0(rep("", 100), rep(c("", "Fizz"), times = c(2, 1)), rep(c("", "Buzz"), times = c(4, 1))) |
|||
cat(ifelse(x == "", 1:100, x), sep = "\n")</syntaxhighlight> |
|||
Or, with a more straightforward use of ifelse: |
|||
<syntaxhighlight lang="rsplus">x <- 1:100 |
|||
ifelse(x %% 15 == 0, 'FizzBuzz', |
|||
ifelse(x %% 5 == 0, 'Buzz', |
|||
ifelse(x %% 3 == 0, 'Fizz', x)))</syntaxhighlight> |
|||
Or, adapting from [https://rosettacode.org/wiki/General_FizzBuzz#Names_solution General FizzBuzz#Names solution]: |
|||
<syntaxhighlight lang="rsplus">namedNums <- c(Fizz = 3, Buzz = 5) |
|||
for(i in 1:100) |
|||
{ |
|||
isFactor <- i %% namedNums == 0 |
|||
print(if(any(isFactor)) paste0(names(namedNums)[isFactor], collapse = "") else i) |
|||
}</syntaxhighlight> |
|||
=={{header|Racket}}== |
|||
<syntaxhighlight lang="racket">#lang racket |
|||
(for ([n (in-range 1 101)]) |
|||
(displayln |
|||
(match (gcd n 15) |
|||
[15 "fizzbuzz"] |
|||
[3 "fizz"] |
|||
[5 "buzz"] |
|||
[_ n])))</syntaxhighlight> |
|||
=={{header|Raku}}== |
|||
(formerly Perl 6) |
|||
{{works with|Rakudo Star|2015-09-10}} |
|||
Most straightforwardly: |
|||
<syntaxhighlight lang="raku" line>for 1 .. 100 { |
|||
when $_ %% (3 & 5) { say 'FizzBuzz'; } |
|||
when $_ %% 3 { say 'Fizz'; } |
|||
when $_ %% 5 { say 'Buzz'; } |
|||
default { .say; } |
|||
}</syntaxhighlight> |
|||
Or abusing multi subs: |
|||
<syntaxhighlight lang="raku" line>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.say;</syntaxhighlight> |
|||
Or abusing list metaoperators: |
|||
<syntaxhighlight lang="raku" line>[1..100].map({[~] ($_%%3, $_%%5) »||» "" Z&& <fizz buzz> or $_ })».say</syntaxhighlight> |
|||
Concisely (readable): |
|||
<syntaxhighlight lang="raku" line>say 'Fizz' x $_ %% 3 ~ 'Buzz' x $_ %% 5 || $_ for 1 .. 100;</syntaxhighlight> |
|||
Shortest FizzBuzz to date: |
|||
<syntaxhighlight lang="raku" line>say "Fizz"x$_%%3~"Buzz"x$_%%5||$_ for 1..100</syntaxhighlight> |
|||
And here's an implementation that never checks for divisibility: |
|||
<syntaxhighlight lang="raku" line>.say for |
|||
( |
|||
(flat ('' xx 2, 'Fizz') xx *) |
|||
Z~ |
|||
(flat ('' xx 4, 'Buzz') xx *) |
|||
) |
|||
Z|| |
|||
1 .. 100;</syntaxhighlight> |
|||
=={{header|RapidQ}}== |
=={{header|RapidQ}}== |
||
The [[ |
The [[#BASIC|BASIC]] solutions work with RapidQ, too. |
||
However, here is a bit more esoteric solution using the IIF() function. |
However, here is a bit more esoteric solution using the IIF() function. |
||
<syntaxhighlight lang="rapidq">FOR i=1 TO 100 |
|||
<pre> |
|||
t$ = IIF(i MOD 3 = 0, "Fizz", "") + IIF(i MOD 5 = 0, "Buzz", "") |
|||
FOR i=1 TO 100 |
|||
PRINT IIF(LEN(t$), t$, i) |
|||
t$ = IIF(i MOD 3 = 0, "Fizz", "") + IIF(i MOD 5 = 0, "Buzz", "") |
|||
NEXT i</syntaxhighlight> |
|||
PRINT IIF(LEN(t$), t$, i) |
|||
NEXT i |
|||
</pre> |
|||
=={{header| |
=={{header|Rascal}}== |
||
<syntaxhighlight lang="rascal">import IO; |
|||
public void fizzbuzz() { |
|||
<pre> |
|||
for(int n <- [1 .. 100]){ |
|||
100 each 1 + as n |
|||
fb = ((n % 3 == 0) ? "Fizz" : "") + ((n % 5 == 0) ? "Buzz" : ""); |
|||
println((fb == "") ?"<n>" : fb); |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|Raven}}== |
|||
<syntaxhighlight lang="raven">100 each 1 + as n |
|||
'' |
'' |
||
n 3 mod 0 = if 'Fizz' cat |
n 3 mod 0 = if 'Fizz' cat |
||
n 5 mod 0 = if 'Buzz' cat |
n 5 mod 0 = if 'Buzz' cat |
||
dup empty if drop n |
dup empty if drop n |
||
say |
say</syntaxhighlight> |
||
=={{header|REALbasic}}== |
|||
See [[FizzBuzz/Basic]] |
|||
=={{header|ReasonML}}== |
|||
<syntaxhighlight lang="ocaml"> |
|||
let fizzbuzz i => |
|||
switch (i mod 3, i mod 5) { |
|||
| (0, 0) => "FizzBuzz" |
|||
| (0, _) => "Fizz" |
|||
| (_, 0) => "Buzz" |
|||
| _ => string_of_int i |
|||
}; |
|||
for i in 1 to 100 { |
|||
print_endline (fizzbuzz i) |
|||
}; |
|||
</syntaxhighlight> |
|||
=={{header|REBOL}}== |
|||
An implementation that concatenates strings and includes a proper code header (title, date, etc.) |
|||
<syntaxhighlight lang="rebol">REBOL [ |
|||
Title: "FizzBuzz" |
|||
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 |
|||
]</syntaxhighlight> |
|||
Here is an example by Nick Antonaccio. |
|||
<syntaxhighlight lang="rebol">repeat i 100 [ |
|||
print switch/default 0 compose [ |
|||
(mod i 15) ["fizzbuzz"] |
|||
(mod i 3) ["fizz"] |
|||
(mod i 5) ["buzz"] |
|||
][i] |
|||
]</syntaxhighlight> |
|||
And a minimized version: |
|||
<syntaxhighlight lang="rebol">repeat i 100[j:""if i // 3 = 0[j:"fizz"]if i // 5 = 0[j: join j"buzz"]if""= j[j: i]print j]</syntaxhighlight> |
|||
The following is presented as a curiosity only, not as an example of good coding practice: |
|||
<syntaxhighlight 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]</syntaxhighlight> |
|||
=={{header|Red}}== |
|||
<syntaxhighlight lang="red">Red [Title: "FizzBuzz"] |
|||
repeat i 100 [ |
|||
print case [ |
|||
i % 15 = 0 ["FizzBuzz"] |
|||
i % 5 = 0 ["Buzz"] |
|||
i % 3 = 0 ["Fizz"] |
|||
true [i] |
|||
] |
|||
]</syntaxhighlight> |
|||
=={{header|Refal}}== |
|||
<syntaxhighlight lang="refal">$ENTRY Go { |
|||
= <FizzBuzz 1>; |
|||
}; |
|||
FizzBuzz { |
|||
101 = ; |
|||
s.N = <Prout <Item s.N>> |
|||
<FizzBuzz <+ 1 s.N>>; |
|||
}; |
|||
Item { |
|||
s.N, <Mod s.N 15>: 0 = FizzBuzz; |
|||
s.N, <Mod s.N 5>: 0 = Buzz; |
|||
s.N, <Mod s.N 3>: 0 = Fizz; |
|||
s.N = s.N; |
|||
};</syntaxhighlight> |
|||
=={{header|Retro}}== |
|||
This is a port of some [http://weblog.raganwald.com/2007/01/dont-overthink-fizzbuzz.html Forth code]. |
|||
<syntaxhighlight 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 ;</syntaxhighlight> |
|||
It's cleaner to use quotes and combinators though: |
|||
<syntaxhighlight 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 ;</syntaxhighlight> |
|||
=={{header|REXX}}== |
|||
This version's program logic closely mirrors the problem statement: |
|||
===three IF-THEN=== |
|||
<syntaxhighlight lang="rexx">/*REXX program displays numbers 1 ──► 100 (some transformed) for the FizzBuzz problem.*/ |
|||
/*╔═══════════════════════════════════╗*/ |
|||
do j=1 to 100; z= j /*║ ║*/ |
|||
if j//3 ==0 then z= 'Fizz' /*║ The divisors (//) of the IFs ║*/ |
|||
if j//5 ==0 then z= 'Buzz' /*║ must be in ascending order. ║*/ |
|||
if j//(3*5)==0 then z= 'FizzBuzz' /*║ ║*/ |
|||
say right(z, 8) /*╚═══════════════════════════════════╝*/ |
|||
end /*j*/ /*stick a fork in it, we're all done. */</syntaxhighlight> |
|||
'''output''' |
|||
<pre style="height:40ex"> |
|||
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 |
|||
</pre> |
</pre> |
||
== |
===SELECT-WHEN=== |
||
This version is a different form, but essentially identical to the '''IF-THEN''' (above), |
|||
<br>but doesn't require the use of a temporary variable to hold/contain the output. |
|||
<syntaxhighlight lang="rexx">/*REXX program displays numbers 1 ──► 100 (some transformed) for the FizzBuzz problem.*/ |
|||
/*╔═══════════════════════════════════╗*/ |
|||
do j=1 to 100 /*║ ║*/ |
|||
select /*║ ║*/ |
|||
when j//15==0 then say 'FizzBuzz' /*║ The divisors (//) of the WHENs ║*/ |
|||
when j//5 ==0 then say ' Buzz' /*║ must be in descending order. ║*/ |
|||
when j//3 ==0 then say ' Fizz' /*║ ║*/ |
|||
otherwise say right(j, 8) /*╚═══════════════════════════════════╝*/ |
|||
end /*select*/ |
|||
end /*j*/ /*stick a fork in it, we're all done. */</syntaxhighlight> |
|||
'''output''' is identical to the 1<sup>st</sup> REXX version. |
|||
===two IF-THEN=== |
|||
This version lends itself to expansion (such as using '''Jazz''' for multiples of '''7'''). |
|||
<syntaxhighlight lang="rexx">/*REXX program displays numbers 1 ──► 100 (some transformed) for the FizzBuzz problem.*/ |
|||
do j=1 for 100; _= |
|||
if j//3 ==0 then _=_'Fizz' |
|||
if j//5 ==0 then _=_'Buzz' |
|||
/* if j//7 ==0 then _=_'Jazz' */ /* ◄─── note that this is a comment. */ |
|||
say right(word(_ j,1),8) |
|||
end /*j*/ /*stick a fork in it, we're all done. */</syntaxhighlight> |
|||
'''output''' is identical to the 1<sup>st</sup> REXX version. |
|||
==="geek" version=== |
|||
<syntaxhighlight lang="rexx">/*REXX program displays numbers 1 ──► 100 (some transformed) for the FizzBuzz problem.*/ |
|||
/* [↓] concise, but somewhat obtuse. */ |
|||
do j=1 for 100 |
|||
say right(word(word('Fizz', 1+(j//3\==0))word('Buzz', 1+(j//5\==0)) j, 1), 8) |
|||
end /*j*/ |
|||
/*stick a fork in it, we're all done. */</syntaxhighlight> |
|||
'''output''' is identical to the 1<sup>st</sup> REXX version. <br><br> |
|||
=={{header|Rhovas}}== |
|||
Standard FizzBuzz using a pattern matching approach: |
|||
* <code>range(1, 100, :incl)</code> creates an inclusion range |
|||
* <code>.for {</code> iterates through the range, with the current element being <code>val</code> |
|||
* Pattern matching on <code>[val.mod(3), val.mod(5)]</code> is used to check divisibility conditions |
|||
** <code>[0, 0]</code>, for instance, matches when <code>val</code>is divisible by both <code>3</code> and <code>5</code> |
|||
** <code>else</code> matches all other possibilities, in this case when <code>val</code> is not divisible by <code>3</code> or <code>5</code> |
|||
<syntaxhighlight lang="scala"> |
|||
range(1, 100, :incl).for { |
|||
match ([val.mod(3), val.mod(5)]) { |
|||
[0, 0]: print("FizzBuzz"); |
|||
[0, _]: print("Fizz"); |
|||
[_, 0]: print("Buzz"); |
|||
else: print(val); |
|||
} |
|||
}; |
|||
</syntaxhighlight> |
|||
=={{header|Ring}}== |
|||
<syntaxhighlight lang="ring"> |
|||
for n = 1 to 100 |
|||
if n % 15 = 0 see "" + n + " = " + "FizzBuzz" + nl loop |
|||
but n % 3 = 0 see "" + n + " = " + "Fizz"+ nl |
|||
but n % 5 = 0 see "" + n + " = " + "Buzz" + nl |
|||
else see "" + n + " = " + n + nl ok |
|||
next</syntaxhighlight> |
|||
{{out}} |
|||
Limited to first 20. |
|||
<pre> |
<pre> |
||
1 = 1 |
|||
1.upto(100) do |n| |
|||
2 = 2 |
|||
3 = Fizz |
|||
4 = 4 |
|||
5 = Buzz |
|||
6 = Fizz |
|||
7 = 7 |
|||
8 = 8 |
|||
9 = Fizz |
|||
10 = Buzz |
|||
11 = 11 |
|||
12 = Fizz |
|||
13 = 13 |
|||
14 = 14 |
|||
15 = FizzBuzz |
|||
16 = 16 |
|||
17 = 17 |
|||
18 = Fizz |
|||
19 = 19 |
|||
20 = Buzz |
|||
</pre> |
|||
=={{header|Robotic}}== |
|||
<syntaxhighlight lang="robotic"> |
|||
set "local1" to 1 |
|||
: "loop" |
|||
wait for 10 |
|||
if "('local1' % 15)" = 0 then "fizzbuzz" |
|||
if "('local1' % 3)" = 0 then "fizz" |
|||
if "('local1' % 5)" = 0 then "buzz" |
|||
* "&local1&" |
|||
: "inc" |
|||
inc "local1" by 1 |
|||
if "local1" <= 100 then "loop" |
|||
goto "done" |
|||
: "fizzbuzz" |
|||
* "FizzBuzz" |
|||
goto "inc" |
|||
: "fizz" |
|||
* "Fizz" |
|||
goto "inc" |
|||
: "buzz" |
|||
* "Buzz" |
|||
goto "inc" |
|||
: "done" |
|||
end |
|||
</syntaxhighlight> |
|||
The '''wait for 10''' function is not really necessary, but it helps to slow down the output. |
|||
=={{header|Rockstar}}== |
|||
Midnight takes your heart and your soul |
|||
While your heart is as high as your soul |
|||
Put your heart without your soul into your heart |
|||
Give back your heart |
|||
Desire is a lovestruck ladykiller |
|||
My world is nothing |
|||
Fire is ice |
|||
Hate is water |
|||
Until my world is Desire, |
|||
Build my world up |
|||
If Midnight taking my world, Fire is nothing and Midnight taking my world, Hate is nothing |
|||
Shout "FizzBuzz!" |
|||
Take it to the top |
|||
If Midnight taking my world, Fire is nothing |
|||
Shout "Fizz!" |
|||
Take it to the top |
|||
If Midnight taking my world, Hate is nothing |
|||
Say "Buzz!" |
|||
Take it to the top |
|||
Whisper my world |
|||
=={{header|RPG}}== |
|||
<nowiki>**</nowiki>free |
|||
dcl-s ix Int(5); |
|||
for ix = 1 to 100; |
|||
select; |
|||
when %rem(ix:15) = 0; |
|||
dsply 'FizzBuzz'; |
|||
when %rem(ix:5) = 0; |
|||
dsply 'Buzz'; |
|||
when %rem(ix:3) = 0; |
|||
dsply 'Fizz'; |
|||
other; |
|||
dsply (%char(ix)); |
|||
endsl; |
|||
endfor; |
|||
=={{header|RPL}}== |
|||
Structured programming: |
|||
≪ { } 1 100 '''FOR''' j |
|||
'''IF''' j 3 MOD '''THEN''' "" '''ELSE''' "Fizz" '''END''' |
|||
'''IF''' j 5 MOD NOT '''THEN''' "Buzz" + '''END''' |
|||
'''IF''' DUP SIZE NOT '''THEN''' DROP j '''END''' |
|||
+ '''NEXT''' |
|||
≫ ''''FIZZB'''' STO |
|||
Arithmetic: |
|||
≪ { } 1 100 '''FOR''' j |
|||
j 3 MOD NOT j 5 MOD NOT → a b |
|||
≪ '''IF''' a b + '''THEN''' "FizzBuzz" 5 4 a * - a b 2 * MAX 4 * SUB '''ELSE''' j '''END''' |
|||
≫ + '''NEXT''' |
|||
≫ ''''FIZZB'''' STO |
|||
Data-centric: |
|||
≪ "FizzBuzz" { (1,4) (5,8) (1,8) } → fb idx |
|||
≪ { } 1 100 '''FOR''' j |
|||
'''IF''' j 3 MOD NOT j 5 MOD NOT 2 * + '''THEN''' fb idx LAST GET C→R SUB '''ELSE''' j '''END''' |
|||
+ '''NEXT''' |
|||
≫ ≫ ''''FIZZB'''' STO |
|||
Esoteric one-liner: |
|||
≪ ≪ j ROT MOD "" ROT IFTE ≫ → f ≪ { } 1 100 FOR j 3 "Fizz" f EVAL 5 "Buzz" f EVAL + SIZE LAST j IFTE + NEXT ≫ ≫ EVAL |
|||
=={{header|Ruby}}== |
|||
<syntaxhighlight lang="ruby">1.upto(100) do |n| |
|||
print "Fizz" if a = (n % 3).zero? |
print "Fizz" if a = (n % 3).zero? |
||
print "Buzz" if b = (n % 5).zero? |
print "Buzz" if b = (n % 5).zero? |
||
print n unless (a || b) |
print n unless (a || b) |
||
puts |
|||
print "\n" |
|||
end</syntaxhighlight> |
|||
A bit more straightforward: |
|||
<syntaxhighlight lang="ruby">(1..100).each do |n| |
|||
puts if (n % 15).zero? |
|||
"FizzBuzz" |
|||
elsif (n % 5).zero? |
|||
"Buzz" |
|||
elsif (n % 3).zero? |
|||
"Fizz" |
|||
else |
|||
n |
|||
end |
|||
end</syntaxhighlight> |
|||
Enumerable#Lazy and classes: |
|||
We can grab the first n fizz/buzz/fizzbuzz numbers in a list with a user defined function (filter_map), starting at the number we desire |
|||
i.e, grabbing the first 10 fizz numbers starting from 30, fizz = Fizz.new(30,10) #=> [30, 33, 36, 39, 42, 45, 48, 51, 54, 57] |
|||
<syntaxhighlight lang="ruby"> |
|||
class Enumerator::Lazy |
|||
def filter_map |
|||
Lazy.new(self) do |holder, *values| |
|||
result = yield *values |
|||
holder << result if result |
|||
end |
|||
end |
|||
end |
end |
||
</pre> |
|||
class Fizz |
|||
def initialize(head, tail) |
|||
@list = (head..Float::INFINITY).lazy.filter_map{|i| i if i % 3 == 0}.first(tail) |
|||
end |
|||
def fizz?(num) |
|||
search = @list |
|||
search.include?(num) |
|||
end |
|||
def drop(num) |
|||
list = @list |
|||
list.delete(num) |
|||
end |
|||
def to_a |
|||
@list.to_a |
|||
end |
|||
end |
|||
class Buzz |
|||
def initialize(head, tail) |
|||
@list = (head..Float::INFINITY).lazy.filter_map{|i| i if i % 5 == 0}.first(tail) |
|||
end |
|||
def buzz?(num) |
|||
search = @list |
|||
search.include?(num) |
|||
end |
|||
def drop(num) |
|||
list = @list |
|||
list.delete(num) |
|||
end |
|||
def to_a |
|||
@list.to_a |
|||
end |
|||
end |
|||
class FizzBuzz |
|||
def initialize(head, tail) |
|||
@list = (head..Float::INFINITY).lazy.filter_map{|i| i if i % 15 == 0}.first(tail) |
|||
end |
|||
def fizzbuzz?(num) |
|||
search = @list |
|||
search.include?(num) |
|||
end |
|||
def to_a |
|||
@list.to_a |
|||
end |
|||
def drop(num) |
|||
list = @list |
|||
list.delete(num) |
|||
end |
|||
end |
|||
stopper = 100 |
|||
@fizz = Fizz.new(1,100) |
|||
@buzz = Buzz.new(1,100) |
|||
@fizzbuzz = FizzBuzz.new(1,100) |
|||
def min(v, n) |
|||
if v == 1 |
|||
puts "Fizz: #{n}" |
|||
@fizz::drop(n) |
|||
elsif v == 2 |
|||
puts "Buzz: #{n}" |
|||
@buzz::drop(n) |
|||
else |
|||
puts "FizzBuzz: #{n}" |
|||
@fizzbuzz::drop(n) |
|||
end |
|||
end |
|||
(@fizz.to_a & @fizzbuzz.to_a).map{|d| @fizz::drop(d)} |
|||
(@buzz.to_a & @fizzbuzz.to_a).map{|d| @buzz::drop(d)} |
|||
while @fizz.to_a.min < stopper or @buzz.to_a.min < stopper or @fizzbuzz.to_a.min < stopper |
|||
f, b, fb = @fizz.to_a.min, @buzz.to_a.min, @fizzbuzz.to_a.min |
|||
min(1,f) if f < fb and f < b |
|||
min(2,b) if b < f and b < fb |
|||
min(0,fb) if fb < b and fb < f |
|||
end</syntaxhighlight> |
|||
An example using string interpolation: |
|||
<syntaxhighlight lang="ruby">(1..100).each do |n| |
|||
v = "#{"Fizz" if n % 3 == 0}#{"Buzz" if n % 5 == 0}" |
|||
puts v.empty? ? n : v |
|||
end</syntaxhighlight> |
|||
Interpolation inspired one-liner: |
|||
<syntaxhighlight 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}" }</syntaxhighlight> |
|||
An example using append: |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
Yet another solution: |
|||
<syntaxhighlight lang="text">1.upto(100) { |i| puts "#{[:Fizz][i%3]}#{[:Buzz][i%5]}"[/.+/] || i }</syntaxhighlight> |
|||
Yet another solution: |
|||
<syntaxhighlight lang="ruby">1.upto(100){|i|puts'FizzBuzz '[n=i**4%-15,n+13]||i}</syntaxhighlight> |
|||
Used Enumerable#cycle: |
|||
<syntaxhighlight lang="ruby">f = [nil, nil, :Fizz].cycle |
|||
b = [nil, nil, nil, nil, :Buzz].cycle |
|||
(1..100).each do |i| |
|||
puts "#{f.next}#{b.next}"[/.+/] || i |
|||
end</syntaxhighlight> |
|||
After beforehand preparing the Array which put the number from 1 to 100, it processes. |
|||
<syntaxhighlight lang="ruby">seq = *0..100 |
|||
{Fizz:3, Buzz:5, FizzBuzz:15}.each{|k,n| n.step(100,n){|i|seq[i]=k}} |
|||
puts seq.drop(1)</syntaxhighlight> |
|||
Monkeypatch example: |
|||
<syntaxhighlight 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)</syntaxhighlight> |
|||
Without mutable variables or inline printing. |
|||
<syntaxhighlight 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")</syntaxhighlight> |
|||
[[Jump anywhere#Ruby]] has a worse example of FizzBuzz, using a continuation! |
|||
Using Ruby 3's Pattern Matching: |
|||
<syntaxhighlight lang="ruby"> |
|||
1.upto(100) do |n| |
|||
puts case [(n % 3).zero?, (n % 5).zero?] |
|||
in true, false |
|||
"Fizz" |
|||
in false, true |
|||
"Buzz" |
|||
in true, true |
|||
"FizzBuzz" |
|||
else |
|||
n |
|||
end |
|||
end |
|||
</syntaxhighlight> |
|||
=={{header|Ruby with RSpec}}== |
|||
This is a solution to FizzBuzz using Test-Driven Development (In this case, with Ruby and RSpec). You will need to set up the correct file structure first, with /lib and /spec directories in your root. |
|||
Your spec/fizzbuzz_spec.rb file should like this: |
|||
<syntaxhighlight lang="ruby"> |
|||
require 'fizzbuzz' |
|||
describe 'FizzBuzz' do |
|||
context 'knows that a number is divisible by' do |
|||
it '3' do |
|||
expect(is_divisible_by_three?(3)).to be_true |
|||
end |
|||
it '5' do |
|||
expect(is_divisible_by_five?(5)).to be_true |
|||
end |
|||
it '15' do |
|||
expect(is_divisible_by_fifteen?(15)).to be_true |
|||
end |
|||
end |
|||
context 'knows that a number is not divisible by' do |
|||
it '3' do |
|||
expect(is_divisible_by_three?(1)).not_to be_true |
|||
end |
|||
it '5' do |
|||
expect(is_divisible_by_five?(1)).not_to be_true |
|||
end |
|||
it '15' do |
|||
expect(is_divisible_by_fifteen?(1)).not_to be_true |
|||
end |
|||
end |
|||
context 'while playing the game it returns' do |
|||
it 'the number' do |
|||
expect(fizzbuzz(1)).to eq 1 |
|||
end |
|||
it 'Fizz' do |
|||
expect(fizzbuzz(3)).to eq 'Fizz' |
|||
end |
|||
it 'Buzz' do |
|||
expect(fizzbuzz(5)).to eq 'Buzz' |
|||
end |
|||
it 'FizzBuzz' do |
|||
expect(fizzbuzz(15)).to eq 'FizzBuzz' |
|||
end |
|||
end |
|||
end |
|||
</syntaxhighlight> |
|||
There are many ways to get these tests to pass. Here is an example solution of what your lib/fizzbuzz.rb file could look like: |
|||
<syntaxhighlight lang="ruby"> |
|||
def fizzbuzz(number) |
|||
return 'FizzBuzz' if is_divisible_by_fifteen?(number) |
|||
return 'Buzz' if is_divisible_by_five?(number) |
|||
return 'Fizz' if is_divisible_by_three?(number) |
|||
number |
|||
end |
|||
def is_divisible_by_three?(number) |
|||
is_divisible_by(number, 3) |
|||
end |
|||
def is_divisible_by_five?(number) |
|||
is_divisible_by(number, 5) |
|||
end |
|||
def is_divisible_by_fifteen?(number) |
|||
is_divisible_by(number, 15) |
|||
end |
|||
def is_divisible_by(number, divisor) |
|||
number % divisor == 0 |
|||
end |
|||
</syntaxhighlight> |
|||
When writing Test Driven code, it's important to remember that you should use the Red, Green, Refactor cycle. Simply writing each of these code snippets independently would go against everything TDD is about. Here is a good video that takes you through the process of writing this [https://www.youtube.com/watch?v=CHTep2zQVAc&feature=youtu.be FizzBuzz implementation using Ruby & RSpec]. |
|||
=={{header|Run BASIC}}== |
|||
See [[FizzBuzz/Basic]] |
|||
=={{header|Rust}}== |
|||
Basic example with a for loop and match: |
|||
<syntaxhighlight lang="rust">fn main() { |
|||
for i in 1..=100 { |
|||
match (i % 3, i % 5) { |
|||
(0, 0) => println!("fizzbuzz"), |
|||
(0, _) => println!("fizz"), |
|||
(_, 0) => println!("buzz"), |
|||
(_, _) => println!("{}", i), |
|||
} |
|||
} |
|||
}</syntaxhighlight> |
|||
Using an iterator and immutable data: |
|||
<syntaxhighlight lang="rust">use std::borrow::Cow; |
|||
fn main() { |
|||
(1..=100) |
|||
.map(|n| match (n % 3, n % 5) { |
|||
(0, 0) => "FizzBuzz".into(), |
|||
(0, _) => "Fizz".into(), |
|||
(_, 0) => "Buzz".into(), |
|||
_ => Cow::from(n.to_string()), |
|||
}) |
|||
.for_each(|n| println!("{:?}", n)); |
|||
} |
|||
</syntaxhighlight> |
|||
A folding iterator version, buffered with a single string allocation, by making use of expressions the <code>write!</code> macro. |
|||
<syntaxhighlight lang="rust">use std::fmt::Write; |
|||
fn fizzbuzz() -> String { |
|||
(1..=100).fold(String::new(), |mut output, x| { |
|||
let fizz = if x % 3 == 0 { "fizz" } else { "" }; |
|||
let buzz = if x % 5 == 0 { "buzz" } else { "" }; |
|||
if fizz.len() + buzz.len() != 0 { |
|||
output + fizz + buzz + "\n" |
|||
} else { |
|||
write!(&mut output, "{}", x).unwrap(); |
|||
output + "\n" |
|||
} |
|||
}) |
|||
} |
|||
fn main() { |
|||
println!("{}", fizzbuzz()); |
|||
}</syntaxhighlight> |
|||
Or the ultimate optimized version with hardcoded output, no standard library or main function, and direct assembly syscalls to write to stdout. |
|||
<syntaxhighlight lang="rust">#![no_std] |
|||
#![feature(asm, lang_items, libc, no_std, start)] |
|||
extern crate libc; |
|||
const LEN: usize = 413; |
|||
static OUT: [u8; LEN] = *b"\ |
|||
1\n2\nFizz\n4\nBuzz\nFizz\n7\n8\nFizz\nBuzz\n11\nFizz\n13\n14\nFizzBuzz\n\ |
|||
16\n17\nFizz\n19\nBuzz\nFizz\n22\n23\nFizz\nBuzz\n26\nFizz\n28\n29\nFizzBuzz\n\ |
|||
31\n32\nFizz\n34\nBuzz\nFizz\n37\n38\nFizz\nBuzz\n41\nFizz\n43\n44\nFizzBuzz\n\ |
|||
46\n47\nFizz\n49\nBuzz\nFizz\n52\n53\nFizz\nBuzz\n56\nFizz\n58\n59\nFizzBuzz\n\ |
|||
61\n62\nFizz\n64\nBuzz\nFizz\n67\n68\nFizz\nBuzz\n71\nFizz\n73\n74\nFizzBuzz\n\ |
|||
76\n77\nFizz\n79\nBuzz\nFizz\n82\n83\nFizz\nBuzz\n86\nFizz\n88\n89\nFizzBuzz\n\ |
|||
91\n92\nFizz\n94\nBuzz\nFizz\n97\n98\nFizz\nBuzz\n"; |
|||
#[start] |
|||
fn start(_argc: isize, _argv: *const *const u8) -> isize { |
|||
unsafe { |
|||
asm!( |
|||
" |
|||
mov $$1, %rax |
|||
mov $$1, %rdi |
|||
mov $0, %rsi |
|||
mov $1, %rdx |
|||
syscall |
|||
" |
|||
: |
|||
: "r" (&OUT[0]) "r" (LEN) |
|||
: "rax", "rdi", "rsi", "rdx" |
|||
: |
|||
); |
|||
} |
|||
0 |
|||
} |
|||
#[lang = "eh_personality"] extern fn eh_personality() {} |
|||
#[lang = "panic_fmt"] extern fn panic_fmt() {}</syntaxhighlight> |
|||
=={{header|Salmon}}== |
|||
<syntaxhighlight lang="salmon">iterate (x; [1...100]) |
|||
((x % 15 == 0) ? "FizzBuzz" : |
|||
((x % 3 == 0) ? "Fizz" : |
|||
((x % 5 == 0) ? "Buzz" : x)))!;</syntaxhighlight> |
|||
or |
|||
<syntaxhighlight 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!; |
|||
};</syntaxhighlight> |
|||
=={{header|SAS}}== |
|||
<syntaxhighlight lang="sas">data _null_; |
|||
do i=1 to 100; |
|||
if mod(i,15)=0 then put "FizzBuzz"; |
|||
else if mod(i,5)=0 then put "Buzz"; |
|||
else if mod(i,3)=0 then put "Fizz"; |
|||
else put i; |
|||
end; |
|||
run;</syntaxhighlight> |
|||
=={{header|Sather}}== |
|||
<syntaxhighlight 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;</syntaxhighlight> |
|||
=={{header|Scala}}== |
|||
{{libheader|Scala}} |
|||
===Idiomatic scala code=== |
|||
<syntaxhighlight lang="scala">object FizzBuzz extends App { |
|||
1 to 100 foreach { n => |
|||
println((n % 3, n % 5) match { |
|||
case (0, 0) => "FizzBuzz" |
|||
case (0, _) => "Fizz" |
|||
case (_, 0) => "Buzz" |
|||
case _ => n |
|||
}) |
|||
} |
|||
}</syntaxhighlight> |
|||
===Geeky over-generalized solution ☺=== |
|||
<syntaxhighlight lang="scala">def replaceMultiples(x: Int, rs: (Int, String)*): Either[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 = replaceMultiples(_: Int, 3 -> "Fizz", 5 -> "Buzz") fold(_.toString, identity) |
|||
1 to 100 map fizzbuzz foreach println</syntaxhighlight> |
|||
===By a two-liners geek=== |
|||
<syntaxhighlight lang="scala">def f(n: Int, div: Int, met: String, notMet: String): String = if (n % div == 0) met else notMet |
|||
for (i <- 1 to 100) println(f(i, 15, "FizzBuzz", f(i, 3, "Fizz", f(i, 5, "Buzz", i.toString))))</syntaxhighlight> |
|||
===One-liner geek=== |
|||
<syntaxhighlight lang="scala">for (i <- 1 to 100) println(Seq(15 -> "FizzBuzz", 3 -> "Fizz", 5 -> "Buzz").find(i % _._1 == 0).map(_._2).getOrElse(i))</syntaxhighlight> |
|||
===Functional Scala=== |
|||
<syntaxhighlight lang="scala">def fizzBuzzTerm(n: Int): String = |
|||
if (n % 15 == 0) "FizzBuzz" |
|||
else if (n % 3 == 0) "Fizz" |
|||
else if (n % 5 == 0) "Buzz" |
|||
else n.toString |
|||
def fizzBuzz(): Unit = LazyList.from(1).take(100).map(fizzBuzzTerm).foreach(println)</syntaxhighlight> |
|||
===Scala 3 (Dotty)=== |
|||
Written so as to introduce changes, with comments. |
|||
<syntaxhighlight lang="scala">def fizzBuzzTerm(n: Int): String | Int = // union types |
|||
(n % 3, n % 5) match // optional semantic indentation; no braces |
|||
case (0, 0) => "FizzBuzz" |
|||
case (0, _) => "Fizz" |
|||
case (_, 0) => "Buzz" |
|||
case _ => n // no need for `.toString`, thanks to union type |
|||
end match // optional `end` keyword, with what it's ending |
|||
end fizzBuzzTerm // `end` also usable for identifiers |
|||
val fizzBuzz = // no namespace object is required; all top level |
|||
LazyList.from(1).map(fizzBuzzTerm) |
|||
@main def run(): Unit = // @main for main method; can take custom args |
|||
fizzBuzz.take(100).foreach(println)</syntaxhighlight> |
|||
=={{header|Scheme}}== |
=={{header|Scheme}}== |
||
<scheme>(do ((i 1 (+ i 1))) |
<syntaxhighlight lang="scheme">(do ((i 1 (+ i 1))) |
||
((> i 100)) |
((> i 100)) |
||
(display |
(display |
||
Line 627: | Line 10,627: | ||
((= 0 (modulo i 5)) "Buzz") |
((= 0 (modulo i 5)) "Buzz") |
||
(else i))) |
(else i))) |
||
(newline))</ |
(newline))</syntaxhighlight> |
||
=={{header|Seed7}}== |
|||
Using a recursive procedure. |
|||
<pre> |
|||
<syntaxhighlight lang="scheme">(define (fizzbuzz x y) |
|||
$ include "seed7_05.s7i"; |
|||
(println |
|||
(cond (( = (modulo x 15) 0 ) "FizzBuzz") |
|||
(( = (modulo x 3) 0 ) "Fizz") |
|||
(( = (modulo x 5) 0 ) "Buzz") |
|||
(else x))) |
|||
(if (< x y) (fizzbuzz (+ x 1) y))) |
|||
(fizzbuzz 1 100)</syntaxhighlight> |
|||
Approach with maps and filters, easier to change, less readable |
|||
than the previous. |
|||
<syntaxhighlight lang="scheme">(define (fizzbuzz x) |
|||
(let ([words '((3 . "Fizz") |
|||
(5 . "Buzz"))]) |
|||
(define (fbm x) |
|||
(let ([w (map cdr (filter (lambda (wo) (= 0 (modulo x (car wo)))) words))]) |
|||
(if (null? w) x (apply string-append w)))) |
|||
(for-each (cut format #t "~a~%" <>) (map fbm (iota x 1 1))))) |
|||
(fizzbuzz 15) |
|||
</syntaxhighlight> |
|||
=={{header|Sed}}== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
Using <tt>seq</tt>: |
|||
<syntaxhighlight lang="sed"> |
|||
seq 100 | sed '/.*[05]$/s//Buzz/;n;s//Buzz/;n;s//Buzz/;s/^[0-9]*/Fizz/' |
|||
</syntaxhighlight> |
|||
=== GNU sed === |
|||
GNU sed has ''first~step'' address expression that matches every ''step''th line. This makes following one-liners possible. |
|||
Using <tt>seq</tt>: |
|||
<syntaxhighlight lang="sed"> |
|||
seq 100 | sed '0~3 s/.*/Fizz/; 0~5 s/[0-9]*$/Buzz/' |
|||
</syntaxhighlight> |
|||
Using <tt>yes</tt>: |
|||
<syntaxhighlight lang="sed"> |
|||
yes | sed -n '0~3s/y/Fizz/;0~5s/y*$/Buzz/;tx;=;b;:x;p;100q' |
|||
</syntaxhighlight> |
|||
Using the option ''-z (--zero-data)'' first introduced in GNU sed 4.2.2 (2012-12-22): |
|||
<syntaxhighlight lang="sed"> |
|||
sed -nz '0~3s/^/Fizz/;0~5s/$/Buzz/;tx;=;b;:x;p;100q' /dev/zero | sed 'y/\c@/\n/' |
|||
</syntaxhighlight> |
|||
Second invocation of ''sed'' translates null characters to newlines. The same could be achieved with <tt>tr \\0 \\n</tt> |
|||
=={{header|Seed7}}== |
|||
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i"; |
|||
const proc: main is func |
const proc: main is func |
||
Line 649: | Line 10,740: | ||
end if; |
end if; |
||
end for; |
end for; |
||
end func; |
end func;</syntaxhighlight> |
||
</pre> |
|||
=={{header| |
=={{header|SenseTalk}}== |
||
<syntaxhighlight lang="sensetalk">repeat 100 |
|||
put "" into output |
|||
if the counter is a multiple of 3 then |
|||
put "Fizz" after output |
|||
end if |
|||
if the counter is a multiple of 5 then |
|||
put "Buzz" after output |
|||
end if |
|||
if output is empty then |
|||
put the counter into output |
|||
end if |
|||
put output |
|||
end repeat</syntaxhighlight> |
|||
=={{header|SETL}}== |
|||
<syntaxhighlight lang="setl">program fizzbuzz; |
|||
loop for n in [1..100] do |
|||
print(fizzbuzz(n)); |
|||
end loop; |
|||
proc fizzbuzz(n); |
|||
divs := [[3, "Fizz"], [5, "Buzz"]]; |
|||
return +/[w : [d,w] in divs | n mod d=0] ? str n; |
|||
end proc; |
|||
end program;</syntaxhighlight> |
|||
=={{header|SequenceL}}== |
|||
<syntaxhighlight lang="sequencel">import <Utilities/Conversion.sl>; |
|||
import <Utilities/Sequence.sl>; |
|||
main(args(2)) := |
|||
let |
|||
result[i] := |
|||
"FizzBuzz" when i mod 3 = 0 and i mod 5 = 0 |
|||
else |
|||
"Fizz" when i mod 3 = 0 |
|||
else |
|||
"Buzz" when i mod 5 = 0 |
|||
else |
|||
intToString(i) |
|||
foreach i within 1 ... 100; |
|||
in |
|||
delimit(result, '\n');</syntaxhighlight> |
|||
=={{header|Shale}}== |
|||
<syntaxhighlight lang="shale">#!/usr/local/bin/shale |
|||
string library |
|||
r var |
|||
i var |
|||
i 1 = |
|||
{ i 100 <= } { |
|||
r "" = |
|||
i 3 % 0 == { r r "fizz" concat string::() = } ifthen |
|||
i 5 % 0 == { r r "buzz" concat string::() = } ifthen |
|||
r "" equals string::() { i } { r } if i "%3d: %p\n" printf |
|||
i++ |
|||
} while</syntaxhighlight> |
|||
=={{header|Shen}}== |
|||
<syntaxhighlight lang="shen">(define fizzbuzz |
|||
101 -> (nl) |
|||
N -> (let divisible-by? (/. A B (integer? (/ A B))) |
|||
(cases (divisible-by? N 15) (do (output "Fizzbuzz!~%") |
|||
(fizzbuzz (+ N 1))) |
|||
(divisible-by? N 3) (do (output "Fizz!~%") |
|||
(fizzbuzz (+ N 1))) |
|||
(divisible-by? N 5) (do (output "Buzz!~%") |
|||
(fizzbuzz (+ N 1))) |
|||
true (do (output (str N)) |
|||
(nl) |
|||
(fizzbuzz (+ N 1)))))) |
|||
(fizzbuzz 1)</syntaxhighlight> |
|||
=== Alternative showing off other features like prolog integration and guards === |
|||
<syntaxhighlight lang="shen">(defprolog fizz |
|||
0 <-- (is _ (output "Fizz")); |
|||
N <-- (when (> N 0)) (is N1 (- N 3)) (fizz N1); |
|||
) |
|||
(defprolog buzz |
|||
0 <-- (is _ (output "Buzz")); |
|||
N <-- (when (> N 0)) (is N1 (- N 5)) (buzz N1); |
|||
) |
|||
(define none |
|||
[] -> true |
|||
[true | _] -> false |
|||
[_ | B] -> (none B) |
|||
) |
|||
(define fizzbuzz |
|||
N M -> (nl) where (> N M) |
|||
N M -> (do |
|||
(if (none [(prolog? (receive N) (fizz N)) (prolog? (receive N) (buzz N))]) |
|||
(output (str N)) |
|||
(output "!") |
|||
) |
|||
(nl) |
|||
(fizzbuzz (+ N 1) M) |
|||
) |
|||
) |
|||
(fizzbuzz 1 100) |
|||
</syntaxhighlight> |
|||
=={{header|Sidef}}== |
|||
Structured: |
|||
<syntaxhighlight lang="perl">{ |i| |
|||
if (i %% 3) { |
|||
print "Fizz" |
|||
i %% 5 && print "Buzz" |
|||
print "\n" |
|||
} |
|||
elsif (i %% 5) { say "Buzz" } |
|||
else { say i } |
|||
} << 1..100</syntaxhighlight> |
|||
Declarative: |
|||
<syntaxhighlight lang="perl">func fizzbuzz({ _ %% 15 }) { "FizzBuzz" } |
|||
func fizzbuzz({ _ %% 5 }) { "Buzz" } |
|||
func fizzbuzz({ _ %% 3 }) { "Fizz" } |
|||
func fizzbuzz( n ) { n } |
|||
for n in (1..100) { say fizzbuzz(n) }</syntaxhighlight> |
|||
One-liner: |
|||
<syntaxhighlight lang="ruby">{>"#{<Fizz>[.%3]}#{<Buzz>[.%5]}"||_}<<1..100</syntaxhighlight> |
|||
=={{header|Simula}}== |
|||
<syntaxhighlight lang="simula">begin |
|||
integer i; |
|||
for i := 1 step 1 until 100 do |
|||
begin |
|||
boolean fizzed; |
|||
fizzed := 0 = mod(i, 3); |
|||
if fizzed then |
|||
outtext("Fizz"); |
|||
if mod(i, 5) = 0 then |
|||
outtext("Buzz") |
|||
else if not fizzed then |
|||
outint(i, 3); |
|||
outimage |
|||
end; |
|||
end</syntaxhighlight> |
|||
=={{header|SkookumScript}}== |
|||
Answer by printing out one of the 4 alternatives: |
|||
<syntaxhighlight lang="javascript"> |
|||
1.to 100 |
|||
[ |
|||
println( |
|||
if idx.mod(15) = 0 ["FizzBuzz"] |
|||
idx.mod(3) = 0 ["Fizz"] |
|||
idx.mod(5) = 0 ["Buzz"] |
|||
else [idx]) |
|||
] |
|||
</syntaxhighlight> |
|||
Answer by building up a string: |
|||
<syntaxhighlight lang="javascript"> |
|||
1.to 100 |
|||
[ |
|||
!str: "" |
|||
if idx.mod(3) = 0 [str += "Fizz"] |
|||
if idx.mod(5) = 0 [str += "Buzz"] |
|||
println(if str.empty? [idx] else [str]) |
|||
] |
|||
</syntaxhighlight> |
|||
Or doing initial bind in one step: |
|||
<syntaxhighlight lang="javascript"> |
|||
1.to 100 |
|||
[ |
|||
!str: if idx.mod(3) = 0 ["Fizz"] else [""] |
|||
if idx.mod(5) = 0 [str += "Buzz"] |
|||
println(if str.empty? [idx] else [str]) |
|||
] |
|||
</syntaxhighlight> |
|||
=={{header|Slate}}== |
|||
<syntaxhighlight 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]</syntaxhighlight> |
|||
=={{header|Slope}}== |
|||
<syntaxhighlight lang="scheme"> |
|||
(define fizz-buzz |
|||
(lambda (x) |
|||
(define ret "") |
|||
(if (zero? (% x 3))(set! ret (append ret "fizz"))) |
|||
(if (zero? (% x 5))(set! ret (append ret "buzz"))) |
|||
(if (equal? ret "") (set! ret (append ret x))) |
|||
ret)) |
|||
(apply display-lines (list-join (map fizz-buzz (range 100 1)))) |
|||
</syntaxhighlight> |
|||
=={{header|Small}}== |
|||
See [[FizzBuzz/EsoLang]] |
|||
=={{header|SmallBASIC}}== |
|||
See [[FizzBuzz/Basic]] |
|||
=={{header|Smalltalk}}== |
|||
Since only GNU Smalltalk supports file-based programming, we'll be using its syntax. |
Since only GNU Smalltalk supports file-based programming, we'll be using its syntax. |
||
<syntaxhighlight 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 ]</syntaxhighlight> |
|||
A Squeak/Pharo example using the Transcript window: |
|||
<syntaxhighlight 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.]</syntaxhighlight> |
|||
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. |
|||
<syntaxhighlight lang="smalltalk">fizzbuzz := Dictionary with: #(true true)->'FizzBuzz' |
|||
with: #(true false)->'Fizz' |
|||
with: #(false true)->'Buzz'. |
|||
1 to: 100 do: |
|||
Integer extend [ |
|||
[ :i | Transcript show: |
|||
fizzbuzz [ |
|||
(fizzbuzz at: {i isDivisibleBy: 3. i isDivisibleBy: 5} |
|||
| fb | |
|||
ifAbsent: [ i ]); cr]</syntaxhighlight> |
|||
fb := '%<Fizz|>1%<Buzz|>2' % { |
|||
Smalltalk does not have a case-select construct, but a similar effect can be attained using a collection and the #includes: method: |
|||
self \\ 3 == 0. self \\ 5 == 0 }. |
|||
<syntaxhighlight lang="smalltalk">1 to: 100 do: [:n | |r| |
|||
^fb isEmpty ifTrue: [ self ] ifFalse: [ fb ] |
|||
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].</syntaxhighlight> |
|||
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): |
|||
<syntaxhighlight 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].</syntaxhighlight> |
|||
The approach building a dynamic string can be done as well: |
|||
<syntaxhighlight 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].</syntaxhighlight> |
|||
=={{header| |
=={{header|SNOBOL4}}== |
||
Merely posting a solution by Daniel Lyons |
|||
[fizzbuzz |
|||
<syntaxhighlight lang="snobol4"> I = 1 |
|||
1 [>=] [ |
|||
LOOP FIZZBUZZ = "" |
|||
[[15 % zero?] ['fizzbuzz' puts] |
|||
EQ(REMDR(I, 3), 0) :F(TRY_5) |
|||
[5 % zero?] ['buzz' puts] |
|||
FIZZBUZZ = FIZZBUZZ "FIZZ" |
|||
TRY_5 EQ(REMDR(I, 5), 0) :F(DO_NUM) |
|||
[true] [dup puts] |
|||
FIZZBUZZ = FIZZBUZZ "BUZZ" |
|||
] when succ |
|||
DO_NUM IDENT(FIZZBUZZ, "") :F(SHOW) |
|||
] while]. |
|||
FIZZBUZZ = I |
|||
SHOW OUTPUT = FIZZBUZZ |
|||
I = I + 1 |
|||
LE(I, 100) :S(LOOP) |
|||
END</syntaxhighlight> |
|||
=={{header|SNUSP}}== |
|||
|100 fizzbuzz |
|||
See [[FizzBuzz/EsoLang]] |
|||
=={{header|SparForte}}== |
|||
As a structured script. |
|||
<syntaxhighlight lang="ada">#!/usr/local/bin/spar |
|||
pragma annotate( summary, "fizzbuzz" ); |
|||
pragma annotate( description, "Write a program that prints the numbers from 1 to 100. But for multiples of" ); |
|||
pragma annotate( description, "three print 'Fizz' instead of the number and for the multiples of five print" ); |
|||
pragma annotate( description, "'Buzz'. For numbers which are multiples of both three and five print" ); |
|||
pragma annotate( description, "'FizzBuzz'" ); |
|||
pragma annotate( see_also, "http://rosettacode.org/wiki/FizzBuzz" ); |
|||
pragma annotate( author, "Ken O. Burtch" ); |
|||
pragma license( unrestricted ); |
|||
pragma restriction( no_external_commands ); |
|||
procedure fizzbuzz is |
|||
begin |
|||
for i in 1..100 loop |
|||
if i mod 15 = 0 then |
|||
? "FizzBuzz"; |
|||
elsif i mod 5 = 0 then |
|||
? "Buzz"; |
|||
elsif i mod 3 = 0 then |
|||
? "Fizz"; |
|||
else |
|||
? i; |
|||
end if; |
|||
end loop; |
|||
end fizzbuzz;</syntaxhighlight> |
|||
=={{header|SQL}}== |
|||
{{libheader|SQL}} |
|||
===Oracle SQL=== |
|||
<syntaxhighlight lang="sql">SELECT CASE |
|||
WHEN MOD(level,15)=0 THEN 'FizzBuzz' |
|||
WHEN MOD(level,3)=0 THEN 'Fizz' |
|||
WHEN MOD(level,5)=0 THEN 'Buzz' |
|||
ELSE TO_CHAR(level) |
|||
END FizzBuzz |
|||
FROM dual |
|||
CONNECT BY LEVEL <= 100;</syntaxhighlight> |
|||
Or using Oracle's DECODE and NVL: |
|||
<syntaxhighlight lang="sql">SELECT nvl(decode(MOD(level,3),0,'Fizz')||decode(MOD(level,5),0,'Buzz'),level) |
|||
FROM dual |
|||
CONNECT BY level<=100;</syntaxhighlight> |
|||
===PostgreSQL specific=== |
|||
<syntaxhighlight 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;</syntaxhighlight> |
|||
Using Generate_Series and tables only: |
|||
<syntaxhighlight lang="sql">SELECT COALESCE(FIZZ || BUZZ, FIZZ, BUZZ, OUTPUT) AS FIZZBUZZ FROM |
|||
(SELECT GENERATE_SERIES AS FULL_SERIES, TO_CHAR(GENERATE_SERIES,'99') AS OUTPUT |
|||
FROM GENERATE_SERIES(1,100)) F LEFT JOIN |
|||
(SELECT TEXT 'Fizz' AS FIZZ, GENERATE_SERIES AS FIZZ_SERIES FROM GENERATE_SERIES(0,100,3)) FIZZ ON |
|||
FIZZ.FIZZ_SERIES = F.FULL_SERIES LEFT JOIN |
|||
(SELECT TEXT 'Buzz' AS BUZZ, GENERATE_SERIES AS BUZZ_SERIES FROM GENERATE_SERIES(0,100,5)) BUZZ ON |
|||
BUZZ.BUZZ_SERIES = F.FULL_SERIES;</syntaxhighlight> |
|||
===Recursive Common Table Expressions (MSSQL 2005+)=== |
|||
<syntaxhighlight 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 )</syntaxhighlight> |
|||
===SQL Anywhere specific - minimalist=== |
|||
<syntaxhighlight lang="sql">SELECT |
|||
isnull(if row_num % 3 = 0 then 'Fizz' endif + if row_num % 5 = 0 then 'Buzz' endif, str(row_num)) |
|||
FROM |
|||
sa_rowgenerator(1,100)</syntaxhighlight> |
|||
===Generic SQL using a join=== |
|||
This should work in most RDBMSs, but you may need to change <tt>MOD(i,divisor)</tt> to <tt>i % divisor</tt>. |
|||
<syntaxhighlight 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;</syntaxhighlight> |
|||
=={{header|Squirrel}}== |
|||
<syntaxhighlight 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);</syntaxhighlight> |
|||
=={{header|Stata}}== |
|||
<syntaxhighlight lang="stata">program define fizzbuzz |
|||
args n |
|||
forvalues i = 1/`n' { |
|||
if mod(`i',15) == 0 { |
|||
display "FizzBuzz" |
|||
} |
|||
else if mod(`i',5) == 0 { |
|||
display "Buzz" |
|||
} |
|||
else if mod(`i',3) == 0 { |
|||
display "Fizz" |
|||
} |
|||
else { |
|||
display `i' |
|||
} |
|||
} |
|||
end</syntaxhighlight> |
|||
=={{header|Swahili}}== |
|||
<syntaxhighlight lang="swahili"> |
|||
shughuli fizzBuzz() { |
|||
kwa i = 1 mpaka 100 { |
|||
kama (i % 15 == 0) { |
|||
andika("FizzBuzz") |
|||
} au (i % 5 == 0) { |
|||
andika("Buzz") |
|||
} au (i % 3 == 0) { |
|||
andika("Fizz") |
|||
} sivyo { |
|||
andika(i) |
|||
} |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|Swift}}== |
|||
=== using a switch statement === |
|||
<syntaxhighlight lang="swift">for i in 1...100 { |
|||
switch (i % 3, i % 5) { |
|||
case (0, 0): |
|||
print("FizzBuzz") |
|||
case (0, _): |
|||
print("Fizz") |
|||
case (_, 0): |
|||
print("Buzz") |
|||
default: |
|||
print(i) |
|||
} |
|||
}</syntaxhighlight> |
|||
=== using two if statements and an Optional === |
|||
<syntaxhighlight lang="swift">for i in 1...100{ |
|||
var s:String? |
|||
if i%3==0{s="Fizz"} |
|||
if i%5==0{s=(s ?? "")+"Buzz"} |
|||
print(s ?? i) |
|||
}</syntaxhighlight> |
|||
=== using a precomputed cycle === |
|||
<syntaxhighlight lang="swift"> |
|||
import Foundation |
|||
let formats: [String] = [ |
|||
"%d", |
|||
"%d", |
|||
"fizz", |
|||
"%d", |
|||
"buzz", |
|||
"fizz", |
|||
"%d", |
|||
"%d", |
|||
"fizz", |
|||
"buzz", |
|||
"%d", |
|||
"fizz", |
|||
"%d", |
|||
"%d", |
|||
"fizzbuzz", |
|||
] |
|||
var count = 0 |
|||
var index = 0 |
|||
while count < 100 { |
|||
count += 1 |
|||
print(String(format: formats[index], count)) |
|||
index += 1 |
|||
index %= 15 |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|Symstatic}}== |
|||
<syntaxhighlight lang="symstatic">let fizzBuzz(n) := |
|||
let fb(0, 0) := "fizzbuzz" |
|||
let fb(0, _) := "fizz" |
|||
let fb(_, 0) := "buzz" |
|||
let fb(_, _) := n |
|||
fb(n % 3, n % 5) |
|||
for i in 1..101: println(fizzBuzz(i)) |
|||
</syntaxhighlight> |
|||
=={{header|Symsyn}}== |
|||
<syntaxhighlight lang="symsyn"> |
|||
| FizzBuzz |
|||
1 I |
|||
if I LE 100 |
|||
mod I 3 X |
|||
mod I 5 Y |
|||
if X EQ 0 |
|||
'FIZZ' $S |
|||
if Y EQ 0 |
|||
+ 'BUZZ' $S |
|||
endif |
|||
else |
|||
if Y EQ 0 |
|||
'BUZZ' $S |
|||
else |
|||
~ I $S |
|||
endif |
|||
endif |
|||
$S [] |
|||
+ I |
|||
goif |
|||
endif |
|||
</syntaxhighlight> |
|||
=={{header|Tailspin}}== |
|||
<syntaxhighlight lang="tailspin"> |
|||
templates fizz |
|||
$ mod 3 -> # |
|||
when <=0> do 'Fizz' ! |
|||
end fizz |
|||
templates buzz |
|||
$ mod 5 -> # |
|||
when <=0> do 'Buzz' ! |
|||
end buzz |
|||
[ 1..100 -> '$->fizz;$->buzz;' ] -> \[i](when <=''> do $i ! otherwise $ !\)... -> '$; |
|||
' -> !OUT::write |
|||
</syntaxhighlight> |
|||
=={{header|tbas}}== |
|||
See [[FizzBuzz/Basic]] |
|||
=={{header|Tcl}}== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
The following example shows Tcl's substitution mechanism that allows to concatenate the results of two successive commands into a string: |
|||
<syntaxhighlight 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} |
|||
}</syntaxhighlight> |
|||
This version uses list rotation, so avoiding an explicit mod operation: |
|||
<syntaxhighlight lang="tcl">set f [lrepeat 5 "Fizz" {$i} {$i}] |
|||
foreach i {5 10} {lset f $i "Buzz"};lset f 0 "FizzBuzz" |
|||
for {set i 1} {$i <= 100} {incr i} { |
|||
puts [subst [lindex [set f [list {*}[lassign $f ff] $ff]] 0]] |
|||
}</syntaxhighlight> |
|||
=={{header|TI SR-56}}== |
|||
{| class="wikitable" |
|||
|+ Texas Instruments SR-56 Program Listing for "Fizzbuzz" |
|||
|- |
|||
! Display !! Key !! Display !! Key !! Display !! Key !! Display !! Key |
|||
|- |
|||
| 00 22 || GTO || 25 64 || x || 50 03 || 3 || 75 || |
|||
|- |
|||
| 01 03 || 3 || 26 52 || ( || 51 34 || RCL || 76 || |
|||
|- |
|||
| 02 07 || 7 || 27 52 || ( || 52 01 || 1 || 77 || |
|||
|- |
|||
| 03 53 || ) || 28 34 || RCL || 53 59 || *pause || 78 || |
|||
|- |
|||
| 04 12 || INV || 29 01 || 1 || 54 22 || GTO || 79 || |
|||
|- |
|||
| 05 29 || *Int || 30 54 || / || 55 03 || 3 || 80 || |
|||
|- |
|||
| 06 56 || *CP || 31 05 || 5 || 56 08 || 8 || 81 || |
|||
|- |
|||
| 07 12 || INV || 32 57 || subr || 57 || || 82 || |
|||
|- |
|||
| 08 37 || *x=t || 33 00 || 0 || 58 || || 83 || |
|||
|- |
|||
| 09 01 || 1 || 34 03 || 3 || 59 || || 84 || |
|||
|- |
|||
| 10 03 || 3 || 35 94 || = || 60 || || 85 || |
|||
|- |
|||
| 11 01 || 1 || 36 58 || rtn || 61 || || 86 || |
|||
|- |
|||
| 12 84 || + || 37 38 || *CMs || 62 || || 87 || |
|||
|- |
|||
| 13 00 || 0 || 38 01 || 1 || 63 || || 88 || |
|||
|- |
|||
| 14 53 || ) || 39 35 || SUM || 64 || || 89 || |
|||
|- |
|||
| 15 58 || rtn || 40 02 || 2 || 65 || || 90 || |
|||
|- |
|||
| 16 33 || STO || 41 34 || RCL || 66 || || 91 || |
|||
|- |
|||
| 17 01 || 1 || 42 02 || 2 || 67 || || 92 || |
|||
|- |
|||
| 18 54 || / || 43 57 || subr || 68 || || 93 || |
|||
|- |
|||
| 19 03 || 3 || 44 01 || 1 || 69 || || 94 || |
|||
|- |
|||
| 20 57 || subr || 45 06 || 6 || 70 || || 95 || |
|||
|- |
|||
| 21 00 || 0 || 46 93 || +/- || 71 || || 96 || |
|||
|- |
|||
| 22 03 || 3 || 47 12 || INV || 72 || || 97 || |
|||
|- |
|||
| 23 84 || + || 48 47 || *x>=t || 73 || || 98 || |
|||
|- |
|||
| 24 02 || 2 || 49 05 || 5 || 74 || || 99 || |
|||
|} |
|||
Asterisk denotes 2nd function key. |
|||
{| class="wikitable" |
|||
|+ Register allocation |
|||
|- |
|||
| 0: Unused || 1: Argument || 2: Number || 3: Unused || 4: Unused |
|||
|- |
|||
| 5: Unused || 6: Unused || 7: Unused || 8: Unused || 9: Unused |
|||
|} |
|||
Annotated listing: |
|||
<syntaxhighlight lang="text"> |
|||
// Address 00: Entry point |
|||
GTO 3 7 // Jump to the main program |
|||
// Address 03: Subroutine |
|||
// Takes a pending division such as ((12/5 and evaluates whether it |
|||
// is evenly divisible. |
|||
// Result 1: evenly divisible, 0: not divisible |
|||
) // Complete the pending division |
|||
INV *Int // Take the fractional part |
|||
*CP // RegT := 0 |
|||
INV *x=t 1 3 // If fractional part is zero, don't increment |
|||
1 + // Start a pending increment of the return value |
|||
0 ) rtn // Return the return value |
|||
// Address 16: Subroutine |
|||
// Takes a number and evaluates whether it is divisible by 3 and 5. |
|||
// Result: 0=indivisible, 1=fizz, 2=buzz, 3=fizzbuzz |
|||
STO 1 // Save subroutine argument |
|||
/ 3 subr 0 3 // 1 if fizz else 0 |
|||
+ 2 x // Buzz is worth 2x as much as Fizz |
|||
( ( RCL 1 / 5 subr 0 3 // 1 if buzz else 0 |
|||
= // Finish the pending + and x |
|||
rtn // Return result |
|||
// Address 37: Main program |
|||
*CMs // Zero out registers |
|||
1 SUM 2 // Number += 1 |
|||
RCL 2 // Retrieve Number |
|||
subr 1 6 // Evaluate whether it is divisible by 3 and 5 |
|||
+/- // Negate (0=indiv., -1=fizz, -2=buzz, -3=fizzbuzz) |
|||
INV *x>=t 5 3 // If negative, skip the next line. |
|||
RCL 1 // Retrieve number instead of zero. |
|||
*pause // Flash the number on the display |
|||
GTO 3 8 // Loop |
|||
</syntaxhighlight> |
|||
'''Usage:''' |
|||
Press RST R/S to start the program. Increasing numbers will flash on the screen. Positive numbers represent themselves; -1 means fizz, -2 buzz and -3 fizzbuzz. About 25 numbers are calculated per minute. |
|||
=={{header|TI-83 BASIC}}== |
|||
See [[FizzBuzz/Basic]] |
|||
=={{header|TI-83 Hex Assembly}}== |
|||
See [[FizzBuzz/Assembly]] |
|||
=={{header|TI-99/4a TI BASIC / Extended BASIC}}== |
|||
See [[FizzBuzz/Basic]] |
|||
=={{Header|Tiny BASIC}}== |
|||
See [[FizzBuzz/Basic]] |
|||
=={{header|TransFORTH}}== |
|||
<syntaxhighlight lang="forth">: FIZZBUZZ |
|||
101 1 DO |
|||
I 15 MOD 0 = IF |
|||
PRINT " FIZZBUZZ " |
|||
ELSE I 3 MOD 0 = IF |
|||
PRINT " FIZZ " |
|||
ELSE I 5 MOD 0 = IF |
|||
PRINT " BUZZ " |
|||
ELSE I . THEN THEN THEN |
|||
CR LOOP ;</syntaxhighlight> |
|||
=={{header|True BASIC}}== |
|||
See [[FizzBuzz/Basic]] |
|||
=={{header|Turing}}== |
|||
<syntaxhighlight lang="turing">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</syntaxhighlight> |
|||
=={{header|TUSCRIPT}}== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
=={{header|TXR}}== |
|||
<syntaxhighlight lang="shell">$ txr -p "(mapcar (op if @1 @1 @2) (repeat '(nil nil fizz nil buzz fizz nil nil fizz buzz nil fizz nil nil fizzbuzz)) (range 1 100))"</syntaxhighlight> |
|||
=={{header|UNIX Shell}}== |
|||
This solution should work with any Bourne-compatible shell: <!-- http://ideone.com/usJXGo --> |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
===Versions for specific shells=== |
|||
The other solutions work with fewer shells. |
|||
The next solution requires <code>$(( ))</code> arithmetic expansion, |
|||
and it should work with every POSIX shell. |
|||
<!-- http://ideone.com/5yZmOz --> |
|||
<syntaxhighlight lang="bash">n=1 |
|||
while [ 100 -ge n ]; do |
|||
if [ $((n % 15)) -eq 0 ]; then |
|||
echo FizzBuzz |
|||
elif [ $((n % 3)) -eq 0 ]; then |
|||
echo Fizz |
|||
elif [ $((n % 5)) -eq 0 ]; then |
|||
echo Buzz |
|||
else |
|||
echo $n |
|||
fi |
|||
n=$((n + 1)) |
|||
done</syntaxhighlight> |
|||
The next solution requires the <code>(( ))</code> command from the [[Korn Shell]]. |
|||
{{works with|pdksh|5.2.14}} |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
A version using concatenation: |
|||
{{works with|bash|3}} |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
A version using some of the insane overkill of Bash 4: |
|||
{{works with|bash|4}} |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
Bash one-liner: <!-- http://ideone.com/xMEGFK --> |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
==={{header|C Shell}}=== |
|||
<syntaxhighlight lang="csh">@ n = 1 |
|||
while ( $n <= 100 ) |
|||
if ($n % 15 == 0) then |
|||
echo FizzBuzz |
|||
else if ($n % 5 == 0) then |
|||
echo Buzz |
|||
else if ($n % 3 == 0) then |
|||
echo Fizz |
|||
else |
|||
echo $n |
|||
endif |
|||
@ n += 1 |
|||
end</syntaxhighlight> |
|||
=={{header|Uiua}}== |
|||
<syntaxhighlight lang="Uiua"> |
|||
⟨&p|&p"Fizz"|&p"Buzz"|&p"Fizzbuzz"⟩°⋯⍉=0⊞◿3_5.+1⇡100 |
|||
</syntaxhighlight> |
|||
=={{header|Ursa}}== |
|||
<syntaxhighlight lang="ursa"># |
|||
# fizzbuzz |
|||
# |
|||
decl int i |
|||
for (set i 1) (< i 101) (inc i) |
|||
if (= (mod i 3) 0) |
|||
out "fizz" console |
|||
end if |
|||
if (= (mod i 5) 0) |
|||
out "buzz" console |
|||
end if |
|||
if (not (or (= (mod i 3) 0) (= (mod i 5) 0))) |
|||
out i console |
|||
end if |
|||
out endl console |
|||
end for</syntaxhighlight> |
|||
=={{header|Ursala}}== |
|||
<syntaxhighlight lang="ursala">#import std |
|||
#import nat |
|||
fizzbuzz = ^T(&&'Fizz'! not remainder\3,&&'Buzz'! not remainder\5)|| ~&h+ %nP |
|||
#show+ |
|||
main = fizzbuzz*t iota 101</syntaxhighlight> |
|||
=={{header|Ursalang}}== |
|||
<syntaxhighlight lang="ursalang">let write = process.stdout.write |
|||
for i of range(100) { |
|||
let n = i + 1 |
|||
if (n % 3 == 0) {write("Fizz")} |
|||
if (n % 5 == 0) {write("Buzz")} |
|||
if (n % 3 != 0 and n % 5 != 0) {write(n.toString())} |
|||
write("\n") |
|||
}</syntaxhighlight> |
|||
=={{header|V}}== |
|||
<syntaxhighlight lang="v">[fizzbuzz |
|||
1 [>=] [ |
|||
[[15 % zero?] ['fizzbuzz' puts] |
|||
[5 % zero?] ['buzz' puts] |
|||
[3 % zero?] ['fizz' puts] |
|||
[true] [dup puts] |
|||
] when succ |
|||
] while]. |
|||
|100 fizzbuzz</syntaxhighlight> |
|||
===Second try=== |
===Second try=== |
||
Line 682: | Line 11,645: | ||
define a command that will generate a sequence |
define a command that will generate a sequence |
||
<syntaxhighlight lang="v">[seq [] swap dup [zero? not] [rolldown [dup] dip cons rollup pred] while pop pop].</syntaxhighlight> |
|||
create a quote that will return a quote that returns a quote if its argument is an integer (A HOF) |
create a quote that will return a quote that returns a quote if its argument is an integer (A HOF) |
||
<syntaxhighlight lang="v">[check [N X F : [[integer?] [[X % zero?] [N F cons] if] if]] view].</syntaxhighlight> |
|||
Create a quote that will make sure that the above quote is applied correctly if given (Number Function) |
Create a quote that will make sure that the above quote is applied correctly if given (Number Function) |
||
as arguments. |
as arguments. |
||
<syntaxhighlight lang="v">[func [[N F] : [dup N F check i] ] view map].</syntaxhighlight> |
|||
And apply it |
And apply it |
||
<syntaxhighlight lang="v">100 seq [ |
|||
[15 [pop 'fizzbuzz' puts]] |
[15 [pop 'fizzbuzz' puts]] |
||
[5 [pop 'buzz' puts]] |
[5 [pop 'buzz' puts]] |
||
[3 [pop 'fizz' puts]] |
[3 [pop 'fizz' puts]] |
||
[1 [puts]]] [func dup] step |
[1 [puts]]] [func dup] step |
||
[i true] map pop |
[i true] map pop</syntaxhighlight> |
||
the first one is much better :) |
the first one is much better :) |
||
=={{header|Vala}}== |
|||
<syntaxhighlight lang="vala">int main() { |
|||
for (int i = 1; i <= 100; i++) { |
|||
if (i % 3 == 0) stdout.printf("Fizz\n"); |
|||
if (i % 5 == 0) stdout.printf("Buzz\n"); |
|||
if (i % 15 == 0) stdout.printf("FizzBuzz\n"); |
|||
if (i % 3 != 0 && i % 5 != 0) stdout.printf("%d\n", i); |
|||
} |
|||
return 0;; |
|||
}</syntaxhighlight> |
|||
=={{header|Vale}}== |
|||
{{works with|Vale|0.2.0}} |
|||
<syntaxhighlight lang="vale"> |
|||
import stdlib.*; |
|||
exported func main(){ |
|||
fizzBuzz(1, 100); |
|||
} |
|||
func fizzBuzz(i int, stop int) { |
|||
result = if i.mod(3) == 0 { |
|||
"Fizz" } else { "" |
|||
} + if i.mod(5) == 0 { |
|||
"Buzz" } else { "" |
|||
}; |
|||
println(if result == "" { i.str() } else { result }); |
|||
if i < stop { |
|||
return fizzBuzz(i + 1, stop); |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|VAX Assembly}}== |
|||
<syntaxhighlight lang="vax assembly"> 00000008 0000 1 len =8 |
|||
00000008 0000 2 msg: .blkb len ;output buffer |
|||
0000000C 0008 3 desc: .blkl 1 ;descriptor lenght field |
|||
00000000' 000C 4 .address msg ;pointer to buffer |
|||
00000012 0010 5 outlen: .blkw 1 |
|||
4C 55 21 0000001A'010E0000' 0012 6 ctr: .ascid "!UL" |
|||
001D 7 |
|||
0000 001D 8 .entry start,0 |
|||
52 7C 001F 9 clrq r2 ;r2+r3 64bit |
|||
52 D6 0021 10 incl r2 ;start index 1 |
|||
0023 11 loop: |
|||
E2 AF B4 0023 12 clrw desc ;assume not fizz and or buzz |
|||
55 D7 AF 9E 0026 13 movab msg, r5 ;pointer to message buffer |
|||
54 50 52 03 7B 002A 14 ediv #3,r2,r0,r4 ;divr.rl,divd.rq,quo.wl,rem.wl |
|||
54 D5 002F 15 tstl r4 ;remainder |
|||
0B 12 0031 16 bneq not_fizz ;not equal zero |
|||
0033 17 |
|||
85 7A7A6966 8F D0 0033 18 movl #^a"fizz", (r5)+ ;add to message |
|||
CA AF 04 A0 003A 19 addw2 #4, desc ;and update length |
|||
003E 20 not_fizz: |
|||
54 50 52 05 7B 003E 21 ediv #5,r2,r0,r4 |
|||
54 D5 0043 22 tstl r4 |
|||
0B 12 0045 23 bneq not_buzz |
|||
0047 24 |
|||
85 7A7A7562 8F D0 0047 25 movl #^a"buzz", (r5)+ |
|||
B6 AF 04 A0 004E 26 addw2 #4, desc |
|||
0052 27 not_buzz: |
|||
B3 AF B5 0052 28 tstw desc ;fizz and or buzz? |
|||
1B 12 0055 29 bneq show_buffer ;neq - yes |
|||
0057 30 |
|||
AD AF 08 B0 0057 31 movw #len, desc ;fao length limit |
|||
005B 32 $fao_s - ;eql -no |
|||
005B 33 ctrstr = ctr, - ;show number |
|||
005B 34 outlen = outlen, - |
|||
005B 35 outbuf = desc, - |
|||
005B 36 p1 = r2 |
|||
96 AF A0 AF B0 006D 37 movw outlen, desc ;characters filled by fao |
|||
0072 38 show_buffer: |
|||
93 AF 7F 0072 39 pushaq desc |
|||
00000000'GF 01 FB 0075 40 calls #1, g^lib$put_output |
|||
9F 52 00000064 8F F3 007C 41 AOBLEQ #100,r2,loop ;limit.rl, index.ml |
|||
04 0084 42 ret |
|||
0085 43 .end start</syntaxhighlight> |
|||
=={{header|VBA}}== |
|||
<syntaxhighlight lang="vb"> |
|||
Option Explicit |
|||
Sub FizzBuzz() |
|||
Dim Tb(1 To 100) As Variant |
|||
Dim i As Integer |
|||
For i = 1 To 100 |
|||
'Tb(i) = i ' move to Else |
|||
If i Mod 15 = 0 Then |
|||
Tb(i) = "FizzBuzz" |
|||
ElseIf i Mod 5 = 0 Then |
|||
Tb(i) = "Buzz" |
|||
ElseIf i Mod 3 = 0 Then |
|||
Tb(i) = "Fizz" |
|||
Else |
|||
Tb(i) = i |
|||
End If |
|||
Next |
|||
Debug.Print Join(Tb, vbCrLf) |
|||
End Sub</syntaxhighlight> |
|||
As an alternative, testing each number only once: |
|||
<syntaxhighlight lang="vb"> |
|||
Sub FizzBuzz() |
|||
Dim i As Integer |
|||
Dim T(1 To 99) As Variant |
|||
For i = 1 To 99 Step 3 |
|||
T(i + 0) = IIf((i + 0) Mod 5 = 0, "Buzz", i) |
|||
T(i + 1) = IIf((i + 1) Mod 5 = 0, "Buzz", i + 1) |
|||
T(i + 2) = IIf((i + 2) Mod 5 = 0, "FizzBuzz", "Fizz") |
|||
Next i |
|||
Debug.Print Join(T, ", ") & ", Buzz" |
|||
End Sub |
|||
</syntaxhighlight> |
|||
=={{header|VBScript}}== |
|||
{{works with|Windows Script Host|*}} |
|||
<syntaxhighlight lang="vbscript">For i = 1 To 100 |
|||
If i Mod 15 = 0 Then |
|||
WScript.Echo "FizzBuzz" |
|||
ElseIf i Mod 5 = 0 Then |
|||
WScript.Echo "Buzz" |
|||
ElseIf i Mod 3 = 0 Then |
|||
WScript.Echo "Fizz" |
|||
Else |
|||
WScript.Echo i |
|||
End If |
|||
Next</syntaxhighlight> |
|||
=====An Alternative===== |
|||
{{works with|Windows Script Host|*}} |
|||
<syntaxhighlight lang="vbscript">With WScript.StdOut |
|||
For i = 1 To 100 |
|||
If i Mod 3 = 0 Then .Write "Fizz" |
|||
If i Mod 5 = 0 Then .Write "Buzz" |
|||
If .Column = 1 Then .WriteLine i Else .WriteLine "" |
|||
Next |
|||
End With</syntaxhighlight> |
|||
=={{header|Verbexx}}== |
|||
<syntaxhighlight lang="verbexx">@LOOP init:{@VAR t3 t5; @VAR i = 1} while:(i <= 100) next:{i++} |
|||
{ |
|||
t3 = (i % 3 == 0); |
|||
t5 = (i % 5 == 0); |
|||
@SAY ( @CASE when:(t3 && t5) { 'FizzBuzz } |
|||
when: t3 { 'Fizz } |
|||
when: t5 { 'Buzz } |
|||
else: { i } |
|||
); |
|||
};</syntaxhighlight> |
|||
=={{header|Verilog}}== |
|||
<syntaxhighlight lang="verilog"> |
|||
module main; |
|||
integer number; |
|||
initial begin |
|||
for(number = 1; number < 100; number = number + 1) begin |
|||
if (number % 15 == 0) $display("FizzBuzz"); |
|||
else begin |
|||
if(number % 3 == 0) $display("Fizz"); |
|||
else begin |
|||
if(number % 5 == 0) $display("Buzz"); |
|||
else $display(number); |
|||
end |
|||
end |
|||
end |
|||
$finish; |
|||
end |
|||
endmodule |
|||
</syntaxhighlight> |
|||
=={{header|VHDL}}== |
|||
<syntaxhighlight lang="vhdl">entity fizzbuzz is |
|||
end entity fizzbuzz; |
|||
architecture beh of fizzbuzz is |
|||
procedure fizzbuzz(num : natural) is |
|||
begin |
|||
if num mod 15 = 0 then |
|||
report "FIZZBUZZ"; |
|||
elsif num mod 3 = 0 then |
|||
report "FIZZ"; |
|||
elsif num mod 5 = 0 then |
|||
report "BUZZ"; |
|||
else |
|||
report to_string(num); |
|||
end if; |
|||
end procedure fizzbuzz; |
|||
begin |
|||
p_fizz : process is |
|||
begin |
|||
for i in 1 to 100 loop |
|||
fizzbuzz(i); |
|||
end loop; |
|||
wait for 200 us; |
|||
end process p_fizz; |
|||
end architecture beh;</syntaxhighlight> |
|||
=={{header|Vim Script}}== |
|||
<syntaxhighlight lang="vim">for i in range(1, 100) |
|||
if i % 15 == 0 |
|||
echo "FizzBuzz" |
|||
elseif i % 5 == 0 |
|||
echo "Buzz" |
|||
elseif i % 3 == 0 |
|||
echo "Fizz" |
|||
else |
|||
echo i |
|||
endif |
|||
endfor</syntaxhighlight> |
|||
=={{header|Visual Basic .NET}}== |
=={{header|Visual Basic .NET}}== |
||
See [[FizzBuzz/Basic]] |
|||
'''Platform:''' [[.NET]] |
|||
{{ |
=={{header|Visual Prolog}}== |
||
<syntaxhighlight lang="text"> |
|||
Sub Main() |
|||
implement main |
|||
open core, console |
|||
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 |
|||
class predicates |
|||
=={{header|UNIX Shell}}== |
|||
fizzbuzz : (integer) -> string procedure (i). |
|||
<pre> |
|||
for n in `seq 1 100`; do |
|||
clauses |
|||
if [ $(($n % 15)) = 0 ]; then |
|||
fizzbuzz(X) = S :- X mod 15 = 0, S = "FizzBuzz", !. |
|||
fizzbuzz(X) = S :- X mod 5 = 0, S = "Buzz", !. |
|||
fizzbuzz(X) = S :- X mod 3 = 0, S = "Fizz", !. |
|||
echo Fizz |
|||
fizzbuzz(X) = S :- S = toString(X). |
|||
echo Buzz |
|||
run() :- |
|||
foreach X = std::fromTo(1,100) do |
|||
echo $n |
|||
write(fizzbuzz(X)), write("\n") |
|||
fi |
|||
end foreach, |
|||
done |
|||
succeed. |
|||
end implement main |
|||
goal |
|||
console::runUtf8(main::run). |
|||
</syntaxhighlight> |
|||
=={{header|V (Vlang)}}== |
|||
Updated for V (Vlang) version 0.2.2 |
|||
<syntaxhighlight lang="go">const ( |
|||
fizz = Tuple{true, false} |
|||
buzz = Tuple{false, true} |
|||
fizzbuzz = Tuple{true, true} |
|||
) |
|||
struct Tuple{ |
|||
val1 bool |
|||
val2 bool |
|||
} |
|||
fn fizz_or_buzz( val int ) Tuple { |
|||
return Tuple{ val % 3 == 0, val % 5 == 0 } |
|||
} |
|||
fn fizzbuzz( n int ) { |
|||
for i in 1..(n + 1) { |
|||
match fizz_or_buzz(i) { |
|||
fizz { println('Fizz') } |
|||
buzz { println('Buzz') } |
|||
fizzbuzz { println('FizzBuzz') } |
|||
else { println(i) } |
|||
} |
|||
} |
|||
} |
|||
fn main(){ |
|||
fizzbuzz(15) |
|||
} |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre>1 |
|||
2 |
|||
Fizz |
|||
4 |
|||
Buzz |
|||
Fizz |
|||
7 |
|||
8 |
|||
Fizz |
|||
Buzz |
|||
11 |
|||
Fizz |
|||
13 |
|||
14 |
|||
FizzBuzz |
|||
</pre> |
</pre> |
||
Basic example with a for loop and match: |
|||
A more portable version: |
|||
<syntaxhighlight lang="go"> |
|||
fn main() { |
|||
mut i := 1 |
|||
for i <= 100 { |
|||
match true { |
|||
i % 15 == 0 { println('FizzBuzz') } |
|||
i % 3 == 0 { println('Fizz') } |
|||
i % 5 == 0 { println('Buzz') } |
|||
else { println(i) } |
|||
} |
|||
i++ |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
Another basic example using the ubiquitous if/else (if) statement: |
|||
<syntaxhighlight lang="go"> |
|||
fn main() { |
|||
for i in 1..100 { |
|||
if i % 15 == 0 { |
|||
println('FizzBuzz') |
|||
} else if i % 3 == 0 { |
|||
println('Fizz') |
|||
} else if i % 5 == 0 { |
|||
println('Buzz') |
|||
} else { |
|||
println(i) |
|||
} |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre style="height:40ex"> |
|||
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 |
|||
</pre> |
|||
=={{header|VTL-2}}== |
|||
<syntaxhighlight lang="vtl2">10 N=1 |
|||
20 #=30 |
|||
30 #=N/3*0+%=0*110 |
|||
40 #=N/5*0+%=0*130 |
|||
50 #=!+30 |
|||
60 ?=N |
|||
70 ?="" |
|||
80 N=N+1 |
|||
90 #=100>N*20 |
|||
100 #=999 |
|||
110 ?="Fizz"; |
|||
120 #=! |
|||
130 ?="Buzz"; |
|||
140 #=! |
|||
180 #=70</syntaxhighlight> |
|||
=={{header|Wart}}== |
|||
<syntaxhighlight lang="wart">for i 1 (i <= 100) ++i |
|||
prn (if (divides i 15) |
|||
"FizzBuzz" |
|||
(divides i 3) |
|||
"Fizz" |
|||
(divides i 5) |
|||
"Buzz" |
|||
:else |
|||
i)</syntaxhighlight> |
|||
=={{header|WDTE}}== |
|||
<syntaxhighlight lang="wdte">let io => import 'io'; |
|||
let s => import 'stream'; |
|||
let multiple of n => == (% n of) 0; |
|||
let fizzbuzz n => switch n { |
|||
multiple (* 3 5) => 'FizzBuzz'; |
|||
multiple 3 => 'Fizz'; |
|||
multiple 5 => 'Buzz'; |
|||
default => n; |
|||
} -- io.writeln io.stdout; |
|||
s.range 1 101 -> s.map fizzbuzz -> s.drain;</syntaxhighlight> |
|||
=={{header|Whitespace}}== |
|||
See [[FizzBuzz/EsoLang]] |
|||
=={{header|Wortel}}== |
|||
<syntaxhighlight lang="wortel">@each &x!console.log x !*&x?{%%x 15 "FizzBuzz" %%x 5 "Buzz" %%x 3 "Fizz" x} @to 100</syntaxhighlight> |
|||
=={{header|Wren}}== |
|||
<syntaxhighlight lang="wren">for (i in 1..100) { |
|||
if (i % 15 == 0) { |
|||
System.print("FizzBuzz") |
|||
} else if (i % 3 == 0) { |
|||
System.print("Fizz") |
|||
} else if (i % 5 == 0) { |
|||
System.print("Buzz") |
|||
} else { |
|||
System.print(i) |
|||
} |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre style="height:40ex"> |
|||
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 |
|||
</pre> |
|||
=={{header|X86 Assembly}}== |
|||
<syntaxhighlight lang="x86asm"> |
|||
; x86_64 linux nasm |
|||
section .bss |
|||
number resb 4 |
|||
section .data |
|||
fizz: db "Fizz" |
|||
buzz: db "Buzz" |
|||
newLine: db 10 |
|||
section .text |
|||
global _start |
|||
_start: |
|||
mov rax, 1 ; initialize counter |
|||
loop: |
|||
push rax |
|||
call fizzBuzz |
|||
pop rax |
|||
inc rax |
|||
cmp rax, 100 |
|||
jle loop |
|||
mov rax, 60 |
|||
mov rdi, 0 |
|||
syscall |
|||
fizzBuzz: |
|||
mov r10, rax |
|||
mov r15, 0 ; boolean fizz or buzz |
|||
checkFizz: |
|||
xor rdx, rdx ; clear rdx for division |
|||
mov rbx, 3 |
|||
div rbx |
|||
cmp rdx, 0 ; modulo result here |
|||
jne checkBuzz |
|||
mov r15, 1 |
|||
mov rsi, fizz |
|||
mov rdx, 4 |
|||
mov rax, 1 |
|||
mov rdi, 1 |
|||
syscall |
|||
checkBuzz: |
|||
mov rax, r10 |
|||
xor rdx, rdx |
|||
mov rbx, 5 |
|||
div rbx |
|||
cmp rdx, 0 |
|||
jne finishLine |
|||
mov r15, 1 |
|||
mov rsi, buzz |
|||
mov rdx, 4 |
|||
mov rax, 1 |
|||
mov rdi, 1 |
|||
syscall |
|||
finishLine: ; print number if no fizz or buzz |
|||
cmp r15, 1 |
|||
je nextLine |
|||
mov rax, r10 |
|||
call printNum |
|||
ret |
|||
nextLine: |
|||
mov rsi, newLine |
|||
mov rdx, 1 |
|||
mov rax, 1 |
|||
mov rdi, 1 |
|||
syscall |
|||
ret |
|||
printNum: ; write proper digits into number buffer |
|||
cmp rax, 100 |
|||
jl lessThanHundred |
|||
mov byte [number], 49 |
|||
mov byte [number + 1], 48 |
|||
mov byte [number + 2], 48 |
|||
mov rdx, 3 |
|||
jmp print |
|||
lessThanHundred: ; get digits to write through division |
|||
xor rdx, rdx |
|||
mov rbx, 10 |
|||
div rbx |
|||
add rdx, 48 |
|||
cmp rax, 0 |
|||
je lessThanTen |
|||
add rax, 48 |
|||
mov byte [number], al |
|||
mov byte [number + 1], dl |
|||
mov rdx, 2 |
|||
jmp print |
|||
lessThanTen: |
|||
mov byte [number], dl |
|||
mov rdx, 1 |
|||
print: |
|||
mov byte [number + rdx], 10 ; add newline |
|||
inc rdx |
|||
mov rax, 1 |
|||
mov rdi, 1 |
|||
mov rsi, number |
|||
syscall |
|||
ret |
|||
</syntaxhighlight> |
|||
=={{header|XBasic}}== |
|||
See [[FizzBuzz/Basic]] |
|||
=={{header|XLISP}}== |
|||
<syntaxhighlight lang="lisp">(defun fizzbuzz () |
|||
(defun fizzb (x y) |
|||
(display (cond |
|||
((= (mod x 3) (mod x 5) 0) "FizzBuzz") |
|||
((= (mod x 3) 0) "Fizz") |
|||
((= (mod x 5) 0) "Buzz") |
|||
(t x))) |
|||
(newline) |
|||
(if (< x y) |
|||
(fizzb (+ x 1) y))) |
|||
(fizzb 1 100)) |
|||
(fizzbuzz)</syntaxhighlight> |
|||
=={{header|XMIDAS}}== |
|||
<syntaxhighlight lang="xmidas">startmacro |
|||
loop 100 count |
|||
calc/quiet three ^count 3 modulo |
|||
calc/quiet five ^count 5 modulo |
|||
if ^three eq 0 and ^five eq 0 |
|||
say "fizzbuzz" |
|||
elseif ^three eq 0 |
|||
say "fizz" |
|||
elseif ^five eq 0 |
|||
say "buzz" |
|||
else |
|||
say ^count |
|||
endif |
|||
endloop |
|||
endmacro</syntaxhighlight> |
|||
=={{header|Xojo}}== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
An alternative syntax: |
|||
<syntaxhighlight lang="vb"> |
|||
For i As Integer = 1 To 100 |
|||
Select Case True |
|||
Case i Mod 3 = 0 And i Mod 5 = 0 |
|||
Print("FizzBuzz") |
|||
Case i Mod 3 = 0 |
|||
Print("Fizz") |
|||
Case i Mod 5 = 0 |
|||
Print("Buzz") |
|||
Else |
|||
Print(Str(i)) |
|||
End Select |
|||
Next</syntaxhighlight> |
|||
=={{header|XPath 2.0}}== |
|||
<syntaxhighlight 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)])</syntaxhighlight> |
|||
...or alternatively... |
|||
<syntaxhighlight 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]</syntaxhighlight> |
|||
=={{header|XPL0}}== |
|||
<syntaxhighlight 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); |
|||
]; |
|||
]</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
<pre> |
||
1 |
|||
NUM=1 |
|||
2 |
|||
until (($NUM==101)) ; do |
|||
Fizz |
|||
if (($NUM % 15 == 0)) ; then |
|||
4 |
|||
echo FizzBuzz |
|||
Buzz |
|||
elif (($NUM % 3 == 0)) ; then |
|||
Fizz |
|||
7 |
|||
elif (($NUM % 5 == 0)) ; then |
|||
... |
|||
echo Buzz |
|||
89 |
|||
else |
|||
FizzBuzz |
|||
echo "$NUM" |
|||
91 |
|||
fi |
|||
92 |
|||
((NUM=$NUM+1)) |
|||
Fizz |
|||
done |
|||
94 |
|||
Buzz |
|||
Fizz |
|||
97 |
|||
98 |
|||
Fizz |
|||
Buzz |
|||
</pre> |
</pre> |
||
=={{header|XSLT}}== |
|||
===XSLT 1.0=== |
|||
{{works with|xsltproc|libxslt 10126}} |
|||
<syntaxhighlight 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"/> |
|||
<!-- Outputs a line for a single FizzBuzz iteration. --> |
|||
<xsl:template name="fizzbuzz-single"> |
|||
<xsl:param name="n"/> |
|||
<!-- $s will be "", "Fizz", "Buzz", or "FizzBuzz". --> |
|||
<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> |
|||
<!-- Output $s. If $s is blank, also output $n. --> |
|||
<xsl:value-of select="$s"/> |
|||
<xsl:if test="$s = ''"> |
|||
<xsl:value-of select="$n"/> |
|||
</xsl:if> |
|||
<!-- End line. --> |
|||
<xsl:value-of select="' '"/> |
|||
</xsl:template> |
|||
<!-- Calls fizzbuzz-single over each value in a range. --> |
|||
<xsl:template name="fizzbuzz-range"> |
|||
<!-- Default parameters: From 1 through 100 --> |
|||
<xsl:param name="startAt" select="1"/> |
|||
<xsl:param name="endAt" select="$startAt + 99"/> |
|||
<!-- Simulate a loop with tail recursion. --> |
|||
<!-- Loop condition --> |
|||
<xsl:if test="$startAt <= $endAt"> |
|||
<!-- Loop body --> |
|||
<xsl:call-template name="fizzbuzz-single"> |
|||
<xsl:with-param name="n" select="$startAt"/> |
|||
</xsl:call-template> |
|||
<!-- Increment counter, repeat --> |
|||
<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> |
|||
<!-- Main procedure --> |
|||
<xsl:template match="/"> |
|||
<!-- Default parameters are used --> |
|||
<xsl:call-template name="fizzbuzz-range"/> |
|||
</xsl:template> |
|||
</xsl:stylesheet></syntaxhighlight> |
|||
===XSLT 1.0 With EXSLT=== |
|||
<syntaxhighlight 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></syntaxhighlight> |
|||
===XSLT 2.0=== |
|||
<syntaxhighlight 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></syntaxhighlight> |
|||
=={{header|Yabasic}}== |
|||
See [[FizzBuzz/Basic]] |
|||
=={{header|YAMLScript}}== |
|||
<syntaxhighlight lang="yaml"> |
|||
#!/usr/bin/env ys-0 |
|||
defn main(count=100 impl=1): |
|||
:: | |
|||
Invoke one of the FizzBuzz implementations below. |
|||
usage: ys fizzbuzz.ys [<count> [<implementation-number>]] |
|||
fizzbuzz =: "fizzbuzz-$impl" |
|||
say: "Running function '$fizzbuzz' with count=$count" |
|||
mapv say: |
|||
call V(fizzbuzz): count |
|||
defn fizzbuzz-1(n): |
|||
:: Implementation 1 - with 'map' |
|||
map _ (1 .. n): |
|||
fn(x): |
|||
cond: |
|||
zero?(x % 15) : 'FizzBuzz' |
|||
zero?(x % 5) : 'Buzz' |
|||
zero?(x % 3) : 'Fizz' |
|||
else : x |
|||
defn fizzbuzz-2(n): |
|||
:: Implementation 2 - with 'loop' |
|||
loop i 1, l []: |
|||
if i <= n: |
|||
recur inc(i): |
|||
conj l: |
|||
cond: |
|||
zero?(i % 15) : 'FizzBuzz' |
|||
zero?(i % 5) : 'Buzz' |
|||
zero?(i % 3) : 'Fizz' |
|||
else : i |
|||
else: l |
|||
defn fizzbuzz-3(n): |
|||
:: Implementation 3 - with 'for' |
|||
for x (1 .. n): |
|||
s =: |
|||
str: |
|||
when (x % 3) == 0: 'Fizz' |
|||
when (x % 5) == 0: 'Buzz' |
|||
if s == '': x s |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
$ ys fizzbuzz.ys 16 2 |
|||
Running function 'fizzbuzz-2' with count=16 |
|||
1 |
|||
2 |
|||
Fizz |
|||
4 |
|||
Buzz |
|||
Fizz |
|||
7 |
|||
8 |
|||
Fizz |
|||
Buzz |
|||
11 |
|||
Fizz |
|||
13 |
|||
14 |
|||
FizzBuzz |
|||
16 |
|||
</pre> |
|||
=={{header|Yorick}}== |
|||
===Iterative solution=== |
|||
<syntaxhighlight 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, ""; |
|||
}</syntaxhighlight> |
|||
===Vectorized solution=== |
|||
<syntaxhighlight 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;</syntaxhighlight> |
|||
=={{header|Z80 Assembly}}== |
|||
See [[FizzBuzz/Assembly]] |
|||
=={{header|Zig}}== |
|||
<syntaxhighlight lang="zig">const print = @import("std").debug.print; |
|||
pub fn main() void { |
|||
var i: usize = 1; |
|||
while (i <= 100) : (i += 1) { |
|||
if (i % 3 == 0 and i % 5 == 0) { |
|||
print("FizzBuzz\n", .{}); |
|||
} else if (i % 3 == 0) { |
|||
print("Fizz\n", .{}); |
|||
} else if (i % 5 == 0) { |
|||
print("Buzz\n", .{}); |
|||
} else { |
|||
print("{}\n", .{i}); |
|||
} |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|zkl}}== |
|||
<syntaxhighlight lang="zkl">foreach n in ([1..100]) { |
|||
if(n % 3 == 0) print("Fizz"); |
|||
if(not (n%5)) "Buzz".print(); |
|||
if(n%3 and n%5) print(n); |
|||
println(); |
|||
}</syntaxhighlight> |
|||
Or, using infinite lazy sequences: |
|||
<syntaxhighlight lang="zkl">fcn f(a,b,c){ a+b and a+b or c } |
|||
Walker.cycle("","","Fizz").zipWith(f,Walker.cycle("","","","","Buzz"),[1..]) |
|||
.walk(100).concat("\n").println();</syntaxhighlight> |
|||
More of the same: |
|||
<syntaxhighlight lang="zkl">Walker.cycle(0,0,"Fizz",0,"Buzz","Fizz",0,0,"Fizz","Buzz",0,"Fizz",0,0,"FizzBuzz") |
|||
.zipWith(fcn(a,b){ a or b },[1..]).walk(100).concat("\n").println();</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
1 |
|||
2 |
|||
Fizz |
|||
4 |
|||
Buzz |
|||
Fizz |
|||
7 |
|||
8 |
|||
Fizz |
|||
Buzz |
|||
11 |
|||
Fizz |
|||
13 |
|||
14 |
|||
FizzBuzz |
|||
... |
|||
</pre> |
|||
=={{header|ZX Spectrum Basic}}== |
|||
{{trans|Applesoft BASIC}} |
|||
<syntaxhighlight lang="zxbasic">10 DEF FN m(a,b)=a-INT (a/b)*b |
|||
20 FOR a=1 TO 100 |
|||
30 LET o$="" |
|||
40 IF FN m(a,3)=0 THEN LET o$="Fizz" |
|||
50 IF FN m(a,5)=0 THEN LET o$=o$+"Buzz" |
|||
60 IF o$="" THEN LET o$=STR$ a |
|||
70 PRINT o$ |
|||
80 NEXT a</syntaxhighlight> |
Latest revision as of 19:06, 24 August 2024
![Task](http://static.miraheze.org/rosettacodewiki/thumb/b/ba/Rcode-button-task-crushed.png/64px-Rcode-button-task-crushed.png)
You are encouraged to solve this task according to the task description, using any language you may know.
- Task
Write a program that prints the integers from 1 to 100 (inclusive).
But:
- for multiples of three, print Fizz instead of the number;
- for multiples of five, print Buzz instead of the number;
- for multiples of both three and five, print FizzBuzz instead of the number.
The FizzBuzz problem was presented as the lowest level of comprehension required to illustrate adequacy.
- Also see
- (a blog) dont-overthink-fizzbuzz
- (a blog) fizzbuzz-the-programmers-stairway-to-heaven
11l
L(i) 1..100
I i % 15 == 0
print(‘FizzBuzz’)
E I i % 3 == 0
print(‘Fizz’)
E I i % 5 == 0
print(‘Buzz’)
E
print(i)
360 Assembly
6502 Assembly
68000 Assembly
8080 Assembly
8086 Assembly
8th
with: n
: num? \ n f -- )
if drop else . then ;
\ is m mod n 0? leave the result twice on the stack
: div? \ m n -- f f
mod 0 = dup ;
: fizz? \ n -- n f
dup 3
div? if "Fizz" . then ;
: buzz? \ n f -- n f
over 5
div? if "Buzz" . then or ;
\ print a message as appropriate for the given number:
: fizzbuzz \ n --
fizz? buzz? num?
space ;
\ iterate from 1 to 100:
' fizzbuzz 1 100 loop
cr bye
AArch64 Assembly
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program FizzBuzz64.s */
/*******************************************/
/* Constantes file */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
/*******************************************/
/* Initialized data */
/*******************************************/
.data
szMessFizz: .asciz "Fizz\n"
szMessBuzz: .asciz "Buzz\n"
szMessFizzBuzz: .asciz "FizzBuzz\n"
szMessNumber: .asciz "Number : @ "
szCarriageReturn: .asciz "\n"
/*******************************************/
/* UnInitialized data */
/*******************************************/
.bss
sZoneConv: .skip 24
/*******************************************/
/* code section */
/*******************************************/
.text
.global main
main: // entry of program
mov x10,3 // divisor 3
mov x11,5 // divisor 5
mov x12,15 // divisor 15
mov x13,1 // indice
1: // loop begin
udiv x14,x13,x12 // multiple 15
msub x15,x14,x12,x13 // remainder
cbnz x15,2f // zero ?
mov x0,x13
ldr x1,qAdrszMessFizzBuzz
bl displayResult
b 4f
2: // multiple 3
udiv x14,x13,x10
msub x15,x14,x10,x13 // remainder
cbnz x15,3f // zero ?
mov x0,x13
ldr x1,qAdrszMessFizz
bl displayResult
b 4f
3: // multiple 5
udiv x14,x13,x11
msub x15,x14,x11,x13 // remainder
cbnz x15,4f // zero ?
mov x0,x13
ldr x1,qAdrszMessBuzz
bl displayResult
4:
add x13,x13,1 // increment indice
cmp x13,100 // maxi ?
ble 1b
100: // standard end of the program
mov x8,EXIT // request to exit program
svc 0 // perform the system call
qAdrszMessFizzBuzz: .quad szMessFizzBuzz
qAdrszMessFizz: .quad szMessFizz
qAdrszMessBuzz: .quad szMessBuzz
/******************************************************************/
/* Display résult */
/******************************************************************/
/* x0 contains the number*/
/* x1 contains display string address */
displayResult:
stp x2,lr,[sp,-16]! // save registers
mov x2,x1
ldr x1,qAdrsZoneConv // conversion number
bl conversion10S // decimal conversion
ldr x0,qAdrszMessNumber
ldr x1,qAdrsZoneConv
bl strInsertAtCharInc // insert result at @ character
bl affichageMess // display message final
mov x0,x2
bl affichageMess
ldp x2,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
qAdrsZoneConv: .quad sZoneConv
qAdrszMessNumber: .quad szMessNumber
/********************************************************/
/* File Include fonctions */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
ABAP
Impure Functional 1
DATA: tab TYPE TABLE OF string.
tab = VALUE #(
FOR i = 1 WHILE i <= 100 (
COND string( LET r3 = i MOD 3
r5 = i MOD 5 IN
WHEN r3 = 0 AND r5 = 0 THEN |FIZZBUZZ|
WHEN r3 = 0 THEN |FIZZ|
WHEN r5 = 0 THEN |BUZZ|
ELSE i ) ) ).
cl_demo_output=>write( tab ).
cl_demo_output=>display( ).
Impure Functional 2
cl_demo_output=>display( value stringtab( for i = 1 until i > 100
let fizz = cond #( when i mod 3 = 0 then |fizz| else space )
buzz = cond #( when i mod 5 = 0 then |buzz| else space )
fb = |{ fizz }{ buzz }| in
( switch #( fb when space then i else fb ) ) ) ).
ABC
HOW TO RETURN fizzbuzz num:
PUT "" IN result
PUT {[3]: "Fizz"; [5]: "Buzz"} IN divwords
FOR div IN keys divwords:
IF num mod div=0:
PUT result^divwords[div] IN result
IF result="":
PUT num>>0 IN result
RETURN result
FOR i IN {1..100}:
WRITE fizzbuzz i/
ACL2
(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))
Action!
PROC Main()
BYTE i,d3,d5
d3=1 d5=1
FOR i=1 TO 100
DO
IF d3=0 AND d5=0 THEN
Print("FizzBuzz")
ELSEIF d3=0 THEN
Print("Fizz")
ELSEIF d5=0 THEN
Print("Buzz")
ELSE
PrintB(i)
FI
Put(32)
d3==+1 d5==+1
IF d3=3 THEN d3=0 FI
IF d5=5 THEN d5=0 FI
OD
RETURN
- Output:
Screenshot from Atari 8-bit computer
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
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.
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);
}
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;
Agda
module FizzBuzz where
open import Agda.Builtin.IO using (IO)
open import Agda.Builtin.Unit renaming (⊤ to Unit)
open import Data.Bool using (Bool ; false ; true ; if_then_else_)
open import Data.Nat using (ℕ ; zero ; suc ; _≡ᵇ_ ; _%_)
open import Data.Nat.Show using (show)
open import Data.List using (List ; [] ; _∷_ ; map)
open import Data.String using (String ; _++_ ; unlines)
postulate putStrLn : String -> IO Unit
{-# FOREIGN GHC import qualified Data.Text as T #-}
{-# COMPILE GHC putStrLn = putStrLn . T.unpack #-}
fizz : String
fizz = "Fizz"
buzz : String
buzz = "Buzz"
_isDivisibleBy_ : (n : ℕ) -> (m : ℕ) -> Bool
n isDivisibleBy zero = false
n isDivisibleBy (suc k) = ((n % (suc k)) ≡ᵇ 0)
getTerm : (n : ℕ) -> String
getTerm n =
if (n isDivisibleBy 15) then (fizz ++ buzz)
else if (n isDivisibleBy 3) then fizz
else if (n isDivisibleBy 5) then buzz
else (show n)
range : (a : ℕ) -> (b : ℕ) -> List (ℕ)
range k zero = []
range k (suc m) = k ∷ (range (suc k) m)
getTerms : (n : ℕ) -> List (String)
getTerms n = map getTerm (range 1 n)
fizzBuzz : String
fizzBuzz = unlines (getTerms 100)
main : IO Unit
main = putStrLn fizzBuzz
ALGOL 68
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
)
or simply:
FOR i TO 100 DO print(((i%*15=0|"FizzBuzz"|:i%*3=0|"Fizz"|:i%*5=0|"Buzz"|i),new line)) OD
or only testing for divisibility by 3 and 5 (AND does not shortcut in Algol 68), as suggested in the #NewLISP second sample:
FOR i TO 100 DO
IF IF i MOD 3 = 0 THEN print( "Fizz" ); FALSE ELSE TRUE FI
AND IF i MOD 5 = 0 THEN print( "Buzz" ); FALSE ELSE TRUE FI
THEN
print( ( whole( i, 0 ) ) )
FI;
print( ( newline ) )
OD
ALGOL-M
BEGIN
INTEGER FUNCTION DIVBY(N, D);
INTEGER N;
INTEGER D;
BEGIN
DIVBY := 1 - (N - D * (N / D));
END;
INTEGER I;
FOR I := 1 STEP 1 UNTIL 100 DO
BEGIN
IF DIVBY(I, 15) = 1 THEN
WRITE("FizzBuzz")
ELSE IF DIVBY(I, 5) = 1 THEN
WRITE("Buzz")
ELSE IF DIVBY(I, 3) = 1 THEN
WRITE("Fizz")
ELSE
WRITE(I);
END;
END
ALGOL W
begin
i_w := 1; % set integers to print in minimum space %
for i := 1 until 100 do begin
if i rem 15 = 0 then write( "FizzBuzz" )
else if i rem 5 = 0 then write( "Buzz" )
else if i rem 3 = 0 then write( "Fizz" )
else write( i )
end for_i
end.
AntLang
n:{1+ x}map range[100]
s:{a:0eq x mod 3;b:0eq x mod 5;concat apply{1elem x}map{0elem x}hfilter seq[1- max[a;b];a;b]merge seq[str[x];"Fizz";"Buzz"]}map n
echo map s
APEX
for(integer i=1; i <= 100; i++){
String output = '';
if(math.mod(i, 3) == 0) output += 'Fizz';
if(math.mod(i, 5) == 0) output += 'Buzz';
if(output != ''){
System.debug(output);
} else {
System.debug(i);
}
}
APL
⎕IO←0
(L,'Fizz' 'Buzz' 'FizzBuzz')[¯1+(L×W=0)+W←(100×~0=W)+W←⊃+/1 2×0=3 5|⊂L←1+⍳100]
Slightly different approach that makes use of the Decode function (⊥):
A[I]←1+I←(0⍷A)/⍳⍴A←('FIZZBUZZ' 'FIZZ’ 'BUZZ' 0)[2⊥¨×(⊂3 5)|¨1+⍳100]
The idea is to first calculate the residues for all numbers 1..100 after division with both 3 and 5. This generates 100 pairs of numbers a b, where a is either 0,1,2 and b is either 0,1,2,3,4.
These pairs are then put through the sign function which returns 0 for a 0, and a 1 for anything greater than 0. Now we have binary pairs. The binary pairs are encoded with a left argument of 2 resulting in 0,1,2,3. These are treated as indices for the "FizzBuzz vector" where 0 is in position 3.
Variable A holds this new vector of words and zeros. Variable I is assigned the zeros' positions. Finally A[I] is replaced with corresponding indices.
If you have an aversion against mixed vectors, consider inserting ⍕¨ before the final (i.e. left-most) assignment.
Here's a Dyalog-specific solution taking advantage of its anonymous function extension:
{ ⍵ 'Fizz' 'Buzz' 'FizzBuzz'[ +/1 2×0=3 5|⍵] }¨1+⍳100
A slightly different version that works both in Dyalog and GNU APL -- credit to Aniket Bhattacharyea, posted on codeburst.io (https://codeburst.io/fizzbuzz-in-apl-a193d1954b4b):
{(‘FizzBuzz’ ‘Fizz’ ‘Buzz’,⍵)[(0=15 3 5|⍵)⍳1]}¨⍳100
Yet another solution, excessively commented:
(and Dyalog, with ⎕ML ← 2)
∇ sv ← fizzbuzz n; t;d
[1] ⍝⍝ Solve the popular 'fizzbuzz' problem in APL.
[2] ⍝⍝ \param n - highest number to compute (≥0)
[3] ⍝⍝ \returns sv - a vector of strings representing the fizzbuzz solution for ⍳n
[4] ⍝⍝ (note we return a string vector to avoid a mixed-type result; remove the
[5] ⍝⍝ ⍕ function from the (⍕t[⍵]) term to see the difference).
[6] ⍝⍝⍝⍝
[7] t←⍳n ⍝ the sequence 1..n itself which we'll pick from
[8] ⍝ ... or the words 'fizz', 'buzz', 'fizzbuzz' depending on
[9] ⍝ ... divisibility by 3 and/or 5
[10] ⍝⎕←t ⍝ (Uncomment to see during call)
[11]
[12] d←1+(+⌿ ⊃ {((0=3|⍵)) (2×(0=5|⍵))} ⍳n)
[13] ⍝ || || | | | ↓↓
[14] ⍝ || || | | | ⍳n: generate range (1..n)
[15] ⍝ || || | ↓.....................↓ ↓↓
[16] ⍝ || || | A dfn (lambda) taking its right arg (⍵, ⍳n here) to compute two boolean
[17] ⍝ || || | vectors(v12): divisibility by 3 and 5, respectively, for each of ⍳n
[18] ⍝ || || ↓
[19] ⍝ || || ⊃: Disclose ('lift-up' and pad w/zeros) the 'ragged' matrix of vectors (v12)
[20] ⍝ || || holding divisibility by 3 and 5 of each ⍳n
[21] ⍝ || ↓↓
[22] ⍝ || +⌿: Sum (v12) row-wise to count divisibility (0=neither 3 nor 5, 1=3, 2=3 and 5)
[23] ⍝ ↓↓
[24] ⍝ 1+: Add one to (v12) to make them 1-based for indexing below:
[25] ⍝⎕←d
[26]
[27] sv ← { ((⍕t[⍵]) 'Fizz' 'Buzz' 'FizzBuzz') [d[⍵]]}¨ ⍳n
[28] ⍝ | | | | | |
[29] ⍝ | | | ↓....↓ |
[30] ⍝ | |................................↓ idx |
[31] ⍝ | ( lookup output vector ) |
[32] ⍝ ↓...........................................↓
[33] ⍝ A dfn (lambda) taking as its right arg (⍵) ⍳n and using the 'each' (¨)
[34] ⍝ operator to apply the lambda to each (idx) of ⍳n.
[35]
[36] ⍝⍝ USAGE
[37] ⍝⍝ ⎕ ← ,fizzbuzz 15
[38] ⍝ 1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz
∇
I prefer the DRYness of solutions that don't have "FizzBuzz" as a separate case; here's such a solution that works with both Dyalog and GNU. You may want to prepend `⍬⊣` to the whole thing in GNU to keep it from returning the list as the value of the expression, causing the interpreter to print it out a second time.
⎕io←1
{⎕←∊'Fizz' 'Buzz'⍵/⍨d,⍱/d←0=3 5|⍵}¨⍳100
Explanation:
⎕io←1 Set the index origin to 1; if it were set to 0, the next step would count from 0 to 99 instead of 1 to 100. { }¨⍳100 Do the thing in braces for each integer from 1 through 100. 3 5|⍵ Make a list of the remainders when the current number is divided by 3 and 5. d←0= Make it a Boolean vector: true for remainder=0, false otherwise. Name it d. d,⍱/ Prepend d to the result of reducing itself with XNOR, yielding a three-element Boolean vector. The first element is true if the number is divisible by 3; the second if it's divisible by 5; and the third only if it's divisible by neither. 'Fizz' 'Buzz'⍵/⍨ Use the Boolean vector as a mask to select elements from a new triple consisting of 'Fizz', 'Buzz', and the current number. Each of the three elements will be included in the selection only if the corresponding Boolean is true. ∊ Combine the selected elements into one vector/string ⎕← And print it out.
AppleScript
Procedural
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
If this were a useful task requiring a degree of efficiency, it would be better to replace the cumulative text concatenations with additions to a fast-to-access list and coerce this list to text in one go at the end. Less critically, the (i mod … = 0) tests could be nested to reduce the number of these performed from 261 to 200:
on fizzBuzz(n)
script o
property output : {}
end script
repeat with i from 1 to n
if (i mod 3 = 0) then
if (i mod 15 = 0) then
set end of o's output to "FizzBuzz"
else
set end of o's output to "Fizz"
end if
else if (i mod 5 = 0) then
set end of o's output to "Buzz"
else
set end of o's output to i
end if
end repeat
set astid to AppleScript's text item delimiters
set AppleScript's text item delimiters to linefeed
set output to o's output as text
set AppleScript's text item delimiters to astid
return output
end fizzBuzz
fizzBuzz(100)
Another alternative would be simply to fill the list with numbers and then go through it again three times overwriting the relevant slots with the appropriate words:
on fizzBuzz(n)
script o
property output : {}
end script
repeat with i from 1 to n
set end of o's output to i
end repeat
repeat with x in {{3, "Fizz"}, {5, "Buzz"}, {15, "FizzBuzz"}}
set {m, t} to x
repeat with i from m to n by m
set item i of o's output to t
end repeat
end repeat
set astid to AppleScript's text item delimiters
set AppleScript's text item delimiters to linefeed
set output to o's output as text
set AppleScript's text item delimiters to astid
return output
end fizzBuzz
fizzBuzz(100)
With the number of numbers raised from 100 to 10,000, the two scripts inserted here take around 0.051 seconds to execute on my current machine, the original AppleScript above around 0.25 seconds, and the one below (originally described as "functional composition") 3.52 seconds.
Functional
For simplicity, and more efficient use of the scripter's time:
------------------------- FIZZBUZZ -------------------------
-- fizz :: Int -> Bool
on fizz(n)
n mod 3 = 0
end fizz
-- buzz :: Int -> Bool
on buzz(n)
n mod 5 = 0
end buzz
-- fizzAndBuzz :: Int -> Bool
on fizzAndBuzz(n)
n mod 15 = 0
end fizzAndBuzz
-- fizzBuzz :: Int -> String
on fizzBuzz(x)
caseOf(x, [[my fizzAndBuzz, "FizzBuzz"], ¬
[my fizz, "Fizz"], ¬
[my buzz, "Buzz"]], x as string)
end fizzBuzz
--------------------------- TEST ---------------------------
on run
intercalate(linefeed, ¬
map(fizzBuzz, enumFromTo(1, 100)))
end run
-------------------- GENERIC FUNCTIONS ---------------------
-- caseOf :: a -> [(predicate, b)] -> Maybe b -> Maybe b
on caseOf(e, lstPV, default)
repeat with lstCase in lstPV
set {p, v} to contents of lstCase
if mReturn(p)'s |λ|(e) then return v
end repeat
return default
end caseOf
-- enumFromTo :: Int -> Int -> [Int]
on enumFromTo(m, n)
if m > n then
set d to -1
else
set d to 1
end if
set lst to {}
repeat with i from m to n by d
set end of lst to i
end repeat
return lst
end enumFromTo
-- intercalate :: Text -> [Text] -> Text
on intercalate(strText, lstText)
set {dlm, my text item delimiters} to {my text item delimiters, strText}
set strJoined to lstText as text
set my text item delimiters to dlm
return strJoined
end intercalate
-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
tell mReturn(f)
set lng to length of xs
set lst to {}
repeat with i from 1 to lng
set end of lst to |λ|(item i of xs, i, xs)
end repeat
return lst
end tell
end map
-- Lift 2nd class handler function into 1st class script wrapper
-- mReturn :: Handler -> Script
on mReturn(f)
if class of f is script then
f
else
script
property |λ| : f
end script
end if
end mReturn
Applesoft BASIC
See FizzBuzz/Basic
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
Arc
Arc 3.1 Base
(for n 1 100
(prn:if
(multiple n 15) 'FizzBuzz
(multiple n 5) 'Buzz
(multiple n 3) 'Fizz
n))
(for n 1 100
(prn:check (string (when (multiple n 3) 'Fizz)
(when (multiple n 5) 'Buzz))
~empty n)) ; check created string not empty, else return n
Waterhouse Arc
(for n 1 100
(prn:case (gcd n 15)
1 n
3 'Fizz
5 'Buzz
'FizzBuzz))
ARM Assembly
/ * linux GAS */
.global _start
.data
Fizz: .ascii "Fizz\n"
Buzz: .ascii "Buzz\n"
FizzAndBuzz: .ascii "FizzBuzz\n"
numstr_buffer: .skip 3
newLine: .ascii "\n"
.text
_start:
bl FizzBuzz
mov r7, #1
mov r0, #0
svc #0
FizzBuzz:
push {lr}
mov r9, #100
fizzbuzz_loop:
mov r0, r9
mov r1, #15
bl divide
cmp r1, #0
ldreq r1, =FizzAndBuzz
moveq r2, #9
beq fizzbuzz_print
mov r0, r9
mov r1, #3
bl divide
cmp r1, #0
ldreq r1, =Fizz
moveq r2, #5
beq fizzbuzz_print
mov r0, r9
mov r1, #5
bl divide
cmp r1, #0
ldreq r1, =Buzz
moveq r2, #5
beq fizzbuzz_print
mov r0, r9
bl make_num
mov r2, r1
mov r1, r0
fizzbuzz_print:
mov r0, #1
mov r7, #4
svc #0
sub r9, #1
cmp r9, #0
bgt fizzbuzz_loop
pop {lr}
mov pc, lr
make_num:
push {lr}
ldr r4, =numstr_buffer
mov r5, #4
mov r6, #1
mov r1, #100
bl divide
cmp r0, #0
subeq r5, #1
movne r6, #0
add r0, #48
strb r0, [r4, #0]
mov r0, r1
mov r1, #10
bl divide
cmp r0, #0
movne r6, #0
cmp r6, #1
subeq r5, #1
add r0, #48
strb r0, [r4, #1]
add r1, #48
strb r1, [r4, #2]
mov r2, #4
sub r0, r2, r5
add r0, r4, r0
mov r1, r5
pop {lr}
mov pc, lr
divide:
udiv r2, r0, r1
mul r3, r1, r2
sub r1, r0, r3
mov r0, r2
mov pc, lr
Arturo
loop 1..100 [x][
case []
when? [0=x%15] -> print "FizzBuzz"
when? [0=x%3] -> print "Fizz"
when? [0=x%5] -> print "Buzz"
else -> print x
]
- 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
AsciiDots
See FizzBuzz/EsoLang#AsciiDots
ASIC
See FizzBuzz/Basic
Asymptote
for(int number = 1; number <= 100; ++number) {
if (number % 15 == 0) {
write("FizzBuzz");
} else {
if (number % 3 == 0) {
write("Fizz");
} else {
if (number % 5 == 0) {
write("Buzz");
} else {
write(number);
}
}
}
}
ATS
#include "share/atspre_staload.hats"
implement main0() = loop(1, 100) where {
fun loop(from: int, to: int): void =
if from > to then () else
let
val by3 = (from % 3 = 0)
val by5 = (from % 5 = 0)
in
case+ (by3, by5) of
| (true, true) => print_string("FizzBuzz")
| (true, false) => print_string("Fizz")
| (false, true) => print_string("Buzz")
| (false, false) => print_int(from);
print_newline();
loop(from+1, to)
end
}
AutoHotkey
Search autohotkey.com: [1]
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
A short example with cascading ternary operators and graphical output. Press Esc to close the window.
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
AutoIt
Example1
Output via MsgBox():
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
Example2
Output via console, logfile and/or messagebox:
#include <Constants.au3>
; uncomment how you want to do the output
Func Out($Msg)
ConsoleWrite($Msg & @CRLF)
;~ FileWriteLine("FizzBuzz.Log", $Msg)
;~ $Btn = MsgBox($MB_OKCANCEL + $MB_ICONINFORMATION, "FizzBuzz", $Msg)
;~ If $Btn > 1 Then Exit ; Pressing 'Cancel'-button aborts the program
EndFunc ;==>Out
Out("# FizzBuzz:")
For $i = 1 To 100
If Mod($i, 15) = 0 Then
Out("FizzBuzz")
ElseIf Mod($i, 5) = 0 Then
Out("Buzz")
ElseIf Mod($i, 3) = 0 Then
Out("Fizz")
Else
Out($i)
EndIf
Next
Out("# Done.")
Avail
For each i from 1 to 100 do [
Print:
if i mod 15 = 0 then ["FizzBuzz"]
else if i mod 3 = 0 then ["Fizz"]
else if i mod 5 = 0 then ["Buzz"]
else [“i”]
++ "\n";
];
AWK
See FizzBuzz/AWK
Axe
For(I,1,100)
!If I^3??I^5
Disp "FIZZBUZZ",i
Else!If I^3
Disp "FIZZ",i
Else!If I^5
Disp "BUZZ",i
Else
Disp I▶Dec,i
End
.Pause to allow the user to actually read the output
Pause 1000
End
Babel
main:
{ { iter 1 + dup
15 %
{ "FizzBuzz" <<
zap }
{ dup
3 %
{ "Fizz" <<
zap }
{ dup
5 %
{ "Buzz" <<
zap}
{ %d << }
if }
if }
if
"\n" << }
100 times }
BabyCobol
* NB: ANY does not exist in BabyCobol so the elegant
* EVALUATE-based COBOL-style solution is impossible here.
* Note the subtly unbalanced IF/ENDs yet valid END at the end.
IDENTIFICATION DIVISION.
PROGRAM-ID. FIZZBUZZ.
DATA DIVISION.
01 INT PICTURE IS 9(3).
01 REM LIKE INT.
01 TMP LIKE INT.
PROCEDURE DIVISION.
LOOP VARYING INT TO 100
DIVIDE 3 INTO INT GIVING TMP REMAINDER REM
IF REM = 0
THEN DISPLAY "Fizz" WITH NO ADVANCING
DIVIDE 5 INTO INT GIVING TMP REMAINDER REM
IF REM = 0
THEN DISPLAY "Buzz" WITH NO ADVANCING
DIVIDE 15 INTO INT GIVING TMP REMAINDER REM
IF REM = 0
THEN DISPLAY ""
ELSE DISPLAY INT
END.
BaCon
bash
Any bash hacker would do this as a one liner at the shell, so...
for n in {1..100}; do ((( n % 15 == 0 )) && echo 'FizzBuzz') || ((( n % 5 == 0 )) && echo 'Buzz') || ((( n % 3 == 0 )) && echo 'Fizz') || echo $n; done
For the sake of readability...
for n in {1..100}; do
((( n % 15 == 0 )) && echo 'FizzBuzz') ||
((( n % 5 == 0 )) && echo 'Buzz') ||
((( n % 3 == 0 )) && echo 'Fizz') ||
echo $n;
done
Here's a very concise approach, with only 75 characters total. Unfortunately it relies on aspects of Bash which are rarely used.
for i in {1..100};do((i%3))&&x=||x=Fizz;((i%5))||x+=Buzz;echo ${x:-$i};done
Here's the concise approach again, this time separated into multiple lines.
# 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
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
See FizzBuzz/Basic
Basic09
See FizzBuzz/Basic
BASIC256
See FizzBuzz/Basic
Batch File
FOR /L version:
@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
Loop version:
@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
FOR /L with a block instead of very-high-overhead subroutine call:
@echo off & setlocal enabledelayedexpansion
for /l %%i in (1,1,100) do (
set /a m5=%%i %% 5
set /a m3=%%i %% 3
set s=
if !m5! equ 0 set s=!s!Fizz
if !m3! equ 0 set s=!s!Buzz
if "!s!"=="" set s=%%i
echo !s!
)
BBC BASIC
See FizzBuzz/Basic
bc
This solution never uses else, because bc has no else keyword (but some implementations add else as an extension).
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
BCPL
GET "libhdr"
LET start() BE $(
FOR i=1 TO 100 DO $(
TEST (i REM 15) = 0 THEN
writes("FizzBuzz")
ELSE TEST (i REM 3) = 0 THEN
writes("Fizz")
ELSE TEST (i REM 5) = 0 THEN
writes("Buzz")
ELSE
writen(i, 0)
newline()
$)
$)
beeswax
Also see on FizzBuzz/EsoLang
“Ordinary” FizzBuzz solution:
> q
>@F5~%"d@F{ > @F q
_1>F3~%'d`Fizz`@F5~%'d >`Buzz`@FNp
;bL@~.~4~.5~5@ P<
Example without double mod 5 check, using a flag instead, to check if Fizz already got printed (in this case the number n must not be printed if mod 5 is > 0):
>@?q
> q >Ag'd@{?p
_>"1F3~%'d`Fizz`f>@F5~%'d`Buzz`@p
b P~;"-~@~.+0~P9@N?<
Befunge
See FizzBuzz/EsoLang
blz
for i = 0; i <= 100; i++
out = ""
if i % 3 == 0
out = "Fizz"
end
if i % 5 == 0
out = out + "Buzz"
end
if out == ""
out = i
end
print(out)
end
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)
BQN
(∾´∾⟜"Fizz"‿"Buzz"/˜·(¬∨´)⊸∾0=3‿5|⊢)¨1+↕100
Using the Catch modifier for flow control
((∾´"fizz"‿"buzz"/˜0=3‿5|⊢)⎊⊢)¨1+↕100
Using the Choose Combonator with a rank 2 array
(3‿5 (0=|)◶[⊢‿"fizz","buzz"‿"fizzbuzz"] ⊢)¨ 1+↕100
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))
Same code, pretty printed:
0:?i
& whl
' ( 1+!i:<101:?i
& out
$ ( mod$(!i.3):0
& ( mod$(!i.5):0&FizzBuzz
| Fizz
)
| mod$(!i.5):0&Buzz
| !i
)
)
Brainf***
See FizzBuzz/EsoLang
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 }
}
}
}
BrightScript (for Roku)
FOR i = 1 TO 100
fz = i MOD 3 = 0
bz = i MOD 5 = 0
IF fz OR bz
IF fz AND NOT bz: str = "Fizz"
ELSEIF bz AND NOT fz: str = "Buzz"
ELSE str = "FizzBuzz"
END IF
ELSE
str = i.ToStr()
END IF
? str
END FOR
Bruijn
:import std/Combinator .
:import std/String .
:import std/Number .
main [y [[0 =? (+101) case-end case-rec]] (+1)]
case-rec str ++ "\n" ++ (1 ++0)
str fizzbuzz "FizzBuzz" (fizz "Fizz" (buzz "Buzz" (number→string 0)))
fizz =?(0 % (+3))
buzz =?(0 % (+5))
fizzbuzz fizz buzz fizz
case-end empty
C
For 2 prime numbers and based on a similar minimal JavaScript solution with low signal-to-noise, the C code is:
int i = 0 ; char B[88] ;
while ( i++ < 100 )
!sprintf( B, "%s%s", i%3 ? "":"Fizz", i%5 ? "":"Buzz" )
? sprintf( B, "%d", i ):0, printf( ", %s", B );
With 4 prime numbers:
int i = 0 ; char B[88] ;
while ( i++ < 100 )
!sprintf( B, "%s%s%s%s",
i%3 ? "":"Fiz", i%5 ? "":"Buz", i%7 ? "":"Goz", i%11 ? "":"Kaz" )
? sprintf( B, "%d", i ):0, printf( ", %s", B );
Output: ..., 89, FizBuz, Goz, 92, Fiz, 94, Buz, Fiz, 97, Goz, FizKaz, Buz
One line version, with pretty printing
#include <stdio.h>
int main() {
for (int i=1; i<=105; i++) if (i%3 && i%5) printf("%3d ", i); else printf("%s%s%s", i%3?"":"Fizz", i%5?"":"Buzz", i%15?" ":"\n");
}
This actually works (the array init part, saves 6 bytes of static data, whee):
#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;
}
#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;
}
Implicit int main and return 0 (C99+):
#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++;
}
}
obfuscated:
#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;}
With numbers theory:
#include <stdio.h>
int main(void)
{
for (int i = 1; i <= 100; ++i) {
if (i % 3 == 0) printf("fizz");
if (i % 5 == 0) printf("buzz");
if (i * i * i * i % 15 == 1) printf("%d", i);
puts("");
}
}
Without conditionals, anything in the loop body gcc compiles with branching, duplicate tests or duplicate strings. Depends on ASCII and two's complement arithmetic:
#include <stdio.h>
int main()
{
for (int i=0;++i<101;puts(""))
{
char f[] = "FizzBuzz%d";
f[8-i%5&12]=0;
printf (f+(-i%3&4+f[8]/8), i);
}
}
C#
class Program
{
public void FizzBuzzGo()
{
Boolean Fizz = false;
Boolean Buzz = false;
for (int count = 1; count <= 100; count ++)
{
Fizz = count % 3 == 0;
Buzz = count % 5 == 0;
if (Fizz && Buzz)
{
Console.WriteLine("Fizz Buzz");
listBox1.Items.Add("Fizz Buzz");
}
else if (Fizz)
{
Console.WriteLine("Fizz");
listBox1.Items.Add("Fizz");
}
else if (Buzz)
{
Console.WriteLine("Buzz");
listBox1.Items.Add("Buzz");
}
else
{
Console.WriteLine(count);
listBox1.Items.Add(count);
}
}
}
}
class Program
{
static void Main()
{
for (uint i = 1; i <= 100; i++)
{
string s = null;
if (i % 3 == 0)
s = "Fizz";
if (i % 5 == 0)
s += "Buzz";
System.Console.WriteLine(s ?? i.ToString());
}
}
}
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);
}
}
}
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);
}
}
}
using System;
namespace FizzBuzz
{
class Program
{
static void Main(string[] args)
{
for (int i = 1; i <= 100; i++)
{
if (i % 15 == 0)
{
Console.WriteLine("FizzBuzz");
}
else if (i % 3 == 0)
{
Console.WriteLine("Fizz");
}
else if (i % 5 == 0)
{
Console.WriteLine("Buzz");
}
else
{
Console.WriteLine(i);
}
}
}
}
}
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);
}
}
}
}
}
using System;
using System.Linq;
namespace FizzBuzz
{
class Program
{
static void Main(string[] args)
{
Enumerable.Range(1, 100).ToList().ForEach(i => Console.WriteLine(i % 5 == 0 ? string.Format(i % 3 == 0 ? "Fizz{0}" : "{0}", "Buzz") : string.Format(i%3 == 0 ? "Fizz" : i.ToString())));
}
}
}
With C#8 switch expressions
class Program
{
public static string FizzBuzzIt(int n) =>
(n % 3, n % 5) switch
{
(0, 0) => "FizzBuzz",
(0, _) => "Fizz",
(_, 0) => "Buzz",
(_, _) => $"{n}"
};
static void Main(string[] args)
{
foreach (var n in Enumerable.Range(1, 100))
{
Console.WriteLine(FizzBuzzIt(n));
}
}
}
TDD using delegates
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;
}
}
}
Good old C ways
using System;
int max = 100;
for(int i=0;
++i<=max;
Console.WriteLine("{0}{1}{2}", i%3==0 ? "Fizz" : "", i%5==0 ? "Buzz" : "", i%3!=0 && i%5!=0 ? i.ToString() : "")
){}
C++
minimal conditions
#include <iostream>
#include <chrono>
int main()
{
int fizz = 0, buzz = 0, fizzbuzz = 0;
bool isFizz = false;
auto startTime = std::chrono::high_resolution_clock::now();
for (unsigned int i = 1; i <= 4000000000; i++) {
isFizz = false;
if (i % 3 == 0) {
isFizz = true;
fizz++;
}
if (i % 5 == 0) {
if (isFizz) {
fizz--;
fizzbuzz++;
}
else {
buzz++;
}
}
}
auto endTime = std::chrono::high_resolution_clock::now();
auto totalTime = endTime - startTime;
printf("\t fizz : %d, buzz: %d, fizzbuzz: %d, duration %lld milliseconds\n", fizz, buzz, fizzbuzz, (totalTime / std::chrono::milliseconds(1)));
return 0;
}
with modulo
#include <iostream>
using namespace std;
int main ()
{
for (int i = 1; i <= 100; i++)
{
if ((i % 15) == 0)
cout << "FizzBuzz\n";
else if ((i % 3) == 0)
cout << "Fizz\n";
else if ((i % 5) == 0)
cout << "Buzz\n";
else
cout << i << "\n";
}
return 0;
}
without modulo 15
#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 << "\n";
}
return 0;
}
without modulo
Modulo can be expensive on some architectures.
#include <iostream>
int main()
{
int i, f = 2, b = 4;
for ( i = 1 ; i <= 100 ; ++i, --f, --b )
{
if ( f && b ) { std::cout << i; }
if ( !f ) { std::cout << "Fizz"; f = 3; }
if ( !b ) { std::cout << "Buzz"; b = 5; }
std::cout << std::endl;
}
return 0;
}
using std::transform
#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;
}
metaprogramming
Version computing FizzBuzz at compile time with metaprogramming:
#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;
}
hardcore templates
Compile with -ftemplate-depth-9000 -std=c++0x:
#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<i>::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<i>::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;
}
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).
Casio BASIC
See FizzBuzz/Basic
Cduce
(* 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);;
Ceylon
shared void run() => {for (i in 1..100) {for (j->k in [3->"Fizz", 5->"Buzz"]) if (j.divides(i)) k}.reduce(plus) else i}.each(print);
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);
Chef
See FizzBuzz/EsoLang
Cherrycake
# Route with custom number of iterations
cached get ~/:n {
# Get the Number of Iterations from the URL Params
int n = req.params.n || 100
# Loop through each iteration
for (i in range(n)) {
if (i % 2 == 0 && i % 3 == 0) { res.write("FizzBuzz\n") continue }
if (i % 2 == 0) { res.write("Fizz\n"); continue; }
if (i % 3 == 0) { res.write("Buzz\n"); continue; }
res.write(i + "\n");
}
# Close the connection
res.end();
}
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);
}
}
Clipper
Also compiles with Harbour (Harbour 3.2.0dev (r1405201749))
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
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
(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)
)
)
Clojure
(doseq [x (range 1 101)] (println x (str (when (zero? (mod x 3)) "fizz") (when (zero? (mod x 5)) "buzz"))))
(defn fizzbuzz [start finish]
(map (fn [n]
(cond
(zero? (mod n 15)) "FizzBuzz"
(zero? (mod n 3)) "Fizz"
(zero? (mod n 5)) "Buzz"
:else n))
(range start finish)))
(fizzbuzz 1 100)
(map (fn [x] (cond (zero? (mod x 15)) "FizzBuzz"
(zero? (mod x 5)) "Buzz"
(zero? (mod x 3)) "Fizz"
:else x))
(range 1 101))
(map #(let [s (str (if (zero? (mod % 3)) "Fizz") (if (zero? (mod % 5)) "Buzz"))] (if (empty? s) % s)) (range 1 101))
(def fizzbuzz (map
#(cond (zero? (mod % 15)) "FizzBuzz"
(zero? (mod % 5)) "Buzz"
(zero? (mod % 3)) "Fizz"
:else %)
(iterate inc 1)))
(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))))
(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))
(take 100 (map #(let [s (str %2 %3) ] (if (seq s) s (inc %)) )
(range)
(cycle [ "" "" "Fizz" ])
(cycle [ "" "" "" "" "Buzz" ])))
(map #(nth (conj (cycle [% % "Fizz" % "Buzz" "Fizz" % % "Fizz" "Buzz" % "Fizz" % % "FizzBuzz"]) %) %) (range 1 101))
(let [n nil fizz (cycle [n n "fizz"]) buzz (cycle [n n n n "buzz"]) nums (iterate inc 1)]
(take 20 (map #(if (or %1 %2) (str %1 %2) %3) fizz buzz nums)))
(take 100
(map #(if (pos? (compare %1 %2)) %1 %2)
(map str (drop 1 (range)))
(map str (cycle ["" "" "Fizz"]) (cycle ["" "" "" "" "Buzz"]))))
;;Using clojure maps
(defn fizzbuzz
[n]
(let [rule {3 "Fizz"
5 "Buzz"}
divs (->> rule
(map first)
sort
(filter (comp (partial = 0)
(partial rem n))))]
(if (empty? divs)
(str n)
(->> divs
(map rule)
(apply str)))))
(defn allfizzbuzz
[max]
(map fizzbuzz (range 1 (inc max))))
(take 100
(map #(str %1 %2 (if-not (or %1 %2) %3))
(cycle [nil nil "Fizz"])
(cycle [nil nil nil nil "Buzz"])
(rest (range))
))
(take 100
(
(fn [& fbspec]
(let [
fbseq #(->> (repeat nil) (cons %2) (take %1) reverse cycle)
strfn #(apply str (if (every? nil? (rest %&)) (first %&)) (rest %&))
]
(->>
fbspec
(partition 2)
(map #(apply fbseq %))
(apply map strfn (rest (range)))
) ;;endthread
) ;;endlet
) ;;endfn
3 "Fizz" 5 "Buzz" 7 "Bazz"
) ;;endfn apply
) ;;endtake
(take 100
(map-indexed
#(case %2 14 "FizzBuzz" (2 5 8 11) "Fizz" (4 9) "Buzz" (inc %1))
(cycle (range 15))
)
)
(take 100
(->>
(map str (cycle [nil nil "Fizz"]) (cycle [nil nil nil nil "Buzz"]))
(map-indexed #(if (empty? %2) (inc %1) %2))
)
)
(take 100
(map-indexed
#(if (number? %2) (+ %1 %2) %2)
(cycle [1 1 "Fizz" 1 "Buzz" "Fizz" 1 1 "Fizz" "Buzz" 1 "Fizz" 1 1 "FizzBuzz"])
)
)
CLU
start_up = proc ()
po: stream := stream$primary_output()
for i: int in int$from_to(1, 100) do
out: string := ""
if i // 3 = 0 then out := out || "Fizz" end
if i // 5 = 0 then out := out || "Buzz" end
if string$empty(out) then out := int$unparse(i) end
stream$putl(po, out)
end
end start_up
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)
COBOL
Canonical version
* 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.
Simpler version
I know this doesn't have the full-bodied, piquant flavor expected from COBOL, but it is a little shorter.
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.
Evaluate Version
I think this shows clearly that it's resolving the problem and illuminating the rules specified
IDENTIFICATION DIVISION.
PROGRAM-ID. FIZZBUZZ.
ENVIRONMENT DIVISION.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 X PIC 999.
01 Y PIC 999.
01 REM3 PIC 999.
01 REM5 PIC 999.
PROCEDURE DIVISION.
PERFORM VARYING X FROM 1 BY 1 UNTIL X > 100
DIVIDE X BY 3 GIVING Y REMAINDER REM3
DIVIDE X BY 5 GIVING Y REMAINDER REM5
EVALUATE REM3 ALSO REM5
WHEN ZERO ALSO ZERO
DISPLAY "FizzBuzz"
WHEN ZERO ALSO ANY
DISPLAY "Fizz"
WHEN ANY ALSO ZERO
DISPLAY "Buzz"
WHEN OTHER
DISPLAY X
END-EVALUATE
END-PERFORM
STOP RUN
.
Chase the Fizz
A solution that simply evaluates and adds.
>>SOURCE FORMAT FREE
identification division.
program-id. fizzbuzz.
data division.
working-storage section.
01 i pic 999.
01 fizz pic 999 value 3.
01 buzz pic 999 value 5.
procedure division.
start-fizzbuzz.
perform varying i from 1 by 1 until i > 100
evaluate i also i
when fizz also buzz
display 'fizzbuzz'
add 3 to fizz
add 5 to buzz
when fizz also any
display 'fizz'
add 3 to fizz
when buzz also any
display 'buzz'
add 5 to buzz
when other
display i
end-evaluate
end-perform
stop run
.
end program fizzbuzz.
Coco
for i from 1 to 100
console.log do
if i % 15 == 0 then 'FizzBuzz'
else if i % 3 == 0 then 'Fizz'
else if i % 5 == 0 then 'Buzz'
else i
for i from 1 to 100
console.log(['Fizz' unless i % 3] + ['Buzz' unless i % 5] or String(i))
Coconut
def fizzbuzz(n):
case (n % 3, n % 5):
match (0, 0): return "FizzBuzz"
match (0, _): return "Fizz"
match (_, 0): return "Buzz"
else: return n |> str
range(1,101)|> map$(fizzbuzz)|> x -> '\n'.join(x)|> print
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
for i in [1..100]
console.log \
if i % 15 is 0
"FizzBuzz"
else if i % 3 is 0
"Fizz"
else if i % 5 is 0
"Buzz"
else
i
for i in [1..100]
console.log(['Fizz' if i % 3 is 0] + ['Buzz' if i % 5 is 0] or i)
ColdFusion
<Cfloop from="1" to="100" index="i">
<Cfif i mod 15 eq 0>FizzBuzz
<Cfelseif i mod 5 eq 0>Fizz
<Cfelseif i mod 3 eq 0>Buzz
<Cfelse><Cfoutput>#i# </Cfoutput>
</Cfif>
</Cfloop>
cfscript version
<cfscript>
result = "";
for(i=1;i<=100;i++){
result=ListAppend(result, (i%15==0) ? "FizzBuzz": (i%5==0) ? "Buzz" : (i%3 eq 0)? "Fizz" : i );
}
WriteOutput(result);
</cfscript>
Comal
0010 FOR i#:=1 TO 100 DO
0020 IF i# MOD 15=0 THEN
0030 PRINT "FizzBuzz"
0040 ELIF i# MOD 5=0 THEN
0050 PRINT "Buzz"
0060 ELIF i# MOD 3=0 THEN
0070 PRINT "Fizz"
0080 ELSE
0090 PRINT i#
0100 ENDIF
0110 ENDFOR i#
0120 END
Comefrom0x10
fizzbuzz
mod_three = 3
mod_five = 5
comefrom fizzbuzz
n
comefrom fizzbuzz if n is mod_three
comefrom fizzbuzz if n is mod_five
n = n + 1
fizz
comefrom fizzbuzz if n is mod_three
'Fizz'...
mod_three = mod_three + 3
linebreak
# would like to write "unless mod_three is mod_five"
comefrom fizz if mod_three - mod_five - 3
''
buzz
comefrom fizzbuzz if n is mod_five
'Buzz'
mod_five = mod_five + 5
comefrom fizzbuzz if n is 100
Commodore BASIC
See FizzBuzz/Basic
Common Lisp
Solution 1:
(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)))
Solution 2:
(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)))))
Solution 3:
(defun fizzbuzz ()
(loop for n from 1 to 100
do (format t "~&~[~[FizzBuzz~:;Fizz~]~*~:;~[Buzz~*~:;~D~]~]~%"
(mod n 3) (mod n 5) n)))
Solution 4:
(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))
Solution 5:
(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))
Solution 6:
(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)))
Solution 7:
(defun core (x)
(mapcar
#'(lambda (a b) (if (equal 0 (mod x a)) b x))
'(3 5)
'("fizz" "buzz")))
(defun filter-core (x)
(if (equal 1 (length (remove-duplicates x)))
(list (car x))
(remove-if-not #'stringp x)))
(defun fizzbuzz (x)
(loop for a from 1 to x do
(print (format nil "~{~a~}" (filter-core (core a))))))
(fizzbuzz 100)
Solution 8:
(defun range (min max)
(loop
:for x :from min :to max
:collect x))
(defun fizzbuzz ()
(map 'nil #'(lambda (n)
(princ
(cond
((zerop (mod n 15)) "FizzBuzz!")
((zerop (mod n 5)) "Buzz!")
((zerop (mod n 3)) "Fizz!")
(t n))
(terpri)))
(range 1 100)))
First 16 lines of output:
1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16
Alternate solution
I use Allegro CL 10.1
;; Project : FizzBuzz
(defun fizzbuzz (&optional n)
(let ((n (or n 1)))
(if (> n 100)
nil
(progn
(let ((mult-3 (is-mult-p n 3))
(mult-5 (is-mult-p n 5)))
(if mult-3
(princ "Fizz"))
(if mult-5
(princ "Buzz"))
(if (not (or mult-3 mult-5))
(princ n))
(princ #\linefeed)
(fizzbuzz (+ n 1)))))))
(defun is-mult-p (n multiple)
(= (rem n multiple) 0))
(fizzbuzz 1)
Output:
1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17 Fizz 19 Buzz
Coq
Require Import Coq.Lists.List.
(* https://coq.inria.fr/library/Coq.Lists.List.html *)
Require Import Coq.Strings.String.
(* https://coq.inria.fr/library/Coq.Strings.String.html *)
Require Import Coq.Strings.Ascii.
(* https://coq.inria.fr/library/Coq.Strings.Ascii.html *)
Require Import Coq.Init.Nat.
(* https://coq.inria.fr/library/Coq.Init.Nat.html *)
(** Definition of [string_of_nat] to convert natural numbers to strings. *)
Definition ascii_of_digit (n : nat) : ascii :=
ascii_of_nat (n + 48).
Definition is_digit (n : nat) : bool :=
andb (0 <=? n) (n <=? 9).
Fixpoint rec_string_of_nat (counter : nat) (n : nat) (acc : string) : string :=
match counter with
| 0 => EmptyString
| S c =>
if (is_digit n)
then String (ascii_of_digit n) acc
else rec_string_of_nat c (n / 10) (String (ascii_of_digit (n mod 10)) acc)
end.
(** The counter is only used to ensure termination. *)
Definition string_of_nat (n : nat) : string :=
rec_string_of_nat n n EmptyString.
(** The FizzBuzz problem. *)
Definition fizz : string :=
"Fizz".
Definition buzz : string :=
"Buzz".
Definition new_line : string :=
String (ascii_of_nat 10) EmptyString.
Definition is_divisible_by (n : nat) (k : nat) : bool :=
(n mod k) =? 0.
Definition get_term (n : nat) : string :=
if (is_divisible_by n 15) then fizz ++ buzz
else if (is_divisible_by n 3) then fizz
else if (is_divisible_by n 5) then buzz
else (string_of_nat n).
Definition range (a : nat) (b : nat) : list nat :=
seq a b.
Definition get_terms (n : nat) : list string :=
map get_term (range 1 n).
Definition fizz_buzz : string :=
concat new_line (get_terms 100).
(** This shows the string. *)
Eval compute in fizz_buzz.
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"%string : string
Cowgol
Straightforward version
include "cowgol.coh";
var i: uint8 := 1;
while i <= 100 loop
if i % 15 == 0 then
print("FizzBuzz");
elseif i % 5 == 0 then
print("Buzz");
elseif i % 3 == 0 then
print("Fizz");
else
print_i8(i);
end if;
print_nl();
i := i + 1;
end loop;
No division
When targeting small systems, it is generally a good idea not to use division if you don't have to. Most of the processors Cowgol targets do not have hardware division, requiring the use of slow and bulky software division routines. This is not helped by the fact that these processors are not fast to begin with, and memory is usually scarce.
Avoiding division requires not only that %
be avoided, but also
print_i8
cannot be used, as printing integers in decimal format
is also done by division. Instead, this code keeps separate 'fizz' and 'buzz'
counters around, as well as keeping the number ready in ASCII format for printing.
Nevertheless, the following code compiles to a
252-byte 8080 executable, whereas the naive version above compiles to a 755-byte
executable. (Compare to the 8080 assembly program above, which assembles to a
98-byte executable.)
include "cowgol.coh";
var i: uint8 := 100;
var fizz: uint8 := 3;
var buzz: uint8 := 5;
var dh: uint8 := '0';
var dl: uint8 := '1';
var prnum: uint8;
while i != 0 loop
fizz := fizz - 1;
buzz := buzz - 1;
prnum := 1;
if fizz == 0 then
print("Fizz");
fizz := 3;
prnum := 0;
end if;
if buzz == 0 then
print("Buzz");
buzz := 5;
prnum := 0;
end if;
if prnum != 0 then
if dh != '0' then
print_char(dh);
end if;
print_char(dl);
end if;
dl := dl + 1;
if dl == ('9' + 1) then
dl := '0';
dh := dh + 1;
end if;
print_nl();
i := i - 1;
end loop;
Craft Basic
See FizzBuzz/Basic
Crystal
1.upto(100) do |v|
p fizz_buzz(v)
end
def fizz_buzz(value)
word = ""
word += "fizz" if value % 3 == 0
word += "buzz" if value % 5 == 0
word += value.to_s if word.empty?
word
end
A more natural solution with the string building:
1.upto(100) do |n|
case
when n % 15 == 0
puts "FizzBuzz"
when n % 5 == 0
puts "Buzz"
when n % 3 == 0
puts "Fizz"
else
puts n
end
end
CSS
<!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml" lang="en"> <head> <style> li { list-style-position: inside; } li:nth-child(3n), li:nth-child(5n) { list-style-type: none; } li:nth-child(3n)::before { content:'Fizz'; } li:nth-child(5n)::after { content:'Buzz'; } </style> </head> <body> <ol> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> <li></li> </ol> </body> </html>
Cubescript
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
]
]
]
]
D
import std.stdio, std.algorithm, std.conv;
/// With if-else.
void fizzBuzz(in uint n) {
foreach (immutable i; 1 .. n + 1)
if (!(i % 15))
"FizzBuzz".writeln;
else if (!(i % 3))
"Fizz".writeln;
else if (!(i % 5))
"Buzz".writeln;
else
i.writeln;
}
/// With switch case.
void fizzBuzzSwitch(in uint n) {
foreach (immutable i; 1 .. n + 1)
switch (i % 15) {
case 0:
"FizzBuzz".writeln;
break;
case 3, 6, 9, 12:
"Fizz".writeln;
break;
case 5, 10:
"Buzz".writeln;
break;
default:
i.writeln;
}
}
void fizzBuzzSwitch2(in uint n) {
foreach (immutable i; 1 .. n + 1)
(i % 15).predSwitch(
0, "FizzBuzz",
3, "Fizz",
5, "Buzz",
6, "Fizz",
9, "Fizz",
10, "Buzz",
12, "Fizz",
/*else*/ i.text).writeln;
}
void main() {
100.fizzBuzz;
writeln;
100.fizzBuzzSwitch;
writeln;
100.fizzBuzzSwitch2;
}
Alternate version calculating values at compile time:
import std;
void main()
{
auto fizzbuzz(in uint i)
{
string r;
if (i % 3 == 0) r ~= "fizz";
if (i % 5 == 0) r ~= "buzz";
if (r.length == 0) r ~= i.to!string;
return r;
}
enum r = 1.iota(101).map!fizzbuzz;
r.each!writeln;
}
Dart
main() {
for (int i = 1; i <= 100; i++) {
List<String> out = [];
if (i % 3 == 0)
out.add("Fizz");
if (i % 5 == 0)
out.add("Buzz");
print(out.length > 0 ? out.join("") : i);
}
}
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
The bc translation written in dc style.
# dc is stack based, so we use the stack instead of a variable for our
# current number.
1 # Number = 1
[[Fizz]n 1 sw]sF # Prints "Fizz" prevents Number from printing
[[Buzz]n 1 sw]sB # Prints "Buzz" prevents Number from printing
[dn]sN # Prints Number
[
dd # Put two extra copies of Number on stack
0 sw # w = 0
3% 0=F # Fizz if 0 == Number % 3 (destroys 1st copy)
5% 0=B # Buzz if 0 == Number % 5 (destroys 2nd copy)
lw 0=N # Print Number if 0 == w
[
]n # Print new line
1+d # Number += 1 and put extra copy on stack
100!<L # Continue Loop if 100 >= Number (destroys copy)
]dsLx # Enter Loop
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.
DeviousYarn
each { x range(1 100)
? { divisible(x 3)
p:'Fizz' }
? { divisible(x 5)
p:'Buzz' }
-? { !:divisible(x 3)
p:x }
o
}
Draco
proc nonrec main() void:
byte i;
for i from 1 upto 100 do
if i % 15 = 0 then writeln("FizzBuzz")
elif i % 5 = 0 then writeln("Buzz")
elif i % 3 = 0 then writeln("Fizz")
else writeln(i)
fi
od
corp
DUP
FizzBuzz, realized using two different methods for string/character output:
Output to STDOUT via single character output.
[$$3/%$[]['F,'i,'z,'z,]?\5/%$[]['B,'u,'z,'z,]?*[$.][]?10,]c: {define function c: mod 3, mod 5 tests, print proper output}
0[$100<][1+c;!]# {loop from 1 to 100}
Output to STDOUT, using stored strings and a separately defined string output operator:
[\[^^>][$;,1+]#%%]⇒P {define operator P: print stored string}
[$$3/%$[][0$"Fizz"P]?\5/%$[][0$"Buzz"P]?*[$.][]?10,]c: {define function c: mod 3, mod 5 tests, print according output}
0[$100<][1+c;!]# {loop from 1 to 100}
DWScript
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;
Dyalect
var n = 1
while n < 20 {
if n % 15 == 0 {
print("fizzbuzz")
} else if n % 3 == 0 {
print("fizz")
} else if n % 5 == 0 {
print("buzz")
} else {
print(n)
}
n = n + 1
}
- Output:
1 2 fizz 4 buzz fizz 7 8 fizz buzz 11 fizz 13 14 fizzbuzz 16 17 fizz 19
Déjà Vu
for i range 1 100:
if = 0 % i 15:
"FizzBuzz"
elseif = 0 % i 3:
"Fizz"
elseif = 0 % i 5:
"Buzz"
else:
i
!print
E
for i in 1..100 {
println(switch ([i % 3, i % 5]) {
match [==0, ==0] { "FizzBuzz" }
match [==0, _ ] { "Fizz" }
match [_, ==0] { "Buzz" }
match _ { i }
})
}
EasyLang
for i = 1 to 100
if i mod 15 = 0
print "FizzBuzz"
elif i mod 5 = 0
print "Buzz"
elif i mod 3 = 0
print "Fizz"
else
print i
.
.
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);
Ecstasy
module FizzBuzz {
void run() {
@Inject Console console;
for (Int x : 1..100) {
console.print(switch (x % 3, x % 5) {
case (0, 0): "FizzBuzz";
case (0, _): "Fizz";
case (_, 0): "Buzz";
case (_, _): x.toString();
});
}
}
}
Ed
H
a
100
.
# iota.ed
g/[^0-9]{1,}/s///g
,p
# decimal -> unary
g/^0+([0-9])/s//\1/
g/^9([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiiii/
g/^8([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiii/
g/^7([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiii/
g/^6([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiii/
g/^5([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiii/
g/^4([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiii/
g/^3([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iii/
g/^2([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2ii/
g/^1([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2i/
g/^0([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2/
g/^9([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiiii/
g/^8([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiii/
g/^7([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiii/
g/^6([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiii/
g/^5([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiii/
g/^4([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiii/
g/^3([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iii/
g/^2([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2ii/
g/^1([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2i/
g/^0([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2/
g/^9([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiiii/
g/^8([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiii/
g/^7([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiii/
g/^6([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiii/
g/^5([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiii/
g/^4([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiii/
g/^3([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iii/
g/^2([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2ii/
g/^1([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2i/
g/^0([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2/
g/^9([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiiii/
g/^8([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiii/
g/^7([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiii/
g/^6([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiii/
g/^5([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiii/
g/^4([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiii/
g/^3([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iii/
g/^2([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2ii/
g/^1([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2i/
g/^0([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2/
g/^9([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiiii/
g/^8([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiii/
g/^7([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiii/
g/^6([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiii/
g/^5([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiii/
g/^4([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiii/
g/^3([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iii/
g/^2([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2ii/
g/^1([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2i/
g/^0([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2/
# iota logic
s/\B/\
/g
a
.
y
d
g/i/x\
s/.*/&i/\
-1d\
y
# fizzbuzz
g/^(i{15})+$/s//FizzBuzz/
g/^(i{5})+$/s//Buzz/
g/^(i{3})+$/s//Fizz/
# unary -> decimal (for 0-10000 range)
g/i{9000}(i{0,999})/s//9\1/
g/i{8000}(i{0,999})/s//8\1/
g/i{7000}(i{0,999})/s//7\1/
g/i{6000}(i{0,999})/s//6\1/
g/i{5000}(i{0,999})/s//5\1/
g/i{4000}(i{0,999})/s//4\1/
g/i{3000}(i{0,999})/s//3\1/
g/i{2000}(i{0,999})/s//2\1/
g/i{1000}(i{0,999})/s//1\1/
v/^[0-9]i*$/s/.*/0&/
g/i{900}(i{0,99})/s//9\1/
g/i{800}(i{0,99})/s//8\1/
g/i{700}(i{0,99})/s//7\1/
g/i{600}(i{0,99})/s//6\1/
g/i{500}(i{0,99})/s//5\1/
g/i{400}(i{0,99})/s//4\1/
g/i{300}(i{0,99})/s//3\1/
g/i{200}(i{0,99})/s//2\1/
g/i{100}(i{0,99})/s//1\1/
v/^[0-9]{2}i*$/s/^([0-9])(i*)$/\10\2/
g/i{90}(i{0,9})/s//9\1/
g/i{80}(i{0,9})/s//8\1/
g/i{70}(i{0,9})/s//7\1/
g/i{60}(i{0,9})/s//6\1/
g/i{50}(i{0,9})/s//5\1/
g/i{40}(i{0,9})/s//4\1/
g/i{30}(i{0,9})/s//3\1/
g/i{20}(i{0,9})/s//2\1/
g/i{10}(i{0,9})/s//1\1/
v/^[0-9]{3}i*$/s/^([0-9]{2})(i*)$/\10\2/
g/i{9}/s//9/
g/i{8}/s//8/
g/i{7}/s//7/
g/i{6}/s//6/
g/i{5}/s//5/
g/i{4}/s//4/
g/i{3}/s//3/
g/i{2}/s//2/
g/i{1}/s//1/
v/^[0-9]{4}i*$/s/^([0-9]{3})(i*)$/\10\2/
g/^0+([0-9])/s//\1/
g/0F1zz/s//Fizz/
g/0Buzz/s//Buzz/
,p
Q
Eero
#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
Egel
import "prelude.eg"
import "io.ego"
using System
using IO
def fizzbuzz =
[ 100 -> print "100\n"
| N ->
if and ((N%3) == 0) ((N%5) == 0) then
let _ = print "fizz buzz, " in fizzbuzz (N+1)
else if (N%3) == 0 then
let _ = print "fizz, " in fizzbuzz (N+1)
else if (N%5) == 0 then
let _ = print "buzz, " in fizzbuzz (N+1)
else
let _ = print N ", " in fizzbuzz (N+1) ]
def main = fizzbuzz 1
Eiffel
class
APPLICATION
create
make
feature
make
do
fizzbuzz
end
fizzbuzz
--Numbers up to 100, prints "Fizz" instead of multiples of 3, and "Buzz" for multiples of 5.
--For multiples of both 3 and 5 prints "FizzBuzz".
do
across
1 |..| 100 as c
loop
if c.item \\ 15 = 0 then
io.put_string ("FIZZBUZZ%N")
elseif c.item \\ 3 = 0 then
io.put_string ("FIZZ%N")
elseif c.item \\ 5 = 0 then
io.put_string ("BUZZ%N")
else
io.put_string (c.item.out + "%N")
end
end
end
end
Ela
open list
prt x | x % 15 == 0 = "FizzBuzz"
| x % 3 == 0 = "Fizz"
| x % 5 == 0 = "Buzz"
| else = x
[1..100] |> map prt
Elixir
Standard approaches
used case
Enum.each 1..100, fn x ->
IO.puts(case { rem(x,3) == 0, rem(x,5) == 0 } do
{ true, true } -> "FizzBuzz"
{ true, false } -> "Fizz"
{ false, true } -> "Buzz"
{ false, false } -> x
end)
end
Alternate approach using pipes and cond:
#!/usr/bin/env elixir
1..100 |> Enum.map(fn i ->
cond do
rem(i,3*5) == 0 -> "FizzBuzz"
rem(i,3) == 0 -> "Fizz"
rem(i,5) == 0 -> "Buzz"
true -> i
end
end) |> Enum.each(fn i -> IO.puts i end)
used Stream.cycle version:
defmodule RC do
def fizzbuzz(limit \\ 100) do
fizz = Stream.cycle(["", "", "Fizz"])
buzz = Stream.cycle(["", "", "", "", "Buzz"])
Stream.zip(fizz, buzz)
|> Enum.take(limit)
|> Enum.with_index
|> Enum.each(fn {{f,b},i} ->
IO.puts if f<>b=="", do: i+1, else: f<>b
end)
end
end
RC.fizzbuzz
Yet another approach:
defmodule FizzBuzz do
def fizzbuzz(n) when rem(n, 15) == 0, do: "FizzBuzz"
def fizzbuzz(n) when rem(n, 5) == 0, do: "Buzz"
def fizzbuzz(n) when rem(n, 3) == 0, do: "Fizz"
def fizzbuzz(n), do: n
end
Enum.each(1..100, &IO.puts FizzBuzz.fizzbuzz &1)
used anonymous function
f = fn(n) when rem(n,15)==0 -> "FizzBuzz"
(n) when rem(n,5)==0 -> "Fizz"
(n) when rem(n,3)==0 -> "Buzz"
(n) -> n
end
for n <- 1..100, do: IO.puts f.(n)
Enum.at version: Returns nil if index is out of bounds.
Enum.each(1..100, fn i ->
str = "#{Enum.at([:Fizz], rem(i,3))}#{Enum.at([:Buzz], rem(i,5))}"
IO.puts if str=="", do: i, else: str
end)
A macro too far
The Stream.cycle version above, but as an overpowered FizzBuzz DSL.
defmodule BadFizz do
# Hand-rolls a bunch of AST before injecting the resulting FizzBuzz code.
defmacrop automate_fizz(fizzers, n) do
# To begin, we need to process fizzers to produce the various components
# we're using in the final assembly. As told by Mickens telling as Antonio
# Banderas, first you must specify a mapping function:
build_parts = (fn {fz, n} ->
ast_ref = {fz |> String.downcase |> String.to_atom, [], __MODULE__}
clist = List.duplicate("", n - 1) ++ [fz]
cycle = quote do: unquote(ast_ref) = unquote(clist) |> Stream.cycle
{ast_ref, cycle}
end)
# ...and then a reducing function:
collate = (fn
({ast_ref, cycle}, {ast_refs, cycles}) ->
{[ast_ref | ast_refs], [cycle | cycles]}
end)
# ...and then, my love, when you are done your computation is ready to run
# across thousands of fizzbuzz:
{ast_refs, cycles} = fizzers
|> Code.eval_quoted([], __ENV__) |> elem(0) # Gotta unwrap this mystery code~
|> Enum.sort(fn ({_, ap}, {_, bp}) -> ap < bp end) # Sort so that Fizz, 3 < Buzz, 5
|> Enum.map(build_parts)
|> Enum.reduce({[], []}, collate)
# Setup the anonymous functions used by Enum.reduce to build our AST components.
# This was previously handled by List.foldl, but ejected because reduce/2's
# default behavior reduces repetition.
#
# ...I was tempted to move these into a macro themselves, and thought better of it.
build_zip = fn (varname, ast) ->
quote do: Stream.zip(unquote(varname), unquote(ast))
end
build_tuple = fn (varname, ast) ->
{:{}, [], [varname, ast]}
end
build_concat = fn (varname, ast) ->
{:<>,
[context: __MODULE__, import: Kernel], # Hygiene values may change; accurate to Elixir 1.1.1
[varname, ast]}
end
# Toss cycles into a block by hand, then smash ast_refs into
# a few different computations on the cycle block results.
cycles = {:__block__, [], cycles}
tuple = ast_refs |> Enum.reduce(build_tuple)
zip = ast_refs |> Enum.reduce(build_zip)
concat = ast_refs |> Enum.reduce(build_concat)
# Finally-- Now that all our components are assembled, we can put
# together the fizzbuzz stream pipeline. After quote ends, this
# block is injected into the caller's context.
quote do
unquote(cycles)
unquote(zip)
|> Stream.with_index
|> Enum.take(unquote(n))
|> Enum.each(fn
{unquote(tuple), i} ->
ccats = unquote(concat)
IO.puts if ccats == "", do: i + 1, else: ccats
end)
end
end
@doc ~S"""
A fizzing, and possibly buzzing function. Somehow, you feel like you've
seen this before. An old friend, suddenly appearing in Kafkaesque nightmare...
...or worse, during a whiteboard interview.
"""
def fizz(n \\ 100) when is_number(n) do
# In reward for all that effort above, we now have the latest in
# programmer productivity:
#
# A DSL for building arbitrary fizzing, buzzing, bazzing, and more!
[{"Fizz", 3},
{"Buzz", 5}#,
#{"Bar", 7},
#{"Foo", 243}, # -> Always printed last (largest number)
#{"Qux", 34}
]
|> automate_fizz(n)
end
end
BadFizz.fizz(100) # => Prints to stdout
Elm
A bit too simple:
import Html exposing (text)
import List exposing (map)
main =
[1..100] |> map getWordForNum |> text
getWordForNum num =
if num % 15 == 0 then
"FizzBuzz"
else if num % 3 == 0 then
"Fizz"
else if num % 5 == 0 then
"Buzz"
else
String.fromInt num
A bit too clever:
import Html exposing (text)
import List exposing (map)
import String exposing (join, fromInt)
main : Html.Html
main =
[1..100] |> map fizzbuzz |> join " " |> text
fizzbuzz : Int -> String
fizzbuzz num =
let
fizz = if num % 3 == 0 then "Fizz" else ""
buzz = if num % 5 == 0 then "Buzz" else ""
in
if fizz == buzz then
fromInt num
else
fizz ++ buzz
Emacs Lisp
(defun fizzbuzz (n)
(cond ((and (zerop (% n 5)) (zerop (% n 3))) "FizzBuzz")
((zerop (% n 3)) "Fizz")
((zerop (% n 5)) "Buzz")
(t n)))
;; loop & print from 0 to 100
(dotimes (i 101)
(message "%s" (fizzbuzz i)))
EMal
logic isFizz, isBuzz
for int count = 1; count <= 100; ++count
isFizz = count % 3 == 0
isBuzz = count % 5 == 0
if isFizz and isBuzz do writeLine("Fizz Buzz")
else if isFizz do writeLine("Fizz")
else if isBuzz do writeLine("Buzz")
else do writeLine(count)
end
end
Emojicode
Simple 1
🏁🍇
🔂 i 🆕⏩ 1 101 1 ❗ 🍇
↪️ i 🚮 15 🙌 0 🍇
😀 🔤FizzBuzz🔤 ❗
🍉
🙅↪️ i 🚮 3 🙌 0 🍇
😀 🔤Fizz🔤 ❗
🍉
🙅↪️ i 🚮 5 🙌 0 🍇
😀 🔤Buzz🔤 ❗
🍉🙅🍇
😀 🔤🧲i🧲🔤 ❗
🍉
🍉
🍉
Simple 2
🏁🍇
🔂 i 🆕⏩ 1 101 1 ❗ 🍇
🔤🔤 ➡️ 🖍🆕 msg
↪️ i 🚮 3 🙌 0 🍇
🔤Fizz🔤 ➡️ 🖍 msg
🍉
↪️ i 🚮 5 🙌 0 🍇
🔤🧲msg🧲Buzz🔤 ➡️ 🖍 msg
🍉
↪️ msg 🙌 🔤🔤 🍇
😀 🔤🧲i🧲🔤 ❗
🍉🙅🍇
😀 🔤🧲msg🧲🔤 ❗
🍉
🍉
🍉
Enguage
FizzBuzz
This source code is supposed to look like plain old English but is, in fact, executable. When used in an Android app, it gives the user direct access to computational abilities of your phone.
It is taken from the dictionary entry for fizzbuzz
This shows the interpretation of two utterances, the latter of which are called recursively. Enguage is not very efficient, but that's not its goal!
NB. Any line beginning with a '#' is a comment, like Unix shells, but any comment following the ']' character are unit tests exercising this code.
On "what is the fizzbuzz of N": is N divisible by 5 and 3; if so, reply "fizzbuzz"; is N divisible by 5; if so, reply "buzz"; is N divisible by 3; if so, reply "fizz"; reply "N". On "do fizzbuzz between N and LIMIT": what is the fizzbuzz of N; remember this; set next to the evaluation of N + 1; NEXT is equal to LIMIT; if so, what is the fizzbuzz of LIMIT; if not, do fizzbuzz between NEXT and LIMIT. #] what is the fizzbuzz of 1: 1. #] what is the fizzbuzz of 12: fizz. #] what is the fizzbuzz of 25: buzz. #] what is the fizzbuzz of 75: fizzbuzz. #] set limit to 5. #] do fizzbuzz between 1 and LIMIT.
On downloading this repo, if git and make are installed, this unit test can be run with:
$ git clone https://github.com/martinwheatman/enguage.git $ cd enguage $ make jar $ export PATH=$PATH:./sbin $ java -jar lib/enguage.jar -T fizzbuzz
Output:
TEST: fizzbuzz ============== user> what is the fizzbuzz of 1. enguage> 1. user> what is the fizzbuzz of 12. enguage> fizz. user> what is the fizzbuzz of 25. enguage> buzz. user> what is the fizzbuzz of 75. enguage> fizzbuzz. user> set limit to 5. enguage> ok , limit is set to 5. user> do fizzbuzz between 1 and LIMIT. enguage> 1 . 2 . fizz . 4 . buzz. 1 test group(s) found +++ PASSED 6 tests in 442ms +++
Erlang
-spec fizzbuzz() -> Result :: string().
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,
lists:flatten([[F(N)] ++ ["\n"] || N <- lists:seq(1,100)]).
ERRE
PROGRAM FIZZ_BUZZ
!
! for rosettacode.org
!
BEGIN
FOR A=1 TO 100 DO
IF A MOD 15=0 THEN
PRINT("FizzBuzz")
ELSIF A MOD 3=0 THEN
PRINT("Fizz")
ELSIF A MOD 5=0 THEN
PRINT("Buzz")
ELSE
PRINT(A)
END IF
END FOR
END PROGRAM
Euler
The original Euler implementations did not allow "long" strings, hence the use of a list here to print FizzBuzz.
begin new i; label iLoop; i <- 0; iLoop: if [ i <- i + 1 ] <= 100 then begin out if i mod 15 = 0 then ( "Fizz", "Buzz" ) else if i mod 5 = 0 then "Buzz" else if i mod 3 = 0 then "Fizz" else i; goto iLoop end else 0 end $
Euphoria
This is based on the VBScript example.
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" )
F#
let fizzbuzz n =
match n%3 = 0, n%5 = 0 with
| true, false -> "fizz"
| false, true -> "buzz"
| true, true -> "fizzbuzz"
| _ -> string n
let printFizzbuzz() =
[1..100] |> List.iter (fizzbuzz >> printfn "%s")
[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)
Another example using (unnecessary) partial active pattern :D
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")
Factor
USING: math kernel io math.functions math.parser 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
More flexible variant without divisibility tests.
USING: kernel sequences arrays generalizations fry math math.parser prettyprint ;
IN: fizzbuzz
: zz ( m seq -- v ) dup length 1 <array> V{ } clone 4 -nrot 1 4 -nrot 3 nrot
'[ dup _ <= ]
3 -nrot
'[
"" _ [ _ [ swap execute( str n -- str n ) ] change-nth ] each-index
dup empty? [ drop dup number>string ] [ ] if swapd suffix! swap 1 +
]
while drop ;
: fizz ( str n -- str n ) dup 3 < [ 1 + ] [ drop "Fizz" append 1 ] if ;
: buzz ( str n -- str n ) dup 5 < [ 1 + ] [ drop "Buzz" append 1 ] if ;
: quxx ( str n -- str n ) dup 7 < [ 1 + ] [ drop "Quxx" append 1 ] if ;
: FizzBuzzQuxx ( m -- v ) { fizz buzz quxx } zz ;
: FizzBuzzQuxx-100 ( -- ) 100 FizzBuzzQuxx . ;
MAIN: FizzBuzzQuxx-100
Another approach is leverage Factor's predicate and intersection classes.
USING: io kernel math math.functions math.parser ranges
sequences ;
IN: rosetta-code.fizz-buzz
PREDICATE: fizz < integer 3 divisor? ;
PREDICATE: buzz < integer 5 divisor? ;
INTERSECTION: fizzbuzz fizz buzz ;
GENERIC: fizzbuzz>string ( n -- str )
M: fizz fizzbuzz>string
drop "Fizz" ;
M: buzz fizzbuzz>string
drop "Buzz" ;
M: fizzbuzz fizzbuzz>string
drop "FizzBuzz" ;
M: integer fizzbuzz>string
number>string ;
MAIN: [ 1 100 [a..b] [ fizzbuzz>string print ] each ]
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
FALSE
See FizzBuzz/EsoLang
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)
}
}
}
FBSL
No 'MOD 15' needed.
#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
- 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...
Fe
There is no built-in mod function, but you can add it via the C API.
static fe_Object *mod(fe_Context *ctx, fe_Object *args) {
fe_Number n = fe_tonumber(ctx, fe_nextarg(ctx, &args));
return fe_number(ctx, fmod(n, fe_tonumber(ctx, fe_nextarg(ctx, &args))));
}
Then, you can solve 'FizzBuzz' the traditional way:
(= i 0)
(while (< i 100)
(= i (+ i 1))
(print
(if (is (mod i 15) 0) "FizzBuzz"
(is (mod i 3) 0) "Fizz"
(is (mod i 5) 0) "Buzz"
i)))
Of course, you can solve this without mod:
(= i 0)
(= fizz 0)
(= buzz 0)
(= fizzbuzz 0)
(while (< i 100)
(= i (+ i 1))
(= fizz (+ fizz 1))
(= buzz (+ buzz 1))
(= fizzbuzz (+ fizzbuzz 1))
; check and reset counters
(print
(if (is fizzbuzz 15) (do (= fizzbuzz 0) (= fizz 0) (= buzz 0) "fizzbuzz")
(is fizz 3) (do (= fizz 0) "fizz")
(is buzz 5) (do (= buzz 0) "buzz")
i)))
Fennel
(for [i 1 100]
(print (if (= (% i 15) 0) :FizzBuzz
(= (% i 3) 0) :Fizz
(= (% i 5) 0) :Buzz
i)))
Use pattern matching and recursive function:
(fn fizz-buzz [from to]
(print (match [(% from 3) (% from 5)]
[0 0] :FizzBuzz
[0 _] :Fizz
[_ 0] :Buzz
_ from))
(when (< from to)
(fizz-buzz (+ from 1) to)))
(fizz-buzz 1 100)
Alternative matching pattern:
(for [i 1 100]
(print (match (% i 15)
0 :FizzBuzz
(where (or 3 6 9 12)) :Fizz
(where (or 5 10) :Buzz
_ i)))
FOCAL
FITR is a built-in function that truncates a floating-point number to an integer. Note that FOCAL uses an arithmetic (three-way) IF statement, rather like early Fortran.
01.10 FOR I=1,100; DO 2.0
01.20 QUIT
02.10 SET ZB=I/15 - FITR(I/15)
02.20 IF (ZB) 2.4, 2.3, 2.4
02.30 TYPE "FizzBuzz" !
02.35 RETURN
02.40 SET Z=I/3 - FITR(I/3)
02.50 IF (Z) 2.7, 2.6, 2.7
02.60 TYPE "Fizz" !
02.65 RETURN
02.70 SET B=I/5 - FITR(I/5)
02.80 IF (B) 2.99, 2.9, 2.99
02.90 TYPE "Buzz" !
02.95 RETURN
02.99 TYPE %3, I, !
Fermat
for i = 1 to 100 do if i|15=0 then !'FizzBuzz ' else if i|5=0 then !'Buzz ' else if i|3=0 then !'Fizz ' else !i;!' ' fi fi fi od
- 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
Fish
Forth
table-driven
: 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 , ' . , ' . ,
or the classic approach
: .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
the well factored approach
SYNONYM is a Forth200x word.
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
the unrolled approach
: n ( n -- n+1 ) dup . 1+ ;
: f ( n -- n+1 ) ." Fizz " 1+ ;
: b ( n -- n+1 ) ." Buzz " 1+ ;
: fb ( n -- n+1 ) ." FizzBuzz " 1+ ;
: fb10 ( n -- n+10 ) n n f n b f n n f b ;
: fb15 ( n -- n+15 ) fb10 n f n n fb ;
: fb100 ( n -- n+100 ) fb15 fb15 fb15 fb15 fb15 fb15 fb10 ;
: .fizzbuzz ( -- ) 1 fb100 drop ;
Fortran
In ANSI FORTRAN 77 or later use structured IF-THEN-ELSE (example uses some ISO Fortran 90 features):
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
This example uses If statements to print "Fizz" and "Buzz" next to each other if the number is divisible by 3 and 5 by waiting to use a line break until after the If statements.
program FizzBuzz
implicit none
integer :: i = 1
do i = 1, 100
if (Mod(i,3) == 0)write(*,"(A)",advance='no') "Fizz"
if (Mod(i,5) == 0)write(*,"(A)",advance='no') "Buzz"
if (Mod(i,3) /= 0 .and. Mod(i,5) /=0 )write(*,"(I3)",advance='no') i
print *, ""
end do
end program FizzBuzz
In ISO Fortran 90 or later use SELECT-CASE statement:
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
FreeBASIC
See FizzBuzz/Basic
Frege
gen n word = cycle (take (n - 1) (repeat "") ++ [word])
pattern = zipWith (++) (gen 3 "fizz") (gen 5 "buzz")
fizzbuzz = zipWith combine pattern [1..] where
combine word number = if null word
then show number
else word
show $ take 100 fizzbuzz
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[]
}
FutureBasic
include "NSLog.incl"
long fizz, buzz, i
for i = 1 to 100
fizz = (i mod 3 )
buzz = (i mod 5 )
if fizz + buzz == 0 then NSLog(@"FizzBuzz") : continue
if fizz == 0 then NSLog(@"Fizz") : continue
if buzz == 0 then NSLog(@"Buzz") : continue
NSLog(@"%ld",i)
next i
HandleEvents
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
Fōrmulæ
Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.
Programs in Fōrmulæ are created/edited online in its website.
In this page you can see and run the program(s) related to this task and their results. You can also change either the programs or the parameters they are called with, for experimentation, but remember that these programs were created with the main purpose of showing a clear solution of the task, and they generally lack any kind of validation.
Solution
Gambas
Click this link to run this code
Public Sub Main()
Dim siCount As Short
Dim sText As String
For siCount = 1 To 100
sText = ""
If siCount Mod 3 = 0 Then sText = "Fizz"
If siCount Mod 5 = 0 Then sText = "Buzz"
If siCount Mod 15 = 0 Then sText = "FizzBuzz"
If sText Then Print sText Else Print siCount
Next
End
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
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;
GDScript
extends Node
func _ready():
for i in range(1, 101):
if i % 15 == 0:
print("FizzBuzz")
elif i % 3 == 0:
print("Fizz")
elif i % 5 == 0:
print("Buzz")
else:
print(i)
get_tree().quit()
Genyris
@prefix u "http://www.genyris.org/lang/utilities#"
def fizzbuzz (n)
map-left ^((3 = 'fizz') (5 = 'buzz'))
lambda (d)
cond
(equal? 0 (% n d!left))
d!right
else
''
for n in (range 1 100)
define fb (''(.join (fizzbuzz n)))
u:format "%a\n"
cond
(equal? fb '')
n
else
fb
GFA Basic
' Fizz Buzz
'
FOR i%=1 TO 100
IF i% MOD 15=0
PRINT "FizzBuzz"
ELSE IF i% MOD 3=0
PRINT "Fizz"
ELSE IF i% MOD 5=0
PRINT "Buzz"
ELSE
PRINT i%
ENDIF
NEXT i%
Gleam
import gleam/int
import gleam/io
import gleam/iterator
pub fn main() {
iterator.range(1, 101)
|> iterator.map(to_fizzbuzz)
|> iterator.map(io.println)
|> iterator.run
}
fn to_fizzbuzz(n: Int) -> String {
case n % 3, n % 5 {
0, 0 -> "FizzBuzz"
0, _ -> "Fizz"
_, 0 -> "Buzz"
_, _ -> int.to_string(n)
}
}
Go
switch/case approach
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)
}
}
}
map approach
package main
import "fmt"
func main() {
for i := 1; i <= 100; i++ {
fmt.Println(map[bool]map[bool]interface{}{
false: {false: i, true: "Fizz"}, true: {false: "Buzz", true: "FizzBuzz"},
}[i%5 == 0][i%3 == 0])
}
}
Golfscript
100,{)6,{.(&},{1$1$%{;}{4*35+6875*25base{90\-}%}if}%\or}%n*
Golo
module FizzBuzz
augment java.lang.Integer {
function getFizzAndOrBuzz = |this| -> match {
when this % 15 == 0 then "FizzBuzz"
when this % 3 == 0 then "Fizz"
when this % 5 == 0 then "Buzz"
otherwise this
}
}
function main = |args| {
foreach i in [1..101] {
println(i: getFizzAndOrBuzz())
}
}
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)
}
One liner version (I added new lines to better readability but when you omit them it's one liner):
// 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)
}
Groovy
1.upto(100) { i -> println "${i % 3 ? '' : 'Fizz'}${i % 5 ? '' : 'Buzz'}" ?: i }
GW-BASIC
See FizzBuzz/Basic
Hare
use fmt;
export fn main() void = {
for (let i = 1z; i <= 100; i += 1) {
fmt::println(
if (i % 15 == 0) "FizzBuzz"
else if (i % 3 == 0) "Fizz"
else if (i % 5 == 0) "Buzz"
else i
)!;
};
};
Haskell
Variant directly implementing the specification:
fizzbuzz :: Int -> String
fizzbuzz x
| f 15 = "FizzBuzz"
| f 3 = "Fizz"
| f 5 = "Buzz"
| otherwise = show x
where
f = (0 ==) . rem x
main :: IO ()
main = mapM_ (putStrLn . fizzbuzz) [1 .. 100]
fizzbuzz :: Int -> String
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 ""
main :: IO ()
main = putStr $ concatMap fizzbuzz [1 .. 100]
Does not perform the mod 15 step, extesible to arbitrary addtional tests, ex: [bar| n `mod` 7 == 0].
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"
Alternate implementation using lazy infinite lists and avoiding use of "mod":
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"])
Or in terms (still without mod or rem) of an applicative ZipList:
import Control.Applicative ( ZipList(ZipList, getZipList) )
fizzBuzz :: [String]
fizzBuzz =
getZipList $ go <$>
ZipList (cycle $ replicate 2 [] <> ["fizz"]) <*>
ZipList (cycle $ replicate 4 [] <> ["buzz"]) <*>
ZipList (show <$> [1 ..])
go :: String -> String -> String -> String
go f b n
| null f && null b = n
| otherwise = f <> b
main :: IO ()
main = mapM_ putStrLn $ take 100 fizzBuzz
or using an applicative test:
import Data.Bool (bool)
fizzBuzz :: [String]
fizzBuzz =
let fb n k = cycle $ replicate (pred n) [] <> [k]
in zipWith
(flip . bool <*> null)
(zipWith (<>) (fb 3 "fizz") (fb 5 "buzz"))
(show <$> [1 ..])
main :: IO ()
main = mapM_ putStrLn $ take 100 fizzBuzz
Using heavy artillery (needs the mtl package):
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"
Using guards plus where.
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]
An elegant solution exploiting monoidal and applicative properties of functions:
import Data.Monoid
fizzbuzz = max
<$> show
<*> "fizz" `when` divisibleBy 3
<> "buzz" `when` divisibleBy 5
<> "quxx" `when` divisibleBy 7
where
when m p x = if p x then m else mempty
divisibleBy n x = x `mod` n == 0
main = mapM_ (putStrLn . fizzbuzz) [1..100]
And pattern matching approach:
fizzbuzz n = case (rem n 3, rem n 5) of
(0, 0) -> "FizzBuzz"
(0, _) -> "Fizz"
(_, 0) -> "Buzz"
(_, _) -> show n
main = mapM_ (putStrLn . fizzbuzz) [1..100]
Generalised solution:
wordthing :: [(Int, String)] -> Int -> String
wordthing lst n =
if matches == [] then
show n
else
concat $ map snd matches
where matches = filter (\x -> n `mod` (fst x) == 0) lst
fizzbuzz :: Int -> String
fizzbuzz = wordthing [(3, "Fizz"), (5, "Buzz")]
main = do
mapM_ (putStrLn . fizzbuzz) [1..100]
hexiscript
for let i 1; i <= 100; i++
if i % 3 = 0 && i % 5 = 0; println "FizzBuzz"
elif i % 3 = 0; println "Fizz"
elif i % 5 = 0; println "Buzz"
else println i; endif
endfor
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
Alternatively:
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
HolyC
U8 i;
for (i = 1; i <= 100; i++) {
if (!(i % 15))
Print("FizzBuzz");
else if (!(i % 3))
Print("Fizz");
else if (!(i % 5))
Print("Buzz");
else
Print("%d", i);
Print("\n");
}
Hoon
:- %say
|= [^ ~ ~]
:- %noun
%+ turn (gulf [1 101])
|= a=@
=+ q=[=(0 (mod a 3)) =(0 (mod a 5))]
?+ q <a>
[& &] "FizzBuzz"
[& |] "Fizz"
[| &] "Buzz"
==
Huginn
import Algorithms as algo;
main( argv_ ) {
if ( size( argv_ ) < 2 ) {
throw Exception( "usage: fizzbuzz {NUM}" );
}
top = integer( argv_[1] );
for ( i : algo.range( 1, top + 1 ) ) {
by3 = ( i % 3 ) == 0;
by5 = ( i % 5 ) == 0;
if ( by3 ) {
print( "fizz" );
}
if ( by5 ) {
print( "buzz" );
}
if ( ! ( by3 || by5 ) ) {
print( i );
}
print( "\n" );
}
return ( 0 );
}
Hy
(for [i (range 1 101)] (print (cond
[(not (% i 15)) "FizzBuzz"]
[(not (% i 5)) "Buzz"]
[(not (% i 3)) "Fizz"]
[True i])))
i
software {
for each 1 to 100
if i % 15 = 0
print("FizzBuzz")
else if i % 3 = 0
print("Fizz")
else if i % 5 = 0
print("Buzz")
else
print(i)
end
end
}
Icon and Unicon
Idris
partial
fizzBuzz : Nat -> String
fizzBuzz n = if (n `modNat` 15) == 0 then "FizzBuzz"
else if (n `modNat` 3) == 0 then "Fizz"
else if (n `modNat` 5) == 0 then "Buzz"
else show n
main : IO ()
main = sequence_ $ map (putStrLn . fizzBuzz) [1..100]
Inform 6
[ 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 "^";
}
];
Inform 7
(Does not work in the current version of Inform 7)
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.
(Version which is less "programmy", and more in the natural English style of interactive fiction.)
The space is a room. An item is a kind of thing. In the space are 100 items.
To say the name:
let the count be the number of items carried by the player;
say "[if the count is the count to the nearest 15]fizzbuzz.[otherwise if the count is the count to the nearest 3]fizz.[otherwise if the count is the count to the nearest 5]buzz.[otherwise][the count in words].".
To count:
if an item is in the space
begin;
let the next one be a random item in the space; silently try taking the next one;
say "[the name]" in sentence case;
count;
end the story;
end if.
When play begins: count. Use no scoring.
Insitux
(function fizzbuzz n
(match (map (rem n) [3 5])
[0 0] "FizzBuzz"
[0 _] "Fizz"
[_ 0] "Buzz"
n))
(loop 100 i
(-> i inc fizzbuzz print))
Io
Here's one way to do it:
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
)
)
And here's a port of the Ruby version, which I personally prefer:
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
)
And here is another more idiomatic version:
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
)
Ioke
(1..100) each(x,
cond(
(x % 15) zero?, "FizzBuzz" println,
(x % 3) zero?, "Fizz" println,
(x % 5) zero?, "Buzz" println
)
)
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
IS-BASIC
See FizzBuzz/Basic
J
Perhaps the most concise approach would be >((2#.3 q:15&+.){(|.(;~,&;);:'Fizz Buzz');~":)&>1+i.100
(The above is a live link to a browser based implementation of fizzbuzz in J. To see how this expression works, remove the leading > leaving items in boxes rather than on lines by themselves. And, then, replace the { with ; which means that instead of using the left argument to select (index) from a list of boxes, the left argument is appended in a box to the left of those boxes. Perhaps also replace the 100 with 20 to shrink the result size. If you remove the 1+i.20 (or 1+i.100) entirely, that would display as the verb (function) which is applied to each number.)
Other approaches are possible:
Solution _1: Using agenda (@.) as a switch:
classify =: +/@(1 2 * 0 = 3 5&|~)
(":@]`('Fizz'"_)`('Buzz'"_)`('FizzBuzz'"_) @. classify "0) >:i.100
Solution 0
> }. (<'FizzBuzz') (I.0=15|n)} (<'Buzz') (I.0=5|n)} (<'Fizz') (I.0=3|n)} ":&.> n=: i.101
Solution 1
Fizz=: 'Fizz' #~ 0 = 3&|
Buzz=: 'Buzz' #~ 0 = 5&|
FizzBuzz=: ": [^:('' -: ]) Fizz,Buzz
FizzBuzz"0 >: i.100
Solution 2 (has taste of table-driven template programming)
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
Solution 3 (depends on an obsolete feature of @ in f`g`h@p)
'`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
Solution 4 (relatively concise):
;:inv}.(":&.> [^:(0 = #@])&.> [: ,&.>/ (;:'Fizz Buzz') #&.>~ 0 = 3 5 |/ ])i.101
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 Fiz...
Here's some intermediate results for subexpressions of this last version (but with a shorter list of numbers):
i.10
0 1 2 3 4 5 6 7 8 9
(3 5 |/ ])i.10
0 1 2 0 1 2 0 1 2 0
0 1 2 3 4 0 1 2 3 4
(0=3 5 |/ ])i.10
1 0 0 1 0 0 1 0 0 1
1 0 0 0 0 1 0 0 0 0
(;:'Fizz Buzz')
┌────┬────┐
│Fizz│Buzz│
└────┴────┘
((;:'Fizz Buzz') #&.>~0=3 5 |/ ])i.10
┌────┬┬┬────┬┬────┬────┬┬┬────┐
│Fizz│││Fizz││ │Fizz│││Fizz│
├────┼┼┼────┼┼────┼────┼┼┼────┤
│Buzz│││ ││Buzz│ │││ │
└────┴┴┴────┴┴────┴────┴┴┴────┘
([: ,&.>/ (;:'Fizz Buzz') #&.>~0=3 5 |/ ])i.10
┌────────┬┬┬────┬┬────┬────┬┬┬────┐
│FizzBuzz│││Fizz││Buzz│Fizz│││Fizz│
└────────┴┴┴────┴┴────┴────┴┴┴────┘
(":&.>)i.10
┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
│0│1│2│3│4│5│6│7│8│9│
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
(":&.> [^:(0 = #@])&.> [: ,&.>/ (;:'Fizz Buzz') #&.>~0=3 5 |/ ])i.10
┌────────┬─┬─┬────┬─┬────┬────┬─┬─┬────┐
│FizzBuzz│1│2│Fizz│4│Buzz│Fizz│7│8│Fizz│
└────────┴─┴─┴────┴─┴────┴────┴─┴─┴────┘
}.(":&.> [^:(0 = #@])&.> [: ,&.>/ (;:'Fizz Buzz') #&.>~0=3 5 |/ ])i.10
┌─┬─┬────┬─┬────┬────┬─┬─┬────┐
│1│2│Fizz│4│Buzz│Fizz│7│8│Fizz│
└─┴─┴────┴─┴────┴────┴─┴─┴────┘
;:inv}.(":&.> [^:(0 = #@])&.> [: ,&.>/ (;:'Fizz Buzz') #&.>~0=3 5 |/ ])i.10
1 2 Fizz 4 Buzz Fizz 7 8 Fizz
Janet
(loop [i :range [1 101]
:let [fizz (zero? (% i 3))
buzz (zero? (% i 5))]]
(print (cond
(and fizz buzz) "fizzbuzz"
fizz "fizz"
buzz "buzz"
i)))
Java
public class FizzBuzz {
public static void main(String[] args) {
for (int number = 1; number <= 100; number++) {
if (number % 15 == 0) {
System.out.println("FizzBuzz");
} else if (number % 3 == 0) {
System.out.println("Fizz");
} else if (number % 5 == 0) {
System.out.println("Buzz");
} else {
System.out.println(number);
}
}
}
}
Or:
public class FizzBuzz {
public static void main(String[] args) {
int number = 1;
while (number <= 100) {
if (number % 15 == 0) {
System.out.println("FizzBuzz");
} else if (number % 3 == 0) {
System.out.println("Fizz");
} else if (number % 5 == 0) {
System.out.println("Buzz");
} else {
System.out.println(number);
}
number++;
}
}
}
Or:
public class FizzBuzz {
public static void main(String[] args) {
int number = 1;
while (number <= 100) {
System.out.println(number % 15 == 0 ? "FizzBuzz" : number % 3 == 0 ? "Fizz" : number % 5 == 0 ? "Buzz" : number);
number++;
}
}
}
Or:
import java.util.stream.IntStream;
class FizzBuzzJdk12 {
public static void main(String[] args) {
IntStream.range(1,101)
.mapToObj(i->switch (i%15) {
case 0 -> "FizzBuzz";
case 3, 6, 9, 12 -> "Fizz";
case 5, 10 -> "Buzz";
default -> Integer.toString(i);
})
.forEach(System.out::println)
;
}
}
Or:
import java.util.stream.IntStream;
class FizzBuzzJdk12 {
static final int FIZZ_FLAG = 0x8000_0000;
static final int BUZZ_FLAG = 0x4000_0000;
static final int FIZZ_BUZZ_FLAG = FIZZ_FLAG|BUZZ_FLAG;
static final int[] FLAGS = new int[] {
FIZZ_BUZZ_FLAG|0, 1, 2, FIZZ_FLAG|3, 4,
BUZZ_FLAG|5, FIZZ_FLAG|6, 7, 8, FIZZ_FLAG|9,
BUZZ_FLAG|10, 11, FIZZ_FLAG|12, 13, 14
};
public static void main(String[] args) {
IntStream.iterate(0,i->++i)
.flatMap(i -> IntStream.range(0,15).map(j->FLAGS[j]+15*i))
.mapToObj(
// JDK12 switch expression ...
n-> switch(n & FIZZ_BUZZ_FLAG) {
case FIZZ_BUZZ_FLAG -> "fizzbuzz";
case FIZZ_FLAG -> "fizz";
case BUZZ_FLAG -> "buzz";
default -> Integer.toString(~FIZZ_BUZZ_FLAG & n);
}
)
.skip(1)
.limit(100)
.forEach(System.out::println)
;
}
}
JavaScript
ES5
var fizzBuzz = function () {
var i, output;
for (i = 1; i < 101; i += 1) {
output = '';
if (!(i % 3)) { output += 'Fizz'; }
if (!(i % 5)) { output += 'Buzz'; }
console.log(output || i);//empty string is false, so we short-circuit
}
};
Alternate version with ghetto pattern matching
for (var i = 1; i <= 100; i++) {
console.log({
truefalse: 'Fizz',
falsetrue: 'Buzz',
truetrue: 'FizzBuzz'
}[(i%3==0) + '' + (i%5==0)] || i)
}
Or very tersely:
for(i=1;i<101;i++)console.log((x=(i%3?'':'Fizz')+(i%5?'':'Buzz'))?x:i);
Or with even less characters:
for(i=1;i<101;i++)console.log((i%3?'':'Fizz')+(i%5?'':'Buzz')||i)
Or, in a more functional style, without mutations
(function rng(i) {
return i ? rng(i - 1).concat(i) : []
})(100).map(
function (n) {
return n % 3 ? (
n % 5 ? n : "Buzz"
) : (
n % 5 ? "Fizz" : "FizzBuzz"
)
}
).join(' ')
ES6
(() => {
// FIZZBUZZ --------------------------------------------------------------
// fizzBuzz :: Int -> String
const fizzBuzz = n =>
caseOf(n, [
[x => x % 15 === 0, "FizzBuzz"],
[x => x % 3 === 0, "Fizz"],
[x => x % 5 === 0, "Buzz"]
], n.toString());
// GENERIC FUNCTIONS -----------------------------------------------------
// caseOf :: a -> [(a -> Bool, b)] -> b -> b
const caseOf = (e, pvs, otherwise) =>
pvs.reduce((a, [p, v]) =>
a !== otherwise ? a : (p(e) ? v : a), otherwise);
// enumFromTo :: Int -> Int -> [Int]
const enumFromTo = (m, n) =>
Array.from({
length: Math.floor(n - m) + 1
}, (_, i) => m + i);
// map :: (a -> b) -> [a] -> [b]
const map = (f, xs) => xs.map(f);
// unlines :: [String] -> String
const unlines = xs => xs.join('\n');
// TEST ------------------------------------------------------------------
return unlines(
map(fizzBuzz, enumFromTo(1, 100))
);
})();
A functional implementation:
const factors = [[3, 'Fizz'], [5, 'Buzz']]
const fizzBuzz = num => factors.map(([factor,text]) => (num % factor)?'':text).join('') || num
const range1 = x => [...Array(x+1).keys()].slice(1)
const outputs = range1(100).map(fizzBuzz)
console.log(outputs.join('\n'))
Or composing generic functions, and without use of modulo (or other) numeric tests:
(() => {
'use strict';
// main :: IO ()
const main = () => {
// FIZZBUZZ ---------------------------------------
// fizzBuzz :: Generator [String]
const fizzBuzz = () => {
const fb = n => k => cycle(
replicate(n - 1)('').concat(k)
);
return zipWith(
liftA2(flip)(bool)(isNull)
)(
zipWith(append)(fb(3)('fizz'))(fb(5)('buzz'))
)(fmap(str)(enumFrom(1)));
};
// TEST -------------------------------------------
console.log(
unlines(
take(100)(
fizzBuzz()
)
)
);
};
// GENERIC FUNCTIONS ----------------------------------
// Just :: a -> Maybe a
const Just = x => ({
type: 'Maybe',
Nothing: false,
Just: x
});
// Nothing :: Maybe a
const Nothing = () => ({
type: 'Maybe',
Nothing: true,
});
// Tuple (,) :: a -> b -> (a, b)
const Tuple = a => b => ({
type: 'Tuple',
'0': a,
'1': b,
length: 2
});
// append (++) :: [a] -> [a] -> [a]
// append (++) :: String -> String -> String
const append = xs => ys => xs.concat(ys);
// bool :: a -> a -> Bool -> a
const bool = f => t => p =>
p ? t : f;
// cycle :: [a] -> Generator [a]
function* cycle(xs) {
const lng = xs.length;
let i = 0;
while (true) {
yield(xs[i])
i = (1 + i) % lng;
}
}
// enumFrom :: Int => Int -> [Int]
function* enumFrom(x) {
let v = x;
while (true) {
yield v;
v = 1 + v;
}
}
// flip :: (a -> b -> c) -> b -> a -> c
const flip = f =>
x => y => f(y)(x);
// fmap <$> :: (a -> b) -> Gen [a] -> Gen [b]
const fmap = f =>
function*(gen) {
let v = take(1)(gen);
while (0 < v.length) {
yield(f(v[0]))
v = take(1)(gen)
}
};
// fst :: (a, b) -> a
const fst = tpl => tpl[0];
// isNull :: [a] -> Bool
// isNull :: String -> Bool
const isNull = xs =>
1 > xs.length;
// Returns Infinity over objects without finite length.
// This enables zip and zipWith to choose the shorter
// argument when one is non-finite, like cycle, repeat etc
// length :: [a] -> Int
const length = xs =>
(Array.isArray(xs) || 'string' === typeof xs) ? (
xs.length
) : Infinity;
// liftA2 :: (a0 -> b -> c) -> (a -> a0) -> (a -> b) -> a -> c
const liftA2 = op => f => g =>
// Lift a binary function to a composition
// over two other functions.
// liftA2 (*) (+ 2) (+ 3) 7 == 90
x => op(f(x))(g(x));
// replicate :: Int -> a -> [a]
const replicate = n => x =>
Array.from({
length: n
}, () => x);
// snd :: (a, b) -> b
const snd = tpl => tpl[1];
// str :: a -> String
const str = x => x.toString();
// take :: Int -> [a] -> [a]
// take :: Int -> String -> String
const take = n => xs =>
'GeneratorFunction' !== xs.constructor.constructor.name ? (
xs.slice(0, n)
) : [].concat.apply([], Array.from({
length: n
}, () => {
const x = xs.next();
return x.done ? [] : [x.value];
}));
// The first argument is a sample of the type
// allowing the function to make the right mapping
// uncons :: [a] -> Maybe (a, [a])
const uncons = xs => {
const lng = length(xs);
return (0 < lng) ? (
lng < Infinity ? (
Just(Tuple(xs[0])(xs.slice(1))) // Finite list
) : (() => {
const nxt = take(1)(xs);
return 0 < nxt.length ? (
Just(Tuple(nxt[0])(xs))
) : Nothing();
})() // Lazy generator
) : Nothing();
};
// unlines :: [String] -> String
const unlines = xs => xs.join('\n');
// zipWith :: (a -> b -> c) Gen [a] -> Gen [b] -> Gen [c]
const zipWith = f => ga => gb => {
function* go(ma, mb) {
let
a = ma,
b = mb;
while (!a.Nothing && !b.Nothing) {
let
ta = a.Just,
tb = b.Just
yield(f(fst(ta))(fst(tb)));
a = uncons(snd(ta));
b = uncons(snd(tb));
}
}
return go(uncons(ga), uncons(gb));
};
// MAIN ---
return main();
})();
Joy
The following program first defines a function "out", that handles the Fizz / Buzz logic, and then loops from 1 to 100 mapping the function onto each number, and printing ("put") the output.
DEFINE out == [[[15 rem null] "FizzBuzz"]
[[ 3 rem null] "Fizz"]
[[ 5 rem null] "Buzz"]
[]] cond
[putchars pop] [put] ifstring '\n putch.
100 [] [out] primrec.
jq
range(1;101)
| if . % 15 == 0 then "FizzBuzz"
elif . % 5 == 0 then "Buzz"
elif . % 3 == 0 then "Fizz"
else .
end
Another solution:
range(100) + 1 | [(
(select(. % 3 == 0) | "Fizz"),
(select(. % 5 == 0) | "Buzz")
) // tostring] | join("")
Julia
One basic solution:
for i in 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
Another possible solution:
collect(i % 15 == 0 ? "FizzBuzz" : i % 5 == 0 ? "Buzz" : i % 3 == 0 ? "Fizz" : i for i in 1:100) |> println
A 3rd possible solution:
fb(i::Integer) = "Fizz" ^ (i % 3 == 0) * "Buzz" ^ (i % 5 == 0) * string(i) ^ (i % 3 != 0 && i % 5 != 0)
for i in 1:100 println(fb(i)) end
A 4th one:
println.(map(fb, 1:100))
A fifth (DRY, Don't Repeat Yourself) possible solution:
for i in 1:100
msg = "Fizz" ^ (i % 3 == 0) * "Buzz" ^ (i % 5 == 0)
println(isempty(msg) ? i : msg)
end
K
Solution 0
`0:\:{:[0=#a:{,/$(:[0=x!3;"Fizz"];:[0=x!5;"Buzz"])}@x;$x;a]}'1_!101
Solution 1
fizzbuzz:{:[0=x!15;`0:,"FizzBuzz";0=x!3;`0:,"Fizz";0=x!5;`0:,"Buzz";`0:,$x]}
fizzbuzz' 1+!100
Solution 2
fizzbuzz:{
v:1+!x
i:(&0=)'v!/:3 5 15
r:@[v;i 0;{"Fizz"}]
r:@[r;i 1;{"Buzz"}]
@[r;i 2;{"FizzBuzz"}]}
`0:$fizzbuzz 100
Solution 3
For kona:
{,/$(s;x)@~#s:`Fizz`Buzz@&~x!'3 5}'1+!30
For k6 and oK, change x!'3 5
to 3 5!'x
.
Kamailio Script
To run it, send a SIP message to the server and FizzBuzz will appear in the logs.
This will only work up to 100 because Kamailio terminates all while loops after 100 iterations.
# FizzBuzz
log_stderror=yes
loadmodule "pv"
loadmodule "xlog"
route {
$var(i) = 1;
while ($var(i) <= 1000) {
if ($var(i) mod 15 == 0) {
xlog("FizzBuzz\n");
} else if ($var(i) mod 5 == 0) {
xlog("Buzz\n");
} else if ($var(i) mod 3 == 0) {
xlog("Fizz\n");
} else {
xlog("$var(i)\n");
}
$var(i) = $var(i) + 1;
}
}
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);
}
KL1
:- module main.
main :-
nats(100, Nats),
fizzbuzz(Nats, Output),
display(Output).
nats(Max, Out) :-
nats(Max, 1, Out).
nats(Max, Count, Out) :- Count =< Max |
Out = [Count|NewOut],
NewCount := Count + 1,
nats(Max, NewCount, NewOut).
nats(Max, Count, Out) :- Count > Max |
Out = [].
fizzbuzz([N|Rest], Out) :- N mod 3 =:= 0, N mod 5 =:= 0 |
Out = ['FizzBuzz' | NewOut],
fizzbuzz(Rest, NewOut).
fizzbuzz([], Out) :-
Out = [].
alternatively.
fizzbuzz([N|Rest], Out) :- N mod 3 =:= 0 |
Out = ['Fizz' | NewOut],
fizzbuzz(Rest, NewOut).
fizzbuzz([N|Rest], Out) :- N mod 5 =:= 0 |
Out = ['Buzz' | NewOut],
fizzbuzz(Rest, NewOut).
alternatively.
fizzbuzz([N|Rest], Out) :-
Out = [N | NewOut],
fizzbuzz(Rest, NewOut).
display([Message|Rest]) :-
io:outstream([print(Message), nl]),
display(Rest).
display([]).
Klong
{:[0=x!15;:FizzBuzz:|0=x!5;:Buzz:|0=x!3;:Fizz;x]}'1+!100
Kotlin
Imperative solution
fun fizzBuzz() {
for (number in 1..100) {
println(
when {
number % 15 == 0 -> "FizzBuzz"
number % 3 == 0 -> "Fizz"
number % 5 == 0 -> "Buzz"
else -> number
}
)
}
}
Functional solution 1
fun fizzBuzz1() {
fun fizzBuzz(x: Int) = if (x % 15 == 0) "FizzBuzz" else x.toString()
fun fizz(x: Any) = if (x is Int && x % 3 == 0) "Buzz" else x
fun buzz(x: Any) = if (x is Int && x.toInt() % 5 == 0) "Fizz" else x
(1..100).map { fizzBuzz(it) }.map { fizz(it) }.map { buzz(it) }.forEach { println(it) }
}
Functional solution 2
fun fizzBuzz2() {
fun fizz(x: Pair<Int, StringBuilder>) = if(x.first % 3 == 0) x.apply { second.append("Fizz") } else x
fun buzz(x: Pair<Int, StringBuilder>) = if(x.first % 5 == 0) x.apply { second.append("Buzz") } else x
fun none(x: Pair<Int, StringBuilder>) = if(x.second.isBlank()) x.second.apply { append(x.first) } else x.second
(1..100).map { Pair(it, StringBuilder()) }
.map { fizz(it) }
.map { buzz(it) }
.map { none(it) }
.forEach { println(it) }
}
Short version with mapOf
fun fizzBuzz() {
(1..100).forEach { println(mapOf(0 to it, it % 3 to "Fizz", it % 5 to "Buzz", it % 15 to "FizzBuzz")[0]) }
}
KQL
range i from 1 to 100 step 1
| project Result =
case(
i % 15 == 0, "FizzBuzz",
i % 3 == 0, "Fizz",
i % 5 == 0, "Buzz",
tostring(i)
)
KSI
`plain
[1 100] `for pos : n ~
out = []
n `mod 3 == 0 ? out.# = 'Fizz' ;
n `mod 5 == 0 ? out.# = 'Buzz' ;
(out `or n) #write_ln #
;
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.
Lambdatalk
1. direct:
{S.map
{lambda {:i}
{if {= {% :i 15} 0}
then fizzbuzz
else {if {= {% :i 3} 0}
then fizz
else {if {= {% :i 5} 0}
then buzz
else :i}}}}
{S.serie 1 100}}
-> 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
2. via a function
{def fizzbuzz
{lambda {:i :n}
{if {> :i :n}
then .
else {if {= {% :i 15} 0}
then fizzbuzz
else {if {= {% :i 3} 0}
then fizz
else {if {= {% :i 5} 0}
then buzz
else :i}}} {fizzbuzz {+ :i 1} :n}
}}}
-> fizzbuzz
{fizzbuzz 1 100}
-> same as above.
Lang
$i = 1
while($i <= 100) {
if($i % 15 == 0) {
fn.println(FizzBuzz)
}elif($i % 5 == 0) {
fn.println(Buzz)
}elif($i % 3 == 0) {
fn.println(Fizz)
}else {
fn.println($i)
}
$i += 1
}
langur
for i of 100 {
writeln switch(0; i rem 15: "FizzBuzz"; i rem 5: "Buzz"; i rem 3: "Fizz"; i)
}
Lasso
with i in generateSeries(1, 100)
select ((#i % 3 == 0 ? 'Fizz' | '') + (#i % 5 == 0 ? 'Buzz' | '') || #i)
LaTeX
This version uses the ifthen and intcalc packages. There sure are more native solutions including solutions in plain TeX, but for me this is a readable and comprehensible one.
\documentclass{minimal}
\usepackage{ifthen}
\usepackage{intcalc}
\newcounter{mycount}
\newboolean{fizzOrBuzz}
\newcommand\fizzBuzz[1]{%
\setcounter{mycount}{1}\whiledo{\value{mycount}<#1}
{
\setboolean{fizzOrBuzz}{false}
\ifthenelse{\equal{\intcalcMod{\themycount}{3}}{0}}{\setboolean{fizzOrBuzz}{true}Fizz}{}
\ifthenelse{\equal{\intcalcMod{\themycount}{5}}{0}}{\setboolean{fizzOrBuzz}{true}Buzz}{}
\ifthenelse{\boolean{fizzOrBuzz}}{}{\themycount}
\stepcounter{mycount}
\\
}
}
\begin{document}
\fizzBuzz{101}
\end{document}
LDPL
data:
i is number
n is number
procedure:
for i from 1 to 101 step 1 do
modulo i by 15 in n
if n is equal to 0 then
display "FizzBuzz" lf
continue
end if
modulo i by 5 in n
if n is equal to 0 then
display "Buzz" lf
continue
end if
modulo i by 3 in n
if n is equal to 0 then
display "Fizz" lf
continue
end if
display i lf
repeat
Lean
Lean 4:
def fizz : String :=
"Fizz"
def buzz : String :=
"Buzz"
def newLine : String :=
"\n"
def isDivisibleBy (n : Nat) (m : Nat) : Bool :=
match m with
| 0 => false
| (k + 1) => (n % (k + 1)) = 0
def getTerm (n : Nat) : String :=
if (isDivisibleBy n 15) then (fizz ++ buzz)
else if (isDivisibleBy n 3) then fizz
else if (isDivisibleBy n 5) then buzz
else toString (n)
def range (a : Nat) (b : Nat) : List (Nat) :=
match b with
| 0 => []
| m + 1 => a :: (range (a + 1) m)
def getTerms (n : Nat) : List (String) :=
(range 1 n).map (getTerm)
def addNewLine (accum : String) (elem : String) : String :=
accum ++ elem ++ newLine
def fizzBuzz : String :=
(getTerms 100).foldl (addNewLine) ("")
def main : IO Unit :=
IO.println (fizzBuzz)
#eval main
Liberty BASIC
See FizzBuzz/Basic
LIL
# fizzbuzz in LIL
for {set i 1} {$i <= 100} {inc i} {
set show ""
if {[expr $i % 3 == 0]} {set show "Fizz"}
if {[expr $i % 5 == 0]} {set show $show"Buzz"}
if {[expr [length $show] == 0]} {set show $i}
print $show
}
- Output:
prompt$ lil fizzbuzz.lil | sed -n '1,16p' 1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16
LiveCode
repeat with i = 1 to 100
switch
case i mod 15 = 0
put "FizzBuzz" & cr after fizzbuzz
break
case i mod 5 = 0
put "Buzz" & cr after fizzbuzz
break
case i mod 3 = 0
put "Fizz" & cr after fizzbuzz
break
default
put i & cr after fizzbuzz
end switch
end repeat
put fizzbuzz
LiveScript
See: http://livescript.net/blog/fizzbuzzbazz.html
[1 to 100] map -> [k + \zz for k, v of {Fi: 3, Bu: 5} | it % v < 1] * '' || it
LLVM
; ModuleID = 'fizzbuzz.c'
; source_filename = "fizzbuzz.c"
; target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
; target triple = "x86_64-pc-windows-msvc19.21.27702"
; This is not strictly LLVM, as it uses the C library function "printf".
; LLVM does not provide a way to print values, so the alternative would be
; to just load the string into memory, and that would be boring.
; Additional comments have been inserted, as well as changes made from the output produced by clang such as putting more meaningful labels for the jumps
$"\01??_C@_09NODAFEIA@FizzBuzz?6?$AA@" = comdat any
$"\01??_C@_05KEBFOHOF@Fizz?6?$AA@" = comdat any
$"\01??_C@_05JKJENPHA@Buzz?6?$AA@" = comdat any
$"\01??_C@_03PMGGPEJJ@?$CFd?6?$AA@" = comdat any
;--- String constant defintions
@"\01??_C@_09NODAFEIA@FizzBuzz?6?$AA@" = linkonce_odr unnamed_addr constant [10 x i8] c"FizzBuzz\0A\00", comdat, align 1
@"\01??_C@_05KEBFOHOF@Fizz?6?$AA@" = linkonce_odr unnamed_addr constant [6 x i8] c"Fizz\0A\00", comdat, align 1
@"\01??_C@_05JKJENPHA@Buzz?6?$AA@" = linkonce_odr unnamed_addr constant [6 x i8] c"Buzz\0A\00", comdat, align 1
@"\01??_C@_03PMGGPEJJ@?$CFd?6?$AA@" = linkonce_odr unnamed_addr constant [4 x i8] c"%d\0A\00", comdat, align 1
;--- The declaration for the external C printf function.
declare i32 @printf(i8*, ...)
; Function Attrs: noinline nounwind optnone uwtable
define i32 @main() #0 {
%1 = alloca i32, align 4
store i32 1, i32* %1, align 4
;--- It does not seem like this branch can be removed
br label %loop
;--- while (i <= 100)
loop:
%2 = load i32, i32* %1, align 4
%3 = icmp sle i32 %2, 100
br i1 %3, label %divisible_15, label %finished
;--- if (i % 15 == 0)
divisible_15:
%4 = load i32, i32* %1, align 4
%5 = srem i32 %4, 15
%6 = icmp eq i32 %5, 0
br i1 %6, label %print_fizzbuzz, label %divisible_3
;--- Print 'FizzBuzz'
print_fizzbuzz:
%7 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @"\01??_C@_09NODAFEIA@FizzBuzz?6?$AA@", i32 0, i32 0))
br label %next
;--- if (i % 3 == 0)
divisible_3:
%8 = load i32, i32* %1, align 4
%9 = srem i32 %8, 3
%10 = icmp eq i32 %9, 0
br i1 %10, label %print_fizz, label %divisible_5
;--- Print 'Fizz'
print_fizz:
%11 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @"\01??_C@_05KEBFOHOF@Fizz?6?$AA@", i32 0, i32 0))
br label %next
;--- if (i % 5 == 0)
divisible_5:
%12 = load i32, i32* %1, align 4
%13 = srem i32 %12, 5
%14 = icmp eq i32 %13, 0
br i1 %14, label %print_buzz, label %print_number
;--- Print 'Buzz'
print_buzz:
%15 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @"\01??_C@_05JKJENPHA@Buzz?6?$AA@", i32 0, i32 0))
br label %next
;--- Print the number
print_number:
%16 = load i32, i32* %1, align 4
%17 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @"\01??_C@_03PMGGPEJJ@?$CFd?6?$AA@", i32 0, i32 0), i32 %16)
;--- It does not seem like this branch can be removed
br label %next
;--- i = i + 1
next:
%18 = load i32, i32* %1, align 4
%19 = add nsw i32 %18, 1
store i32 %19, i32* %1, align 4
br label %loop
;--- exit main
finished:
ret i32 0
}
attributes #0 = { noinline nounwind optnone uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
!llvm.module.flags = !{!0, !1}
!llvm.ident = !{!2}
!0 = !{i32 1, !"wchar_size", i32 2}
!1 = !{i32 7, !"PIC Level", i32 2}
!2 = !{!"clang version 6.0.1 (tags/RELEASE_601/final)"}
Lobster
include "std.lobster"
forbias(100, 1) i:
fb := (i % 3 == 0 and "fizz" or "") +
(i % 5 == 0 and "buzz" or "")
print fb.length and fb or "" + i
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 #]
"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:
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]
Lhogho can use the above code, except that 'modulo' must be replaced with 'remainder'.
LOLCODE
See FizzBuzz/EsoLang
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)
Lua
If/else Ladder
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
Concatenation
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 = i
end
print(output)
end
Quasi bit field
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
Lookup table
local t = {
[0] = "FizzBuzz",
[3] = "Fizz",
[5] = "Buzz",
[6] = "Fizz",
[9] = "Fizz",
[10] = "Buzz",
[12] = "Fizz"
}
for i = 1, 100 do
print(t[i%15] or i)
end
Metatable insertion
Sets any numeric key to its fizzbuzz value so that fizzbuzz[30] is "fizzbuzz"
local mt = {
__newindex = (function (t, k, v)
if type(k) ~= "number" then rawset(t, k, v)
elseif 0 == (k % 15) then rawset(t, k, "fizzbuzz")
elseif 0 == (k % 5) then rawset(t, k, "fizz")
elseif 0 == (k % 3) then rawset(t, k, "buzz")
else rawset(t, k, k) end
return t[k]
end)
}
local fizzbuzz = {}
setmetatable(fizzbuzz, mt)
for i=1,100 do fizzbuzz[i] = i end
for i=1,100 do print(fizzbuzz[i]) end
Fast Version without Modulo
#!/usr/bin/env luajit
local to=arg[1] or tonumber(arg[1]) or 100
local CF,CB=3,5
local cf,cb=CF,CB
for i=1,to do
cf,cb=cf-1,cb-1
if cf~=0 and cb~=0 then
io.write(i)
else
if cf==0 then
cf=CF
io.write("Fizz")
end
if cb==0 then
cb=CB
io.write("Buzz")
end
end
io.write(", ")
end
- Output:
> ./fizzbuzz.lua 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, %
Luck
for i in range(1,101) do (
if i%15 == 0 then print("FizzBuzz")
else if i%3 == 0 then print("Fizz")
else if i%5 == 0 then print("Buzz")
else print(i)
)
M2000 Interpreter
\\ one line, hard to read
For i=1 to 100 {If i mod 3=0 Then {if i mod 5=0 Then Print "FizzBuzz", Else Print "Fizz",} Else {if i mod 5=0 Then Print "Buzz", else print i, } } : Print
\\ Better code
For i=1 to 100 {
Push str$(i,0)+". "+if$(i mod 3=0->"Fizz","")+if$(i mod 5=0->"Buzz","")
If stackitem$()="" then Drop : Continue
Print Letter$
}
\\ Far Better Code
For i=1 to 100 {
Printme(if$(i mod 3=0->"Fizz","")+if$(i mod 5=0->"Buzz",""))
}
Print
Sub Printme(a$)
If a$<>"" Then Print a$, else Print i,
End Sub
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)')')
')
MACRO-11
.TITLE FIZBUZ
.MCALL .TTYOUT,.EXIT
FIZBUZ::MOV #1,R2 ; COUNTER
MOV #3,R3 ; FIZZ COUNTER
MOV #5,R4 ; BUZZ COUNTER
NUMBER: CLR R5
CHKFIZ: DEC R3
BNE CHKBUZ
MOV #FIZZ,R1
JSR PC,PRSTR
MOV #3,R3
INC R5
CHKBUZ: DEC R4
BNE CHKNUM
MOV #BUZZ,R1
JSR PC,PRSTR
MOV #5,R4
INC R5
CHKNUM: TST R5
BNE NEXNUM
MOV R2,R0
JSR PC,PR0
NEXNUM: MOV #NL,R1
JSR PC,PRSTR
INC R2
CMP R2,#^D100
BLE NUMBER
.EXIT
; STRING DATA
FIZZ: .ASCIZ /FIZZ/
BUZZ: .ASCIZ /BUZZ/
NL: .BYTE 15,12,0
.EVEN
; PRINT NUMBER IN R0 AS DECIMAL
PR0: MOV R2,-(SP)
MOV #4$,R1
1$: MOV #-1,R2
2$: INC R2
SUB #12,R0
BCC 2$
ADD #72,R0
MOVB R0,-(R1)
MOV R2,R0
BNE 1$
3$: MOVB (R1)+,R0
.TTYOUT
BNE 3$
MOV (SP)+,R2
RTS PC
.ASCII /...../
4$: .BYTE 0
; PRINT STRING IN R1
PRSTR: MOVB (R1)+,R0
.TTYOUT
BNE PRSTR
RTS PC
.END FIZBUZ
MAD
NORMAL MODE IS INTEGER
VECTOR VALUES FIZZ = $4HFIZZ*$
VECTOR VALUES BUZZ = $4HBUZZ*$
VECTOR VALUES FIBU = $8HFIZZBUZZ*$
VECTOR VALUES NUM = $I2*$
INTERNAL FUNCTION REM.(A,B) = A-(A/B)*B
THROUGH LOOP, FOR I = 1, 1, I .G. 100
WHENEVER REM.(I,15).E.0
PRINT FORMAT FIBU
OR WHENEVER REM.(I,5).E.0
PRINT FORMAT BUZZ
OR WHENEVER REM.(I,3).E.0
PRINT FORMAT FIZZ
OTHERWISE
PRINT FORMAT NUM,I
LOOP END OF CONDITIONAL
END OF PROGRAM
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
Maple
One line:
seq(print(`if`(modp(n,3)=0,`if`(modp(n,15)=0,"FizzBuzz","Fizz"),`if`(modp(n,5)=0,"Buzz",n))),n=1..100):
With a fizzbuzz function defined:
fizzbuzz1 := n->`if`(modp(n,3)=0,`if`(modp(n,15)=0,"FizzBuzz","Fizz"),`if`(modp(n,5)=0,"Buzz",n)):
for i to 100 do fizzbuzz1(i); od;
Using piecewise:
fizzbuzz2 := n->piecewise(modp(n,15)=0,"FizzBuzz",modp(n,3)=0,"Fizz",modp(n,5)=0,"Buzz",n):
for i to 100 do fizzbuzz2(i); od;
Using conventional if/then branches:
fizzbuzz3 := proc(n) local r;
r:=map2(modp,n,[3,5]);
if r=[0,0] then "FizzBuzz"
elif r[1]=0 then "Fizz"
elif r[2]=0 then "Buzz"
else n fi;
end proc:
for i to 100 do fizzbuzz3(i); od;
Mathematica / Wolfram Language
Do[Print[Which[Mod[i, 15] == 0, "FizzBuzz", Mod[i, 5] == 0, "Buzz", Mod[i, 3] == 0, "Fizz", True, i]], {i, 100}]
Using rules,
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"}
Using rules, but different approach:
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]]
An extendible version using Table
Table[If[# === "", i, #]&@StringJoin[
Table[If[Divisible[i, First@nw], Last@nw, ""],
{nw, {{3, "Fizz"}, {5, "Buzz"}}}]],
{i, 1, 100}]
Another one-liner using Map (the /@ operator shorthand of it) and a pure function with a very readable Which
Which[ Mod[#,15] == 0, "FizzBuzz", Mod[#, 3] == 0, "Fizz", Mod[#,5]==0, "Buzz", True, #]& /@ Range[1,100]
Additional examples using DownValue pattern matching, the first without Mod'ing 15:
f[n_] := f[n, Mod[n, {3, 5}]]
f[_, {0, 0}] := "FizzBuzz"
f[_, {0, _}] := "Fizz"
f[_, {_, 0}] := "Buzz"
f[n_, {_, _}] := n
f /@ Range[100]
f[n_] := f[n, Mod[n, 15]]
f[_, 0] := "FizzBuzz"
f[n_, _] := f[n, Mod[n, {3, 5}]]
f[_, {0, _}] := "Fizz"
f[_, {_, 0}] := "Buzz"
f[n_, {_, _}] := n
f /@ Range[100]
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).
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
Here's a more extendible version that uses disp() to print the output:
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
straightforward
x = string(1:100);
x(3:3:$) = 'Fizz';
x(5:5:$) = 'Buzz';
x(3*5:3*5:$) = 'FizzBuzz'
Maxima
for n:1 thru 100 do
if mod(n, 15) = 0 then (sprint("FizzBuzz"), newline())
elseif mod(n, 3) = 0 then (sprint("Fizz"), newline())
elseif mod(n,5) = 0 then (sprint("Buzz"), newline())
else (sprint(n), newline());
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)
)
)
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");
}
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.
fizz(N) = ( if N mod 3 = 0 then yes else no ).
:- func buzz(int) = bool.
buzz(N) = ( if N mod 5 = 0 then yes else no ).
% N 3? 5?
:- func fizzbuzz(int, bool, bool) = string.
fizzbuzz(_, yes, yes) = "FizzBuzz".
fizzbuzz(_, yes, no) = "Fizz".
fizzbuzz(_, no, yes) = "Buzz".
fizzbuzz(N, no, no) = 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(fizzbuzz(N, fizz(N), buzz(N)), !IO),
io.nl(!IO),
( if N < To then
main(N + 1, To, !IO)
else
true
).
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
Microsoft Small Basic
For n = 1 To 100
op = ""
If Math.Remainder(n, 3) = 0 Then
op = "Fizz"
EndIf
IF Math.Remainder(n, 5) = 0 Then
op = text.Append(op, "Buzz")
EndIf
If op = "" Then
TextWindow.WriteLine(n)
Else
TextWindow.WriteLine(op)
EndIf
EndFor
min
0 (
succ false :hit
(3 mod 0 ==) ("Fizz" print! true @hit) when
(5 mod 0 ==) ("Buzz" print! true @hit) when
(hit) (print) unless newline
) 100 times
Minimal BASIC
See FizzBuzz/Basic
MiniScript
for i in range(1,100)
if i % 15 == 0 then
print "FizzBuzz"
else if i % 3 == 0 then
print "Fizz"
else if i % 5 == 0 then
print "Buzz"
else
print i
end if
end for
MIPS Assembly
#################################
# Fizz Buzz #
# MIPS Assembly targetings MARS #
# By Keith Stellyes #
# August 24, 2016 #
#################################
# $a0 left alone for printing
# $a1 stores our counter
# $a2 is 1 if not evenly divisible
.data
fizz: .asciiz "Fizz\n"
buzz: .asciiz "Buzz\n"
fizzbuzz: .asciiz "FizzBuzz\n"
newline: .asciiz "\n"
.text
loop:
beq $a1,100,exit
add $a1,$a1,1
#test for counter mod 15 ("FIZZBUZZ")
div $a2,$a1,15
mfhi $a2
bnez $a2,loop_not_fb #jump past the fizzbuzz print logic if NOT MOD 15
#### PRINT FIZZBUZZ: ####
li $v0,4 #set syscall arg to PRINT_STRING
la $a0,fizzbuzz #set the PRINT_STRING arg to fizzbuzz
syscall #call PRINT_STRING
j loop #return to start
#### END PRINT FIZZBUZZ ####
loop_not_fb:
div $a2,$a1,3 #divide $a1 (our counter) by 3 and store remainder in HI
mfhi $a2 #retrieve remainder (result of MOD)
bnez $a2, loop_not_f #jump past the fizz print logic if NOT MOD 3
#### PRINT FIZZ ####
li $v0,4
la $a0,fizz
syscall
j loop
#### END PRINT FIZZ ####
loop_not_f:
div $a2,$a1,5
mfhi $a2
bnez $a2,loop_not_b
#### PRINT BUZZ ####
li $v0,4
la $a0,buzz
syscall
j loop
#### END PRINT BUZZ ####
loop_not_b:
#### PRINT THE INTEGER ####
li $v0,1 #set syscall arg to PRINT_INTEGER
move $a0,$a1 #set PRINT_INTEGER arg to contents of $a1
syscall #call PRINT_INTEGER
### PRINT THE NEWLINE CHAR ###
li $v0,4 #set syscall arg to PRINT_STRING
la $a0,newline
syscall
j loop #return to beginning
exit:
li $v0,10
syscall
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
Miranda
main :: [sys_message]
main = [Stdout (lay (map fizzbuzz [1..100]))]
fizzbuzz :: num->[char]
fizzbuzz n = "FizzBuzz", if n mod 15 = 0
= "Fizz", if n mod 3 = 0
= "Buzz", if n mod 5 = 0
= show n, otherwise
ML
Standard ML
First using two helper functions, one for deciding what to output and another for performing recursion with an auxiliary argument j.
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
Second using the standard-library combinator List.tabulate and a helper function, fb, that calculates and prints the output.
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
mLite
local
fun fizzbuzz'
(x mod 15 = 0) = "FizzBuzz"
| (x mod 5 = 0) = "Buzz"
| (x mod 3 = 0) = "Fizz"
| x = ntos x
in
fun fizzbuzz
([], s) = rev s
| (x :: xs, s) = fizzbuzz (xs, fizzbuzz' x :: s)
| (x :: xs) = fizzbuzz (x :: xs, [])
end
;
println ` fizzbuzz ` iota 100;
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)
Modula-2
MODULE Fizzbuzz;
FROM FormatString IMPORT FormatString;
FROM Terminal IMPORT WriteString,WriteLn,ReadChar;
TYPE CB = PROCEDURE(INTEGER);
PROCEDURE Fizz(n : INTEGER);
BEGIN
IF n MOD 3 = 0 THEN
WriteString("Fizz");
Buzz(n,Newline)
ELSE
Buzz(n,WriteInt)
END
END Fizz;
PROCEDURE Buzz(n : INTEGER; f : CB);
BEGIN
IF n MOD 5 = 0 THEN
WriteString("Buzz");
WriteLn
ELSE
f(n)
END
END Buzz;
PROCEDURE WriteInt(n : INTEGER);
VAR buf : ARRAY[0..9] OF CHAR;
BEGIN
FormatString("%i\n", buf, n);
WriteString(buf)
END WriteInt;
PROCEDURE Newline(n : INTEGER);
BEGIN
WriteLn
END Newline;
VAR i : INTEGER;
BEGIN
FOR i:=1 TO 30 DO
Fizz(i)
END;
ReadChar
END Fizzbuzz.
Modula-3
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.
Monte
def fizzBuzz(top):
var t := 1
while (t < top):
if ((t % 3 == 0) || (t % 5 == 0)):
if (t % 15 == 0):
traceln(`$t FizzBuzz`)
else if (t % 3 == 0):
traceln(`$t Fizz`)
else:
traceln(`$t Buzz`)
t += 1
fizzBuzz(100)
MontiLang
&DEFINE LOOP 100&
1 VAR i .
FOR LOOP
|| VAR ln .
i 5 % 0 ==
IF : .
ln |Buzz| + VAR ln .
ENDIF
i 3 % 0 ==
IF : .
ln |Fizz| + VAR ln .
ENDIF
ln || ==
IF : .
i PRINT .
ENDIF
ln || !=
IF : .
ln PRINT .
ENDIF
i 1 + VAR i .
ENDFOR
MoonScript
for i = 1,100
print ((a) -> a == "" and i or a) table.concat {
i % 3 == 0 and "Fizz" or ""
i % 5 == 0 and "Buzz" or ""}
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
fizzbuzz
for i=1:1:100 do write !
. write:(i#3)&(i#5) i write:'(i#3) "Fizz" write:'(i#5) "Buzz"
Nanoquery
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
println i
end
end
NATURAL
DEFINE DATA
LOCAL
1 #I (I4)
1 #MODULO (I4)
1 #DIVISOR (I4)
1 #OUT (A10)
END-DEFINE
*
FOR #I := 1 TO 100
#DIVISOR := 15
#OUT := 'FizzBuzz'
PERFORM MODULO
*
#DIVISOR := 5
#OUT := 'Buzz'
PERFORM MODULO
*
#DIVISOR := 3
#OUT := 'Fizz'
PERFORM MODULO
*
WRITE #I
END-FOR
*
DEFINE SUBROUTINE MODULO
#MODULO := #I - (#I / #DIVISOR) * #DIVISOR
IF #MODULO = 0
WRITE NOTITLE #OUT
ESCAPE TOP
END-IF
END-SUBROUTINE
*
END
Neko
var i = 1
while(i < 100) {
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");
}
i ++= 1
}
Nemerle
The naive approach:
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))")
}
}
A much slicker approach is posted here
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
Never
func fizz_buzz() -> int
{
var i = 1;
for (i = 1; i <= 100; i = i + 1)
{
/* if (i % 15 == 0) */
if (i % 3 == 0 && i % 5 == 0)
{
prints("Fizz Buzz\n")
}
else if (i % 3 == 0)
{
prints("Fizz\n")
}
else if (i % 5 == 0)
{
prints("Buzz\n")
}
else
{
prints(i + "\n")
}
};
0
}
func main() -> int {
fizz_buzz();
0
}
- Output:
prompt$ never -f fizzbuzz.nev 2>/dev/null 1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 Fizz Buzz 16 ... 89 Fizz Buzz 91 92 Fizz 94 Buzz Fizz 97 98 Fizz Buzz
NewLISP
(dotimes (i 100)
(println
(cond
((= 0 (% i 15)) "FizzBuzz")
((= 0 (% i 3)) "Fizz")
((= 0 (% i 5)) "Buzz")
('t i))))
Solution 2.
Many of the solutions have a command to print "fizzbuzz". Since the programs can print "fizz" and "buzz", why not print "fizz" followed immediately by "buzz"? This also removes the need to check for divisibility by 15.
It would be nice to have a very easy way to know whether a word was actually printed (because we otherwise have to print the number). I mean a way that doesn't involve checking for divisibility again or setting a flag.
We want a macro or function that is somewhat like "or" but that evaluates all of the expressions even if the first yields true. Like "or", it returns a true value (a number) if any of the expressions yielded true. In newLISP, it seems that a function suffices, but in some languages a macro may be necessary because the arguments to a function are not always evaluated from left to right.
I believe that this method makes it easier to modify the program when the list of words to be printed is extended.
(define (try-all) ;; The arguments are in (args) or $args.
(let (cnt (length (filter true? $args)))
(if (zero? cnt) nil cnt)))
(define (fizz)
(define (say? n s) (if (= 0 (% i n)) (print s))) ;; Dynamic scoping.
(for (i 1 21)
(unless
(try-all
(say? 3 'fizz)
(say? 5 'buzz)
(say? 7 'boom)
(say? 11 'crux))
(print i))
(println)))
(fizz)
1
2
fizz
4
buzz
fizz
boom
8
fizz
buzz
crux
fizz
13
boom
fizzbuzz
16
17
fizz
19
buzz
fizzboom
Solution 3.
Instead of explicitly including the numbers 3, 5, 7, etc., let's tell the computer to use the prime numbers starting with 3.
(define (m-prime-gen)
(fn ( , n) ;; Unused parameter n is our local variable.
;; Self-modifying code.
(until (= 1 (length (factor (setf n (++ 2))))))
n))
(define (try-all) ;; The arguments are in (args) or $args.
(let (cnt (length (filter true? $args)))
(if (zero? cnt) nil cnt)))
(define (fizz)
(define (say? n s) (if (= 0 (% i n)) (print s))) ;; Dynamic scoping.
(for (i 1 21)
(let (p (m-prime-gen))
(unless
(try-all
(say? (p) 'fizz)
(say? (p) 'buzz)
(say? (p) 'boom)
(say? (p) 'crux)
(say? (p) 'ZAP))
(print i))
(println))))
(fizz)
1
2
fizz
4
buzz
fizz
boom
8
fizz
buzz
crux
fizz
ZAP
boom
fizzbuzz
16
17
fizz
19
buzz
fizzboom
NewtonScript
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
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);
Nim
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)
Without Modulus
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
Using macro
Computes everything at compile time.
import macros
macro FizzBuzz(N): untyped =
var source = ""
for i in 1..N.intVal:
source &= "echo \""
if i mod 15 == 0:
source &= "FizzBuzz"
elif i mod 3 == 0:
source &= "Fizz"
elif i mod 5 == 0:
source &= "Buzz"
else:
source &= $i
source &= "\"\n"
result = parseStmt(source)
FizzBuzz(100)
Nix
with (import <nixpkgs> { }).lib;
with builtins;
let
fizzbuzz = { x ? 1 }:
''
${if (mod x 15 == 0) then
"FizzBuzz"
else if (mod x 3 == 0) then
"Fizz"
else if (mod x 5 == 0) then
"Buzz"
else
(toString x)}
'' + (if (x < 100) then
fizzbuzz { x = x + 1; } else "");
in
fizzbuzz { }
Nu
(1..100
| each {|i| $"(if $i mod 3 == 0 {"Fizz"})(if $i mod 5 == 0 {"Buzz"})"
| if ($in == "") {$i} else {$in}}
| str join "\n")
Oberon-2
MODULE FizzBuzz;
IMPORT Out;
VAR i: INTEGER;
BEGIN
FOR i := 1 TO 100 DO
IF i MOD 15 = 0 THEN
Out.String("FizzBuzz")
ELSIF i MOD 5 = 0 THEN
Out.String("Buzz")
ELSIF i MOD 3 = 0 THEN
Out.String("Fizz")
ELSE
Out.Int(i,0)
END;
Out.Ln
END
END FizzBuzz.
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();
};
};
}
}
}
Objective-C
// FizzBuzz in Objective-C
#import <Foundation/Foundation.h>
int main(int argc, char* argv[]) {
for (NSInteger i=1; I <= 101; i++) {
if (i % 15 == 0) {
NSLog(@"FizzBuzz\n");
} else if (i % 3 == 0) {
NSLog(@"Fizz\n");
} else if (i % 5 == 0) {
NSLog(@"Buzz\n");
} else {
NSLog(@"%li\n", i);
}
}
}
OCaml
Idiomatic OCaml to solve the stated problem:
let fizzbuzz i =
match i mod 3, i mod 5 with
0, 0 -> "FizzBuzz"
| 0, _ -> "Fizz"
| _, 0 -> "Buzz"
| _ -> string_of_int i
let _ =
for i = 1 to 100 do print_endline (fizzbuzz i) done
With a view toward extensibility, there are many approaches: monadic, list of rules, ... here we'll use a piped sequence of rules to define a new "fizzbuzz" function:
(* Useful rule declaration: "cond => f", 'cond'itionally applies 'f' to 'a'ccumulated value *)
let (=>) cond f a = if cond then f a else a
let append s a = a^s
let fizzbuzz i =
"" |> (i mod 3 = 0 => append "Fizz")
|> (i mod 5 = 0 => append "Buzz")
|> (function "" -> string_of_int i
| s -> s)
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
Oforth
: fizzbuzz
| i |
100 loop: i [
null
i 3 mod ifZero: [ "Fizz" + ]
i 5 mod ifZero: [ "Buzz" + ]
dup ifNull: [ drop i ] .
] ;
Ol
(for-each (lambda (x)
(print (cond
((and (zero? (mod x 3)) (zero? (mod x 5)))
"FizzBuzz")
((zero? (mod x 3))
"Fizz")
((zero? (mod x 5))
"Buzz")
(else
x))))
(iota 100))
Onyx (wasm)
use core { * }
fizzbuzz :: (len: u32) -> void {
for i in 1..len+1 {
msg : str;
if (i%3 == 0 && i%5 == 0) { msg = "FizzBuzz !!!"; }
elseif (i%3 == 0) { msg = "Fizz"; }
elseif (i%5 == 0) { msg = "Buzz"; }
else { msg = tprintf("{}", i); }
printf("{}\n", msg);
}
}
main :: () {
fizzbuzz(100);
}
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()
}
}
Order
#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))
)
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
Palo Alto Tiny BASIC
See FizzBuzz/Basic.
PARI/GP
{for(n=1,100,
print(if(n%3,
if(n%5,
n
,
"Buzz"
)
,
if(n%5,
"Fizz"
,
"FizzBuzz"
)
))
)}
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.
PascalABC.NET
begin
for var i:=1 to 100 do
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)
end.
PDP-8 Assembly
Runs on SimH, or any PDP-8 with an EAE
/--------------------------------------------------------
/THIS PROGRAM PRINTS THE INTEGERS FROM 1 TO 100 (INCL).
/WITH THE FOLLOWING RESTRICTIONS:
/ FOR MULTIPLES OF THREE, PRINT 'FIZZ'
/ FOR MULTIPLES OF FIVE, PRINT 'BUZZ'
/ FOR MULTIPLES OF BOTH THREE AND FIVE, PRINT 'FIZZBUZZ'
/--------------------------------------------------------
/--------------------------------------------------------
/DEFINES
/--------------------------------------------------------
SWBA=7447 /EAE MODE A INSTRUCTION
DVI=7407 /EAE DIVIDE INSTRUCTION
AIX0=0010 /AUTO INDEX REGISTER 0
CR=0215 /CARRIAGE RETURN
LF=0212 /LINEFEED
EOT=0000 /END OF TEXT NUL
FIZMOD=0003 /CONSTANT DECIMAL 3 (FIZZ)
BUZMOD=0005 /CONSTANT DECIMAL 5 (BUZZ)
K10=0012 /CONSTANT DECIMAL 10
LAST=0144 /FIZZBUZZ THE NUMBERS 1..LAST
/0144 OCTAL == 100 DECIMAL
/CAN BE ANY FROM [0001...7777]
/--------------------------------------------------------
/FIZZBUZZ START=0200
/--------------------------------------------------------
*200 /START IN MEMORY AT 0200 OCTAL
FZZBZZ, CLA /CLEAR AC
TAD (-LAST-1 /LOAD CONSTANT -(LAST+1)
DCA CNTR /SET UP MAIN COUNTER
TAD (-FIZMOD /SET UP FIZZ COUNTER
DCA FIZCTR /TO -3
TAD (-BUZMOD /SET UP BUZZ COUNTER
DCA BUZCTR /TO -5
LOOP, ISZ CNTR /READY?
SKP /NO: CONTINUE
JMP I [7600 /YES: RETURN TO OS/8, REPLACE BY
/'HLT' IF NOT ON OS/8
CHKFIZ, ISZ FIZCTR /MULTIPLE OF 3?
JMP CHKBUZ /NO: CONTINUE
TAD FIZSTR /YES: LOAD ADDRESS OF 'FIZZ'
JMS STROUT /PRINT IT TO TTY
TAD (-FIZMOD /RELOAD THE
DCA FIZCTR /MOD 3 COUNTER
CHKBUZ, ISZ BUZCTR /MULTIPLE OF 5?
JMP CHKNUM /NO: CONTINUE
TAD BUZSTR /YES: LOAD ADDRESS OF 'BUZZ'
JMS STROUT /PRINT IT TO TTY
TAD (-BUZMOD /RELOAD THE
DCA BUZCTR /MOD 5 COUNTER
JMP NXTLIN /PRINT NEWLINE AND CONTINUE
CHKNUM, TAD FIZCTR /CHECK WHETHER MOD 3 COUNTER
TAD (FIZMOD /IS RELOADED
SNA /DID WE JUST PRINT 'FIZZ'?
JMP NXTLIN /YES: PRINT NEWLINE AND CONTINUE
CLA /ZERO THE AC
NUM, TAD CNTR /LOAD THE MAIN NUMBER COUNTER
TAD (LAST+1 /OFFSET IT TO A POSITIVE VALUE
JMS NUMOUT /PRINT IT TO THE TTY
NXTLIN, TAD LINSTR /LOAD THE ADDRESS OF THE NEWLINE
JMS STROUT /PRINT IT TO TTY
JMP LOOP /CONTINUE WITH THE NEXT NUMBER
CNTR, 0 /MAIN COUNTER
FIZCTR, 0 /FIZZ COUNTER
BUZCTR, 0 /BUZZ COUNTER
/--------------------------------------------------------
/WRITE ASCII CHARACTER IN AC TO TTY
/PRE : AC=ASCII CHARACTER
/POST: AC=0
/--------------------------------------------------------
CHROUT, .-.
TLS /SEND CHARACTER TO TTY
TSF /IS TTY READY FOR NEXT CHARACTER?
JMP .-1 /NO TRY AGAIN
CLA /AC=0
JMP I CHROUT /RETURN
/--------------------------------------------------------
/WRITE NUL TERMINATED ASCII STRING TO TTY
/PRE : AC=ADDRESS OF STRING MINUS 1
/POST: AC=0
/--------------------------------------------------------
STROUT, .-.
DCA AIX0 /STORE POINTER IN AUTO INDEX 0
STRLOP, TAD I AIX0 /GET NEXT CHARACTER FROM STRING
SNA /SKIP IF NOT EOT
JMP I STROUT /RETURN
JMS CHROUT /PRINT CHARACTER
JMP STRLOP /GO GET NEXT CHARACTER
/--------------------------------------------------------
/WRITE NUMBER IN AC TO TTY AS DECIMAL
/PRE : AC=UNSIGNED NUMBER BETWEEN 0000 AND 7777
/POST: AC=0
/--------------------------------------------------------
NUMOUT, .-.
SWBA /SET EAE IN MODE A
MQL /MQ=NUM; AC=0
TAD BUFFER /LOAD END OF BUFFER
DCA BUFPTR /IN BUFPTR
SKP /NUM IS ALREADY IN MQ
NUMLOP, MQL /MQ=NUM; AC=0
DVI /MQ=NUM/10; AC=NUM-(NUM/10)*10
K10 /DECIMAL 10
TAD ("0 /ADD ASCII ZERO
DCA I BUFPTR /STORE CHAR BUFFER, BACK TO FRONT
CMA /AC=-1
TAD BUFPTR /DECREMENT
DCA BUFPTR /BUFFER POINTER
MQA /MQ -> AC
SZA /READY IF ZERO
JMP NUMLOP /GET NEXT DIGIT
TAD BUFPTR /LOAD START OF CONVERTED NUMBER
JMS STROUT /SEND IT TO TTY
JMP I NUMOUT /RETURN
BUFFER, .+4 /ADDRESS OF BUFFER
*.+4 /RESERVE 4 LOCATIONS (MAX=4095)
EOT /END OF BUFFER
BUFPTR, 0 /POINTER IN BUFFER
/--------------------------------------------------------
/STRINGS
/--------------------------------------------------------
FIZSTR, . /FIZZ STRING
"F; "I; "Z; "Z; EOT
BUZSTR, . /BUZZ STRING
"B; "U; "Z; "Z; EOT
LINSTR, . /NEWLINE STIRNG
CR; LF; EOT
$
Output:
. .PAL FIZBUZ.PA ERRORS DETECTED: 0 LINKS GENERATED: 0 .LOAD FIZBUZ.BN .START 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 .
Peloton
Variable-length padded English dialect
<# 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|...</#> </#>
Fixed-length English dialect
<@ 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|...</@> </@>
Perl
use strict;
use warnings;
use feature qw(say);
for my $i (1..100) {
say $i % 15 == 0 ? "FizzBuzz"
: $i % 3 == 0 ? "Fizz"
: $i % 5 == 0 ? "Buzz"
: $i;
}
More concisely:
print 'Fizz'x!($_ % 3) . 'Buzz'x!($_ % 5) || $_, "\n" for 1 .. 100;
For code-golfing:
print+(Fizz)[$_%3].(Buzz)[$_%5]||$_,$/for 1..1e2
For array of values:
map((Fizz)[$_%3].(Buzz)[$_%5]||$_,1..100);
Cheating:
use feature "say";
@a = ("FizzBuzz", 0, 0, "Fizz", 0, "Buzz", "Fizz", 0, 0, "Fizz", "Buzz", 0, "Fizz");
say $a[$_ % 15] || $_ for 1..100;
as a subroutine:
sub fizz_buzz {
join("\n", map {
sub mult {$_ % shift == 0};
my @out;
if (mult 3) { push @out, "Fizz"; }
if (mult 5) { push @out, "Buzz"; }
if (!@out) {push @out, $_; }
join('', @out);
} (1..100))."\n";
}
print fizz_buzz;
By transforming a list:
@FB1 = (1..100);
@FB2 = map{!($_%3 or $_%5)?'FizzBuzz': $_}@FB1;
@FB3 = map{(/\d/ and !($_%3))?'Fizz': $_}@FB2;
@FB4 = map{(/\d/ and !($_%5))?'Buzz': $_}@FB3;
@FB5 = map{$_."\n"}@FB4;
print @FB5;
Phix
constant x = {"%d\n","Fizz\n","Buzz\n","FizzBuzz\n"} for i=1 to 100 do printf(1,x[1+(remainder(i,3)=0)+2*(remainder(i,5)=0)],i) end for
Two variants with tabulated output:
function f(integer i) integer idx = 1+(remainder(i,3)=0)+2*(remainder(i,5)=0) return sprintf({"%-8d","Fizz ","Buzz ","FizzBuzz"}[idx],i) end function printf(1,join_by(apply(tagset(100),f),10,10))
(output same as below)
sequence s = apply(true,sprintf,{{"%-8d"},tagset(100)}) for i=3 to 100 by 3 do s[i] = "Fizz " end for for i=5 to 100 by 5 do s[i] = "Buzz " end for for i=15 to 100 by 15 do s[i] = "FizzBuzz" end for printf(1,join_by(s,10,10))
- Output:
1 11 Fizz 31 41 Fizz 61 71 Fizz 91 2 Fizz 22 32 Fizz 52 62 Fizz 82 92 Fizz 13 23 Fizz 43 53 Fizz 73 83 Fizz 4 14 Fizz 34 44 Fizz 64 74 Fizz 94 Buzz FizzBuzz Buzz Buzz FizzBuzz Buzz Buzz FizzBuzz Buzz Buzz Fizz 16 26 Fizz 46 56 Fizz 76 86 Fizz 7 17 Fizz 37 47 Fizz 67 77 Fizz 97 8 Fizz 28 38 Fizz 58 68 Fizz 88 98 Fizz 19 29 Fizz 49 59 Fizz 79 89 Fizz Buzz Buzz FizzBuzz Buzz Buzz FizzBuzz Buzz Buzz FizzBuzz Buzz
Grotesquely inefficient (non-tabulated output), just for fun. Can you do worse, yet keep it semi-plausibile that someone might have actually earnestly written it?
constant threes = tagset(100,0,3), fives = tagset(100,0,5), fifteens = tagset(100,0,15) for i=1 to 100 do if not find(i,threes) and not find(i,fives) and not find(i,fifteens) then printf(1,"%d",i) end if if find(i,threes) and not find(i,fives) and not find(i,fifteens) then printf(1,"Fizz") end if if not find(i,threes) and find(i,fives) and not find(i,fifteens) then printf(1,"Buzz",i) end if if find(i,threes) and find(i,fives) and find(i,fifteens) then printf(1,"FizzBuzz") end if printf(1,"\n") end for
Phixmonti
/# Rosetta Code problem: http://rosettacode.org/wiki/FizzBuzz
by Galileo, 10/2022 #/
100 for
dup print " " print dup
3 mod not if "Fizz" print endif
5 mod not if "Buzz" print endif
nl
endfor
- Output:
1 2 3 Fizz 4 5 Buzz 6 Fizz 7 8 9 Fizz 10 Buzz 11 12 Fizz 13 14 15 FizzBuzz 16 17 18 Fizz 19 20 Buzz 21 Fizz 22 23 24 Fizz 25 Buzz 26 27 Fizz 28 29 30 FizzBuzz 31 32 33 Fizz 34 35 Buzz 36 Fizz 37 38 39 Fizz 40 Buzz 41 42 Fizz 43 44 45 FizzBuzz 46 47 48 Fizz 49 50 Buzz 51 Fizz 52 53 54 Fizz 55 Buzz 56 57 Fizz 58 59 60 FizzBuzz 61 62 63 Fizz 64 65 Buzz 66 Fizz 67 68 69 Fizz 70 Buzz 71 72 Fizz 73 74 75 FizzBuzz 76 77 78 Fizz 79 80 Buzz 81 Fizz 82 83 84 Fizz 85 Buzz 86 87 Fizz 88 89 90 FizzBuzz 91 92 93 Fizz 94 95 Buzz 96 Fizz 97 98 99 Fizz 100 Buzz === Press any key to exit ===
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;
]
PHP
if/else ladder approach
<?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";
}
?>
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.
<?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";
}
?>
Concatenation approach without if-s
<?php
for (
$i = 0;
$i++ < 100;
$o = ($i % 3 ? '' : 'Fizz') . ($i % 5 ? '' : 'Buzz')
)
echo $o ? : $i, PHP_EOL;
?>
One Liner Approach
<?php
for($i = 1; $i <= 100 and print(($i % 15 ? $i % 5 ? $i % 3 ? $i : 'Fizz' : 'Buzz' : 'FizzBuzz') . "\n"); ++$i);
?>
Compact One Liner Approach
for($i=0;$i++<100;)echo($i%3?'':'Fizz').($i%5?'':'Buzz')?:$i,"\n";
Array One Liner Approach
for($i = 0; $i++ < 100;) echo [$i, 'Fizz', 'Buzz', 'FizzBuzz'][!($i % 3) + 2 * !($i % 5)], "\n";
Picat
Picat supports different programming styles/paradigms.
First some "standalone" predicates.
Using a map
fizzbuzz_map =>
println(fizzbuzz_map),
FB = [I : I in 1..100],
Map = [(3="Fizz"),(5="Buzz"),(15="FizzBuzz")],
foreach(I in FB, K=V in Map)
if I mod K == 0 then
FB[I] := V
end
end,
println(FB).
Using a template for the pattern
fizzbuzz_template1 =>
println(fizzbuzz_template1),
N = 100,
F = [_,_,fizz,_,buzz,fizz,_,_,fizz,buzz,_,fizz,_,_,fizzbuzz],
FF = [F : _I in 1..1+N div F.length].flatten(),
foreach(I in 1..N)
(var(FF[I]) -> print(I) ; print(FF[I])),
print(" ")
end,
nl.
Another version with templates
fizzbuzz_template2 =>
println(fizzbuzz_template2),
N = 100,
F = new_list(N),
FV = [3,5,15],
FN = ["Fizz","Buzz","FizzBuzz"],
foreach(I in 1..N, {Val,Name} in zip(FV,FN))
if I mod Val == 0 then F[I] := Name end
end,
foreach(I in 1..N)
printf("%w ", cond(var(F[I]),I, F[I]))
end,
nl.
Below are some versions for identifying the FizzBuzziness of a number.
To be used with the following general wrapper:
fizzbuzz(Goal) =>
println(Goal),
foreach(I in 1..100)
printf("%w ", apply(Goal,I))
end,
nl.
Plain imperative approach: if/else
fb1(I) = V =>
V = I.to_string(),
if I mod 15 == 0 then V := "FizzBuzz"
elseif I mod 3 == 0 then V := "Fizz"
elseif I mod 5 == 0 then V := "Buzz"
end.
Pattern matching + conditions in head
fb2(I) = "FizzBuzz", I mod 15 == 0 => true.
fb2(I) = "Fizz", I mod 3 == 0 => true.
fb2(I) = "Buzz", I mod 5 == 0 => true.
fb2(I) = I.to_string() => true.
Another pattern matching approach
fb3(I) = fb3b(I, I mod 3, I mod 5).
fb3b(_I,0,0) = "FizzBuzz".
fb3b(_I,_,0) = "Buzz".
fb3b(_I,0,_) = "Fizz".
fb3b(I,_,_) = I.
Using cond/3 and string concatenation
fb4(I) = cond(I mod 3 == 0, "Fizz", "") ++
cond(I mod 5 == 0, "Buzz", "") ++
cond(not ((I mod 3 == 0; I mod 5==0)), I.to_string(), "").
Recursive function (conditions in head)
fizzbuzz_rec =>
print(fizzbuzz_rec),
fb5(100,[],L),
println(L).
fb5(N,L1,L), N = 0 ?=>
L = L1.reverse().
fb5(N,L1,L),N mod 15 == 0 ?=>
fb5(N-1,L1 ++ ["FizzBuzz"], L).
fb5(N,L1,L), N mod 5 == 0 ?=>
fb5(N-1,L1 ++ ["Buzz"], L).
fb5(N,L1,L), N mod 3 == 0 ?=>
fb5(N-1,L1 ++ ["Fizz"], L).
fb5(N,L1,L), N mod 3 > 0, N mod 5 > 0 =>
fb5(N-1,L1 ++ [N.to_string()], L).
Golfing style
fizzbuzz_golf =>
println(fizzbuzz_golf),
[cond(P=="",I,P):I in 1..100,(I mod 3==0->P="Fizz";P=""),(I mod 5==0->P:=P++"Buzz";true)].println().
Planner version
Picat has support for "classic" planning problems. The planner
module must be imported.
import planner.
fizzbuzz_planner =>
println(fizzbuzz_planner),
plan(100,Plan),
println(Plan.reverse()),
nl.
final(Goal) => Goal == 0.
action(H,To,Move,Cost) ?=>
H mod 15 == 0,
Move = "FizzBuzz",
To = H-1,
Cost = 1.
action(H,To,Move,Cost) ?=>
H mod 5 == 0,
Move = "Buzz",
To = H-1,
Cost = 1.
action(H,To,Move,Cost) ?=>
H mod 3 == 0,
Move = "Fizz",
To = H-1,
Cost = 1.
action(H,To,Move,Cost) =>
H mod 3 > 0,
H mod 5 > 0,
Move = H.to_string(),
To = H-1,
Cost = 1.
Here we test everything.
go =>
fizzbuzz_map,
fizzbuzz_template1,
fizzbuzz_template2,
fizzbuzz_planner,
fizzbuzz_rec,
fizzbuzz_golf,
FBs = [fb1,fb2,fb3,fb4],
foreach(FB in FBs)
call(fizzbuzz,FB)
end,
nl.
PicoLisp
We could simply use 'at' here:
(for N 100
(prinl
(or (pack (at (0 . 3) "Fizz") (at (0 . 5) "Buzz")) N) ) )
# Above, we simply count till 100 'prin'-ting number 'at' 3rd ('Fizz'), 5th ('Buzz') and 'pack'-ing 15th number ('FizzBuzz').
# Rest of the times 'N' is printed as it loops in 'for'.
Or do it the standard way:
(for N 100
(prinl
(cond
((=0 (% N 15)) "FizzBuzz")
((=0 (% N 3)) "Fizz")
((=0 (% N 5)) "Buzz")
(T N) ) ) )
Piet
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");
}
}
}
PILOT
C :i = 0
*loop
C :i = i + 1
J ( i > 100 ) : *finished
C :modulo = i % 15
J ( modulo = 0 ) : *fizzbuzz
C :modulo = i % 3
J ( modulo = 0 ) : *fizz
C :modulo = i % 5
J ( modulo = 0 ) : *buzz
T :#i
J : *loop
*fizzbuzz
T :FizzBuzz
J : *loop
*fizz
T :Fizz
J : *loop
*buzz
T :Buzz
J : *loop
*finished
END:
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
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;
PL/M
100H:
/* DECLARE OUTPUT IN TERMS OF CP/M -
PL/M DOES NOT COME WITH ANY STANDARD LIBRARY */
BDOS: PROCEDURE(FUNC, ARG);
DECLARE FUNC BYTE, ARG ADDRESS;
GO TO 5;
END BDOS;
PUT$STRING: PROCEDURE(STR);
DECLARE STR ADDRESS;
CALL BDOS(9, STR);
CALL BDOS(9, .(13,10,'$'));
END PUT$STRING;
/* PRINT A NUMBER */
PUT$NUMBER: PROCEDURE(N);
DECLARE S (5) BYTE INITIAL ('...$');
DECLARE P ADDRESS;
DECLARE (N, D, C BASED P) BYTE;
P = .S(3);
DIGIT:
P = P-1;
C = (N MOD 10) + '0';
N = N/10;
IF N > 0 THEN GO TO DIGIT;
CALL PUT$STRING(P);
END PUT$NUMBER;
/* FIZZBUZZ */
DECLARE N BYTE;
DO N = 1 TO 100;
IF N MOD 15 = 0 THEN
CALL PUT$STRING(.'FIZZBUZZ$');
ELSE IF N MOD 5 = 0 THEN
CALL PUT$STRING(.'BUZZ$');
ELSE IF N MOD 3 = 0 THEN
CALL PUT$STRING(.'FIZZ$');
ELSE
CALL PUT$NUMBER(N);
END;
/* EXIT TO CP/M */
CALL BDOS(0,0);
EOF
PL/SQL
begin
for i in 1 .. 100
loop
case
when mod(i, 15) = 0 then
dbms_output.put_line('FizzBuzz');
when mod(i, 5) = 0 then
dbms_output.put_line('Buzz');
when mod(i, 3) = 0 then
dbms_output.put_line('Fizz');
else
dbms_output.put_line(i);
end case;
end loop;
end;
Plain English
To play FizzBuzz up to a number:
Put "" into a string.
Loop.
If a counter is past the number, exit.
If the counter is evenly divisible by 3, append "Fizz" to the string.
If the counter is evenly divisible by 5, append "Buzz" to the string.
If the string is blank, append the counter then "" to the string.
Write the string to the console.
Clear the string.
Repeat.
To run:
Start up.
Play FizzBuzz up to 100.
Wait for the escape key.
Shut down.
Pointless
output =
range(1, 100)
|> map(fizzBuzz)
|> printLines
fizzBuzz(n) =
if result == "" then n else result
where result = fizzBuzzString(n)
fizzBuzzString(n) =
(if n % 3 == 0 then "Fizz" else "")
+ (if n % 5 == 0 then "Buzz" else "")
Pony
use "collections"
actor Main
new create(env: Env) =>
for i in Range[I32](1, 100) do
env.out.print(fizzbuzz(i))
end
fun fizzbuzz(n: I32): String =>
if (n % 15) == 0 then
"FizzBuzz"
elseif (n % 5) == 0 then
"Buzz"
elseif (n % 3) == 0 then
"Fizz"
else
n.string()
end
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;
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
or...
/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
Potion
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.
PowerShell
Straightforward, looping
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
}
}
Pipeline, Switch
$txt=$null
1..100 | ForEach-Object {
switch ($_) {
{ $_ % 3 -eq 0 } { $txt+="Fizz" }
{ $_ % 5 -eq 0 } { $txt+="Buzz" }
$_ { if($txt) { $txt } else { $_ }; $txt=$null }
}
}
Concatenation
1..100 | ForEach-Object {
$s = ''
if ($_ % 3 -eq 0) { $s += "Fizz" }
if ($_ % 5 -eq 0) { $s += "Buzz" }
if (-not $s) { $s = $_ }
$s
}
Piping, Evaluation, Concatenation
1..100 | % {write-host("$(if(($_ % 3 -ne 0) -and ($_ % 5 -ne 0)){$_})$(if($_ % 3 -eq 0){"Fizz"})$(if($_ % 5 -eq 0){"Buzz"})")}
Filter, Piping, Regex Matching, Array Auto-Selection
filter fizz-buzz{
@(
$_,
"Fizz",
"Buzz",
"FizzBuzz"
)[
2 *
($_ -match '[05]$') +
($_ -match '(^([369][0369]?|[258][147]|[147][258]))$')
]
}
1..100 | fizz-buzz
String Manipulation with Regex
(1..100 -join "`n") + "`nFizzBuzz" -replace '(?ms)(^([369]([369]|(?=0|$))|[258][147]|[147]([28]|(?=5))))(?=[05]?$.*(Fizz))|(((?<=[369])|[^369])0+|((?<=[147\s])|[^147\s])5)(?=$.*(Buzz))|FizzBuzz', '$5$9'
Processing
Console & Visualization
Reserved variable "width" in Processing is 100 pixels by default, suitable for this FizzBuzz exercise. Accordingly, range is pixel index from 0 to 99.
for (int i = 0; i < width; i++) {
if (i % 3 == 0 && i % 5 == 0) {
stroke(255, 255, 0);
println("FizzBuzz!");
}
else if (i % 5 == 0) {
stroke(0, 255, 0);
println("Buzz");
}
else if (i % 3 == 0) {
stroke(255, 0, 0);
println("Fizz");
}
else {
stroke(0, 0, 255);
println(i);
}
line(i, 0, i, height);
}
Console & Visualization, Ternary
for (int i = 0; i < width; i++) {
stroke((i % 5 == 0 && i % 3 == 0) ? #FFFF00 : (i % 5 == 0) ? #00FF00 : (i % 3 == 0) ? #FF0000 : #0000FF);
line(i, 0, i, height);
println((i % 5 == 0 && i % 3 == 0) ? "FizzBuzz!" : (i % 5 == 0) ? "Buzz" : (i % 3 == 0) ? "Fizz" : i);
}
Console
for (int 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("\n");
}
Console, "Futureproof"
for(int i = 1; i <= 100; i++){
String output = "";
if(i % 3 == 0) output += "Fizz";
if(i % 5 == 0) output += "Buzz";
// copy & paste above line to add more tests
if(output == "") output = str(i);
println(output);
}
All examples produce the same console output:
- 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
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.
fizzbuzz :-
forall(between(1, 100, X), print_item(X)).
print_item(X) :-
( X mod 15 =:= 0
-> write('FizzBuzz')
; X mod 3 =:= 0
-> write('Fizz')
; X mod 5 =:= 0
-> write('Buzz')
; write(X)
),
nl.
More conventional, doing the loop this time failure driven:
fizzbuzz(X) :- X mod 15 =:= 0, !, write('FizzBuzz').
fizzbuzz(X) :- X mod 3 =:= 0, !, write('Fizz').
fizzbuzz(X) :- X mod 5 =:= 0, !, write('Buzz').
fizzbuzz(X) :- write(X).
dofizzbuzz :-between(1, 100, X), fizzbuzz(X), nl, fail.
dofizzbuzz.
Clearer, doing the loop this time tail recursive, quite declarative:
% 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, yes) :- N mod D =:= 0.
divisible_by(N, D, no) :- N mod D =\= 0.
% Print 'Fizz', 'Buzz', 'FizzBuzz' or N as appropriate.
fizz_buzz_or_n(N) :- N > 100.
fizz_buzz_or_n(N) :- N =< 100,
divisible_by(N, 3, Fizz),
divisible_by(N, 5, Buzz),
fizzbuzz(N, Fizz, Buzz, FB),
write(FB), nl,
M is N+1, fizz_buzz_or_n(M).
main :-
fizz_buzz_or_n(1).
Using modern Prolog techniques, resulting in idiomatic, highly declarative code:
% This implementation uses modern Prolog techniques
% in order to be an idiomatic solution that uses logical purity, generality and determinism wherever possible:
% - CLP(Z): constraint logic programming on integers.
% - library(reif): efficient logical predicates based on 'Indexing dif/2'.
:- module(fizz_buzz, [main/0, integer_fizzbuzz_below_100/2, integer_fizzbuzz/2]).
:- use_module(library(reif)).
% for Scryer-Prolog:
:- use_module(library(clpz)).
:- use_module(library(between)).
:- use_module(library(iso_ext)).
:- use_module(library(si)).
% for SWI-Prolog:
% :- use_module(library(clpfd)).
% Prints all solutions to `integer_fizzbuzz_below_100` each on a separate line, in order.
% Logically-impure shell, as currently there is no logically-pure way to write to a filestream.
main :-
forall(integer_fizzbuzz_below_100(_, FizzBuzz), write_line(FizzBuzz)).
write_line(Value) :-
write(Value),
nl.
% Constrains FizzBuzz results to the range 1 <= X <= 100,
% and (for the 'most general query' where neither X or FizzBuzz is concrete)
% ensures results are traversed in order low -> high X.
%
% ?- integer_fizzbuzz_below_100(X, FizzBuzz) % generate all the results in order
% ?- integer_fizzbuzz_below_100(27, Result) % Find out what output `27` will produce (it's 'Fizz'.)
% ?- integer_fizzbuzz_below_100(X, 'Fizz') % generate all the numbers which would print 'Fizz' in order (3, 6, 9, etc).
% ?- integer_fizzbuzz_below_100(X, Res), integer_si(Res) % generate all the numbers which would print themselves in order (1, 2, 4, 6, 7, 8, 11, etc).
% ?- integer_fizzbuzz_below_100(X, Res), is_of_type(integer, Res) % SWI-Prolog version doing the same.
integer_fizzbuzz_below_100(X, FizzBuzz) :-
between(1, 100, X),
integer_fizzbuzz(X, FizzBuzz).
% States the relationship between a number
% and its FizzBuzz representation.
%
% Because constraints are propagated lazily,
% prompting this predicate without having constrained `Num`
% to a particular integer value will give you its definition back.
% Put differently: This predicate returns the whole solution space at once,
% and external labeling techniques are required to traverse and concretize this solution space
% in an order that we like.
integer_fizzbuzz(Num, FizzBuzz) :-
if_(Num mod 15 #= 0, FizzBuzz = 'FizzBuzz',
if_(Num mod 5 #= 0, FizzBuzz = 'Buzz',
if_(Num mod 3 #= 0, FizzBuzz = 'Fizz',
Num = FizzBuzz)
)
).
% Reifiable `#=`.
#=(X, Y, T) :-
X #= X1,
Y #= Y1,
zcompare(C, X1, Y1),
eq_t(C, T).
eq_t(=, true).
eq_t(<, false).
eq_t(>, false).
PureBasic
See FizzBuzz/Basic
Pyret
fun fizzbuzz(n :: NumPositive) -> String:
doc: ```For positive input which is multiples of three return 'Fizz', for the multiples of five return 'Buzz'.
For numbers which are multiples of both three and five return 'FizzBuzz'. Otherwise, return the number itself.```
ask:
| num-modulo(n, 15) == 0 then: "FizzBuzz"
| num-modulo(n, 3) == 0 then: "Fizz"
| num-modulo(n, 5) == 0 then: "Buzz"
| otherwise: num-to-string(n)
end
where:
fizzbuzz(1) is "1"
fizzbuzz(101) is "101"
fizzbuzz(45) is "FizzBuzz"
fizzbuzz(33) is "Fizz"
fizzbuzz(25) is "Buzz"
end
range(1, 101).map(fizzbuzz).each(print)
Python
Python2: Simple
for i in range(1, 101):
if i % 15 == 0:
print "FizzBuzz"
elif i % 3 == 0:
print "Fizz"
elif i % 5 == 0:
print "Buzz"
else:
print i
Python3: Simple
for i in range(1, 101):
if i % 15 == 0:
print("FizzBuzz")
elif i % 3 == 0:
print("Fizz")
elif i % 5 == 0:
print("Buzz")
else:
print(i)
Python: Simple - no duplication
for n in range(1,101):
response = ''
if not n%3:
response += 'Fizz'
if not n%5:
response += 'Buzz'
print(response or n)
One liner using string concatenation:
for i in range(1,101): print("Fizz"*(i%3==0) + "Buzz"*(i%5==0) or i)
One liner another code:
for i in range(100):print(i%3//2*'Fizz'+i%5//4*'Buzz'or i+1)
List Comprehensions:
for n in range(1, 100):
fb = ''.join([ denom[1] if n % denom[0] == 0 else '' for denom in [(3,'fizz'),(5,'buzz')] ])
print fb if fb else n
Another list comprehension:
print (', '.join([(x%3<1)*'Fizz'+(x%5<1)*'Buzz' or str(x) for x in range(1,101)]))
Python: List Comprehension (Python 3)
[print("FizzBuzz") if i % 15 == 0 else print("Fizz") if i % 3 == 0 else print("Buzz") if i % 5 == 0 else print(i) for i in range(1,101)]
Python: Lazily
You can also create a lazy, unbounded sequence by using generator expressions:
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
Or equivalently, in terms of map, and Python 3 libraries:
'''Fizz buzz'''
from itertools import count, cycle, islice
# fizzBuzz :: () -> Generator [String]
def fizzBuzz():
'''A non-finite stream of fizzbuzz terms.
'''
return map(
lambda f, b, n: (f + b) or str(n),
cycle([''] * 2 + ['Fizz']),
cycle([''] * 4 + ['Buzz']),
count(1)
)
# ------------------------- TEST -------------------------
def main():
'''Display of first 100 terms of the fizzbuzz series.
'''
print(
'\n'.join(
list(islice(
fizzBuzz(),
100
))
)
)
if __name__ == '__main__':
main()
Python3.8: With walrus operator
print(*map(lambda n: 'Fizzbuzz '[(i):i+13] if (i := n**4%-15) > -14 else n, range(1,100)))
Python: Math tricks
Numbers ending in 5 or 0 are divisible by 5. Numbers whose digits recursively summed to a single-digit number == 3,6 or 9 are divisible by 3.
def numsum(n):
''' The recursive sum of all digits in a number
unit a single character is obtained'''
res = sum([int(i) for i in str(n)])
if res < 10: return res
else : return numsum(res)
for n in range(1,101):
response = 'Fizz'*(numsum(n) in [3,6,9]) + \
'Buzz'*(str(n)[-1] in ['5','0'])\
or n
print(response)
Python3: Super concise: 1 line
print(*((lambda x=x: ''.join(chr(c) for c in (102, 105)) + (2 * chr(122)) + ''.join(chr(c) for c in (98, 117)) + (2 * chr(122)) + '\n' if x % (30 >> 1) == 0 else ''.join(chr(c) for c in (102, 105)) + (2 * chr(122)) + '\n' if x % (6 >> 1) == 0 else ''.join(chr(c) for c in (98, 117)) + (2 * chr(122)) + '\n' if x % (10 >> 1) == 0 else str(x) + '\n')() for x in range(1, 101)))
q
q is the query language for kdb+.
{(`$string x)^`fizzbuzz`buzz`fizz`(x mod\:15 5 3)?'0}
Usage:
q)/ Fizzbuzz
q)fb:{(`$string x)^`fizzbuzz`buzz`fizz`(x mod\:15 5 3)?'0}
q)fb 1+til 20
`1`2`fizz`4`buzz`fizz`7`8`fizz`buzz`11`fizz`13`14`fizzbuzz`16`17`fizz`19`buzz
https://https://q201.org/apply-fizzbuzz//
https://code.kx.com/q/ref/mod/
https://code.kx.com/q/ref/fill
Explanation:
q)show x:1+til 20
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
q)x mod\:15 5 3
1 1 1
2 2 2
3 3 0
4 4 1
5 0 2
6 1 0
..
q)(x mod\:15 5 3)?'0
3 3 2 3 1 2 3 3 2 1 3 2 3 3 0 3 3 2 3 1
q)`fizzbuzz`buzz`fizz`(x mod\:15 5 3)?'0 / substitutions
```fizz``buzz`fizz```fizz`buzz``fizz```fizzbuzz```fizz``buzz
q)`$string x / numbers => symbols
`1`2`3`4`5`6`7`8`9`10`11`12`13`14`15`16`17`18`19`20
q)(`$string x)^`fizzbuzz`buzz`fizz`(x mod\:15 5 3)?'0 / replace nulls with numbers
`1`2`fizz`4`buzz`fizz`7`8`fizz`buzz`11`fizz`13`14`fizzbuzz`16`17`fizz`19`buzz
QB64
For n = 1 To 100
If n Mod 15 = 0 Then
Print "FizzBuzz"
ElseIf n Mod 5 = 0 Then
Print "Buzz"
ElseIf n Mod 3 = 0 Then
Print "Fizz"
Else
Print n
End If
Next
Quackery
100 times
[ i^ 1+ true
over 3 mod not
if [ say "fizz" drop false ]
over 5 mod not
if [ say "buzz" drop false ]
iff echo else drop
sp ]
R
xx <- x <- 1:100
xx[x %% 3 == 0] <- "Fizz"
xx[x %% 5 == 0] <- "Buzz"
xx[x %% 15 == 0] <- "FizzBuzz"
xx
Or, without directly checking for divisibility by 15:
xx <- rep("", 100)
x <- 1:100
xx[x %% 3 == 0] <- paste0(xx[x %% 3 == 0], "Fizz")
xx[x %% 5 == 0] <- paste0(xx[x %% 5 == 0], "Buzz")
xx[xx == ""] <- x[xx == ""]
xx
Or, (ab)using the vector recycling rule:
x <- paste0(rep("", 100), c("", "", "Fizz"), c("", "", "", "", "Buzz"))
cat(ifelse(x == "", 1:100, x), sep = "\n")
Or, for an abuse of the recycling rules that could be generalised:
x <- paste0(rep("", 100), rep(c("", "Fizz"), times = c(2, 1)), rep(c("", "Buzz"), times = c(4, 1)))
cat(ifelse(x == "", 1:100, x), sep = "\n")
Or, with a more straightforward use of ifelse:
x <- 1:100
ifelse(x %% 15 == 0, 'FizzBuzz',
ifelse(x %% 5 == 0, 'Buzz',
ifelse(x %% 3 == 0, 'Fizz', x)))
Or, adapting from General FizzBuzz#Names solution:
namedNums <- c(Fizz = 3, Buzz = 5)
for(i in 1:100)
{
isFactor <- i %% namedNums == 0
print(if(any(isFactor)) paste0(names(namedNums)[isFactor], collapse = "") else i)
}
Racket
#lang racket
(for ([n (in-range 1 101)])
(displayln
(match (gcd n 15)
[15 "fizzbuzz"]
[3 "fizz"]
[5 "buzz"]
[_ n])))
Raku
(formerly Perl 6)
Most straightforwardly:
for 1 .. 100 {
when $_ %% (3 & 5) { say 'FizzBuzz'; }
when $_ %% 3 { say 'Fizz'; }
when $_ %% 5 { say 'Buzz'; }
default { .say; }
}
Or abusing multi subs:
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.say;
Or abusing list metaoperators:
[1..100].map({[~] ($_%%3, $_%%5) »||» "" Z&& <fizz buzz> or $_ })».say
Concisely (readable):
say 'Fizz' x $_ %% 3 ~ 'Buzz' x $_ %% 5 || $_ for 1 .. 100;
Shortest FizzBuzz to date:
say "Fizz"x$_%%3~"Buzz"x$_%%5||$_ for 1..100
And here's an implementation that never checks for divisibility:
.say for
(
(flat ('' xx 2, 'Fizz') xx *)
Z~
(flat ('' xx 4, 'Buzz') xx *)
)
Z||
1 .. 100;
RapidQ
The BASIC solutions work with RapidQ, too. However, here is a bit more esoteric solution using the IIF() function.
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
Rascal
import IO;
public void fizzbuzz() {
for(int n <- [1 .. 100]){
fb = ((n % 3 == 0) ? "Fizz" : "") + ((n % 5 == 0) ? "Buzz" : "");
println((fb == "") ?"<n>" : fb);
}
}
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
REALbasic
See FizzBuzz/Basic
ReasonML
let fizzbuzz i =>
switch (i mod 3, i mod 5) {
| (0, 0) => "FizzBuzz"
| (0, _) => "Fizz"
| (_, 0) => "Buzz"
| _ => string_of_int i
};
for i in 1 to 100 {
print_endline (fizzbuzz i)
};
REBOL
An implementation that concatenates strings and includes a proper code header (title, date, etc.)
REBOL [
Title: "FizzBuzz"
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
]
Here is an example by Nick Antonaccio.
repeat i 100 [
print switch/default 0 compose [
(mod i 15) ["fizzbuzz"]
(mod i 3) ["fizz"]
(mod i 5) ["buzz"]
][i]
]
And a minimized version:
repeat i 100[j:""if i // 3 = 0[j:"fizz"]if i // 5 = 0[j: join j"buzz"]if""= j[j: i]print j]
The following is presented as a curiosity only, not as an example of good coding practice:
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]
Red
Red [Title: "FizzBuzz"]
repeat i 100 [
print case [
i % 15 = 0 ["FizzBuzz"]
i % 5 = 0 ["Buzz"]
i % 3 = 0 ["Fizz"]
true [i]
]
]
Refal
$ENTRY Go {
= <FizzBuzz 1>;
};
FizzBuzz {
101 = ;
s.N = <Prout <Item s.N>>
<FizzBuzz <+ 1 s.N>>;
};
Item {
s.N, <Mod s.N 15>: 0 = FizzBuzz;
s.N, <Mod s.N 5>: 0 = Buzz;
s.N, <Mod s.N 3>: 0 = Fizz;
s.N = s.N;
};
Retro
This is a port of some Forth code.
: 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 ;
It's cleaner to use quotes and combinators though:
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 ;
REXX
This version's program logic closely mirrors the problem statement:
three IF-THEN
/*REXX program displays numbers 1 ──► 100 (some transformed) for the FizzBuzz problem.*/
/*╔═══════════════════════════════════╗*/
do j=1 to 100; z= j /*║ ║*/
if j//3 ==0 then z= 'Fizz' /*║ The divisors (//) of the IFs ║*/
if j//5 ==0 then z= 'Buzz' /*║ must be in ascending order. ║*/
if j//(3*5)==0 then z= 'FizzBuzz' /*║ ║*/
say right(z, 8) /*╚═══════════════════════════════════╝*/
end /*j*/ /*stick a fork in it, we're all done. */
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
This version is a different form, but essentially identical to the IF-THEN (above),
but doesn't require the use of a temporary variable to hold/contain the output.
/*REXX program displays numbers 1 ──► 100 (some transformed) for the FizzBuzz problem.*/
/*╔═══════════════════════════════════╗*/
do j=1 to 100 /*║ ║*/
select /*║ ║*/
when j//15==0 then say 'FizzBuzz' /*║ The divisors (//) of the WHENs ║*/
when j//5 ==0 then say ' Buzz' /*║ must be in descending order. ║*/
when j//3 ==0 then say ' Fizz' /*║ ║*/
otherwise say right(j, 8) /*╚═══════════════════════════════════╝*/
end /*select*/
end /*j*/ /*stick a fork in it, we're all done. */
output is identical to the 1st REXX version.
two IF-THEN
This version lends itself to expansion (such as using Jazz for multiples of 7).
/*REXX program displays numbers 1 ──► 100 (some transformed) for the FizzBuzz problem.*/
do j=1 for 100; _=
if j//3 ==0 then _=_'Fizz'
if j//5 ==0 then _=_'Buzz'
/* if j//7 ==0 then _=_'Jazz' */ /* ◄─── note that this is a comment. */
say right(word(_ j,1),8)
end /*j*/ /*stick a fork in it, we're all done. */
output is identical to the 1st REXX version.
"geek" version
/*REXX program displays numbers 1 ──► 100 (some transformed) for the FizzBuzz problem.*/
/* [↓] concise, but somewhat obtuse. */
do j=1 for 100
say right(word(word('Fizz', 1+(j//3\==0))word('Buzz', 1+(j//5\==0)) j, 1), 8)
end /*j*/
/*stick a fork in it, we're all done. */
output is identical to the 1st REXX version.
Rhovas
Standard FizzBuzz using a pattern matching approach:
range(1, 100, :incl)
creates an inclusion range.for {
iterates through the range, with the current element beingval
- Pattern matching on
[val.mod(3), val.mod(5)]
is used to check divisibility conditions[0, 0]
, for instance, matches whenval
is divisible by both3
and5
else
matches all other possibilities, in this case whenval
is not divisible by3
or5
range(1, 100, :incl).for {
match ([val.mod(3), val.mod(5)]) {
[0, 0]: print("FizzBuzz");
[0, _]: print("Fizz");
[_, 0]: print("Buzz");
else: print(val);
}
};
Ring
for n = 1 to 100
if n % 15 = 0 see "" + n + " = " + "FizzBuzz" + nl loop
but n % 3 = 0 see "" + n + " = " + "Fizz"+ nl
but n % 5 = 0 see "" + n + " = " + "Buzz" + nl
else see "" + n + " = " + n + nl ok
next
- Output:
Limited to first 20.
1 = 1 2 = 2 3 = Fizz 4 = 4 5 = Buzz 6 = Fizz 7 = 7 8 = 8 9 = Fizz 10 = Buzz 11 = 11 12 = Fizz 13 = 13 14 = 14 15 = FizzBuzz 16 = 16 17 = 17 18 = Fizz 19 = 19 20 = Buzz
Robotic
set "local1" to 1
: "loop"
wait for 10
if "('local1' % 15)" = 0 then "fizzbuzz"
if "('local1' % 3)" = 0 then "fizz"
if "('local1' % 5)" = 0 then "buzz"
* "&local1&"
: "inc"
inc "local1" by 1
if "local1" <= 100 then "loop"
goto "done"
: "fizzbuzz"
* "FizzBuzz"
goto "inc"
: "fizz"
* "Fizz"
goto "inc"
: "buzz"
* "Buzz"
goto "inc"
: "done"
end
The wait for 10 function is not really necessary, but it helps to slow down the output.
Rockstar
Midnight takes your heart and your soul While your heart is as high as your soul Put your heart without your soul into your heart Give back your heart Desire is a lovestruck ladykiller My world is nothing Fire is ice Hate is water Until my world is Desire, Build my world up If Midnight taking my world, Fire is nothing and Midnight taking my world, Hate is nothing Shout "FizzBuzz!" Take it to the top If Midnight taking my world, Fire is nothing Shout "Fizz!" Take it to the top If Midnight taking my world, Hate is nothing Say "Buzz!" Take it to the top Whisper my world
RPG
**free dcl-s ix Int(5); for ix = 1 to 100; select; when %rem(ix:15) = 0; dsply 'FizzBuzz'; when %rem(ix:5) = 0; dsply 'Buzz'; when %rem(ix:3) = 0; dsply 'Fizz'; other; dsply (%char(ix)); endsl; endfor;
RPL
Structured programming:
≪ { } 1 100 FOR j IF j 3 MOD THEN "" ELSE "Fizz" END IF j 5 MOD NOT THEN "Buzz" + END IF DUP SIZE NOT THEN DROP j END + NEXT ≫ 'FIZZB' STO
Arithmetic:
≪ { } 1 100 FOR j j 3 MOD NOT j 5 MOD NOT → a b ≪ IF a b + THEN "FizzBuzz" 5 4 a * - a b 2 * MAX 4 * SUB ELSE j END ≫ + NEXT ≫ 'FIZZB' STO
Data-centric:
≪ "FizzBuzz" { (1,4) (5,8) (1,8) } → fb idx ≪ { } 1 100 FOR j IF j 3 MOD NOT j 5 MOD NOT 2 * + THEN fb idx LAST GET C→R SUB ELSE j END + NEXT ≫ ≫ 'FIZZB' STO
Esoteric one-liner:
≪ ≪ j ROT MOD "" ROT IFTE ≫ → f ≪ { } 1 100 FOR j 3 "Fizz" f EVAL 5 "Buzz" f EVAL + SIZE LAST j IFTE + NEXT ≫ ≫ EVAL
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)
puts
end
A bit more straightforward:
(1..100).each do |n|
puts if (n % 15).zero?
"FizzBuzz"
elsif (n % 5).zero?
"Buzz"
elsif (n % 3).zero?
"Fizz"
else
n
end
end
Enumerable#Lazy and classes:
We can grab the first n fizz/buzz/fizzbuzz numbers in a list with a user defined function (filter_map), starting at the number we desire
i.e, grabbing the first 10 fizz numbers starting from 30, fizz = Fizz.new(30,10) #=> [30, 33, 36, 39, 42, 45, 48, 51, 54, 57]
class Enumerator::Lazy
def filter_map
Lazy.new(self) do |holder, *values|
result = yield *values
holder << result if result
end
end
end
class Fizz
def initialize(head, tail)
@list = (head..Float::INFINITY).lazy.filter_map{|i| i if i % 3 == 0}.first(tail)
end
def fizz?(num)
search = @list
search.include?(num)
end
def drop(num)
list = @list
list.delete(num)
end
def to_a
@list.to_a
end
end
class Buzz
def initialize(head, tail)
@list = (head..Float::INFINITY).lazy.filter_map{|i| i if i % 5 == 0}.first(tail)
end
def buzz?(num)
search = @list
search.include?(num)
end
def drop(num)
list = @list
list.delete(num)
end
def to_a
@list.to_a
end
end
class FizzBuzz
def initialize(head, tail)
@list = (head..Float::INFINITY).lazy.filter_map{|i| i if i % 15 == 0}.first(tail)
end
def fizzbuzz?(num)
search = @list
search.include?(num)
end
def to_a
@list.to_a
end
def drop(num)
list = @list
list.delete(num)
end
end
stopper = 100
@fizz = Fizz.new(1,100)
@buzz = Buzz.new(1,100)
@fizzbuzz = FizzBuzz.new(1,100)
def min(v, n)
if v == 1
puts "Fizz: #{n}"
@fizz::drop(n)
elsif v == 2
puts "Buzz: #{n}"
@buzz::drop(n)
else
puts "FizzBuzz: #{n}"
@fizzbuzz::drop(n)
end
end
(@fizz.to_a & @fizzbuzz.to_a).map{|d| @fizz::drop(d)}
(@buzz.to_a & @fizzbuzz.to_a).map{|d| @buzz::drop(d)}
while @fizz.to_a.min < stopper or @buzz.to_a.min < stopper or @fizzbuzz.to_a.min < stopper
f, b, fb = @fizz.to_a.min, @buzz.to_a.min, @fizzbuzz.to_a.min
min(1,f) if f < fb and f < b
min(2,b) if b < f and b < fb
min(0,fb) if fb < b and fb < f
end
An example using string interpolation:
(1..100).each do |n|
v = "#{"Fizz" if n % 3 == 0}#{"Buzz" if n % 5 == 0}"
puts v.empty? ? n : v
end
Interpolation inspired one-liner:
1.upto(100) { |n| puts "#{'Fizz' if n % 3 == 0}#{'Buzz' if n % 5 == 0}#{n if n % 3 != 0 && n % 5 != 0}" }
An example using append:
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
Yet another solution:
1.upto(100) { |i| puts "#{[:Fizz][i%3]}#{[:Buzz][i%5]}"[/.+/] || i }
Yet another solution:
1.upto(100){|i|puts'FizzBuzz '[n=i**4%-15,n+13]||i}
Used Enumerable#cycle:
f = [nil, nil, :Fizz].cycle
b = [nil, nil, nil, nil, :Buzz].cycle
(1..100).each do |i|
puts "#{f.next}#{b.next}"[/.+/] || i
end
After beforehand preparing the Array which put the number from 1 to 100, it processes.
seq = *0..100
{Fizz:3, Buzz:5, FizzBuzz:15}.each{|k,n| n.step(100,n){|i|seq[i]=k}}
puts seq.drop(1)
Monkeypatch example:
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)
Without mutable variables or inline printing.
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")
Jump anywhere#Ruby has a worse example of FizzBuzz, using a continuation!
Using Ruby 3's Pattern Matching:
1.upto(100) do |n|
puts case [(n % 3).zero?, (n % 5).zero?]
in true, false
"Fizz"
in false, true
"Buzz"
in true, true
"FizzBuzz"
else
n
end
end
Ruby with RSpec
This is a solution to FizzBuzz using Test-Driven Development (In this case, with Ruby and RSpec). You will need to set up the correct file structure first, with /lib and /spec directories in your root.
Your spec/fizzbuzz_spec.rb file should like this:
require 'fizzbuzz'
describe 'FizzBuzz' do
context 'knows that a number is divisible by' do
it '3' do
expect(is_divisible_by_three?(3)).to be_true
end
it '5' do
expect(is_divisible_by_five?(5)).to be_true
end
it '15' do
expect(is_divisible_by_fifteen?(15)).to be_true
end
end
context 'knows that a number is not divisible by' do
it '3' do
expect(is_divisible_by_three?(1)).not_to be_true
end
it '5' do
expect(is_divisible_by_five?(1)).not_to be_true
end
it '15' do
expect(is_divisible_by_fifteen?(1)).not_to be_true
end
end
context 'while playing the game it returns' do
it 'the number' do
expect(fizzbuzz(1)).to eq 1
end
it 'Fizz' do
expect(fizzbuzz(3)).to eq 'Fizz'
end
it 'Buzz' do
expect(fizzbuzz(5)).to eq 'Buzz'
end
it 'FizzBuzz' do
expect(fizzbuzz(15)).to eq 'FizzBuzz'
end
end
end
There are many ways to get these tests to pass. Here is an example solution of what your lib/fizzbuzz.rb file could look like:
def fizzbuzz(number)
return 'FizzBuzz' if is_divisible_by_fifteen?(number)
return 'Buzz' if is_divisible_by_five?(number)
return 'Fizz' if is_divisible_by_three?(number)
number
end
def is_divisible_by_three?(number)
is_divisible_by(number, 3)
end
def is_divisible_by_five?(number)
is_divisible_by(number, 5)
end
def is_divisible_by_fifteen?(number)
is_divisible_by(number, 15)
end
def is_divisible_by(number, divisor)
number % divisor == 0
end
When writing Test Driven code, it's important to remember that you should use the Red, Green, Refactor cycle. Simply writing each of these code snippets independently would go against everything TDD is about. Here is a good video that takes you through the process of writing this FizzBuzz implementation using Ruby & RSpec.
Run BASIC
See FizzBuzz/Basic
Rust
Basic example with a for loop and match:
fn main() {
for i in 1..=100 {
match (i % 3, i % 5) {
(0, 0) => println!("fizzbuzz"),
(0, _) => println!("fizz"),
(_, 0) => println!("buzz"),
(_, _) => println!("{}", i),
}
}
}
Using an iterator and immutable data:
use std::borrow::Cow;
fn main() {
(1..=100)
.map(|n| match (n % 3, n % 5) {
(0, 0) => "FizzBuzz".into(),
(0, _) => "Fizz".into(),
(_, 0) => "Buzz".into(),
_ => Cow::from(n.to_string()),
})
.for_each(|n| println!("{:?}", n));
}
A folding iterator version, buffered with a single string allocation, by making use of expressions the write!
macro.
use std::fmt::Write;
fn fizzbuzz() -> String {
(1..=100).fold(String::new(), |mut output, x| {
let fizz = if x % 3 == 0 { "fizz" } else { "" };
let buzz = if x % 5 == 0 { "buzz" } else { "" };
if fizz.len() + buzz.len() != 0 {
output + fizz + buzz + "\n"
} else {
write!(&mut output, "{}", x).unwrap();
output + "\n"
}
})
}
fn main() {
println!("{}", fizzbuzz());
}
Or the ultimate optimized version with hardcoded output, no standard library or main function, and direct assembly syscalls to write to stdout.
#![no_std]
#![feature(asm, lang_items, libc, no_std, start)]
extern crate libc;
const LEN: usize = 413;
static OUT: [u8; LEN] = *b"\
1\n2\nFizz\n4\nBuzz\nFizz\n7\n8\nFizz\nBuzz\n11\nFizz\n13\n14\nFizzBuzz\n\
16\n17\nFizz\n19\nBuzz\nFizz\n22\n23\nFizz\nBuzz\n26\nFizz\n28\n29\nFizzBuzz\n\
31\n32\nFizz\n34\nBuzz\nFizz\n37\n38\nFizz\nBuzz\n41\nFizz\n43\n44\nFizzBuzz\n\
46\n47\nFizz\n49\nBuzz\nFizz\n52\n53\nFizz\nBuzz\n56\nFizz\n58\n59\nFizzBuzz\n\
61\n62\nFizz\n64\nBuzz\nFizz\n67\n68\nFizz\nBuzz\n71\nFizz\n73\n74\nFizzBuzz\n\
76\n77\nFizz\n79\nBuzz\nFizz\n82\n83\nFizz\nBuzz\n86\nFizz\n88\n89\nFizzBuzz\n\
91\n92\nFizz\n94\nBuzz\nFizz\n97\n98\nFizz\nBuzz\n";
#[start]
fn start(_argc: isize, _argv: *const *const u8) -> isize {
unsafe {
asm!(
"
mov $$1, %rax
mov $$1, %rdi
mov $0, %rsi
mov $1, %rdx
syscall
"
:
: "r" (&OUT[0]) "r" (LEN)
: "rax", "rdi", "rsi", "rdx"
:
);
}
0
}
#[lang = "eh_personality"] extern fn eh_personality() {}
#[lang = "panic_fmt"] extern fn panic_fmt() {}
Salmon
iterate (x; [1...100])
((x % 15 == 0) ? "FizzBuzz" :
((x % 3 == 0) ? "Fizz" :
((x % 5 == 0) ? "Buzz" : x)))!;
or
iterate (x; [1...100])
{
if (x % 15 == 0)
"FizzBuzz"!
else if (x % 3 == 0)
"Fizz"!
else if (x % 5 == 0)
"Buzz"!
else
x!;
};
SAS
data _null_;
do i=1 to 100;
if mod(i,15)=0 then put "FizzBuzz";
else if mod(i,5)=0 then put "Buzz";
else if mod(i,3)=0 then put "Fizz";
else put i;
end;
run;
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;
Scala
Idiomatic scala code
object FizzBuzz extends App {
1 to 100 foreach { n =>
println((n % 3, n % 5) match {
case (0, 0) => "FizzBuzz"
case (0, _) => "Fizz"
case (_, 0) => "Buzz"
case _ => n
})
}
}
Geeky over-generalized solution ☺
def replaceMultiples(x: Int, rs: (Int, String)*): Either[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 = replaceMultiples(_: Int, 3 -> "Fizz", 5 -> "Buzz") fold(_.toString, identity)
1 to 100 map fizzbuzz foreach println
By a two-liners geek
def f(n: Int, div: Int, met: String, notMet: String): String = if (n % div == 0) met else notMet
for (i <- 1 to 100) println(f(i, 15, "FizzBuzz", f(i, 3, "Fizz", f(i, 5, "Buzz", i.toString))))
One-liner geek
for (i <- 1 to 100) println(Seq(15 -> "FizzBuzz", 3 -> "Fizz", 5 -> "Buzz").find(i % _._1 == 0).map(_._2).getOrElse(i))
Functional Scala
def fizzBuzzTerm(n: Int): String =
if (n % 15 == 0) "FizzBuzz"
else if (n % 3 == 0) "Fizz"
else if (n % 5 == 0) "Buzz"
else n.toString
def fizzBuzz(): Unit = LazyList.from(1).take(100).map(fizzBuzzTerm).foreach(println)
Scala 3 (Dotty)
Written so as to introduce changes, with comments.
def fizzBuzzTerm(n: Int): String | Int = // union types
(n % 3, n % 5) match // optional semantic indentation; no braces
case (0, 0) => "FizzBuzz"
case (0, _) => "Fizz"
case (_, 0) => "Buzz"
case _ => n // no need for `.toString`, thanks to union type
end match // optional `end` keyword, with what it's ending
end fizzBuzzTerm // `end` also usable for identifiers
val fizzBuzz = // no namespace object is required; all top level
LazyList.from(1).map(fizzBuzzTerm)
@main def run(): Unit = // @main for main method; can take custom args
fizzBuzz.take(100).foreach(println)
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))
Using a recursive procedure.
(define (fizzbuzz x y)
(println
(cond (( = (modulo x 15) 0 ) "FizzBuzz")
(( = (modulo x 3) 0 ) "Fizz")
(( = (modulo x 5) 0 ) "Buzz")
(else x)))
(if (< x y) (fizzbuzz (+ x 1) y)))
(fizzbuzz 1 100)
Approach with maps and filters, easier to change, less readable than the previous.
(define (fizzbuzz x)
(let ([words '((3 . "Fizz")
(5 . "Buzz"))])
(define (fbm x)
(let ([w (map cdr (filter (lambda (wo) (= 0 (modulo x (car wo)))) words))])
(if (null? w) x (apply string-append w))))
(for-each (cut format #t "~a~%" <>) (map fbm (iota x 1 1)))))
(fizzbuzz 15)
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
Using seq:
seq 100 | sed '/.*[05]$/s//Buzz/;n;s//Buzz/;n;s//Buzz/;s/^[0-9]*/Fizz/'
GNU sed
GNU sed has first~step address expression that matches every stepth line. This makes following one-liners possible.
Using seq:
seq 100 | sed '0~3 s/.*/Fizz/; 0~5 s/[0-9]*$/Buzz/'
Using yes:
yes | sed -n '0~3s/y/Fizz/;0~5s/y*$/Buzz/;tx;=;b;:x;p;100q'
Using the option -z (--zero-data) first introduced in GNU sed 4.2.2 (2012-12-22):
sed -nz '0~3s/^/Fizz/;0~5s/$/Buzz/;tx;=;b;:x;p;100q' /dev/zero | sed 'y/\c@/\n/'
Second invocation of sed translates null characters to newlines. The same could be achieved with tr \\0 \\n
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;
SenseTalk
repeat 100
put "" into output
if the counter is a multiple of 3 then
put "Fizz" after output
end if
if the counter is a multiple of 5 then
put "Buzz" after output
end if
if output is empty then
put the counter into output
end if
put output
end repeat
SETL
program fizzbuzz;
loop for n in [1..100] do
print(fizzbuzz(n));
end loop;
proc fizzbuzz(n);
divs := [[3, "Fizz"], [5, "Buzz"]];
return +/[w : [d,w] in divs | n mod d=0] ? str n;
end proc;
end program;
SequenceL
import <Utilities/Conversion.sl>;
import <Utilities/Sequence.sl>;
main(args(2)) :=
let
result[i] :=
"FizzBuzz" when i mod 3 = 0 and i mod 5 = 0
else
"Fizz" when i mod 3 = 0
else
"Buzz" when i mod 5 = 0
else
intToString(i)
foreach i within 1 ... 100;
in
delimit(result, '\n');
Shale
#!/usr/local/bin/shale
string library
r var
i var
i 1 =
{ i 100 <= } {
r "" =
i 3 % 0 == { r r "fizz" concat string::() = } ifthen
i 5 % 0 == { r r "buzz" concat string::() = } ifthen
r "" equals string::() { i } { r } if i "%3d: %p\n" printf
i++
} while
Shen
(define fizzbuzz
101 -> (nl)
N -> (let divisible-by? (/. A B (integer? (/ A B)))
(cases (divisible-by? N 15) (do (output "Fizzbuzz!~%")
(fizzbuzz (+ N 1)))
(divisible-by? N 3) (do (output "Fizz!~%")
(fizzbuzz (+ N 1)))
(divisible-by? N 5) (do (output "Buzz!~%")
(fizzbuzz (+ N 1)))
true (do (output (str N))
(nl)
(fizzbuzz (+ N 1))))))
(fizzbuzz 1)
Alternative showing off other features like prolog integration and guards
(defprolog fizz
0 <-- (is _ (output "Fizz"));
N <-- (when (> N 0)) (is N1 (- N 3)) (fizz N1);
)
(defprolog buzz
0 <-- (is _ (output "Buzz"));
N <-- (when (> N 0)) (is N1 (- N 5)) (buzz N1);
)
(define none
[] -> true
[true | _] -> false
[_ | B] -> (none B)
)
(define fizzbuzz
N M -> (nl) where (> N M)
N M -> (do
(if (none [(prolog? (receive N) (fizz N)) (prolog? (receive N) (buzz N))])
(output (str N))
(output "!")
)
(nl)
(fizzbuzz (+ N 1) M)
)
)
(fizzbuzz 1 100)
Sidef
Structured:
{ |i|
if (i %% 3) {
print "Fizz"
i %% 5 && print "Buzz"
print "\n"
}
elsif (i %% 5) { say "Buzz" }
else { say i }
} << 1..100
Declarative:
func fizzbuzz({ _ %% 15 }) { "FizzBuzz" }
func fizzbuzz({ _ %% 5 }) { "Buzz" }
func fizzbuzz({ _ %% 3 }) { "Fizz" }
func fizzbuzz( n ) { n }
for n in (1..100) { say fizzbuzz(n) }
One-liner:
{>"#{<Fizz>[.%3]}#{<Buzz>[.%5]}"||_}<<1..100
Simula
begin
integer i;
for i := 1 step 1 until 100 do
begin
boolean fizzed;
fizzed := 0 = mod(i, 3);
if fizzed then
outtext("Fizz");
if mod(i, 5) = 0 then
outtext("Buzz")
else if not fizzed then
outint(i, 3);
outimage
end;
end
SkookumScript
Answer by printing out one of the 4 alternatives:
1.to 100
[
println(
if idx.mod(15) = 0 ["FizzBuzz"]
idx.mod(3) = 0 ["Fizz"]
idx.mod(5) = 0 ["Buzz"]
else [idx])
]
Answer by building up a string:
1.to 100
[
!str: ""
if idx.mod(3) = 0 [str += "Fizz"]
if idx.mod(5) = 0 [str += "Buzz"]
println(if str.empty? [idx] else [str])
]
Or doing initial bind in one step:
1.to 100
[
!str: if idx.mod(3) = 0 ["Fizz"] else [""]
if idx.mod(5) = 0 [str += "Buzz"]
println(if str.empty? [idx] else [str])
]
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]
Slope
(define fizz-buzz
(lambda (x)
(define ret "")
(if (zero? (% x 3))(set! ret (append ret "fizz")))
(if (zero? (% x 5))(set! ret (append ret "buzz")))
(if (equal? ret "") (set! ret (append ret x)))
ret))
(apply display-lines (list-join (map fizz-buzz (range 100 1))))
Small
See FizzBuzz/EsoLang
SmallBASIC
See FizzBuzz/Basic
Smalltalk
Since only GNU Smalltalk supports file-based programming, we'll be using its syntax.
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 ]
A Squeak/Pharo example using the Transcript window:
(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.]
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.
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]
Smalltalk does not have a case-select construct, but a similar effect can be attained using a collection and the #includes: method:
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].
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):
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].
The approach building a dynamic string can be done as well:
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].
SNOBOL4
Merely posting a solution by Daniel Lyons
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
SNUSP
See FizzBuzz/EsoLang
SparForte
As a structured script.
#!/usr/local/bin/spar
pragma annotate( summary, "fizzbuzz" );
pragma annotate( description, "Write a program that prints the numbers from 1 to 100. But for multiples of" );
pragma annotate( description, "three print 'Fizz' instead of the number and for the multiples of five print" );
pragma annotate( description, "'Buzz'. For numbers which are multiples of both three and five print" );
pragma annotate( description, "'FizzBuzz'" );
pragma annotate( see_also, "http://rosettacode.org/wiki/FizzBuzz" );
pragma annotate( author, "Ken O. Burtch" );
pragma license( unrestricted );
pragma restriction( no_external_commands );
procedure fizzbuzz is
begin
for i in 1..100 loop
if i mod 15 = 0 then
? "FizzBuzz";
elsif i mod 5 = 0 then
? "Buzz";
elsif i mod 3 = 0 then
? "Fizz";
else
? i;
end if;
end loop;
end fizzbuzz;
SQL
Oracle SQL
SELECT CASE
WHEN MOD(level,15)=0 THEN 'FizzBuzz'
WHEN MOD(level,3)=0 THEN 'Fizz'
WHEN MOD(level,5)=0 THEN 'Buzz'
ELSE TO_CHAR(level)
END FizzBuzz
FROM dual
CONNECT BY LEVEL <= 100;
Or using Oracle's DECODE and NVL:
SELECT nvl(decode(MOD(level,3),0,'Fizz')||decode(MOD(level,5),0,'Buzz'),level)
FROM dual
CONNECT BY level<=100;
PostgreSQL specific
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;
Using Generate_Series and tables only:
SELECT COALESCE(FIZZ || BUZZ, FIZZ, BUZZ, OUTPUT) AS FIZZBUZZ FROM
(SELECT GENERATE_SERIES AS FULL_SERIES, TO_CHAR(GENERATE_SERIES,'99') AS OUTPUT
FROM GENERATE_SERIES(1,100)) F LEFT JOIN
(SELECT TEXT 'Fizz' AS FIZZ, GENERATE_SERIES AS FIZZ_SERIES FROM GENERATE_SERIES(0,100,3)) FIZZ ON
FIZZ.FIZZ_SERIES = F.FULL_SERIES LEFT JOIN
(SELECT TEXT 'Buzz' AS BUZZ, GENERATE_SERIES AS BUZZ_SERIES FROM GENERATE_SERIES(0,100,5)) BUZZ ON
BUZZ.BUZZ_SERIES = F.FULL_SERIES;
Recursive Common Table Expressions (MSSQL 2005+)
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 )
SQL Anywhere specific - minimalist
SELECT
isnull(if row_num % 3 = 0 then 'Fizz' endif + if row_num % 5 = 0 then 'Buzz' endif, str(row_num))
FROM
sa_rowgenerator(1,100)
Generic SQL using a join
This should work in most RDBMSs, but you may need to change MOD(i,divisor) to i % divisor.
-- 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;
Squirrel
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);
Stata
program define fizzbuzz
args n
forvalues i = 1/`n' {
if mod(`i',15) == 0 {
display "FizzBuzz"
}
else if mod(`i',5) == 0 {
display "Buzz"
}
else if mod(`i',3) == 0 {
display "Fizz"
}
else {
display `i'
}
}
end
Swahili
shughuli fizzBuzz() {
kwa i = 1 mpaka 100 {
kama (i % 15 == 0) {
andika("FizzBuzz")
} au (i % 5 == 0) {
andika("Buzz")
} au (i % 3 == 0) {
andika("Fizz")
} sivyo {
andika(i)
}
}
}
Swift
using a switch statement
for i in 1...100 {
switch (i % 3, i % 5) {
case (0, 0):
print("FizzBuzz")
case (0, _):
print("Fizz")
case (_, 0):
print("Buzz")
default:
print(i)
}
}
using two if statements and an Optional
for i in 1...100{
var s:String?
if i%3==0{s="Fizz"}
if i%5==0{s=(s ?? "")+"Buzz"}
print(s ?? i)
}
using a precomputed cycle
import Foundation
let formats: [String] = [
"%d",
"%d",
"fizz",
"%d",
"buzz",
"fizz",
"%d",
"%d",
"fizz",
"buzz",
"%d",
"fizz",
"%d",
"%d",
"fizzbuzz",
]
var count = 0
var index = 0
while count < 100 {
count += 1
print(String(format: formats[index], count))
index += 1
index %= 15
}
Symstatic
let fizzBuzz(n) :=
let fb(0, 0) := "fizzbuzz"
let fb(0, _) := "fizz"
let fb(_, 0) := "buzz"
let fb(_, _) := n
fb(n % 3, n % 5)
for i in 1..101: println(fizzBuzz(i))
Symsyn
| FizzBuzz
1 I
if I LE 100
mod I 3 X
mod I 5 Y
if X EQ 0
'FIZZ' $S
if Y EQ 0
+ 'BUZZ' $S
endif
else
if Y EQ 0
'BUZZ' $S
else
~ I $S
endif
endif
$S []
+ I
goif
endif
Tailspin
templates fizz
$ mod 3 -> #
when <=0> do 'Fizz' !
end fizz
templates buzz
$ mod 5 -> #
when <=0> do 'Buzz' !
end buzz
[ 1..100 -> '$->fizz;$->buzz;' ] -> \[i](when <=''> do $i ! otherwise $ !\)... -> '$;
' -> !OUT::write
tbas
See FizzBuzz/Basic
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
The following example shows Tcl's substitution mechanism that allows to concatenate the results of two successive commands into a string:
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}
}
This version uses list rotation, so avoiding an explicit mod operation:
set f [lrepeat 5 "Fizz" {$i} {$i}]
foreach i {5 10} {lset f $i "Buzz"};lset f 0 "FizzBuzz"
for {set i 1} {$i <= 100} {incr i} {
puts [subst [lindex [set f [list {*}[lassign $f ff] $ff]] 0]]
}
TI SR-56
Display | Key | Display | Key | Display | Key | Display | Key |
---|---|---|---|---|---|---|---|
00 22 | GTO | 25 64 | x | 50 03 | 3 | 75 | |
01 03 | 3 | 26 52 | ( | 51 34 | RCL | 76 | |
02 07 | 7 | 27 52 | ( | 52 01 | 1 | 77 | |
03 53 | ) | 28 34 | RCL | 53 59 | *pause | 78 | |
04 12 | INV | 29 01 | 1 | 54 22 | GTO | 79 | |
05 29 | *Int | 30 54 | / | 55 03 | 3 | 80 | |
06 56 | *CP | 31 05 | 5 | 56 08 | 8 | 81 | |
07 12 | INV | 32 57 | subr | 57 | 82 | ||
08 37 | *x=t | 33 00 | 0 | 58 | 83 | ||
09 01 | 1 | 34 03 | 3 | 59 | 84 | ||
10 03 | 3 | 35 94 | = | 60 | 85 | ||
11 01 | 1 | 36 58 | rtn | 61 | 86 | ||
12 84 | + | 37 38 | *CMs | 62 | 87 | ||
13 00 | 0 | 38 01 | 1 | 63 | 88 | ||
14 53 | ) | 39 35 | SUM | 64 | 89 | ||
15 58 | rtn | 40 02 | 2 | 65 | 90 | ||
16 33 | STO | 41 34 | RCL | 66 | 91 | ||
17 01 | 1 | 42 02 | 2 | 67 | 92 | ||
18 54 | / | 43 57 | subr | 68 | 93 | ||
19 03 | 3 | 44 01 | 1 | 69 | 94 | ||
20 57 | subr | 45 06 | 6 | 70 | 95 | ||
21 00 | 0 | 46 93 | +/- | 71 | 96 | ||
22 03 | 3 | 47 12 | INV | 72 | 97 | ||
23 84 | + | 48 47 | *x>=t | 73 | 98 | ||
24 02 | 2 | 49 05 | 5 | 74 | 99 |
Asterisk denotes 2nd function key.
0: Unused | 1: Argument | 2: Number | 3: Unused | 4: Unused |
5: Unused | 6: Unused | 7: Unused | 8: Unused | 9: Unused |
Annotated listing:
// Address 00: Entry point
GTO 3 7 // Jump to the main program
// Address 03: Subroutine
// Takes a pending division such as ((12/5 and evaluates whether it
// is evenly divisible.
// Result 1: evenly divisible, 0: not divisible
) // Complete the pending division
INV *Int // Take the fractional part
*CP // RegT := 0
INV *x=t 1 3 // If fractional part is zero, don't increment
1 + // Start a pending increment of the return value
0 ) rtn // Return the return value
// Address 16: Subroutine
// Takes a number and evaluates whether it is divisible by 3 and 5.
// Result: 0=indivisible, 1=fizz, 2=buzz, 3=fizzbuzz
STO 1 // Save subroutine argument
/ 3 subr 0 3 // 1 if fizz else 0
+ 2 x // Buzz is worth 2x as much as Fizz
( ( RCL 1 / 5 subr 0 3 // 1 if buzz else 0
= // Finish the pending + and x
rtn // Return result
// Address 37: Main program
*CMs // Zero out registers
1 SUM 2 // Number += 1
RCL 2 // Retrieve Number
subr 1 6 // Evaluate whether it is divisible by 3 and 5
+/- // Negate (0=indiv., -1=fizz, -2=buzz, -3=fizzbuzz)
INV *x>=t 5 3 // If negative, skip the next line.
RCL 1 // Retrieve number instead of zero.
*pause // Flash the number on the display
GTO 3 8 // Loop
Usage:
Press RST R/S to start the program. Increasing numbers will flash on the screen. Positive numbers represent themselves; -1 means fizz, -2 buzz and -3 fizzbuzz. About 25 numbers are calculated per minute.
TI-83 BASIC
See FizzBuzz/Basic
TI-83 Hex Assembly
TI-99/4a TI BASIC / Extended BASIC
See FizzBuzz/Basic
Tiny BASIC
See FizzBuzz/Basic
TransFORTH
: FIZZBUZZ
101 1 DO
I 15 MOD 0 = IF
PRINT " FIZZBUZZ "
ELSE I 3 MOD 0 = IF
PRINT " FIZZ "
ELSE I 5 MOD 0 = IF
PRINT " BUZZ "
ELSE I . THEN THEN THEN
CR LOOP ;
True BASIC
See FizzBuzz/Basic
Turing
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
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
TXR
$ txr -p "(mapcar (op if @1 @1 @2) (repeat '(nil nil fizz nil buzz fizz nil nil fizz buzz nil fizz nil nil fizzbuzz)) (range 1 100))"
UNIX Shell
This solution should work with any Bourne-compatible shell:
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
Versions for specific shells
The other solutions work with fewer shells.
The next solution requires $(( ))
arithmetic expansion,
and it should work with every POSIX shell.
n=1
while [ 100 -ge n ]; do
if [ $((n % 15)) -eq 0 ]; then
echo FizzBuzz
elif [ $((n % 3)) -eq 0 ]; then
echo Fizz
elif [ $((n % 5)) -eq 0 ]; then
echo Buzz
else
echo $n
fi
n=$((n + 1))
done
The next solution requires the (( ))
command from the Korn Shell.
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
A version using concatenation:
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
A version using some of the insane overkill of Bash 4:
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
Bash one-liner:
for i in {1..100};do ((($i%15==0))&& echo FizzBuzz)||((($i%5==0))&& echo Buzz;)||((($i%3==0))&& echo Fizz;)||echo $i;done
C Shell
@ n = 1
while ( $n <= 100 )
if ($n % 15 == 0) then
echo FizzBuzz
else if ($n % 5 == 0) then
echo Buzz
else if ($n % 3 == 0) then
echo Fizz
else
echo $n
endif
@ n += 1
end
Uiua
⟨&p|&p"Fizz"|&p"Buzz"|&p"Fizzbuzz"⟩°⋯⍉=0⊞◿3_5.+1⇡100
Ursa
#
# fizzbuzz
#
decl int i
for (set i 1) (< i 101) (inc i)
if (= (mod i 3) 0)
out "fizz" console
end if
if (= (mod i 5) 0)
out "buzz" console
end if
if (not (or (= (mod i 3) 0) (= (mod i 5) 0)))
out i console
end if
out endl console
end for
Ursala
#import std
#import nat
fizzbuzz = ^T(&&'Fizz'! not remainder\3,&&'Buzz'! not remainder\5)|| ~&h+ %nP
#show+
main = fizzbuzz*t iota 101
Ursalang
let write = process.stdout.write
for i of range(100) {
let n = i + 1
if (n % 3 == 0) {write("Fizz")}
if (n % 5 == 0) {write("Buzz")}
if (n % 3 != 0 and n % 5 != 0) {write(n.toString())}
write("\n")
}
V
[fizzbuzz
1 [>=] [
[[15 % zero?] ['fizzbuzz' puts]
[5 % zero?] ['buzz' puts]
[3 % zero?] ['fizz' puts]
[true] [dup puts]
] when succ
] while].
|100 fizzbuzz
Second try
(a compiler for fizzbuzz)
define a command that will generate a sequence
[seq [] swap dup [zero? not] [rolldown [dup] dip cons rollup pred] while pop pop].
create a quote that will return a quote that returns a quote if its argument is an integer (A HOF)
[check [N X F : [[integer?] [[X % zero?] [N F cons] if] if]] view].
Create a quote that will make sure that the above quote is applied correctly if given (Number Function) as arguments.
[func [[N F] : [dup N F check i] ] view map].
And apply it
100 seq [
[15 [pop 'fizzbuzz' puts]]
[5 [pop 'buzz' puts]]
[3 [pop 'fizz' puts]]
[1 [puts]]] [func dup] step
[i true] map pop
the first one is much better :)
Vala
int main() {
for (int i = 1; i <= 100; i++) {
if (i % 3 == 0) stdout.printf("Fizz\n");
if (i % 5 == 0) stdout.printf("Buzz\n");
if (i % 15 == 0) stdout.printf("FizzBuzz\n");
if (i % 3 != 0 && i % 5 != 0) stdout.printf("%d\n", i);
}
return 0;;
}
Vale
import stdlib.*;
exported func main(){
fizzBuzz(1, 100);
}
func fizzBuzz(i int, stop int) {
result = if i.mod(3) == 0 {
"Fizz" } else { ""
} + if i.mod(5) == 0 {
"Buzz" } else { ""
};
println(if result == "" { i.str() } else { result });
if i < stop {
return fizzBuzz(i + 1, stop);
}
}
VAX Assembly
00000008 0000 1 len =8
00000008 0000 2 msg: .blkb len ;output buffer
0000000C 0008 3 desc: .blkl 1 ;descriptor lenght field
00000000' 000C 4 .address msg ;pointer to buffer
00000012 0010 5 outlen: .blkw 1
4C 55 21 0000001A'010E0000' 0012 6 ctr: .ascid "!UL"
001D 7
0000 001D 8 .entry start,0
52 7C 001F 9 clrq r2 ;r2+r3 64bit
52 D6 0021 10 incl r2 ;start index 1
0023 11 loop:
E2 AF B4 0023 12 clrw desc ;assume not fizz and or buzz
55 D7 AF 9E 0026 13 movab msg, r5 ;pointer to message buffer
54 50 52 03 7B 002A 14 ediv #3,r2,r0,r4 ;divr.rl,divd.rq,quo.wl,rem.wl
54 D5 002F 15 tstl r4 ;remainder
0B 12 0031 16 bneq not_fizz ;not equal zero
0033 17
85 7A7A6966 8F D0 0033 18 movl #^a"fizz", (r5)+ ;add to message
CA AF 04 A0 003A 19 addw2 #4, desc ;and update length
003E 20 not_fizz:
54 50 52 05 7B 003E 21 ediv #5,r2,r0,r4
54 D5 0043 22 tstl r4
0B 12 0045 23 bneq not_buzz
0047 24
85 7A7A7562 8F D0 0047 25 movl #^a"buzz", (r5)+
B6 AF 04 A0 004E 26 addw2 #4, desc
0052 27 not_buzz:
B3 AF B5 0052 28 tstw desc ;fizz and or buzz?
1B 12 0055 29 bneq show_buffer ;neq - yes
0057 30
AD AF 08 B0 0057 31 movw #len, desc ;fao length limit
005B 32 $fao_s - ;eql -no
005B 33 ctrstr = ctr, - ;show number
005B 34 outlen = outlen, -
005B 35 outbuf = desc, -
005B 36 p1 = r2
96 AF A0 AF B0 006D 37 movw outlen, desc ;characters filled by fao
0072 38 show_buffer:
93 AF 7F 0072 39 pushaq desc
00000000'GF 01 FB 0075 40 calls #1, g^lib$put_output
9F 52 00000064 8F F3 007C 41 AOBLEQ #100,r2,loop ;limit.rl, index.ml
04 0084 42 ret
0085 43 .end start
VBA
Option Explicit
Sub FizzBuzz()
Dim Tb(1 To 100) As Variant
Dim i As Integer
For i = 1 To 100
'Tb(i) = i ' move to Else
If i Mod 15 = 0 Then
Tb(i) = "FizzBuzz"
ElseIf i Mod 5 = 0 Then
Tb(i) = "Buzz"
ElseIf i Mod 3 = 0 Then
Tb(i) = "Fizz"
Else
Tb(i) = i
End If
Next
Debug.Print Join(Tb, vbCrLf)
End Sub
As an alternative, testing each number only once:
Sub FizzBuzz()
Dim i As Integer
Dim T(1 To 99) As Variant
For i = 1 To 99 Step 3
T(i + 0) = IIf((i + 0) Mod 5 = 0, "Buzz", i)
T(i + 1) = IIf((i + 1) Mod 5 = 0, "Buzz", i + 1)
T(i + 2) = IIf((i + 2) Mod 5 = 0, "FizzBuzz", "Fizz")
Next i
Debug.Print Join(T, ", ") & ", Buzz"
End Sub
VBScript
For i = 1 To 100
If i Mod 15 = 0 Then
WScript.Echo "FizzBuzz"
ElseIf i Mod 5 = 0 Then
WScript.Echo "Buzz"
ElseIf i Mod 3 = 0 Then
WScript.Echo "Fizz"
Else
WScript.Echo i
End If
Next
An Alternative
With WScript.StdOut
For i = 1 To 100
If i Mod 3 = 0 Then .Write "Fizz"
If i Mod 5 = 0 Then .Write "Buzz"
If .Column = 1 Then .WriteLine i Else .WriteLine ""
Next
End With
Verbexx
@LOOP init:{@VAR t3 t5; @VAR i = 1} while:(i <= 100) next:{i++}
{
t3 = (i % 3 == 0);
t5 = (i % 5 == 0);
@SAY ( @CASE when:(t3 && t5) { 'FizzBuzz }
when: t3 { 'Fizz }
when: t5 { 'Buzz }
else: { i }
);
};
Verilog
module main;
integer number;
initial begin
for(number = 1; number < 100; number = number + 1) begin
if (number % 15 == 0) $display("FizzBuzz");
else begin
if(number % 3 == 0) $display("Fizz");
else begin
if(number % 5 == 0) $display("Buzz");
else $display(number);
end
end
end
$finish;
end
endmodule
VHDL
entity fizzbuzz is
end entity fizzbuzz;
architecture beh of fizzbuzz is
procedure fizzbuzz(num : natural) is
begin
if num mod 15 = 0 then
report "FIZZBUZZ";
elsif num mod 3 = 0 then
report "FIZZ";
elsif num mod 5 = 0 then
report "BUZZ";
else
report to_string(num);
end if;
end procedure fizzbuzz;
begin
p_fizz : process is
begin
for i in 1 to 100 loop
fizzbuzz(i);
end loop;
wait for 200 us;
end process p_fizz;
end architecture beh;
Vim Script
for i in range(1, 100)
if i % 15 == 0
echo "FizzBuzz"
elseif i % 5 == 0
echo "Buzz"
elseif i % 3 == 0
echo "Fizz"
else
echo i
endif
endfor
Visual Basic .NET
See FizzBuzz/Basic
Visual Prolog
implement main
open core, console
class predicates
fizzbuzz : (integer) -> string procedure (i).
clauses
fizzbuzz(X) = S :- X mod 15 = 0, S = "FizzBuzz", !.
fizzbuzz(X) = S :- X mod 5 = 0, S = "Buzz", !.
fizzbuzz(X) = S :- X mod 3 = 0, S = "Fizz", !.
fizzbuzz(X) = S :- S = toString(X).
run() :-
foreach X = std::fromTo(1,100) do
write(fizzbuzz(X)), write("\n")
end foreach,
succeed.
end implement main
goal
console::runUtf8(main::run).
V (Vlang)
Updated for V (Vlang) version 0.2.2
const (
fizz = Tuple{true, false}
buzz = Tuple{false, true}
fizzbuzz = Tuple{true, true}
)
struct Tuple{
val1 bool
val2 bool
}
fn fizz_or_buzz( val int ) Tuple {
return Tuple{ val % 3 == 0, val % 5 == 0 }
}
fn fizzbuzz( n int ) {
for i in 1..(n + 1) {
match fizz_or_buzz(i) {
fizz { println('Fizz') }
buzz { println('Buzz') }
fizzbuzz { println('FizzBuzz') }
else { println(i) }
}
}
}
fn main(){
fizzbuzz(15)
}
- Output:
1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz
Basic example with a for loop and match:
fn main() {
mut i := 1
for i <= 100 {
match true {
i % 15 == 0 { println('FizzBuzz') }
i % 3 == 0 { println('Fizz') }
i % 5 == 0 { println('Buzz') }
else { println(i) }
}
i++
}
}
Another basic example using the ubiquitous if/else (if) statement:
fn main() {
for i in 1..100 {
if i % 15 == 0 {
println('FizzBuzz')
} else if i % 3 == 0 {
println('Fizz')
} else if i % 5 == 0 {
println('Buzz')
} else {
println(i)
}
}
}
- 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
VTL-2
10 N=1
20 #=30
30 #=N/3*0+%=0*110
40 #=N/5*0+%=0*130
50 #=!+30
60 ?=N
70 ?=""
80 N=N+1
90 #=100>N*20
100 #=999
110 ?="Fizz";
120 #=!
130 ?="Buzz";
140 #=!
180 #=70
Wart
for i 1 (i <= 100) ++i
prn (if (divides i 15)
"FizzBuzz"
(divides i 3)
"Fizz"
(divides i 5)
"Buzz"
:else
i)
WDTE
let io => import 'io';
let s => import 'stream';
let multiple of n => == (% n of) 0;
let fizzbuzz n => switch n {
multiple (* 3 5) => 'FizzBuzz';
multiple 3 => 'Fizz';
multiple 5 => 'Buzz';
default => n;
} -- io.writeln io.stdout;
s.range 1 101 -> s.map fizzbuzz -> s.drain;
Whitespace
See FizzBuzz/EsoLang
Wortel
@each &x!console.log x !*&x?{%%x 15 "FizzBuzz" %%x 5 "Buzz" %%x 3 "Fizz" x} @to 100
Wren
for (i in 1..100) {
if (i % 15 == 0) {
System.print("FizzBuzz")
} else if (i % 3 == 0) {
System.print("Fizz")
} else if (i % 5 == 0) {
System.print("Buzz")
} else {
System.print(i)
}
}
- 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
X86 Assembly
; x86_64 linux nasm
section .bss
number resb 4
section .data
fizz: db "Fizz"
buzz: db "Buzz"
newLine: db 10
section .text
global _start
_start:
mov rax, 1 ; initialize counter
loop:
push rax
call fizzBuzz
pop rax
inc rax
cmp rax, 100
jle loop
mov rax, 60
mov rdi, 0
syscall
fizzBuzz:
mov r10, rax
mov r15, 0 ; boolean fizz or buzz
checkFizz:
xor rdx, rdx ; clear rdx for division
mov rbx, 3
div rbx
cmp rdx, 0 ; modulo result here
jne checkBuzz
mov r15, 1
mov rsi, fizz
mov rdx, 4
mov rax, 1
mov rdi, 1
syscall
checkBuzz:
mov rax, r10
xor rdx, rdx
mov rbx, 5
div rbx
cmp rdx, 0
jne finishLine
mov r15, 1
mov rsi, buzz
mov rdx, 4
mov rax, 1
mov rdi, 1
syscall
finishLine: ; print number if no fizz or buzz
cmp r15, 1
je nextLine
mov rax, r10
call printNum
ret
nextLine:
mov rsi, newLine
mov rdx, 1
mov rax, 1
mov rdi, 1
syscall
ret
printNum: ; write proper digits into number buffer
cmp rax, 100
jl lessThanHundred
mov byte [number], 49
mov byte [number + 1], 48
mov byte [number + 2], 48
mov rdx, 3
jmp print
lessThanHundred: ; get digits to write through division
xor rdx, rdx
mov rbx, 10
div rbx
add rdx, 48
cmp rax, 0
je lessThanTen
add rax, 48
mov byte [number], al
mov byte [number + 1], dl
mov rdx, 2
jmp print
lessThanTen:
mov byte [number], dl
mov rdx, 1
print:
mov byte [number + rdx], 10 ; add newline
inc rdx
mov rax, 1
mov rdi, 1
mov rsi, number
syscall
ret
XBasic
See FizzBuzz/Basic
XLISP
(defun fizzbuzz ()
(defun fizzb (x y)
(display (cond
((= (mod x 3) (mod x 5) 0) "FizzBuzz")
((= (mod x 3) 0) "Fizz")
((= (mod x 5) 0) "Buzz")
(t x)))
(newline)
(if (< x y)
(fizzb (+ x 1) y)))
(fizzb 1 100))
(fizzbuzz)
XMIDAS
startmacro
loop 100 count
calc/quiet three ^count 3 modulo
calc/quiet five ^count 5 modulo
if ^three eq 0 and ^five eq 0
say "fizzbuzz"
elseif ^three eq 0
say "fizz"
elseif ^five eq 0
say "buzz"
else
say ^count
endif
endloop
endmacro
Xojo
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
An alternative syntax:
For i As Integer = 1 To 100
Select Case True
Case i Mod 3 = 0 And i Mod 5 = 0
Print("FizzBuzz")
Case i Mod 3 = 0
Print("Fizz")
Case i Mod 5 = 0
Print("Buzz")
Else
Print(Str(i))
End Select
Next
XPath 2.0
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)])
...or alternatively...
for $n in 1 to 100 return
($n, 'Fizz', 'Buzz', 'FizzBuzz')[number(($n mod 3) = 0) + number(($n mod 5) = 0)*2 + 1]
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);
];
]
- Output:
1 2 Fizz 4 Buzz Fizz 7 ... 89 FizzBuzz 91 92 Fizz 94 Buzz Fizz 97 98 Fizz Buzz
XSLT
XSLT 1.0
<?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"/>
<!-- Outputs a line for a single FizzBuzz iteration. -->
<xsl:template name="fizzbuzz-single">
<xsl:param name="n"/>
<!-- $s will be "", "Fizz", "Buzz", or "FizzBuzz". -->
<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>
<!-- Output $s. If $s is blank, also output $n. -->
<xsl:value-of select="$s"/>
<xsl:if test="$s = ''">
<xsl:value-of select="$n"/>
</xsl:if>
<!-- End line. -->
<xsl:value-of select="' '"/>
</xsl:template>
<!-- Calls fizzbuzz-single over each value in a range. -->
<xsl:template name="fizzbuzz-range">
<!-- Default parameters: From 1 through 100 -->
<xsl:param name="startAt" select="1"/>
<xsl:param name="endAt" select="$startAt + 99"/>
<!-- Simulate a loop with tail recursion. -->
<!-- Loop condition -->
<xsl:if test="$startAt <= $endAt">
<!-- Loop body -->
<xsl:call-template name="fizzbuzz-single">
<xsl:with-param name="n" select="$startAt"/>
</xsl:call-template>
<!-- Increment counter, repeat -->
<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>
<!-- Main procedure -->
<xsl:template match="/">
<!-- Default parameters are used -->
<xsl:call-template name="fizzbuzz-range"/>
</xsl:template>
</xsl:stylesheet>
XSLT 1.0 With EXSLT
<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>
XSLT 2.0
<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>
Yabasic
See FizzBuzz/Basic
YAMLScript
#!/usr/bin/env ys-0
defn main(count=100 impl=1):
:: |
Invoke one of the FizzBuzz implementations below.
usage: ys fizzbuzz.ys [<count> [<implementation-number>]]
fizzbuzz =: "fizzbuzz-$impl"
say: "Running function '$fizzbuzz' with count=$count"
mapv say:
call V(fizzbuzz): count
defn fizzbuzz-1(n):
:: Implementation 1 - with 'map'
map _ (1 .. n):
fn(x):
cond:
zero?(x % 15) : 'FizzBuzz'
zero?(x % 5) : 'Buzz'
zero?(x % 3) : 'Fizz'
else : x
defn fizzbuzz-2(n):
:: Implementation 2 - with 'loop'
loop i 1, l []:
if i <= n:
recur inc(i):
conj l:
cond:
zero?(i % 15) : 'FizzBuzz'
zero?(i % 5) : 'Buzz'
zero?(i % 3) : 'Fizz'
else : i
else: l
defn fizzbuzz-3(n):
:: Implementation 3 - with 'for'
for x (1 .. n):
s =:
str:
when (x % 3) == 0: 'Fizz'
when (x % 5) == 0: 'Buzz'
if s == '': x s
- Output:
$ ys fizzbuzz.ys 16 2 Running function 'fizzbuzz-2' with count=16 1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16
Yorick
Iterative solution
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, "";
}
Vectorized solution
output = swrite(format="%d", indgen(100));
output(3::3) = "Fizz";
output(5::5) = "Buzz";
output(15::15) = "FizzBuzz";
write, format="%s\n", output;
Z80 Assembly
Zig
const print = @import("std").debug.print;
pub fn main() void {
var i: usize = 1;
while (i <= 100) : (i += 1) {
if (i % 3 == 0 and i % 5 == 0) {
print("FizzBuzz\n", .{});
} else if (i % 3 == 0) {
print("Fizz\n", .{});
} else if (i % 5 == 0) {
print("Buzz\n", .{});
} else {
print("{}\n", .{i});
}
}
}
zkl
foreach n in ([1..100]) {
if(n % 3 == 0) print("Fizz");
if(not (n%5)) "Buzz".print();
if(n%3 and n%5) print(n);
println();
}
Or, using infinite lazy sequences:
fcn f(a,b,c){ a+b and a+b or c }
Walker.cycle("","","Fizz").zipWith(f,Walker.cycle("","","","","Buzz"),[1..])
.walk(100).concat("\n").println();
More of the same:
Walker.cycle(0,0,"Fizz",0,"Buzz","Fizz",0,0,"Fizz","Buzz",0,"Fizz",0,0,"FizzBuzz")
.zipWith(fcn(a,b){ a or b },[1..]).walk(100).concat("\n").println();
- Output:
1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz ...
ZX Spectrum Basic
10 DEF FN m(a,b)=a-INT (a/b)*b
20 FOR a=1 TO 100
30 LET o$=""
40 IF FN m(a,3)=0 THEN LET o$="Fizz"
50 IF FN m(a,5)=0 THEN LET o$=o$+"Buzz"
60 IF o$="" THEN LET o$=STR$ a
70 PRINT o$
80 NEXT a
- Programming Tasks
- Classic CS problems and programs
- Iteration
- Recursion
- Simple
- 11l
- 360 Assembly
- 6502 Assembly
- 68000 Assembly
- 8080 Assembly
- 8086 Assembly
- 8th
- AArch64 Assembly
- ABAP
- ABC
- ACL2
- Action!
- ActionScript
- Ada
- Agda
- ALGOL 68
- ALGOL-M
- ALGOL W
- AntLang
- APEX
- APL
- AppleScript
- Applesoft BASIC
- Arbre
- Arc
- ARM Assembly
- Arturo
- AsciiDots
- ASIC
- Asymptote
- ATS
- AutoHotkey
- AutoIt
- Avail
- AWK
- Axe
- Babel
- BabyCobol
- BaCon
- Bash
- BASIC
- Basic09
- BASIC256
- Batch File
- BBC BASIC
- Bc
- BCPL
- Beeswax
- Befunge
- Blz
- Boo
- BQN
- Bracmat
- Brainf***
- Brat
- BrightScript (for Roku)
- Bruijn
- C
- C sharp
- C++
- Casio BASIC
- Cduce
- Ceylon
- Chapel
- Chef
- Cherrycake
- Clay
- Clipper
- CLIPS
- Clojure
- CLU
- CMake
- COBOL
- Coco
- Coconut
- CoffeeScript
- ColdFusion
- Comal
- Comefrom0x10
- Commodore BASIC
- Common Lisp
- Coq
- Cowgol
- Craft Basic
- Crystal
- CSS
- Cubescript
- D
- Dart
- Dc
- Delphi
- DeviousYarn
- Draco
- DUP
- DWScript
- Dyalect
- Déjà Vu
- E
- EasyLang
- ECL
- Ecstasy
- Ed
- Eero
- Egel
- Eiffel
- Ela
- Elixir
- Elm
- Emacs Lisp
- EMal
- Emojicode
- Enguage
- Erlang
- ERRE
- Euler
- Euphoria
- F Sharp
- Factor
- Falcon
- FALSE
- Fantom
- FBSL
- Fe
- Fennel
- FOCAL
- Fermat
- Fish
- Forth
- Fortran
- FreeBASIC
- Frege
- Frink
- FutureBasic
- Fōrmulæ
- Gambas
- GAP
- GDScript
- Genyris
- GFA Basic
- Gleam
- Go
- Golfscript
- Golo
- Gosu
- Groovy
- GW-BASIC
- Hare
- Haskell
- Hexiscript
- HicEst
- HolyC
- Hoon
- Huginn
- Hy
- I
- Icon
- Unicon
- Idris
- Inform 6
- Inform 7
- Insitux
- Io
- Ioke
- Iptscrae
- IS-BASIC
- J
- Janet
- Java
- JavaScript
- Joy
- Jq
- Julia
- K
- Kamailio Script
- Kaya
- KL1
- Klong
- Kotlin
- KQL
- KSI
- LabVIEW
- Lambdatalk
- Lang
- Langur
- Lasso
- LaTeX
- Ifthen
- Intcalc
- LDPL
- Lean
- Liberty BASIC
- LIL
- LiveCode
- LiveScript
- LLVM
- Lobster
- Logo
- LOLCODE
- LSE
- Lua
- Luck
- M2000 Interpreter
- M4
- MACRO-11
- MAD
- Make
- Jot
- Maple
- Mathematica
- Wolfram Language
- MATLAB
- Maxima
- MAXScript
- MEL
- Mercury
- Metafont
- Microsoft Small Basic
- Min
- Minimal BASIC
- MiniScript
- MIPS Assembly
- Mirah
- Miranda
- ML
- Standard ML
- MLite
- MMIX
- Modula-2
- Modula-3
- Monte
- MontiLang
- MoonScript
- MUMPS
- Nanoquery
- NATURAL
- Neko
- Nemerle
- NetRexx
- Never
- NewLISP
- NewtonScript
- Nickle
- Nim
- Nix
- Nu
- Oberon-2
- Objeck
- Objective-C
- OCaml
- Octave
- Oforth
- Ol
- Onyx (wasm)
- OOC
- Order
- Oz
- Palo Alto Tiny BASIC
- PARI/GP
- Pascal
- PascalABC.NET
- PDP-8 Assembly
- Peloton
- Perl
- Phix
- Phix/basics
- Phixmonti
- PHL
- PHP
- Picat
- PicoLisp
- Piet
- Pike
- PILOT
- PIR
- PL/I
- PL/M
- PL/SQL
- Plain English
- Pointless
- Pony
- Pop11
- PostScript
- Potion
- PowerShell
- Processing
- Prolog
- PureBasic
- Pyret
- Python
- Q
- QB64
- Quackery
- R
- Racket
- Raku
- RapidQ
- Rascal
- Raven
- REALbasic
- ReasonML
- REBOL
- Red
- Refal
- Retro
- REXX
- Rhovas
- Ring
- Robotic
- Rockstar
- RPG
- RPL
- Ruby
- Ruby with RSpec
- Run BASIC
- Rust
- Salmon
- SAS
- Sather
- Scala
- Scheme
- Sed
- Seed7
- SenseTalk
- SETL
- SequenceL
- Shale
- Shen
- Sidef
- Simula
- SkookumScript
- Slate
- Slope
- Small
- SmallBASIC
- Smalltalk
- SNOBOL4
- SNUSP
- SparForte
- SQL
- Squirrel
- Stata
- Swahili
- Swift
- Symstatic
- Symsyn
- Tailspin
- Tbas
- Tcl
- TI SR-56
- TI-83 BASIC
- TI-83 Hex Assembly
- TI-99/4a TI BASIC / Extended BASIC
- Tiny BASIC
- TransFORTH
- True BASIC
- Turing
- TUSCRIPT
- TXR
- UNIX Shell
- C Shell
- Uiua
- Ursa
- Ursala
- Ursalang
- V
- Vala
- Vale
- VAX Assembly
- VBA
- VBScript
- Verbexx
- Verilog
- VHDL
- Vim Script
- Visual Basic .NET
- Visual Prolog
- V (Vlang)
- VTL-2
- Wart
- WDTE
- Whitespace
- Wortel
- Wren
- X86 Assembly
- XBasic
- XLISP
- XMIDAS
- Xojo
- XPath 2.0
- XPL0
- XSLT
- Yabasic
- YAMLScript
- Yorick
- Z80 Assembly
- Zig
- Zkl
- ZX Spectrum Basic
- Pages with too many expensive parser function calls