40
\$\begingroup\$

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

\$\endgroup\$

106 Answers 106

2
\$\begingroup\$

Setanta, 45 44 43 bytes

gniomh F(n){ma n<2 toradh 1toradh n*F(n-1)}

Try it here!

\$\endgroup\$
2
\$\begingroup\$

GolfScript, 9 bytes

1\~,{)*}/

Try it online!

1\         # Puts 1 under the input, this will be the acumulator
  ~,       # Makes an array with numbers from 0 to (n-1)
    {)*}   # This block goes to the top of the stack without being executed, when executed it increments and multiplies, this avoids multiplying by 0 and also multiplies by n
        /  # Executes the previous block for each number in the array
\$\endgroup\$
1
  • \$\begingroup\$ Welcome to Code Golf! \$\endgroup\$
    – Bubbler
    Sep 15 '20 at 22:41
2
\$\begingroup\$

Flurry -nii, 14 bytes

{}{<({})[]>}{}

Try it online!

Takes single number from the stack and prints its factorial from the return value.

The online interpreter implements certain arithmetic shortcuts, so it computes and prints 125! in an instant.

How it works

Iterate through 1 to n using the stack height and multiply all of them to the starting value of 1.

// n is the only content of the stack at program start
// 1 is popped from empty stack
main = pop push-mul pop
     = n push-mul 1

// height yields 1 to n, since it is called after a push
// <a b> = a * b (where a, b are Church numerals)
push-mul = \x. <(push x) height>
\$\endgroup\$
2
\$\begingroup\$

Labyrinth, 16 bytes

