Factorial Calculator

In this challenge, you will implement a function to calculate the factorial of a given non-negative integer. The factorial of a number n (denoted as n!) is the product of all positive integers less than or equal to n. For example, the factorial of 5 is 5! = 5 * 4 * 3 * 2 * 1 = 120.

Factorials grow very quickly, so it is important to handle large numbers appropriately. Rust's standard library provides the u128 type, which can handle very large integers. Your task is to implement a function that calculates the factorial of a given u32 number and returns the result as a u128.

Your task

Implement a function factorial(n: u32) -> u128 that calculates the factorial of the given non-negative integer n. Use early returns to handle the base case when n is 0, since 0! is defined as 1. For other values of n, use a loop to calculate the factorial.

Requirements

The function should take a single argument n of type u32 and return a u128.
Use early returns to handle the case when n is 0.
For other values of n, use a loop to calculate the factorial.

Example

let result = factorial(5);
assert_eq!(result, 120);
 
let result = factorial(10);
assert_eq!(result, 3628800);
 
let result = factorial(0);
assert_eq!(result, 1);

Hints

Remember that Rust has a u128 type which can hold very large numbers. This will be useful for calculating large factorials.
Use the return statement to handle the base case of 0!.
A for loop or while loop can be used to multiply the numbers from 1 to n.
Consider using an iterative approach rather than a recursive one to avoid potential stack overflow issues for large n.

Editor not available on Mobile!

In order to solve the challenge, please visit this page on a desktop computer.

Solutions

Christopher Nielson

c-nielson

3 days ago

2.80ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    if n <= 1 {
        return 1;
    }
    let mut result: u128 = 1;
    for i in 2..=n {
        result *= i as u128;
    }
    result
}

SeinPierre

4 days ago

2.74ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    let mut res:u128 = 1;
    for i in 1..=n {
        res *= i as u128;
    }
    res
}

SeinPierre

4 days ago

2.99ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    let n = n as u128;
    let mut res:u128 = 1;
    for i in 1..=n {
        res *= i;
    }
    res
}

Donald Huber-Youmans

dHuberYoumans

5 days ago

2.86ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    let mut res: u128 = 1;
    for i in 1..=n {
        res *= i as u128;
    }
    res
}

Elliott Draper

ejdraper

7 days ago

2.97ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    if n == 0 {
        return 1;
    }
    if n == 1 {
        return 1;
    } else {
        return factorial(n - 1) * n as u128;
    }
}

Muhammad-Dennis

7 days ago

2.90ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    let n = n as u128;
    
    if n == 1 {
        return 1
    }
    (1..=n).rev().fold(1, |acc, next| acc * next) as u128
}

エヴァンゲリオン

Lu-zihang

10 days ago

3.58ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    if n == 0 {1} 
    else {n as u128 * factorial(n-1)}
}

エヴァンゲリオン

Lu-zihang

10 days ago

2.73ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    if n == 0 {1} 
    else {n as u128 * factorial(n-1)}
}

Sthitaprajna Sahu

sthitasahu

12 days ago

3.59ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    let mut result=1;
    if n==0{
       return 1;
    }
    else{
        for i in 1..=n as u128{
            result=result*i;
        }
    }
    return result;
}

Sthitaprajna Sahu

sthitasahu

12 days ago

3.20ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    let mut result:u128=1;
    if n==0{
       return 1;
    }
    else{
        for i in 1..=n as u128{
            result=result*i;
        }
    }
    return result;
}

Florian Gaudin-Delrieu

FlorianGD

12 days ago

2.86ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    if n == 0 {
        1
    } else {
        n as u128 * factorial(n-1)
    }
}

dawwestk

14 days ago

14.11ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    match n {
        0 => 1,
        1 => 1,
        _ => {
            let mut x = 1u128;
            for i in (1..=n).rev() {
                x *= i as u128;
            }
            x
        }
    }
}

PangoSea

kapaseker

16 days ago

5.02ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    (1..=n).fold(1u128, |acc, x| acc * x as u128)
}

matsuyama-k1

19 days ago

3.50ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    let mut result:u128 = 1;
    for i in 1..(n+1) {
        result *= i as u128;
    }
    return result
}

Sakura

sakkura

20 days ago

3.79ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    let mut base: u128 = 1;
    for i in 2..=n {
        base *= i as u128;
    }
    base
}

Ahmet Özcan

ahmetoozcan

21 days ago

3.32ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    (1..=n).map(|x| x as u128).product()
}

mm-yyyy

21 days ago

3.77ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    if n == 0 { 1 } else {
        let mut f: u128 = 1;
        for i in 1..=n as u128 {
            f *= i;
        }
        f
    }
}

Bugra Okumus

bgraokmush

21 days ago

2.91ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    match n {
        0 => return 1 as u128,
        1 => return 1 as u128,
        _ => n as u128 * factorial(n-1)
    }
}

Mikhail Shutov

mshutov

21 days ago

2.69ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    (1..=(n as u128)).product()
}

Dominicm99

21 days ago

2.75ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    let mut ret: u128 = 1;
    for i in 2..=n {ret *= i as u128}
    ret
}

vikingNR

22 days ago

3.01ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    match n {
        0 => 1 as u128,
        1 => n as u128,
        _ => n as u128 * factorial(n-1)
    }
    // Implement your code here
}

nedrw

22 days ago

3.08ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    let mut res = 1u128;
    for i in 2..=n { res *= i as u128}
    res
}

chuyuanlinzi

22 days ago

2.86ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    if n == 0 || n == 1 {
        1 as u128
    } else {
        n as u128 * factorial(n - 1)
    }
}

