# FizzBuzz

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


## ABC

HOW TO RETURN fizzbuzz num:
PUT "" IN result
PUT {[3]: "Fizz"; [5]: "Buzz"} IN divwords
FOR div IN keys divwords:
IF num mod div=0:
PUT result^divwords[div] IN result
IF result="":
PUT num>>0 IN result
RETURN result

FOR i IN {1..100}:
WRITE fizzbuzz i/

## ACL2

(defun fizzbuzz-r (i)
(declare (xargs :measure (nfix (- 100 i))))
(prog2$(cond ((= (mod i 15) 0) (cw "FizzBuzz~%")) ((= (mod i 5) 0) (cw "Buzz~%")) ((= (mod i 3) 0) (cw "Fizz~%")) (t (cw "~x0~%" i))) (if (zp (- 100 i)) nil (fizzbuzz-r (1+ i))))) (defun fizzbuzz () (fizzbuzz-r 1))  ## Action! PROC Main() BYTE i,d3,d5 d3=1 d5=1 FOR i=1 TO 100 DO IF d3=0 AND d5=0 THEN Print("FizzBuzz") ELSEIF d3=0 THEN Print("Fizz") ELSEIF d5=0 THEN Print("Buzz") ELSE PrintB(i) FI Put(32) d3==+1 d5==+1 IF d3=3 THEN d3=0 FI IF d5=5 THEN d5=0 FI OD RETURN Output: 1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17 Fizz 19 Buzz Fizz 22 23 Fizz Buzz 26 Fizz 28 29 FizzBuzz 31 32 Fizz 34 Buzz Fizz 37 38 Fizz Buzz 41 Fizz 43 44 FizzBuzz 46 47 Fizz 49 Buzz Fizz 52 53 Fizz Buzz 56 Fizz 58 59 FizzBuzz 61 62 Fizz 64 Buzz Fizz 67 68 Fizz Buzz 71 Fizz 73 74 FizzBuzz 76 77 Fizz 79 Buzz Fizz 82 83 Fizz Buzz 86 Fizz 88 89 FizzBuzz 91 92 Fizz 94 Buzz Fizz 97 98 Fizz Buzz  ## ActionScript The ActionScript solution works just like the JavaScript solution (they share the ECMAScript specification). The difference is that ActionScript has the trace command to write out to a console. for (var i:int = 1; i <= 100; i++) { if (i % 15 == 0) trace('FizzBuzz'); else if (i % 5 == 0) trace('Buzz'); else if (i % 3 == 0) trace('Fizz'); else trace(i); }  ## Ada with Ada.Text_IO; use Ada.Text_IO; procedure Fizzbuzz is begin for I in 1..100 loop if I mod 15 = 0 then Put_Line("FizzBuzz"); elsif I mod 5 = 0 then Put_Line("Buzz"); elsif I mod 3 = 0 then Put_Line("Fizz"); else Put_Line(Integer'Image(I)); end if; end loop; end Fizzbuzz;  ## Agda module FizzBuzz where open import Agda.Builtin.IO using (IO) open import Agda.Builtin.Unit renaming (⊤ to Unit) open import Data.Bool using (Bool ; false ; true ; if_then_else_) open import Data.Nat using (ℕ ; zero ; suc ; _≡ᵇ_ ; _%_) open import Data.Nat.Show using (show) open import Data.List using (List ; [] ; _∷_ ; map) open import Data.String using (String ; _++_ ; unlines) postulate putStrLn : String -> IO Unit {-# FOREIGN GHC import qualified Data.Text as T #-} {-# COMPILE GHC putStrLn = putStrLn . T.unpack #-} fizz : String fizz = "Fizz" buzz : String buzz = "Buzz" _isDivisibleBy_ : (n : ℕ) -> (m : ℕ) -> Bool n isDivisibleBy zero = false n isDivisibleBy (suc k) = ((n % (suc k)) ≡ᵇ 0) getTerm : (n : ℕ) -> String getTerm n = if (n isDivisibleBy 15) then (fizz ++ buzz) else if (n isDivisibleBy 3) then fizz else if (n isDivisibleBy 5) then buzz else (show n) range : (a : ℕ) -> (b : ℕ) -> List (ℕ) range k zero = [] range k (suc m) = k ∷ (range (suc k) m) getTerms : (n : ℕ) -> List (String) getTerms n = map getTerm (range 1 n) fizzBuzz : String fizzBuzz = unlines (getTerms 100) main : IO Unit main = putStrLn fizzBuzz  ## ALGOL 68 main:( FOR i TO 100 DO printf(($gl$, IF i %* 15 = 0 THEN "FizzBuzz" ELIF i %* 3 = 0 THEN "Fizz" ELIF i %* 5 = 0 THEN "Buzz" ELSE i FI )) OD ) or simply: FOR i TO 100 DO print(((i%*15=0|"FizzBuzz"|:i%*3=0|"Fizz"|:i%*5=0|"Buzz"|i),new line)) OD ## 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 ∇  I prefer the DRYness of solutions that don't have "FizzBuzz" as a separate case; here's such a solution that works with both Dyalog and GNU. You may want to prepend ⍬⊣ to the whole thing in GNU to keep it from returning the list as the value of the expression, causing the interpreter to print it out a second time. Works with: Dyalog APL Works with: GNU APL ⎕io←1 {⎕←∊'Fizz' 'Buzz'⍵/⍨d,⍱/d←0=3 5|⍵}¨⍳100  Explanation: ⎕io←1 Set the index origin to 1; if it were set to 0, the next step would count from 0 to 99 instead of 1 to 100. { }¨⍳100 Do the thing in braces for each integer from 1 through 100. 3 5|⍵ Make a list of the remainders when the current number is divided by 3 and 5. d←0= Make it a Boolean vector: true for remainder=0, false otherwise. Name it d. d,⍱/ Prepend d to the result of reducing itself with XNOR, yielding a three-element Boolean vector. The first element is true if the number is divisible by 3; the second if it's divisible by 5; and the third only if it's divisible by neither. 'Fizz' 'Buzz'⍵/⍨ Use the Boolean vector as a mask to select elements from a new triple consisting of 'Fizz', 'Buzz', and the current number. Each of the three elements will be included in the selection only if the corresponding Boolean is true. ∊ Combine the selected elements into one vector/string ⎕← And print it out. ## AppleScript ### Procedural property outputText: "" repeat with i from 1 to 100 if i mod 15 = 0 then set outputText to outputText & "FizzBuzz" else if i mod 3 = 0 then set outputText to outputText & "Fizz" else if i mod 5 = 0 then set outputText to outputText & "Buzz" else set outputText to outputText & i end if set outputText to outputText & linefeed end repeat outputText  If this were a useful task requiring a degree of efficiency, it would be better to replace the cumulative text concatenations with additions to a fast-to-access list and coerce this list to text in one go at the end. Less critically, the (i mod … = 0) tests could be nested to reduce the number of these performed from 261 to 200: on fizzBuzz(n) script o property output : {} end script repeat with i from 1 to n if (i mod 3 = 0) then if (i mod 15 = 0) then set end of o's output to "FizzBuzz" else set end of o's output to "Fizz" end if else if (i mod 5 = 0) then set end of o's output to "Buzz" else set end of o's output to i end if end repeat set astid to AppleScript's text item delimiters set AppleScript's text item delimiters to linefeed set output to o's output as text set AppleScript's text item delimiters to astid return output end fizzBuzz fizzBuzz(100)  Another alternative would be simply to fill the list with numbers and then go through it again three times overwriting the relevant slots with the appropriate words: on fizzBuzz(n) script o property output : {} end script repeat with i from 1 to n set end of o's output to i end repeat repeat with x in {{3, "Fizz"}, {5, "Buzz"}, {15, "FizzBuzz"}} set {m, t} to x repeat with i from m to n by m set item i of o's output to t end repeat end repeat set astid to AppleScript's text item delimiters set AppleScript's text item delimiters to linefeed set output to o's output as text set AppleScript's text item delimiters to astid return output end fizzBuzz fizzBuzz(100)  With the number of numbers raised from 100 to 10,000, the two scripts inserted here take around 0.051 seconds to execute on my current machine, the original AppleScript above around 0.25 seconds, and the one below (originally described as "functional composition") 3.52 seconds. ### Functional For simplicity, and more efficient use of the scripter's time: ------------------------- FIZZBUZZ ------------------------- -- fizz :: Int -> Bool on fizz(n) n mod 3 = 0 end fizz -- buzz :: Int -> Bool on buzz(n) n mod 5 = 0 end buzz -- fizzAndBuzz :: Int -> Bool on fizzAndBuzz(n) n mod 15 = 0 end fizzAndBuzz -- fizzBuzz :: Int -> String on fizzBuzz(x) caseOf(x, [[my fizzAndBuzz, "FizzBuzz"], ¬ [my fizz, "Fizz"], ¬ [my buzz, "Buzz"]], x as string) end fizzBuzz --------------------------- TEST --------------------------- on run intercalate(linefeed, ¬ map(fizzBuzz, enumFromTo(1, 100))) end run -------------------- GENERIC FUNCTIONS --------------------- -- caseOf :: a -> [(predicate, b)] -> Maybe b -> Maybe b on caseOf(e, lstPV, default) repeat with lstCase in lstPV set {p, v} to contents of lstCase if mReturn(p)'s |λ|(e) then return v end repeat return default end caseOf -- enumFromTo :: Int -> Int -> [Int] on enumFromTo(m, n) if m > n then set d to -1 else set d to 1 end if set lst to {} repeat with i from m to n by d set end of lst to i end repeat return lst end enumFromTo -- intercalate :: Text -> [Text] -> Text on intercalate(strText, lstText) set {dlm, my text item delimiters} to {my text item delimiters, strText} set strJoined to lstText as text set my text item delimiters to dlm return strJoined end intercalate -- map :: (a -> b) -> [a] -> [b] on map(f, xs) tell mReturn(f) set lng to length of xs set lst to {} repeat with i from 1 to lng set end of lst to |λ|(item i of xs, i, xs) end repeat return lst end tell end map -- Lift 2nd class handler function into 1st class script wrapper -- mReturn :: Handler -> Script on mReturn(f) if class of f is script then f else script property |λ| : f end script end if end mReturn  ## Applesoft BASIC ## 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 } ## BabyCobol  * NB: ANY does not exist in BabyCobol so the elegant * EVALUATE-based COBOL-style solution is impossible here. * Note the subtly unbalanced IF/ENDs yet valid END at the end. IDENTIFICATION DIVISION. PROGRAM-ID. FIZZBUZZ. DATA DIVISION. 01 INT PICTURE IS 9(3). 01 REM LIKE INT. 01 TMP LIKE INT. PROCEDURE DIVISION. LOOP VARYING INT TO 100 DIVIDE 3 INTO INT GIVING TMP REMAINDER REM IF REM = 0 THEN DISPLAY "Fizz" WITH NO ADVANCING DIVIDE 5 INTO INT GIVING TMP REMAINDER REM IF REM = 0 THEN DISPLAY "Buzz" WITH NO ADVANCING DIVIDE 15 INTO INT GIVING TMP REMAINDER REM IF REM = 0 THEN DISPLAY "" ELSE DISPLAY INT END.  ## BaCon ## bash Any bash hacker would do this as a one liner at the shell, so... for n in {1..100}; do ((( n % 15 == 0 )) && echo 'FizzBuzz') || ((( n % 5 == 0 )) && echo 'Buzz') || ((( n % 3 == 0 )) && echo 'Fizz') || echo$n; done


for 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  Using the Choose Combonator with a rank 2 array (3‿5 (0=|)◶[⊢‿"fizz","buzz"‿"fizzbuzz"] ⊢)¨ 1+↕100  ## Bracmat 0:?i&whl'(1+!i:<101:?i&out$(mod$(!i.3):0&(mod$(!i.5):0&FizzBuzz|Fizz)|mod$(!i.5):0&Buzz|!i)) Same code, pretty printed:  0:?i & whl ' ( 1+!i:<101:?i & out$ (   mod$(!i.3):0 & ( mod$(!i.5):0&FizzBuzz
| Fizz
)
| mod$(!i.5):0&Buzz | !i ) ) ## Brainf*** ## Brat 1.to 100 { n | true? n % 15 == 0 { p "FizzBuzz" } { true? n % 3 == 0 { p "Fizz" } { true? n % 5 == 0 { p "Buzz" } { p n } } } } ## BrightScript (for Roku) FOR i = 1 TO 100 fz = i MOD 3 = 0 bz = i MOD 5 = 0 IF fz OR bz IF fz AND NOT bz: str = "Fizz" ELSEIF bz AND NOT fz: str = "Buzz" ELSE str = "FizzBuzz" END IF ELSE str = i.ToStr() END IF ? str END FOR ## Bruijn :import std/Combinator . :import std/String . :import std/Number . main [y [[0 =? (+101) case-end case-rec]] (+1)] case-rec str ++ "\n" ++ (1 ++0) str fizzbuzz "FizzBuzz" (fizz "Fizz" (buzz "Buzz" (number→string 0))) fizz =?(0 % (+3)) buzz =?(0 % (+5)) fizzbuzz fizz buzz fizz case-end empty ## C For 2 prime numbers and based on a similar minimal JavaScript solution with low signal-to-noise, the C code is:  int i = 0 ; char B[88] ; while ( i++ < 100 ) !sprintf( B, "%s%s", i%3 ? "":"Fizz", i%5 ? "":"Buzz" ) ? sprintf( B, "%d", i ):0, printf( ", %s", B );  With 4 prime numbers:  int i = 0 ; char B[88] ; while ( i++ < 100 ) !sprintf( B, "%s%s%s%s", i%3 ? "":"Fiz", i%5 ? "":"Buz", i%7 ? "":"Goz", i%11 ? "":"Kaz" ) ? sprintf( B, "%d", i ):0, printf( ", %s", B );  Output: ..., 89, FizBuz, Goz, 92, Fiz, 94, Buz, Fiz, 97, Goz, FizKaz, Buz  One line version, with pretty printing #include <stdio.h> int main() { for (int i=1; i<=105; i++) if (i%3 && i%5) printf("%3d ", i); else printf("%s%s%s", i%3?"":"Fizz", i%5?"":"Buzz", i%15?" ":"\n"); }  This actually works (the array init part, saves 6 bytes of static data, whee): #include<stdio.h> int main () { int i; const char *s[] = { "%d\n", "Fizz\n", s[3] + 4, "FizzBuzz\n" }; for (i = 1; i <= 100; i++) printf(s[!(i % 3) + 2 * !(i % 5)], i); return 0; }  #include<stdio.h> int main (void) { int i; for (i = 1; i <= 100; i++) { if (!(i % 15)) printf ("FizzBuzz"); else if (!(i % 3)) printf ("Fizz"); else if (!(i % 5)) printf ("Buzz"); else printf ("%d", i); printf("\n"); } return 0; }  Implicit int main and return 0 (C99+): #include <stdio.h> main() { int i = 1; while(i <= 100) { if(i % 15 == 0) puts("FizzBuzz"); else if(i % 3 == 0) puts("Fizz"); else if(i % 5 == 0) puts("Buzz"); else printf("%d\n", i); i++; } }  obfuscated: #include <stdio.h> #define F(x,y) printf("%s",i%x?"":#y"zz") int main(int i){for(--i;i++^100;puts(""))F(3,Fi)|F(5,Bu)||printf("%i",i);return 0;}  With numbers theory: #include <stdio.h> int main(void) { for (int i = 1; i <= 100; ++i) { if (i % 3 == 0) printf("fizz"); if (i % 5 == 0) printf("buzz"); if (i * i * i * i % 15 == 1) printf("%d", i); puts(""); } }  Without conditionals, anything in the loop body gcc compiles with branching, duplicate tests or duplicate strings. Depends on ASCII and two's complement arithmetic: #include <stdio.h> int main() { for (int i=0;++i<101;puts("")) { char f[] = "FizzBuzz%d"; f[8-i%5&12]=0; printf (f+(-i%3&4+f[8]/8), i); } }  ## C# class Program { public void FizzBuzzGo() { Boolean Fizz = false; Boolean Buzz = false; for (int count = 1; count <= 100; count ++) { Fizz = count % 3 == 0; Buzz = count % 5 == 0; if (Fizz && Buzz) { Console.WriteLine("Fizz Buzz"); listBox1.Items.Add("Fizz Buzz"); } else if (Fizz) { Console.WriteLine("Fizz"); listBox1.Items.Add("Fizz"); } else if (Buzz) { Console.WriteLine("Buzz"); listBox1.Items.Add("Buzz"); } else { Console.WriteLine(count); listBox1.Items.Add(count); } } } }  class Program { static void Main() { for (uint i = 1; i <= 100; i++) { string s = null; if (i % 3 == 0) s = "Fizz"; if (i % 5 == 0) s += "Buzz"; System.Console.WriteLine(s ?? i.ToString()); } } }  using System; using System.Linq; namespace FizzBuzz { class Program { static void Main(string[] args) { Enumerable.Range(1, 100) .Select(a => String.Format("{0}{1}", a % 3 == 0 ? "Fizz" : string.Empty, a % 5 == 0 ? "Buzz" : string.Empty)) .Select((b, i) => String.IsNullOrEmpty(b) ? (i + 1).ToString() : b) .ToList() .ForEach(Console.WriteLine); } } }  using System; using System.Globalization; using System.Linq; namespace FizzBuzz { class Program { static void Main() { Enumerable.Range(1, 100) .GroupBy(e => e % 15 == 0 ? "FizzBuzz" : e % 5 == 0 ? "Buzz" : e % 3 == 0 ? "Fizz" : string.Empty) .SelectMany(item => item.Select(x => new { Value = x, Display = String.IsNullOrEmpty(item.Key) ? x.ToString(CultureInfo.InvariantCulture) : item.Key })) .OrderBy(x => x.Value) .Select(x => x.Display) .ToList() .ForEach(Console.WriteLine); } } }  using System; namespace FizzBuzz { class Program { static void Main(string[] args) { for (int i = 1; i <= 100; i++) { if (i % 15 == 0) { Console.WriteLine("FizzBuzz"); } else if (i % 3 == 0) { Console.WriteLine("Fizz"); } else if (i % 5 == 0) { Console.WriteLine("Buzz"); } else { Console.WriteLine(i); } } } } }  using System; using System.Globalization; namespace Rosettacode { class Program { static void Main() { for (var number = 0; number < 100; number++) { if ((number % 3) == 0 & (number % 5) == 0) { //For numbers which are multiples of both three and five print "FizzBuzz". Console.WriteLine("FizzBuzz"); continue; } if ((number % 3) == 0) Console.WriteLine("Fizz"); if ((number % 5) == 0) Console.WriteLine("Buzz"); if ((number % 3) != 0 && (number % 5) != 0) Console.WriteLine(number.ToString(CultureInfo.InvariantCulture)); if (number % 5 == 0) { Console.WriteLine(Environment.NewLine); } } } } }  using System; using System.Linq; namespace FizzBuzz { class Program { static void Main(string[] args) { Enumerable.Range(1, 100).ToList().ForEach(i => Console.WriteLine(i % 5 == 0 ? string.Format(i % 3 == 0 ? "Fizz{0}" : "{0}", "Buzz") : string.Format(i%3 == 0 ? "Fizz" : i.ToString()))); } } }  ### With C#8 switch expressions class Program { public static string FizzBuzzIt(int n) => (n % 3, n % 5) switch { (0, 0) => "FizzBuzz", (0, _) => "Fizz", (_, 0) => "Buzz", (_, _) =>$"{n}"
};

static void Main(string[] args)
{
foreach (var n in Enumerable.Range(1, 100))
{
Console.WriteLine(FizzBuzzIt(n));
}
}
}


### TDD using delegates

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace FizzBuzz
{
[TestClass]
public class FizzBuzzTest
{
private FizzBuzz fizzBuzzer;

[TestInitialize]
public void Initialize()
{
fizzBuzzer = new FizzBuzz();
}

[TestMethod]
public void Give4WillReturn4()
{
Assert.AreEqual("4", fizzBuzzer.FizzBuzzer(4));
}

[TestMethod]
public void Give9WillReturnFizz()
{
Assert.AreEqual("Fizz", fizzBuzzer.FizzBuzzer(9));
}

[TestMethod]
public void Give25WillReturnBuzz()
{
Assert.AreEqual("Buzz", fizzBuzzer.FizzBuzzer(25));
}

[TestMethod]
public void Give30WillReturnFizzBuzz()
{
Assert.AreEqual("FizzBuzz", fizzBuzzer.FizzBuzzer(30));
}

[TestMethod]
public void First15()
{
ICollection expected = new ArrayList
{"1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz"};

var actual = Enumerable.Range(1, 15).Select(x => fizzBuzzer.FizzBuzzer(x)).ToList();

CollectionAssert.AreEqual(expected, actual);
}

[TestMethod]
public void From1To100_ToShowHowToGet100()
{
const int expected = 100;
var actual = Enumerable.Range(1, 100).Select(x => fizzBuzzer.FizzBuzzer(x)).ToList();

Assert.AreEqual(expected, actual.Count);
}
}

public class FizzBuzz
{
private delegate string Xzzer(int value);
private readonly IList<Xzzer> _functions = new List<Xzzer>();

public FizzBuzz()
{
_functions.Add(x => x % 3 == 0 ? "Fizz" : "");
_functions.Add(x => x % 5 == 0 ? "Buzz" : "");
}

public string FizzBuzzer(int value)
{
var result = _functions.Aggregate(String.Empty, (current, function) => current + function.Invoke(value));
return String.IsNullOrEmpty(result) ? value.ToString(CultureInfo.InvariantCulture) : result;
}
}
}


### Good old C ways

using System;
int max = 100;
for(int i=0;
++i<=max;
Console.WriteLine("{0}{1}{2}", i%3==0 ? "Fizz" : "", i%5==0 ? "Buzz" : "", i%3!=0 && i%5!=0  ? i.ToString() : "")
){}


## C++

### minimal conditions

#include <iostream>
#include <chrono>

int main()
{

int fizz = 0, buzz = 0, fizzbuzz = 0;

bool isFizz = false;

auto startTime = std::chrono::high_resolution_clock::now();

for (unsigned int i = 1; i <= 4000000000; i++) {
isFizz = false;

if (i % 3 == 0) {
isFizz = true;
fizz++;
}

if (i % 5 == 0) {
if (isFizz) {
fizz--;
fizzbuzz++;
}
else {
buzz++;
}
}

}

auto endTime = std::chrono::high_resolution_clock::now();
auto totalTime = endTime - startTime;

printf("\t fizz : %d, buzz: %d, fizzbuzz: %d, duration %lld milliseconds\n", fizz, buzz, fizzbuzz, (totalTime / std::chrono::milliseconds(1)));

return 0;
}


### with modulo

#include <iostream>

using namespace std;
int main ()
{
for (int i = 1; i <= 100; i++)
{
if ((i % 15) == 0)
cout << "FizzBuzz\n";
else if ((i % 3) == 0)
cout << "Fizz\n";
else if ((i % 5) == 0)
cout << "Buzz\n";
else
cout << i << "\n";
}
return 0;
}


### without modulo 15

#include <iostream>
using namespace std;

int main()
{
for (int i = 0; i <= 100; ++i)
{
bool fizz = (i % 3) == 0;
bool buzz = (i % 5) == 0;
if (fizz)
cout << "Fizz";
if (buzz)
cout << "Buzz";
if (!fizz && !buzz)
cout << i;
cout << "\n";
}
return 0;
}


### without modulo

Modulo can be expensive on some architectures.

#include <iostream>

int main()
{
int i, f = 2, b = 4;

for ( i = 1 ; i <= 100 ; ++i, --f, --b )
{
if ( f && b ) { std::cout << i;             }
if ( !f )     { std::cout << "Fizz"; f = 3; }
if ( !b )     { std::cout << "Buzz"; b = 5; }
std::cout << std::endl;
}

return 0;
}


### using std::transform

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


## Cherrycake

# Route with custom number of iterations
cached get ~/:n {

# Get the Number of Iterations from the URL Params
int n = req.params.n || 100

# Loop through each iteration
for (i in range(n)) {

if (i % 2 == 0 && i % 3 == 0) { res.write("FizzBuzz\n") continue }
if (i % 2 == 0) { res.write("Fizz\n"); continue; }
if (i % 3 == 0) { res.write("Buzz\n"); continue; }
res.write(i + "\n");

}

# Close the connection
res.end();

}

## Clay

main() {
for(i in range(1,100)) {
if(i % 3 == 0 and i % 5 == 0) println("fizzbuzz");
else if(i % 3 == 0) println("fizz");
else if(i % 5 == 0) println("buzz");
else print(i);
}
}


## Clipper

Also compiles with Harbour (Harbour 3.2.0dev (r1405201749))

PROCEDURE Main()

LOCAL n
LOCAL cFB

FOR n := 1 TO 100
cFB := ""
AEval( { { 3, "Fizz" }, { 5, "Buzz" } }, {|x| cFB += iif( ( n % x[ 1 ] ) == 0, x[ 2 ], "" ) } )
?? iif( cFB == "", LTrim( Str( n ) ), cFB ) + iif( n == 100, ".", ", " )
NEXT

RETURN


The advantage of this approach is that it is trivial to add another factor:

AEval( {{3,"Fizz"},{5,"Buzz"},{9,"Jazz"}}, {|x| cFB += Iif((n % x[1])==0, x[2], "")})

## CLIPS

(deffacts count
(count-to 100)
)

(defrule print-numbers
(count-to ?max)
=>
(loop-for-count (?num ?max) do
(if
(= (mod ?num 3) 0)
then
(printout t "Fizz")
)
(if
(= (mod ?num 5) 0)
then
(printout t "Buzz")
)
(if
(and (> (mod ?num 3) 0) (> (mod ?num 5) 0))
then
(printout t ?num)
)
(priint depth, unsigned int i> struct NUM_DIGITS_CORE : NUM_DIGITS_COREntout t crlf)
)
)

## Clojure

(doseq [x (range 1 101)] (println x (str (when (zero? (mod x 3)) "fizz") (when (zero? (mod x 5)) "buzz"))))