?+1#*
(: (;
 @!;

Try it online!

Utilizes two loops, one to duplicate and decrement the input until zero, then one to multiply all the items on the stack.

\$\endgroup\$
2
\$\begingroup\$

Assembly (MIPS, SPIM), 78 bytes, 6*9 = 54 assembled bytes

main:li$2,5
syscall
li$4,1
f:beqz$2,g
mul$4,$4,$2
sub$2,1
b f
g:li$2,1
syscall

Try it online!

This is a significant optimization of this answer, but the account was deleted.

Specifically, this makes the following changes:

  • It compares once at the top of the loop, using an unconditional branch at the bottom
  • It uses the numerical register names which are shorter
  • It removes spaces between mnemonics, as SPIM accepts this
  • It removes the second operand from sub

Otherwise, the logic is identical.

\$\endgroup\$
2
\$\begingroup\$

Phooey, 15 bytes

=>&.[@<*>-1]<$i

Try it online!

=>&.[@<*>-1]<$i # stack tape 
=               #   (0)  >a    0     acc = 1
 >              #   (0)   a   >0     move left
  &.            #   (0)   a   >n     read int
    [      ]    #   (0)   a   >n     loop while n != 0
     @          #    n    a   >n         push n
      <*>       #   (0)   a*n >n         multiply acc by n (popping from stack)
         -1     #   (0)   a*n >n-1       subtract 1 from n
            <   #   (0)  >res 0      go right to the result
             $i #   (0)  >res 0      print as integer

Since Phooey uses int64_t, this supports up to 20.

\$\endgroup\$
2
+250
\$\begingroup\$

Factor + math.factorials, 6 bytes

[ n! ]

Try it online!

Thanks to @Bubbler for -9 bytes

Factor + math.factorials, 15 bytes

[ factorial . ]

Try it online!

\$\endgroup\$
1
  • 1
    \$\begingroup\$ There's n! which is a synonym of factorial, and you don't need to print the result, so simply n! is a valid built-in submission. (You don't need to wrap it in a quotation, as a built-in submission is scored by its name.) \$\endgroup\$
    – Bubbler
    Mar 31 '21 at 3:34
2
\$\begingroup\$

Vyxal, 1 byte

¡

Try it Online!

Built-in factorial.


No built-in, 2 bytes

ɾΠ

Explanation:

    # Implicit input
ɾ   # Range [1, N]
 Π  # Reduce by multiplication
    # Implicit output

Try it Online!

\$\endgroup\$
2
\$\begingroup\$

jq, 10 bytes

.+1|tgamma

Uses the gamma function Γ(n) = (n - 1)!

Try it online!

\$\endgroup\$
1
  • 1
    \$\begingroup\$ I think |ceil is not necessary since floating point imprecision is allowed. \$\endgroup\$
    – Bubbler
    Sep 2 '21 at 23:50
1
\$\begingroup\$

Keg, -hr, 4 bytes

Ï_∑*

Try it online!

\$\endgroup\$
1
\$\begingroup\$

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!

\$\endgroup\$
1
\$\begingroup\$

Io, 20 bytes

method(\,\factorial)

Try it online!

\$\endgroup\$
1
\$\begingroup\$

Seriously, 2 bytes

,!

Try it online!

\$\endgroup\$
1
\$\begingroup\$

Desmos, 2 bytes

n!

Try it in Desmos

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

\$\endgroup\$
1
\$\begingroup\$

Wolfram Language (Mathematica), 9 3 bytes

-6 bytes thanks to @att

#!&

Try it online!

\$\endgroup\$
1
  • 3
    \$\begingroup\$ 3 bytes \$\endgroup\$
    – att
    Aug 25 '20 at 5:00
1
\$\begingroup\$

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)
\$\endgroup\$
1
\$\begingroup\$

Elixir, 30 bytes

Recursive.

def f(n),do: n>1&&n*(f n-1)||1

Try it online!

\$\endgroup\$
1
\$\begingroup\$

Burlesque, 4 bytes

ri?!

Try it online!

Explanation:

ri    # Read integer
  ?!  # Calculate factorial
\$\endgroup\$
1
\$\begingroup\$

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!

\$\endgroup\$
1
\$\begingroup\$

cQuents, 5 bytes

$0:$!

Try it online!

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

\$\endgroup\$
1
\$\begingroup\$

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

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

Try it online!

\$\endgroup\$
1
  • 1
    \$\begingroup\$ Suggest n<1 instead of n==0 \$\endgroup\$
    – ceilingcat
    Aug 31 '20 at 9:36
1
\$\begingroup\$

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!

\$\endgroup\$
1
  • \$\begingroup\$ If anyone knows if there's a way to do 7.4 arrow functions with recursion I'd be very interested to know! \$\endgroup\$
    – 640KB
    Aug 25 '20 at 19:24
1
\$\begingroup\$

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

\$\endgroup\$
2
  • 1
    \$\begingroup\$ You can do -~b to just do range(n). You've also got a trailing space in your submission \$\endgroup\$
    – Jo King
    Aug 27 '20 at 6:08
  • 1
    \$\begingroup\$ If you didn't notice yet, TIO has a Code Golf submission generator. \$\endgroup\$
    – Bubbler
    Aug 28 '20 at 2:26
1
\$\begingroup\$

Haskell, 17 characters

f n=product[1..n]

Bonus reference: "The Evolution of a Haskell Programmer" by Fritz Ruehr

Try it online!

\$\endgroup\$
1
\$\begingroup\$

Arn, 2 bytes

↓;

Try it!

Unpacked: .fact. Passes STDIN (_) into the factorial function via the . infix

3 byte solution:

A→.

Unpacked: *\~

  \      Fold with
*        Multiplication
    ~    1-range
      _  Variable initialized to STDIN; implied
\$\endgroup\$
1
\$\begingroup\$

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!

\$\endgroup\$
1
\$\begingroup\$

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

\$\endgroup\$
1
\$\begingroup\$

Husk, 1 byte

Π

Try it online!

\$\endgroup\$
1
\$\begingroup\$

Python 3, 30 27 bytes

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

Try it online!

\$\endgroup\$
1
\$\begingroup\$

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.

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.