I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

# Factorial

Factorial
You are encouraged to solve this task according to the task description, using any language you may know.
Definitions
•   The factorial of   0   (zero)   is defined as being   1   (unity).
•   The   Factorial Function   of a positive integer,   n,   is defined as the product of the sequence:
                 n,   n-1,   n-2,   ...   1


Write a function to return the factorial of a number.

Solutions can be iterative or recursive.

Support for trapping negative   n   errors is optional.

## 0815

This is an iterative solution which outputs the factorial of each number supplied on standard input.

factorial: $[n][ fold.seed:1 1..n [a,b][a*b]] ### Product factorial:$[n][product 1..n] loop 1..19 [x][	print ["Factorial of" x "=" factorial x]]
Output:
Factorial of 1 = 1
Factorial of 2 = 2
Factorial of 3 = 6
Factorial of 4 = 24
Factorial of 5 = 120
Factorial of 6 = 720
Factorial of 7 = 5040
Factorial of 8 = 40320
Factorial of 9 = 362880
Factorial of 10 = 3628800
Factorial of 11 = 39916800
Factorial of 12 = 479001600
Factorial of 13 = 6227020800
Factorial of 14 = 87178291200
Factorial of 15 = 1307674368000
Factorial of 16 = 20922789888000
Factorial of 17 = 355687428096000
Factorial of 18 = 6402373705728000
Factorial of 19 = 121645100408832000

## AsciiDots

;AutoIt Version: 3.2.10.0MsgBox (0,"Factorial",factorial(6))Func factorial($int) if$int < 0 Then      return 0   Elseif $int == 0 Then return 1 EndIf return$int * factorial($int - 1)EndFunc ## Avail Avail has a built-in factorial method using the standard exclamation point. Assert: 7! = 5040; Its implementation is quite simple, using iterative left fold_through_. Method "_!" is [n : [0..1] | 1]; Method "_!" is[ n : [2..∞)| left fold 2 to n through [k : [2..∞), s : [2..∞) | k × s]]; ## AWK Recursive function fact_r(n){ if ( n <= 1 ) return 1; return n*fact_r(n-1);} Iterative function fact(n){ if ( n < 1 ) return 1; r = 1 for(m = 2; m <= n; m++) { r *= m; } return r} ## Axe Iterative Lbl FACT1→RFor(I,1,r₁) R*I→REndRReturn Recursive Lbl FACTr₁??1,r₁*FACT(r₁-1)Return ## Babel ### Iterative ((main {(0 1 2 3 4 5 6 7 8 9 10) {fact ! %d nl <<} each}) (fact {({dup 0 =}{ zap 1 } {dup 1 =}{ zap 1 } {1 }{ <- 1 {iter 1 + *} -> 1 - times }) cond})) ### Recursive ((main {(0 1 2 3 4 5 6 7 8 9 10) {fact ! %d nl <<} each}) (fact {({dup 0 =}{ zap 1 } {dup 1 =}{ zap 1 } {1 }{ dup 1 - fact ! *}) cond}))  When run, either code snippet generates the following Output: 1 1 2 6 24 120 720 5040 40320 362880 3628800 ## BaCon Overflow occurs at 21 or greater. Negative values treated as 0. ' FactorialFUNCTION factorial(NUMBER n) TYPE NUMBER IF n <= 1 THEN RETURN 1 ELSE RETURN n * factorial(n - 1) ENDIFEND FUNCTION n = VAL(TOKEN$(ARGUMENT$, 2))PRINT n, factorial(n) FORMAT "%ld! = %ld\n" Output: prompt$ ./factorial 0
0! = 1
prompt$./factorial 20 20! = 2432902008176640000 ## bash ### Recursive factorial(){ if [$1 -le 1 ]  then    echo 1  else    result=$(factorial$[$1-1]) echo$((result*$1)) fi}  ## BASIC ### Iterative Works with: QBasic Works with: RapidQ FUNCTION factorial (n AS Integer) AS Integer DIM f AS Integer, i AS Integer f = 1 FOR i = 2 TO n f = f*i NEXT i factorial = fEND FUNCTION ### Recursive Works with: QBasic Works with: RapidQ FUNCTION factorial (n AS Integer) AS Integer IF n < 2 THEN factorial = 1 ELSE factorial = n * factorial(n-1) END IFEND FUNCTION ### Commodore BASIC All numbers in Commodore BASIC are stored as floating-point with a 32-bit mantissa. The maximum representable value is 1.70141183 × 1038, so it can handle factorials up to 33! = 8.68331762 × 1036, but only keeps 32 bits of precision. That means that what you see is what you get; the mantissa for 33! is 8.68331762 exactly instead of 8.68331761881188649551819440128. #### Iterative 10 REM FACTORIAL20 REM COMMODORE BASIC 2.030 INPUT "N=";N: GOSUB 10040 PRINT N;"! =";F50 GOTO 30100 REM FACTORIAL CALC USING SIMPLE LOOP110 F = 1120 FOR I=1 TO N130 F = F*I140 NEXT150 RETURN #### Recursive with memoization and demo The demo stops at 13!, which is when the numbers start being formatted in scientific notation. 100 REM FACTORIAL110 DIM F(35): F(0)=1: REM MEMOS120 DIM S(35): SP=0: REM STACK+PTR130 FOR I=1 TO 13140 : S(SP)=I: SP=SP+1: REM PUSH(I)150 : GOSUB 200160 : SP=SP-1: REM POP170 : PRINT I;"! = ";S(SP)180 NEXT I190 END200 REM FACTORIAL: S(SP-1) = S(SP-1)!210 IF F(S(SP-1)) THEN 240: REM MEMOIZED220 S(SP)=S(SP-1)-1: SP=SP+1: GOSUB 200: REM RECURSE230 SP=SP-1: F(S(SP-1))=S(SP-1)*S(SP): REM MEMOIZE240 S(SP-1)=F(S(SP-1)): REM PUSH(RESULT)250 RETURN Output:  1 ! = 1 2 ! = 2 3 ! = 6 4 ! = 24 5 ! = 120 6 ! = 720 7 ! = 5040 8 ! = 40320 9 ! = 362880 10 ! = 3628800 11 ! = 39916800 12 ! = 479001600 13 ! = 6.2270208E+09  ### GW-BASIC 10 INPUT "Enter a non/negative integer: ", N20 IF N < 0 THEN GOTO 1030 F# = 140 IF N = 0 THEN PRINT F# : END50 F# = F# * N60 N = N - 170 GOTO 40 ### IS-BASIC 100 DEF FACT(N)110 LET F=1120 FOR I=2 TO N130 LET F=F*I140 NEXT150 LET FACT=F160 END DEF ### Sinclair ZX81 BASIC #### Iterative  10 INPUT N 20 LET FACT=1 30 FOR I=2 TO N 40 LET FACT=FACT*I 50 NEXT I 60 PRINT FACT Input: 13 Output: 6227020800 #### Recursive A GOSUB is just a procedure call that doesn't pass parameters.  10 INPUT N 20 LET FACT=1 30 GOSUB 60 40 PRINT FACT 50 STOP 60 IF N=0 THEN RETURN 70 LET FACT=FACT*N 80 LET N=N-1 90 GOSUB 60100 RETURN Input: 13 Output: 6227020800 ### Tiny BASIC 10 LET F = 120 PRINT "Enter an integer."30 INPUT N40 IF N = 0 THEN GOTO 8050 LET F = F * N60 LET N = N - 170 GOTO 4080 PRINT F ## BASIC256 ### Iterative print "enter a number, n = ";input nprint string(n) + "! = " + string(factorial(n)) function factorial(n) factorial = 1 if n > 0 then for p = 1 to n factorial *= p next p end ifend function ### Recursive print "enter a number, n = ";input nprint string(n) + "! = " + string(factorial(n)) function factorial(n) if n > 0 then factorial = n * factorial(n-1) else factorial = 1 end ifend function ## Batch File @echo offset /p x=set /a fs=%x%-1set y=%x%FOR /L %%a IN (%fs%, -1, 1) DO SET /a y*=%%aif %x% EQU 0 set y=1echo %y%pauseexit ## BBC BASIC 18! is the largest that doesn't overflow.  *FLOAT64 @% = &1010 PRINT FNfactorial(18) END DEF FNfactorial(n) IF n <= 1 THEN = 1 ELSE = n * FNfactorial(n-1) Output: 6402373705728000 ## bc #! /usr/bin/bc -q define f(x) { if (x <= 1) return (1); return (f(x-1) * x)}f(1000)quit ## Beads beads 1 program Factorial// only works for cardinal numbers 0..Ncalc main_init log to_str(Iterative(4)) // 24 log to_str(Recursive(5)) // 120 calc Iterative( n:num -- number of iterations ):num -- result var total = 1 loop from:2 to:n index:ix total = ix * total return total calc Recursive ditto if n <= 1 return 1 else return n * Recursive(n-1) Output: 24 120 ## beeswax Infinite loop for entering n and getting the result n!:  p <_>1FT"pF>M"p~.~d >Pd >~{Np d < Calculate n! only once:  p <_1FT"pF>M"p~.~d >Pd >~{; Limits for UInt64 numbers apply to both examples. Examples: i indicates that the program expects the user to enter an integer. julia> beeswax("factorial.bswx")i01i11i22i36i103628800i2217196083355034583040 Input of negative numbers forces the program to quit with an error message. ## Befunge &1\> :v v *< ^-1:_$>\:|         @.$< ## BQN Fac ← ×´1+↕! 720 ≡ Fac 6 ## Bracmat Compute 10! and checking that it is 3628800, the esoteric way  ( = . !arg:0&1 | !arg * ( ( = r . !arg:?r & ' ( . !arg:0&1 | !arg*(($r)$($r))$(!arg+-1) ) )$ (                   =   r                    .   !arg:?r                      &                           ' (                           .   !arg:0&1                            | !arg*(($r)$($r))$(!arg+-1)                          )                  )                )              $(!arg+-1) )$ 10  : 3628800