(defn fizzbuzz [start finish]
(map (fn [n]
(cond
(zero? (mod n 15)) "FizzBuzz"
(zero? (mod n 3)) "Fizz"
(zero? (mod n 5)) "Buzz"
:else n))
(range start finish)))
(fizzbuzz 1 100)

(map (fn [x] (cond (zero? (mod x 15)) "FizzBuzz"
(zero? (mod x 5)) "Buzz"
(zero? (mod x 3)) "Fizz"
:else x))
(range 1 101))

(map #(let [s (str (if (zero? (mod % 3)) "Fizz") (if (zero? (mod % 5)) "Buzz"))] (if (empty? s) % s)) (range 1 101))

(def fizzbuzz (map
#(cond (zero? (mod % 15)) "FizzBuzz"
(zero? (mod % 5)) "Buzz"
(zero? (mod % 3)) "Fizz"
:else %)
(iterate inc 1)))

(defn fizz-buzz
([] (fizz-buzz (range 1 101)))
([lst]
(letfn [(fizz? [n] (zero? (mod n 3)))
(buzz? [n] (zero? (mod n 5)))]
(let [f     "Fizz"
b     "Buzz"
items (map (fn [n]
(cond (and (fizz? n) (buzz? n)) (str f b)
(fizz? n) f
(buzz? n) b
:else n))
lst)] items))))

(map (fn [n]
(if-let [fb (seq (concat (when (zero? (mod n 3)) "Fizz")
(when (zero? (mod n 5)) "Buzz")))]
(apply str fb)
n))
(range 1 101))

(take 100 (map #(let [s (str %2 %3) ] (if (seq s) s (inc %)) )
(range)
(cycle [ "" "" "Fizz" ])
(cycle [ "" "" "" "" "Buzz" ])))

