FizzBuzz

FizzBuzz is a programming puzzle. It lays out a problem which Rosetta Code users are encouraged to solve, using languages and techniques they know. Multiple approaches are not discouraged, so long as the puzzle guidelines are followed. For other Puzzles, see Category:Puzzles.

Write a program that prints the numbers from 1 to 100. But for multiples of three print "Fizz" instead of the number and for the multiples of five print "Buzz". For numbers which are multiples of both three and five print "FizzBuzz". [1]

FizzBuzz was presented as the lowest level of comprehension required to illustrate adequacy. [2]

Ada

<lang ada>with Ada.Text_IO; use Ada.Text_IO;

procedure Fizzbuzz is begin

  for I in 1..100 loop
     if I mod 15 = 0 then
        Put_Line("FizzBuzz");
     elsif I mod 5 = 0 then
        Put_Line("Buzz");
     elsif I mod 3 = 0 then
        Put_Line("Fizz");
     else
        Put_Line(Integer'Image(I));
     end if;
  end loop;

end Fizzbuzz;</lang>

ALGOL 68

<lang algol68>main:(

 FOR i TO 100 DO
   printf(($gl$,
     IF i %* 15 = 0 THEN
       "FizzBuzz"
     ELIF i %* 3 = 0 THEN
       "Fizz"
     ELIF i %* 5 = 0 THEN
       "Buzz"
     ELSE
       i
     FI
   ))
 OD

)</lang> or simply: <lang algol68>FOR i TO 100 DO print(((i%*15=0|"FizzBuzz"|:i%*3=0|"Fizz"|:i%*5=0|"Buzz"|i),new line)) OD</lang>

APL

     ⎕IO←0
     (L,'Fizz' 'Buzz' 'FizzBuzz')[¯1+(L×W=0)+W←(100×~0=W)+W←⊃+/1 2×0=3 5|⊂L←1+⍳100]

AutoHotkey

Search autohotkey.com: [3]
<lang AutoHotkey> Loop, 100 {

 If (Mod(A_Index, 15) = 0)
   output .= "FizzBuzz`n"
 Else If (Mod(A_Index, 3) = 0)
   output .= "Fizz`n"
 Else If (Mod(A_Index, 5) = 0)
   output .= "Buzz`n"
 Else
   output .= "`n"

} FileDelete, output.txt FileAppend, %output%, output.txt Run, cmd /k type output.txt </lang>

AWK

<lang AWK>BEGIN {

  for (NUM=1; NUM<=100; NUM++)
      if (NUM % 15 == 0)
          {print "FizzBuzz"}
      else if (NUM % 3 == 0)
          {print "Fizz"}
      else if (NUM % 5 == 0)
          {print "Buzz"}
      else
          {print NUM}

}</lang>

BASIC

Works with: QuickBasic version 4.5

If/else ladder approach

<lang qbasic>FOR A = 1 TO 100

  IF A MOD 15 = 0 THEN
     PRINT "FizzBuzz"
  ELSE IF A MOD 3 = 0 THEN
     PRINT "Fizz"
  ELSE IF A MOD 5 = 0 THEN
     PRINT "Buzz"
  ELSE
     PRINT A
  END IF

NEXT A</lang>

Concatenation approach

<lang qbasic>FOR A = 1 TO 100

  OUT$ = ""

  IF A MOD 3 = 0 THEN 
     OUT$ = "Fizz"
  END IF

  IF A MOD 5 = 0 THEN
     OUT$ = OUT$ + "Buzz"
  END IF
  
  IF OUT$ = "" THEN
     OUT$ = STR$(A)
  END IF

  PRINT OUT$

NEXT A</lang>

See also: RapidQ

C

<lang c>#include<stdio.h>

int main (void) {

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

}</lang>

C++

<lang cpp>#include <iostream>

using namespace std; int main () {

      int i;
      for (i = 0; i <= 100; i++) {
              if ((i % 15) == 0)
                      cout << "FizzBuzz" << endl;
              else if ((i % 3) == 0)
                      cout << "Fizz" << endl;
              else if ((i % 5) == 0)
                      cout << "Buzz" << endl;
              else
                      cout << i << endl;
      }
      return 0;

}</lang>

Alternate version not using modulo 15: <lang cpp>#include <iostream> using namespace std;

int main() {

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

}</lang>

Version computing FizzBuzz at compile time with metaprogramming: <lang cpp>

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

} </lang>