This recursive lambda function is made in the following way (see http://en.wikipedia.org/wiki/Lambda_calculus):

Recursive lambda function for computing factorial.

   g := λr. λn.(1, if n = 0; else n × (r r (n-1)))
f := g g



or, translated to Bracmat, and computing 10!

      ( (=(r.!arg:?r&'(.!arg:0&1|!arg*(($r)$($r))$(!arg+-1)))):?g    & (!g$!g):?f & !f$10    )

The following is a straightforward recursive solution. Stack overflow occurs at some point, above 4243! in my case (Win XP).

  factorial=.!arg:~>1|!arg*factorial$(!arg+-1)   factorial$4243
(13552 digits, 2.62 seconds) 52254301882898638594700346296120213182765268536522926.....0000000


Lastly, here is an iterative solution

(factorial=  r.   !arg:?r  &   whl    ' (!arg:>1&(!arg+-1:?arg)*!r:?r)  & !r);

## Cat

Taken direct from the Cat manual:

define rec_fac      { dup 1 <= [pop 1] [dec rec_fac *] if }

## Ceylon

shared void run() { 	Integer? recursiveFactorial(Integer n) => 			switch(n <=> 0)			case(smaller) null			case(equal) 1			case(larger) if(exists f = recursiveFactorial(n - 1)) then n * f else null;  	Integer? iterativeFactorial(Integer n) =>			switch(n <=> 0)			case(smaller) null			case(equal) 1			case(larger) (1:n).reduce(times); 	for(Integer i in 0..10) {		print("the iterative factorial of     i is iterativeFactorial(i) else "negative"		       and the recursive factorial of i is recursiveFactorial(i) else "negative"\n");	}}

## Chapel

proc fac(n) {	var r = 1;	for i in 1..n do		r *= i; 	return r;}

## Chef

Caramel Factorials. Only reads one value. Ingredients.1 g Caramel2 g Factorials Method.Take Factorials from refrigerator.Put Caramel into 1st mixing bowl.Verb the Factorials.Combine Factorials into 1st mixing bowl.Verb Factorials until verbed.Pour contents of the 1st mixing bowl into the 1st baking dish. Serves 1.

## ChucK

### Recursive

 0 => int total;fun int factorial(int i){    if (i == 0) return 1;    else    {        i * factorial(i - 1) => total;    }     return total;} // == another way fun int factorial(int x){     if (x <= 1 ) return 1;     else return x * factorial (x - 1);} // callfactorial (5) => int answer; // testif ( answer == 120 ) <<<"success">>>;

### Iterative

 1 => int total;fun int factorial(int i){    while(i > 0)     {        total * i => total;        1 -=> i;    }    return total;}

## Clay

Obviously there’s more than one way to skin a cat. Here’s a selection — recursive, iterative, and “functional” solutions.

factorialRec(n) {    if (n == 0) return 1;    return n * factorialRec(n - 1);} factorialIter(n) {    for (i in range(1, n))        n *= i;    return n;} factorialFold(n) {    return reduce(multiply, 1, range(1, n + 1));}

We could also do it at compile time, because — hey — why not?

[n|n > 0] factorialStatic(static n) = n * factorialStatic(static n - 1);overload factorialStatic(static 0) = 1;

Because a literal 1 has type Int32, these functions receive and return numbers of that type. We must be a bit more careful if we wish to permit other numeric types (e.g. for larger integers).

[N|Integer?(N)] factorial(n: N) {    if (n == 0) return N(1);    return n * factorial(n - 1);}

And testing:

main() {    println(factorialRec(5));           // 120    println(factorialIter(5));          // 120    println(factorialFold(5));          // 120    println(factorialStatic(static 5)); // 120    println(factorial(Int64(20)));      // 2432902008176640000}

## Clio

### Recursive

 fn factorial n:  if n <= 1: n  else:     n * (n - 1 -> factorial) 10 -> factorial -> print

## CLIPS

 (deffunction factorial (?a)    (if (or (not (integerp ?a)) (< ?a 0)) then        (printout t "Factorial Error!" crlf)     else        (if (= ?a 0) then            1         else            (* ?a (factorial (- ?a 1))))))

## Clojure

### Folding

(defn factorial [x]  (apply * (range 2 (inc x))))

### Recursive

(defn factorial [x]  (if (< x 2)      1      (* x (factorial (dec x)))))

### Tail recursive

(defn factorial [x]  (loop [x x         acc 1]    (if (< x 2)        acc        (recur (dec x) (* acc x)))))

## Draco

/* Note that ulong is 32 bits, so fac(12) is the largest * supported value. This is why the input parameter * is a byte. The parameters are all unsigned. */ proc nonrec fac(byte n) ulong:    byte i;    ulong rslt;    rslt := 1;    for i from 2 upto n do        rslt := rslt * i    od;    rsltcorp proc nonrec main() void:    byte i;    for i from 0 upto 12 do        writeln(i:2, "! = ", fac(i):9)    odcorp
Output:
 0! =         1
1! =         1
2! =         2
3! =         6
4! =        24
5! =       120
6! =       720
7! =      5040
8! =     40320
9! =    362880
10! =   3628800
11! =  39916800
12! = 479001600

## Dragon

select "std"factorial = 1n = readln()for(i=1,i<=n,++i)        {            factorial = factorial * i                 }           showln "factorial of " + n + " is " + factorial

## DWScript

Note that Factorial is part of the standard DWScript maths functions.

### Iterative

function IterativeFactorial(n : Integer) : Integer;var    i : Integer;begin   Result := 1;   for i := 2 to n do      Result *= i;end;

### Recursive

function RecursiveFactorial(n : Integer) : Integer;begin   if n>1 then      Result := RecursiveFactorial(n-1)*n   else Result := 1;end;

## Dyalect

func factorial(n) {    if n < 2 {       1    } else {       n * factorial(n - 1)    }}

## Dylan

### Functional

 define method factorial (n)  if (n < 1)    error("invalid argument");  else    reduce1(\*, range(from: 1, to: n))  endend method;

### Iterative

 define method factorial (n)  if (n < 1)    error("invalid argument");  else    let total = 1;    for (i from n to 2 by -1)      total := total * i;    end;    total  endend method;

### Recursive

 define method factorial (n)  if (n < 1)    error("invalid argument");  end;  local method loop (n)          if (n <= 2)            n          else            n * loop(n - 1)          end        end;  loop(n)end method;

### Tail recursive

 define method factorial (n)  if (n < 1)    error("invalid argument");  end;  // Dylan implementations are required to perform tail call optimization so                                                                                                                                                                  // this is equivalent to iteration.                                                                                                                                                                                                         local method loop (n, total)          if (n <= 2)            total          else            let next = n - 1;            loop(next, total * next)          end        end;  loop(n, n)end method;

## Déjà Vu

### Iterative

factorial:    1    while over:        * over        swap -- swap    drop swap

### Recursive

factorial:    if dup:        * factorial -- dup    else:        1 drop

## E

pragma.enable("accumulator")def factorial(n) {  return accum 1 for i in 2..n { _ * i }}

## EasyLang

func factorial n . r .  r = 1  i = 2  while i <= n    r = r * i    i += 1  ..call factorial 7 rprint r

## EchoLisp

### Iterative

 (define (fact n)    (for/product ((f (in-range 2 (1+ n)))) f))(fact 10)    → 3628800

### Recursive with memoization

 (define (fact n)    (if (zero? n) 1     (* n (fact (1- n)))))(remember 'fact)(fact 10)    → 3628800

### Tail recursive

 (define (fact n (acc 1))(if (zero? n) acc    (fact (1- n) (* n acc))))(fact 10)    → 3628800

### Primitive

 (factorial 10)    → 3628800

### Numerical approximation

 (lib 'math)math.lib v1.13 ® EchoLisp(gamma 11)    → 3628800.0000000005

## EGL

### Iterative

 function fact(n int in) returns (bigint)    if (n < 0)        writestdout("No negative numbers");        return (0);    end    ans bigint = 1;    for (i int from 1 to n)        ans *= i;    end    return (ans);end

### Recursive

 function fact(n int in) returns (bigint)    if (n < 0)        SysLib.writeStdout("No negative numbers");        return (0);    end    if (n < 2)    	return (1);    else     	return (n * fact(n - 1));    endend

## Eiffel

 note	description: "recursive and iterative factorial example of a positive integer." class	FACTORIAL_EXAMPLE create	make feature -- Initialization 	make		local			n: NATURAL		do			n := 5			print ("%NFactorial of " + n.out + " = ")			print (recursive_factorial (n))		end feature -- Access 	recursive_factorial (n: NATURAL): NATURAL			-- factorial of 'n'		do			if n = 0 then				Result := 1			else				Result := n * recursive_factorial (n - 1)			end		end 	iterative_factorial (n: NATURAL): NATURAL			-- factorial of 'n'		local			v: like n		do			from				Result := 1				v := n			until				v <= 1			loop				Result := Result * v				v := v - 1			end		end end

## Ela

Tail recursive version:

fact = fact' 1L                    where fact' acc 0 = acc                               fact' acc n = fact' (n * acc) (n - 1)

## Elixir

defmodule Factorial do  # Simple recursive function  def fac(0), do: 1  def fac(n) when n > 0, do: n * fac(n - 1)   # Tail recursive function  def fac_tail(0), do: 1  def fac_tail(n), do: fac_tail(n, 1)  def fac_tail(1, acc), do: acc   def fac_tail(n, acc) when n > 1, do: fac_tail(n - 1, acc * n)   # Tail recursive function with default parameter  def fac_default(n, acc \\ 1)  def fac_default(0, acc), do: acc  def fac_default(n, acc) when n > 0, do: fac_default(n - 1, acc * n)   # Using Enumeration features  def fac_reduce(0), do: 1  def fac_reduce(n) when n > 0, do: Enum.reduce(1..n, 1, &*/2)   # Using Enumeration features with pipe operator  def fac_pipe(0), do: 1  def fac_pipe(n) when n > 0, do: 1..n |> Enum.reduce(1, &*/2) end

## Elm

### Recursive

 factorial : Int -> Intfactorial n =  if n < 1 then 1 else n*factorial(n-1)

### Tail Recursive

 factorialAux : Int -> Int -> IntfactorialAux a acc =    if a < 2 then acc else factorialAux (a - 1) (a * acc) factorial : Int -> Intfactorial a =    factorialAux a 1

### Functional

 import List exposing (product, range) factorial : Int -> Intfactorial a =    product (range 1 a)

## Emacs Lisp

 ;; Functional (most elegant and best suited to Lisp dialects):(defun fact (n)  "Return the factorial of integer N, which require to be positive or 0."  ;; Elisp won't do any type checking automatically, so  ;; good practice would be doing that ourselves:  (if (not (and (integerp n) (>= n 0)))      (error "Function fact (N): Not a natural number or 0: %S" n))   ;; But the actual code is very short:  (apply '* (number-sequence 1 n)))       ;; (For N = 0, number-sequence returns the empty list, resp. nil,  ;; and the * function works with zero arguments, returning 1.)
 ;; Recursive:(defun fact (n)  "Return the factorial of integer N, which require to be positive or 0."  (if (not (and (integerp n) (>= n 0))) ; see above      (error "Function fact (N): Not a natural number or 0: %S" n))  (cond ; (or use an (if ...) with an else part)   ((or (= n 0) (= n 1)) 1)    (t (* n (fact (1- n))))))

Both of these only work up to N = 19, beyond which arithmetic overflow seems to happen. The calc package (which comes with Emacs) has a builtin fact(). It automatically uses the bignums implemented by calc.

(require 'calc)(calc-eval "fact(30)")=>"265252859812191058636308480000000"

## embedded C for AVR MCU

### Iterative

long factorial(int n) {    long result = 1;    do {         result *= n;    while(--n);    return result;}

## Erlang

With a fold:

lists:foldl(fun(X,Y) -> X*Y end, 1, lists:seq(1,N)).

With a recursive function:

fac(1) -> 1;fac(N) -> N * fac(N-1).

With a tail-recursive function:

fac(N) -> fac(N-1,N).fac(1,N) -> N;fac(I,N) -> fac(I-1,N*I).

## ERRE

You must use a procedure to implement factorial because ERRE has one-line FUNCTION only.

Iterative procedure:

     PROCEDURE FACTORIAL(X%->F)      F=1      IF X%<>0 THEN        FOR I%=X% TO 2 STEP Ä1 DO          F=F*X%        END FOR      END IF    END PROCEDURE

Recursive procedure:

     PROCEDURE FACTORIAL(FACT,X%->FACT)       IF X%>1 THEN FACTORIAL(X%*FACT,X%-1->FACT)       END IF    END PROCEDURE

Procedure call is for example FACTORIAL(1,5->N)

## Euphoria

Straight forward methods

### Iterative

function factorial(integer n)  atom f = 1  while n > 1 do    f *= n    n -= 1  end while   return fend function

### Recursive

function factorial(integer n)  if n > 1 then    return factorial(n-1) * n  else    return 1  end ifend function

### Tail Recursive

Works with: Euphoria version 4.0.0
function factorial(integer n, integer acc = 1)  if n <= 0 then    return acc  else    return factorial(n-1, n*acc)  end ifend function

### 'Paper tape' / Virtual Machine version

Works with: Euphoria version 4.0.0

Another 'Paper tape' / Virtual Machine version, with as much as possible happening in the tape itself. Some command line handling as well.

include std/mathcons.e enum MUL_LLL, 	TESTEQ_LIL,	TESTLT_LIL,	TRUEGO_LL, 	MOVE_LL, 	INCR_L, 	TESTGT_LLL, 	GOTO_L,	OUT_LI,	OUT_II,	STOP global sequence tape = { 	1, 	1,	0,	0,	0,	{TESTLT_LIL, 5, 0, 4},	{TRUEGO_LL, 4, 22}, 	{TESTEQ_LIL, 5, 0, 4},	{TRUEGO_LL, 4, 20},	{MUL_LLL, 1, 2, 3},	{TESTEQ_LIL, 3, PINF, 4},	{TRUEGO_LL, 4, 18},	{MOVE_LL, 3, 1},	{INCR_L, 2},	{TESTGT_LLL, 2, 5, 4 },	{TRUEGO_LL, 4, 18},	{GOTO_L, 10},	{OUT_LI, 3, "%.0f\n"},	{STOP},	{OUT_II, 1, "%.0f\n"},	{STOP},	{OUT_II, "Negative argument", "%s\n"},	{STOP}} global integer ip = 1 procedure eval( sequence cmd )	atom i = 1	while i <= length( cmd ) do		switch cmd[ i ] do			case MUL_LLL then -- multiply location location giving location				tape[ cmd[ i + 3 ] ] = tape[ cmd[ i + 1 ] ] * tape[ cmd[ i + 2 ] ]				i += 3			case TESTEQ_LIL then -- test if location eq value giving location				tape[ cmd[ i + 3 ]] = ( tape[ cmd[ i + 1 ] ] = cmd[ i + 2 ] )				i += 3			case TESTLT_LIL then -- test if location eq value giving location				tape[ cmd[ i + 3 ]] = ( tape[ cmd[ i + 1 ] ] < cmd[ i + 2 ] )				i += 3			case TRUEGO_LL then -- if true in location, goto location				if tape[ cmd[ i + 1 ] ] then					ip = cmd[ i + 2 ] - 1				end if				i += 2			case MOVE_LL then -- move value at location to location				tape[ cmd[ i + 2 ] ] = tape[ cmd[ i + 1 ] ] 				i += 2			case INCR_L then -- increment value at location				tape[ cmd[ i + 1 ] ] += 1				i += 1			case TESTGT_LLL then -- test if location gt location giving location				tape[ cmd[ i + 3 ]] = ( tape[ cmd[ i + 1 ] ] > tape[ cmd[ i + 2 ] ] )				i += 3			case GOTO_L then -- goto location				ip = cmd[ i + 1 ] - 1				i += 1			case OUT_LI then -- output location using format				printf( 1, cmd[ i + 2], tape[ cmd[ i + 1 ] ] ) 				i += 2			case OUT_II then -- output immediate using format				if sequence( cmd[ i + 1 ] ) then					printf( 1, cmd[ i + 2], { cmd[ i + 1 ] } ) 				else					printf( 1, cmd[ i + 2], cmd[ i + 1 ] ) 				end if				i += 2			case STOP then -- stop				abort(0)		end switch		i += 1	end whileend procedure include std/convert.e sequence cmd = command_line()if length( cmd ) > 2 then	puts( 1, cmd[ 3 ] & "! = " )	tape[ 5 ] = to_number(cmd[3])else	puts( 1, "eui fact.ex <number>\n" )	abort(1)end if while 1 do	if sequence( tape[ ip ] ) then		eval( tape[ ip ] ) 	end if	ip += 1end while

## Excel

Choose a cell and write in the function bar on the top :

 =fact(5)

The result is shown as :

120


## Ezhil

Recursive

 நிரல்பாகம்  fact ( n )  @( n == 0 ) ஆனால்            பின்கொடு  1     இல்லை            பின்கொடு    n*fact( n - 1 )    முடிமுடி பதிப்பி fact ( 10 )

## F#

//val inline factorial ://   ^a ->  ^a//    when  ^a : (static member get_One : ->  ^a) and//          ^a : (static member ( + ) :  ^a *  ^a ->  ^a) and//          ^a : (static member ( * ) :  ^a *  ^a ->  ^a)let inline factorial n = Seq.reduce (*) [ LanguagePrimitives.GenericOne .. n ]
> factorial 8;;
val it : int = 40320
> factorial 800I;;
val it : bigint = 771053011335386004144639397775028360595556401816010239163410994033970851827093069367090769795539033092647861224230677444659785152639745401480184653174909762504470638274259120173309701702610875092918816846985842150593623718603861642063078834117234098513725265045402523056575658860621238870412640219629971024686826624713383660963127048195572279707711688352620259869140994901287895747290410722496106151954257267396322405556727354786893725785838732404646243357335918597747405776328924775897564519583591354080898117023132762250714057271344110948164029940588827847780442314473200479525138318208302427727803133219305210952507605948994314345449325259594876385922128494560437296428386002940601874072732488897504223793518377180605441783116649708269946061380230531018291930510748665577803014523251797790388615033756544830374909440162270182952303329091720438210637097105616258387051884030288933650309756289188364568672104084185529365727646234588306683493594765274559497543759651733699820639731702116912963247441294200297800087061725868223880865243583365623482704395893652711840735418799773763054887588219943984673401051362280384187818611005035187862707840912942753454646054674870155072495767509778534059298038364204076299048072934501046255175378323008217670731649519955699084482330798811049166276249251326544312580289357812924825898217462848297648349400838815410152872456707653654424335818651136964880049831580548028614922852377435001511377656015730959254647171290930517340367287657007606177675483830521499707873449016844402390203746633086969747680671468541687265823637922007413849118593487710272883164905548707198762911703545119701275432473548172544699118836274377270607420652133092686282081777383674487881628800801928103015832821021286322120460874941697199487758769730544922012389694504960000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000I


## Factor

USING: math.ranges sequences ; : factorial ( n -- n ) [1,b] product ;

The [1,b] word takes a number from the stack and pushes a range, which is then passed to product.

## FALSE

[1\[$][[email protected]*\1-]#%]f:^'0- f;!. Recursive: [$1=~[1-f;!*]?]f: ## Fancy def class Number { def factorial { 1 upto: self . product }} # print first ten factorials1 upto: 10 do_each: |i| { i to_s ++ "! = " ++ (i factorial) println} ## Fantom The following uses 'Ints' to hold the computed factorials, which limits results to a 64-bit signed integer. class Main{ static Int factorialRecursive (Int n) { if (n <= 1) return 1 else return n * (factorialRecursive (n - 1)) } static Int factorialIterative (Int n) { Int product := 1 for (Int i := 2; i <=n ; ++i) { product *= i } return product } static Int factorialFunctional (Int n) { (1..n).toList.reduce(1) |a,v| { v->mult(a) // use a dynamic invoke // alternatively, cast a: v * (Int)a } } public static Void main () { echo (factorialRecursive(20)) echo (factorialIterative(20)) echo (factorialFunctional(20)) }} ## Fermat The factorial function is built in. 666! Output:  10106320568407814933908227081298764517575823983241454113404208073574138021  03697022989202806801491012040989802203557527039339704057130729302834542423840165  85642874066153029797241068282869939717688434251350949378748077490349338925526287  83417618832618994264849446571616931313803111176195730515264233203896418054108160  67607893067483259816815364609828668662748110385603657973284604842078094141556427  70874534510059882948847250594907196772727091196506088520929434066550648022642608  33579015030977811408324970137380791127776157191162033175421999994892271447526670  85796752482688850461263732284539176142365823973696764537603278769322286708855475  06983568164371084614056976933006577541441308350104365957229945444651724282400214  05551404642962910019014384146757305529649145692697340385007641405511436428361286  13304734147348086095123859660926788460671181469216252213374650499557831741950594  82714722569989641408869425126104519667256749553222882671938160611697400311264211  15613325735032129607297117819939038774163943817184647655275750142521290402832369  63922624344456975024058167368431809068544577258472983979437818072648213608650098  74936976105696120379126536366566469680224519996204004154443821032721047698220334  84585960930792965695612674094739141241321020558114937361996687885348723217053605  11305248710796441479213354542583576076596250213454667968837996023273163069094700  42946710666392541958119313633986054565867362395523193239940480940410876723200000  00000000000000000000000000000000000000000000000000000000000000000000000000000000  00000000000000000000000000000000000000000000000000000000000000000000000000000000  ## FOCAL 1.1 F N=0,10; D 21.2 S N=-3; D 21.3 S N=100; D 21.4 S N=300; D 21.5 Q 2.1 I (N)3.1,4.12.2 S R=12.3 F I=1,N; S R=R*I2.4 T "FACTORIAL OF ", %3.0, N, " IS ", %8.0, R, !2.9 R 3.1 T "N IS NEGATIVE" !; D 2.9 4.1 T "FACTORIAL OF 0 IS 1" !; D 2.9 Output: FACTORIAL OF 0 IS 1 FACTORIAL OF = 1 IS = 1 FACTORIAL OF = 2 IS = 2 FACTORIAL OF = 3 IS = 6 FACTORIAL OF = 4 IS = 24 FACTORIAL OF = 5 IS = 120 FACTORIAL OF = 6 IS = 720 FACTORIAL OF = 7 IS = 5040 FACTORIAL OF = 8 IS = 40320 FACTORIAL OF = 9 IS = 362880 FACTORIAL OF = 10 IS = 3628800 N IS NEGATIVE FACTORIAL OF = 100 IS = 0.93325720E+158 FACTORIAL OF = 300 IS = 0.30605100E+615  The factorial of 300 is the largest one which FOCAL can compute, 301 causes an overflow. ## Forth ### Single Precision : fac ( n -- n! ) 1 swap 1+ 1 ?do i * loop ; ### Double Precision On a 64 bit computer, can compute up to 33! Also does error checking. In gforth, error code -24 is "invalid numeric argument." : factorial ( n -- d ) dup 33 u> -24 and throw dup 2 < IF drop 1. ELSE 1. rot 1+ 2 DO i 1 m*/ LOOP THEN ; 33 factorial d. 8683317618811886495518194401280000000 ok-5 factorial d. :2: Invalid numeric argument  ## Fortran ### Fortran 90 A simple one-liner is sufficient. nfactorial = PRODUCT((/(i, i=1,n)/)) Recursive functions were added in Fortran 90, allowing the following: INTEGER RECURSIVE FUNCTION RECURSIVE_FACTORIAL(X) RESULT(ANS) INTEGER, INTENT(IN) :: X IF (X <= 1) THEN ANS = 1 ELSE ANS = X * RECURSIVE_FACTORIAL(X-1) END IF END FUNCTION RECURSIVE_FACTORIAL ### FORTRAN 77  FUNCTION FACT(N) INTEGER N,I,FACT FACT=1 DO 10 I=1,N 10 FACT=FACT*I END ## FPr FP-Way fact==((1&),iota)1*2)&  Recursive fact==(id<=1&)->(1&);id*fact°id-1&  ## FreeBASIC ' FB 1.05.0 Win64 Function Factorial_Iterative(n As Integer) As Integer Var result = 1 For i As Integer = 2 To n result *= i Next Return resultEnd Function Function Factorial_Recursive(n As Integer) As Integer If n = 0 Then Return 1 Return n * Factorial_Recursive(n - 1)End Function For i As Integer = 1 To 5 Print i; " =>"; Factorial_Iterative(i)Next For i As Integer = 6 To 10 Print Using "##"; i; Print " =>"; Factorial_Recursive(i)Next PrintPrint "Press any key to quit"Sleep Output:  1 => 1 2 => 2 3 => 6 4 => 24 5 => 120 6 => 720 7 => 5040 8 => 40320 9 => 362880 10 => 3628800  ## friendly interactive shell Asterisk is quoted to prevent globbing. ### Iterative  function factorial set x argv[1] set result 1 for i in (seq x) set result (expr i '*' result) end echo resultend  ### Recursive  function factorial set x argv[1] if [ x -eq 1 ] echo 1 else expr (factorial (expr x - 1)) '*' x endend  ## Frink Frink has a built-in factorial operator and function that creates arbitrarily-large numbers and caches results so that subsequent calls are fast. Some notes on its implementation: • Factorials are calculated once and cached in memory so further recalculation is fast. • There is a limit to the size of factorials that gets cached in memory. Currently this limit is 10000!. Numbers larger than this will not be cached, but re-calculated on demand. • When calculating a factorial within the caching limit, say, 5000!, all of the factorials smaller than this will get calculated and cached in memory. • Calculations of huge factorials larger than the cache limit 10000! are calculated by a binary splitting algorithm which makes them significantly faster on Java 1.8 and later. (Did you know that Java 1.8's BigInteger calculations got drastically faster because Frink's internal algorithms were contributed to it?) • Functions that calculate binomial coefficients like binomial[m,n] are more efficient because of the use of binary splitting algorithms, especially for large numbers. • The function factorialRatio[a, b] allows efficient calculation of the ratio of two factorials a! / b!, using a binary splitting algorithm.  // Calculate factorial with math operatorx = 5println[x!] // Calculate factorial with built-in functionprintln[factorial[x]]  Building a factorial function with no recursion  // Build factorial function with using a range and product function.factorial2[x] := product[1 to x]println[factorial2[5]]  Building a factorial function with recursion  factorial3[x] :={ if x <= 1 return 1 else return x * factorial3[x-1] // function calling itself} println[factorial3[5]]  ## FunL ### Procedural def factorial( n ) = if n < 0 error( 'factorial: n should be non-negative' ) else res = 1 for i <- 2..n res *= i res ### Recursive def factorial( (0|1) ) = 1 factorial( n ) | n > 0 = n*factorial( n - 1 ) | otherwise = error( 'factorial: n should be non-negative' ) ### Tail-recursive def factorial( n ) | n >= 0 = def fact( acc, 0 ) = acc fact( acc, n ) = fact( acc*n, n - 1 ) fact( 1, n ) | otherwise = error( 'factorial: n should be non-negative' ) ### Using a library function def factorial( n ) | n >= 0 = product( 1..n ) | otherwise = error( 'factorial: n should be non-negative' ) ## Futhark  This example is incorrect. Please fix the code and remove this message.Details: Futhark's syntax has changed, so this example will not compile ### Recursive  fun fact(n: int): int = if n == 0 then 1 else n * fact(n-1)  ## Iterative  fun fact(n: int): int = loop (out = 1) = for i < n do out * (i+1) in out  ## FutureBasic window 1, @"Factorial", ( 0, 0, 300, 550 ) local fn factorialIterative( n as long ) as double double f long i if ( n > 1 ) f = 1 for i = 2 to n f = f * i next else f = 1 end ifend fn = f local fn factorialRecursive( n as long ) as double double f if ( n < 2 ) f = 1 else f = n * fn factorialRecursive( n -1 ) end ifend fn = f long i for i = 0 to 12 print "Iterative:"; using "####"; i; " = "; fn factorialIterative( i ) print "Recursive:"; using "####"; i; " = "; fn factorialRecursive( i ) printnext HandleEvents Output: Iterative: 0 = 1 Recursive: 0 = 1 Iterative: 1 = 1 Recursive: 1 = 1 Iterative: 2 = 2 Recursive: 2 = 2 Iterative: 3 = 6 Recursive: 3 = 6 Iterative: 4 = 24 Recursive: 4 = 24 Iterative: 5 = 120 Recursive: 5 = 120 Iterative: 6 = 720 Recursive: 6 = 720 Iterative: 7 = 5040 Recursive: 7 = 5040 Iterative: 8 = 40320 Recursive: 8 = 40320 Iterative: 9 = 362880 Recursive: 9 = 362880 Iterative: 10 = 3628800 Recursive: 10 = 3628800 Iterative: 11 = 39916800 Recursive: 11 = 39916800 Iterative: 12 = 479001600 Recursive: 12 = 479001600  ## Gambas  ' Task: Factorial' Language: Gambas' Author: Sinuhe Masan (2019)' Function factorial iterativeFunction factorial_iter(num As Integer) As Long Dim fact As Long Dim i As Integer fact = 1 If num > 1 Then For i = 2 To num fact = fact * i Next Endif Return fact End ' Function factorial recursiveFunction factorial_rec(num As Integer) As Long If num <= 1 Then Return 1 Else Return num * factorial_rec(num - 1) Endif End Public Sub Main() Print factorial_iter(6) Print factorial_rec(7) End  Output: 720 5040  ## GAP # Built-inFactorial(5); # An implementationfact := n -> Product([1 .. n]); ## Genyris def factorial (n) if (< n 2) 1 * n factorial (- n 1) ## GML n = argument0j = 1for(i = 1; i <= n; i += 1) j *= ireturn j ## gnuplot Gnuplot has a builtin ! factorial operator for use on integers. set xrange [0:4.95]set key leftplot int(x)! If you wanted to write your own it can be done recursively. # Using int(n) allows non-integer "n" inputs with the factorial# calculated on int(n) in that case.# Arranging the condition as "n>=2" avoids infinite recursion if# n==NaN, since any comparison involving NaN is false. Could change# "1" to an expression like "n*0+1" to propagate a NaN input to the# output too, if desired.#factorial(n) = (n >= 2 ? int(n)*factorial(n-1) : 1)set xrange [0:4.95]set key leftplot factorial(x) ## Go ### Iterative Sequential, but at least handling big numbers: package main import ( "fmt" "math/big") func main() { fmt.Println(factorial(800))} func factorial(n int64) *big.Int { if n < 0 { return nil } r := big.NewInt(1) var f big.Int for i := int64(2); i <= n; i++ { r.Mul(r, f.SetInt64(i)) } return r} ### Built in, exact Built in function currently uses a simple divide and conquer technique. It's a step up from sequential multiplication. package main import ( "math/big" "fmt") func factorial(n int64) *big.Int { var z big.Int return z.MulRange(1, n)} func main() { fmt.Println(factorial(800))} ### Efficient exact For a bigger step up, an algorithm fast enough to compute factorials of numbers up to a million or so, see Factorial/Go. ### Built in, Gamma package main import ( "fmt" "math") func factorial(n float64) float64 { return math.Gamma(n + 1)} func main() { for i := 0.; i <= 10; i++ { fmt.Println(i, factorial(i)) } fmt.Println(100, factorial(100))} Output: 0 1 1 1 2 2 3 6 4 24 5 120 6 720 7 5040 8 40320 9 362880 10 3.6288e+06 100 9.332621544394405e+157  ### Built in, Lgamma package main import ( "fmt" "math" "math/big") func lfactorial(n float64) float64 { l, _ := math.Lgamma(n + 1) return l} func factorial(n float64) *big.Float { i, frac := math.Modf(lfactorial(n) * math.Log2E) z := big.NewFloat(math.Exp2(frac)) return z.SetMantExp(z, int(i))} func main() { for i := 0.; i <= 10; i++ { fmt.Println(i, factorial(i)) } fmt.Println(100, factorial(100)) fmt.Println(800, factorial(800))} Output: 0 1 1 1 2 2 3 6 4 24 5 119.99999999999994 6 720.0000000000005 7 5039.99999999999 8 40320.000000000015 9 362880.0000000001 10 3.6288000000000084e+06 100 9.332621544394454e+157 800 7.710530113351238e+1976  ## Golfscript Iterative (uses folding) {.!{1}{,{)}%{*}*}if}:fact;5fact puts # test or {),(;{*}*}:fact; Recursive {.1<{;1}{.(fact*}if}:fact; ## Gridscript  #FACTORIAL. @width 14@height 8 (1,3):START(7,1):CHECKPOINT 0(3,3):INPUT INT TO n(5,3):STORE n(7,3):GO EAST(9,3):DECREMENT n(11,3):SWITCH n(11,5):MULTIPLY BY n(11,7):GOTO 0(13,3):PRINT  ## Groovy ### Recursive A recursive closure must be pre-declared. def rFactrFact = { (it > 1) ? it * rFact(it - 1) : 1 as BigInteger } ### Iterative def iFact = { (it > 1) ? (2..it).inject(1 as BigInteger) { i, j -> i*j } : 1 } Test Program: def time = { Closure c -> def start = System.currentTimeMillis() def result = c() def elapsedMS = (System.currentTimeMillis() - start)/1000 printf '(%6.4fs elapsed)', elapsedMS result} def dashes = '---------------------'print " n! elapsed time "; (0..15).each { def length = Math.max(it - 3, 3); printf " %{length}d", it }; println()print "--------- -----------------"; (0..15).each { def length = Math.max(it - 3, 3); print " {dashes[0..<length]}" }; println()[recursive:rFact, iterative:iFact].each { name, fact -> printf "%9s ", name def factList = time { (0..15).collect {fact(it)} } factList.each { printf ' %3d', it } println()} Output:  n! elapsed time 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 --------- ----------------- --- --- --- --- --- --- --- ---- ----- ------ ------- -------- --------- ---------- ----------- ------------ recursive (0.0040s elapsed) 1 1 2 6 24 120 720 5040 40320 362880 3628800 39916800 479001600 6227020800 87178291200 1307674368000 iterative (0.0060s elapsed) 1 1 2 6 24 120 720 5040 40320 362880 3628800 39916800 479001600 6227020800 87178291200 1307674368000 ## Haskell The simplest description: factorial is the product of the numbers from 1 to n: factorial n = product [1..n] Or, using composition and omitting the argument (partial application): factorial = product . enumFromTo 1 Or, written explicitly as a fold: factorial n = foldl (*) 1 [1..n] See also: The Evolution of a Haskell Programmer Or, if you wanted to generate a list of all the factorials: factorials = scanl (*) 1 [1..] Or, written without library functions: factorial :: Integral -> Integralfactorial 0 = 1factorial n = n * factorial (n-1) Tail-recursive, checking the negative case: fac n | n >= 0 = go 1 n | otherwise = error "Negative factorial!" where go acc 0 = acc go acc n = go (acc * n) (n - 1) Using postfix notation: {-# LANGUAGE PostfixOperators #-} (!) :: Integer -> Integer(!) 0 = 1(!) n = n * (pred n !) main :: IO ()main = do print (5 !) print ((4 !) !) ### Binary splitting The following method is more efficient for large numbers. -- product of [a,a+1..b]productFromTo a b = if a>b then 1 else if a == b then a else productFromTo a c * productFromTo (c+1) b where c = (a+b) div 2 factorial = productFromTo 1 ## Haxe ### Iterative static function factorial(n:Int):Int { var result = 1; while (1<n) result *= n--; return result;} ### Recursive static function factorial(n:Int):Int { return n == 0 ? 1 : n * factorial2(n - 1);} ### Tail-Recursive inline static function _fac_aux(n, acc:Int):Int { return n < 1 ? acc : _fac_aux(n - 1, acc * n);} static function factorial(n:Int):Int { return _fac_aux(n,1);} ### Functional static function factorial(n:Int):Int { return [for (i in 1...(n+1)) i].fold(function(num, total) return total *= num, 1);} ### Comparison using StringTools;using Lambda; class Factorial { // iterative static function factorial1(n:Int):Int { var result = 1; while (1<n) result *= n--; return result; } // recursive static function factorial2(n:Int):Int { return n == 0 ? 1 : n * factorial2(n - 1); } // tail-recursive inline static function _fac_aux(n, acc:Int):Int { return n < 1 ? acc : _fac_aux(n - 1, acc * n); } static function factorial3(n:Int):Int { return _fac_aux(n,1); } // functional static function factorial4(n:Int):Int { return [for (i in 1...(n+1)) i].fold(function(num, total) return total *= num, 1); } static function main() { var v = 12; // iterative var start = haxe.Timer.stamp(); var result = factorial1(v); var duration = haxe.Timer.stamp() - start; Sys.println('iterative'.rpad(' ', 20) + 'result: result time: duration ms'); // recursive start = haxe.Timer.stamp(); result = factorial2(v); duration = haxe.Timer.stamp() - start; Sys.println('recursive'.rpad(' ', 20) + 'result: result time: duration ms'); // tail-recursive start = haxe.Timer.stamp(); result = factorial3(v); duration = haxe.Timer.stamp() - start; Sys.println('tail-recursive'.rpad(' ', 20) + 'result: result time: duration ms'); // functional start = haxe.Timer.stamp(); result = factorial4(v); duration = haxe.Timer.stamp() - start; Sys.println('functional'.rpad(' ', 20) + 'result: result time: duration ms'); }} Output: iterative result: 479001600 time: 6.198883056640625e-06 ms recursive result: 479001600 time: 1.31130218505859375e-05 ms tail-recursive result: 479001600 time: 1.9073486328125e-06 ms functional result: 479001600 time: 1.40666961669921875e-05 ms  ## hexiscript ### Iterative fun fac n let acc 1 while n > 0 let acc (acc * n--) endwhile return accendfun ### Recursive fun fac n if n <= 0 return 1 else return n * fac (n - 1) endifendfun ## HicEst WRITE(Clipboard) factorial(6) ! pasted: 720 FUNCTION factorial(n) factorial = 1 DO i = 2, n factorial = factorial * i ENDDOEND ## HolyC ### Iterative U64 Factorial(U64 n) { U64 i, result = 1; for (i = 1; i <= n; ++i) result *= i; return result;} Print("1: %d\n", Factorial(1));Print("10: %d\n", Factorial(10)); Note: Does not support negative numbers. ### Recursive I64 Factorial(I64 n) { if (n == 0) return 1; if (n < 0) return -1 * ((-1 * n) * Factorial((-1 * n) - 1)); return n * Factorial(n - 1));} Print("+1: %d\n", Factorial(1));Print("+10: %d\n", Factorial(10));Print("-10: %d\n", Factorial(-10)); ## Hy (defn ! [n] (reduce * (range 1 (inc n)) 1)) (print (! 6)) ; 720(print (! 0)) ; 1 ## i concept factorial(n) { return n!} software { print(factorial(-23)) print(factorial(0)) print(factorial(1)) print(factorial(2)) print(factorial(3)) print(factorial(22))}  ## Icon and Unicon ### Recursive procedure factorial(n) n := integer(n) | runerr(101, n) if n < 0 then fail return if n = 0 then 1 else n*factorial(n-1)end  ### Iterative The factors provides the following iterative procedure which can be included with 'link factors': procedure factorial(n) #: return n! (n factorial) local i n := integer(n) | runerr(101, n) if n < 0 then fail i := 1 every i *:= 1 to n return iend ## IDL function fact,n return, product(lindgen(n)+1)end ## Inform 6 [ factorial n; if(n == 0) return 1; else return n * factorial(n - 1);]; ## Io Factorials are built-in to Io: 3 factorial ## J ### Operator  ! 8 NB. Built in factorial operator40320 ### Iterative / Functional  */1+i.840320 ### Recursive  (*:@:<:)^:(1&<) 840320 ### Generalization Factorial, like most of J's primitives, is generalized (mathematical generalization is often something to avoid in application code while being something of a curated virtue in utility code):  ! 8 0.8 _0.8 NB. Generalizes as 1 + the gamma function40320 0.931384 4.59084 ! 800x NB. Also arbitrarily large7710530113353860041446393977750283605955564018160102391634109940339708518270930693670907697955390330926478612242306774446597851526397454014801846531749097625044706382742591201733097017026108750929188168469858421505936237186038616420630788341172340985137252... ## Janet ### Recursive #### Non-Tail Recursive  (defn factorial [x] (cond (< x 0) nil (= x 0) 1 (* x (factorial (dec x)))))  #### Tail Recursive Given the initial recursive sample is not using tail recursion, there is a possibility to hit a stack overflow (if the user has lowered Janet's very high default max stack size) or exhaust the host's available memory. The recursive sample can be written with tail recursion (Janet supports TCO) to perform the algorithm in linear time and constant space, instead of linear space.  (defn factorial-iter [product counter max-count] (if (> counter max-count) product (factorial-iter (* counter product) (inc counter) max-count))) (defn factorial [n] (factorial-iter 1 1 n))  ### Iterative  (defn factorial [x] (cond (< x 0) nil (= x 0) 1 (do (var fac 1) (for i 1 (inc x) (*= fac i)) fac)))  ### Functional  (defn factorial [x] (cond (< x 0) nil (= x 0) 1 (product (range 1 (inc x)))))  ## Java ### Iterative  package programas; import java.math.BigInteger;import java.util.InputMismatchException;import java.util.Scanner; public class IterativeFactorial { public BigInteger factorial(BigInteger n) { if ( n == null ) { throw new IllegalArgumentException(); } else if ( n.signum() == - 1 ) { // negative throw new IllegalArgumentException("Argument must be a non-negative integer"); } else { BigInteger factorial = BigInteger.ONE; for ( BigInteger i = BigInteger.ONE; i.compareTo(n) < 1; i = i.add(BigInteger.ONE) ) { factorial = factorial.multiply(i); } return factorial; } } public static void main(String[] args) { Scanner scanner = new Scanner(System.in); BigInteger number, result; boolean error = false; System.out.println("FACTORIAL OF A NUMBER"); do { System.out.println("Enter a number:"); try { number = scanner.nextBigInteger(); result = new IterativeFactorial().factorial(number); error = false; System.out.println("Factorial of " + number + ": " + result); } catch ( InputMismatchException e ) { error = true; scanner.nextLine(); } catch ( IllegalArgumentException e ) { error = true; scanner.nextLine(); } } while ( error ); scanner.close(); } }  ### Recursive  package programas; import java.math.BigInteger;import java.util.InputMismatchException;import java.util.Scanner; public class RecursiveFactorial { public BigInteger factorial(BigInteger n) { if ( n == null ) { throw new IllegalArgumentException(); } else if ( n.equals(BigInteger.ZERO) ) { return BigInteger.ONE; } else if ( n.signum() == - 1 ) { // negative throw new IllegalArgumentException("Argument must be a non-negative integer"); } else { return n.equals(BigInteger.ONE) ? BigInteger.ONE : factorial(n.subtract(BigInteger.ONE)).multiply(n); } } public static void main(String[] args) { Scanner scanner = new Scanner(System.in); BigInteger number, result; boolean error = false; System.out.println("FACTORIAL OF A NUMBER"); do { System.out.println("Enter a number:"); try { number = scanner.nextBigInteger(); result = new RecursiveFactorial().factorial(number); error = false; System.out.println("Factorial of " + number + ": " + result); } catch ( InputMismatchException e ) { error = true; scanner.nextLine(); } catch ( IllegalArgumentException e ) { error = true; scanner.nextLine(); } } while ( error ); scanner.close(); } }  ### Simplified and Combined Version  import java.math.BigInteger;import java.util.InputMismatchException;import java.util.Scanner; public class LargeFactorial { public static long userInput; public static void main(String[]args){ Scanner input = new Scanner(System.in); System.out.println("Input factorial integer base: "); try { userInput = input.nextLong(); System.out.println(userInput + "! is\n" + factorial(userInput) + " using standard factorial method."); System.out.println(userInput + "! is\n" + factorialRec(userInput) + " using recursion method."); }catch(InputMismatchException x){ System.out.println("Please give integral numbers."); }catch(StackOverflowError ex){ if(userInput > 0) { System.out.println("Number too big."); }else{ System.out.println("Please give non-negative(positive) numbers."); } }finally { System.exit(0); } } public static BigInteger factorialRec(long n){ BigInteger result = BigInteger.ONE; return n == 0 ? result : result.multiply(BigInteger.valueOf(n)).multiply(factorial(n-1)); } public static BigInteger factorial(long n){ BigInteger result = BigInteger.ONE; for(int i = 1; i <= n; i++){ result = result.multiply(BigInteger.valueOf(i)); } return result; }}  ## JavaScript ### Iterative function factorial(n) { //check our edge case if (n < 0) { throw "Number must be non-negative"; } var result = 1; //we skip zero and one since both are 1 and are identity while (n > 1) { result *= n; n--; } return result;} ### Recursive #### ES5 (memoized ) (function(x) { var memo = {}; function factorial(n) { return n < 2 ? 1 : memo[n] || (memo[n] = n * factorial(n - 1)); } return factorial(x); })(18); Output: 6402373705728000 Or, assuming that we have some sort of integer range function, we can memoize using the accumulator of a fold/reduce: (function () { 'use strict'; // factorial :: Int -> Int function factorial(x) { return range(1, x) .reduce(function (a, b) { return a * b; }, 1); } // range :: Int -> Int -> [Int] function range(m, n) { var a = Array(n - m + 1), i = n + 1; while (i-- > m) a[i - m] = i; return a; } return factorial(18); })(); Output: 6402373705728000 #### ES6 var factorial = n => (n < 2) ? 1 : n * factorial(n - 1); Or, as an alternative to recursion, we can fold/reduce a product function over the range of integers 1..n (() => { 'use strict'; // factorial :: Int -> Int const factorial = n => enumFromTo(1, n) .reduce(product, 1); const test = () => factorial(18); // --> 6402373705728000 // GENERIC FUNCTIONS ---------------------------------- // product :: Num -> Num -> Num const product = (a, b) => a * b; // range :: Int -> Int -> [Int] const enumFromTo = (m, n) => Array.from({ length: (n - m) + 1 }, (_, i) => m + i); // MAIN ------ return test();})(); Output: 6402373705728000 The first part outputs the factorial for every addition to the array and the second part calculates factorial from a single number.  <html> <body> <button onclick="incrementFact()">Factorial</button> <p id="FactArray"></p> <p id="Factorial"></p> <br> </body> </html> <input id="userInput" value=""><br><button onclick="singleFact()">Single Value Factorial</button><p id="SingleFactArray"></p><p id="SingleFactorial"></p> <script> function mathFact(total, sum) { return total * sum; } var incNumbers = [1]; function incrementFact() { var n = incNumbers.pop(); incNumbers.push(n); incNumbers.push(n + 1); document.getElementById("FactArray").innerHTML = incNumbers; document.getElementById("Factorial").innerHTML = incNumbers.reduceRight(mathFact); } var singleNum = []; function singleFact() { var x = document.getElementById("userInput").value; for (i = 0; i < x; i++) { singleNum.push(i + 1); document.getElementById("SingleFactArray").innerHTML = singleNum; } document.getElementById("SingleFactorial").innerHTML = singleNum.reduceRight(mathFact); singleNum = []; } </script> ## JOVIAL PROC FACTORIAL(ARG) U; BEGIN ITEM ARG U; ITEM TEMP U; TEMP = 1; FOR I:2 BY 1 WHILE I<=ARG; TEMP = TEMP*I; FACTORIAL = TEMP; END ## Joy DEFINE factorial == [0 =] [pop 1] [dup 1 - factorial *] ifte.  ## jq An efficient and idiomatic definition in jq is simply to multiply the first n integers: def fact: reduce range(1; .+1) as i (1; . * i); Here is a rendition in jq of the standard recursive definition of the factorial function, assuming n is non-negative: def fact(n): if n <= 1 then n else n * fact(n-1) end;  Recent versions of jq support tail recursion optimization for 0-arity filters, so here is an implementation that would would benefit from this optimization. The helper function, _fact, is defined here as a subfunction of the main function, which is a filter that accepts the value of n from its input. def fact: def _fact: # Input: [accumulator, counter] if .[1] <= 1 then . else [.[0] * .[1], .[1] - 1]| _fact end; # Extract the accumulated value from the output of _fact: [1, .] | _fact | .[0] ; ## Jsish /* Factorial, in Jsish */ /* recursive */function fact(n) { return ((n < 2) ? 1 : n * fact(n - 1)); } /* iterative */function factorial(n:number) { if (n < 0) throw format("factorial undefined for negative values: %d", n); var fac = 1; while (n > 1) fac *= n--; return fac;} if (Interp.conf('unitTest') > 0) {;fact(18);;fact(1); ;factorial(18);;factorial(42);try { factorial(-1); } catch (err) { puts(err); }} Output: prompt jsish --U factorial.jsi fact(18) ==> 6402373705728000 fact(1) ==> 1 factorial(18) ==> 6402373705728000 factorial(42) ==> 1.40500611775288e+51 factorial undefined for negative values: -1 ## Julia Works with: Julia version 0.6 Built-in version: help?> factorial search: factorial Factorization factorize factorial(n) Factorial of n. If n is an Integer, the factorial is computed as an integer (promoted to at least 64 bits). Note that this may overflow if n is not small, but you can use factorial(big(n)) to compute the result exactly in arbitrary precision. If n is not an Integer, factorial(n) is equivalent to gamma(n+1). julia> factorial(6) 720 julia> factorial(21) ERROR: OverflowError() [...] julia> factorial(21.0) 5.109094217170944e19 julia> factorial(big(21)) 51090942171709440000 Dynamic version: function fact(n::Integer) n < 0 && return zero(n) f = one(n) for i in 2:n f *= i end return fend for i in 10:20 println("i -> ", fact(i))end Output: 10 -> 3628800 11 -> 39916800 12 -> 479001600 13 -> 6227020800 14 -> 87178291200 15 -> 1307674368000 16 -> 20922789888000 17 -> 355687428096000 18 -> 6402373705728000 19 -> 121645100408832000 20 -> 2432902008176640000 Alternative version: fact2(n::Integer) = prod(Base.OneTo(n))@show fact2(20) Output: fact2(20) = 2432902008176640000 ## K ### Iterative  facti:*/1+!: facti 5120 ### Recursive  factr:{:[x>1;x*_f x-1;1]} factr 6720 ## Klingphix { recursive }:factorial dup 1 great ( [dup 1 - factorial *] [drop 1] ) if; { iterative }:factorial2 1 swap [*] for; ( 0 22 ) [ "Factorial(" print dup print ") = " print factorial2 print nl] for " " input Output: Factorial(0) = 1 Factorial(1) = 1 Factorial(2) = 2 Factorial(3) = 6 Factorial(4) = 24 Factorial(5) = 120 Factorial(6) = 720 Factorial(7) = 5040 Factorial(8) = 40320 Factorial(9) = 362880 Factorial(10) = 3628800 Factorial(11) = 39916800 Factorial(12) = 479001600 Factorial(13) = 6.22703e+9 Factorial(14) = 8.71783e+10 Factorial(15) = 1.30768e+12 Factorial(16) = 2.09228e+13 Factorial(17) = 3.55688e+14 Factorial(18) = 6.40238e+15 Factorial(19) = 1.21646e+17 Factorial(20) = 2.4329e+18 Factorial(21) = 5.1091e+19 Factorial(22) = 1.124e+21 ## Klong Based on the K examples above.  factRecursive::{:[x>1;x*.f(x-1);1]} factIterative::{*/1+!x}  ## KonsolScript function factorial(Number n):Number { Var:Number ret; if (n >= 0) { ret = 1; Var:Number i = 1; for (i = 1; i <= n; i++) { ret = ret * i; } } else { ret = 0; } return ret;} ## Kotlin fun facti(n: Int) = when { n < 0 -> throw IllegalArgumentException("negative numbers not allowed") else -> { var ans = 1L for (i in 2..n) ans *= i ans }} fun factr(n: Int): Long = when { n < 0 -> throw IllegalArgumentException("negative numbers not allowed") n < 2 -> 1L else -> n * factr(n - 1)} fun main(args: Array<String>) { val n = 20 println("n! = " + facti(n)) println("n! = " + factr(n))} Output: 20! = 2432902008176640000 20! = 2432902008176640000 ## Lambdatalk  {def fac {lambda {:n} {if {< :n 1} then 1 else {long_mult :n {fac {- :n 1}}}}}} {fac 6}-> 720 {fac 100}-> 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000  ## Lang5 ### Folding  : fact iota 1 + '* reduce ; 5 fact120  ### Recursive  : fact dup 2 < if else dup 1 - fact * then ; 5 fact120  ## langur ### Folding val .factorial = f fold(f .x x .y, pseries .n)writeln .factorial(7) Works with: langur version 0.6.13 val .factorial = f fold(f{x}, 2 to .n)writeln .factorial(7) ### Recursive val .factorial = f if(.x < 2: 1; .x x self(.x - 1))writeln .factorial(7) ### Iterative val .factorial = f(.i) { var .answer = 1 for .x in 2 to .i { .answer x= .x } .answer}writeln .factorial(7) ### Iterative Folding Works with: langur version 0.7.0 val .factorial = f(.n) for[=1] .x in .n { _for x= .x }writeln .factorial(7) Output: 5040 ## Lasso ### Iterative define factorial(n) => { local(x = 1) with i in generateSeries(2, #n) do { #x *= #i } return #x} ### Recursive define factorial(n) => #n < 2 ? 1 | #n * factorial(#n - 1) ## Latitude ### Functional factorial := { 1 upto (1 + 1) product.}. ### Recursive factorial := { takes '[n]. if { n == 0. } then { 1. } else { n * factorial (n - 1). }.}. ### Iterative factorial := { local 'acc = 1. 1 upto (1 + 1) do { acc = acc * 1. }. acc.}. ## LFE ### Non-Tail-Recursive Versions The non-tail-recursive versions of this function are easy to read: they look like the math textbook definitions. However, they will cause the Erlang VM to throw memory errors when passed very large numbers. To avoid such errors, use the tail-recursive version below. Using the cond form:  (defun factorial (n) (cond ((== n 0) 1) ((> n 0) (* n (factorial (- n 1))))))  Using guards (with the when form):  (defun factorial ((n) (when (== n 0)) 1) ((n) (when (> n 0)) (* n (factorial (- n 1)))))  Using pattern matching and a guard:  (defun factorial ((0) 1) ((n) (when (> n 0)) (* n (factorial (- n 1)))))  ### Tail-Recursive Version  (defun factorial (n) (factorial n 1)) (defun factorial ((0 acc) acc) ((n acc) (when (> n 0)) (factorial (- n 1) (* n acc))))  Example usage in the REPL:  > (lists:map #'factorial/1 (lists:seq 10 20))(3628800 39916800 479001600 6227020800 87178291200 1307674368000 20922789888000 355687428096000 6402373705728000 121645100408832000 2432902008176640000)  Or, using io:format to print results to stdout:  > (lists:foreach (lambda (x) (io:format '"~p~n" (,(factorial x)))) (lists:seq 10 20))36288003991680047900160062270208008717829120013076743680002092278988800035568742809600064023737057280001216451004088320002432902008176640000ok  Note that the use of progn above was simply to avoid the list of oks that are generated as a result of calling io:format inside a lists:map's anonymous function. ## Liberty BASIC  for i =0 to 40 print " FactorialI( "; using( "####", i); ") = "; factorialI( i) print " FactorialR( "; using( "####", i); ") = "; factorialR( i) next i wait function factorialI( n) if n >1 then f =1 For i = 2 To n f = f * i Next i else f =1 end if factorialI =f end function function factorialR( n) if n <2 then f =1 else f =n *factorialR( n -1) end if factorialR =f end function end ## Lingo ### Recursive on fact (n) if n<=1 then return 1 return n * fact(n-1)end ### Iterative on fact (n) res = 1 repeat with i = 2 to n res = res*i end repeat return resend ## Lisaac - factorial x : INTEGER : INTEGER <- ( + result : INTEGER; (x <= 1).if { result := 1; } else { result := x * factorial(x - 1); }; result); ## Little Man Computer The Little Man can cope with integers up to 999. So he can calculate up to 6 factorial before it all gets too much for him.  // Little Man Computer// Reads an integer n and prints n factorial// Works for n = 0..6 LDA one // initialize factorial to 1 STA fac INP // get n from user BRZ done // if n = 0, return 1 STA n // else store n LDA one // initialize k = 1outer STA k // outer loop: store latest k LDA n // test for k = n SUB k BRZ done // done if so LDA fac // save previous factorial STA prev LDA k // initialize i = kinner STA i // inner loop: store latest i LDA fac // build factorial by repeated addition ADD prev STA fac LDA i // decrement i SUB one BRZ next_k // if i = 0, move on to next k BRA inner // else loop for another additionnext_k LDA k // increment k ADD one BRA outer // back to start of outer loop done LDA fac // done, load the result OUT // print it HLT // haltn DAT 0 // input valuek DAT 0 // outer loop counter, 1 up to ni DAT 0 // inner loop counter, k down to 0fac DAT 0 // holds k!, i.e. n! when doneprev DAT 0 // previous value of facone DAT 1 // constant 1// end  ## LiveCode // recursivefunction factorialr n if n < 2 then return 1 else return n * factorialr(n-1) end ifend factorialr // using accumulatorfunction factorialacc n acc if n = 0 then return acc else return factorialacc(n-1, n * acc) end ifend factorialacc function factorial n return factorialacc(n,1)end factorial // iterativefunction factorialit n put 1 into f if n > 1 then repeat with i = 1 to n multiply f by i end repeat end if return fend factorialit ## LLVM ; ModuleID = 'factorial.c'; source_filename = "factorial.c"; target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"; target triple = "x86_64-pc-windows-msvc19.21.27702" ; This is not strictly LLVM, as it uses the C library function "printf".; LLVM does not provide a way to print values, so the alternative would be; to just load the string into memory, and that would be boring. ; Additional comments have been inserted, as well as changes made from the output produced by clang such as putting more meaningful labels for the jumps "\[email protected][email protected][email protected]" = comdat any @"\[email protected][email protected][email protected]" = linkonce_odr unnamed_addr constant [5 x i8] c"%ld\0A\00", comdat, align 1 ;--- The declaration for the external C printf function.declare i32 @printf(i8*, ...) ; Function Attrs: noinline nounwind optnone uwtabledefine i32 @factorial(i32) #0 {;-- local copy of n %2 = alloca i32, align 4;-- long result %3 = alloca i32, align 4;-- int i %4 = alloca i32, align 4;-- local n = parameter n store i32 %0, i32* %2, align 4;-- result = 1 store i32 1, i32* %3, align 4;-- i = 1 store i32 1, i32* %4, align 4 br label %loop loop:;-- i <= n %5 = load i32, i32* %4, align 4 %6 = load i32, i32* %2, align 4 %7 = icmp sle i32 %5, %6 br i1 %7, label %loop_body, label %exit loop_body:;-- result *= i %8 = load i32, i32* %4, align 4 %9 = load i32, i32* %3, align 4 %10 = mul nsw i32 %9, %8 store i32 %10, i32* %3, align 4 br label %loop_increment loop_increment:;-- ++i %11 = load i32, i32* %4, align 4 %12 = add nsw i32 %11, 1 store i32 %12, i32* %4, align 4 br label %loop exit:;-- return result %13 = load i32, i32* %3, align 4 ret i32 %13} ; Function Attrs: noinline nounwind optnone uwtabledefine i32 @main() #0 {;-- factorial(5) %1 = call i32 @factorial(i32 5);-- printf("%ld\n", factorial(5)) %2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @"\[email protected][email protected][email protected]", i32 0, i32 0), i32 %1);-- return 0 ret i32 0} attributes #0 = { noinline nounwind optnone uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" } !llvm.module.flags = !{!0, !1}!llvm.ident = !{!2} !0 = !{i32 1, !"wchar_size", i32 2}!1 = !{i32 7, !"PIC Level", i32 2}!2 = !{!"clang version 6.0.1 (tags/RELEASE_601/final)"} Output: 120 ## Logo ### Recursive to factorial :n if :n < 2 [output 1] output :n * factorial :n-1end ### Iterative NOTE: Slight code modifications may needed in order to run this as each Logo implementation differs in various ways. to factorial :n make "fact 1 make "i 1 repeat :n [make "fact :fact * :i make "i :i + 1] print :fact end ## LOLCODE HAI 1.3 HOW IZ I Faktorial YR Number BOTH SAEM 1 AN BIGGR OF Number AN 1 O RLY? YA RLY FOUND YR 1 NO WAI FOUND YR PRODUKT OF Number AN I IZ Faktorial YR DIFFRENCE OF Number AN 1 MKAY OICIF U SAY SO IM IN YR LOOP UPPIN YR Index WILE DIFFRINT Index AN 13 VISIBLE Index "! = " I IZ Faktorial YR Index MKAYIM OUTTA YR LOOPKTHXBYE Output: 0! = 1 1! = 1 2! = 2 3! = 6 4! = 24 5! = 120 6! = 720 7! = 5040 8! = 40320 9! = 362880 10! = 3628800 11! = 39916800 12! = 479001600 ## Lua ### Recursive function fact(n) return n > 0 and n * fact(n-1) or 1end ### Tail Recursive function fact(n, acc) acc = acc or 1 if n == 0 then return acc end return fact(n-1, n*acc)end ### Memoization The memoization table can be accessed directly (eg. fact[10]) and will return the memoized value, or nil if the value has not been memoized yet. If called as a function (eg. fact(10)), the value will be calculated, memoized and returned. fact = setmetatable({[0] = 1}, { __call = function(t,n) if n < 0 then return 0 end if not t[n] then t[n] = n * t(n-1) end return t[n] end}) ## M2000 Interpreter M2000 Interpreter running in M2000 Environment, a Visual Basic 6.0 application. So we use Decimals, for output. Normal Print overwrite console screen, and at the last line scroll up on line, feeding a new clear line. Some time needed to print over and we wish to erase the line before doing that. Here we use another aspect of this variant of Print. Any special formatting function () are kept local, so after the end of statement formatting return to whatever has before. We want here to change width of column. Normally column width for all columns are the same. For this statement (Print Over) this not hold, we can change column width as print with it. Also we can change justification, and we can choose on column the use of proportional or non proportional text rendering (console use any font as non proportional by default, and if it is proportional font then we can use it as proportional too). Because no new line append to end of this statement, we need to use a normal Print to send new line. [email protected] is 1 in Decimal type (27 digits).  Module CheckIt { Locale 1033 ' ensure #,### print with comma Function factorial (n){ If n<0 then Error "Factorial Error!" If n>27 then Error "Overflow" [email protected]:While n>1 {m*=n:n--}:=m } Const Proportional=4 Const ProportionalLeftJustification=5 Const NonProportional=0 Const NonProportionalLeftJustification=1 For i=1 to 27 \\ we can print over (erasing line first), without new line at the end \\ and we can change how numbers apears, and the with of columns \\ numbers by default have right justification \\ all () format have temporary use in this kind of print. Print Over (Proportional),("\f\a\c\t\o\r\i\a\l\(#\=",15), i,(ProportionalLeftJustification), $("#,###",40), factorial(i) Print \\ new line Next i}Checkit  Output:  factorial(1)= 1 factorial(2)= 2 factorial(3)= 6 factorial(4)= 24 factorial(5)= 120 factorial(6)= 720 factorial(7)= 5,040 factorial(8)= 40,320 factorial(9)= 362,880 factorial(10)= 3,628,800 factorial(11)= 39,916,800 factorial(12)= 479,001,600 factorial(13)= 6,227,020,800 factorial(14)= 87,178,291,200 factorial(15)= 1,307,674,368,000 factorial(16)= 20,922,789,888,000 factorial(17)= 355,687,428,096,000 factorial(18)= 6,402,373,705,728,000 factorial(19)= 121,645,100,408,832,000 factorial(20)= 2,432,902,008,176,640,000 factorial(21)= 51,090,942,171,709,440,000 factorial(22)= 1,124,000,727,777,607,680,000 factorial(23)= 25,852,016,738,884,976,640,000 factorial(24)= 620,448,401,733,239,439,360,000 factorial(25)= 15,511,210,043,330,985,984,000,000 factorial(26)= 403,291,461,126,605,635,584,000,000 factorial(27)= 10,888,869,450,418,352,160,768,000,000  ## M4 define(factorial',ifelse($1',0,1,eval($1*factorial(decr($1)))')')dnldnlfactorial(5)
Output:
120


            NORMAL MODE IS INTEGER           R   CALCULATE FACTORIAL OF N             INTERNAL FUNCTION(N)            ENTRY TO FACT.            RES = 1            THROUGH FACMUL, FOR MUL = 2, 1, MUL.G.NFACMUL      RES = RES * MUL            FUNCTION RETURN RES            END OF FUNCTION           R   USE THE FUNCTION TO PRINT 0! THROUGH 12!            VECTOR VALUES FMT = $I2,6H ! IS ,I9*$            THROUGH PRNFAC, FOR NUM = 0, 1, NUM.G.12PRNFAC      PRINT FORMAT FMT, NUM, FACT.(NUM)             END OF PROGRAM
Output:
 0! IS         1
1! IS         1
2! IS         2
3! IS         6
4! IS        24
5! IS       120
6! IS       720
7! IS      5040
8! IS     40320
9! IS    362880
10! IS   3628800
11! IS  39916800
12! IS 479001600


## MANOOL

 { let rec  { Fact = -- compile-time constant binding    { proc { N } as -- precondition: N.IsI48[] & (N >= 0)    : if N == 0 then 1 else      N * Fact[N - 1]    }  }  in -- use Fact here or just make the whole expression to evaluate to it:  Fact}

Conventional notation (equivalent to the above up to AST):

 { let rec  { Fact = -- compile-time constant binding    { proc { N } as -- precondition: N.IsI48[] & (N >= 0)      { if N == 0 then 1 else        N * Fact[N - 1]      }    }  }  in -- use Fact here or just make the whole expression to evaluate to it:  Fact}

Iterative version (in MANOOL, probably more appropriate in this particular case):

 { let  { Fact = -- compile-time constant binding    { proc { N } as -- precondition: N.IsI48[] & (N >= 0)    : var { Res = 1 } in -- variable binding    : do Res after -- return result    : while N <> 0 do -- loop while N does not equal to zero      Res = N * Res; N = N - 1    }  }  in -- use Fact here or just make the whole expression to evaluate to it:  Fact}

## Maple

Builtin

 > 5!;                                  120

Recursive

RecFact := proc( n :: nonnegint )        if n = 0 or n = 1 then                1        else                n * thisproc( n -  1 )        end ifend proc:
 > seq( RecFact( i ) = i!, i = 0 .. 10 );1 = 1, 1 = 1, 2 = 2, 6 = 6, 24 = 24, 120 = 120, 720 = 720, 5040 = 5040,     40320 = 40320, 362880 = 362880, 3628800 = 3628800

Iterative

 IterFact := proc( n :: nonnegint )        local   i;        mul( i, i = 2 .. n )end proc:
 > seq( IterFact( i ) = i!, i = 0 .. 10 );1 = 1, 1 = 1, 2 = 2, 6 = 6, 24 = 24, 120 = 120, 720 = 720, 5040 = 5040,     40320 = 40320, 362880 = 362880, 3628800 = 3628800

## Mathematica / Wolfram Language

Note that Mathematica already comes with a factorial function, which can be used as e.g. 5! (gives 120). So the following implementations are only of pedagogical value.

### Recursive

factorial[n_Integer] := n*factorial[n-1]factorial[0] = 1

### Iterative (direct loop)

factorial[n_Integer] :=   Block[{i, result = 1}, For[i = 1, i <= n, ++i, result *= i]; result]

### Iterative (list)

factorial[n_Integer] := Block[{i}, Times @@ Table[i, {i, n}]]

## MATLAB

### Built-in

The factorial function is built-in to MATLAB. The built-in function is only accurate for N <= 21 due to the precision limitations of floating point numbers.

answer = factorial(N)

### Recursive

function f=fac(n)    if n==0        f=1;        return    else        f=n*fac(n-1);    end

### Iterative

A possible iterative solution:

  function b=factorial(a)	b=1;		for i=1:a		    b=b*i;	end

## Maude

 fmod FACTORIAL is 	protecting INT . 	op undefined : -> Int .	op _! : Int -> Int . 	var n : Int . 	eq 0 ! = 1 .	eq n ! = if n < 0 then undefined else n * (sd(n, 1) !) fi . endfm red 11 ! .

## Maxima

### Built-in

n!

## MAXScript

### Iterative

fn factorial n =(    if n == 0 then return 1    local fac = 1    for i in 1 to n do    (        fac *= i    )    fac)

### Recursive

fn factorial_rec n =(    local fac = 1    if n > 1 then    (        fac = n * factorial_rec (n - 1)    )    fac)

## Mercury

### Recursive (using arbitrary large integers and memoisation)

:- module factorial. :- interface.:- import_module integer. :- func factorial(integer) = integer. :- implementation. :- pragma memo(factorial/1). factorial(N) =    (   N =< integer(0)    ->  integer(1)    ;   factorial(N - integer(1)) * N    ).

A small test program:

:- module test_factorial.:- interface.:- import_module io. :- pred main(io::di, io::uo) is det. :- implementation.:- import_module factorial.:- import_module char, integer, list, string. main(!IO) :-    command_line_arguments(Args, !IO),    filter(is_all_digits, Args, CleanArgs),    Arg1 = list.det_index0(CleanArgs, 0),    Number = integer.det_from_string(Arg1),    Result = factorial(Number),    Fmt = integer.to_string,    io.format("factorial(%s) = %s\n", [s(Fmt(Number)), s(Fmt(Result))], !IO).

Example output:

factorial(100) = 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

## Microsoft Small Basic

'Factorial - smallbasic - 05/01/2019For n = 1 To 25    f = 1    For i = 1 To n        f = f * i    EndFor    TextWindow.WriteLine("Factorial(" + n + ")=" + f)EndFor
Output:
Factorial(25)=15511210043330985984000000


## min

Works with: min version 0.19.6
((dup 0 ==) 'succ (dup pred) '* linrec) :factorial

## MiniScript

### Iterative

factorial = function(n)    result = 1    for i in range(2,n)        result = result * i    end for    return resultend function print factorial(10)

### Recursive

factorial = function(n)     if n <= 0 then return 1 else return n * factorial(n-1)end function print factorial(10)
Output:
3628800

## MIPS Assembly

### Iterative

 ################################### Factorial; iterative           ## By Keith Stellyes :)           ## Targets Mars implementation    ## August 24, 2016                ################################### # This example reads an integer from user, stores in register a1# Then, it uses a0 as a multiplier and target, it is set to 1 # Pseudocode:# a0 = 1# a1 = read_int_from_user()# while(a1 > 1)# {# a0 = a0*a1# DECREMENT a1# }# print(a0) .text ### PROGRAM BEGIN ###	### GET INTEGER FROM USER ###	li $v0, 5 #set syscall arg to READ_INTEGER syscall #make the syscall move$a1, $v0 #int from READ_INTEGER is returned in$v0, but we need $v0 #this will be used as a counter ### SET$a1 TO INITAL VALUE OF 1 AS MULTIPLIER ###	li $a0,1 ### Multiply our multiplier,$a1 by our counter, $a0 then store in$a1 ###loop:	ble $a1,1,exit # If the counter is greater than 1, go back to start mul$a0,$a0,$a1 #a1 = a1*a0 	subi $a1,$a1,1 # Decrement counter 	j loop # Go back to start exit: 	### PRINT RESULT ###	li $v0,1 #set syscall arg to PRINT_INTEGER #NOTE: syscall 1 (PRINT_INTEGER) takes a0 as its argument. Conveniently, that # is our result. syscall #make the syscall #exit li$v0, 10 #set syscall arg to EXIT	syscall #make the syscall

## VHDL

LIBRARY ieee;USE ieee.std_logic_1164.ALL;USE ieee.numeric_std.ALL; ENTITY Factorial IS	GENERIC (			Nbin : INTEGER := 3 ; -- number of bit to input number 			Nbou : INTEGER := 13) ; -- number of bit to output factorial 	PORT (		clk : IN STD_LOGIC ; -- clock of circuit		sr  : IN STD_LOGIC_VECTOR(1 DOWNTO 0); -- set and reset  		N   : IN STD_LOGIC_VECTOR(Nbin-1 DOWNTO 0) ; -- max number 	    Fn  : OUT STD_LOGIC_VECTOR(Nbou-1 DOWNTO 0)); -- factorial of "n" END Factorial ; ARCHITECTURE Behavior OF Factorial IS ---------------------- Program Multiplication -------------------------------- 	FUNCTION Mult ( CONSTANT MFa : IN UNSIGNED ;					CONSTANT MI   : IN UNSIGNED ) RETURN UNSIGNED IS 			 	VARIABLE Z : UNSIGNED(MFa'RANGE) ;	VARIABLE U : UNSIGNED(MI'RANGE) ;	BEGIN	Z := TO_UNSIGNED(0, MFa'LENGTH) ; -- to obtain the multiplication	U := MI ; -- regressive counter 		LOOP 			Z := Z + MFa ; -- make multiplication			U := U - 1 ; 			EXIT WHEN U = 0 ;		END LOOP ; 		RETURN Z ;	END Mult ; -------------------Program Factorial ---------------------------------------	FUNCTION Fact (CONSTANT Nx : IN NATURAL ) RETURN UNSIGNED IS 	VARIABLE C  : NATURAL RANGE 0 TO 2**Nbin-1 ;	VARIABLE I  : UNSIGNED(Nbin-1 DOWNTO 0) ;	VARIABLE Fa : UNSIGNED(Nbou-1 DOWNTO 0) ;	BEGIN 		C := 0 ; -- counter 		I :=  TO_UNSIGNED(1, Nbin) ;		Fa := TO_UNSIGNED(1, Nbou) ;			LOOP			EXIT WHEN C = Nx ; -- end loop 			C := C + 1 ;  -- progressive couter 			Fa := Mult (Fa , I ); -- call function to make a multiplication 			I := I + 1 ; -- 		END LOOP ;		RETURN Fa ;	END Fact ;--------------------- Program TO Call Factorial Function ------------------------------------------------------	TYPE Table IS ARRAY (0 TO 2**Nbin-1) OF UNSIGNED(Nbou-1 DOWNTO 0) ;	FUNCTION Call_Fact RETURN Table IS	VARIABLE Fc : Table ; 	BEGIN 		FOR c IN 0 TO 2**Nbin-1 LOOP			Fc(c) := Fact(c) ;				END LOOP ;		RETURN Fc ; 	END FUNCTION Call_Fact; 	CONSTANT Result : Table := Call_Fact ; ------------------------------------------------------------------------------------------------------------SIGNAL Nin : STD_LOGIC_VECTOR(N'RANGE) ;BEGIN    -- start of architecture  Nin <= N               WHEN RISING_EDGE(clk) AND sr = "10" ELSE       (OTHERS => '0') WHEN RISING_EDGE(clk) AND sr = "01" ELSE	   UNAFFECTED; Fn <= STD_LOGIC_VECTOR(Result(TO_INTEGER(UNSIGNED(Nin)))) WHEN RISING_EDGE(clk) ; END Behavior ;

## Vim Script

function! Factorial(n)  if a:n < 2    return 1  else    return a:n * Factorial(a:n-1)  endifendfunction

## Visual Basic

Works with: Visual Basic version VB6 Standard
 Option Explicit Sub Main()    Dim i As Variant    For i = 1 To 27        Debug.Print "Factorial(" & i & ")= , recursive : " & Format$(FactRec(i), "#,###") & " - iterative : " & Format$(FactIter(i), "#,####")    NextEnd Sub 'Main Private Function FactRec(n As Variant) As Variant    n = CDec(n)    If n = 1 Then        FactRec = 1#    Else        FactRec = n * FactRec(n - 1)    End IfEnd Function 'FactRec Private Function FactIter(n As Variant)    Dim i As Variant, f As Variant    f = 1#    For i = 1# To CDec(n)        f = f * i    Next i    FactIter = fEnd Function 'FactIter
Output:
Factorial(1)= , recursive : 1 - iterative : 1
Factorial(2)= , recursive : 2 - iterative : 2
Factorial(3)= , recursive : 6 - iterative : 6
Factorial(4)= , recursive : 24 - iterative : 24
Factorial(5)= , recursive : 120 - iterative : 120
Factorial(6)= , recursive : 720 - iterative : 720
Factorial(7)= , recursive : 5,040 - iterative : 5,040
Factorial(8)= , recursive : 40,320 - iterative : 40,320
Factorial(9)= , recursive : 362,880 - iterative : 362,880
Factorial(10)= , recursive : 3,628,800 - iterative : 3,628,800
Factorial(11)= , recursive : 39,916,800 - iterative : 39,916,800
Factorial(12)= , recursive : 479,001,600 - iterative : 479,001,600
Factorial(13)= , recursive : 6,227,020,800 - iterative : 6,227,020,800
Factorial(14)= , recursive : 87,178,291,200 - iterative : 87,178,291,200
Factorial(15)= , recursive : 1,307,674,368,000 - iterative : 1,307,674,368,000
Factorial(16)= , recursive : 20,922,789,888,000 - iterative : 20,922,789,888,000
Factorial(17)= , recursive : 355,687,428,096,000 - iterative : 355,687,428,096,000
Factorial(18)= , recursive : 6,402,373,705,728,000 - iterative : 6,402,373,705,728,000
Factorial(19)= , recursive : 121,645,100,408,832,000 - iterative : 121,645,100,408,832,000
Factorial(20)= , recursive : 2,432,902,008,176,640,000 - iterative : 2,432,902,008,176,640,000
Factorial(21)= , recursive : 51,090,942,171,709,440,000 - iterative : 51,090,942,171,709,440,000
Factorial(22)= , recursive : 1,124,000,727,777,607,680,000 - iterative : 1,124,000,727,777,607,680,000
Factorial(23)= , recursive : 25,852,016,738,884,976,640,000 - iterative : 25,852,016,738,884,976,640,000
Factorial(24)= , recursive : 620,448,401,733,239,439,360,000 - iterative : 620,448,401,733,239,439,360,000
Factorial(25)= , recursive : 15,511,210,043,330,985,984,000,000 - iterative : 15,511,210,043,330,985,984,000,000
Factorial(26)= , recursive : 403,291,461,126,605,635,584,000,000 - iterative : 403,291,461,126,605,635,584,000,000
Factorial(27)= , recursive : 10,888,869,450,418,352,160,768,000,000 - iterative : 10,888,869,450,418,352,160,768,000,000



## Visual Basic .NET

Translation of: C#

Various type implementations follow. No error checking, so don't try to evaluate a number less than zero, or too large of a number.

Imports SystemImports System.NumericsImports System.Linq Module Module1     ' Type Double:     Function DofactorialI(n As Integer) As Double ' Iterative        DofactorialI = 1 : For i As Integer = 1 To n : DofactorialI *= i : Next    End Function     ' Type Unsigned Long:     Function ULfactorialI(n As Integer) As ULong ' Iterative        ULfactorialI = 1 : For i As Integer = 1 To n : ULfactorialI *= i : Next    End Function     ' Type Decimal:     Function DefactorialI(n As Integer) As Decimal ' Iterative        DefactorialI = 1 : For i As Integer = 1 To n : DefactorialI *= i : Next    End Function     ' Extends precision by "dehydrating" and "rehydrating" the powers of ten    Function DxfactorialI(n As Integer) As String ' Iterative        Dim factorial as Decimal = 1, zeros as integer = 0        For i As Integer = 1 To n : factorial *= i            If factorial Mod 10 = 0 Then factorial /= 10 : zeros += 1        Next : Return factorial.ToString() & New String("0", zeros)    End Function     ' Arbitrary Precision:     Function FactorialI(n As Integer) As BigInteger ' Iterative        factorialI = 1 : For i As Integer = 1 To n : factorialI *= i : Next    End Function     Function Factorial(number As Integer) As BigInteger ' Functional        Return Enumerable.Range(1, number).Aggregate(New BigInteger(1),            Function(acc, num) acc * num)    End Function     Sub Main()        Console.WriteLine("Double  : {0}! = {1:0}", 20, DoFactorialI(20))        Console.WriteLine("ULong   : {0}! = {1:0}", 20, ULFactorialI(20))        Console.WriteLine("Decimal : {0}! = {1:0}", 27, DeFactorialI(27))        Console.WriteLine("Dec.Ext : {0}! = {1:0}", 32, DxFactorialI(32))        Console.WriteLine("Arb.Prec: {0}! = {1}", 250, Factorial(250))    End SubEnd Module
Output:

Note that the first four are the maximum possible for their type without causing a run-time error.

Double  : 20! = 2432902008176640000
ULong   : 20! = 2432902008176640000
Decimal : 27! = 10888869450418352160768000000
Dec.Ext : 32! = 263130836933693530167218012160000000
Arb.Prec: 250! = 3232856260909107732320814552024368470994843717673780666747942427112823747555111209488817915371028199450928507353189432926730931712808990822791030279071281921676527240189264733218041186261006832925365133678939089569935713530175040513178760077247933065402339006164825552248819436572586057399222641254832982204849137721776650641276858807153128978777672951913990844377478702589172973255150283241787320658188482062478582659808848825548800000000000000000000000000000000000000000000000000000000000000


## Vlang

Updated to Vlang version 0.2.2

### Imperative

const max_size = 10 fn factorial_i() {  mut facs := [0].repeat(max_size + 1)  facs[0] = 1  println('The 0-th Factorial number is: 1')  for i := 1; i <= max_size; i++ {    facs[i] = i * facs[i - 1]    num := facs[i]    println('The $i-th Factorial number is:$num')  }} fn main() {	factorial_i()}

### Recursive

const max_size = 10 fn factorial_r(n int) int {  if n == 0 {    return 1  }  return n * factorial_r(n - 1)} fn main() {  for i := 0; i <= max_size; i++ {    println('factorial($i) is:${factorial_r(i)}')  }}

### Tail Recursive

const max_size = 10 fn factorial_tail(n int) int {	sum := 1	return factorial_r(n, sum)} fn factorial_r(n int, sum int) int {  if n == 0 {    return sum  }  return factorial_r(n - 1, n * sum )} fn main() {  for i := 0; i <= max_size; i++ {    println('factorial($i) is:${factorial_tail(i)}')  }}

### Memoized

const max_size = 10 struct Cache {mut:  values []int} fn fac_cached(n int, mut cache Cache) int {  is_in_cache := cache.values.len > n  if is_in_cache {    return cache.values[n]  }  fac_n := if n == 0 { 1 } else { n * fac_cached(n - 1, mut cache) }  cache.values << fac_n  return fac_n} fn main() {  mut cache := Cache{}  for n := 0; n <= max_size; n++ {    fac_n := fac_cached(n, mut cache)    println('The $n-th Factorial is:$fac_n')  }}
Output:
The 0-th Factorial is: 1
The 1-th Factorial is: 1
The 2-th Factorial is: 2
The 3-th Factorial is: 6
The 4-th Factorial is: 24
The 5-th Factorial is: 120
The 6-th Factorial is: 720
The 7-th Factorial is: 5040
The 8-th Factorial is: 40320
The 9-th Factorial is: 362880
The 10-th Factorial is: 3628800

## Wart

### Recursive, all at once

def (fact n)  if (n = 0)    1    (n * (fact n-1))

### Recursive, using cases and pattern matching

def (fact n)  (n * (fact n-1)) def (fact 0)  1

### Iterative, with an explicit loop

def (fact n)  ret result 1    for i 1 (i <= n) ++i      result <- result*i

### Iterative, with a pseudo-generator

# a useful helper to generate all the natural numbers until ndef (nums n)  collect+for i 1 (i <= n) ++i    yield i def (fact n)  (reduce (*) nums.n 1)

## WDTE

### Recursive

let max a b => a { < b => b }; let ! n => n { > 1 => - n 1 -> ! -> * n } -> max 1;

### Iterative

let s => import 'stream'; let ! n => s.range 1 (+ n 1) -> s.reduce 1 *;