(map #(nth (conj (cycle [% % "Fizz" % "Buzz" "Fizz" % % "Fizz" "Buzz" % "Fizz" % % "FizzBuzz"]) %) %) (range 1 101))

(let [n nil fizz (cycle [n n "fizz"]) buzz (cycle [n n n n "buzz"]) nums (iterate inc 1)]
(take 20 (map #(if (or %1 %2) (str %1 %2) %3) fizz buzz nums)))

(take 100
(map #(if (pos? (compare %1 %2)) %1 %2)
(map str (drop 1 (range)))
(map str (cycle ["" "" "Fizz"]) (cycle ["" "" "" "" "Buzz"]))))

;;Using clojure maps
(defn fizzbuzz
[n]
(let [rule {3 "Fizz"
5 "Buzz"}
divs (->> rule
(map first)
sort
(filter (comp (partial = 0)
(partial rem n))))]
(if (empty? divs)
(str n)
(->> divs
(map rule)
(apply str)))))

(defn allfizzbuzz
[max]
(map fizzbuzz (range 1 (inc max))))

(take 100
(map #(str %1 %2 (if-not (or %1 %2) %3))
(cycle [nil nil "Fizz"])
(cycle [nil nil nil nil "Buzz"])
(rest (range))
))

(take 100
(
(fn [& fbspec]
(let [
fbseq #(->> (repeat nil) (cons %2) (take %1) reverse cycle)
strfn #(apply str (if (every? nil? (rest %&)) (first %&)) (rest %&))
]
(->>
fbspec
(partition 2)
(map #(apply fbseq %))
(apply map strfn (rest (range)))
) ;;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) Solution 8: (defun range (min max) (loop :for x :from min :to max :collect x)) (defun fizzbuzz () (map 'nil #'(lambda (n) (princ (cond ((zerop (mod n 15)) "FizzBuzz!") ((zerop (mod n 5)) "Buzz!") ((zerop (mod n 3)) "Fizz!") (t n)) (terpri))) (range 1 100))) First 16 lines of output: 1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16  ### Alternate solution I use Allegro CL 10.1 ;; Project : FizzBuzz (defun fizzbuzz (&optional n) (let ((n (or n 1))) (if (> n 100) nil (progn (let ((mult-3 (is-mult-p n 3)) (mult-5 (is-mult-p n 5))) (if mult-3 (princ "Fizz")) (if mult-5 (princ "Buzz")) (if (not (or mult-3 mult-5)) (princ n)) (princ #\linefeed) (fizzbuzz (+ n 1))))))) (defun is-mult-p (n multiple) (= (rem n multiple) 0)) (fizzbuzz 1) Output: 1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17 Fizz 19 Buzz  ## Coq Require Import Coq.Lists.List. (* https://coq.inria.fr/library/Coq.Lists.List.html *) Require Import Coq.Strings.String. (* https://coq.inria.fr/library/Coq.Strings.String.html *) Require Import Coq.Strings.Ascii. (* https://coq.inria.fr/library/Coq.Strings.Ascii.html *) Require Import Coq.Init.Nat. (* https://coq.inria.fr/library/Coq.Init.Nat.html *) (** Definition of [string_of_nat] to convert natural numbers to strings. *) Definition ascii_of_digit (n : nat) : ascii := ascii_of_nat (n + 48). Definition is_digit (n : nat) : bool := andb (0 <=? n) (n <=? 9). Fixpoint rec_string_of_nat (counter : nat) (n : nat) (acc : string) : string := match counter with | 0 => EmptyString | S c => if (is_digit n) then String (ascii_of_digit n) acc else rec_string_of_nat c (n / 10) (String (ascii_of_digit (n mod 10)) acc) end. (** The counter is only used to ensure termination. *) Definition string_of_nat (n : nat) : string := rec_string_of_nat n n EmptyString. (** The FizzBuzz problem. *) Definition fizz : string := "Fizz". Definition buzz : string := "Buzz". Definition new_line : string := String (ascii_of_nat 10) EmptyString. Definition is_divisible_by (n : nat) (k : nat) : bool := (n mod k) =? 0. Definition get_term (n : nat) : string := if (is_divisible_by n 15) then fizz ++ buzz else if (is_divisible_by n 3) then fizz else if (is_divisible_by n 5) then buzz else (string_of_nat n). Definition range (a : nat) (b : nat) : list nat := seq a b. Definition get_terms (n : nat) : list string := map get_term (range 1 n). Definition fizz_buzz : string := concat new_line (get_terms 100). (** This shows the string. *) Eval compute in fizz_buzz. Output  = "1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17 Fizz 19 Buzz Fizz 22 23 Fizz Buzz 26 Fizz 28 29 FizzBuzz 31 32 Fizz 34 Buzz Fizz 37 38 Fizz Buzz 41 Fizz 43 44 FizzBuzz 46 47 Fizz 49 Buzz Fizz 52 53 Fizz Buzz 56 Fizz 58 59 FizzBuzz 61 62 Fizz 64 Buzz Fizz 67 68 Fizz Buzz 71 Fizz 73 74 FizzBuzz 76 77 Fizz 79 Buzz Fizz 82 83 Fizz Buzz 86 Fizz 88 89 FizzBuzz 91 92 Fizz 94 Buzz Fizz 97 98 Fizz Buzz"%string : string  ## Cowgol ### Straightforward version include "cowgol.coh"; var i: uint8 := 1; while i <= 100 loop if i % 15 == 0 then print("FizzBuzz"); elseif i % 5 == 0 then print("Buzz"); elseif i % 3 == 0 then print("Fizz"); else print_i8(i); end if; print_nl(); i := i + 1; end loop; ### No division When targeting small systems, it is generally a good idea not to use division if you don't have to. Most of the processors Cowgol targets do not have hardware division, requiring the use of slow and bulky software division routines. This is not helped by the fact that these processors are not fast to begin with, and memory is usually scarce. Avoiding division requires not only that % be avoided, but also print_i8 cannot be used, as printing integers in decimal format is also done by division. Instead, this code keeps separate 'fizz' and 'buzz' counters around, as well as keeping the number ready in ASCII format for printing. Nevertheless, the following code compiles to a 252-byte 8080 executable, whereas the naive version above compiles to a 755-byte executable. (Compare to the 8080 assembly program above, which assembles to a 98-byte executable.) include "cowgol.coh"; var i: uint8 := 100; var fizz: uint8 := 3; var buzz: uint8 := 5; var dh: uint8 := '0'; var dl: uint8 := '1'; var prnum: uint8; while i != 0 loop fizz := fizz - 1; buzz := buzz - 1; prnum := 1; if fizz == 0 then print("Fizz"); fizz := 3; prnum := 0; end if; if buzz == 0 then print("Buzz"); buzz := 5; prnum := 0; end if; if prnum != 0 then if dh != '0' then print_char(dh); end if; print_char(dl); end if; dl := dl + 1; if dl == ('9' + 1) then dl := '0'; dh := dh + 1; end if; print_nl(); i := i - 1; end loop; ## Craft Basic ## 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;

0[$100<][1+c;!]# {loop from 1 to 100} ## DWScript var i : Integer; for i := 1 to 100 do begin if i mod 15 = 0 then PrintLn('FizzBuzz') else if i mod 3 = 0 then PrintLn('Fizz') else if i mod 5 = 0 then PrintLn('Buzz') else PrintLn(i); end; ## Dyalect var n = 1 while n < 20 { if n % 15 == 0 { print("fizzbuzz") } else if n % 3 == 0 { print("fizz") } else if n % 5 == 0 { print("buzz") } else { print(n) } n = n + 1 } Output: 1 2 fizz 4 buzz fizz 7 8 fizz buzz 11 fizz 13 14 fizzbuzz 16 17 fizz 19 ## Déjà Vu for i range 1 100: if = 0 % i 15: "FizzBuzz" elseif = 0 % i 3: "Fizz" elseif = 0 % i 5: "Buzz" else: i !print ## E for i in 1..100 { println(switch ([i % 3, i % 5]) { match [==0, ==0] { "FizzBuzz" } match [==0, _ ] { "Fizz" } match [_, ==0] { "Buzz" } match _ { i } }) } ## EasyLang for i = 1 to 100 if i mod 15 = 0 print "FizzBuzz" elif i mod 5 = 0 print "Buzz" elif i mod 3 = 0 print "Fizz" else print i . . ## ECL DataRec := RECORD STRING s; END; DataRec MakeDataRec(UNSIGNED c) := TRANSFORM SELF.s := MAP ( c % 15 = 0 => 'FizzBuzz', c % 3 = 0 => 'Fizz', c % 5 = 0 => 'Buzz', (STRING)c ); END; d := DATASET(100,MakeDataRec(COUNTER)); OUTPUT(d); ## Ecstasy module FizzBuzz { void run() { @Inject Console console; for (Int x : 1..100) { console.print(switch (x % 3, x % 5) { case (0, 0): "FizzBuzz"; case (0, _): "Fizz"; case (_, 0): "Buzz"; case (_, _): x.toString(); }); } } } ## Ed H a 100 . # iota.ed g/[^0-9]{1,}/s///g ,p # decimal -> unary g/^0+([0-9])/s//\1/ g/^9([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiiii/ g/^8([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiii/ g/^7([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiii/ g/^6([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiii/ g/^5([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiii/ g/^4([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiii/ g/^3([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iii/ g/^2([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2ii/ g/^1([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2i/ g/^0([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2/ g/^9([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiiii/ g/^8([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiii/ g/^7([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiii/ g/^6([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiii/ g/^5([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiii/ g/^4([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiii/ g/^3([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iii/ g/^2([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2ii/ g/^1([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2i/ g/^0([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2/ g/^9([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiiii/ g/^8([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiii/ g/^7([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiii/ g/^6([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiii/ g/^5([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiii/ g/^4([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiii/ g/^3([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iii/ g/^2([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2ii/ g/^1([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2i/ g/^0([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2/ g/^9([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiiii/ g/^8([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiii/ g/^7([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiii/ g/^6([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiii/ g/^5([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiii/ g/^4([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiii/ g/^3([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iii/ g/^2([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2ii/ g/^1([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2i/ g/^0([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2/ g/^9([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiiii/ g/^8([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiii/ g/^7([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiii/ g/^6([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiii/ g/^5([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiii/ g/^4([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiii/ g/^3([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iii/ g/^2([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2ii/ g/^1([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2i/ g/^0([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2/ # iota logic s/\B/\ /g a . y d g/i/x\ s/.*/&i/\ -1d\ y # fizzbuzz g/^(i{15})+$/s//FizzBuzz/
g/^(i{5})+$/s//Buzz/ g/^(i{3})+$/s//Fizz/
# unary -> decimal (for 0-10000 range)
g/i{9000}(i{0,999})/s//9\1/
g/i{8000}(i{0,999})/s//8\1/
g/i{7000}(i{0,999})/s//7\1/
g/i{6000}(i{0,999})/s//6\1/
g/i{5000}(i{0,999})/s//5\1/
g/i{4000}(i{0,999})/s//4\1/
g/i{3000}(i{0,999})/s//3\1/
g/i{2000}(i{0,999})/s//2\1/
g/i{1000}(i{0,999})/s//1\1/
v/^[0-9]i*$/s/.*/0&/ g/i{900}(i{0,99})/s//9\1/ g/i{800}(i{0,99})/s//8\1/ g/i{700}(i{0,99})/s//7\1/ g/i{600}(i{0,99})/s//6\1/ g/i{500}(i{0,99})/s//5\1/ g/i{400}(i{0,99})/s//4\1/ g/i{300}(i{0,99})/s//3\1/ g/i{200}(i{0,99})/s//2\1/ g/i{100}(i{0,99})/s//1\1/ v/^[0-9]{2}i*$/s/^([0-9])(i*)$/\10\2/ g/i{90}(i{0,9})/s//9\1/ g/i{80}(i{0,9})/s//8\1/ g/i{70}(i{0,9})/s//7\1/ g/i{60}(i{0,9})/s//6\1/ g/i{50}(i{0,9})/s//5\1/ g/i{40}(i{0,9})/s//4\1/ g/i{30}(i{0,9})/s//3\1/ g/i{20}(i{0,9})/s//2\1/ g/i{10}(i{0,9})/s//1\1/ v/^[0-9]{3}i*$/s/^([0-9]{2})(i*)$/\10\2/ g/i{9}/s//9/ g/i{8}/s//8/ g/i{7}/s//7/ g/i{6}/s//6/ g/i{5}/s//5/ g/i{4}/s//4/ g/i{3}/s//3/ g/i{2}/s//2/ g/i{1}/s//1/ v/^[0-9]{4}i*$/s/^([0-9]{3})(i*)$/\10\2/ g/^0+([0-9])/s//\1/ g/0F1zz/s//Fizz/ g/0Buzz/s//Buzz/ ,p Q ## Eero #import <Foundation/Foundation.h> int main() autoreleasepool for int i in 1 .. 100 s := '' if i % 3 == 0 s << 'Fizz' if i % 5 == 0 s << 'Buzz' Log( '(%d) %@', i, s ) return 0 ## Egel import "prelude.eg" import "io.ego" using System using IO def fizzbuzz = [ 100 -> print "100\n" | N -> if and ((N%3) == 0) ((N%5) == 0) then let _ = print "fizz buzz, " in fizzbuzz (N+1) else if (N%3) == 0 then let _ = print "fizz, " in fizzbuzz (N+1) else if (N%5) == 0 then let _ = print "buzz, " in fizzbuzz (N+1) else let _ = print N ", " in fizzbuzz (N+1) ] def main = fizzbuzz 1 ## Eiffel class APPLICATION create make feature make do fizzbuzz end fizzbuzz --Numbers up to 100, prints "Fizz" instead of multiples of 3, and "Buzz" for multiples of 5. --For multiples of both 3 and 5 prints "FizzBuzz". do across 1 |..| 100 as c loop if c.item \\ 15 = 0 then io.put_string ("FIZZBUZZ%N") elseif c.item \\ 3 = 0 then io.put_string ("FIZZ%N") elseif c.item \\ 5 = 0 then io.put_string ("BUZZ%N") else io.put_string (c.item.out + "%N") end end end end ## Ela open list prt x | x % 15 == 0 = "FizzBuzz" | x % 3 == 0 = "Fizz" | x % 5 == 0 = "Buzz" | else = x [1..100] |> map prt ## Elixir ### Standard approaches used case Enum.each 1..100, fn x -> IO.puts(case { rem(x,3) == 0, rem(x,5) == 0 } do { true, true } -> "FizzBuzz" { true, false } -> "Fizz" { false, true } -> "Buzz" { false, false } -> x end) end Alternate approach using pipes and cond: #!/usr/bin/env elixir 1..100 |> Enum.map(fn i -> cond do rem(i,3*5) == 0 -> "FizzBuzz" rem(i,3) == 0 -> "Fizz" rem(i,5) == 0 -> "Buzz" true -> i end end) |> Enum.each(fn i -> IO.puts i end) used Stream.cycle version: defmodule RC do def fizzbuzz(limit \\ 100) do fizz = Stream.cycle(["", "", "Fizz"]) buzz = Stream.cycle(["", "", "", "", "Buzz"]) Stream.zip(fizz, buzz) |> Enum.take(limit) |> Enum.with_index |> Enum.each(fn {{f,b},i} -> IO.puts if f<>b=="", do: i+1, else: f<>b end) end end RC.fizzbuzz Yet another approach: defmodule FizzBuzz do def fizzbuzz(n) when rem(n, 15) == 0, do: "FizzBuzz" def fizzbuzz(n) when rem(n, 5) == 0, do: "Buzz" def fizzbuzz(n) when rem(n, 3) == 0, do: "Fizz" def fizzbuzz(n), do: n end Enum.each(1..100, &IO.puts FizzBuzz.fizzbuzz &1) used anonymous function f = fn(n) when rem(n,15)==0 -> "FizzBuzz" (n) when rem(n,5)==0 -> "Fizz" (n) when rem(n,3)==0 -> "Buzz" (n) -> n end for n <- 1..100, do: IO.puts f.(n) Enum.at version: Returns nil if index is out of bounds. Enum.each(1..100, fn i -> str = "#{Enum.at([:Fizz], rem(i,3))}#{Enum.at([:Buzz], rem(i,5))}" IO.puts if str=="", do: i, else: str end) ### A macro too far The Stream.cycle version above, but as an overpowered FizzBuzz DSL. defmodule BadFizz do # Hand-rolls a bunch of AST before injecting the resulting FizzBuzz code. defmacrop automate_fizz(fizzers, n) do # To begin, we need to process fizzers to produce the various components # we're using in the final assembly. As told by Mickens telling as Antonio # Banderas, first you must specify a mapping function: build_parts = (fn {fz, n} -> ast_ref = {fz |> String.downcase |> String.to_atom, [], __MODULE__} clist = List.duplicate("", n - 1) ++ [fz] cycle = quote do: unquote(ast_ref) = unquote(clist) |> Stream.cycle {ast_ref, cycle} end) # ...and then a reducing function: collate = (fn ({ast_ref, cycle}, {ast_refs, cycles}) -> {[ast_ref | ast_refs], [cycle | cycles]} end) # ...and then, my love, when you are done your computation is ready to run # across thousands of fizzbuzz: {ast_refs, cycles} = fizzers |> Code.eval_quoted([], __ENV__) |> elem(0) # Gotta unwrap this mystery code~ |> Enum.sort(fn ({_, ap}, {_, bp}) -> ap < bp end) # Sort so that Fizz, 3 < Buzz, 5 |> Enum.map(build_parts) |> Enum.reduce({[], []}, collate) # Setup the anonymous functions used by Enum.reduce to build our AST components. # This was previously handled by List.foldl, but ejected because reduce/2's # default behavior reduces repetition. # # ...I was tempted to move these into a macro themselves, and thought better of it. build_zip = fn (varname, ast) -> quote do: Stream.zip(unquote(varname), unquote(ast)) end build_tuple = fn (varname, ast) -> {:{}, [], [varname, ast]} end build_concat = fn (varname, ast) -> {:<>, [context: __MODULE__, import: Kernel], # Hygiene values may change; accurate to Elixir 1.1.1 [varname, ast]} end # Toss cycles into a block by hand, then smash ast_refs into # a few different computations on the cycle block results. cycles = {:__block__, [], cycles} tuple = ast_refs |> Enum.reduce(build_tuple) zip = ast_refs |> Enum.reduce(build_zip) concat = ast_refs |> Enum.reduce(build_concat) # Finally-- Now that all our components are assembled, we can put # together the fizzbuzz stream pipeline. After quote ends, this # block is injected into the caller's context. quote do unquote(cycles) unquote(zip) |> Stream.with_index |> Enum.take(unquote(n)) |> Enum.each(fn {unquote(tuple), i} -> ccats = unquote(concat) IO.puts if ccats == "", do: i + 1, else: ccats end) end end @doc ~S""" A fizzing, and possibly buzzing function. Somehow, you feel like you've seen this before. An old friend, suddenly appearing in Kafkaesque nightmare... ...or worse, during a whiteboard interview. """ def fizz(n \\ 100) when is_number(n) do # In reward for all that effort above, we now have the latest in # programmer productivity: # # A DSL for building arbitrary fizzing, buzzing, bazzing, and more! [{"Fizz", 3}, {"Buzz", 5}#, #{"Bar", 7}, #{"Foo", 243}, # -> Always printed last (largest number) #{"Qux", 34} ] |> automate_fizz(n) end end BadFizz.fizz(100) # => Prints to stdout ## Elm A bit too simple: import Html exposing (text) import List exposing (map) main = [1..100] |> map getWordForNum |> text getWordForNum num = if num % 15 == 0 then "FizzBuzz" else if num % 3 == 0 then "Fizz" else if num % 5 == 0 then "Buzz" else String.fromInt num A bit too clever: import Html exposing (text) import List exposing (map) import String exposing (join, fromInt) main : Html.Html main = [1..100] |> map fizzbuzz |> join " " |> text fizzbuzz : Int -> String fizzbuzz num = let fizz = if num % 3 == 0 then "Fizz" else "" buzz = if num % 5 == 0 then "Buzz" else "" in if fizz == buzz then fromInt num else fizz ++ buzz ## Emacs Lisp (defun fizzbuzz (n) (cond ((and (zerop (% n 5)) (zerop (% n 3))) "FizzBuzz") ((zerop (% n 3)) "Fizz") ((zerop (% n 5)) "Buzz") (t n))) ;; loop & print from 0 to 100 (dotimes (i 101) (message "%s" (fizzbuzz i))) ## EMal logic isFizz, isBuzz for int count = 1; count <= 100; ++count isFizz = count % 3 == 0 isBuzz = count % 5 == 0 if isFizz and isBuzz do writeLine("Fizz Buzz") else if isFizz do writeLine("Fizz") else if isBuzz do writeLine("Buzz") else do writeLine(count) end end ## Emojicode ### Simple 1 🏁🍇 🔂 i 🆕⏩ 1 101 1 ❗ 🍇 ↪️ i 🚮 15 🙌 0 🍇 😀 🔤FizzBuzz🔤 ❗ 🍉 🙅↪️ i 🚮 3 🙌 0 🍇 😀 🔤Fizz🔤 ❗ 🍉 🙅↪️ i 🚮 5 🙌 0 🍇 😀 🔤Buzz🔤 ❗ 🍉🙅🍇 😀 🔤🧲i🧲🔤 ❗ 🍉 🍉 🍉 ### Simple 2 🏁🍇 🔂 i 🆕⏩ 1 101 1 ❗ 🍇 🔤🔤 ➡️ 🖍🆕 msg ↪️ i 🚮 3 🙌 0 🍇 🔤Fizz🔤 ➡️ 🖍 msg 🍉 ↪️ i 🚮 5 🙌 0 🍇 🔤🧲msg🧲Buzz🔤 ➡️ 🖍 msg 🍉 ↪️ msg 🙌 🔤🔤 🍇 😀 🔤🧲i🧲🔤 ❗ 🍉🙅🍇 😀 🔤🧲msg🧲🔤 ❗ 🍉 🍉 🍉 ## Enguage FizzBuzz This source code is supposed to look like plain old English but is, in fact, executable. When used in an Android app, it gives the user direct access to computational abilities of your phone. It is taken from the dictionary entry for fizzbuzz This shows the interpretation of two utterances, the latter of which are called recursively. Enguage is not very efficient, but that's not its goal! NB. Any line beginning with a '#' is a comment, like Unix shells, but any comment following the ']' character are unit tests exercising this code. On "what is the fizzbuzz of N": is N divisible by 5 and 3; if so, reply "fizzbuzz"; is N divisible by 5; if so, reply "buzz"; is N divisible by 3; if so, reply "fizz"; reply "N". On "do fizzbuzz between N and LIMIT": what is the fizzbuzz of N; remember this; set next to the evaluation of N + 1; NEXT is equal to LIMIT; if so, what is the fizzbuzz of LIMIT; if not, do fizzbuzz between NEXT and LIMIT. #] what is the fizzbuzz of 1: 1. #] what is the fizzbuzz of 12: fizz. #] what is the fizzbuzz of 25: buzz. #] what is the fizzbuzz of 75: fizzbuzz. #] set limit to 5. #] do fizzbuzz between 1 and LIMIT.  On downloading this repo, if git and make are installed, this unit test can be run with: $ git clone https://github.com/martinwheatman/enguage.git
$cd enguage$ make jar
$export PATH=$PATH:./sbin


## Euphoria

Works with: Euphoria version 4.0.0

This is based on the VBScript example.

include std/utils.e

function fb( atom n )
sequence fb
if remainder( n, 15 ) = 0 then
fb = "FizzBuzz"
elsif remainder( n, 5 ) = 0 then
fb = "Fizz"
elsif remainder( n, 3 ) = 0 then
fb = "Buzz"
else
fb = sprintf( "%d", n )
end if
return fb
end function

function fb2( atom n )
return iif( remainder(n, 15) = 0, "FizzBuzz",
iif( remainder( n, 5 ) = 0, "Fizz",
iif( remainder( n, 3) = 0, "Buzz", sprintf( "%d", n ) ) ) )
end function

for i = 1 to 30 do
printf( 1, "%s ", { fb( i ) } )
end for

puts( 1, "\n" )

for i = 1 to 30 do
printf( 1, "%s ", { fb2( i ) } )
end for

puts( 1, "\n" )

## F#

let fizzbuzz n =
match n%3 = 0, n%5 = 0 with
| true, false -> "fizz"
| false, true -> "buzz"
| true, true  -> "fizzbuzz"
| _ -> string n

let printFizzbuzz() =
[1..100] |> List.iter (fizzbuzz >> printfn "%s")
[1..100]
|> List.map (fun x ->
match x with
| _ when x % 15 = 0 ->"fizzbuzz"
| _ when x % 5 = 0 -> "buzz"
| _ when x % 3 = 0 -> "fizz"
| _ ->  x.ToString())
|> List.iter (fun x -> printfn "%s" x)

Another example using (unnecessary) partial active pattern :D

let (|MultipleOf|_|) divisors number =
if Seq.exists ((%) number >> (<>) 0) divisors
then None
else Some ()

let fizzbuzz = function
| MultipleOf [3; 5] -> "fizzbuzz"
| MultipleOf [3]    -> "fizz"
| MultipleOf [5]    -> "buzz"
| n                 -> string n

{ 1 .. 100 }
|> Seq.iter (fizzbuzz >> printfn "%s")

## Factor

USING: math kernel io math.functions math.parser math.ranges ;
IN: fizzbuzz
: fizz ( n -- str ) 3 divisor? "Fizz" "" ? ;
: buzz ( n -- str ) 5 divisor? "Buzz" "" ? ;
: fizzbuzz ( n -- str ) dup [ fizz ] [ buzz ] bi append [ number>string ] [ nip ] if-empty ;
: main ( -- ) 100 [1,b] [ fizzbuzz print ] each ;
MAIN: main

More flexible variant without divisibility tests.

USING: kernel sequences arrays generalizations fry math math.parser prettyprint ;
IN: fizzbuzz

: zz ( m seq -- v ) dup length 1 <array> V{ } clone 4 -nrot 1 4 -nrot 3 nrot
'[ dup _ <= ]
3 -nrot
'[
"" _ [ _ [ swap execute( str n -- str n ) ] change-nth ] each-index
dup empty? [ drop dup number>string ] [ ] if swapd suffix! swap 1 +
]
while drop ;

: fizz ( str n -- str n ) dup 3 < [ 1 + ] [ drop "Fizz" append 1 ] if ;
: buzz ( str n -- str n ) dup 5 < [ 1 + ] [ drop "Buzz" append 1 ] if ;
: quxx ( str n -- str n ) dup 7 < [ 1 + ] [ drop "Quxx" append 1 ] if ;
: FizzBuzzQuxx ( m -- v ) { fizz buzz quxx } zz ;
: FizzBuzzQuxx-100 ( -- ) 100 FizzBuzzQuxx . ;

MAIN: FizzBuzzQuxx-100

Another approach is leverage Factor's predicate and intersection classes.

USING: io kernel math math.functions math.parser ranges
sequences ;
IN: rosetta-code.fizz-buzz

PREDICATE: fizz < integer 3 divisor? ;
PREDICATE: buzz < integer 5 divisor? ;

INTERSECTION: fizzbuzz fizz buzz ;

GENERIC: fizzbuzz>string ( n -- str )

M: fizz fizzbuzz>string
drop "Fizz" ;

M: buzz fizzbuzz>string
drop "Buzz" ;

M: fizzbuzz fizzbuzz>string
drop "FizzBuzz" ;

M: integer fizzbuzz>string
number>string ;

MAIN: [ 1 100 [a..b] [ fizzbuzz>string print ] each ]

## Falcon

for i in [1:101]
switch i % 15
case 0        : > "FizzBuzz"
case 5,10     : > "Buzz"
case 3,6,9,12 : > "Fizz"
default       : > i
end
end

## Fantom

class FizzBuzz
{
public static Void main ()
{
for (Int i:=1; i <= 100; ++i)
{
if (i % 15 == 0)
echo ("FizzBuzz")
else if (i % 3 == 0)
echo ("Fizz")
else if (i % 5 == 0)
echo ("Buzz")
else
echo (i)
}
}
}

## FBSL

No 'MOD 15' needed.

#APPTYPE CONSOLE

DIM numbers AS STRING
DIM imod5 AS INTEGER
DIM imod3 AS INTEGER

FOR DIM i = 1 TO 100
numbers = ""
imod3 = i MOD 3
imod5 = i MOD 5
IF NOT imod3 THEN numbers = "Fizz"
IF NOT imod5 THEN numbers = numbers & "Buzz"
IF imod3 AND imod5 THEN numbers = i
PRINT numbers, " ";
NEXT

PAUSE
Output:
1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17 Fizz 19 Buzz Fiz
z 22 23 Fizz Buzz 26 Fizz 28 29 FizzBuzz 31 32 Fizz 34 Buzz Fizz 37 38 Fizz Buzz
41 Fizz 43 44 FizzBuzz 46 47 Fizz 49 Buzz Fizz 52 53 Fizz Buzz 56 Fizz 58 59 Fi
zzBuzz 61 62 Fizz 64 Buzz Fizz 67 68 Fizz Buzz 71 Fizz 73 74 FizzBuzz 76 77 Fizz
79 Buzz Fizz 82 83 Fizz Buzz 86 Fizz 88 89 FizzBuzz 91 92 Fizz 94 Buzz Fizz 97
98 Fizz Buzz
Press any key to continue...


## Fe

There is no built-in mod function, but you can add it via the C API.

static fe_Object *mod(fe_Context *ctx, fe_Object *args) {
fe_Number n = fe_tonumber(ctx, fe_nextarg(ctx, &args));
return fe_number(ctx, fmod(n, fe_tonumber(ctx, fe_nextarg(ctx, &args))));
}

Then, you can solve 'FizzBuzz' the traditional way:

(= i 0)
(while (< i 100)
(= i (+ i 1))
(print
(if (is (mod i 15) 0) "FizzBuzz"
(is (mod i  3) 0) "Fizz"
(is (mod i  5) 0) "Buzz"
i)))

Of course, you can solve this without mod:

(= i 0)
(= fizz 0)
(= buzz 0)
(= fizzbuzz 0)

(while (< i 100)
(= i (+ i 1))
(= fizz (+ fizz 1))
(= buzz (+ buzz 1))
(= fizzbuzz (+ fizzbuzz 1))
; check and reset counters
(print
(if (is fizzbuzz 15) (do (= fizzbuzz 0) (= fizz 0) (= buzz 0) "fizzbuzz")
(is fizz 3) (do (= fizz 0) "fizz")
(is buzz 5) (do (= buzz 0) "buzz")
i)))

## Fennel

(for [i 1 100]
(print (if (= (% i 15) 0) :FizzBuzz
(= (% i 3) 0) :Fizz
(= (% i 5) 0) :Buzz
i)))

Use pattern matching and recursive function:

(fn fizz-buzz [from to]
(print (match [(% from 3) (% from 5)]
[0 0] :FizzBuzz
[0 _] :Fizz
[_ 0] :Buzz
_     from))
(when (< from to)
(fizz-buzz (+ from 1) to)))

(fizz-buzz 1 100)

Alternative matching pattern:

Translation of: D
(for [i 1 100]
(print (match (% i 15)
0                     :FizzBuzz
(where (or 3 6 9 12)) :Fizz
(where (or 5 10)      :Buzz
_                      i)))

## FOCAL

FITR is a built-in function that truncates a floating-point number to an integer. Note that FOCAL uses an arithmetic (three-way) IF statement, rather like early Fortran.

01.10 FOR I=1,100; DO 2.0
01.20 QUIT

02.10 SET ZB=I/15 - FITR(I/15)
02.20 IF (ZB) 2.4, 2.3, 2.4
02.30 TYPE "FizzBuzz" !
02.35 RETURN
02.40 SET Z=I/3 - FITR(I/3)
02.50 IF (Z) 2.7, 2.6, 2.7
02.60 TYPE "Fizz" !
02.65 RETURN
02.70 SET B=I/5 - FITR(I/5)
02.80 IF (B) 2.99, 2.9, 2.99
02.90 TYPE "Buzz" !
02.95 RETURN
02.99 TYPE %3, I, !

## Fermat

for i = 1 to 100 do if i|15=0 then !'FizzBuzz ' else if i|5=0 then !'Buzz ' else if i|3=0 then !'Fizz ' else !i;!' ' fi fi fi od
Output:

1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17 Fizz 19 Buzz Fizz 22 23 Fizz Buzz 26 Fizz 28 29 FizzBuzz 31 32 Fizz 34 Buzz Fizz 37 38 Fizz Buzz 41 Fizz 43 44 FizzBuzz 46 47 Fizz 49 Buzz Fizz 52 53 Fizz Buzz 56 Fizz 58 59 FizzBuzz 61 62 Fizz 64 Buzz Fizz 67 68 Fizz Buzz 71 Fizz 73 74 FizzBuzz 76 77 Fizz 79 Buzz Fizz 82 83 Fizz Buzz 86 Fizz 88 89 FizzBuzz 91 92 Fizz 94 Buzz Fizz 97 98 Fizz Buzz

## Forth

### table-driven

: fizz ( n -- ) drop ." Fizz" ;
: buzz ( n -- ) drop ." Buzz" ;
: fb   ( n -- ) drop ." FizzBuzz" ;
: vector create does> ( n -- )
over 15 mod cells + @ execute ;
vector .fizzbuzz
' fb   , ' . ,    ' . ,
' fizz , ' . ,    ' buzz ,
' fizz , ' . ,    ' . ,
' fizz , ' buzz , ' . ,
' fizz , ' . ,    ' . ,

### or the classic approach

: .fizzbuzz ( n -- )
dup 3 mod 0= if s" Fizz" pad  place then
dup 5 mod 0= if s" Buzz" pad +place then

: zz ( n -- )
1+ 1 do i .fizzbuzz cr loop ;
100 zz

### the well factored approach

SYNONYM is a Forth200x word.

SYNONYM NOT INVERT \ Bitwise boolean not

: Fizz?  ( n -- ? )  3 MOD 0=  DUP IF ." Fizz" THEN ;
: Buzz?  ( n -- ? )  5 MOD 0=  DUP IF ." Buzz" THEN ;
: ?print  ( n ? -- )  IF . THEN ;
: FizzBuzz  ( -- )
101 1 DO CR  I  DUP Fizz? OVER Buzz? OR  NOT ?print  LOOP ;

FizzBuzz

### the unrolled approach

: n     ( n -- n+1 )    dup .         1+ ;
: f     ( n -- n+1 )    ." Fizz "     1+ ;
: b     ( n -- n+1 )    ." Buzz "     1+ ;
: fb    ( n -- n+1 )    ." FizzBuzz " 1+ ;
: fb10  ( n -- n+10 )   n n f n b f n n f b ;
: fb15  ( n -- n+15 )   fb10 n f n n fb ;
: fb100 ( n -- n+100 )  fb15 fb15 fb15 fb15 fb15 fb15 fb10 ;
: .fizzbuzz ( -- )      1 fb100 drop ;

## Fortran

In ANSI FORTRAN 77 or later use structured IF-THEN-ELSE (example uses some ISO Fortran 90 features):

program fizzbuzz_if
integer :: i

do i = 1, 100
if     (mod(i,15) == 0) then; print *, 'FizzBuzz'
else if (mod(i,3) == 0) then; print *, 'Fizz'
else if (mod(i,5) == 0) then; print *, 'Buzz'
else;                         print *, i
end if
end do
end program fizzbuzz_if

This example uses If statements to print "Fizz" and "Buzz" next to each other if the number is divisible by 3 and 5 by waiting to use a line break until after the If statements.

program FizzBuzz
implicit none
integer :: i = 1

do i = 1, 100
if (Mod(i,3) /= 0 .and. Mod(i,5) /=0 )write(*,"(I3)",advance='no') i
print *, ""
end do
end program FizzBuzz

In ISO Fortran 90 or later use SELECT-CASE statement:

program fizzbuzz_select
integer :: i

do i = 1, 100
select case (mod(i,15))
case 0;        print *, 'FizzBuzz'
case 3,6,9,12; print *, 'Fizz'
case 5,10;     print *, 'Buzz'
case default;  print *, i
end select
end do
end program fizzbuzz_select

## Frege

gen n word = cycle (take (n - 1) (repeat "") ++ [word])
pattern = zipWith (++) (gen 3 "fizz") (gen 5 "buzz")
fizzbuzz = zipWith combine pattern [1..] where
combine word number = if null word
then show number
else word
show $take 100 fizzbuzz ## Frink for i = 1 to 100 { flag = false if i mod 3 == 0 { flag = true print["Fizz"] } if i mod 5 == 0 { flag = true print["Buzz"] } if flag == false print[i] println[] } ## FutureBasic include "NSLog.incl" long fizz, buzz, i for i = 1 to 100 fizz = (i mod 3 ) buzz = (i mod 5 ) if fizz + buzz == 0 then NSLog(@"FizzBuzz") : continue if fizz == 0 then NSLog(@"Fizz") : continue if buzz == 0 then NSLog(@"Buzz") : continue NSLog(@"%ld",i) next i HandleEvents Output: 1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17 Fizz 19 Buzz Fizz 22 23 Fizz Buzz 26 Fizz 28 29 FizzBuzz 31 32 Fizz 34 Buzz Fizz 37 38 Fizz Buzz 41 Fizz 43 44 FizzBuzz 46 47 Fizz 49 Buzz Fizz 52 53 Fizz Buzz 56 Fizz 58 59 FizzBuzz 61 62 Fizz 64 Buzz Fizz 67 68 Fizz Buzz 71 Fizz 73 74 FizzBuzz 76 77 Fizz 79 Buzz Fizz 82 83 Fizz Buzz 86 Fizz 88 89 FizzBuzz 91 92 Fizz 94 Buzz Fizz 97 98 Fizz Buzz  ## Fōrmulæ Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition. Programs in Fōrmulæ are created/edited online in its website. In this page you can see and run the program(s) related to this task and their results. You can also change either the programs or the parameters they are called with, for experimentation, but remember that these programs were created with the main purpose of showing a clear solution of the task, and they generally lack any kind of validation. Solution ## Gambas Public Sub Main() Dim siCount As Short Dim sText As String For siCount = 1 To 100 sText = "" If siCount Mod 3 = 0 Then sText = "Fizz" If siCount Mod 5 = 0 Then sText = "Buzz" If siCount Mod 15 = 0 Then sText = "FizzBuzz" If sText Then Print sText Else Print siCount Next End Output: 1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17 Fizz 19 Buzz Fizz 22 23 Fizz Buzz 26 Fizz 28 29 FizzBuzz 31 32 Fizz 34 Buzz Fizz 37 38 Fizz Buzz 41 Fizz 43 44 FizzBuzz 46 47 Fizz 49 Buzz Fizz 52 53 Fizz Buzz 56 Fizz 58 59 FizzBuzz 61 62 Fizz 64 Buzz Fizz 67 68 Fizz Buzz 71 Fizz 73 74 FizzBuzz 76 77 Fizz 79 Buzz Fizz 82 83 Fizz Buzz 86 Fizz 88 89 FizzBuzz 91 92 Fizz 94 Buzz Fizz 97 98 Fizz Buzz  ## GAP FizzBuzz := function() local i; for i in [1 .. 100] do if RemInt(i, 15) = 0 then Print("FizzBuzz\n"); elif RemInt(i, 3) = 0 then Print("Fizz\n"); elif RemInt(i, 5) = 0 then Print("Buzz\n"); else Print(i, "\n"); fi; od; end; ## GDScript extends Node func _ready(): for i in range(1, 101): if i % 15 == 0: print("FizzBuzz") elif i % 3 == 0: print("Fizz") elif i % 5 == 0: print("Buzz") else: print(i) get_tree().quit() ## Genyris @prefix u "http://www.genyris.org/lang/utilities#" def fizzbuzz (n) map-left ^((3 = 'fizz') (5 = 'buzz')) lambda (d) cond (equal? 0 (% n d!left)) d!right else '' for n in (range 1 100) define fb (''(.join (fizzbuzz n))) u:format "%a\n" cond (equal? fb '') n else fb ## GFA Basic ' Fizz Buzz ' FOR i%=1 TO 100 IF i% MOD 15=0 PRINT "FizzBuzz" ELSE IF i% MOD 3=0 PRINT "Fizz" ELSE IF i% MOD 5=0 PRINT "Buzz" ELSE PRINT i% ENDIF NEXT i% ## Gleam import gleam/int import gleam/io import gleam/iterator pub fn main() { iterator.range(1, 101) |> iterator.map(to_fizzbuzz) |> iterator.map(io.println) |> iterator.run } fn to_fizzbuzz(n: Int) -> String { case n % 3, n % 5 { 0, 0 -> "FizzBuzz" 0, _ -> "Fizz" _, 0 -> "Buzz" _, _ -> int.to_string(n) } } ## Go ### switch/case approach package main import "fmt" func main() { for i := 1; i <= 100; i++ { switch { case i%15==0: fmt.Println("FizzBuzz") case i%3==0: fmt.Println("Fizz") case i%5==0: fmt.Println("Buzz") default: fmt.Println(i) } } } ### map approach package main import "fmt" func main() { for i := 1; i <= 100; i++ { fmt.Println(map[bool]map[bool]interface{}{ false: {false: i, true: "Fizz"}, true: {false: "Buzz", true: "FizzBuzz"}, }[i%5 == 0][i%3 == 0]) } } ## Golfscript 100,{)6,{.(&},{1$1$%{;}{4*35+6875*25base{90\-}%}if}%\or}%n* ## Golo module FizzBuzz augment java.lang.Integer { function getFizzAndOrBuzz = |this| -> match { when this % 15 == 0 then "FizzBuzz" when this % 3 == 0 then "Fizz" when this % 5 == 0 then "Buzz" otherwise this } } function main = |args| { foreach i in [1..101] { println(i: getFizzAndOrBuzz()) } } ## Gosu for (i in 1..100) { if (i % 3 == 0 && i % 5 == 0) { print("FizzBuzz") continue } if (i % 3 == 0) { print("Fizz") continue } if (i % 5 == 0) { print("Buzz") continue } // default print(i) } One liner version (I added new lines to better readability but when you omit them it's one liner): // note that compiler reports error (I don't know why) but still it's working for (i in 1..100) { print(i % 5 == 0 ? i % 3 == 0 ? "FizzBuzz" : "Buzz" : i % 3 == 0 ? "Fizz" : i) } ## Groovy 1.upto(100) { i -> println "${i % 3 ? '' : 'Fizz'}${i % 5 ? '' : 'Buzz'}" ?: i } ## GW-BASIC ## Hare use fmt; export fn main() void = { for (let i = 1z; i <= 100; i += 1) { fmt::println( if (i % 15 == 0) "FizzBuzz" else if (i % 3 == 0) "Fizz" else if (i % 5 == 0) "Buzz" else i )!; }; }; ## Haskell Variant directly implementing the specification: fizzbuzz :: Int -> String fizzbuzz x | f 15 = "FizzBuzz" | f 3 = "Fizz" | f 5 = "Buzz" | otherwise = show x where f = (0 ==) . rem x main :: IO () main = mapM_ (putStrLn . fizzbuzz) [1 .. 100] fizzbuzz :: Int -> String fizzbuzz n = '\n' : if null (fizz ++ buzz) then show n else fizz ++ buzz where fizz = if mod n 3 == 0 then "Fizz" else "" buzz = if mod n 5 == 0 then "Buzz" else "" main :: IO () main = putStr$ concatMap fizzbuzz [1 .. 100]

Does not perform the mod 15 step, extesible to arbitrary addtional tests, ex: [bar| n mod 7 == 0].

main = mapM_ (putStrLn . fizzbuzz) [1..100]

fizzbuzz n =
show n <|> [fizz| n mod 3 == 0] ++
[buzz| n mod 5 == 0]

-- A simple default choice operator.
-- Defaults if both fizz and buzz fail, concats if any succeed.
infixr 0 <|>
d <|> [] = d
_ <|> x = concat x

fizz = "Fizz"
buzz = "Buzz"

Alternate implementation using lazy infinite lists and avoiding use of "mod":

main = mapM_ putStrLn $take 100$ zipWith show_number_or_fizzbuzz [1..] fizz_buzz_list

show_number_or_fizzbuzz x y = if null y then show x else y

fizz_buzz_list = zipWith (++) (cycle ["","","Fizz"]) (cycle ["","","","","Buzz"])

Or in terms (still without mod or rem) of an applicative ZipList:

import Control.Applicative ( ZipList(ZipList, getZipList) )

fizzBuzz :: [String]
fizzBuzz =
getZipList $go <$>
ZipList (cycle $replicate 2 [] <> ["fizz"]) <*> ZipList (cycle$ replicate 4 [] <> ["buzz"]) <*>
ZipList (show <$> [1 ..]) go :: String -> String -> String -> String go f b n | null f && null b = n | otherwise = f <> b main :: IO () main = mapM_ putStrLn$ take 100 fizzBuzz

or using an applicative test:

import Data.Bool (bool)

fizzBuzz :: [String]
fizzBuzz =
let fb n k = cycle $replicate (pred n) [] <> [k] in zipWith (flip . bool <*> null) (zipWith (<>) (fb 3 "fizz") (fb 5 "buzz")) (show <$> [1 ..])

main :: IO ()
main = mapM_ putStrLn $take 100 fizzBuzz Using heavy artillery (needs the mtl package): import Control.Monad.State import Control.Monad.Trans import Control.Monad.Writer main = putStr$ execWriter $mapM_ (flip execStateT True . fizzbuzz) [1..100] fizzbuzz :: Int -> StateT Bool (Writer String) () fizzbuzz x = do when (x mod 3 == 0)$ tell "Fizz" >> put False
when (x mod 5 == 0) $tell "Buzz" >> put False get >>= (flip when$ tell $show x) tell "\n" Using guards plus where. fizzBuzz :: (Integral a) => a -> String fizzBuzz i | fizz && buzz = "FizzBuzz" | fizz = "Fizz" | buzz = "Buzz" | otherwise = show i where fizz = i mod 3 == 0 buzz = i mod 5 == 0 main = mapM_ (putStrLn . fizzBuzz) [1..100] An elegant solution exploiting monoidal and applicative properties of functions: import Data.Monoid fizzbuzz = max <$> show
<*> "fizz" when divisibleBy 3
<>  "buzz" when divisibleBy 5
<>  "quxx" when divisibleBy 7
where
when m p x = if p x then m else mempty
divisibleBy n x = x mod n == 0

main = mapM_ (putStrLn . fizzbuzz) [1..100]

And pattern matching approach:

fizzbuzz n = case (rem n 3, rem n 5) of
(0, 0) -> "FizzBuzz"
(0, _) -> "Fizz"
(_, 0) -> "Buzz"
(_, _) -> show n

main = mapM_ (putStrLn . fizzbuzz) [1..100]

Generalised solution:

wordthing :: [(Int, String)] -> Int -> String
wordthing lst n =
if matches == [] then
show n
else

## Inform 6

[ Main i;
for (i = 1: i <= 100: i++) {
if (i % 3 == 0)
print "Fizz";
if (i % 5 == 0)
print "Buzz";
if (i % 3 ~= 0 && i % 5 ~= 0)
print i;

print "^";
}
];

## Inform 7

(Does not work in the current version of Inform 7)

Home is a room.

When play begins:
repeat with N running from 1 to 100:
let printed be false;
if the remainder after dividing N by 3 is 0:
say "Fizz";
now printed is true;
if the remainder after dividing N by 5 is 0:
say "Buzz";
now printed is true;
if printed is false, say N;
say ".";
end the story.

(Version which is less "programmy", and more in the natural English style of interactive fiction.)

The space is a room.  An item is a kind of thing.  In the space are 100 items.

To say the name:
let the count be the number of items carried by the player;
say "[if the count is the count to the nearest 15]fizzbuzz.[otherwise if the count is the count to the nearest 3]fizz.[otherwise if the count is the count to the nearest 5]buzz.[otherwise][the count in words].".

To count:
if an item is in the space
begin;
let the next one be a random item in the space; silently try taking the next one;
say "[the name]" in sentence case;
count;
end the story;
end if.

When play begins: count.  Use no scoring.

## Insitux

(function fizzbuzz n
(match (map (rem n) [3 5])
[0 0] "FizzBuzz"
[0 _] "Fizz"
[_ 0] "Buzz"
n))

(loop 100 i
(-> i inc fizzbuzz print))

## Io

Here's one way to do it:

for(a,1,100,
if(a % 15 == 0) then(
"FizzBuzz" println
) elseif(a % 3 == 0) then(
"Fizz" println
) elseif(a % 5 == 0) then(
"Buzz" println
) else (
a println
)
)

And here's a port of the Ruby version, which I personally prefer:

a := 0; b := 0
for(n, 1, 100,
if(a = (n % 3) == 0, "Fizz" print);
if(b = (n % 5) == 0, "Buzz" print);
if(a not and b not, n print);
"\n" print
)

And here is another more idiomatic version:

for (n, 1, 100,
fb := list (
if (n % 3 == 0, "Fizz"),
if (n % 5 == 0, "Buzz")) select (isTrue)

if (fb isEmpty, n, fb join) println
)

## Ioke

(1..100) each(x,
cond(
(x % 15) zero?, "FizzBuzz" println,
(x % 3) zero?, "Fizz" println,
(x % 5) zero?, "Buzz" println
)
)

## Iptscrae

; FizzBuzz in Iptscrae
1 a =
{
"" b =
{ "fizz" b &= } a 3 % 0 == IF
{ "buzz" b &= } a 5 % 0 == IF
{ a ITOA LOGMSG } { b LOGMSG } b STRLEN 0 == IFELSE
a ++
}
{ a 100 <= } WHILE

## 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
(() => {
'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 1.8.5 One basic solution: for i in 1:100 if i % 15 == 0 println("FizzBuzz") elseif i % 3 == 0 println("Fizz") elseif i % 5 == 0 println("Buzz") else println(i) end end Another possible solution: collect(i % 15 == 0 ? "FizzBuzz" : i % 5 == 0 ? "Buzz" : i % 3 == 0 ? "Fizz" : i for i in 1:100) |> println A 3rd possible solution: fb(i::Integer) = "Fizz" ^ (i % 3 == 0) * "Buzz" ^ (i % 5 == 0) * string(i) ^ (i % 3 != 0 && i % 5 != 0) for i in 1:100 println(fb(i)) end A 4th one: println.(map(fb, 1:100)) A fifth (DRY, Don't Repeat Yourself) possible solution: for i in 1:100 msg = "Fizz" ^ (i % 3 == 0) * "Buzz" ^ (i % 5 == 0) println(isempty(msg) ? i : msg) end ## K ### Solution 0 0:\:{:[0=#a:{,/$(:[0=x!3;"Fizz"];:[0=x!5;"Buzz"])}@x;$x;a]}'1_!101 ### Solution 1  fizzbuzz:{:[0=x!15;0:,"FizzBuzz";0=x!3;0:,"Fizz";0=x!5;0:,"Buzz";0:,$x]}
fizzbuzz' 1+!100

### Solution 2

fizzbuzz:{
v:1+!x
i:(&0=)'v!/:3 5 15
r:@[v;i 0;{"Fizz"}]
r:@[r;i 1;{"Buzz"}]
@[r;i 2;{"FizzBuzz"}]}

0:$fizzbuzz 100 ### Solution 3 For kona: {,/$(s;x)@~#s: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

route {
$var(i) = 1; while ($var(i) <= 1000) {
if ($var(i) mod 15 == 0) { xlog("FizzBuzz\n"); } else if ($var(i) mod 5 == 0) {
xlog("Buzz\n");
} else if ($var(i) mod 3 == 0) { xlog("Fizz\n"); } else { xlog("$var(i)\n");
}
$var(i) =$var(i) + 1;
}
}

## Kaya

// fizzbuzz in Kaya
program fizzbuzz;

Void fizzbuzz(Int size) {
for i in [1..size] {
if (i % 15 == 0) {
putStrLn("FizzBuzz");
} else if (i % 5 == 0) {
putStrLn("Buzz");
} else if (i % 3 == 0) {
putStrLn("Fizz");
} else {
putStrLn( string(i) );
}
}
}

Void main() {
fizzbuzz(100);
}

## KL1

:- module main.

main :-
nats(100, Nats),
fizzbuzz(Nats, Output),
display(Output).

nats(Max, Out) :-
nats(Max, 1, Out).
nats(Max, Count, Out) :- Count =< Max |
Out = [Count|NewOut],
NewCount := Count + 1,
nats(Max, NewCount, NewOut).
nats(Max, Count, Out) :- Count > Max |
Out = [].

fizzbuzz([N|Rest], Out) :- N mod 3 =:= 0, N mod 5 =:= 0 |
Out = ['FizzBuzz' | NewOut],
fizzbuzz(Rest, NewOut).
fizzbuzz([], Out) :-
Out = [].
alternatively.
fizzbuzz([N|Rest], Out) :- N mod 3 =:= 0 |
Out = ['Fizz' | NewOut],
fizzbuzz(Rest, NewOut).
fizzbuzz([N|Rest], Out) :- N mod 5 =:= 0 |
Out = ['Buzz' | NewOut],
fizzbuzz(Rest, NewOut).
alternatively.
fizzbuzz([N|Rest], Out) :-
Out = [N | NewOut],
fizzbuzz(Rest, NewOut).

display([Message|Rest]) :-
io:outstream([print(Message), nl]),
display(Rest).
display([]).

## Klong

{:[0=x!15;:FizzBuzz:|0=x!5;:Buzz:|0=x!3;:Fizz;x]}'1+!100

## Kotlin

### Imperative solution

fun fizzBuzz() {
for (number in 1..100) {
println(
when {
number % 15 == 0 -> "FizzBuzz"
number % 3 == 0 -> "Fizz"
number % 5 == 0 -> "Buzz"
else -> number
}
)
}
}

### Functional solution 1

fun fizzBuzz1() {
fun fizzBuzz(x: Int) = if (x % 15 == 0) "FizzBuzz" else x.toString()
fun fizz(x: Any) = if (x is Int && x % 3 == 0) "Buzz" else x
fun buzz(x: Any) = if (x is Int && x.toInt() % 5 == 0) "Fizz" else x

(1..100).map { fizzBuzz(it) }.map { fizz(it) }.map { buzz(it) }.forEach { println(it) }
}

### Functional solution 2

fun fizzBuzz2() {
fun fizz(x: Pair<Int, StringBuilder>) = if(x.first % 3 == 0) x.apply { second.append("Fizz") } else x
fun buzz(x: Pair<Int, StringBuilder>) = if(x.first % 5 == 0) x.apply { second.append("Buzz") } else x
fun none(x: Pair<Int, StringBuilder>) = if(x.second.isBlank()) x.second.apply { append(x.first) } else x.second

(1..100).map { Pair(it, StringBuilder()) }
.map { fizz(it) }
.map { buzz(it) }
.map { none(it) }
.forEach { println(it) }
}

### Short version with mapOf

fun fizzBuzz() {
(1..100).forEach { println(mapOf(0 to it, it % 3 to "Fizz", it % 5 to "Buzz", it % 15 to "FizzBuzz")[0]) }
}

## KQL

range i from 1 to 100 step 1
| project Result =
case(
i % 15 == 0, "FizzBuzz",
i % 3 == 0, "Fizz",
i % 5 == 0, "Buzz",
tostring(i)
)

## KSI

plain
[1 100] for pos : n ~
out = []
n mod 3 == 0 ? out.# = 'Fizz' ;
n mod 5 == 0 ? out.# = 'Buzz' ;
(out or n) #write_ln #
;

## LabVIEW

This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.

## Lambdatalk

1. direct:

{S.map
{lambda {:i}
{if {= {% :i 15} 0}
then fizzbuzz
else {if {= {% :i 3} 0}
then fizz
else {if {= {% :i 5} 0}
then buzz
else :i}}}}
{S.serie 1 100}}
-> 1 2 fizz 4 buzz fizz 7 8 fizz buzz 11 fizz 13 14 fizzbuzz 16 17 fizz 19 buzz fizz 22 23 fizz buzz 26 fizz 28 29 fizzbuzz 31 32 fizz 34 buzz fizz 37 38 fizz buzz 41 fizz 43 44 fizzbuzz 46 47 fizz 49 buzz fizz 52 53 fizz buzz 56 fizz 58 59 fizzbuzz 61 62 fizz 64 buzz fizz 67 68 fizz buzz 71 fizz 73 74 fizzbuzz 76 77 fizz 79 buzz fizz 82 83 fizz buzz 86 fizz 88 89 fizzbuzz 91 92 fizz 94 buzz fizz 97 98 fizz buzz

2. via a function

{def fizzbuzz
{lambda {:i :n}
{if {> :i :n}
then .
else {if {= {% :i 15} 0}
then fizzbuzz
else {if {= {% :i 3} 0}
then fizz
else {if {= {% :i 5} 0}
then buzz
else :i}}} {fizzbuzz {+ :i 1} :n}
}}}
-> fizzbuzz

{fizzbuzz 1 100}
-> same as above.

## Lang

$i = 1 while($i <= 100) {
if($i % 15 == 0) { fn.println(FizzBuzz) }elif($i % 5 == 0) {
fn.println(Buzz)
}elif($i % 3 == 0) { fn.println(Fizz) }else { fn.println($i)
}

$i += 1 } ## langur for i of 100 { writeln switch(0; i rem 15: "FizzBuzz"; i rem 5: "Buzz"; i rem 3: "Fizz"; i) } ## Lasso with i in generateSeries(1, 100) select ((#i % 3 == 0 ? 'Fizz' | '') + (#i % 5 == 0 ? 'Buzz' | '') || #i) ## LaTeX 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} ## LDPL data: i is number n is number procedure: for i from 1 to 101 step 1 do modulo i by 15 in n if n is equal to 0 then display "FizzBuzz" lf continue end if modulo i by 5 in n if n is equal to 0 then display "Buzz" lf continue end if modulo i by 3 in n if n is equal to 0 then display "Fizz" lf continue end if display i lf repeat ## Lean Lean 4: def fizz : String := "Fizz" def buzz : String := "Buzz" def newLine : String := "\n" def isDivisibleBy (n : Nat) (m : Nat) : Bool := match m with | 0 => false | (k + 1) => (n % (k + 1)) = 0 def getTerm (n : Nat) : String := if (isDivisibleBy n 15) then (fizz ++ buzz) else if (isDivisibleBy n 3) then fizz else if (isDivisibleBy n 5) then buzz else toString (n) def range (a : Nat) (b : Nat) : List (Nat) := match b with | 0 => [] | m + 1 => a :: (range (a + 1) m) def getTerms (n : Nat) : List (String) := (range 1 n).map (getTerm) def addNewLine (accum : String) (elem : String) : String := accum ++ elem ++ newLine def fizzBuzz : String := (getTerms 100).foldl (addNewLine) ("") def main : IO Unit := IO.println (fizzBuzz) #eval main ## Liberty BASIC ## 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

### Metatable insertion

Sets any numeric key to its fizzbuzz value so that fizzbuzz[30] is "fizzbuzz"

local mt = {
__newindex = (function (t, k, v)
if type(k) ~= "number" then	rawset(t, k, v)
elseif 0 == (k % 15) then	rawset(t, k, "fizzbuzz")
elseif 0 == (k % 5) then	rawset(t, k, "fizz")
elseif 0 == (k % 3) then	rawset(t, k, "buzz")
else 						rawset(t, k, k) end
return t[k]
end)
}

local fizzbuzz = {}
setmetatable(fizzbuzz, mt)

for i=1,100 do fizzbuzz[i] = i end
for i=1,100 do print(fizzbuzz[i]) end

### Fast Version without Modulo

#!/usr/bin/env luajit
local to=arg[1] or tonumber(arg[1]) or 100
local CF,CB=3,5
local cf,cb=CF,CB
for i=1,to do
cf,cb=cf-1,cb-1
if cf~=0 and cb~=0 then
io.write(i)
else
if cf==0 then
cf=CF
io.write("Fizz")
end
if cb==0 then
cb=CB
io.write("Buzz")
end
end
io.write(", ")
end
Output:
> ./fizzbuzz.lua
1, 2, Fizz, 4, Buzz, Fizz, 7, 8, Fizz, Buzz, 11, Fizz, 13, 14, FizzBuzz, 16, 17, Fizz, 19, Buzz, Fizz, 22, 23, Fizz, Buzz, 26, Fizz, 28, 29, FizzBuzz, 31, 32, Fizz, 34, Buzz, Fizz, 37, 38, Fizz, Buzz, 41, Fizz, 43, 44, FizzBuzz, 46, 47, Fizz, 49, Buzz, Fizz, 52, 53, Fizz, Buzz, 56, Fizz, 58, 59, FizzBuzz, 61, 62, Fizz, 64, Buzz, Fizz, 67, 68, Fizz, Buzz, 71, Fizz, 73, 74, FizzBuzz, 76, 77, Fizz, 79, Buzz, Fizz, 82, 83, Fizz, Buzz, 86, Fizz, 88, 89, FizzBuzz, 91, 92, Fizz, 94, Buzz, Fizz, 97, 98, Fizz, Buzz, %


## Luck

for i in range(1,101) do (
if i%15 == 0 then print("FizzBuzz")
else if i%3 == 0 then print("Fizz")
else if i%5 == 0 then print("Buzz")
else print(i)
)

## M2000 Interpreter

\\ one line, hard to read
For i=1 to 100 {If i mod 3=0 Then {if i mod 5=0 Then Print "FizzBuzz",  Else Print "Fizz",} Else {if i mod 5=0 Then Print "Buzz", else print i, } } : Print

\\ Better code
For i=1 to 100 {
Push str$(i,0)+". "+if$(i mod 3=0->"Fizz","")+if$(i mod 5=0->"Buzz","") If stackitem$()="" then Drop : Continue
Print Letter$} \\ Far Better Code For i=1 to 100 { Printme(if$(i mod 3=0->"Fizz","")+if$(i mod 5=0->"Buzz","")) } Print Sub Printme(a$)
If a$<>"" Then Print a$, else Print i,
End Sub

## M4

define(for',
ifelse($#,0,$0'',
ifelse(eval($2<=$3),1,
pushdef($1',$2)$5'popdef($1')$0($1',eval($2+$4),$3,$4,$5')')')') for(x',1,100,1, ifelse(eval(x%15==0),1,FizzBuzz, ifelse(eval(x%3==0),1,Fizz, ifelse(eval(x%5==0),1,Buzz,x)')') ') ## MACRO-11  .TITLE FIZBUZ .MCALL .TTYOUT,.EXIT FIZBUZ::MOV #1,R2 ; COUNTER MOV #3,R3 ; FIZZ COUNTER MOV #5,R4 ; BUZZ COUNTER NUMBER: CLR R5 CHKFIZ: DEC R3 BNE CHKBUZ MOV #FIZZ,R1 JSR PC,PRSTR MOV #3,R3 INC R5 CHKBUZ: DEC R4 BNE CHKNUM MOV #BUZZ,R1 JSR PC,PRSTR MOV #5,R4 INC R5 CHKNUM: TST R5 BNE NEXNUM MOV R2,R0 JSR PC,PR0 NEXNUM: MOV #NL,R1 JSR PC,PRSTR INC R2 CMP R2,#^D100 BLE NUMBER .EXIT ; STRING DATA FIZZ: .ASCIZ /FIZZ/ BUZZ: .ASCIZ /BUZZ/ NL: .BYTE 15,12,0 .EVEN ; PRINT NUMBER IN R0 AS DECIMAL PR0: MOV R2,-(SP) MOV #4$,R1
1$: MOV #-1,R2 2$:     INC     R2
SUB     #12,R0
BCC     2$ADD #72,R0 MOVB R0,-(R1) MOV R2,R0 BNE 1$
3$: MOVB (R1)+,R0 .TTYOUT BNE 3$
MOV     (SP)+,R2
RTS     PC
.ASCII  /...../
4$: .BYTE 0 ; PRINT STRING IN R1 PRSTR: MOVB (R1)+,R0 .TTYOUT BNE PRSTR RTS PC .END FIZBUZ ## MAD  NORMAL MODE IS INTEGER VECTOR VALUES FIZZ =$4HFIZZ*$VECTOR VALUES BUZZ =$4HBUZZ*$VECTOR VALUES FIBU =$8HFIZZBUZZ*$VECTOR VALUES NUM =$I2*$INTERNAL FUNCTION REM.(A,B) = A-(A/B)*B THROUGH LOOP, FOR I = 1, 1, I .G. 100 WHENEVER REM.(I,15).E.0 PRINT FORMAT FIBU OR WHENEVER REM.(I,5).E.0 PRINT FORMAT BUZZ OR WHENEVER REM.(I,3).E.0 PRINT FORMAT FIZZ OTHERWISE PRINT FORMAT NUM,I LOOP END OF CONDITIONAL END OF PROGRAM ## make 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]

Additional examples using DownValue pattern matching, the first without Mod'ing 15:

f[n_] := f[n, Mod[n, {3, 5}]]
f[_, {0, 0}] := "FizzBuzz"
f[_, {0, _}] := "Fizz"
f[_, {_, 0}] := "Buzz"
f[n_, {_, _}] := n

f /@ Range[100]
f[n_] := f[n, Mod[n, 15]]
f[_, 0] := "FizzBuzz"

f[n_, _] := f[n, Mod[n, {3, 5}]]
f[_, {0, _}] := "Fizz"
f[_, {_, 0}] := "Buzz"
f[n_, {_, _}] := n

f /@ Range[100]

## MATLAB

There are more sophisticated solutions to this task, but in the spirit of "lowest level of comprehension required to illustrate adequacy" this is what one might expect from a novice programmer (with a little variation in how the strings are stored and displayed).

function fizzBuzz()
for i = (1:100)
if mod(i,15) == 0
fprintf('FizzBuzz ')
elseif mod(i,3) == 0
fprintf('Fizz ')
elseif mod(i,5) == 0
fprintf('Buzz ')
else
fprintf('%i ',i))
end
end
fprintf('\n');
end

Here's a more extendible version that uses disp() to print the output:

function out = fizzbuzzS()
nums = [3, 5];
words = {'fizz', 'buzz'};
for (n=1:100)
tempstr = '';
for (i = 1:2)
if mod(n,nums(i))==0
tempstr = [tempstr,  words{i}];
end
end
if length(tempstr) == 0
disp(n);
else
disp(tempstr);
end
end
end

straightforward

x            = string(1:100);
x(3:3:$) = 'Fizz'; x(5:5:$)     = 'Buzz';
x(3*5:3*5:$) = 'FizzBuzz' ## Maxima for n:1 thru 100 do if mod(n, 15) = 0 then (sprint("FizzBuzz"), newline()) elseif mod(n, 3) = 0 then (sprint("Fizz"), newline()) elseif mod(n,5) = 0 then (sprint("Buzz"), newline()) else (sprint(n), newline()); ## MAXScript for i in 1 to 100 do ( case of ( (mod i 15 == 0): (print "FizzBuzz") (mod i 5 == 0): (print "Buzz") (mod i 3 == 0): (print "Fizz") default: (print i) ) ) ## MEL for($i=1; $i<=100;$i++)
{
if($i % 15 == 0) print "FizzBuzz\n"; else if ($i % 3 == 0)
print "Fizz\n";
else if ($i % 5 == 0) print "Buzz\n"; else print ($i + "\n");
}

## Mercury

:- module fizzbuzz.
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.
:- implementation.
:- import_module int, string, bool.

:- func fizz(int) = bool.
fizz(N) = ( if N mod 3 = 0 then yes else no ).

:- func buzz(int) = bool.
buzz(N) = ( if N mod 5 = 0 then yes else no ).

%                N    3?    5?
:- func fizzbuzz(int, bool, bool) = string.
fizzbuzz(_, yes, yes) = "FizzBuzz".
fizzbuzz(_, yes, no)  = "Fizz".
fizzbuzz(_, no,  yes) = "Buzz".
fizzbuzz(N, no,  no)  = from_int(N).

main(!IO) :- main(1, 100, !IO).

:- pred main(int::in, int::in, io::di, io::uo) is det.
main(N, To, !IO) :-
io.write_string(fizzbuzz(N, fizz(N), buzz(N)), !IO),
io.nl(!IO),
( if N < To then
main(N + 1, To, !IO)
else
true
).

## Metafont

for i := 1 upto 100:
message if i mod 15 = 0: "FizzBuzz" &
elseif i mod 3 = 0: "Fizz" &
elseif i mod 5 = 0: "Buzz" &
else: decimal i & fi "";
endfor
end

## Microsoft Small Basic

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

## 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
#### END PRINT FIZZBUZZ ####

loop_not_fb:
div $a2,$a1,3 #divide $a1 (our counter) by 3 and store remainder in HI mfhi$a2 #retrieve remainder (result of MOD)
bnez $a2, loop_not_f #jump past the fizz print logic if NOT MOD 3 #### PRINT FIZZ #### li$v0,4
la $a0,fizz syscall j loop #### END PRINT FIZZ #### loop_not_f: div$a2,$a1,5 mfhi$a2
bnez $a2,loop_not_b #### PRINT BUZZ #### li$v0,4
la $a0,buzz syscall j loop #### END PRINT BUZZ #### loop_not_b: #### PRINT THE INTEGER #### li$v0,1 #set syscall arg to PRINT_INTEGER
move $a0,$a1 #set PRINT_INTEGER arg to contents of $a1 syscall #call PRINT_INTEGER ### PRINT THE NEWLINE CHAR ### li$v0,4 #set syscall arg to PRINT_STRING
la $a0,newline syscall j loop #return to beginning exit: li$v0,10
syscall

## Mirah

1.upto(100) do |n|
print "Fizz" if a = ((n % 3) == 0)
print "Buzz" if b = ((n % 5) == 0)
print n unless (a || b)
print "\n"
end

A little more straight forward:

1.upto(100) do |n|
if (n % 15) == 0
puts "FizzBuzz"
elsif (n % 5) == 0
puts "Buzz"
elsif (n % 3) == 0
puts "Fizz"
else
puts n
end
end

## Miranda

main :: [sys_message]
main = [Stdout (lay (map fizzbuzz [1..100]))]

fizzbuzz :: num->[char]
fizzbuzz n = "FizzBuzz", if n mod 15 = 0
= "Fizz",     if n mod 3  = 0
= "Buzz",     if n mod 5  = 0
= show n,     otherwise

## ML

### Standard ML

First using two helper functions, one for deciding what to output and another for performing recursion with an auxiliary argument j.

local
fun fbstr i =
case (i mod 3 = 0, i mod 5 = 0) of
(true , true ) => "FizzBuzz"
| (true , false) => "Fizz"
| (false, true ) => "Buzz"
| (false, false) => Int.toString i

fun fizzbuzz' (n, j) =
if n = j then () else (print (fbstr j ^ "\n"); fizzbuzz' (n, j+1))
in
fun fizzbuzz n = fizzbuzz' (n, 1)
val _ = fizzbuzz 100
end

Second using the standard-library combinator List.tabulate and a helper function, fb, that calculates and prints the output.

local
fun fb i = let val fizz = i mod 3 = 0 andalso (print "Fizz"; true)
val buzz = i mod 5 = 0 andalso (print "Buzz"; true)
in fizz orelse buzz orelse (print (Int.toString i); true) end
in
fun fizzbuzz n = (List.tabulate (n, fn i => (fb (i+1); print "\n")); ())
val _ = fizzbuzz 100
end

### mLite

local
fun fizzbuzz'
(x mod 15 = 0) = "FizzBuzz"
|	(x mod  5 = 0) = "Buzz"
|	(x mod  3 = 0) = "Fizz"
|	x = ntos x
in
fun fizzbuzz
([], s) = rev s
|	(x :: xs, s) = fizzbuzz (xs, fizzbuzz' x :: s)
|	(x :: xs)    = fizzbuzz (x :: xs, [])
end
;

println  fizzbuzz  iota 100;

## MMIX

t   IS $255 Ja IS$127

LOC Data_Segment
data   GREG   @

fizz   IS @-Data_Segment
BYTE "Fizz",0,0,0,0

buzz   IS @-Data_Segment
BYTE "Buzz",0,0,0,0

nl     IS @-Data_Segment
BYTE #a,0,0,0,0,0,0,0

buffer IS @-Data_Segment

LOC #1000
GREG @

% "usual" print integer subroutine
printnum LOC @
OR   $1,$0,0
SETL $2,buffer+64 ADDU$2,$2,data XOR$3,$3,$3
STBU $3,$2,1
loop   DIV  $1,$1,10
GET  $3,rR ADDU$3,$3,'0' STBU$3,$2,0 SUBU$2,$2,1 PBNZ$1,loop
ADDU t,$2,1 TRAP 0,Fputs,StdOut GO Ja,Ja,0 Main SETL$0,1           % i = 1
1H     SETL $2,0 % fizz not taken CMP$1,$0,100 % i <= 100 BP$1,4F          % if no, go to end
DIV  $1,$0,3
GET  $1,rR %$1 = mod(i,3)
CSZ  $2,$1,1        % $2 = Fizz taken? BNZ$1,2F          % $1 != 0? yes, then skip ADDU t,data,fizz TRAP 0,Fputs,StdOut % print "Fizz" 2H DIV$1,$0,5 GET$1,rR          % $1 = mod(i,5) BNZ$1,3F          % $1 != 0? yes, then skip ADDU t,data,buzz TRAP 0,Fputs,StdOut % print "Buzz" JMP 5F % skip print i 3H BP$2,5F          % skip if Fizz was taken
GO   Ja,printnum    % print i
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;

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;

END Fizzbuzz.

## Modula-3

MODULE Fizzbuzz EXPORTS Main;

IMPORT IO;

BEGIN
FOR i := 1 TO 100 DO
IF i MOD 15 = 0 THEN
IO.Put("FizzBuzz\n");
ELSIF i MOD 5 = 0 THEN
IO.Put("Buzz\n");
ELSIF i MOD 3 = 0 THEN
IO.Put("Fizz\n");
ELSE
IO.PutInt(i);
IO.Put("\n");
END;
END;
END Fizzbuzz.

## Monte

def fizzBuzz(top):
var t := 1
while (t < top):
if ((t % 3 == 0) || (t % 5 == 0)):
if (t % 15 == 0):
traceln($t FizzBuzz) else if (t % 3 == 0): traceln($t  Fizz)
else:
traceln($t Buzz) t += 1 fizzBuzz(100) ## MontiLang &DEFINE LOOP 100& 1 VAR i . FOR LOOP || VAR ln . i 5 % 0 == IF : . ln |Buzz| + VAR ln . ENDIF i 3 % 0 == IF : . ln |Fizz| + VAR ln . ENDIF ln || == IF : . i PRINT . ENDIF ln || != IF : . ln PRINT . ENDIF i 1 + VAR i . ENDFOR ## MoonScript for i = 1,100 print ((a) -> a == "" and i or a) table.concat { i % 3 == 0 and "Fizz" or "" i % 5 == 0 and "Buzz" or ""} ## MUMPS FIZZBUZZ NEW I FOR I=1:1:100 WRITE !,$SELECT(('(I#3)&'(I#5)):"FizzBuzz",'(I#5):"Buzz",'(I#3):"Fizz",1:I)
KILL I
QUIT
fizzbuzz
for i=1:1:100 do  write !
. write:(i#3)&(i#5) i write:'(i#3) "Fizz" write:'(i#5) "Buzz"

## Nanoquery

for i in range(1, 100)
if ((i % 3) = 0) and ((i % 5) = 0)
println "FizzBuzz"
else if i % 3 = 0
println "Fizz"
else if i % 5 = 0
println "Buzz"
else
println i
end
end

## NATURAL

DEFINE DATA
LOCAL
1 #I       (I4)
1 #MODULO  (I4)
1 #DIVISOR (I4)
1 #OUT     (A10)
END-DEFINE
*
FOR #I := 1 TO 100
#DIVISOR := 15
#OUT := 'FizzBuzz'
PERFORM MODULO
*
#DIVISOR := 5
#OUT := 'Buzz'
PERFORM MODULO
*
#DIVISOR := 3
#OUT := 'Fizz'
PERFORM MODULO
*
WRITE #I
END-FOR
*
DEFINE SUBROUTINE MODULO
#MODULO := #I - (#I / #DIVISOR) * #DIVISOR
IF #MODULO = 0
WRITE NOTITLE #OUT
ESCAPE TOP
END-IF
END-SUBROUTINE
*
END

## Neko

var i = 1

while(i < 100) {
if(i % 15 == 0) {
$print("FizzBuzz\n"); } else if(i % 3 == 0) {$print("Fizz\n");
} else if(i % 5 == 0) {
$print("Buzz\n"); } else {$print(i + "\n");
}

i ++= 1
}

## Nemerle

The naive approach:

using System;
using System.Console;

module FizzBuzz
{
FizzBuzz(x : int) : string
{
|x when x % 15 == 0 => "FizzBuzz"
|x when x %  5 == 0 => "Buzz"
|x when x %  3 == 0 => "Fizz"
|_                  => $"$x"
}

Main() : void
{
foreach (i in [1 .. 100])
WriteLine($"$(FizzBuzz(i))")
}
}

A much slicker approach is posted here

## NetRexx

loop j=1 for 100
select
when j//15==0 then say 'FizzBuzz'
when j//5==0  then say 'Buzz'
when j//3==0  then say 'Fizz'
otherwise say j.right(4)
end
end

## Never

func fizz_buzz() -> int
{
var i = 1;

for (i = 1; i <= 100; i = i + 1)
{
/* if (i % 15 == 0) */
if (i % 3 == 0 && i % 5 == 0)
{
prints("Fizz Buzz\n")
}
else if (i % 3 == 0)
{
prints("Fizz\n")
}
else if (i % 5 == 0)
{
prints("Buzz\n")
}
else
{
prints(i + "\n")
}
};

0
}

func main() -> int {
fizz_buzz();

0
}
Output:
prompt$never -f fizzbuzz.nev 2>/dev/null 1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 Fizz Buzz 16 ... 89 Fizz Buzz 91 92 Fizz 94 Buzz Fizz 97 98 Fizz Buzz ## NewLISP (dotimes (i 100) (println (cond ((= 0 (% i 15)) "FizzBuzz") ((= 0 (% i 3)) "Fizz") ((= 0 (% i 5)) "Buzz") ('t i)))) ## NewtonScript for i := 1 to 100 do begin if i mod 15 = 0 then print("FizzBuzz") else if i mod 3 = 0 then print("Fizz") else if i mod 5 = 0 then print("Buzz") else print(i); print("\n") end ## Nickle /* Fizzbuzz in nickle */ void function fizzbuzz(size) { for (int i = 1; i < size; i++) { if (i % 15 == 0) { printf("Fizzbuzz\n"); } else if (i % 5 == 0) { printf("Buzz\n"); } else if (i % 3 == 0) { printf("Fizz\n"); } else { printf("%i\n", i); } } } fizzbuzz(1000); ## Nim Translation of: Python for i in 1..100: if i mod 15 == 0: echo("FizzBuzz") elif i mod 3 == 0: echo("Fizz") elif i mod 5 == 0: echo("Buzz") else: echo(i) ### Without Modulus var messages = @["", "Fizz", "Buzz", "FizzBuzz"] var acc = 810092048 for i in 1..100: var c = acc and 3 echo(if c == 0:$i else: messages[c])
acc = acc shr 2 or c shl 28

### Using macro

Computes everything at compile time.

import macros
macro FizzBuzz(N): untyped =
var source = ""
for i in 1..N.intVal:
source &= "echo \""
if i mod 15 == 0:
source &= "FizzBuzz"
elif i mod 3 == 0:
source &= "Fizz"
elif i mod 5 == 0:
source &= "Buzz"
else:
source &= $i source &= "\"\n" result = parseStmt(source) FizzBuzz(100) ## Nix with (import <nixpkgs> { }).lib; with builtins; let fizzbuzz = { x ? 1 }: ''${if (mod x 15 == 0) then
"FizzBuzz"
else if (mod x 3 == 0) then
"Fizz"
else if (mod x 5 == 0) then
"Buzz"
else
(toString x)}
'' + (if (x < 100) then
fizzbuzz { x = x + 1; } else "");
in
fizzbuzz { }

## Nu

(1..100
| each {|i| $"(if$i mod 3 == 0 {"Fizz"})(if $i mod 5 == 0 {"Buzz"})" | if ($in == "") {$i} else {$in}}
| str join "\n")

## Oberon-2

MODULE FizzBuzz;

IMPORT Out;

VAR i: INTEGER;

BEGIN
FOR i := 1 TO 100 DO
IF i MOD 15 = 0 THEN
Out.String("FizzBuzz")
ELSIF i MOD 5 = 0 THEN
Out.String("Buzz")
ELSIF i MOD 3 = 0 THEN
Out.String("Fizz")
ELSE
Out.Int(i,0)
END;
Out.Ln
END
END FizzBuzz.

## Objeck

bundle Default {
class Fizz {
function : Main(args : String[]) ~ Nil {
for(i := 0; i <= 100; i += 1;) {
if(i % 15 = 0) {
"FizzBuzz"->PrintLine();
}
else if(i % 3 = 0) {
"Fizz"->PrintLine();
}
else if(i % 5 = 0) {
"Buzz"->PrintLine();
}
else {
i->PrintLine();
};
};
}
}
}

## Objective-C

// FizzBuzz in Objective-C
#import <Foundation/Foundation.h>

int main(int argc, char* argv[]) {
for (NSInteger i=1; I <= 101; i++) {
if (i % 15 == 0) {
NSLog(@"FizzBuzz\n");
} else if (i % 3 == 0) {
NSLog(@"Fizz\n");
} else if (i % 5 == 0) {
NSLog(@"Buzz\n");
} else {
NSLog(@"%li\n", i);
}
}
}

## OCaml

Idiomatic OCaml to solve the stated problem:

let fizzbuzz i =
match i mod 3, i mod 5 with
0, 0 -> "FizzBuzz"
| 0, _ -> "Fizz"
| _, 0 -> "Buzz"
| _    -> string_of_int i

let _ =
for i = 1 to 100 do print_endline (fizzbuzz i) done

With a view toward extensibility, there are many approaches: monadic, list of rules, ... here we'll use a piped sequence of rules to define a new "fizzbuzz" function:

(* Useful rule declaration: "cond => f", 'cond'itionally applies 'f' to 'a'ccumulated value *)
let (=>) cond f a = if cond then f a else a
let append s a = a^s

let fizzbuzz i =
"" |> (i mod 3 = 0 => append "Fizz")
|> (i mod 5 = 0 => append "Buzz")
|> (function "" -> string_of_int i
| s  -> s)

## Octave

for i = 1:100
if ( mod(i,15) == 0 )
disp("FizzBuzz");
elseif ( mod(i, 3) == 0 )
disp("Fizz")
elseif ( mod(i, 5) == 0 )
disp("Buzz")
else
disp(i)
endif
endfor

## Oforth

: fizzbuzz
| i |
100 loop: i [
null
i 3 mod ifZero: [ "Fizz" + ]
i 5 mod ifZero: [ "Buzz" + ]
dup ifNull: [ drop i ] .
] ;

## Ol

(for-each (lambda (x)
(print (cond
((and (zero? (mod x 3)) (zero? (mod x 5)))
"FizzBuzz")
((zero? (mod x 3))
"Fizz")
((zero? (mod x 5))
"Buzz")
(else
x))))
(iota 100))

## Onyx (wasm)

use core { * }

fizzbuzz :: (len: u32) -> void {
for i in 1..len+1 {
msg : str;
if (i%3 == 0 && i%5 == 0) { msg = "FizzBuzz !!!"; }
elseif (i%3 == 0) { msg = "Fizz"; }
elseif (i%5 == 0) { msg = "Buzz"; }
else { msg = tprintf("{}", i); }
printf("{}\n", msg);
}
}

main :: () {
fizzbuzz(100);
}

## OOC

fizz: func (n: Int) -> Bool {
if(n % 3 == 0) {
printf("Fizz")
return true
}
return false
}

buzz: func (n: Int) -> Bool {
if(n % 5 == 0) {
printf("Buzz")
return true
}
return false
}

main: func {
for(n in 1..100) {
fizz:= fizz(n)
buzz:= buzz(n)
fizz || buzz || printf("%d", n)
println()
}
}

## Order

#include <order/interpreter.h>

// Get FB for one number
#define ORDER_PP_DEF_8fizzbuzz ORDER_PP_FN(            \
8fn(8N,                                                \
8let((8F, 8fn(8N, 8G,                              \
8is_0(8remainder(8N, 8G)))),         \
8cond((8ap(8F, 8N, 15), 8quote(fizzbuzz))     \
(8ap(8F, 8N, 3), 8quote(fizz))          \
(8ap(8F, 8N, 5), 8quote(buzz))          \
(8else, 8N)))) )

// Print E followed by a comma (composable, 8print is not a function)
#define ORDER_PP_DEF_8print_el ORDER_PP_FN( \
8fn(8E, 8print(8E 8comma)) )

ORDER_PP(  // foreach instead of map, to print but return nothing
8seq_for_each(8compose(8print_el, 8fizzbuzz), 8seq_iota(1, 100))
)

## Oz

declare
fun {FizzBuzz X}
if     X mod 15 == 0 then 'FizzBuzz'
elseif X mod  3 == 0 then 'Fizz'
elseif X mod  5 == 0 then 'Buzz'
else                      X
end
end
in
for I in 1..100 do
{Show {FizzBuzz I}}
end

## Palo Alto Tiny BASIC

See FizzBuzz/Basic.

## PARI/GP

{for(n=1,100,
print(if(n%3,
if(n%5,
n
,
"Buzz"
)
,
if(n%5,
"Fizz"
,
"FizzBuzz"
)
))
)}

## Pascal

program fizzbuzz(output);
var
i: integer;
begin
for i := 1 to 100 do
if i mod 15 = 0 then
writeln('FizzBuzz')
else if i mod 3 = 0 then
writeln('Fizz')
else if i mod 5 = 0 then
writeln('Buzz')
else
writeln(i)
end.

## PascalABC.NET

begin
for var i:=1 to 100 do
if i mod 15 = 0 then
Print('FizzBuzz')
else if i mod 3 = 0 then
Print('Fizz')
else if i mod 5 = 0 then
Print('Buzz')
else Print(i)
end.

## PDP-8 Assembly

Works with: PAL-D

Runs on SimH, or any PDP-8 with an EAE

/--------------------------------------------------------
/THIS PROGRAM PRINTS THE INTEGERS FROM 1 TO 100 (INCL).
/WITH THE FOLLOWING RESTRICTIONS:
/  FOR MULTIPLES OF THREE, PRINT 'FIZZ'
/  FOR MULTIPLES OF FIVE,  PRINT 'BUZZ'
/  FOR MULTIPLES OF BOTH THREE AND FIVE, PRINT 'FIZZBUZZ'
/--------------------------------------------------------

/--------------------------------------------------------
/DEFINES
/--------------------------------------------------------
SWBA=7447               /EAE MODE A INSTRUCTION
DVI=7407                /EAE DIVIDE INSTRUCTION
AIX0=0010               /AUTO INDEX REGISTER 0
CR=0215                 /CARRIAGE RETURN
LF=0212                 /LINEFEED
EOT=0000                /END OF TEXT NUL
FIZMOD=0003             /CONSTANT DECIMAL 3 (FIZZ)
BUZMOD=0005             /CONSTANT DECIMAL 5 (BUZZ)
K10=0012                /CONSTANT DECIMAL 10

LAST=0144               /FIZZBUZZ THE NUMBERS 1..LAST
/0144 OCTAL == 100 DECIMAL
/CAN BE ANY FROM [0001...7777]

/--------------------------------------------------------
/FIZZBUZZ START=0200
/--------------------------------------------------------
*200            /START IN MEMORY AT 0200 OCTAL
FZZBZZ, CLA             /CLEAR AC
DCA CNTR        /SET UP MAIN COUNTER
TAD (-FIZMOD    /SET UP FIZZ COUNTER
DCA FIZCTR      /TO -3
TAD (-BUZMOD    /SET UP BUZZ COUNTER
DCA BUZCTR      /TO -5
SKP             /NO: CONTINUE
/'HLT' IF NOT ON OS/8
CHKFIZ, ISZ FIZCTR      /MULTIPLE OF 3?
JMP CHKBUZ      /NO: CONTINUE
JMS STROUT      /PRINT IT TO TTY
DCA FIZCTR      /MOD 3 COUNTER
CHKBUZ, ISZ BUZCTR      /MULTIPLE OF 5?
JMP CHKNUM      /NO: CONTINUE
JMS STROUT      /PRINT IT TO TTY
DCA BUZCTR      /MOD 5 COUNTER
JMP NXTLIN      /PRINT NEWLINE AND CONTINUE
CHKNUM, TAD FIZCTR      /CHECK WHETHER MOD 3 COUNTER
SNA             /DID WE JUST PRINT 'FIZZ'?
JMP NXTLIN      /YES: PRINT NEWLINE AND CONTINUE
CLA             /ZERO THE AC
TAD (LAST+1     /OFFSET IT TO A POSITIVE VALUE
JMS NUMOUT      /PRINT IT TO THE TTY
JMS STROUT      /PRINT IT TO TTY
JMP LOOP        /CONTINUE WITH THE NEXT NUMBER
CNTR,   0               /MAIN COUNTER
FIZCTR, 0               /FIZZ COUNTER
BUZCTR, 0               /BUZZ COUNTER

/--------------------------------------------------------
/WRITE ASCII CHARACTER IN AC TO TTY
/PRE : AC=ASCII CHARACTER
/POST: AC=0
/--------------------------------------------------------
CHROUT, .-.
TLS             /SEND CHARACTER TO TTY
TSF             /IS TTY READY FOR NEXT CHARACTER?
JMP .-1         /NO TRY AGAIN
CLA             /AC=0
JMP I CHROUT    /RETURN

/--------------------------------------------------------
/WRITE NUL TERMINATED ASCII STRING TO TTY
/PRE : AC=ADDRESS OF STRING MINUS 1
/POST: AC=0
/--------------------------------------------------------
STROUT, .-.
DCA AIX0        /STORE POINTER IN AUTO INDEX 0
STRLOP, TAD I AIX0      /GET NEXT CHARACTER FROM STRING
SNA             /SKIP IF NOT EOT
JMP I STROUT    /RETURN
JMS CHROUT      /PRINT CHARACTER
JMP STRLOP      /GO GET NEXT CHARACTER

/--------------------------------------------------------
/WRITE NUMBER IN AC TO TTY AS DECIMAL
/PRE : AC=UNSIGNED NUMBER BETWEEN 0000 AND 7777
/POST: AC=0
/--------------------------------------------------------
NUMOUT, .-.
SWBA            /SET EAE IN MODE A
MQL             /MQ=NUM; AC=0
DCA BUFPTR      /IN BUFPTR
SKP             /NUM IS ALREADY IN MQ
NUMLOP, MQL             /MQ=NUM; AC=0
DVI             /MQ=NUM/10; AC=NUM-(NUM/10)*10
K10             /DECIMAL 10
DCA I BUFPTR    /STORE CHAR BUFFER, BACK TO FRONT
CMA             /AC=-1
DCA BUFPTR      /BUFFER POINTER
MQA             /MQ -> AC
JMP NUMLOP      /GET NEXT DIGIT
JMS STROUT      /SEND IT TO TTY
JMP I NUMOUT    /RETURN
*.+4            /RESERVE 4 LOCATIONS (MAX=4095)
EOT             /END OF BUFFER
BUFPTR, 0               /POINTER IN BUFFER

/--------------------------------------------------------
/STRINGS
/--------------------------------------------------------
FIZSTR, .               /FIZZ STRING
"F; "I; "Z; "Z; EOT
BUZSTR, .               /BUZZ STRING
"B; "U; "Z; "Z; EOT
LINSTR, .               /NEWLINE STIRNG
CR; LF; EOT
$ Output: . .PAL FIZBUZ.PA ERRORS DETECTED: 0 LINKS GENERATED: 0 .LOAD FIZBUZ.BN .START 1 2 FIZZ 4 BUZZ FIZZ 7 8 FIZZ BUZZ 11 FIZZ 13 14 FIZZBUZZ 16 17 FIZZ 19 BUZZ FIZZ 22 23 FIZZ BUZZ 26 FIZZ 28 29 FIZZBUZZ 31 32 FIZZ 34 BUZZ FIZZ 37 38 FIZZ BUZZ 41 FIZZ 43 44 FIZZBUZZ 46 47 FIZZ 49 BUZZ FIZZ 52 53 FIZZ BUZZ 56 FIZZ 58 59 FIZZBUZZ 61 62 FIZZ 64 BUZZ FIZZ 67 68 FIZZ BUZZ 71 FIZZ 73 74 FIZZBUZZ 76 77 FIZZ 79 BUZZ FIZZ 82 83 FIZZ BUZZ 86 FIZZ 88 89 FIZZBUZZ 91 92 FIZZ 94 BUZZ FIZZ 97 98 FIZZ BUZZ .  ## Peloton Variable-length padded English dialect <# DEFINE USERDEFINEDROUTINE LITERAL>__FizzBuzz|<# SUPPRESSAUTOMATICWHITESPACE> <# TEST ISITMODULUSZERO PARAMETER LITERAL>1|3</#> <# TEST ISITMODULUSZERO PARAMETER LITERAL>1|5</#> <# ONLYFIRSTOFLASTTWO><# SAY LITERAL>Fizz</#></#> <# ONLYSECONDOFLASTTWO><# SAY LITERAL>Buzz</#></#> <# BOTH><# SAY LITERAL>FizzBuzz</#></#> <# NEITHER><# SAY PARAMETER>1</#></#> </#></#> <# ITERATE FORITERATION LITERAL LITERAL>100|<# ACT USERDEFINEDROUTINE POSITION FORITERATION>__FizzBuzz|...</#> </#> Fixed-length English dialect <@ DEFUDRLIT>__FizzBuzz|<@ SAW> <@ TSTMD0PARLIT>1|3</@> <@ TSTMD0PARLIT>1|5</@> <@ O12><@ SAYLIT>Fizz</@></@> <@ O22><@ SAYLIT>Buzz</@></@> <@ BTH><@ SAYLIT>FizzBuzz</@></@> <@ NTH><@ SAYPAR>1</@></@> </@></@> <@ ITEFORLITLIT>100|<@ ACTUDRPOSFOR>__FizzBuzz|...</@> </@> ## Perl use strict; use warnings; use feature qw(say); for my$i (1..100) {
say $i % 15 == 0 ? "FizzBuzz" :$i %  3 == 0 ? "Fizz"
: $i % 5 == 0 ? "Buzz" :$i;
}

More concisely:

print 'Fizz'x!($_ % 3) . 'Buzz'x!($_ % 5) || $_, "\n" for 1 .. 100; For code-golfing: print+(Fizz)[$_%3].(Buzz)[$_%5]||$_,$/for 1..1e2 For array of values: map((Fizz)[$_%3].(Buzz)[$_%5]||$_,1..100);

Cheating:

use feature "say";

@a = ("FizzBuzz", 0, 0, "Fizz", 0, "Buzz", "Fizz", 0, 0, "Fizz", "Buzz", 0, "Fizz");

say $a[$_ % 15] || $_ for 1..100; as a subroutine: sub fizz_buzz { join("\n", map { sub mult {$_ % shift == 0};
my @out;
if (mult 3) { push @out, "Fizz"; }
if (mult 5) { push @out, "Buzz"; }
if (!@out) {push @out, $_; } join('', @out); } (1..100))."\n"; } print fizz_buzz; By transforming a list:  @FB1 = (1..100); @FB2 = map{!($_%3 or $_%5)?'FizzBuzz':$_}@FB1;
@FB3 = map{(/\d/ and !($_%3))?'Fizz':$_}@FB2;
@FB4 = map{(/\d/ and !($_%5))?'Buzz':$_}@FB3;
@FB5 = map{$_."\n"}@FB4; print @FB5; ## Phix Library: Phix/basics Translation of: C constant x = {"%d\n","Fizz\n","Buzz\n","FizzBuzz\n"} for i=1 to 100 do printf(1,x[1+(remainder(i,3)=0)+2*(remainder(i,5)=0)],i) end for  Two variants with tabulated output: function f(integer i) integer idx = 1+(remainder(i,3)=0)+2*(remainder(i,5)=0) return sprintf({"%-8d","Fizz ","Buzz ","FizzBuzz"}[idx],i) end function printf(1,join_by(apply(tagset(100),f),10,10))  (output same as below) sequence s = apply(true,sprintf,{{"%-8d"},tagset(100)}) for i=3 to 100 by 3 do s[i] = "Fizz " end for for i=5 to 100 by 5 do s[i] = "Buzz " end for for i=15 to 100 by 15 do s[i] = "FizzBuzz" end for printf(1,join_by(s,10,10))  Output: 1 11 Fizz 31 41 Fizz 61 71 Fizz 91 2 Fizz 22 32 Fizz 52 62 Fizz 82 92 Fizz 13 23 Fizz 43 53 Fizz 73 83 Fizz 4 14 Fizz 34 44 Fizz 64 74 Fizz 94 Buzz FizzBuzz Buzz Buzz FizzBuzz Buzz Buzz FizzBuzz Buzz Buzz Fizz 16 26 Fizz 46 56 Fizz 76 86 Fizz 7 17 Fizz 37 47 Fizz 67 77 Fizz 97 8 Fizz 28 38 Fizz 58 68 Fizz 88 98 Fizz 19 29 Fizz 49 59 Fizz 79 89 Fizz Buzz Buzz FizzBuzz Buzz Buzz FizzBuzz Buzz Buzz FizzBuzz Buzz  Grotesquely inefficient (non-tabulated output), just for fun. Can you do worse, yet keep it semi-plausibile that someone might have actually earnestly written it? constant threes = tagset(100,0,3), fives = tagset(100,0,5), fifteens = tagset(100,0,15) for i=1 to 100 do if not find(i,threes) and not find(i,fives) and not find(i,fifteens) then printf(1,"%d",i) end if if find(i,threes) and not find(i,fives) and not find(i,fifteens) then printf(1,"Fizz") end if if not find(i,threes) and find(i,fives) and not find(i,fifteens) then printf(1,"Buzz",i) end if if find(i,threes) and find(i,fives) and find(i,fifteens) then printf(1,"FizzBuzz") end if printf(1,"\n") end for  ## Phixmonti /# Rosetta Code problem: http://rosettacode.org/wiki/FizzBuzz by Galileo, 10/2022 #/ 100 for dup print " " print dup 3 mod not if "Fizz" print endif 5 mod not if "Buzz" print endif nl endfor Output: 1 2 3 Fizz 4 5 Buzz 6 Fizz 7 8 9 Fizz 10 Buzz 11 12 Fizz 13 14 15 FizzBuzz 16 17 18 Fizz 19 20 Buzz 21 Fizz 22 23 24 Fizz 25 Buzz 26 27 Fizz 28 29 30 FizzBuzz 31 32 33 Fizz 34 35 Buzz 36 Fizz 37 38 39 Fizz 40 Buzz 41 42 Fizz 43 44 45 FizzBuzz 46 47 48 Fizz 49 50 Buzz 51 Fizz 52 53 54 Fizz 55 Buzz 56 57 Fizz 58 59 60 FizzBuzz 61 62 63 Fizz 64 65 Buzz 66 Fizz 67 68 69 Fizz 70 Buzz 71 72 Fizz 73 74 75 FizzBuzz 76 77 78 Fizz 79 80 Buzz 81 Fizz 82 83 84 Fizz 85 Buzz 86 87 Fizz 88 89 90 FizzBuzz 91 92 93 Fizz 94 95 Buzz 96 Fizz 97 98 99 Fizz 100 Buzz === Press any key to exit === ## PHL Translation of: C module fizzbuzz; extern printf; @Integer main [ var i = 1; while (i <= 100) { if (i % 15 == 0) printf("FizzBuzz"); else if (i % 3 == 0) printf("Fizz"); else if (i % 5 == 0) printf("Buzz"); else printf("%d", i); printf("\n"); i = i::inc; } return 0; ] ## PHP ### if/else ladder approach <?php for ($i = 1; $i <= 100;$i++)
{
if (!($i % 15)) echo "FizzBuzz\n"; else if (!($i % 3))
echo "Fizz\n";
else if (!($i % 5)) echo "Buzz\n"; else echo "$i\n";
}
?>

### Concatenation approach

Uses PHP's concatenation operator (.=) to build the output string. The concatenation operator allows us to add data to the end of a string without overwriting the whole string. Since Buzz will always appear if our number is divisible by five, and Buzz is the second part of "FizzBuzz", we can simply append "Buzz" to our string.

In contrast to the if-else ladder, this method lets us skip the check to see if $i is divisible by both 3 and 5 (i.e. 15). However, we get the added complexity of needing to reset$str to an empty string (not necessary in some other languages), and we also need a separate if statement to check to see if our string is empty, so we know if $i was not divisible by 3 or 5. <?php for ($i = 1; $i <= 100; ++$i )
{
$str = ""; if (!($i % 3 ) )
$str .= "Fizz"; if (!($i % 5 ) )
$str .= "Buzz"; if ( empty($str ) )
$str =$i;

echo $str . "\n"; } ?> ### Concatenation approach without if-s <?php for ($i = 0;
$i++ < 100;$o = ($i % 3 ? '' : 'Fizz') . ($i % 5 ? '' : 'Buzz')
)
echo $o ? :$i, PHP_EOL;
?>

### One Liner Approach

<?php

for($i = 0;$i++ < 100;) echo [$i, 'Fizz', 'Buzz', 'FizzBuzz'][!($i % 3) + 2 * !($i % 5)], "\n"; ## Picat Picat supports different programming styles/paradigms. First some "standalone" predicates. ### Using a map fizzbuzz_map => println(fizzbuzz_map), FB = [I : I in 1..100], Map = [(3="Fizz"),(5="Buzz"),(15="FizzBuzz")], foreach(I in FB, K=V in Map) if I mod K == 0 then FB[I] := V end end, println(FB). ### Using a template for the pattern fizzbuzz_template1 => println(fizzbuzz_template1), N = 100, F = [_,_,fizz,_,buzz,fizz,_,_,fizz,buzz,_,fizz,_,_,fizzbuzz], FF = [F : _I in 1..1+N div F.length].flatten(), foreach(I in 1..N) (var(FF[I]) -> print(I) ; print(FF[I])), print(" ") end, nl. ### Another version with templates fizzbuzz_template2 => println(fizzbuzz_template2), N = 100, F = new_list(N), FV = [3,5,15], FN = ["Fizz","Buzz","FizzBuzz"], foreach(I in 1..N, {Val,Name} in zip(FV,FN)) if I mod Val == 0 then F[I] := Name end end, foreach(I in 1..N) printf("%w ", cond(var(F[I]),I, F[I])) end, nl. Below are some versions for identifying the FizzBuzziness of a number. To be used with the following general wrapper: fizzbuzz(Goal) => println(Goal), foreach(I in 1..100) printf("%w ", apply(Goal,I)) end, nl. ### Plain imperative approach: if/else fb1(I) = V => V = I.to_string(), if I mod 15 == 0 then V := "FizzBuzz" elseif I mod 3 == 0 then V := "Fizz" elseif I mod 5 == 0 then V := "Buzz" end. ### Pattern matching + conditions in head fb2(I) = "FizzBuzz", I mod 15 == 0 => true. fb2(I) = "Fizz", I mod 3 == 0 => true. fb2(I) = "Buzz", I mod 5 == 0 => true. fb2(I) = I.to_string() => true. ### Another pattern matching approach fb3(I) = fb3b(I, I mod 3, I mod 5). fb3b(_I,0,0) = "FizzBuzz". fb3b(_I,_,0) = "Buzz". fb3b(_I,0,_) = "Fizz". fb3b(I,_,_) = I. ### Using cond/3 and string concatenation fb4(I) = cond(I mod 3 == 0, "Fizz", "") ++ cond(I mod 5 == 0, "Buzz", "") ++ cond(not ((I mod 3 == 0; I mod 5==0)), I.to_string(), ""). ### Recursive function (conditions in head) fizzbuzz_rec => print(fizzbuzz_rec), fb5(100,[],L), println(L). fb5(N,L1,L), N = 0 ?=> L = L1.reverse(). fb5(N,L1,L),N mod 15 == 0 ?=> fb5(N-1,L1 ++ ["FizzBuzz"], L). fb5(N,L1,L), N mod 5 == 0 ?=> fb5(N-1,L1 ++ ["Buzz"], L). fb5(N,L1,L), N mod 3 == 0 ?=> fb5(N-1,L1 ++ ["Fizz"], L). fb5(N,L1,L), N mod 3 > 0, N mod 5 > 0 => fb5(N-1,L1 ++ [N.to_string()], L). ### Golfing style fizzbuzz_golf => println(fizzbuzz_golf), [cond(P=="",I,P):I in 1..100,(I mod 3==0->P="Fizz";P=""),(I mod 5==0->P:=P++"Buzz";true)].println(). ### Planner version Picat has support for "classic" planning problems. The planner module must be imported. import planner. fizzbuzz_planner => println(fizzbuzz_planner), plan(100,Plan), println(Plan.reverse()), nl. final(Goal) => Goal == 0. action(H,To,Move,Cost) ?=> H mod 15 == 0, Move = "FizzBuzz", To = H-1, Cost = 1. action(H,To,Move,Cost) ?=> H mod 5 == 0, Move = "Buzz", To = H-1, Cost = 1. action(H,To,Move,Cost) ?=> H mod 3 == 0, Move = "Fizz", To = H-1, Cost = 1. action(H,To,Move,Cost) => H mod 3 > 0, H mod 5 > 0, Move = H.to_string(), To = H-1, Cost = 1. Here we test everything. go => fizzbuzz_map, fizzbuzz_template1, fizzbuzz_template2, fizzbuzz_planner, fizzbuzz_rec, fizzbuzz_golf, FBs = [fb1,fb2,fb3,fb4], foreach(FB in FBs) call(fizzbuzz,FB) end, nl. ## PicoLisp We could simply use 'at' here: (for N 100 (prinl (or (pack (at (0 . 3) "Fizz") (at (0 . 5) "Buzz")) N) ) ) # Above, we simply count till 100 'prin'-ting number 'at' 3rd ('Fizz'), 5th ('Buzz') and 'pack'-ing 15th number ('FizzBuzz'). # Rest of the times 'N' is printed as it loops in 'for'. Or do it the standard way: (for N 100 (prinl (cond ((=0 (% N 15)) "FizzBuzz") ((=0 (% N 3)) "Fizz") ((=0 (% N 5)) "Buzz") (T N) ) ) ) ## Piet ## Pike int main(){ for(int i = 1; i <= 100; i++) { if(i % 15 == 0) { write("FizzBuzz\n"); } else if(i % 3 == 0) { write("Fizz\n"); } else if(i % 5 == 0) { write("Buzz\n"); } else { write(i + "\n"); } } } ## PILOT C :i = 0 *loop C :i = i + 1 J ( i > 100 ) : *finished C :modulo = i % 15 J ( modulo = 0 ) : *fizzbuzz C :modulo = i % 3 J ( modulo = 0 ) : *fizz C :modulo = i % 5 J ( modulo = 0 ) : *buzz T :#i J : *loop *fizzbuzz T :FizzBuzz J : *loop *fizz T :Fizz J : *loop *buzz T :Buzz J : *loop *finished END: ## PIR Works with: Parrot version tested with 2.4.0 .sub main :main .local int f .local int mf .local int skipnum f = 1 LOOP: if f > 100 goto DONE skipnum = 0 mf = f % 3 if mf == 0 goto FIZZ FIZZRET: mf = f % 5 if mf == 0 goto BUZZ BUZZRET: if skipnum > 0 goto SKIPNUM print f SKIPNUM: print "\n" inc f goto LOOP end FIZZ: print "Fizz" inc skipnum goto FIZZRET end BUZZ: print "Buzz" inc skipnum goto BUZZRET end DONE: end .end ## PL/I do i = 1 to 100; select; when (mod(i,15) = 0) put skip list ('FizzBuzz'); when (mod(i,3) = 0) put skip list ('Fizz'); when (mod(i,5) = 0) put skip list ('Buzz'); otherwise put skip list (i); end; end; ## PL/M 100H: /* DECLARE OUTPUT IN TERMS OF CP/M - PL/M DOES NOT COME WITH ANY STANDARD LIBRARY */ BDOS: PROCEDURE(FUNC, ARG); DECLARE FUNC BYTE, ARG ADDRESS; GO TO 5; END BDOS; PUT$STRING: PROCEDURE(STR);
CALL BDOS(9, STR);
CALL BDOS(9, .(13,10,'$')); END PUT$STRING;

/* PRINT A NUMBER */
PUT$NUMBER: PROCEDURE(N); DECLARE S (5) BYTE INITIAL ('...$');
DECLARE (N, D, C BASED P) BYTE;
P = .S(3);
DIGIT:
P = P-1;
C = (N MOD 10) + '0';
N = N/10;
IF N > 0 THEN GO TO DIGIT;
CALL PUT$STRING(P); END PUT$NUMBER;

/* FIZZBUZZ */
DECLARE N BYTE;
DO N = 1 TO 100;
IF N MOD 15 = 0 THEN
CALL PUT$STRING(.'FIZZBUZZ$');
ELSE IF N MOD 5 = 0 THEN
CALL PUT$STRING(.'BUZZ$');
ELSE IF N MOD 3 = 0 THEN
CALL PUT$STRING(.'FIZZ$');
ELSE
CALL PUT$NUMBER(N); END; /* EXIT TO CP/M */ CALL BDOS(0,0); EOF ## PL/SQL begin for i in 1 .. 100 loop case when mod(i, 15) = 0 then dbms_output.put_line('FizzBuzz'); when mod(i, 5) = 0 then dbms_output.put_line('Buzz'); when mod(i, 3) = 0 then dbms_output.put_line('Fizz'); else dbms_output.put_line(i); end case; end loop; end; ## Plain English To play FizzBuzz up to a number: Put "" into a string. Loop. If a counter is past the number, exit. If the counter is evenly divisible by 3, append "Fizz" to the string. If the counter is evenly divisible by 5, append "Buzz" to the string. If the string is blank, append the counter then "" to the string. Write the string to the console. Clear the string. Repeat. To run: Start up. Play FizzBuzz up to 100. Wait for the escape key. Shut down. ## Pointless output = range(1, 100) |> map(fizzBuzz) |> printLines fizzBuzz(n) = if result == "" then n else result where result = fizzBuzzString(n) fizzBuzzString(n) = (if n % 3 == 0 then "Fizz" else "") + (if n % 5 == 0 then "Buzz" else "") ## Pony use "collections" actor Main new create(env: Env) => for i in Range[I32](1, 100) do env.out.print(fizzbuzz(i)) end fun fizzbuzz(n: I32): String => if (n % 15) == 0 then "FizzBuzz" elseif (n % 5) == 0 then "Buzz" elseif (n % 3) == 0 then "Fizz" else n.string() end ## Pop11 lvars str; for i from 1 to 100 do if i rem 15 = 0 then 'FizzBuzz' -> str; elseif i rem 3 = 0 then 'Fizz' -> str; elseif i rem 5 = 0 then 'Buzz' -> str; else '' >< i -> str; endif; printf(str, '%s\n'); endfor; ## PostScript 1 1 100 { /c false def dup 3 mod 0 eq { (Fizz) print /c true def } if dup 5 mod 0 eq { (Buzz) print /c true def } if c {pop}{( ) cvs print} ifelse (\n) print } for or... /fizzdict 100 dict def fizzdict begin /notmod{ ( ) cvs } def /mod15 { dup 15 mod 0 eq { (FizzBuzz)def }{pop}ifelse} def /mod3 { dup 3 mod 0 eq {(Fizz)def}{pop}ifelse} def /mod5 { dup 5 mod 0 eq {(Buzz)def}{pop}ifelse} def 1 1 100 { mod3 } for 1 1 100 { mod5 } for 1 1 100 { mod15} for 1 1 100 { dup currentdict exch known { currentdict exch get}{notmod} ifelse print (\n) print} for end ## Potion 1 to 100 (a): if (a % 15 == 0): 'FizzBuzz'. elsif (a % 3 == 0): 'Fizz'. elsif (a % 5 == 0): 'Buzz'. else: a. string print "\n" print. ## PowerShell ### Straightforward, looping for ($i = 1; $i -le 100;$i++) {
if ($i % 15 -eq 0) { "FizzBuzz" } elseif ($i % 5 -eq 0) {
"Buzz"
} elseif ($i % 3 -eq 0) { "Fizz" } else {$i
}
}

### Pipeline, Switch

$txt=$null
1..100 | ForEach-Object {
switch ($_) { {$_ % 3 -eq 0 }  { $txt+="Fizz" } {$_ % 5 -eq 0 }  { $txt+="Buzz" }$_                { if($txt) {$txt } else { $_ };$txt=$null } } } ### Concatenation Translation of: C# 1..100 | ForEach-Object {$s = ''
if ($_ % 3 -eq 0) {$s += "Fizz" }
if ($_ % 5 -eq 0) {$s += "Buzz" }
if (-not $s) {$s = $_ }$s
}

### Piping, Evaluation, Concatenation

1..100 | % {write-host("$(if(($_ % 3 -ne 0) -and ($_ % 5 -ne 0)){$_})$(if($_ % 3 -eq 0){"Fizz"})$(if($_ % 5 -eq 0){"Buzz"})")}

### Filter, Piping, Regex Matching, Array Auto-Selection

filter fizz-buzz{
@(

## Processing

### Console & Visualization

Reserved variable "width" in Processing is 100 pixels by default, suitable for this FizzBuzz exercise. Accordingly, range is pixel index from 0 to 99.

for (int i = 0; i < width; i++) {
if (i % 3 == 0 && i % 5 == 0) {
stroke(255, 255, 0);
println("FizzBuzz!");
}
else if (i % 5 == 0) {
stroke(0, 255, 0);
println("Buzz");
}
else if (i % 3 == 0) {
stroke(255, 0, 0);
println("Fizz");
}
else {
stroke(0, 0, 255);
println(i);
}
line(i, 0, i, height);
}

### Console & Visualization, Ternary

for (int i = 0; i < width; i++) {
stroke((i % 5 == 0 && i % 3 == 0) ? #FFFF00 : (i % 5 == 0) ? #00FF00 : (i % 3 == 0) ? #FF0000 : #0000FF);
line(i, 0, i, height);
println((i % 5 == 0 && i % 3 == 0) ? "FizzBuzz!" : (i % 5 == 0) ? "Buzz" : (i % 3 == 0) ? "Fizz" : i);
}

### Console

for (int i = 1; i <= 100; i++) {
if (i % 3 == 0) {
print("Fizz");
}
if (i % 5 == 0) {
print("Buzz");
}
if (i % 3 != 0 && i % 5 != 0) {
print(i);
}
print("\n");
}

### Console, "Futureproof"

for(int i = 1; i <= 100; i++){
String output = "";

if(i % 3 == 0) output += "Fizz";
if(i % 5 == 0) output += "Buzz";
// copy & paste above line to add more tests

if(output == "") output = str(i);
println(output);
}

All examples produce the same console output:

Output:
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
16
17
Fizz
19
Buzz
Fizz
22
23
Fizz
Buzz
26
Fizz
28
29
FizzBuzz
31
32
Fizz
34
Buzz
Fizz
37
38
Fizz
Buzz
41
Fizz
43
44
FizzBuzz
46
47
Fizz
49
Buzz
Fizz
52
53
Fizz
Buzz
56
Fizz
58
59
FizzBuzz
61
62
Fizz
64
Buzz
Fizz
67
68
Fizz
Buzz
71
Fizz
73
74
FizzBuzz
76
77
Fizz
79
Buzz
Fizz
82
83
Fizz
Buzz
86
Fizz
88
89
FizzBuzz
91
92
Fizz
94
Buzz
Fizz
97
98
Fizz
Buzz


## Prolog

Works with: SWI Prolog version 4.8.0
Works with: Ciao Prolog version 1.21.0

Maybe not the most conventional way to write this in Prolog. The fizzbuzz predicate uses a higher-order predicate and print_item uses the if-then-else construction.

fizzbuzz :-
forall(between(1, 100, X), print_item(X)).

print_item(X) :-
(  X mod 15 =:= 0
-> write('FizzBuzz')
;  X mod 3 =:= 0
-> write('Fizz')
;  X mod 5 =:= 0
-> write('Buzz')
;  write(X)
),
nl.

More conventional, doing the loop this time failure driven:

fizzbuzz(X) :- X mod 15 =:= 0, !, write('FizzBuzz').
fizzbuzz(X) :- X mod 3 =:= 0, !, write('Fizz').
fizzbuzz(X) :- X mod 5 =:= 0, !, write('Buzz').
fizzbuzz(X) :- write(X).

dofizzbuzz :-between(1, 100, X), fizzbuzz(X), nl, fail.
dofizzbuzz.

Clearer, doing the loop this time tail recursive, quite declarative:

%        N  /3?  /5?  V
fizzbuzz(_, yes, yes, 'FizzBuzz').
fizzbuzz(_, yes, no,  'Fizz').
fizzbuzz(_, no,  yes, 'Buzz').
fizzbuzz(N, no,  no,  N).

% Unifies V with 'yes' if D divides evenly into N, 'no' otherwise.
divisible_by(N, D, yes) :- N mod D =:= 0.
divisible_by(N, D, no) :- N mod D =\= 0.

% Print 'Fizz', 'Buzz', 'FizzBuzz' or N as appropriate.
fizz_buzz_or_n(N) :- N > 100.
fizz_buzz_or_n(N) :- N =< 100,
divisible_by(N, 3, Fizz),
divisible_by(N, 5, Buzz),
fizzbuzz(N, Fizz, Buzz, FB),
write(FB), nl,
M is N+1, fizz_buzz_or_n(M).

main :-
fizz_buzz_or_n(1).

Using modern Prolog techniques, resulting in idiomatic, highly declarative code:

Works with: SWI Prolog version 8.2.1
Works with: Scryer Prolog version 0.7.8
% This implementation uses modern Prolog techniques
% in order to be an idiomatic solution that uses logical purity, generality and determinism wherever possible:
% - CLP(Z): constraint logic programming on integers.
% - library(reif): efficient logical predicates based on 'Indexing dif/2'.
:- module(fizz_buzz, [main/0, integer_fizzbuzz_below_100/2, integer_fizzbuzz/2]).

:- use_module(library(reif)).

% for Scryer-Prolog:
:- use_module(library(clpz)).
:- use_module(library(between)).
:- use_module(library(iso_ext)).
:- use_module(library(si)).

% for SWI-Prolog:
% :- use_module(library(clpfd)).

% Prints all solutions to integer_fizzbuzz_below_100 each on a separate line, in order.
% Logically-impure shell, as currently there is no logically-pure way to write to a filestream.
main :-
forall(integer_fizzbuzz_below_100(_, FizzBuzz), write_line(FizzBuzz)).

write_line(Value) :-
write(Value),
nl.

% Constrains FizzBuzz results to the range 1 <= X <= 100,
% and (for the 'most general query' where neither X or FizzBuzz is concrete)
% ensures results are traversed in order low -> high X.
%
% ?- integer_fizzbuzz_below_100(X, FizzBuzz) % generate all the results in order
% ?- integer_fizzbuzz_below_100(27, Result) % Find out what output 27 will produce (it's 'Fizz'.)
% ?- integer_fizzbuzz_below_100(X, 'Fizz')   % generate all the numbers which would print 'Fizz' in order (3, 6, 9, etc).
% ?- integer_fizzbuzz_below_100(X, Res), integer_si(Res) % generate all the numbers which would print themselves in order (1, 2, 4, 6, 7, 8, 11, etc).
% ?- integer_fizzbuzz_below_100(X, Res), is_of_type(integer, Res) % SWI-Prolog version doing the same.
integer_fizzbuzz_below_100(X, FizzBuzz) :-
between(1, 100, X),
integer_fizzbuzz(X, FizzBuzz).

% States the relationship between a number
% and its FizzBuzz representation.
%
% Because constraints are propagated lazily,
% prompting this predicate without having constrained Num
% to a particular integer value will give you its definition back.
% Put differently: This predicate returns the whole solution space at once,
% and external labeling techniques are required to traverse and concretize this solution space
% in an order that we like.
integer_fizzbuzz(Num, FizzBuzz) :-
if_(Num mod 15 #= 0, FizzBuzz = 'FizzBuzz',
if_(Num mod 5 #= 0, FizzBuzz = 'Buzz',
if_(Num mod 3 #= 0, FizzBuzz = 'Fizz',
Num = FizzBuzz)
)
).

% Reifiable #=.
#=(X, Y, T) :-
X #= X1,
Y #= Y1,
zcompare(C, X1, Y1),
eq_t(C, T).

eq_t(=, true).
eq_t(<, false).
eq_t(>, false).

## Pyret

fun fizzbuzz(n :: NumPositive) -> String:
doc: For positive input which is multiples of three return 'Fizz', for the multiples of five return 'Buzz'.
For numbers which are multiples of both three and five return 'FizzBuzz'. Otherwise, return the number itself.
| num-modulo(n, 15) == 0 then: "FizzBuzz"
| num-modulo(n, 3) == 0 then: "Fizz"
| num-modulo(n, 5) == 0 then: "Buzz"
| otherwise: num-to-string(n)
end
where:
fizzbuzz(1) is "1"
fizzbuzz(101) is "101"
fizzbuzz(45) is "FizzBuzz"
fizzbuzz(33) is "Fizz"
fizzbuzz(25) is "Buzz"
end

range(1, 101).map(fizzbuzz).each(print)

## Python

### Python2: Simple

for i in range(1, 101):
if i % 15 == 0:
print "FizzBuzz"
elif i % 3 == 0:
print "Fizz"
elif i % 5 == 0:
print "Buzz"
else:
print i

### Python3: Simple

for i in range(1, 101):
if i % 15 == 0:
print("FizzBuzz")
elif i % 3 == 0:
print("Fizz")
elif i % 5 == 0:
print("Buzz")
else:
print(i)

### Python: Simple - no duplication

for n in range(1,101):
response = ''

if not n%3:
response += 'Fizz'
if not n%5:
response += 'Buzz'

print(response or n)

One liner using string concatenation:

for i in range(1,101): print("Fizz"*(i%3==0) + "Buzz"*(i%5==0) or i)

One liner another code:

for i in range(100):print(i%3//2*'Fizz'+i%5//4*'Buzz'or i+1)

List Comprehensions:

for n in range(1, 100):
fb = ''.join([ denom[1] if n % denom[0] == 0 else '' for denom in [(3,'fizz'),(5,'buzz')] ])
print fb if fb else n

Another list comprehension:

print (', '.join([(x%3<1)*'Fizz'+(x%5<1)*'Buzz' or str(x) for x in range(1,101)]))

### Python: List Comprehension (Python 3)

[print("FizzBuzz") if i % 15 == 0 else print("Fizz") if i % 3 == 0 else print("Buzz") if i % 5 == 0 else print(i) for i in range(1,101)]

### Python: Lazily

You can also create a lazy, unbounded sequence by using generator expressions:

from itertools import cycle, izip, count, islice

fizzes = cycle([""] * 2 + ["Fizz"])
buzzes = cycle([""] * 4 + ["Buzz"])
both = (f + b for f, b in izip(fizzes, buzzes))

# if the string is "", yield the number
# otherwise yield the string
fizzbuzz = (word or n for word, n in izip(both, count(1)))

# print the first 100
for i in islice(fizzbuzz, 100):
print i

Or equivalently, in terms of map, and Python 3 libraries:

Works with: Python version 3.7
'''Fizz buzz'''

from itertools import count, cycle, islice

# fizzBuzz :: () -> Generator [String]
def fizzBuzz():
'''A non-finite stream of fizzbuzz terms.
'''
return map(
lambda f, b, n: (f + b) or str(n),
cycle([''] * 2 + ['Fizz']),
cycle([''] * 4 + ['Buzz']),
count(1)
)

# ------------------------- TEST -------------------------
def main():
'''Display of first 100 terms of the fizzbuzz series.
'''
print(
'\n'.join(
list(islice(
fizzBuzz(),
100
))
)
)

if __name__ == '__main__':
main()

### Python3.8: With walrus operator

print(*map(lambda n: 'Fizzbuzz '[(i):i+13] if (i := n**4%-15) > -14 else n, range(1,100)))

### Python: Math tricks

Numbers ending in 5 or 0 are divisible by 5. Numbers whose digits recursively summed to a single-digit number == 3,6 or 9 are divisible by 3.

def numsum(n):
''' The recursive sum of all digits in a number
unit a single character is obtained'''
res = sum([int(i) for i in str(n)])
if res < 10: return res
else : return numsum(res)

for n in range(1,101):
response = 'Fizz'*(numsum(n) in [3,6,9]) + \
'Buzz'*(str(n)[-1] in ['5','0'])\
or n
print(response)

### Python3: Super concise: 1 line

print(*((lambda x=x: ''.join(chr(c) for c in (102, 105)) + (2 * chr(122)) + ''.join(chr(c) for c in (98, 117)) + (2 * chr(122)) + '\n' if x % (30 >> 1) == 0 else ''.join(chr(c) for c in (102, 105)) + (2 * chr(122)) + '\n' if x % (6 >> 1) == 0 else ''.join(chr(c) for c in (98, 117)) + (2 * chr(122)) + '\n' if x % (10 >> 1) == 0 else str(x) + '\n')() for x in range(1, 101)))

## q

q is the query language for kdb+.

{($string x)^fizzbuzzbuzzfizz(x mod\:15 5 3)?'0} Usage: q)/ Fizzbuzz q)fb:{($string x)^fizzbuzzbuzzfizz(x mod\:15 5 3)?'0}
q)fb 1+til 20
12fizz4buzzfizz78fizzbuzz11fizz1314fizzbuzz1617fizz19buzz

Explanation:

q)show x:1+til 20
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
q)x mod\:15 5 3
1  1 1
2  2 2
3  3 0
4  4 1
5  0 2
6  1 0
..
q)(x mod\:15 5 3)?'0
3 3 2 3 1 2 3 3 2 1 3 2 3 3 0 3 3 2 3 1
q)fizzbuzzbuzzfizz(x mod\:15 5 3)?'0  / substitutions
fizzbuzzfizzfizzbuzzfizzfizzbuzzfizzbuzz
q)$string x / numbers => symbols 1234567891011121314151617181920 q)($string x)^fizzbuzzbuzzfizz(x mod\:15 5 3)?'0  / replace nulls with numbers
12fizz4buzzfizz78fizzbuzz11fizz1314fizzbuzz1617fizz19buzz

## QB64

For n = 1 To 100
If n Mod 15 = 0 Then
Print "FizzBuzz"
ElseIf n Mod 5 = 0 Then
Print "Buzz"
ElseIf n Mod 3 = 0 Then
Print "Fizz"
Else
Print n
End If
Next

## Quackery

  100 times
[ i^ 1+ true
over 3 mod not
if [ say "fizz" drop false ]
over 5 mod not
if [ say "buzz" drop false ]
iff echo else drop
sp ]

## R

xx <- x <- 1:100
xx[x %% 3 == 0] <- "Fizz"
xx[x %% 5 == 0] <- "Buzz"
xx[x %% 15 == 0] <- "FizzBuzz"
xx

Or, without directly checking for divisibility by 15:

xx <- rep("", 100)
x <- 1:100
xx[x %% 3 == 0] <- paste0(xx[x %% 3 == 0], "Fizz")
xx[x %% 5 == 0] <- paste0(xx[x %% 5 == 0], "Buzz")
xx[xx == ""] <- x[xx == ""]
xx

Or, (ab)using the vector recycling rule:

x <- paste0(rep("", 100), c("", "", "Fizz"), c("", "", "", "", "Buzz"))
cat(ifelse(x == "", 1:100, x), sep = "\n")

Or, for an abuse of the recycling rules that could be generalised:

x <- paste0(rep("", 100), rep(c("", "Fizz"), times = c(2, 1)), rep(c("", "Buzz"), times = c(4, 1)))
cat(ifelse(x == "", 1:100, x), sep = "\n")

Or, with a more straightforward use of ifelse:

x <- 1:100
ifelse(x %% 15 == 0, 'FizzBuzz',
ifelse(x %% 5 == 0, 'Buzz',
ifelse(x %% 3 == 0, 'Fizz', x)))

Or, adapting from General FizzBuzz#Names solution:

namedNums <- c(Fizz = 3, Buzz = 5)
for(i in 1:100)
{
isFactor <- i %% namedNums == 0
print(if(any(isFactor)) paste0(names(namedNums)[isFactor], collapse = "") else i)
}

## Racket

#lang racket

(for ([n (in-range 1 101)])
(displayln
(match (gcd n 15)
[15 "fizzbuzz"]
[3 "fizz"]
[5 "buzz"]
[_ n])))

## Raku

(formerly Perl 6)

Works with: Rakudo Star version 2015-09-10

Most straightforwardly:

for 1 .. 100 {
when $_ %% (3 & 5) { say 'FizzBuzz'; } when$_ %% 3       { say 'Fizz'; }
when $_ %% 5 { say 'Buzz'; } default { .say; } } Or abusing multi subs: multi sub fizzbuzz(Int$ where * %% 15) { 'FizzBuzz' }
multi sub fizzbuzz(Int $where * %% 5) { 'Buzz' } multi sub fizzbuzz(Int$ where * %%  3) { 'Fizz' }
multi sub fizzbuzz(Int $number ) {$number }
(1 .. 100)».&fizzbuzz.say;

Or abusing list metaoperators:

[1..100].map({[~] ($_%%3,$_%%5) »||» "" Z&& <fizz buzz> or $_ })».say Concisely (readable): say 'Fizz' x$_ %% 3 ~ 'Buzz' x $_ %% 5 ||$_ for 1 .. 100;

Shortest FizzBuzz to date:

say "Fizz"x$_%%3~"Buzz"x$_%%5||$_ for 1..100 And here's an implementation that never checks for divisibility: .say for ( (flat ('' xx 2, 'Fizz') xx *) Z~ (flat ('' xx 4, 'Buzz') xx *) ) Z|| 1 .. 100; ## RapidQ The BASIC solutions work with RapidQ, too. However, here is a bit more esoteric solution using the IIF() function. FOR i=1 TO 100 t$ = IIF(i MOD 3 = 0, "Fizz", "") + IIF(i MOD 5 = 0, "Buzz", "")
PRINT IIF(LEN(t$), t$, i)
NEXT i

## Rascal

import IO;

public void fizzbuzz() {
for(int n <- [1 .. 100]){
fb = ((n % 3 == 0) ? "Fizz" : "") + ((n % 5 == 0) ? "Buzz" : "");
println((fb == "") ?"<n>" : fb);
}
}

## Raven

100 each 1 + as n
''
n 3 mod 0 = if 'Fizz' cat
n 5 mod 0 = if 'Buzz' cat
dup empty if drop n
say

## ReasonML

let fizzbuzz i =>
switch (i mod 3, i mod 5) {
| (0, 0) => "FizzBuzz"
| (0, _) => "Fizz"
| (_, 0) => "Buzz"
| _ => string_of_int i
};

for i in 1 to 100 {
print_endline (fizzbuzz i)
};

## REBOL

An implementation that concatenates strings and includes a proper code header (title, date, etc.)

REBOL [
Title: "FizzBuzz"
URL: http://rosettacode.org/wiki/FizzBuzz
]

; Concatenative. Note use of 'case/all' construct to evaluate all
; conditions. I use 'copy' to allocate a new string each time through
; the loop -- otherwise 'x' would get very long...

repeat i 100 [
x: copy ""
case/all [
0 = mod i 3 [append x "Fizz"]
0 = mod i 5 [append x "Buzz"]
"" = x      [x: mold i]
]
print x
]

Here is an example by Nick Antonaccio.

repeat i 100 [
print switch/default 0 compose [
(mod i 15) ["fizzbuzz"]
(mod i 3)  ["fizz"]
(mod i 5)  ["buzz"]
][i]
]

And a minimized version:

repeat i 100[j:""if i // 3 = 0[j:"fizz"]if i // 5 = 0[j: join j"buzz"]if""= j[j: i]print j]

The following is presented as a curiosity only, not as an example of good coding practice:

m: func [i d] [0 = mod i d]
spick: func [t x y][either any [not t  "" = t][y][x]]
zz: func [i] [rejoin [spick m i 3 "Fizz" ""  spick m i 5 "Buzz" ""]]
repeat i 100 [print spick z: zz i z i]

## Red

Red [Title: "FizzBuzz"]

repeat i 100 [
print case [
i % 15 = 0 ["FizzBuzz"]
i % 5 = 0 ["Buzz"]
i % 3 = 0 ["Fizz"]
true [i]
]
]

## Refal

### GNU sed

GNU sed has first~step address expression that matches every stepth line. This makes following one-liners possible.

Using seq:

seq 100 | sed '0~3 s/.*/Fizz/; 0~5 s/[0-9]*$/Buzz/' Using yes: yes | sed -n '0~3s/y/Fizz/;0~5s/y*$/Buzz/;tx;=;b;:x;p;100q'

Using the option -z (--zero-data) first introduced in GNU sed 4.2.2 (2012-12-22):

sed -nz '0~3s/^/Fizz/;0~5s/$/Buzz/;tx;=;b;:x;p;100q' /dev/zero | sed 'y/\c@/\n/' Second invocation of sed translates null characters to newlines. The same could be achieved with tr \\0 \\n ## Seed7 $ include "seed7_05.s7i";

const proc: main is func
local
var integer: number is 0;
begin
for number range 1 to 100 do
if number rem 15 = 0 then
writeln("FizzBuzz");
elsif number rem 5 = 0 then
writeln("Buzz");
elsif number rem 3 = 0 then
writeln("Fizz");
else
writeln(number);
end if;
end for;
end func;

## SenseTalk

repeat 100
put "" into output
if the counter is a multiple of 3 then
put "Fizz" after output
end if
if the counter is a multiple of 5 then
put "Buzz" after output
end if
if output is empty then
put the counter into output
end if
put output
end repeat

## SETL

program fizzbuzz;
loop for n in [1..100] do
print(fizzbuzz(n));
end loop;

proc fizzbuzz(n);
divs := [[3, "Fizz"], [5, "Buzz"]];
return +/[w : [d,w] in divs | n mod d=0] ? str n;
end proc;
end program;

## SequenceL

import <Utilities/Conversion.sl>;
import <Utilities/Sequence.sl>;

main(args(2)) :=
let
result[i] :=
"FizzBuzz" when i mod 3 = 0 and i mod 5 = 0
else
"Fizz" when i mod 3 = 0
else
"Buzz" when i mod 5 = 0
else
intToString(i)
foreach i within 1 ... 100;
in
delimit(result, '\n');

## Shale

#!/usr/local/bin/shale

string library

r var
i var
i 1 =
{ i 100 <= } {
r "" =
i 3 % 0 == { r r "fizz" concat string::() = } ifthen
i 5 % 0 == { r r "buzz" concat string::() = } ifthen
r "" equals string::() { i } { r } if i "%3d: %p\n" printf
i++
} while

## Shen

(define fizzbuzz
101 -> (nl)
N -> (let divisible-by? (/. A B (integer? (/ A B)))
(cases (divisible-by? N 15) (do (output "Fizzbuzz!~%")
(fizzbuzz (+ N 1)))
(divisible-by? N 3) (do (output "Fizz!~%")
(fizzbuzz (+ N 1)))
(divisible-by? N 5) (do (output "Buzz!~%")
(fizzbuzz (+ N 1)))
true (do (output (str N))
(nl)
(fizzbuzz (+ N 1))))))

(fizzbuzz 1)

(defprolog fizz
0 <-- (is _ (output "Fizz"));
N <-- (when (> N 0)) (is N1 (- N 3)) (fizz N1);
)

(defprolog buzz
0 <-- (is _ (output "Buzz"));
N <-- (when (> N 0)) (is N1 (- N 5)) (buzz N1);
)

(define none
[] -> true
[true | _] -> false
[_ | B] -> (none B)
)

(define fizzbuzz
N M -> (nl) where (> N M)
N M -> (do
(if (none [(prolog? (receive N) (fizz N)) (prolog? (receive N) (buzz N))])
(output (str N))
(output "!")
)
(nl)
(fizzbuzz (+ N 1) M)
)
)

(fizzbuzz 1 100)

## Sidef

Structured:

{ |i|
if (i %% 3) {
print "Fizz"
i %% 5 && print "Buzz"
print "\n"
}
elsif (i %% 5) { say "Buzz" }
else  { say i }
} << 1..100

Declarative:

func fizzbuzz({ _ %% 15 }) { "FizzBuzz" }
func fizzbuzz({ _ %%  5 }) {     "Buzz" }
func fizzbuzz({ _ %%  3 }) {     "Fizz" }
func fizzbuzz(        n  ) {          n }

for n in (1..100) { say fizzbuzz(n) }

One-liner:

{>"#{<Fizz>[.%3]}#{<Buzz>[.%5]}"||_}<<1..100

## Simula

begin
integer i;
for i := 1 step 1 until 100 do
begin
boolean fizzed;
fizzed := 0 = mod(i, 3);
if fizzed then
outtext("Fizz");
if mod(i, 5) = 0 then
outtext("Buzz")
else if not fizzed then
outint(i, 3);
outimage
end;
end

## SkookumScript

Answer by printing out one of the 4 alternatives:

1.to 100
[
println(
if idx.mod(15) = 0 ["FizzBuzz"]
idx.mod(3) = 0 ["Fizz"]
idx.mod(5) = 0 ["Buzz"]
else [idx])
]

Answer by building up a string:

1.to 100
[
!str: ""
if idx.mod(3) = 0 [str += "Fizz"]
if idx.mod(5) = 0 [str += "Buzz"]
println(if str.empty? [idx] else [str])
]

Or doing initial bind in one step:

1.to 100
[
!str: if idx.mod(3) = 0 ["Fizz"] else [""]
if idx.mod(5) = 0 [str += "Buzz"]
println(if str.empty? [idx] else [str])
]

## Slate

n@(Integer traits) fizzbuzz
[
output ::= ((n \\ 3) isZero ifTrue: ['Fizz'] ifFalse: ['']) ; ((n \\ 5) isZero ifTrue: ['Buzz'] ifFalse: ['']).
output isEmpty ifTrue: [n printString] ifFalse: [output]
].
1 to: 100 do: [| :i | inform: i fizzbuzz]

## Slope

(define fizz-buzz
(lambda (x)
(define ret "")
(if (zero? (% x 3))(set! ret (append ret "fizz")))
(if (zero? (% x 5))(set! ret (append ret "buzz")))
(if (equal? ret "") (set! ret (append ret x)))
ret))
(apply display-lines (list-join (map fizz-buzz (range 100 1))))

## Smalltalk

Since only GNU Smalltalk supports file-based programming, we'll be using its syntax.

Integer extend [
fizzbuzz [
| fb |
fb := '%<Fizz|>1%<Buzz|>2' % {
self \\ 3 == 0.  self \\ 5 == 0 }.
^fb isEmpty ifTrue: [ self ] ifFalse: [ fb ]
]
]
1 to: 100 do: [ :i | i fizzbuzz displayNl ]

A Squeak/Pharo example using the Transcript window:

(1 to: 100) do:
[:n |
((n \\ 3)*(n \\ 5)) isZero
ifFalse: [Transcript show: n].
(n \\ 3) isZero
ifTrue: [Transcript show: 'Fizz'].
(n \\ 5) isZero
ifTrue: [Transcript show: 'Buzz'].
Transcript cr.]

The Squeak/Pharo examples below present possibilities using the powerful classes available. In this example, the dictionary can have as keys pairs of booleans and in the interaction the several boolean patterns select the string to be printed or if the pattern is not found the number itself is printed.

fizzbuzz := Dictionary with: #(true true)->'FizzBuzz'
with: #(true false)->'Fizz'
with: #(false true)->'Buzz'.

1 to: 100 do:
[ :i | Transcript show:
(fizzbuzz at: {i isDivisibleBy: 3. i isDivisibleBy: 5}
ifAbsent: [ i ]); cr]

Smalltalk does not have a case-select construct, but a similar effect can be attained using a collection and the #includes: method:

1 to: 100 do: [:n | |r|
r := n rem: 15.
Transcript show: (r isZero
ifTrue:['fizzbuzz']
ifFalse: [(#(3 6 9 12) includes: r)
ifTrue:['fizz']
ifFalse:[((#(5 10) includes: r))
ifTrue:['buzz']
ifFalse:[n]]]);
cr].

If the construction of the whole collection is done beforehand, Smalltalk provides a straightforward way of doing because collections can be heterogeneous (may contain any object):

fbz := (1 to: 100) asOrderedCollection.
3 to: 100 by:  3 do: [:i | fbz at: i put: 'Fizz'].
5 to: 100 by:  5 do: [:i | fbz at: i put: 'Buzz'].
15 to: 100 by: 15 do: [:i | fbz at: i put: 'FizzBuzz'].
fbz do: [:i | Transcript show: i; cr].

The approach building a dynamic string can be done as well:

1 to: 100 do: [:i | |fb s|
fb := {i isDivisibleBy: 3. i isDivisibleBy: 5. nil}.
fb at: 3 put: (fb first | fb second) not.
s := '<1?Fizz:><2?Buzz:><3?{1}:>' format: {i printString}.
Transcript show: (s expandMacrosWithArguments: fb); cr].

## SNOBOL4

Merely posting a solution by Daniel Lyons

        I = 1
LOOP    FIZZBUZZ = ""
EQ(REMDR(I, 3), 0)              :F(TRY_5)
FIZZBUZZ = FIZZBUZZ "FIZZ"
TRY_5   EQ(REMDR(I, 5), 0)              :F(DO_NUM)
FIZZBUZZ = FIZZBUZZ "BUZZ"
DO_NUM  IDENT(FIZZBUZZ, "")             :F(SHOW)
FIZZBUZZ = I
SHOW    OUTPUT = FIZZBUZZ
I = I + 1
LE(I, 100)                      :S(LOOP)
END

## SparForte

As a structured script.

#!/usr/local/bin/spar
pragma annotate( summary, "fizzbuzz" );
pragma annotate( description, "Write a program that prints the numbers from 1 to 100. But for multiples of" );
pragma annotate( description, "three print 'Fizz' instead of the number and for the multiples of five print" );
pragma annotate( description, "'Buzz'. For numbers which are multiples of both three and five print" );
pragma annotate( description, "'FizzBuzz'" );
pragma annotate( see_also, "http://rosettacode.org/wiki/FizzBuzz" );
pragma annotate( author, "Ken O. Burtch" );

pragma restriction( no_external_commands );

procedure fizzbuzz is
begin
for i in 1..100 loop
if i mod 15 = 0 then
? "FizzBuzz";
elsif i mod 5 = 0 then
? "Buzz";
elsif i mod 3 = 0 then
? "Fizz";
else
? i;
end if;
end loop;
end fizzbuzz;

## SQL

Library: SQL

### Oracle SQL

SELECT CASE
WHEN MOD(level,15)=0 THEN 'FizzBuzz'
WHEN MOD(level,3)=0 THEN 'Fizz'
WHEN MOD(level,5)=0 THEN 'Buzz'
ELSE TO_CHAR(level)
END FizzBuzz
FROM dual
CONNECT BY LEVEL <= 100;

Or using Oracle's DECODE and NVL:

SELECT nvl(decode(MOD(level,3),0,'Fizz')||decode(MOD(level,5),0,'Buzz'),level)
FROM dual
CONNECT BY level<=100;

### PostgreSQL specific

SELECT i, fizzbuzz
FROM
(SELECT i,
CASE
WHEN i % 15 = 0 THEN 'FizzBuzz'
WHEN i %  5 = 0 THEN 'Buzz'
WHEN i %  3 = 0 THEN 'Fizz'
ELSE NULL
END AS fizzbuzz
FROM generate_series(1,100) AS i) AS fb
WHERE fizzbuzz IS NOT NULL;

Using Generate_Series and tables only:

SELECT COALESCE(FIZZ || BUZZ, FIZZ, BUZZ, OUTPUT) AS FIZZBUZZ FROM
(SELECT GENERATE_SERIES AS FULL_SERIES, TO_CHAR(GENERATE_SERIES,'99') AS OUTPUT
FROM GENERATE_SERIES(1,100)) F LEFT JOIN
(SELECT TEXT 'Fizz' AS FIZZ, GENERATE_SERIES AS FIZZ_SERIES FROM GENERATE_SERIES(0,100,3)) FIZZ ON
FIZZ.FIZZ_SERIES = F.FULL_SERIES LEFT JOIN
(SELECT TEXT 'Buzz' AS BUZZ, GENERATE_SERIES AS BUZZ_SERIES FROM GENERATE_SERIES(0,100,5)) BUZZ ON
BUZZ.BUZZ_SERIES = F.FULL_SERIES;

### Recursive Common Table Expressions (MSSQL 2005+)

WITH nums (n, fizzbuzz ) AS (
SELECT 1, CONVERT(nvarchar, 1) UNION ALL
SELECT
(n + 1) as n1,
CASE
WHEN (n + 1) % 15 = 0 THEN 'FizzBuzz'
WHEN (n + 1) % 3  = 0 THEN 'Fizz'
WHEN (n + 1) % 5  = 0 THEN 'Buzz'
ELSE CONVERT(nvarchar, (n + 1))
END
FROM nums WHERE n < 100
)
SELECT n, fizzbuzz FROM nums
ORDER BY n ASC
OPTION ( MAXRECURSION 100 )

### SQL Anywhere specific - minimalist

SELECT
isnull(if row_num % 3 = 0 then 'Fizz' endif + if row_num % 5 = 0 then 'Buzz' endif, str(row_num))
FROM
sa_rowgenerator(1,100)

### Generic SQL using a join

This should work in most RDBMSs, but you may need to change MOD(i,divisor) to i % divisor.

-- Load some numbers
CREATE TABLE numbers(i INTEGER);
INSERT INTO numbers VALUES(1);
INSERT INTO numbers SELECT i + (SELECT MAX(i) FROM numbers) FROM numbers;
INSERT INTO numbers SELECT i + (SELECT MAX(i) FROM numbers) FROM numbers;
INSERT INTO numbers SELECT i + (SELECT MAX(i) FROM numbers) FROM numbers;
INSERT INTO numbers SELECT i + (SELECT MAX(i) FROM numbers) FROM numbers;
INSERT INTO numbers SELECT i + (SELECT MAX(i) FROM numbers) FROM numbers;
INSERT INTO numbers SELECT i + (SELECT MAX(i) FROM numbers) FROM numbers;
INSERT INTO numbers SELECT i + (SELECT MAX(i) FROM numbers) FROM numbers;
-- Define the fizzes and buzzes
CREATE TABLE fizzbuzz (message VARCHAR(8), divisor INTEGER);
INSERT INTO fizzbuzz VALUES('fizz',      3);
INSERT INTO fizzbuzz VALUES('buzz',      5);
INSERT INTO fizzbuzz VALUES('fizzbuzz', 15);
-- Play fizzbuzz
SELECT COALESCE(max(message),CAST(i AS VARCHAR(99))) as result
FROM numbers LEFT OUTER JOIN fizzbuzz ON MOD(i,divisor) = 0
GROUP BY i
HAVING i <= 100
ORDER BY i;
-- Tidy up
DROP TABLE fizzbuzz;
DROP TABLE numbers;

## Squirrel

function Fizzbuzz(n) {
for (local i = 1; i <= n; i += 1) {
if (i % 15 == 0)
print ("FizzBuzz\n")
else if (i % 5 == 0)
print ("Buzz\n")
else if (i % 3 == 0)
print ("Fizz\n")
else {
print (i + "\n")
}
}
}
Fizzbuzz(100);

## Stata

program define fizzbuzz
args n
forvalues i = 1/n' {
if mod(i',15) == 0 {
display "FizzBuzz"
}
else if mod(i',5) == 0 {
display "Buzz"
}
else if mod(i',3) == 0 {
display "Fizz"
}
else {
display i'
}
}
end

## Swahili

shughuli fizzBuzz() {
kwa i = 1 mpaka 100 {
kama (i % 15 == 0) {
andika("FizzBuzz")
} au (i % 5 == 0) {
andika("Buzz")
} au (i % 3 == 0) {
andika("Fizz")
} sivyo {
andika(i)
}
}
}

## Swift

### using a switch statement

for i in 1...100 {
switch (i % 3, i % 5) {
case (0, 0):
print("FizzBuzz")
case (0, _):
print("Fizz")
case (_, 0):
print("Buzz")
default:
print(i)
}
}

### using two if statements and an Optional

for i in 1...100{
var s:String?
if i%3==0{s="Fizz"}
if i%5==0{s=(s ?? "")+"Buzz"}
print(s ?? i)
}

### using a precomputed cycle

import Foundation

let formats: [String] = [
"%d",
"%d",
"fizz",
"%d",
"buzz",
"fizz",
"%d",
"%d",
"fizz",
"buzz",
"%d",
"fizz",
"%d",
"%d",
"fizzbuzz",
]

var count = 0
var index = 0
while count < 100 {
count += 1
print(String(format: formats[index], count))
index += 1
index %= 15
}

## Symsyn

| FizzBuzz

1 I
if I LE 100
mod I 3 X
mod I 5 Y
if X EQ 0
'FIZZ' $S if Y EQ 0 + 'BUZZ'$S
endif
else
if Y EQ 0
'BUZZ' $S else ~ I$S
endif
endif
$S [] + I goif endif ## Tailspin templates fizz$ mod 3 -> #
when <=0> do 'Fizz' !
end fizz

templates buzz
$mod 5 -> # when <=0> do 'Buzz' ! end buzz [ 1..100 -> '$->fizz;$->buzz;' ] -> \[i](when <=''> do$i ! otherwise $!\)... -> '$;
' -> !OUT::write

## Tcl

proc fizzbuzz {n {m1 3} {m2 5}} {
for {set i 1} {$i <=$n} {incr i} {
set ans ""
if {$i %$m1 == 0} {append ans Fizz}
if {$i %$m2 == 0} {append ans Buzz}
puts [expr {$ans eq "" ?$i : $ans}] } } fizzbuzz 100 The following example shows Tcl's substitution mechanism that allows to concatenate the results of two successive commands into a string: while {[incr i] < 101} { set fb [if {$i % 3 == 0} {list Fizz}][if {$i % 5 == 0} {list Buzz}] if {$fb ne ""} {puts $fb} {puts$i}
}

This version uses list rotation, so avoiding an explicit mod operation:

set f [lrepeat 5 "Fizz" {$i} {$i}]
foreach i {5 10} {lset f $i "Buzz"};lset f 0 "FizzBuzz" for {set i 1} {$i <= 100} {incr i} {
puts [subst [lindex [set f [list {*}[lassign $f ff]$ff]] 0]]
}

## TI SR-56

Texas Instruments SR-56 Program Listing for "Fizzbuzz"
Display Key Display Key Display Key Display Key
00 22 GTO 25 64 x 50 03 3 75
01 03 3 26 52 ( 51 34 RCL 76
02 07 7 27 52 ( 52 01 1 77
03 53 ) 28 34 RCL 53 59 *pause 78
04 12 INV 29 01 1 54 22 GTO 79
05 29 *Int 30 54 / 55 03 3 80
06 56 *CP 31 05 5 56 08 8 81
07 12 INV 32 57 subr 57 82
08 37 *x=t 33 00 0 58 83
09 01 1 34 03 3 59 84
10 03 3 35 94 = 60 85
11 01 1 36 58 rtn 61 86
12 84 + 37 38 *CMs 62 87
13 00 0 38 01 1 63 88
14 53 ) 39 35 SUM 64 89
15 58 rtn 40 02 2 65 90
16 33 STO 41 34 RCL 66 91
17 01 1 42 02 2 67 92
18 54 / 43 57 subr 68 93
19 03 3 44 01 1 69 94
20 57 subr 45 06 6 70 95
21 00 0 46 93 +/- 71 96
22 03 3 47 12 INV 72 97
23 84 + 48 47 *x>=t 73 98
24 02 2 49 05 5 74 99

Asterisk denotes 2nd function key.

 0: Unused 1: Argument 2: Number 3: Unused 4: Unused 5: Unused 6: Unused 7: Unused 8: Unused 9: Unused

Annotated listing:

// Address 00: Entry point

// Takes a pending division such as ((12/5 and evaluates whether it
// is evenly divisible.
// Result 1: evenly divisible, 0: not divisible

)              // Complete the pending division
INV *Int       // Take the fractional part
*CP            // RegT := 0
INV *x=t 1 3   // If fractional part is zero, don't increment
1 +            // Start a pending increment of the return value
0 ) rtn        // Return the return value

// Takes a number and evaluates whether it is divisible by 3 and 5.
// Result:  0=indivisible, 1=fizz, 2=buzz, 3=fizzbuzz

STO 1                    // Save subroutine argument
/ 3   subr 0 3           // 1 if fizz else 0
+ 2 x                    // Buzz is worth 2x as much as Fizz
( ( RCL 1 / 5 subr 0 3   // 1 if buzz else 0
=                        // Finish the pending + and x
rtn                      // Return result

*CMs            // Zero out registers
1 SUM 2         // Number += 1
RCL 2           // Retrieve Number
subr 1 6        // Evaluate whether it is divisible by 3 and 5
+/-             // Negate (0=indiv., -1=fizz, -2=buzz, -3=fizzbuzz)
INV *x>=t 5 3   // If negative, skip the next line.
RCL 1           // Retrieve number instead of zero.
*pause          // Flash the number on the display
GTO 3 8         // Loop

Usage:

Press RST R/S to start the program. Increasing numbers will flash on the screen. Positive numbers represent themselves; -1 means fizz, -2 buzz and -3 fizzbuzz. About 25 numbers are calculated per minute.

## TransFORTH

: FIZZBUZZ
101 1 DO
I 15 MOD 0 = IF
PRINT " FIZZBUZZ "
ELSE I 3 MOD 0 = IF
PRINT " FIZZ "
ELSE I 5 MOD 0 = IF
PRINT " BUZZ "
ELSE I . THEN THEN THEN
CR LOOP ;

## Turing

for i : 1 .. 100
if i mod 15 = 0 then
put "Fizzbuzz"
elsif i mod 5 = 0 then
put "Buzz"
elsif i mod 3 = 0 then
put "Fizz"
else
put i
end if
end for

## TUSCRIPT

 MODE TUSCRIPT
LOOP n=1,100
mod=MOD (n,15)
SELECT mod
CASE 0
PRINT n," FizzBuzz"
CASE 3,6,9,12
PRINT n," Fizz"
CASE 5,10
PRINT n," Buzz"
DEFAULT
PRINT n
ENDSELECT
ENDLOOP

$txr -p "(mapcar (op if @1 @1 @2) (repeat '(nil nil fizz nil buzz fizz nil nil fizz buzz nil fizz nil nil fizzbuzz)) (range 1 100))" ## UNIX Shell This solution should work with any Bourne-compatible shell: i=1 while expr$i '<=' 100 >/dev/null; do
w=false
expr $i % 3 = 0 >/dev/null && { printf Fizz; w=true; } expr$i % 5 = 0 >/dev/null && { printf Buzz; w=true; }
if $w; then echo; else echo$i; fi
i=expr $i + 1 done ### Versions for specific shells The other solutions work with fewer shells. The next solution requires $(( )) arithmetic expansion, and it should work with every POSIX shell.

n=1
while [ 100 -ge n ]; do
if [ $((n % 15)) -eq 0 ]; then echo FizzBuzz elif [$((n % 3)) -eq 0 ]; then
echo Fizz
elif [ $((n % 5)) -eq 0 ]; then echo Buzz else echo$n
fi
n=$((n + 1)) done The next solution requires the (( )) command from the Korn Shell. Works with: pdksh version 5.2.14 NUM=1 until ((NUM == 101)) ; do if ((NUM % 15 == 0)) ; then echo FizzBuzz elif ((NUM % 3 == 0)) ; then echo Fizz elif ((NUM % 5 == 0)) ; then echo Buzz else echo "$NUM"
fi
((NUM = NUM + 1))
done

A version using concatenation:

Works with: bash version 3
for ((n=1; n<=100; n++))
do
fb=''
[ $(( n % 3 )) -eq 0 ] && fb="${fb}Fizz"
[ $(( n % 5 )) -eq 0 ] && fb="${fb}Buzz"
[ -n "${fb}" ] && echo "${fb}" || echo "$n" done A version using some of the insane overkill of Bash 4: Works with: bash version 4 command_not_found_handle () { local Fizz=3 Buzz=5 [$(( $2 %$1 )) -eq 0 ] && echo -n $1 && [${!1} -eq 3 ]
}

for i in {1..100}
do
Fizz $i && ! Buzz$i || echo -n $i echo done Bash one-liner: for i in {1..100};do ((($i%15==0))&& echo FizzBuzz)||((($i%5==0))&& echo Buzz;)||((($i%3==0))&& echo Fizz;)||echo $i;done ### C Shell @ n = 1 while ($n <= 100 )
if ($n % 15 == 0) then echo FizzBuzz else if ($n % 5 == 0) then
echo Buzz
else if ($n % 3 == 0) then echo Fizz else echo$n
endif
@ n += 1
end

## Uiua

⟨&p|&p"Fizz"|&p"Buzz"|&p"Fizzbuzz"⟩°⋯⍉=0⊞◿3_5.+1⇡100

## Ursa

#
# fizzbuzz
#
decl int i
for (set i 1) (< i 101) (inc i)
if (= (mod i 3) 0)
out "fizz" console
end if
if (= (mod i 5) 0)
out "buzz" console
end if
if (not (or (= (mod i 3) 0) (= (mod i 5) 0)))
out i console
end if
out endl console
end for

## Ursala

#import std
#import nat

fizzbuzz = ^T(&&'Fizz'! not remainder\3,&&'Buzz'! not remainder\5)|| ~&h+ %nP

#show+

main = fizzbuzz*t iota 101

## V

[fizzbuzz
1 [>=] [
[[15 % zero?] ['fizzbuzz' puts]
[5 % zero?]  ['buzz' puts]
[3 % zero?]  ['fizz' puts]
[true] [dup puts]
] when succ
] while].
|100 fizzbuzz

### Second try

(a compiler for fizzbuzz)

define a command that will generate a sequence

[seq [] swap dup [zero? not] [rolldown [dup] dip cons rollup pred] while pop pop].

create a quote that will return a quote that returns a quote if its argument is an integer (A HOF)

[check [N X F : [[integer?] [[X % zero?] [N F cons] if] if]] view].

Create a quote that will make sure that the above quote is applied correctly if given (Number Function) as arguments.

[func [[N F] : [dup N F check i] ] view map].

And apply it

100 seq [
[15 [pop 'fizzbuzz' puts]]
[5  [pop 'buzz' puts]]
[3  [pop 'fizz' puts]]
[1  [puts]]] [func dup] step
[i true] map pop

the first one is much better :)

## Vala

int main() {
for (int i = 1; i <= 100; i++) {
if (i % 3 == 0) stdout.printf("Fizz\n");
if (i % 5 == 0) stdout.printf("Buzz\n");
if (i % 15 == 0) stdout.printf("FizzBuzz\n");
if (i % 3 != 0 && i % 5 != 0) stdout.printf("%d\n", i);

}
return 0;;
}

## Vale

Works with: Vale version 0.2.0
import stdlib.*;

exported func main(){
fizzBuzz(1, 100);
}

func fizzBuzz(i int, stop int) {
result = if i.mod(3) == 0 {
"Fizz" } else { ""
} + if i.mod(5) == 0 {
"Buzz" } else { ""
};

println(if result == "" { i.str() } else { result });

if i < stop {
return fizzBuzz(i + 1, stop);
}
}

## VAX Assembly

                           00000008  0000     1 len	=8
00000008  0000     2 msg:	.blkb	len			;output buffer
0000000C  0008     3 desc:	.blkl	1			;descriptor lenght field
00000000' 000C     4 	.address msg			;pointer to buffer
00000012  0010     5 outlen:	.blkw	1
4C 55 21 0000001A'010E0000' 0012     6 ctr:	.ascid	"!UL"
001D     7
0000  001D     8 .entry	start,0
52   7C  001F     9 	clrq	r2			;r2+r3 64bit
52   D6  0021    10 	incl	r2			;start index 1
0023    11 loop:
E2 AF   B4  0023    12 	clrw	desc			;assume not fizz and or buzz
55   D7 AF   9E  0026    13 	movab	msg, r5			;pointer to message buffer
54   50   52   03   7B  002A    14 	ediv	#3,r2,r0,r4		;divr.rl,divd.rq,quo.wl,rem.wl
54   D5  002F    15 	tstl	r4			;remainder
0B   12  0031    16 	bneq	not_fizz		;not equal zero
0033    17
85   7A7A6966 8F   D0  0033    18 	movl	#^a"fizz", (r5)+	;add to message
CA AF   04   A0  003A    19 	addw2	#4, desc		;and update length
003E    20 not_fizz:
54   50   52   05   7B  003E    21 	ediv	#5,r2,r0,r4
54   D5  0043    22 	tstl	r4
0B   12  0045    23 	bneq	not_buzz
0047    24
85   7A7A7562 8F   D0  0047    25 	movl	#^a"buzz", (r5)+
B6 AF   04   A0  004E    26 	addw2	#4, desc
0052    27 not_buzz:
B3 AF   B5  0052    28 	tstw	desc			;fizz and or buzz?
1B   12  0055    29 	bneq	show_buffer		;neq - yes
0057    30
AD AF   08   B0  0057    31 	movw	#len, desc		;fao length limit
005B    32 	$fao_s - ;eql -no 005B 33 ctrstr = ctr, - ;show number 005B 34 outlen = outlen, - 005B 35 outbuf = desc, - 005B 36 p1 = r2 96 AF A0 AF B0 006D 37 movw outlen, desc ;characters filled by fao 0072 38 show_buffer: 93 AF 7F 0072 39 pushaq desc 00000000'GF 01 FB 0075 40 calls #1, g^lib$put_output
9F 52   00000064 8F   F3  007C    41 	AOBLEQ	#100,r2,loop		;limit.rl, index.ml
04  0084    42 	ret
0085    43 .end	start

## VBA

Option Explicit

Sub FizzBuzz()
Dim Tb(1 To 100) As Variant
Dim i As Integer
For i = 1 To 100
'Tb(i) = i ' move to Else
If i Mod 15 = 0 Then
Tb(i) = "FizzBuzz"
ElseIf i Mod 5 = 0 Then
Tb(i) = "Buzz"
ElseIf i Mod 3 = 0 Then
Tb(i) = "Fizz"
Else
Tb(i) = i
End If
Next
Debug.Print Join(Tb, vbCrLf)
End Sub

As an alternative, testing each number only once:

Sub FizzBuzz()
Dim i As Integer
Dim T(1 To 99) As Variant
For i = 1 To 99 Step 3
T(i + 0) = IIf((i + 0) Mod 5 = 0, "Buzz", i)
T(i + 1) = IIf((i + 1) Mod 5 = 0, "Buzz", i + 1)
T(i + 2) = IIf((i + 2) Mod 5 = 0, "FizzBuzz", "Fizz")
Next i
Debug.Print Join(T, ", ") & ", Buzz"
End Sub

## VBScript

Works with: Windows Script Host version *
For i = 1 To 100
If i Mod 15 = 0 Then
WScript.Echo "FizzBuzz"
ElseIf i Mod 5 = 0 Then
WScript.Echo "Buzz"
ElseIf i Mod 3 = 0 Then
WScript.Echo "Fizz"
Else
WScript.Echo i
End If
Next
##### An Alternative
Works with: Windows Script Host version *
With WScript.StdOut
For i = 1 To 100
If i Mod 3 = 0 Then .Write "Fizz"
If i Mod 5 = 0 Then .Write "Buzz"
If .Column = 1 Then .WriteLine i Else .WriteLine ""
Next
End With

## Verbexx

@LOOP init:{@VAR t3 t5; @VAR i = 1} while:(i <= 100) next:{i++}
{
t3 = (i % 3 == 0);
t5 = (i % 5 == 0);

@SAY ( @CASE when:(t3 && t5) { 'FizzBuzz }
when: t3        { 'Fizz     }
when: t5        { 'Buzz     }
else:           { i         }
);
};

## Verilog

module main;
integer  number;

initial begin

for(number = 1; number < 100; number = number + 1) begin
if (number % 15 == 0) $display("FizzBuzz"); else begin if(number % 3 == 0)$display("Fizz");
else begin
if(number % 5 == 0) $display("Buzz"); else$display(number);
end
end
end
$finish; end endmodule ## VHDL entity fizzbuzz is end entity fizzbuzz; architecture beh of fizzbuzz is procedure fizzbuzz(num : natural) is begin if num mod 15 = 0 then report "FIZZBUZZ"; elsif num mod 3 = 0 then report "FIZZ"; elsif num mod 5 = 0 then report "BUZZ"; else report to_string(num); end if; end procedure fizzbuzz; begin p_fizz : process is begin for i in 1 to 100 loop fizzbuzz(i); end loop; wait for 200 us; end process p_fizz; end architecture beh; ## Vim Script for i in range(1, 100) if i % 15 == 0 echo "FizzBuzz" elseif i % 5 == 0 echo "Buzz" elseif i % 3 == 0 echo "Fizz" else echo i endif endfor ## Visual Basic .NET ## Visual Prolog implement main open core, console class predicates fizzbuzz : (integer) -> string procedure (i). clauses fizzbuzz(X) = S :- X mod 15 = 0, S = "FizzBuzz", !. fizzbuzz(X) = S :- X mod 5 = 0, S = "Buzz", !. fizzbuzz(X) = S :- X mod 3 = 0, S = "Fizz", !. fizzbuzz(X) = S :- S = toString(X). run() :- foreach X = std::fromTo(1,100) do write(fizzbuzz(X)), write("\n") end foreach, succeed. end implement main goal console::runUtf8(main::run). ## V (Vlang) Updated for V (Vlang) version 0.2.2 const ( fizz = Tuple{true, false} buzz = Tuple{false, true} fizzbuzz = Tuple{true, true} ) struct Tuple{ val1 bool val2 bool } fn fizz_or_buzz( val int ) Tuple { return Tuple{ val % 3 == 0, val % 5 == 0 } } fn fizzbuzz( n int ) { for i in 1..(n + 1) { match fizz_or_buzz(i) { fizz { println('Fizz') } buzz { println('Buzz') } fizzbuzz { println('FizzBuzz') } else { println(i) } } } } fn main(){ fizzbuzz(15) } Output: 1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz  Basic example with a for loop and match: fn main() { mut i := 1 for i <= 100 { match true { i % 15 == 0 { println('FizzBuzz') } i % 3 == 0 { println('Fizz') } i % 5 == 0 { println('Buzz') } else { println(i) } } i++ } } Another basic example using the ubiquitous if/else (if) statement: fn main() { for i in 1..100 { if i % 15 == 0 { println('FizzBuzz') } else if i % 3 == 0 { println('Fizz') } else if i % 5 == 0 { println('Buzz') } else { println(i) } } } Output: 1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17 Fizz 19 Buzz Fizz 22 23 Fizz Buzz 26 Fizz 28 29 FizzBuzz 31 32 Fizz 34 Buzz Fizz 37 38 Fizz Buzz 41 Fizz 43 44 FizzBuzz 46 47 Fizz 49 Buzz Fizz 52 53 Fizz Buzz 56 Fizz 58 59 FizzBuzz 61 62 Fizz 64 Buzz Fizz 67 68 Fizz Buzz 71 Fizz 73 74 FizzBuzz 76 77 Fizz 79 Buzz Fizz 82 83 Fizz Buzz 86 Fizz 88 89 FizzBuzz 91 92 Fizz 94 Buzz Fizz 97 98 Fizz Buzz  ## VTL-2 10 N=1 20 #=30 30 #=N/3*0+%=0*110 40 #=N/5*0+%=0*130 50 #=!+30 60 ?=N 70 ?="" 80 N=N+1 90 #=100>N*20 100 #=999 110 ?="Fizz"; 120 #=! 130 ?="Buzz"; 140 #=! 180 #=70 ## Wart for i 1 (i <= 100) ++i prn (if (divides i 15) "FizzBuzz" (divides i 3) "Fizz" (divides i 5) "Buzz" :else i) ## WDTE let io => import 'io'; let s => import 'stream'; let multiple of n => == (% n of) 0; let fizzbuzz n => switch n { multiple (* 3 5) => 'FizzBuzz'; multiple 3 => 'Fizz'; multiple 5 => 'Buzz'; default => n; } -- io.writeln io.stdout; s.range 1 101 -> s.map fizzbuzz -> s.drain; ## Whitespace ## Wortel @each &x!console.log x !*&x?{%%x 15 "FizzBuzz" %%x 5 "Buzz" %%x 3 "Fizz" x} @to 100 ## Wren for (i in 1..100) { if (i % 15 == 0) { System.print("FizzBuzz") } else if (i % 3 == 0) { System.print("Fizz") } else if (i % 5 == 0) { System.print("Buzz") } else { System.print(i) } } Output: 1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17 Fizz 19 Buzz Fizz 22 23 Fizz Buzz 26 Fizz 28 29 FizzBuzz 31 32 Fizz 34 Buzz Fizz 37 38 Fizz Buzz 41 Fizz 43 44 FizzBuzz 46 47 Fizz 49 Buzz Fizz 52 53 Fizz Buzz 56 Fizz 58 59 FizzBuzz 61 62 Fizz 64 Buzz Fizz 67 68 Fizz Buzz 71 Fizz 73 74 FizzBuzz 76 77 Fizz 79 Buzz Fizz 82 83 Fizz Buzz 86 Fizz 88 89 FizzBuzz 91 92 Fizz 94 Buzz Fizz 97 98 Fizz Buzz  ## X86 Assembly ; x86_64 linux nasm section .bss number resb 4 section .data fizz: db "Fizz" buzz: db "Buzz" newLine: db 10 section .text global _start _start: mov rax, 1 ; initialize counter loop: push rax call fizzBuzz pop rax inc rax cmp rax, 100 jle loop mov rax, 60 mov rdi, 0 syscall fizzBuzz: mov r10, rax mov r15, 0 ; boolean fizz or buzz checkFizz: xor rdx, rdx ; clear rdx for division mov rbx, 3 div rbx cmp rdx, 0 ; modulo result here jne checkBuzz mov r15, 1 mov rsi, fizz mov rdx, 4 mov rax, 1 mov rdi, 1 syscall checkBuzz: mov rax, r10 xor rdx, rdx mov rbx, 5 div rbx cmp rdx, 0 jne finishLine mov r15, 1 mov rsi, buzz mov rdx, 4 mov rax, 1 mov rdi, 1 syscall finishLine: ; print number if no fizz or buzz cmp r15, 1 je nextLine mov rax, r10 call printNum ret nextLine: mov rsi, newLine mov rdx, 1 mov rax, 1 mov rdi, 1 syscall ret printNum: ; write proper digits into number buffer cmp rax, 100 jl lessThanHundred mov byte [number], 49 mov byte [number + 1], 48 mov byte [number + 2], 48 mov rdx, 3 jmp print lessThanHundred: ; get digits to write through division xor rdx, rdx mov rbx, 10 div rbx add rdx, 48 cmp rax, 0 je lessThanTen add rax, 48 mov byte [number], al mov byte [number + 1], dl mov rdx, 2 jmp print lessThanTen: mov byte [number], dl mov rdx, 1 print: mov byte [number + rdx], 10 ; add newline inc rdx mov rax, 1 mov rdi, 1 mov rsi, number syscall ret ## XBasic ## XLISP (defun fizzbuzz () (defun fizzb (x y) (display (cond ((= (mod x 3) (mod x 5) 0) "FizzBuzz") ((= (mod x 3) 0) "Fizz") ((= (mod x 5) 0) "Buzz") (t x))) (newline) (if (< x y) (fizzb (+ x 1) y))) (fizzb 1 100)) (fizzbuzz) ## XMIDAS startmacro loop 100 count calc/quiet three ^count 3 modulo calc/quiet five ^count 5 modulo if ^three eq 0 and ^five eq 0 say "fizzbuzz" elseif ^three eq 0 say "fizz" elseif ^five eq 0 say "buzz" else say ^count endif endloop endmacro ## Xojo  For i As Integer = 1 To 100 If i Mod 3 = 0 And i Mod 5 = 0 Then Print("FizzBuzz") ElseIf i Mod 3 = 0 Then Print("Fizz") ElseIf i Mod 5 = 0 Then Print("Buzz") Else Print(Str(i)) End If Next An alternative syntax:  For i As Integer = 1 To 100 Select Case True Case i Mod 3 = 0 And i Mod 5 = 0 Print("FizzBuzz") Case i Mod 3 = 0 Print("Fizz") Case i Mod 5 = 0 Print("Buzz") Else Print(Str(i)) End Select Next ## XPath 2.0 for$n in 1 to 100 return
concat('fizz'[not($n mod 3)], 'buzz'[not($n mod 5)], $n[$n mod 15 = (1,2,4,7,8,11,13,14)])

...or alternatively...

for $n in 1 to 100 return ($n, 'Fizz', 'Buzz', 'FizzBuzz')[number(($n mod 3) = 0) + number(($n mod 5) = 0)*2 + 1]

## XPL0

code CrLf=9, IntOut=11, Text=12;
int     N;
[for N:= 1 to 100 do
[if rem(N/3)=0 then Text(0,"Fizz");
if rem(N/5)=0 then Text(0,"Buzz")
else if rem(N/3)#0 then IntOut(0,N);
CrLf(0);
];
]
Output:
1
2
Fizz
4
Buzz
Fizz
7
...
89
FizzBuzz
91
92
Fizz
94
Buzz
Fizz
97
98
Fizz
Buzz


## XSLT

### XSLT 1.0

Works with: xsltproc version libxslt 10126
<?xml version="1.0" encoding="utf-8" ?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:output method="text" encoding="utf-8"/>

<!-- Outputs a line for a single FizzBuzz iteration. -->
<xsl:template name="fizzbuzz-single">
<xsl:param name="n"/>

<!-- $s will be "", "Fizz", "Buzz", or "FizzBuzz". --> <xsl:variable name="s"> <xsl:if test="$n mod 3 = 0">Fizz</xsl:if>
<xsl:if test="$n mod 5 = 0">Buzz</xsl:if> </xsl:variable> <!-- Output$s. If $s is blank, also output$n. -->
<xsl:value-of select="$s"/> <xsl:if test="$s = ''">
<xsl:value-of select="$n"/> </xsl:if> <!-- End line. --> <xsl:value-of select="'&#10;'"/> </xsl:template> <!-- Calls fizzbuzz-single over each value in a range. --> <xsl:template name="fizzbuzz-range"> <!-- Default parameters: From 1 through 100 --> <xsl:param name="startAt" select="1"/> <xsl:param name="endAt" select="$startAt + 99"/>

<!-- Simulate a loop with tail recursion. -->

<!-- Loop condition -->
<xsl:if test="$startAt &lt;=$endAt">
<!-- Loop body -->
<xsl:call-template name="fizzbuzz-single">
<xsl:with-param name="n" select="$startAt"/> </xsl:call-template> <!-- Increment counter, repeat --> <xsl:call-template name="fizzbuzz-range"> <xsl:with-param name="startAt" select="$startAt + 1"/>
<xsl:with-param name="endAt" select="$endAt"/> </xsl:call-template> </xsl:if> </xsl:template> <!-- Main procedure --> <xsl:template match="/"> <!-- Default parameters are used --> <xsl:call-template name="fizzbuzz-range"/> </xsl:template> </xsl:stylesheet> ### XSLT 1.0 With EXSLT <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:exsl="http://exslt.org/common" exclude-result-prefixes="xsl exsl"> <xsl:output method="text"/> <xsl:template name="FizzBuzz" match="/"> <xsl:param name="n" select="1" /> <xsl:variable name="_"> <_><xsl:value-of select="$n" /></_>
</xsl:variable>
<xsl:apply-templates select="exsl:node-set($_)/_" /> <xsl:if test="$n < 100">
<xsl:call-template name="FizzBuzz">
<xsl:with-param name="n" select="$n + 1" /> </xsl:call-template> </xsl:if> </xsl:template> <xsl:template match="_[. mod 3 = 0]">Fizz </xsl:template> <xsl:template match="_[. mod 5 = 0]">Buzz </xsl:template> <xsl:template match="_[. mod 15 = 0]" priority="1">FizzBuzz </xsl:template> <xsl:template match="_"> <xsl:value-of select="concat(.,'&#x0A;')" /> </xsl:template> </xsl:stylesheet> ### XSLT 2.0 <xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> <xsl:output method="text"/> <xsl:template match="/"> <xsl:value-of separator="&#x0A;" select=" for$n in 1 to 100 return
concat('fizz'[not($n mod 3)], 'buzz'[not($n mod 5)], $n[$n mod 15 = (1,2,4,7,8,11,13,14)])"/>
</xsl:template>

</xsl:stylesheet>

## YAMLScript

#!/usr/bin/env ys-0

# This program has multiple implementations of "fizzbuzz".

# usage: yamlscript fizzbuzz.ys [<count>] [<fizzbuzz-fn-#>]

# The main function runs a certain requested fizzbuzz implementation function
# for a certain requested number (default is 100).

defn main(count=100 impl=1):
fizzbuzz =: "fizzbuzz-$impl" when-not ENV.'YS_TEST': say: "Running function '$fizzbuzz' with count=$count" function =: resolve(fizzbuzz.symbol()) result =: function(count) mapv say: result # These implementation functions were adapted from # https://rosettacode.org/wiki/FizzBuzz#Clojure defn fizzbuzz-1(n): map: fn(x): cond: zero?(x % 15): 'FizzBuzz' zero?(x % 5): 'Buzz' zero?(x % 3): 'Fizz' =>: x =>: 1 .. n defn fizzbuzz-2(n): loop [i 1, l []]: if (i > n): =>: l recur inc(i): conj l: cond: zero?(i % 15): 'FizzBuzz' zero?(i % 5): 'Buzz' zero?(i % 3): 'Fizz' =>: i defn fizzbuzz-3(n): map: fn(x): s =: str: when zero?(x % 3): 'Fizz' =>: (zero?(x % 5) && 'Buzz') || nil if empty?(s): x s rng: 1 n Output: $ ys sample/fizzbuzz.ys 16 2
Running function 'fizzbuzz-2' with count=16
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
16


## Yorick

### Iterative solution

for(i = 1; i <= 100; i++) {
if(i % 3 == 0)
write, format="%s", "Fizz";
if(i % 5 == 0)
write, format="%s", "Buzz";
if(i % 3 && i % 5)
write, format="%d", i;
write, "";
}

### Vectorized solution

output = swrite(format="%d", indgen(100));
output(3::3) = "Fizz";
output(5::5) = "Buzz";
output(15::15) = "FizzBuzz";
write, format="%s\n", output;

## Zig

const print = @import("std").debug.print;
pub fn main() void {
var i: usize = 1;
while (i <= 100) : (i += 1) {
if (i % 3 == 0 and i % 5 == 0) {
print("FizzBuzz\n", .{});
} else if (i % 3 == 0) {
print("Fizz\n", .{});
} else if (i % 5 == 0) {
print("Buzz\n", .{});
} else {
print("{}\n", .{i});
}
}
}

## zkl

foreach n in ([1..100]) {
if(n % 3 == 0) print("Fizz");
if(not (n%5)) "Buzz".print();
if(n%3 and n%5) print(n);
println();
}

Or, using infinite lazy sequences:

fcn f(a,b,c){ a+b and a+b or c }
Walker.cycle("","","Fizz").zipWith(f,Walker.cycle("","","","","Buzz"),[1..])
.walk(100).concat("\n").println();

More of the same:

Walker.cycle(0,0,"Fizz",0,"Buzz","Fizz",0,0,"Fizz","Buzz",0,"Fizz",0,0,"FizzBuzz")
.zipWith(fcn(a,b){ a or b },[1..]).walk(100).concat("\n").println();
Output:
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
...


## ZX Spectrum Basic

Translation of: Applesoft BASIC
10 DEF FN m(a,b)=a-INT (a/b)*b
20 FOR a=1 TO 100
30 LET o$="" 40 IF FN m(a,3)=0 THEN LET o$="Fizz"
50 IF FN m(a,5)=0 THEN LET o$=o$+"Buzz"
60 IF o$="" THEN LET o$=STR$a 70 PRINT o$
80 NEXT a`