C#

<lang csharp> using System;

namespace RosettaCode.FizzBuzz {

   class Program
   {
       static void Main(string[] args)
       {
           for (int i = 1; i <= 100; i++)
           {
               string output = "";
               if (i % 3 == 0) output += "Fizz";
               if (i % 5 == 0) output += "Buzz";
               if (String.IsNullOrEmpty(output)) output = i.ToString();
               Console.WriteLine(output);
           }
       }
   }

} </lang>

Clojure

<lang lisp>(map (fn [x] (cond (zero? (mod x 15)) "FizzBuzz" (zero? (mod x 5)) "Buzz" (zero? (mod x 3)) "Fizz" :else x))

    (range 1 101))</lang>

Common Lisp

<lang lisp>(defun fizzbuzz ()

 (loop for x from 1 to 100 do
   (print (cond ((zerop (mod x 15)) "FizzBuzz")
                ((zerop (mod x 3))  "Fizz")
                ((zerop (mod x 5))  "Buzz")
                (t                  x)))))
(defun fizzbuzz ()
 (loop for x from 1 to 100 do
   (format t "~&~{~A~}"
     (or (append (when (zerop (mod x 3)) '("Fizz"))
                 (when (zerop (mod x 5)) '("Buzz")))
         (list x)))))</lang>

D

<lang d>module fizzbuzz; import std.stdio; import std.string ;

// if-else void fizzBuzz(int n) {

 for(int i = 1 ; i <= n; i++)
   if (!(i%15))
     writef("FizzBuzz") ;
   else if (!(i%3))
     writef("Fizz") ;
   else if (!(i%5))
     writef("Buzz") ;
   else
     writef(i) ;
 writefln() ;

}

// use switch case void fizzBuzz_s(int n) {

 for(int i = 1 ; i <= n; i++)
   switch(i%15) {
     case 0:
       writef("FizzBuzz") ; break ;        
     case 3,6,9,12:
       writef("Fizz") ; break ;
     case 5,10:
       writef("Buzz") ; break ;
     default:
       writef(i) ;
   }
 writefln() ;

}

// recursive with concatenation string fizzBuzz_r(int n){

 string s = "" ;
 if (n == 0)
   return s ;
 if(!(n % 5))
   s = "Buzz"~ s ;
 if(!(n % 3))
   s = "Fizz" ~ s ;
 if (s == "")
   s = toString(n) ;   
 return fizzBuzz_r(n-1) ~  s ;

}

// alternative recursive string fizzBuzz_r2(int n){

 return (n>0) ? fizzBuzz_r2(n-1) ~ 
   (n % 15 ? n % 5 ? n % 3 ? toString(n) :"Fizz" : "Buzz" : "FizzBuzz") 
              : "";

}

void main() {

 fizzBuzz(100) ;
 fizzBuzz_s(100) ;
 writefln(fizzBuzz_r(100)) ;
 writefln(fizzBuzz_r2(100)) ;
 for(int i = 1 ; i <= 100;i++)
 writef("%s", i % 15 ? i % 5 ? i % 3 ? toString(i) :"Fizz" : "Buzz" : "FizzBuzz") ;

}</lang>

E

<lang e>for i in 1..100 {

  println(switch ([i % 3, i % 5]) {
    match [==0, ==0] { "FizzBuzz" }
    match [==0, _  ] { "Fizz" }
    match [_,   ==0] { "Buzz" }
    match _          { i }
  })
}</lang>

Erlang

