The vanilla factorial challenge

Question

Task

Given a non-negative integer \$n\$, evaluate the factorial \$n!\$.

The factorial is defined as follows:

$$ n!=\begin{cases}1 & n=0\\n\times(n-1)!&n>0\end{cases} $$

Rules

• All default I/O methods are allowed.
• Standard loopholes are forbidden.
• Built-ins are allowed.
• There is no time or memory limit.
• Giving imprecise or incorrect results for large inputs due to the limit of the native number format is fine, as long as the underlying algorithm is correct. Specifically, it is not allowed to abuse the native number type to trivialize the challenge, which is one of the standard loopholes.
• This is code-golf. Shortest code in bytes wins, but feel free to participate in various esolangs (especially the ones hindered by the restrictions of the former challenge).

Test cases

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

---

Note: We already have the old factorial challenge, but it has some restrictions on the domain, performance, and banning built-ins. As the consensus here was to create a separate challenge without those restrictions so that more esolangs can participate, here it goes.

Also, we discussed whether we should close the old one as a duplicate of this, and we decided to leave it open.

Answer 1

Pyramid Scheme, 510 bytes

    ^           ^     ^
   / \         / \   / \
  /set\       /   \ /out\
 ^-----^     /loop \-----^
/a\   /]\   ^-------^   /b\
---  ^---^ /a\      -^  ---
    / \ /#\---      /]\
   /set\---^       ^---^
  ^-----^ / \     / \  -^
 /b\   ^-/   \   /set\  -^
 ---  ^-/line \ ^-----^  -^
     /1\-------/b\   ^-  / \
     ---       ---  /*\ /set\
                   ^---^-----^
                  /b\ /a\   /-\
                  --- ---  ^---^
                          /a\ /1\
                          --- ---

Try it online!

It works!

I spent way too long debugging this. There's a lot of empty space which I can't seem to get rid of.

This is basically the following pseudocode:

a = input
b = 1
while a
  b *= a
  a -= 1
print b

Answer 2

JavaScript, 19 bytes

f=n=>n?f(n-1n)*n:1n

2 bytes longer than the other JS answers, but can safely calculate as high as 11190! instead of 18!, with anything higher exceeding the call stack size (tested on Node.js 18.6.0). the result has 40450 digits.

update: running with --stack-size=65536 allows me to calculate up to 95200!, resulting in 432625 digits. Trying to calculate any higher caused segmentation faults, no matter what I set the stack size to.

Answer 3

><>, 14 bytes

1$:@?!n$:1-@*!

Try it online

Explanation

1               # initialize product as 1
 $:@?!n         # if the current counter (starts as n) is 0, print the product
       $:1-@    # subtract 1 from the counter for the next iteration
            *   # multiply current counter with product
             !  # skip the product initialization for the next iteration

Answer 4

Nibbles, 8 nibbles (4 bytes)

? $ `*,$ 1

Attempt This Online!

Explanation

? $ `*,$ 1    #
----------------------------------------
? $           # if arg1
              # equals truthy (<0)
    `*        #    product
      ,$      #    range 1..arg1
              # else
         1    #    1 

Answer 5

Vyxal 3L, 2 bytes

/*

Try it Online!

Fold / the input by multiplication *. Fold treats whole numbers as the range from 1 to n.

The factorial built-in is 4 bytes: fact

Answer 6

BQN, 5 bytes

×´1+↕

Try it at BQN online!

Explanation

Same as chunes's Uiua answer, just different syntax.

×´1+↕
    ↕  Range from 0 to argument - 1
  1+   Add 1 to each
×´     Fold on multiplication

Answer 7

Setanta, 45 44 43 35 bytes

gniomh F(n){toradh(n>1&n*F(n-1))|1}

Try it here!

Answer 8

SNOBOL4 (CSNOBOL4), 65 bytes

 i =input
 p =1
i x =x + 1
 p =p * x
 output =p le(i,x) :f(i)
end

Try it online!

Answer 9

Desmos, 2 bytes

n!

Try it in Desmos

Finally a competitive Desmos answer that isn't graphical-output!

Answer 10

Wolfram Language (Mathematica), ⁹ 3 bytes

-6 bytes thanks to @att

#!&

Try it online!

Answer 11

MathGolf, 1 byte

!

Try it online.

Explanation:

!  # Get the factorial (aka gamma(n+1)) of the (implicit) input-integer
   # (output the entire stack joined together implicitly as result)

Answer 12

Burlesque, 4 bytes

ri?!

Try it online!

Explanation:

ri    # Read integer
  ?!  # Calculate factorial

Answer 13

Lua, 36 bytes

x=1 for i=1,...do x=x*i end print(x)

Try it online!

On Lua <= 5.2 this will use double, allowing big inputs to work. On Lua 5.3+ (as currently on TIO) integers are used instead, making big inputs fail. This can be worked around at cost of one byte:

Lua, 37 bytes

x=1. for i=1,...do x=x*i end print(x)

Try it online!

Answer 14

cQuents, 5 bytes

$0:$!

Try it online!

The first three bytes are for 0-indexing, since by default cQuents uses 1-indexing.

Answer 15

C# (Visual C# Interactive Compiler), 30 bytes

int f(int n)=>n==0?1:n*f(n-1);

Try it online!

Answer 16

PHP, 38 bytes

Recursive...

function f($n){return$n?$n*f($n-1):1;}

Try it online!

Or functional...

PHP, 39 bytes

fn($n)=>$n?array_product(range($n,1)):1

Try it online!

Answer 17

Python 2, 46 bytes

lambda n:reduce(lambda a,b:a*b,range(1,n+1),1)

How it works:

the reduce function takes in the list that contains all the numbers from 1 to n and reduces it by the multiplication function (lambda a,b:a*b) to a single number. An optional initial parameter is set in the case that n is equal to 0.

Try it online (with all test cases)!

Answer 18

C#, 42 bytes

Using the power of fresh and new C# 9 we can achieve a stunning 42 bytes!

int f(int n)=>n<2?1:n*f(n-1);return f(10);

for C# 8 and the online example we need to add 38 bytes for a total of 70 bytes

class P{static int Main(){int f(int n)=>n<2?1:n*f(n-1);return f(10);}}

Try it online!

Answer 19

ink, 50 bytes

==function f(n)
{
-!n:~return 1
}
~return n*f(n-1)

Try it online!

Had to make it a proper function instead of just a stitch, since I actually have to use the return value (so outputting by printing is not an option - or at least not a good one).

Answer 20

Python 3, 30 27 bytes

f=lambda n:1>>n or n*f(n-1)

Try it online!

Answer 21

Kotlin, 37 bytes

fun a(n:Int)=(1..n).fold(1){a,b->a*b}

Had to use fold(1){a,b->a*b}(surprisingly enough 1 less byte than something like fold(1,Int::times)) due to a lack of a product function in the stdlib.

Answer 22

BRASCA v0.4, 11 bytes

^{v0.4 was made after my initial solution and added the r operator, hence the seperate answer.}

ig0$r[*$]xn

Try it online!

Explanation

ig          - Convert to numbers and concatenate digits
  0$r       - Push range (i, 0) to stack
     [*$]   - Multiply it all
         xn - Remove the 0 and output the result

BRASCA, 15 14 bytes

ig[:1-]x[*$]xn

Try it online!

Explanation

ig                   - Convert to numbers and concatenate
  [:1-]              - Generate a sequence from N to 0 on the stack
       x             - Remove the 0
        [*$]         - Multiply it all together
            $n       - Bring the number to the front and output it

Answer 23

Javascript (ES6),19 bytes

f=n=>n?f(n-1)*n:1

Answer 24

Tcl, 35 bytes

proc F x {expr $x?\[F $x-1]*($x):1}

Try it online!

Answer 25

Pxem, 26 bytes (filename) + 0 bytes (content) = 26 bytes.

• Filename (escaped): \001._.c.w.t.m.!.m\001.-.c.a.s.n
• Content: empty

Usage

• Input decimal integer from STDIN
• Output to STDOUT

How it works

XX.z
.a\001XX.z # push one
.a._.c.wXX.z # push getint; dup; while pop!=0; do
  .a.t.m.!XX.z # heap=pop; push heap; push pop*pop
  .a.m\001.-XX.z # push heap; push 1; push abs(pop-pop)
  .a.cXX.z # dup
.a.a.s.nXX.z # done; pop; printf "%d" pop
.a

Try it online!

Answer 26

M4, 49 bytes

define(f,`ifelse($1,0,1,`eval($1*f(decr($1)))')')

Try it online!

Usage

f(n)dnl where n is an integer.

Answer 27

Python 3, 56 bytes

def f(n):
 k=1
 for i in range(2,n+1):
  k=k*i
 return k

Try it online!

Answer 28

Pinecone, 45 bytes

f::{Int}:(k:1;i:1|i<=in|i:i+1@k:k*i;print:k)

Answer 29

Scala 3, 79 bytes

import compiletime.ops.int._
type F[N<:Int]=N match{case 0=>1 case _=>N*F[N-1]}

Try it in Scastie

Answer 30

Red, 40 bytes

f: func[n][either n = 0[1][n * f n - 1]]

Try it online!

I'm surprised there are no Red answers here yet. I'm still pretty new to Red, so there may be golf potential here. But I condensed it as much as I could (all the whitespace is necessary). It's the simple recursive definition: if n = 0, return 1, else return n * f(n-1).