FizzBuzz: Difference between revisions

 

But:

 

 

{{trans|Python3: Simple}}

 

I i % 15 == 0

print(‘FizzBuzz’)

print(‘Buzz’)

E

 

=={{header|360 Assembly}}==

 

=={{header|8th}}==

with: n

 

' fizzbuzz 1 100 loop

cr bye

 

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program FizzBuzz64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

 

=={{header|ABAP}}==

===Impure Functional 1===

{{works with|ABAP|7.4 SP05 or Above only}}

 

tab = VALUE #(

 

cl_demo_output=>write( tab ).

 

===Impure Functional 2===

{{works with|ABAP|7.4 SP05 or Above only}}

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

 

=={{header|ACL2}}==

(declare (xargs :measure (nfix (- 100 i))))

(prog2$

(fizzbuzz-r (1+ i)))))

 

 

=={{header|Action!}}==

BYTE i,d3,d5

 

IF d5=5 THEN d5=0 FI

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/FizzBuzz.png Screenshot from Atari 8-bit computer]

=={{header|ActionScript}}==

The [[ActionScript]] solution works just like the [[FizzBuzz#JavaScript|JavaScript]] solution (they share the [[ECMAScript]] specification). The difference is that ActionScript has the ''trace'' command to write out to a console.

if (i % 15 == 0)

trace('FizzBuzz');

else

trace(i);

 

=={{header|Ada}}==

procedure Fizzbuzz is

end if;

end loop;

 

=={{header|ALGOL 68}}==

FOR i TO 100 DO

printf(($gl$,

))

OD

or simply:

 

=={{header|ALGOL-M}}==

 

INTEGER FUNCTION DIVBY(N, D);

END;

 

 

=={{header|ALGOL W}}==

begin

i_w := 1; % set integers to print in minimum space %

else write( i )

end for_i

 

=={{header|AntLang}}==

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

 

=={{header|APEX}}==

for(integer i=1; i <= 100; i++){

String output = '';

}

}

 

=={{header|APL}}==

(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

Here's a Dyalog-specific solution taking advantage of its anonymous function extension:

 

 

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

 

 

Yet another solution, excessively commented:

{{works with|GNU_APL}} (and Dyalog, with [http://course.dyalog.com/autumn2021/Quirks/ ⎕ML ← 2])

 

[1] ⍝⍝ Solve the popular 'fizzbuzz' problem in APL.

[2] ⍝⍝ \param n - highest number to compute (≥0)

[37] ⍝⍝ ⎕ ← ,fizzbuzz 15

[38] ⍝ 1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz

 

=={{header|AppleScript}}==

===Procedural===

repeat with i from 1 to 100

if i mod 15 = 0 then

set outputText to outputText & linefeed

end repeat

----

If this were a useful task requiring a degree of efficiency, it would be better to replace the cumulative text concatenations with additions to a fast-to-access list and coerce this list to text in one go at the end. Less critically, the <tt>(i mod … = 0)</tt> tests could be nested to reduce the number of these performed from 261 to 200:

 

script o

property output : {}

end fizzBuzz

 

 

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:

 

script o

property output : {}

end fizzBuzz

 

 

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:

 

-- fizz :: Int -> Bool

end script

end if

 

=={{header|Applesoft BASIC}}==

 

=={{header|Arbre}}==

for x in [1..100]

if x%5==0 and x%3==0

 

main():

 

=={{header|Arc}}==

===Arc 3.1 Base===

(prn:if

(multiple n 15) 'FizzBuzz

(multiple n 5) 'Buzz

(multiple n 3) 'Fizz

(prn:check (string (when (multiple n 3) 'Fizz)

(when (multiple n 5) 'Buzz))

 

===Waterhouse Arc===

(prn:case (gcd n 15)

1 n

3 'Fizz

5 'Buzz

 

=={{header|ARM Assembly}}==

/ * linux GAS */

 

mov r0, r2

mov pc, lr

 

=={{header|Arturo}}==

case []

when? [0=x%15] -> print "FizzBuzz"

when? [0=x%5] -> print "Buzz"

else -> print x

{{out}}

<pre>1

 

=={{header|Asymptote}}==

if (number % 15 == 0) {

write("FizzBuzz");

}

}

 

=={{header|ATS}}==

 

implement main0() = loop(1, 100) where {

loop(from+1, to)

end

 

=={{header|AutoHotkey}}==

{{AutoHotkey case}}

{

If (Mod(A_Index, 15) = 0)

FileDelete, output.txt

FileAppend, %output%, output.txt

A short example with cascading ternary operators and graphical output. Press Esc to close the window.

Gui,Show

Loop, 100

Return

Esc::

 

=={{header|AutoIt}}==

===Example1===

Output via MsgBox():

If Mod($i, 15) = 0 Then

MsgBox(0, "FizzBuzz", "FizzBuzz")

MsgBox(0, "FizzBuzz", $i)

EndIf

 

===Example2===

Output via console, logfile and/or messagebox:

 

; uncomment how you want to do the output

EndIf

Next

 

=={{header|Avail}}==

Print:

if i mod 15 = 0 then ["FizzBuzz"]

else [“i”]

++ "\n";

 

=={{header|AWK}}==

 

=={{header|Axe}}==

!If I^3??I^5

Disp "FIZZBUZZ",i

.Pause to allow the user to actually read the output

Pause 1000

 

=={{header|Babel}}==

{ { iter 1 + dup

"\n" << }

 

 

=={{header|BaCon}}==

=={{header|bash}}==

Any bash hacker would do this as a one liner at the shell, so...

For the sake of readability...

((( n % 15 == 0 )) && echo 'FizzBuzz') ||

((( n % 5 == 0 )) && echo 'Buzz') ||

((( n % 3 == 0 )) && echo 'Fizz') ||

echo $n;

Here's a very concise approach, with only 75 characters total.

Unfortunately it relies on aspects of Bash which are rarely used.

Here's the concise approach again, this time separated into multiple lines.

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+=Buzz # ...Otherwise, append (not set) the string "Buzz" to x.

echo ${x:-$i} # Print x unless it is blanked out. Otherwise, print i.

It's a bit silly to optimize such a small & fast program,

but for the sake of algorithm analysis it's worth noting that

 

=={{header|BASIC}}==

See [[FizzBuzz/Basic]]

 

FOR /L version:

 

for /L %%i in (1,1,100) do call :tester %%i

goto :eof

:NotFizz

echo %1

 

Loop version:

 

set n=1

 

 

:NotFizz

 

FOR /L with a block instead of very-high-overhead subroutine call:

 

for /l %%i in (1,1,100) do (

set /a m5=%%i %% 5

if "!s!"=="" set s=%%i

echo !s!

 

=={{header|BBC BASIC}}==

This solution never uses <tt>else</tt>, because bc has no <tt>else</tt> keyword (but some implementations add <tt>else</tt> as an extension).

 

w = 0

if (i % 3 == 0) { "Fizz"; w = 1; }

"

}

 

=={{header|BCPL}}==

 

LET start() BE $(

$)

$)

 

=={{header|beeswax}}==

“Ordinary” FizzBuzz solution:

 

>@F5~%"d@F{ > @F q

_1>F3~%'d`Fizz`@F5~%'d >`Buzz`@FNp

 

 

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 >Ag'd@{?p

_>"1F3~%'d`Fizz`f>@F5~%'d`Buzz`@p

 

=={{header|Befunge}}==

 

=={{header|blz}}==

out = ""

if i % 3 == 0

end

print(out)

 

=={{header|Boo}}==

for i in range(1, size):

if i%15 == 0:

print i

 

 

=={{header|BQN}}==

 

=={{header|Bracmat}}==

Same code, pretty printed:

& whl

' ( 1+!i:<101:?i

| !i

)

 

=={{header|Brainf***}}==

 

=={{header|Brat}}==

true? n % 15 == 0

{ p "FizzBuzz" }

}

}

 

=={{header|BrightScript (for Roku)}}==

fz = i MOD 3 = 0

bz = i MOD 5 = 0

END IF

? str

 

=={{header|C}}==

 

For 2 prime numbers and based on a similar minimal [[#JavaScript|JavaScript]] solution with low signal-to-noise, the C code is:

while ( i++ < 100 )

!sprintf( B, "%s%s", i%3 ? "":"Fizz", i%5 ? "":"Buzz" )

With 4 prime numbers:

while ( i++ < 100 )

!sprintf( B, "%s%s%s%s",

i%3 ? "":"Fiz", i%5 ? "":"Buz", i%7 ? "":"Goz", i%11 ? "":"Kaz" )

One line version, with pretty printing

 

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

}

 

int main ()

printf(s[!(i % 3) + 2 * !(i % 5)], i);

return 0;

 

 

int main (void)

}

return 0;

Implicit int main and return 0 (C99+):

main() {

i++;

}

obfuscated:

#define F(x,y) printf("%s",i%x?"":#y"zz")

 

 

int main(void)

}

}

 

Without conditionals, anything in the loop body gcc compiles with branching, duplicate tests or duplicate strings. Depends on ASCII and two's complement arithmetic:

 

int main()

{

}

}

 

=={{header|C sharp|C#}}==

 

{

public void FizzBuzzGo()

}

}

 

{

static void Main()

}

}

 

using System.Linq;

 

}

}

 

using System.Globalization;

using System.Linq;

}

}

 

namespace FizzBuzz

{

}

}

 

