# FizzBuzz: Difference between revisions

FizzBuzz
You are encouraged to solve this task according to the task description, using any language you may know.

Write a program that prints the integers from   1   to   100   (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

## 11l

Translation of: Python3: Simple
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)

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

Works with: as version Raspberry Pi 3B version Buster 64 bits
/* 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
bl displayResult
b 4f
2:                              // multiple 3
udiv x14,x13,x10
msub x15,x14,x10,x13        // remainder
cbnz x15,3f                 // zero ?
mov x0,x13
bl displayResult
b 4f
3:                               // multiple 5
udiv x14,x13,x11
msub x15,x14,x11,x13         // remainder
cbnz x15,4f                  // zero ?
mov x0,x13
bl displayResult
4:
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
/******************************************************************/
/*     Display résult                                            */
/******************************************************************/
/* x0 contains the number*/
/* x1 contains display string address    */
displayResult:
stp x2,lr,[sp,-16]!            // save  registers
mov x2,x1
bl conversion10S               // decimal conversion
bl strInsertAtCharInc          // insert result at @ character
bl affichageMess               // display message final
mov x0,x2
bl affichageMess

ldp x2,lr,[sp],16              // restaur  2 registers
/********************************************************/
/*        File Include fonctions                        */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"

## ABAP

### Impure Functional 1

Works with: ABAP version 7.4 SP05 or Above only
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

Works with: ABAP version 7.4 SP05 or Above only
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 ) ) ) ).


## 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: 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;  ## 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 ## 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. Works with: Dyalog_APL 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: Works with: GNU_APL (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 ∇  ## 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 ## 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 ## ASIC ## 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 .= "FizzBuzzn" Else If (Mod(A_Index, 3) = 0) output .= "Fizzn" Else If (Mod(A_Index, 5) = 0) output .= "Buzzn" 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 } ## 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 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 ## Basic09 ## BASIC256 ## 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 ## 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~%'dFizz@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~%'dFizzf>@F5~%'dBuzz@p b P~;"-~@~.+0~P9@N?< ## Befunge ## 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 ## 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*** ## 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 ## 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

Works with: C++11
#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).

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


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

Works with: OpenCOBOL
      * 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
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.

Works with: OpenCOBOL
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

Works with: OpenCOBOL
       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

Works with: OpenCOBOL

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'
when fizz also any
display 'fizz'
when buzz also any
display '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 ## 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)  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_fizz_buzz_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 get_first_positive_numbers (n: nat): list nat := seq 1 n. Definition fizz_buzz_terms (n: nat): list string := map get_fizz_buzz_term (get_first_positive_numbers n). Definition fizz_buzz: string := concat new_line (fizz_buzz_terms 100). (** This shows the string. *) Eval compute in fizz_buzz.  ## 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; ## 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)
if (i % 5 == 0)
print(out.length > 0 ? out.join("") : i);
}
}


## dc

Translation of: bc
[[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;

## 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, However they run on execution servers. By default remote servers are used, but they are limited in memory and processing power, since they are intended for demonstration and casual use. A local server can be downloaded and installed, it has no limitations (it runs in your own computer). Because of that, example programs can be fully visualized and edited, but some of them will not run if they require a moderate or heavy computation/memory resources, and no local server is being used.

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


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;


## 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 }


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

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 a single zipWith3: import Data.List (zipWith3) import Data.Bool (bool) fizzBuzz :: [String] fizzBuzz = zipWith3 (\f b n -> let fb = f ++ b in bool fb n (null fb)) (cycle$ replicate 2 [] ++ ["fizz"])
(cycle $replicate 4 [] ++ ["buzz"]) (show <$> [1 ..])

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

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

# 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

# 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

# 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

# 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

# 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

# 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


## 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.  ## 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 ## 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 fgh@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: Translation of: Python Translation of: Haskell (() => { '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

Works with: Julia version 0.6

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

For kona:
{,/$(s;x)@~#s:FizzBuzz@&~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.  ## langur for .i of 100 { writeln given(0; .i rem 15: "FizzBuzz"; .i rem 5: "Buzz"; .i rem 3: "Fizz"; .i) } Works with: langur version 0.8.1 for .i of 100 { writeln if(.i div 15: "FizzBuzz"; .i div 5: "Buzz"; .i div 3: "Fizz"; .i) } ## Lasso with i in generateSeries(1, 100) select ((#i % 3 == 0 ? 'Fizz' | '') + (#i % 5 == 0 ? 'Buzz' | '') || #i)  ## LaTeX Library: ifthen Library: 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. \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}  ## Liberty 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 [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'.

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

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


### 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)')') ') ## make Works with: BSD make Library: jot 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]


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


## 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 Translation of: GW-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 Works with: min version 0.19.3 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 ## 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

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