<lang erlang> fizzbuzz() ->

   F = fun(N) when N rem 15 == 0 -> "FizzBuzz";
          (N) when N rem 3 == 0  -> "Fizz";
          (N) when N rem 5 == 0  -> "Buzz";
          (N) -> integer_to_list(N)
       end,
   [F(N)++"\n" || N <- lists:seq(1,100)].

</lang>

Factor

<lang factor>USING: math kernel io math.ranges ; IN: fizzbuzz

divides? ( m n -- ? ) mod 0 = ;

fizz ( n -- str ) 3 divides? "Fizz" "" ? ;

buzz ( n -- str ) 5 divides? "Buzz" "" ? ;

fizzbuzz ( n -- str ) dup [ fizz ] [ buzz ] bi append [ number>string ] [ nip ] if-empty ;

main ( -- ) 100 [1,b] [ fizzbuzz print ] each ;

MAIN: main</lang>

Forth

table-driven

<lang forth>: fizz ( n -- ) drop ." Fizz" ;

buzz ( n -- ) drop ." Buzz" ;

fb ( n -- ) drop ." FizzBuzz" ;

vector create does> ( n -- )

 over 15 mod cells + @ execute ;

vector .fizzbuzz

 ' fb   , ' . ,    ' . ,
 ' fizz , ' . ,    ' buzz ,
 ' fizz , ' . ,    ' . ,
 ' fizz , ' buzz , ' . ,
 ' fizz , ' . ,    ' . ,</lang>

or the classic approach

<lang forth>: .fizzbuzz ( n -- )

 0 pad c!
 dup 3 mod 0= if s" Fizz" pad  place then
 dup 5 mod 0= if s" Buzz" pad +place then
 pad c@ if drop pad count type else . then ;

zz ( n -- )

 1+ 1 do i .fizzbuzz cr loop ;

100 zz</lang>

Fortran

In ANSI FORTRAN 66 or later use structured IF-THEN-ELSE (example uses some ISO Fortran 90 features): <lang fortran> program fizzbuzz_if

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

In ISO Fortran 90 or later use SELECT-CASE statement: <lang fortran> program fizzbuzz_select

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

</lang>

Groovy

<lang groovy>for (i in 1..100) {

 println "${i%3?:'Fizz'}${i%5?:'Buzz'}" ?: i

}</lang>

Haskell

Variant directly implementing the specification:

<lang haskell>output x | x3 && x5 = "FizzBuzz"

        | x3        =  "Fizz"
        | x5        =  "Buzz"
        | otherwise = show x
        where 
          x3 = x `mod` 3 == 0 
          x5 = x `mod` 5 == 0 

answer = map output [1..100]</lang>

J

Solution 0 <lang J>> }. (<'FizzBuzz') (I.0=15|n)} (<'Buzz') (I.0=5|n)} (<'Fizz') (I.0=3|n)} ":&.> n=: i.101</lang>

Solution 1 <lang J>Fizz=: 'Fizz' #~ 0 = 3&| Buzz=: 'Buzz' #~ 0 = 5&| FizzBuzz=: ": [^:(''-:]) Fizz,Buzz

FizzBuzz"0 >: i.100</lang>

Java

If/else ladder

<lang java>public class FizzBuzz{ public static void main(String[] args){ for(int i= 1; i <= 100; i++){ if(i % 15 == 0){ System.out.println("FizzBuzz"); }else if(i % 3 == 0){ System.out.println("Fizz"); }else if(i % 5 == 0){ System.out.println("Buzz"); }else{ System.out.println(i); } } } }</lang>

Concatenation

<lang java>public class FizzBuzz{ public static void main(String[] args){ for(int i= 1; i <= 100; i++){ String output = ""; if(i % 3 == 0) output += "Fizz"; if(i % 5 == 0) output += "Buzz"; if(output.equals("")) output += i; System.out.println(output); } } }</lang>

Ternary operator

<lang java>public class FizzBuzz{ public static void main(String[] args){ for(int i= 1; i <= 100; i++){ System.out.println(i % 15 != 0 ? i % 5 != 0 ? i % 3 != 0 ? i : "Fizz" : "Buzz" : "FizzBuzz" ;); } } }</lang>

