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

Arpan Shingala

arpan-vs

5 days ago

2.72ms

81.28kb

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

Arpan Shingala

arpan-vs

5 days ago

3.04ms

81.28kb

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

GunGraveCpp

6 days ago

3.07ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    if n != 0 {
        return (1..=n).map(|x| x as u128).reduce(|mul, r| mul * r).unwrap();
    }
    1
}

amdfxlucas

6 days ago

2.81ms

81.28kb

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

manu3618

10 days ago

3.73ms

81.28kb

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

aghia98

11 days ago

2.95ms

81.28kb

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

Heino Mortensen

hmortensen83

12 days ago

2.90ms

81.28kb

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

Christophe Pronier

chrpron

19 days ago

3.21ms

81.28kb

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

Walter White

durgaprasad118

20 days ago

4.41ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    if n ==0 {
        return 1;
    }
    let mut p:u128 =1;
    let mut ans = n;
    while ans>0{
       p*=ans as u128;
       ans-=1; 
    }
    p
}

vasie

vasie1337

21 days ago

3.32ms

81.28kb

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

vasie

vasie1337

21 days ago

4.15ms

81.28kb

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

bzdula

21 days ago

2.81ms

81.28kb

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

Ranjith Thangavel

RanjithECE24

24 days ago

4.00ms

81.28kb

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

Wouter

WouterMartens

a month ago

2.93ms

81.28kb

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

whhc

a month ago

3.01ms

81.28kb

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

Andy Randrianirina

andyslash

a month ago

2.81ms

81.28kb

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

medzernik

a month ago

3.84ms

81.28kb

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

Baron Curtin

baroncurtin2

a month ago

3.10ms

81.28kb

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

Evrins Hu

evrins

a month ago

3.43ms

81.28kb

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

johndoe30bc

a month ago

2.82ms

81.28kb

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

xxxxsk

a month ago

3.21ms

81.28kb


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

orao-pao

a month ago

2.75ms

81.28kb

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

Evgenii Grigorenko

grevgeny

a month ago

2.73ms

81.28kb

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

Evgenii Grigorenko

grevgeny

a month ago

4.61ms

81.28kb

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

brucecox01

a month ago

2.67ms

81.28kb

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

Ashish Khare

ashishk1331

a month ago

3.43ms

81.28kb

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

pickbiest

a month ago

3.86ms

81.28kb

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

Krzysztof Atłasik

katlasik

2 months ago

2.70ms

81.28kb

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

Kr0wZ

2 months ago

5.05ms

81.28kb

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

Alexander Y

unixander

2 months ago

2.67ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    (1..=n as u128).reduce(|a, b | a * b).unwrap_or(1)
}

Philippe Massicotte

PMassicotte

2 months ago

2.93ms

81.28kb

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

Philippe Massicotte

PMassicotte

2 months ago

3.45ms

81.28kb

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

Harsh Ranjan

harshRn

2 months ago

3.35ms

81.28kb

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

jeroenvgestel

2 months ago

2.91ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    if n == 0 {
        return 1;
    }
    let mut total: u128 = 1;
    let mut cur = n as u128;
    
    while cur > 0 {
        total = total * cur;
        cur -= 1;
    }
    
    total
}

Luigi Terrone

LuigiTer

2 months ago

3.39ms

81.28kb

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

Enes

enesscevik

2 months ago

3.19ms

81.28kb

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

ikatlinsky

2 months ago

3.47ms

81.28kb

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

Aztra Corporation Inc.

AZTRA2022

2 months ago

3.02ms

81.28kb

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

mathias dusautoy

pourquoi

2 months ago

2.65ms

81.28kb

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

Enriko

rix71

2 months ago

3.83ms

81.28kb

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

LeonardoPinheiro23

2 months ago

3.34ms

81.28kb

const FACTORIALS: [u128; 35] = [
    1,                                       // 0!
    1,                                       // 1!
    2,                                       // 2!
    6,                                       // 3!
    24,                                      // 4!
    120,                                     // 5!
    720,                                     // 6!
    5040,                                    // 7!
    40320,                                   // 8!
    362880,                                  // 9!
    3628800,                                 // 10!
    39916800,                                // 11!
    479001600,                               // 12!
    6227020800,                              // 13!
    87178291200,                             // 14!
    1307674368000,                           // 15!
    20922789888000,                          // 16!
    355687428096000,                         // 17!
    6402373705728000,                        // 18!
    121645100408832000,                      // 19!
    2432902008176640000,                     // 20!
    51090942171709440000,                    // 21!
    1124000727777607680000,                  // 22!
    25852016738884976640000,                 // 23!
    620448401733239439360000,                // 24!
    15511210043330985984000000,              // 25!
    403291461126605635584000000,             // 26!
    10888869450418352160768000000,           // 27!
    304888344611713860501504000000,          // 28!
    8841761993739701954543616000000,         // 29!
    265252859812191058636308480000000,       // 30!
    8222838654177922817725562880000000,      // 31!
    263130836933693530167218012160000000,    // 32!
    8683317618811886495518194401280000000,   // 33!
    295232799039604140847618609643520000000, // 34!
];
pub fn factorial(n: u32) -> u128 {
    FACTORIALS[n as usize]
}

LeonardoPinheiro23

2 months ago

3.92ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    let n = n as u128;
    let mut product = 1u128;
    for factor in (1..=n).rev() {
        product *= factor;
    }
    product
}

annececiledunand

2 months ago

2.79ms

81.28kb

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

sjmellor

3 months ago

3.70ms

81.28kb

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

ggnne

3 months ago

2.84ms

81.28kb

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

Tommytto

3 months ago

2.86ms

81.28kb

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

Viktor Merkurev

fennr

3 months ago

3.22ms

81.28kb

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

Anatma2

3 months ago

3.97ms

81.28kb

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

MrGru

3 months ago

3.11ms

81.28kb

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

Liyqq

4 months ago

3.33ms

81.28kb

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