General FizzBuzz: Difference between revisions

</pre>

<br><br>

 

=={{header|AppleScript}}==

 

 

end |λ|

end script

end |λ|

end script

 

on run

end run

 

 

 

 

-- foldl :: (a -> b -> a) -> a -> [b] -> a

end foldl

 

on mReturn(f)

f

else

end script

end if

{{Out}}

<pre>1

19

Buzz</pre>

 

=={{header|AWK}}==

 

;Usage:

 

;Program:

<!-- http://ideone.com/fACMfK -->

<!-- (!!) Note: the sandbox at ideone.com does not allow output to files -->

#

function Print(s) {

print "END {print " q2 "# Done." q2 "}"

Print( "# Done." )

 

Example output see [[FizzBuzz/AWK#Custom_FizzBuzz]]

 

=={{header|Batch File}}==

 

)

 

)

pause

{{Out}}

2

Fizz

Buzz

Press any key to continue . . .</pre>

 

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

This implementation (unlike some of the ones given on this page...) fully obeys the specification, in that it prompts the user for the parameters at run time. It also allows users to specify as many factors as they want, rather than limiting them to three.

INPUT "Maximum number: " max%

INPUT "Number of factors: " n%

NEXT

IF matched% THEN PRINT ELSE PRINT;i%

Output:

<pre>Maximum number: 20

19

Buzz</pre>

 

=={{header|C}}==

#include <stdio.h>

#include <stdlib.h>

return 0;

}

{{out}}

<pre>

Buzz

</pre>

 

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

#include <algorithm>

#include <iostream>

return 0;

}

{{out}}

<pre>

</pre>

 

 

 

{{out}}<pre>SAMPLES>do ^GENFIZBUZZ(12,"FIN,FANG,FOOM","2,3,4")

 

=={{header|Ceylon}}==

print("enter the max value");

}

}

 

=={{header|Clojure}}==

(map second pairs))

 

(apply str

(fix f)))))

 

'''Usage:'''

 

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

(defun fizzbuzz (limit factor-words)

(loop for i from 1 to limit

(not (zerop (parse-integer input :junk-allowed t))))

finally (fizzbuzz (parse-integer input :junk-allowed t) (read-factors))))

 

=={{header|D}}==

import std.stdio;

 

}

}

 

{{out}}

19

Buzz</pre>

 

=={{header|Elixir}}==

{{trans|Ruby}}

def fizzbuzz(input) do

[num | nwords] = String.split(input)

7 Baxx