using System.Globalization;

 

}

}

 

using System.Linq;

}

}

 

===With C#8 switch expressions===

 

{

public static string FizzBuzzIt(int n) =>

}

}

 

===TDD using delegates===

 

using System.Collections;

using System.Collections.Generic;

}

}

 

===Good old C ways===

 

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() : "")

){}

 

=={{header|C++}}==

===minimal conditions===

#include <chrono>

 

return 0;

}

===with modulo===

 

using namespace std;

}

return 0;

===without modulo 15===

using namespace std;

 

}

return 0;

===without modulo===

Modulo can be expensive on some architectures.

 

int main()

return 0;

}

===using std::transform===

{{works with|C++11}}

#include <algorithm>

#include <vector>

 

return 0;

===metaprogramming===

Version computing FizzBuzz at compile time with metaprogramming:

 

template <int n, int m3, int m5>

fb_run<100> fb;

return 0;

===hardcore templates===

Compile with -ftemplate-depth-9000 -std=c++0x:

#include <string>

#include <cstdlib>

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

 

 

=={{header|Cduce}}==

 

let format (n : Int) : Latin1 =

let fizbuzz (size : Int) : _ = fizz (1, size);;

 

 

=={{header|Ceylon}}==

 

=={{header|Chapel}}==

for i in 1..n do

if i % 15 == 0 then

}

 

 

=={{header|Chef}}==

See [[FizzBuzz/EsoLang]]

 

=={{header|Clay}}==

for(i in range(1,100)) {

if(i % 3 == 0 and i % 5 == 0) println("fizzbuzz");

else print(i);

}

 

=={{header|Clipper}}==

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

 

LOCAL n

 

RETURN

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

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

 

=={{header|CLIPS}}==

(count-to 100)

)

(priint depth, unsigned int i> struct NUM_DIGITS_CORE : NUM_DIGITS_COREntout t crlf)

)

 

=={{header|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]

(range start finish)))

(fizzbuzz 1 100)

 

(zero? (mod x 5)) "Buzz"

(zero? (mod x 3)) "Fizz"

:else x))

#(cond (zero? (mod % 15)) "FizzBuzz"

(zero? (mod % 5)) "Buzz"

(zero? (mod % 3)) "Fizz"

:else %)

 

([] (fizz-buzz (range 1 101)))

([lst]

(buzz? n) b

:else n))

(if-let [fb (seq (concat (when (zero? (mod n 3)) "Fizz")

(when (zero? (mod n 5)) "Buzz")))]

(apply str fb)

n))

(range)

(cycle [ "" "" "Fizz" ])

(map #(if (pos? (compare %1 %2)) %1 %2)

(map str (drop 1 (range)))

(map str (cycle ["" "" "Fizz"]) (cycle ["" "" "" "" "Buzz"]))))

;;Using clojure maps

(defn fizzbuzz

[max]

(map fizzbuzz (range 1 (inc max))))

(take 100

(map #(str %1 %2 (if-not (or %1 %2) %3))

(rest (range))

))

 

(take 100

(

) ;;endfn apply

) ;;endtake

 

(take 100

(map-indexed

)

)

 

(take 100

(->>

)

)

 

(take 100

(map-indexed

)

)

 

=={{header|CLU}}==

po: stream := stream$primary_output()

stream$putl(po, out)

end

 

=={{header|CMake}}==

math(EXPR off3 "${i} % 3")

math(EXPR off5 "${i} % 5")

message(${i})

endif()

 

=={{header|COBOL}}==

===Canonical version===

{{works with|OpenCOBOL}}<!-- http://www.opencobol.org/ -->

* cobc -x -g FIZZBUZZ.COB

*

END-PERFORM

DISPLAY ""

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

Program-id. fizz-buzz.

 

else display num

end-perform.

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

STOP RUN

.

 

===Chase the Fizz===

{{works with|OpenCOBOL}}

A solution that simply evaluates and adds.

identification division.

program-id. fizzbuzz.

.

end program fizzbuzz.

 

=={{header|Coco}}==

console.log do

if i % 15 == 0 then 'FizzBuzz'

else if i % 3 == 0 then 'Fizz'

else if i % 5 == 0 then 'Buzz'

 

 

=={{header|Coconut}}==