Recursive

<lang java>public String fizzBuzz(int n){

 String s = "";
 if (n == 0)
   return s;
 if((n % 5) == 0)
   s = "Buzz" + s;
 if((n % 3) == 0)
   s = "Fizz" + s;
 if (s.equals(""))
   s = n + "";   
 return fizzBuzz(n-1) +  s;

}</lang>

Alternative Recursive

<lang java>public String fizzBuzz(int n){

 return (n>0) ? fizzBuzz(n-1) + 
   (n % 15 != 0? n % 5 != 0? n % 3 != 0? (n+"") :"Fizz" : "Buzz" : "FizzBuzz") 
              : "";

}</lang>

JavaScript

Works with: NJS version 0.2.5

<lang javascript>for (var i = 1; i <= 100; i++) {

 if (i % 15 == 0) {
   print("FizzBuzz");
 } else if (i % 3 == 0) {
   print("Fizz");
 } else if (i % 5 == 0) {
   print("Buzz");
 } else {
   print(i);
 }

}</lang>

M4

<lang M4> define(`for',

  `ifelse($#,0,``$0,
  `ifelse(eval($2<=$3),1,
  `pushdef(`$1',$2)$5`'popdef(`$1')$0(`$1',eval($2+$4),$3,$4,`$5')')')')

for(`x',1,100,1,

  `ifelse(eval(x%15==0),1,FizzBuzz,
  `ifelse(eval(x%3==0),1,Fizz,
  `ifelse(eval(x%5==0),1,Buzz,x)')')

') </lang>

Mathematica

<lang Mathematica>

Do[Print[Which[Mod[i, 15] == 0, "FizzBuzz", Mod[i, 5] == 0, "Buzz", Mod[i, 3] == 0, "Fizz", True, i]], {i, 100}]

</lang>

MAXScript

<lang maxscript>for i in 1 to 100 do (

   case of
   (
       (mod i 15 == 0): (print "FizzBuzz")
       (mod i 5 == 0):  (print "Buzz")
       (mod i 3 == 0):  (print "Fizz")
       default:         (print i)
   )

)</lang>

Metafont

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

Modula-3

<lang modula3> MODULE Fizzbuzz EXPORTS Main;

IMPORT IO;

BEGIN

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

END Fizzbuzz. </lang>

Oberon-2

<lang oberon2> MODULE FizzBuzz;

  IMPORT Out;

  VAR i: INTEGER;

BEGIN

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

END FizzBuzz. </lang>

OCaml

<lang ocaml>let output x =

 match x mod 3 = 0, x mod 5 = 0 with
   true,  true  -> "FizzBuzz"
 | true,  false -> "Fizz"
 | false, true  -> "Buzz"
 | false, false -> string_of_int x

let _ =

 for i = 1 to 100 do print_endline (output i) done</lang>

Octave

<lang octave>for i = 1:100

 if ( mod(i,15) == 0 )
   disp("FizzBuzz");
 elseif ( mod(i, 3) == 0 )
   disp("Fizz")
 elseif ( mod(i, 5) == 0 )
   disp("Buzz")
 endif

endfor</lang>

Perl

<lang perl>foreach (1 .. 100) {

   if (0 == $_ % 15) {
       print "FizzBuzz\n";
   } elsif (0 == $_ % 3) {
       print "Fizz\n";
   } elsif (0 == $_ % 5) {
       print "Buzz\n";
   } else {
       print "$_\n";
   };

};</lang>

More concisely:

<lang perl>sub f { $_[0] % $_[1] ?  : $_[2] } print f($_, 3, 'Fizz') . f($_, 5, 'Buzz') || $_, "\n"

   foreach 1 .. 100;</lang>

PHP

if/else ladder approach

<lang php><?php for ($i = 1; $i <= 100; $i++) {

   if (!($i % 15))
       echo "FizzBuzz\n";
   else if (!($i % 3))
       echo "Fizz\n";
   else if (!($i % 5))
       echo "Buzz\n";
   else
       echo "$i\n";

} ></lang>

concatenation approach

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

In contrast to the if-else ladder, this method lets us skip the check to see if $i is divisible by both 3 and 5 (i.e. 15). However, we get the added complexity of needing to reset $str to an empty string (not necessary in some other languages), and we also need a separate if statement to check to see if our string is empty, so we know if $i was not divisible by 3 or 5.

<lang php><?php for ( $i = 1; $i <= 100; ++$i ) {

    $str = "";

    if (!($i % 3 ) )
         $str .= "Fizz";

    if (!($i % 5 ) )
         $str .= "Buzz";

    if ( empty( $str ) )
         $str = $i;

    echo $str . "\n";

} ?></lang>

Pop11

<lang pop11> lvars str; for i from 1 to 100 do

 if i rem 15 = 0 then
   'FizzBuzz' -> str;
 elseif i rem 3 = 0 then
   'Fizz' -> str;
 elseif i rem 5 = 0 then
   'Buzz' -> str;
 else
    >< i -> str;
 endif;
 printf(str, '%s\n');

endfor; </lang>

PostScript

<lang postscript> 1 1 100 { /c false def dup 3 mod 0 eq { (Fizz) print /c true def } if dup 5 mod 0 eq { (Buzz) print /c true def } if

   c {pop}{(   ) cvs print} ifelse
   (\n) print

} for </lang> or... <lang postscript> /fizzdict 100 dict def fizzdict begin /notmod{ ( ) cvs } def /mod15 { dup 15 mod 0 eq { (FizzBuzz)def }{pop}ifelse} def /mod3 { dup 3 mod 0 eq {(Fizz)def}{pop}ifelse} def /mod5 { dup 5 mod 0 eq {(Buzz)def}{pop}ifelse} def 1 1 100 { mod3 } for 1 1 100 { mod5 } for 1 1 100 { mod15} for 1 1 100 { dup currentdict exch known { currentdict exch get}{notmod} ifelse print (\n) print} for end </lang>

Python

<lang python> for i in xrange(1, 101):

   if i % 15 == 0:
       print "FizzBuzz"
   elif i % 3 == 0:
       print "Fizz"
   elif i % 5 == 0:
       print "Buzz"
   else:
       print i

</lang>

And a shorter, but less clear version, using a list comprehension and logical expressions: <lang python> for i in range(1, 101):

   words = [word for n, word in ((3, 'Fizz'), (5, 'Buzz')) if not i % n]
   print .join(words) or i

</lang>

Without modulus

I came across this crazy version[4] without using the modulus operator: <lang python> messages = [None, "Fizz", "Buzz", "FizzBuzz"] acc = 810092048 for i in xrange(1, 101):

   c = acc & 3
   print messages[c] if c else i
   acc = acc >> 2 | c << 28

</lang>

R

<lang R>

x <- 1:100
str <- as.character(x)
str[x%%15==0] <- "FizzBuzz"
str[x%%3==0] <- "Fizz"
str[x%%5==0] <- "Buzz"
str

</lang>

RapidQ

The BASIC solutions work with RapidQ, too.
However, here is a bit more esoteric solution using the IIF() function. <lang rapidq>

FOR i=1 TO 100
    t$ = IIF(i MOD 3 = 0, "Fizz", "") + IIF(i MOD 5 = 0, "Buzz", "")
    PRINT IIF(LEN(t$), t$, i)
NEXT i

</lang>

Raven

<lang raven> 100 each 1 + as n

 
 n 3 mod 0 = if 'Fizz' cat
 n 5 mod 0 = if 'Buzz' cat
 dup empty if drop n
 say

</lang>

Ruby

<lang ruby> 1.upto(100) do |n|

 print "Fizz" if a = (n % 3).zero?
 print "Buzz" if b = (n % 5).zero?
 print n unless (a || b)
 print "\n"

end </lang>

Scheme

<lang scheme>(do ((i 1 (+ i 1)))

   ((> i 100))
   (display
     (cond ((= 0 (modulo i 15)) "FizzBuzz")
           ((= 0 (modulo i 3))  "Fizz")
           ((= 0 (modulo i 5))  "Buzz")
           (else                i)))
   (newline))</lang>

Seed7

<lang seed7> $ include "seed7_05.s7i";

const proc: main is func

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

</lang>

Slate

<lang slate> n@(Integer traits) fizzbuzz [| output |

 output: ((n \\ 3) isZero ifTrue: ['Fizz'] ifFalse: []) ; ((n \\ 5) isZero ifTrue: ['Buzz'] ifFalse: []).
 output isEmpty ifTrue: [n printString] ifFalse: [output]

]. 1 to: 100 do: [| :i | inform: i fizzbuzz] </lang>

Smalltalk

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

<lang smalltalk>Integer extend [

   fizzbuzz [
       | fb |
       fb := '%<Fizz|>1%<Buzz|>2' % {
           self \\ 3 == 0.  self \\ 5 == 0 }.
       ^fb isEmpty ifTrue: [ self ] ifFalse: [ fb ]
   ]

] 1 to: 100 do: [ :i | i fizzbuzz displayNl ]</lang>

Standard ML

<lang sml>fun output x =

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

val () = let

 fun aux i = if i <= 100 then (print (output i ^ "\n");
                           aux (i+1))
                     else ()

in

 aux 1

end</lang>

Tcl

<lang tcl>proc fizzbuzz {n {m1 3} {m2 5}} {

   for {set i 1} {$i <= $n} {incr i} {
       set ans ""
       if {$i % $m1 == 0} {append ans Fizz}
       if {$i % $m2 == 0} {append ans Buzz}
       puts [expr {$ans eq "" ? $i : $ans}]
   }

} fizzbuzz 100</lang>

UNIX Shell

<lang sh>

for n in `seq 1 100`; do
  if  [ $(($n % 15)) = 0 ]; then
    echo FizzBuzz
  elif [ $(($n % 3)) = 0 ]; then
    echo Fizz
  elif [ $(($n % 5)) = 0 ]; then
    echo Buzz
  else
    echo $n
  fi
done

</lang>

A more portable version:

<lang sh>

NUM=1
until (($NUM==101)) ; do
   if (($NUM % 15 == 0)) ; then
       echo FizzBuzz
   elif (($NUM % 3 == 0)) ; then
       echo Fizz
   elif (($NUM % 5 == 0)) ; then
       echo Buzz
   else 
       echo "$NUM"
   fi
   ((NUM=$NUM+1))
done

</lang>

Ursala

<lang Ursala>

1. import std
2. import nat

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

1. show+

main = fizzbuzz*t iota 101 </lang>

V

<lang v>[fizzbuzz

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

Second try

(a compiler for fizzbuzz)

define a command that will generate a sequence <lang v>[seq [] swap dup [zero? not] [rolldown [dup] dip cons rollup pred] while pop pop].</lang>

create a quote that will return a quote that returns a quote if its argument is an integer (A HOF) <lang v>[check [N X F : [[integer?] [[X % zero?] [N F cons] if] if]] view].</lang>

Create a quote that will make sure that the above quote is applied correctly if given (Number Function) as arguments. <lang v>[func [[N F] : [dup N F check i] ] view map].</lang>

And apply it <lang v>100 seq [

       [15 [pop 'fizzbuzz' puts]]
       [5  [pop 'buzz' puts]]
       [3  [pop 'fizz' puts]] 
       [1  [puts]]] [func dup] step
       [i true] map pop</lang>

the first one is much better :)

Visual Basic .NET

Platform: .NET

Works with: Visual Basic .NET version 9.0+

<lang vbnet> Sub Main()

       For i = 1 To 100
           If i Mod 15 = 0 Then
               Console.WriteLine("FizzBuzz")
           ElseIf i Mod 5 = 0 Then
               Console.WriteLine("Buzz")
           ElseIf i Mod 3 = 0 Then
               Console.WriteLine("Fizz")
           Else
               Console.WriteLine(i)
           End If
       Next

   End Sub</lang>