FizzBuzz: Difference between revisions

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

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

int max = 100;

for(int i=0;

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>

</syntaxhighlight>

===with modulo===

using namespace std;

}</syntaxhighlight>

===without modulo 15===

using namespace std;

===without modulo===

Modulo can be expensive on some architectures.

int main()

===using std::transform===

{{works with|C++11}}

#include <algorithm>

#include <vector>

===metaprogramming===

Version computing FizzBuzz at compile time with metaprogramming:

template <int n, int m3, int m5>

===hardcore templates===

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

#include <string>

#include <cstdlib>

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

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

0020 IF i# MOD 15=0 THEN

0030 PRINT "FizzBuzz"

0100 ENDIF

0110 ENDFOR i#

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

=={{header|Coq}}==

Require Import Coq.Lists.List.

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

(** This shows the string. *)

Eval compute in fizz_buzz.

===Straightforward version===

var i: uint8 := 1;

print_nl();

i := i + 1;

===No division===

98-byte executable.)