case (n % 3, n % 5):

match (0, 0): return "FizzBuzz"

match (_, 0): return "Buzz"

else: return n |> str

 

=={{header|CoffeeScript}}==

if i % 15 is 0

console.log "FizzBuzz"

console.log "Buzz"

else

console.log \

if i % 15 is 0

"Buzz"

else

 

=={{header|ColdFusion}}==

<Cfif i mod 15 eq 0>FizzBuzz

<Cfelseif i mod 5 eq 0>Fizz

<Cfelse><Cfoutput>#i# </Cfoutput>

</Cfif>

cfscript version

result = "";

for(i=1;i<=100;i++){

}

WriteOutput(result);

 

=={{header|Comefrom0x10}}==

 

mod_three = 3

mod_five = 5

mod_five = mod_five + 5

 

 

=={{header|Common Lisp}}==

Solution 1:

(loop for x from 1 to 100 do

(princ (cond ((zerop (mod x 15)) "FizzBuzz")

((zerop (mod x 5)) "Buzz")

(t x)))

Solution 2:

(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")))

Solution 3:

(loop for n from 1 to 100

do (format t "~&~[~[FizzBuzz~:;Fizz~]~*~:;~[Buzz~*~:;~D~]~]~%"

Solution 4:

as fizz = (zerop (mod n 3))

as buzz = (zerop (mod n 5))

(format t

"~&~:[~;Fizz~]~:[~;Buzz~]~:[~;~D~]~%"

Solution 5:

(loop as n from 1 to 100

as f = (zerop (mod n 3))

if f collect 'fizz

if b collect 'buzz

Solution 6:

(loop as n from 1 to 100

as f = (zerop (mod n 3))

as b = (zerop (mod n 5))

 

Solution 7:

(mapcar

#'(lambda (a b) (if (equal 0 (mod x a)) b x))

(print (format nil "~{~a~}" (filter-core (core a))))))

 

First 16 lines of output:

<pre>

I use [https://franz.com/downloads/clp/survey Allegro CL 10.1]

 

;; Project : FizzBuzz

 

(= (rem n multiple) 0))

(fizzbuzz 1)

Output:

<pre>

Buzz

</pre>

 

=={{header|Coq}}==

 

Require Import Coq.Lists.List.

(* https://coq.inria.fr/library/Coq.Lists.List.html *)

(** Definition of [string_of_nat] to convert natural numbers to strings. *)

 

ascii_of_nat (n + 48).

 

 

match counter with

| 0 => EmptyString

if (is_digit n)

then String (ascii_of_digit n) acc

(** The counter is only used to ensure termination. *)

 

rec_string_of_nat n n EmptyString.

 

(** The FizzBuzz problem. *)

 

 

 

String (ascii_of_nat 10) EmptyString.

 

(n mod k) =? 0.

 

if (is_divisible_by n 15) then fizz ++ buzz

else if (is_divisible_by n 3) then fizz

else (string_of_nat n).

 

 

 

 

(** This shows the string. *)

Eval compute in fizz_buzz.

 

 

=={{header|Cowgol}}==

===Straightforward version===

 

 

var i: uint8 := 1;

print_nl();

i := i + 1;

 

===No division===

98-byte executable.)

 

 

var i: uint8 := 100;

i := i - 1;

end loop;

 

=={{header|Crystal}}==

p fizz_buzz(v)

end

word += value.to_s if word.empty?

word

 

A more natural solution with the string building:

 

case

when n % 15 == 0

puts n

end

 

=={{header|CSS}}==

 

=={{header|Cubescript}}==

loop i 100 [

push i (+ $i 1) [

]

]

 

=={{header|D}}==

 

/// With if-else.

writeln;

100.fizzBuzzSwitch2;

Alternate version calculating values at compile time:

 

void main()

 

r.each!writeln;

 

=={{header|Dart}}==

main() {

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

}

}

 

=={{header|dc}}==

{{trans|bc}}

[[Buzz]P 1 sw]sB

[li p sz]sN

]sL

1 si [i = 1]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+d # Number += 1 and put extra copy on stack

100!<L # Continue Loop if 100 >= Number (destroys copy)

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

Writeln(i);

end;

 

=={{header|DeviousYarn}}==

? { divisible(x 3)

p:'Fizz' }

p:x }

o

 

=={{header|Draco}}==

byte i;

for i from 1 upto 100 do

fi

od

 

=={{header|DUP}}==

 

Output to STDOUT via single character output.

 

Output to STDOUT, using stored strings and a separately defined string output operator:

[$$3/%$[][0$"Fizz"P]?\5/%$[][0$"Buzz"P]?*[$.][]?10,]c: {define function c: mod 3, mod 5 tests, print according output}

 

=={{header|DWScript}}==

 

for i := 1 to 100 do begin

PrintLn('Buzz')

else PrintLn(i);

 

=={{header|Dyalect}}==

 

 

while n < 20 {

 

n = n + 1

 

{{out}}

 

=={{header|Déjà Vu}}==

if = 0 % i 15:

"FizzBuzz"

else:

i

 

=={{header|E}}==

println(switch ([i % 3, i % 5]) {

match [==0, ==0] { "FizzBuzz" }

match _ { i }

})

 

=={{header|EasyLang}}==

if i mod 15 = 0

print "FizzBuzz"

print i

.

 

=={{header|ECL}}==

STRING s;

END;

d := DATASET(100,MakeDataRec(COUNTER));

 

 

=={{header|Eero}}==

 

int main()

Log( '(%d) %@', i, s )

 

 

=={{header|Egel}}==

import "prelude.eg"

import "io.ego"

 

def main = fizzbuzz 1

 

=={{header|Eiffel}}==

class

APPLICATION

end

 

 

=={{header|Ela}}==

 

prt x | x % 15 == 0 = "FizzBuzz"

| else = x

 

 

=={{header|Elixir}}==

===Standard approaches===

used case

IO.puts(case { rem(x,3) == 0, rem(x,5) == 0 } do

{ true, true } -> "FizzBuzz"

{ false, false } -> x

end)

 

Alternate approach using pipes and cond:

 

1..100 |> Enum.map(fn i ->

cond do

true -> i

end

 

used Stream.cycle version:

def fizzbuzz(limit \\ 100) do

fizz = Stream.cycle(["", "", "Fizz"])

end

 

 

Yet another approach:

def fizzbuzz(n) when rem(n, 15) == 0, do: "FizzBuzz"

def fizzbuzz(n) when rem(n, 5) == 0, do: "Buzz"

end

 

 

used anonymous function

(n) when rem(n,5)==0 -> "Fizz"

(n) when rem(n,3)==0 -> "Buzz"

end

 

 

Enum.at version: Returns nil if index is out of bounds.

str = "#{Enum.at([:Fizz], rem(i,3))}#{Enum.at([:Buzz], rem(i,5))}"

IO.puts if str=="", do: i, else: str

 

===A macro too far===

The Stream.cycle version above, but as an overpowered FizzBuzz DSL.

# Hand-rolls a bunch of AST before injecting the resulting FizzBuzz code.

defmacrop automate_fizz(fizzers, n) do

end

 

 

=={{header|Elm}}==

A bit too simple:

import List exposing (map)

 

"Buzz"

else

 

A bit too clever:

import List exposing (map)

import String exposing (join, fromInt)

fromInt num

else

 

=={{header|Emacs Lisp}}==

(cond ((and (zerop (% n 5)) (zerop (% n 3))) "FizzBuzz")

((zerop (% n 3)) "Fizz")

;; loop & print from 0 to 100

(dotimes (i 101)

 

=={{header|Emojicode}}==

===Simple 1===

🔂 i 🆕⏩ 1 101 1 ❗ 🍇

↪️ i 🚮 15 🙌 0 🍇

🍉

🍉

===Simple 2===

🔂 i 🆕⏩ 1 101 1 ❗ 🍇

🔤🔤 ➡️ 🖍🆕 msg

🍉

🍉

 

=={{header|Erlang}}==

fizzbuzz() ->

F = fun(N) when N rem 15 == 0 -> "FizzBuzz";

(N) -> integer_to_list(N)

end,

 

=={{header|ERRE}}==

PROGRAM FIZZ_BUZZ

!

END FOR

END PROGRAM

 

=={{header|Euphoria}}==

{{works with|Euphoria|4.0.0}}

This is based on the [[VBScript]] example.

 

function fb( atom n )

end for

 

 

=={{header|F Sharp|F#}}==

match n%3 = 0, n%5 = 0 with

| true, false -> "fizz"

 

let printFizzbuzz() =

|> List.map (fun x ->

match x with

| _ when x % 3 = 0 -> "fizz"

| _ -> x.ToString())

Another example using (unnecessary) partial active pattern :D

if Seq.exists ((%) number >> (<>) 0) divisors

then None

 

{ 1 .. 100 }

 

=={{header|Factor}}==

IN: fizzbuzz

: fizz ( n -- str ) 3 divisor? "Fizz" "" ? ;

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

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

 

More flexible variant without divisibility tests.

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

IN: fizzbuzz

 

MAIN: FizzBuzzQuxx-100

 

=={{header|Falcon}}==

switch i % 15

case 0 : > "FizzBuzz"

default : > i

end

 

=={{header|FALSE}}==

 

=={{header|Fantom}}==

{

public static Void main ()

}

}

 

=={{header|FBSL}}==

'''No 'MOD 15' needed.'''

 

DIM numbers AS STRING

NEXT

 

{{out}}

1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17 Fizz 19 Buzz Fiz

98 Fizz Buzz

Press any key to continue...

 

=={{header|Fennel}}==

(print (if (= (% i 15) 0) :FizzBuzz

(= (% i 3) 0) :Fizz

(= (% i 5) 0) :Buzz

Use pattern matching and recursive function:

(print (match [(% from 3) (% from 5)]

[0 0] :FizzBuzz

(fizz-buzz (+ from 1) to)))

 

Alternative matching pattern:{{trans|D}}

(print (match (% i 15)

0 :FizzBuzz

(where (or 3 6 9 12)) :Fizz

(where (or 5 10) :Buzz

 

=={{header|FOCAL}}==

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

01.20 QUIT

 

02.90 TYPE "Buzz" !

02.95 RETURN

 

=={{header|Fermat}}==

{{out}}<pre>

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

 

=={{header|Forth}}==

===table-driven===

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

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

' fizz , ' . , ' . ,

' fizz , ' buzz , ' . ,

===or the classic approach===

0 pad c!

dup 3 mod 0= if s" Fizz" pad place then

: zz ( n -- )

1+ 1 do i .fizzbuzz cr loop ;

===the well factored approach===

SYNONYM is a Forth200x word.

 

 

: Fizz? ( n -- ? ) 3 MOD 0= DUP IF ." Fizz" THEN ;

101 1 DO CR I DUP Fizz? OVER Buzz? OR NOT ?print LOOP ;

 

===the unrolled approach===

: f ( n -- n+1 ) ." Fizz " 1+ ;

: b ( n -- n+1 ) ." Buzz " 1+ ;

: fb15 ( n -- n+15 ) fb10 n f n n fb ;

: fb100 ( n -- n+100 ) fb15 fb15 fb15 fb15 fb15 fb15 fb10 ;

 

=={{header|Fortran}}==

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

integer :: i

end if

end do

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.

implicit none

integer :: i = 1

end do

end program FizzBuzz

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

integer :: i

end select

end do

 

=={{header|FreeBASIC}}==

 

=={{header|Frege}}==

pattern = zipWith (++) (gen 3 "fizz") (gen 5 "buzz")

fizzbuzz = zipWith combine pattern [1..] where

then show number

else word

 

=={{header|Frink}}==

{

flag = false

 

println[]

 

=={{header|FutureBasic}}==

 

 

for i = 1 to 100

fizz = (i mod 3 )

buzz = (i mod 5 )

next i

 

 

Output:

<pre>

</pre>

 

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=efbe83377a1eabe475d8eba13965cfde Click this link to run this code]'''

Dim siCount As Short

Dim sText As String

Next

 

Output:

<pre>

 

=={{header|GAP}}==

local i;

for i in [1 .. 100] do

fi;

od;

 

=={{header|Genyris}}==

@prefix u "http://www.genyris.org/lang/utilities#"

 

fb

 

 

=={{header|GFA Basic}}==

 

' Fizz Buzz

'

ENDIF

NEXT i%

 

=={{header|Gleam}}==

 

import gleam/io

import gleam/iterator

_, _ -> int.to_string(n)

}

 

=={{header|Go}}==

===switch/case approach===

 

import "fmt"

}

}

===map approach===

 

import "fmt"

}[i%5 == 0][i%3 == 0])

}

 

=={{header|Golfscript}}==

 

=={{header|Golo}}==

 

augment java.lang.Integer {

}

}

 

=={{header|Gosu}}==

if (i % 3 == 0 && i % 5 == 0) {

print(i)

One liner version (I added new lines to better readability but when you omit them it's one liner):

for (i in 1..100) {

print(i % 5 == 0 ? i % 3 == 0 ? "FizzBuzz" : "Buzz" : i % 3 == 0 ? "Fizz" : i)

 

=={{header|Groovy}}==

 

=={{header|GW-BASIC}}==

See [[FizzBuzz/Basic]]

 

=={{header|Haskell}}==

Variant directly implementing the specification:

fizzbuzz x

| f 15 = "FizzBuzz"

 

main :: IO ()

 

fizzbuzz n =

'\n' :

 

main :: IO ()

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

 

fizzbuzz n =

 

fizz = "Fizz"

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

 

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

 

 

 

fizzBuzz :: [String]

fizzBuzz =

 

main :: IO ()

 

or using an applicative test:

 

 

fizzBuzz :: [String]

fizzBuzz =

 

main :: IO ()

 

Using heavy artillery (needs the mtl package):

import Control.Monad.State

import Control.Monad.Trans

when (x `mod` 5 == 0) $ tell "Buzz" >> put False

get >>= (flip when $ tell $ show x)

Using guards plus where.

fizzBuzz i

| fizz && buzz = "FizzBuzz"

buzz = i `mod` 5 == 0

 

 

An elegant solution exploiting monoidal and applicative properties of functions:

 

fizzbuzz = max

divisibleBy n x = x `mod` n == 0

 

 

And pattern matching approach:

(0, 0) -> "FizzBuzz"

(0, _) -> "Fizz"

(_, _) -> show n

 

 

Generalised solution:

wordthing lst n =

if matches == [] then

 

main = do

 

=={{header|hexiscript}}==

if i % 3 = 0 && i % 5 = 0; println "FizzBuzz"

elif i % 3 = 0; println "Fizz"

elif i % 5 = 0; println "Buzz"

else println i; endif

 

=={{header|HicEst}}==

IF( MOD(i, 15) == 0 ) THEN

WRITE() "FizzBuzz"

WRITE() i

ENDIF

Alternatively:

 

DO i = 1, 100

IF( string == " ") WRITE(Text=string) i

WRITE() string

 

=={{header|HolyC}}==

for (i = 1; i <= 100; i++) {

if (!(i % 15))

Print("%d", i);

Print("\n");

 

=={{header|Hoon}}==

|= [^ ~ ~]

:- %noun

[& |] "Fizz"

[| &] "Buzz"

 

=={{header|Huginn}}==

 

main( argv_ ) {

}

return ( 0 );

 

=={{header|Hy}}==

 

[(not (% i 15)) "FizzBuzz"]

[(not (% i 5)) "Buzz"]

[(not (% i 3)) "Fizz"]

 

=={{header|i}}==

for each 1 to 100

if i % 15 = 0

end

end

 

=={{header|Icon}} and {{header|Unicon}}==

procedure main()

every i := 1 to 100 do

else

write(i)

procedure main()

every i := 1 to 100 do

write((i % 15 = 0 & "FizzBuzz") | (i % 5 = 0 & "Buzz") | (i % 3 = 0 & "Fizz") | i)

procedure main()

every i := 1 to 100 do

default: i

})

procedure main()

every i := 1 to 100 do {

write(s)

}

procedure main()

every i := 1 to 100 do

write("" ~== (if i % 3 = 0 then "Fizz" else "") || (if i % 5 == 0 then "Buzz" else "") | i)

procedure main()

every i := 1 to 100 do {

write(("" ~= s) | i)

}

 

=={{header|Idris}}==

fizzBuzz : Nat -> String

fizzBuzz n = if (n `modNat` 15) == 0 then "FizzBuzz"

 

main : IO ()

 

=={{header|Inform 6}}==

 

 

=={{header|Inform 7}}==

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

 

 

When play begins:

if printed is false, say N;

say ".";

 

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

 

 

To say the name:

end if.

 

=={{header|Io}}==

Here's one way to do it:

if(a % 15 == 0) then(

"FizzBuzz" println

a println

)

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

for(n, 1, 100,

if(a = (n % 3) == 0, "Fizz" print);

if(a not and b not, n print);

"\n" print

And here is another more idiomatic version:

fb := list (

if (n % 3 == 0, "Fizz"),

if (fb isEmpty, n, fb join) println

 

=={{header|Ioke}}==

cond(

(x % 15) zero?, "FizzBuzz" println,

(x % 5) zero?, "Buzz" println

)

 

=={{header|Iptscrae}}==

1 a =

{

a ++

}

 

=={{header|J}}==

 

Perhaps the most concise approach would be [https://jsoftware.github.io/j-playground/bin/html/emj.html#code=%3E((2%23.3%20q%3A15%26%2B.)%7B(%7C.(%3B~%2C%26%3B)%3B%3A'Fizz%20Buzz')%3B~%22%3A)%26%3E1%2Bi.100 >((2#.3 q:15&amp;+.){(|.(;~,&amp;;);:'Fizz Buzz');~":)&amp;&gt;1+i.100]

 

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

Solution 1

Buzz=: 'Buzz' #~ 0 = 5&|

FizzBuzz=: ": [^:('' -: ]) Fizz,Buzz

 

Solution 2 (has taste of table-driven template programming)

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

 

Solution 3 (depends on an obsolete feature of @ in f`g`h@p)

'`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)

 

 

Solution 4 (relatively concise):

 

 

Here's some intermediate results for subexpressions of this last version (but with a shorter list of numbers):

 

0 1 2 3 4 5 6 7 8 9

(3 5 |/ ])i.10

└─┴─┴────┴─┴────┴────┴─┴─┴────┘

;:inv}.(":&.> [^:(0 = #@])&.> [: ,&.>/ (;:'Fizz Buzz') #&.>~0=3 5 |/ ])i.10

 

=={{header|Janet}}==

(loop [i :range [1 101]

:let [fizz (zero? (% i 3))

buzz "buzz"

i)))

 

=={{header|Java}}==

public class FizzBuzz {

public static void main(String[] args) {

}

}

'''Or: '''

public class FizzBuzz {

public static void main(String[] args) {

}

}

'''Or: '''

public class FizzBuzz {

public static void main(String[] args) {

}

}

 

=={{header|JavaScript}}==

===ES5===

 

var i, output;

for (i = 1; i < 101; i += 1) {

console.log(output || i);//empty string is false, so we short-circuit

}

 

Alternate version with ghetto pattern matching

console.log({

truefalse: 'Fizz',

truetrue: 'FizzBuzz'

}[(i%3==0) + '' + (i%5==0)] || i)

 

Or very tersely:

 

Or with even less characters:

 

Or, in a more functional style, without mutations

return i ? rng(i - 1).concat(i) : []

})(100).map(

)

}

 

===ES6===

 

// FIZZBUZZ --------------------------------------------------------------

map(fizzBuzz, enumFromTo(1, 100))

);

 

A functional implementation:

 

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)

 

 

 

{{Trans|Python}}

{{Trans|Haskell}}

'use strict';

 

// MAIN ---

return main();

 

=={{header|Joy}}==

 

=={{header|jq}}==

| if . % 15 == 0 then "FizzBuzz"

elif . % 5 == 0 then "Buzz"

elif . % 3 == 0 then "Fizz"

else .

 

Another solution:

 

(select(. % 3 == 0) | "Fizz"),

(select(. % 5 == 0) | "Buzz")

) // tostring] | join("")

 

=={{header|Julia}}==

 

One basic solution:

if i % 15 == 0

println("FizzBuzz")

println(i)

end

 

Another possible solution:

 

A 3rd possible solution:

 

A 4th one:

 

A fifth (DRY, Don't Repeat Yourself) possible solution:

msg = "Fizz" ^ (i % 3 == 0) * "Buzz" ^ (i % 5 == 0)

println(isempty(msg) ? i : msg)

 

=={{header|K}}==

===Solution 0===

 

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

v:1+!x

i:(&0=)'v!/:3 5 15

@[r;i 2;{"FizzBuzz"}]}

 

 

===Solution 3===

For k6 and oK, change <code>x!'3 5</code> to <code>3 5!'x</code>.

 

 

This will only work up to 100 because Kamailio terminates all while loops after 100 iterations.

log_stderror=yes

loadmodule "pv"

$var(i) = $var(i) + 1;

}

 

=={{header|Kaya}}==

program fizzbuzz;

 

Void main() {

fizzbuzz(100);

 

=={{header|KL1}}==

:- module main.

 

display(Rest).

display([]).

 

=={{header|Klong}}==

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

 

=={{header|Kotlin}}==

 

===Imperative solution===

for (number in 1..100) {

println(

)

}

 

===Functional solution 1===

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

 

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

 

===Functional solution 2===

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

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

}

 

=={{header|KQL}}==

range i from 1 to 100 step 1

| project Result =

tostring(i)

)

 

=={{header|KSI}}==

`plain

[1 100] `for pos : n ~

(out `or n) #write_ln #

;

 

=={{header|LabVIEW}}==

 

=={{header|Lambdatalk}}==

1. direct:

 

-> same as above.

 

 

=={{header|langur}}==

 

writeln if(.i div 15: "FizzBuzz"; .i div 5: "Buzz"; .i div 3: "Fizz"; .i)

 

=={{header|Lasso}}==

 

=={{header|LaTeX}}==

{{libheader|intcalc}}

This version uses the ifthen and intcalc packages. There sure are more native solutions including solutions in plain TeX, but for me this is a readable and comprehensible one.

\usepackage{ifthen}

\usepackage{intcalc}

\begin{document}

\fizzBuzz{101}

 

=={{header|Liberty BASIC}}==

 

=={{header|LIL}}==

for {set i 1} {$i <= 100} {inc i} {

set show ""

if {[expr [length $show] == 0]} {set show $i}

print $show

 

{{out}}

 

=={{header|LiveCode}}==

switch

case i mod 15 = 0

end switch

end repeat

 

=={{header|LiveScript}}==

See: http://livescript.net/blog/fizzbuzzbazz.html

 

=={{header|LLVM}}==

; source_filename = "fizzbuzz.c"

; target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"

!0 = !{i32 1, !"wchar_size", i32 2}

!1 = !{i32 7, !"PIC Level", i32 2}

 

=={{header|Lobster}}==

 

forbias(100, 1) i:

fb := (i % 3 == 0 and "fizz" or "") +

(i % 5 == 0 and "buzz" or "")

 

=={{header|Logo}}==

output cond [ [[equal? 0 modulo :n 15] "FizzBuzz]

[[equal? 0 modulo :n 5] "Buzz]

end

 

"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:

make "c "

if equal? 0 modulo :n 5 [make "c "Buzz]

end

 

Lhogho can use the above code, except that 'modulo' must be replaced with 'remainder'.

 

 

=={{header|LSE}}==

10 CHAINE FB

20 FAIRE 45 POUR I_1 JUSQUA 100

50 TERMINER

100 PROCEDURE &MOD(A,B) LOCAL A,B

 

=={{header|Lua}}==

===If/else Ladder===

if i % 15 == 0 then

print("FizzBuzz")

print(i)

end

===Concatenation===

output = ""

if i % 3 == 0 then

end

print(output)

 

===Quasi bit field===

 

for i = 1, 100 do

print(word[(i % 3 == 0 and 1 or 0) + (i % 5 == 0 and 2 or 0)] or i)

 

===Lookup table===

[0] = "FizzBuzz",

[3] = "Fizz",

for i = 1, 100 do

print(t[i%15] or i)

 

=== Fast Version without Modulo ===

#!/usr/bin/env luajit

local to=arg[1] or tonumber(arg[1]) or 100

io.write(", ")

end

 

{{out}}

 

=={{header|Luck}}==

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)

 

=={{header|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

If a$<>"" Then Print a$, else Print i,

End Sub

 

=={{header|M4}}==

`ifelse($#,0,``$0'',

`ifelse(eval($2<=$3),1,

`ifelse(eval(x%3==0),1,Fizz,

`ifelse(eval(x%5==0),1,Buzz,x)')')

 

=={{header|make}}==

{{works with|BSD make}}

{{libheader|jot}}

MOD5 = 0

ALL != jot 100

. endif

 

 

=={{header|Maple}}==

One line:

With a fizzbuzz function defined:

Using piecewise:

Using conventional if/then branches:

r:=map2(modp,n,[3,5]);

if r=[0,0] then "FizzBuzz"

else n fi;

end proc:

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Using rules,

buzz[i_] := Mod[i, 5] == 0

Range[100] /. {i_ /; fizz[i]&&buzz[i] :> "FizzBuzz", \

Using rules, but different approach:

f[n_ /; Mod[n, 15] == 0] := "FizzBuzz";

f[n_ /; Mod[n, 3] == 0] := "Fizz";

f[n_] := n;

 

An extendible version using Table

Table[If[Divisible[i, First@nw], Last@nw, ""],

{nw, {{3, "Fizz"}, {5, "Buzz"}}}]],

Another one-liner using Map (the /@ operator shorthand of it) and a pure function with a very readable Which

 

=={{header|MATLAB}}==

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

for i = (1:100)

if mod(i,15) == 0

end

fprintf('\n');

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

nums = [3, 5];

words = {'fizz', 'buzz'};

end

end

 

=={{header|Maxima}}==

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

 

=={{header|MAXScript}}==

(

case of

default: (print i)

)

 

=={{header|MEL}}==

{

if($i % 15 == 0)

else

print ($i + "\n");

 

=={{header|Mercury}}==

:- interface.

:- import_module io.

else

true

 

=={{header|Metafont}}==

message if i mod 15 = 0: "FizzBuzz" &

elseif i mod 3 = 0: "Fizz" &

else: decimal i & fi "";

endfor

 

=={{header|Microsoft Small Basic}}==

{{trans|GW-BASIC}}

For n = 1 To 100

op = ""

EndIf

EndFor

 

=={{header|min}}==

{{works with|min|0.19.3}}

succ false :hit

(3 mod 0 ==) ("Fizz" print! true @hit) when

(5 mod 0 ==) ("Buzz" print! true @hit) when

(hit) (print) unless newline

 

=={{header|MiniScript}}==

if i % 15 == 0 then

print "FizzBuzz"

print i

end if

 

=={{header|MIPS Assembly}}==

#################################

# Fizz Buzz #

li $v0,10

syscall

 

=={{header|Mirah}}==

print "Fizz" if a = ((n % 3) == 0)

print "Buzz" if b = ((n % 5) == 0)

print n unless (a || b)

print "\n"

 

A little more straight forward:

if (n % 15) == 0

puts "FizzBuzz"

puts n

end

 

=={{header|ML}}==

==={{header|Standard ML}}===

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

fun fbstr i =

case (i mod 3 = 0, i mod 5 = 0) of

fun fizzbuzz n = fizzbuzz' (n, 1)

val _ = fizzbuzz 100

 

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

fun fb i = let val fizz = i mod 3 = 0 andalso (print "Fizz"; true)

val buzz = i mod 5 = 0 andalso (print "Buzz"; true)

fun fizzbuzz n = (List.tabulate (n, fn i => (fb (i+1); print "\n")); ())

val _ = fizzbuzz 100

 

==={{header|mLite}}===

fun fizzbuzz'

(x mod 15 = 0) = "FizzBuzz"

 

println ` fizzbuzz ` iota 100;

 

=={{header|MMIX}}==

Ja IS $127

 

JMP 1B % repeat for next i

4H XOR t,t,t

 

=={{header|Modula-2}}==

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

 

ReadChar

 

=={{header|Modula-3}}==

 

IMPORT IO;

END;

END;

 

=={{header|Monte}}==

 

var t := 1

while (t < top):

 

fizzBuzz(100)

 

=={{header|MontiLang}}==

 

1 VAR i .

 

ENDIF

i 1 + VAR i .

 

=={{header|MoonScript}}==

 

print ((a) -> a == "" and i or a) table.concat {

i % 3 == 0 and "Fizz" or ""

 

=={{header|MUMPS}}==

NEW I

FOR I=1:1:100 WRITE !,$SELECT(('(I#3)&'(I#5)):"FizzBuzz",'(I#5):"Buzz",'(I#3):"Fizz",1:I)

KILL I

 

for i=1:1:100 do write !

 

=={{header|Nanoquery}}==

if ((i % 3) = 0) and ((i % 5) = 0)

println "FizzBuzz"

println i

end

 

=={{header|NATURAL}}==

DEFINE DATA

LOCAL

*

END

 

=={{header|Neko}}==

 

while(i < 100) {

 

i ++= 1

 

=={{header|Nemerle}}==

The naive approach:

using System.Console;

 

WriteLine($"$(FizzBuzz(i))")

}

A much slicker approach is [http://www.dreamincode.net/forums/blog/217/entry-3539-fizzbuzz-in-nemerle/ posted here]

 

=={{header|NetRexx}}==

select

when j//15==0 then say 'FizzBuzz'

otherwise say j.right(4)

end

 

=={{header|Never}}==

{

var i = 1;

 

0

 

{{out}}

 

=={{header|NewLISP}}==

(println

(cond

((= 0 (% i 3)) "Fizz")

((= 0 (% i 5)) "Buzz")

 

=={{header|NewtonScript}}==

begin

if i mod 15 = 0 then

print(i);

print("\n")

 

=={{header|Nickle}}==

 

void function fizzbuzz(size) {

}

 

 

=={{header|Nim}}==

{{trans|Python}}

if i mod 15 == 0:

echo("FizzBuzz")

echo("Buzz")

else:

 

===Without Modulus===

var acc = 810092048

for i in 1..100:

var c = acc and 3

echo(if c == 0: $i else: messages[c])

 

===Using macro===

Computes everything at compile time.

macro FizzBuzz(N): untyped =

var source = ""

result = parseStmt(source)

 

 

=={{header|Nix}}==

with builtins;

let

fizzbuzz { x = x + 1; } else "");

in

 

=={{header|Oberon-2}}==

 

IMPORT Out;

Out.Ln

END

 

=={{header|Objeck}}==

class Fizz {

function : Main(args : String[]) ~ Nil {

}

}

 

=={{header|Objective-C}}==

#import <Foundation/Foundation.h>

 

}

}

 

=={{header|OCaml}}==

Idiomatic OCaml to solve the stated problem:

 

match i mod 3, i mod 5 with

0, 0 -> "FizzBuzz"

let _ =

 

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:

 

let (=>) cond f a = if cond then f a else a

let append s a = a^s

|> (i mod 5 = 0 => append "Buzz")

|> (function "" -> string_of_int i

 

=={{header|Octave}}==

if ( mod(i,15) == 0 )

disp("FizzBuzz");

disp(i)

endif

 

=={{header|Oforth}}==

 

| i |

100 loop: i [

i 5 mod ifZero: [ "Buzz" + ]

dup ifNull: [ drop i ] .

 

=={{header|Ol}}==

(for-each (lambda (x)

(print (cond

x))))

(iota 100))

=={{header|OOC}}==

if(n % 3 == 0) {

printf("Fizz")

println()

}

 

=={{header|Order}}==

 

// Get FB for one number

ORDER_PP( // foreach instead of map, to print but return nothing

8seq_for_each(8compose(8print_el, 8fizzbuzz), 8seq_iota(1, 100))

 

=={{header|Oz}}==

fun {FizzBuzz X}

if X mod 15 == 0 then 'FizzBuzz'

for I in 1..100 do

{Show {FizzBuzz I}}

 

=={{header|PARI/GP}}==

print(if(n%3,

if(n%5,

)

))

 

=={{header|Pascal}}==

var

i: integer;

else

writeln(i)

 

=={{header|PDP-8 Assembly}}==

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

 

/--------------------------------------------------------

/THIS PROGRAM PRINTS THE INTEGERS FROM 1 TO 100 (INCL).

CR; LF; EOT

$

 

Output:

=={{header|Peloton}}==

Variable-length padded English dialect

<# TEST ISITMODULUSZERO PARAMETER LITERAL>1|3</#>

<# TEST ISITMODULUSZERO PARAMETER LITERAL>1|5</#>

<# NEITHER><# SAY PARAMETER>1</#></#>

</#></#>

Fixed-length English dialect

<@ TSTMD0PARLIT>1|3</@>

<@ TSTMD0PARLIT>1|5</@>

<@ NTH><@ SAYPAR>1</@></@>

</@></@>

 

=={{header|Perl}}==

use strict;

use warnings;

: $i % 5 == 0 ? "Buzz"

: $i;

 

More concisely:

 

 

For code-golfing:

 

 

For array of values:

 

 

Cheating:

 

use feature "say";

 

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

 

 

as a subroutine:

 

sub fizz_buzz {

join("\n", map {

}

print fizz_buzz;

 

By transforming a list:

 

@FB1 = (1..100);

@FB2 = map{!($_%3 or $_%5)?'FizzBuzz': $_}@FB1;

@FB5 = map{$_."\n"}@FB4;

print @FB5;

 

=={{header|Phix}}==

{{libheader|Phix/basics}}

{{trans|C}}

<span style="color: #008080;">constant</span> <span style="color: #000000;">x</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{<span style="color: #008000;">"%d\n"<span style="color: #0000FF;">,<span style="color: #008000;">"Fizz\n"<span style="color: #0000FF;">,<span style="color: #008000;">"Buzz\n"<span style="color: #0000FF;">,<span style="color: #008000;">"FizzBuzz\n"<span style="color: #0000FF;">}</span>

<span style="color: #008080;">for</span> <span style="color: #000000;">i<span style="color: #0000FF;">=<span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">100</span> <span style="color: #008080;">do</span>

<span style="color: #7060A8;">printf<span style="color: #0000FF;">(<span style="color: #000000;">1<span style="color: #0000FF;">,<span style="color: #000000;">x<span style="color: #0000FF;">[<span style="color: #000000;">1<span style="color: #0000FF;">+<span style="color: #0000FF;">(<span style="color: #7060A8;">remainder<span style="color: #0000FF;">(<span style="color: #000000;">i<span style="color: #0000FF;">,<span style="color: #000000;">3<span style="color: #0000FF;">)<span style="color: #0000FF;">=<span style="color: #000000;">0<span style="color: #0000FF;">)<span style="color: #0000FF;">+<span style="color: #000000;">2<span style="color: #0000FF;">*<span style="color: #0000FF;">(<span style="color: #7060A8;">remainder<span style="color: #0000FF;">(<span style="color: #000000;">i<span style="color: #0000FF;">,<span style="color: #000000;">5<span style="color: #0000FF;">)<span style="color: #0000FF;">=<span style="color: #000000;">0<span style="color: #0000FF;">)<span style="color: #0000FF;">]<span style="color: #0000FF;">,<span style="color: #000000;">i<span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for

Two variants with tabulated output:

<span style="color: #008080;">function</span> <span style="color: #000000;">f<span style="color: #0000FF;">(<span style="color: #004080;">integer</span> <span style="color: #000000;">i<span style="color: #0000FF;">)</span>

<span style="color: #004080;">integer</span> <span style="color: #000000;">idx</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1<span style="color: #0000FF;">+<span style="color: #0000FF;">(<span style="color: #7060A8;">remainder<span style="color: #0000FF;">(<span style="color: #000000;">i<span style="color: #0000FF;">,<span style="color: #000000;">3<span style="color: #0000FF;">)<span style="color: #0000FF;">=<span style="color: #000000;">0<span style="color: #0000FF;">)<span style="color: #0000FF;">+<span style="color: #000000;">2<span style="color: #0000FF;">*<span style="color: #0000FF;">(<span style="color: #7060A8;">remainder<span style="color: #0000FF;">(<span style="color: #000000;">i<span style="color: #0000FF;">,<span style="color: #000000;">5<span style="color: #0000FF;">)<span style="color: #0000FF;">=<span style="color: #000000;">0<span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>

<span style="color: #7060A8;">printf<span style="color: #0000FF;">(<span style="color: #000000;">1<span style="color: #0000FF;">,<span style="color: #7060A8;">join_by<span style="color: #0000FF;">(<span style="color: #7060A8;">apply<span style="color: #0000FF;">(<span style="color: #7060A8;">tagset<span style="color: #0000FF;">(<span style="color: #000000;">100<span style="color: #0000FF;">)<span style="color: #0000FF;">,<span style="color: #000000;">f<span style="color: #0000FF;">)<span style="color: #0000FF;">,<span style="color: #000000;">10<span style="color: #0000FF;">,<span style="color: #000000;">10<span style="color: #0000FF;">)<span style="color: #0000FF;">)

(output same as below)

<span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">apply<span style="color: #0000FF;">(<span style="color: #004600;">true<span style="color: #0000FF;">,<span style="color: #7060A8;">sprintf<span style="color: #0000FF;">,<span style="color: #0000FF;">{<span style="color: #0000FF;">{<span style="color: #008000;">"%-8d"<span style="color: #0000FF;">}<span style="color: #0000FF;">,<span style="color: #7060A8;">tagset<span style="color: #0000FF;">(<span style="color: #000000;">100<span style="color: #0000FF;">)<span style="color: #0000FF;">}<span style="color: #0000FF;">)</span>

<span style="color: #008080;">for</span> <span style="color: #000000;">i<span style="color: #0000FF;">=<span style="color: #000000;">3</span> <span style="color: #008080;">to</span> <span style="color: #000000;">100</span> <span style="color: #008080;">by</span> <span style="color: #000000;">3</span> <span style="color: #008080;">do</span> <span style="color: #000000;">s<span style="color: #0000FF;">[<span style="color: #000000;">i<span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"Fizz "</span> <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #008080;">for</span> <span style="color: #000000;">i<span style="color: #0000FF;">=<span style="color: #000000;">15</span> <span style="color: #008080;">to</span> <span style="color: #000000;">100</span> <span style="color: #008080;">by</span> <span style="color: #000000;">15</span> <span style="color: #008080;">do</span> <span style="color: #000000;">s<span style="color: #0000FF;">[<span style="color: #000000;">i<span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"FizzBuzz"</span> <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #7060A8;">printf<span style="color: #0000FF;">(<span style="color: #000000;">1<span style="color: #0000FF;">,<span style="color: #7060A8;">join_by<span style="color: #0000FF;">(<span style="color: #000000;">s<span style="color: #0000FF;">,<span style="color: #000000;">10<span style="color: #0000FF;">,<span style="color: #000000;">10<span style="color: #0000FF;">)<span style="color: #0000FF;">)

{{out}}

<pre>

</pre>

Grotesquely inefficient (non-tabulated output), just for fun. Can you do worse, yet keep it semi-plausibile that someone might have actually earnestly written it?

<span style="color: #008080;">constant</span> <span style="color: #000000;">threes</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">tagset<span style="color: #0000FF;">(<span style="color: #000000;">100<span style="color: #0000FF;">,<span style="color: #000000;">0<span style="color: #0000FF;">,<span style="color: #000000;">3<span style="color: #0000FF;">)<span style="color: #0000FF;">,</span>

<span style="color: #000000;">fives</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">tagset<span style="color: #0000FF;">(<span style="color: #000000;">100<span style="color: #0000FF;">,<span style="color: #000000;">0<span style="color: #0000FF;">,<span style="color: #000000;">5<span style="color: #0000FF;">)<span style="color: #0000FF;">,</span>

<span style="color: #7060A8;">printf<span style="color: #0000FF;">(<span style="color: #000000;">1<span style="color: #0000FF;">,<span style="color: #008000;">"\n"<span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for