Ohayo

labike

22 days ago

4.33ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    if n == 0 {
        return 1;
    } else {
        let mut current = 1;
        let mut num = n;
        while num > 1 {
            current *= num as u128;
            num -= 1;
        }
        return current;
    }
}

Infinite Time

InfiniteTime3000

23 days ago

3.13ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    if n == 0 {return 1;}
    let mut f: u128 = 1;
    for i in 1..=n as u128{
        f*=i;
    }
    f
}

Sandeep chauhan

ryzen-xp

23 days ago

3.03ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    match n {
        0|1 => 1 ,
        _ => (n as u128) * factorial(n-1),
    }
    
}

PavelPerna

24 days ago

2.57ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    match n {
        0|1 => 1,
        _ => (n as u128)*factorial(n-1)
    }
}

rawar089

24 days ago

8.68ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    if n == 0 { return 1}
    let mut f: u128 = 1;
    for i in 1..=n as u128 {
        f = f * i;
    }
    f
}

rawar089

24 days ago

5.31ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    if n == 0 { return 1}
    let mut f: u128 = 1;
    for i in 1..=n {
        f = f * i as u128;
    }
    f
}

Vlad

mvldmihai

24 days ago

3.29ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    if n == 0 {
        return 1;
    }
    let mut start: u128 = 1;
    let mut sum: u128 = 1;
    while start <= n.into() {
        sum *= start;
        start += 1;
    }
    sum
}

Stan

i2z4

24 days ago

2.78ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    if n == 0 || n == 1 {
        return 1;
    }
    let mut fact: u128 = 1;
    let mut i = n as u128;
    while i > 0 {
        fact *= i;
        i -= 1;
    }
    fact
}

L-Super

24 days ago

3.51ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    if n == 0 || n == 1{
        return 1;
    }
    n as u128 * factorial(n-1)
}

Tarokc

25 days ago

2.96ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    let fac: u128;
    if n == 0 || n == 1{
        return 1 as u128
    }
    else {
        fac = n as u128 * factorial(n-1);
    }
    fac as u128
}

zahrajavar

25 days ago

2.76ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    if n==0 {
        return 1 as u128;
    }
    let mut prod:u128=1;
    for i in 1..(n+1){
        prod = prod * i as u128;
    }
    return prod;
}

karapy

a month ago

2.91ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    if n == 0 { return 1;}
    let mut sum : u128 = n as u128;
    let mut counter =  n - 1;
    loop {
        if counter == 0 { break sum }
        sum *= counter as u128;
        counter -= 1;        
    }
}

goerfra

a month ago

2.99ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    if n == 0 { return 1; }
    // n as u128 * factorial(n - 1)
    let mut sum:u128 = n as u128;
    let mut ct = n - 1;
    loop {
        if ct == 0 { break sum }
        sum *= ct as u128;  
        ct -= 1;
    }
}
//Time: 10.56623700ms | 2.65645000ms
//Peak heap memory consumption: 81.28KB

Larry Oates

Leafmun-certii

a month ago

3.07ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    if n == 0 {
        return 1
    }
    n as u128 * factorial(n-1)
}

Yofifi

a month ago

3.13ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    let mut sum: u128 = 1;
    for i in 2..=n {
        sum = sum * i as u128
    }
    sum
}

aey4

a month ago

2.78ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    let mut factorial:u128 = 1;
    if n == 0 {return 1;}
    for number in (1..=n).rev(){
        factorial *= number as u128;
    }
    factorial
}

aey4

a month ago

4.06ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    let mut factorial:u128 = 1;
    if n == 0 {return 1;}
    for number in (1..=n).rev(){
        factorial *= number as u128;
    }
    factorial
}

Tarokc

a month ago

2.78ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    let mut fac: u128 = 0;
    if n == 0 || n == 1{
        return 1 as u128
    }
    else {
        fac = n as u128 * factorial(n-1);
    }
    fac as u128
}

viky

vikyw89

a month ago

2.84ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    // base case
    if n == 0 {
        return 1;
    }
    // recursive case
    return n as u128 * factorial(n - 1);
}

Casper Bottelet

Bottelet

a month ago

2.81ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    let mut current = u128::try_from(n).unwrap();
    let mut result: u128 = 1;
    if current == 0 {
        return 1;
    }
    while current > 0 {
        result *= current;
        current -= 1;
    }
 
    return result;
}

Caio César

caiocdcs

a month ago

3.00ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    (1..=(n as u128)).product()
}

RonaldoArayadev

a month ago

2.91ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    let mut res: u128 = 1;
    if n == 0 {return 1;}
    for i in 1..=n {
        res = res * (i as u128);
    }
    res
}

Sir Woody Hackswell

Hackswell

a month ago

2.88ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    let mut factorial: u128 = 1;
    for i in 2..=n {
        factorial *= i as u128;
    }
    factorial
}

Yamami

Yamami1221

a month ago

3.18ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    let mut result: u128 = 1;
    for i in 1..=n {
        result *= i as u128;
    }
    return result;
}

JeppeFoldberg

a month ago

2.80ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    (1..=n as u128)
        .fold(1, |acc, number| acc * number)
}

doroshtapgh

a month ago

2.82ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    if n == 0 || n == 1 {
        1
    } else {
        let mut sum = 1u128;
        
        for i in 1..=n as u128 {
            sum *= i;
        }
        sum
    }
}

vgpetrov

a month ago

3.93ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    if n <= 1 {
        1 as u128
    } else {
        factorial(n - 1) * (n as u128)
    }
}