"""

 

{{out}}

 

=={{header|Erlang}}==

%%% @doc Implementation of General FizzBuzz

%%% @see https://rosettacode.org/wiki/General_FizzBuzz

[fizzbuzz(X, Factors, []) || X <- lists:seq(1, N)]

).

'''Usage:'''

<pre>

 

=={{header|Factor}}==

math.ranges prettyprint sequences splitting ;

IN: rosetta-code.general-fizzbuzz

: main ( -- ) get-input [ fizzbuzz ] with each ;

 

{{out}}

<pre>

Uses GForth specific words ']]' and '[['.

If your forth does not have them: Sequence ']] A B C .. [[' is equivalent with 'postpone A postpone B postpone C ..'

: times ( xt n -- )

BEGIN dup WHILE

\ Example:

\ 1 fb[ 3 s" fizz" ]+[ 5 s" buzz" ]+[ 7 s" dizz" ]+[ ]fb 40 times drop

{{out}}

<pre>

1 2 F 4 B F G 8 F B 11 F 13 G FB 16 17 F 19 B FG 22 23 F B 26 F G 29 FB 31 32 F 34 BG F 37 38 F B

</pre>

=={{header|FreeBASIC}}==

{{trans|BBC BASIC}}

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>Enter maximum number, if number < 1 then the program wil end 110

109

Buzz</pre>

 

=={{header|Go}}==

package main

 

}

 

 

=={{header|Groovy}}==

(1..40).each {Integer value -> log +=(value %3 == 0) ? (value %5 == 0)? 'FIZZBUZZ\n':(value %7 == 0)? 'FIZZBAXX\n':'FIZZ\n'

:(value %5 == 0) ? (value %7 == 0)? 'BUZBAXX\n':'BUZZ\n'

:(value+'\n')}

println log

<pre>

1

BUZZ

</pre>

 

=={{header|Haskell}}==

 

fizz a xs

| null result = show a

mapM_ (\ x -> putStrLn $ fizz x multiples) [1..n]

where convert [x, y] = (read x, y)

 

Or, as a function which takes a list of rules as an argument:

 

 

 

where

where

noise = foldl reWrite [] rules

 

main :: IO ()

{{Out}}

<pre>1

The trick here involves looking for where the factors evenly divide the counting numbers. Where no factor is relevant we use the counting number, an in the remaining cases we use the string which corresponds to the factor:

 

:

b=. * x|/1+i.y

>,&":&.>/(m#inv"_1~-.b),(*/b)#&.>1+i.y

 

Example use:

 

1

2

Fizz

19

 

For our example, b looks like this:

 

1 1 1 1 0 1 1 1 1 0 1 1 1 1 0 1 1 1 1 0

 

<code>*/b</code> gives us 1s where we want numbers and 0s where we want to plug in the strings:

 

 

<code>m</code> is our strings, and #inv expands values out to match a selection. So, in our example, <code>m#inv"_1~-.b</code> looks like this:

 

│││Fizz││ │Fizz│ ││Fizz│ ││Fizz││ │Fizz│││Fizz││ │

├┼┼────┼┼────┼────┼────┼┼────┼────┼┼────┼┼────┼────┼┼┼────┼┼────┤

├┼┼────┼┼────┼────┼────┼┼────┼────┼┼────┼┼────┼────┼┼┼────┼┼────┤

│││ ││ │ │Baxx││ │ ││ ││Baxx│ │││ ││ │

 

All that remains is to assemble these pieces into the final result...

 

=={{header|Java}}==

 

public static void main(String[] args) {

}

 

 

 

'''For a more complete example see [[/jFizzBuzz|jFizzBuzz]]'''

 

=={{header|JavaScript}}==

 

First as compacted by Google's Closure compiler:

return function b(a) {

return a ? b(a - 1).concat(a) : [];

}, "") || a.toString()) + "\n";

}, "");

 

and then in the original expanded form, for better legibility:

 

 

return (

}

 

 

{{out}}

===ES6===

 

const range = (min, max) =>

Array.from({ length: max - min }, (_, i) => min + i)

).join('\n')

 

 

{{Out}}

=={{header|Julia}}==

For simplicity, assume that the user will enter valid input.

for i = 1 : upper

triggered = false

 

println("EOF\n")

 

{{out}}

=={{header|Kotlin}}==

 

 

//Read the maximum number, set to 0 if it couldn't be read

println(i)

}

 

=={{header|LiveCode}}==

put f1 & cr & f2 & cr & f3 into factors

sort factors ascending numeric

end repeat

return fizzbuzz

 

=={{header|Lua}}==

local response

print("\n")

param.factor[i], param.word[i] = io.read("*number", "*line")

end

 

=== Without modulo ===

{{trans|Python}}

local res = {}

 

print(fizzbuzz(n, mods))

end

 

{{out}}

7

broccoli </pre>

 

=={{header|Maple}}==

local i;

i := 1:

if (not factored) then printf("%d", i): end if:

printf("\n");

{{Out|Output}}

<pre>1

Buzz</pre>

 

runTo=(*LCM@@list[[All,1]]+1*)20;

Column@Table[

Select[list,Mod[x,#[[1]]]==0&][[All,2]]/.{}->{x}

,{x,1,runTo}

 

<pre>1

13

Baxx

FizzBuzz

16

 

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

FROM Conversions IMPORT StrToInt;

FROM FormatString IMPORT FormatString;

 

ReadChar

 

=={{header|Nim}}==

This solution has no input validation

import parseutils, strutils, algorithm

 

 

 

 

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

{{works with|PARI/GP|2.8.0+}}

This version uses a variadic argument to allow more or less than 3 factors. It could be easily modified for earlier versions, either by taking a vector rather than bare arguments (making the call <code>fizz(20,[[3,"Fizz"],[5,"Buzz"],[7,"Baxx"]])</code>) or to support exactly factors (keeping the call the same).

{

v=vecsort(v,1);

);

}

{{out}}

<pre>1

 

=={{header|Perl}}==

#!bin/usr/perl

use 5.020;

}

}

 

{{out}}

</pre>

 

1

2

19

Buzz

 

 

}

}

 

 

{{out}}

1

2

Buzz

Fizz

8

Fizz

Fizz

13

FizzBuzz

16

19

Buzz

 

=={{header|PicoLisp}}==

(for A N

(prinl

A ) ) ) )

 

 

{{out}}

 

=={{header|PowerShell}}==

$data = @("3 Fizz","5 Buzz","7 Baxx")

#An array with whitespace as the delimiter

Write-HoSt $outP

}

{{Out}}

<pre>PS> ./GENFB

Buzz

PS></pre>

 

=={{header|Python}}==

lines = []

for num in numbers:

lines.append(words if words else str(num))

return '\n'.join(lines)

 

if __name__ == '__main__':

 

{{out}}

Buzz</pre>

 

 

{{works with|Python|3.x}}

 

3: "Fizz",

5: "Buzz",

}

 

factors = defaultdict(list)

 

res = ''

 

if __name__ == '__main__':

for line in fizzbuzz(n, mods):

print(line)

 

 

n = 100

 

print(fizzbuzz(n, mods))

 

{{Out}}

</pre>

 

 

 

 

{{out}}

2

Fizz

Fizz

19

 

 

 

 

 

{{out}}

<pre>1

19

Buzz</pre>

 

=={{header|REXX}}==

parse arg h $ /*obtain optional arguments from the CL*/

if $='' | $="," then $= "3 Fizz 5 Buzz 7 Baxx" /* " " " " " " */

 

<pre>

1

</pre>

 

parse arg h $ /*obtain optional arguments from the CL*/

if $='' | $="," then $= "3 Fizz 5 Buzz 7 Baxx" /* " " " " " " */

 

 

=={{header|Ring}}==

limit = 20

for n = 1 to limit

next

 

 

=={{header|Ruby}}==

num, *nword = text.split

num = num.to_i

EOS

 

 

{{out}}

=={{header|Rust}}==

 

use std::io::BufRead;

 

}

}

 

This solution stores the Fizz Buzz state in a struct, leveraging types and the standard library for a more general solution:

 

use std::fmt::{self, Write};

use std::io::{self, Stdin};

assert_eq!(expected, &printed);

}

 

=={{header|Sidef}}==

method filter(this) {

var fb = ''

}

 

{{out}}

<pre>

</pre>

 

 

 

 

}

 

 

{{out}}

 

1

2

4

8

11

13

16

17

19

 

=={{header|Tailspin}}==

templates sayWords

def i: $;

templates maybeSay

def word: $.word;

end maybeSay

$input.words... -> maybeSay !

end sayWords

' -> !OUT::write

{{out}}

<pre>

For fun, the below implementation is a compatible extension of [[FizzBuzz#Tcl]]:

 

if {$args eq ""} {

set args {{3 Fizz} {5 Buzz}}

}

}

 

=={{header|Ursa}}==

This program reads a max number, then reads factors until the user enters a blank line.

# general fizzbuzz

#

end if

out endl console

Output:

<pre>>20

19

Buzz</pre>

=={{header|VBA}}==

Option Explicit

 

If StrPtr(UserChoice.Name) <> 0 And UserChoice.Number < MaxNumber Then ok = True

Loop

{{out}}

With the entry :

 

=={{header|VBScript}}==

Function FizzBuzz(range, mapping)

data = Array()

y = WScript.StdIn.ReadLine

WScript.StdOut.WriteLine ""

{{Out|Sample Run}}

<pre>\Desktop>cscript /nologo fizzbuzz.vbs

 

=={{header|Visual Basic .NET}}==

 

Module Program

Next

End Sub

 

{{out}}

19

Buzz</pre>

 

=={{header|zkl}}==

fizzBuzzers:=List();

do(3){ n,txt:=ask(">").split(); fizzBuzzers.append(T(n.toInt(),txt)) }

s:=fizzBuzzers.filter('wrap([(fb,txt)]){ n%fb==0 }).apply("get",1).concat();

println(s or n);

{{out}}

<pre>

=={{header|ZX Spectrum Basic}}==

{{trans|BBC_BASIC}}

20 INPUT "Number of factors: ";n

30 DIM f(n): DIM w$(n,4)

130 PRINT

140 NEXT i