Logo

Programming-Idioms

Create the recursive function f which returns the factorial of the non-negative integer i, calculated from f(i-1)
New implementation

Be concise.

Be useful.

All contributions dictatorially edited by webmasters to match personal tastes.

Please do not paste any copyright violating material.

Please try to avoid dependencies to third-party libraries and frameworks.

Other implementations
function F (I : Natural) return Natural is (if I < 2 then 1 else I * F (I - 1));
unsigned int f(unsigned int i)
{
	return i?i*f(i-1):1;
}
(defn f [i]
  (loop [cnt i, acc 1N]
    (if (zero? cnt) acc
      (recur (dec cnt) (* cnt acc)))))
unsigned int f( unsigned int i ) {
	if ( i == 0 ) return 1;
	
	return i * f( i - 1 );
}
int f(int i) => i == 0 ? 1 : i * f(i - 1)
int f(int i)
{
    if (i == 0) return 1;
    return i * f(i - 1);
}
uint f(in uint i) pure nothrow @nogc
in {
    assert(i <= 12);
} body {
    if (i == 0)
        return 1;
    else
        return i * f(i - 1);
}
f(i) => (i == 0) ? 1 : i * f(i - 1);
defmodule Factorial do
  def f(0), do: 1
  def f(i) when i > 0 do
    n * f(i-1)
  end
end
f(0) -> 1;
f(I) -> I * f(I - 1).
module x
  implicit none
contains
  recursive function f (i) result (res)
    integer, intent(in) :: i
    integer :: res
    if (i <= 0) then
       res = 1
    else
       res = f(i-1) * i
    end if
  end function f
end module x
func f(i int) int {
  if i == 0 {
    return 1
  }
  return i * f(i-1)
}
def f(i) { i == 0 ? 1 : i * f(i - 1) }
f i = if i > 1 then f (i-1) * i else 1
function f(i) {
   return i<2 ? 1 : i * f(i-1);
}
const f = i => i === 0 ? 1 : i * f(i-1)
int f(int i) {
    if (i == 0)
        return 1;
    else
        return i * f(i - 1);
}
fun f(i: Int): Int = when (i) {
    0 -> 1
    else -> i * f(i - 1)
}
fun f(i: Int) = if (i == 0) 1 else i * f(i - 1)
(defun f (i)
  (if (< i 2)
    1
    (* i (f (- i 1)))))
function f(n)
   local function f_(factorial,n)
      if n < 2 then return 1
      return f_(factorial*n, n-1)
   end
   return f_(1,n)
end
unsigned f(unsigned i) {
  return i?i*f(i-1):1;
}
function f($i) {
	if($i == 0) {
		return 1;
	}

	return ($i * f($i-1));
}
function f(int $i): int
{
    if ($i == 0) {
        return 1;
    }

    return $i * f($i - 1);
}
type
  TPositiveInt = 0..MaxInt;

function _f(_i: TPositiveInt): Integer;
begin
  if (_i < 2) then
    Result := 1
  else
    Result := _f(_i - 1);
end; 
sub f {
   my $i = shift;
   return $i<2 ? 1 : $i * f($i-1);
}
def f(i):
   if i == 0:
       return 1
   else:
       return i * f(i-1)
fac = Hash.new {|h, i| h[i] = i * h[i-1] }.tap {|h| h[0] = 1 }
f = Hash.new { |hash, i| hash[i] = i * hash[i -1] }
f[0] = 1
fn factorial(num: u64) -> u64 {
    match num {
        0 | 1 => 1,
        _ => factorial(num - 1) * num,
    }
}
fn f(n: u32) -> u32 {
    if n < 2 {
        1
    } else {
        n * f(n - 1)
    }
}
def f(i: Int): Int =
  if (i > 1){
    i * f(i-1) 
  } else{
    1
  }
(define (f i)
  (if (> i 1)
      (* (f (- i 1)) i)
      1))
f := [:i | i = 0 ifTrue: [1] ifFalse: [i * (f value: i - 1)]].
Function f(i As Integer) As Integer
    Return If(i = 0, 1, i * f(i - 1))
End Function