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

sander-b-postnl

4 hours ago

2.16ms

81.28kb

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

Bhardwaj08

5 hours ago

2.23ms

81.28kb

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

savasozturk

6 hours ago

2.29ms

81.28kb

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

Zava

zavakid

10 hours ago

2.07ms

85.89kb

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

Mikhail

mk-comm

14 hours ago

2.22ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    if n == 0 {
        1 // Base case: factorial of 0 is 1
    } else {
        n as u128 * factorial(n - 1) // Recursive case
    }
}

shmaxuti

15 hours ago

2.22ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    match n {
        0 => 1,
        1 => 1,
        2.. => {
            let mut result: u128 = 1;
            for num in 2..=n {
                result *= num as u128;
            }
            result
        }
    }
}

Carlos Arias

carlos-quantexai

19 hours ago

2.12ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // ... existing code ...
    if n == 0 {
        return 1;
    }
    let mut result: u128 = 1; // Initialize result to 1 for multiplication
    
    for i in 1..=n { // Start from 1 to avoid multiplying by 0
        result *= i as u128; // Cast i to u128
    }
    result
}

José Bernardo

jose-bernardo

20 hours ago

2.09ms

81.28kb

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

Maxence Potier

Mxn-ptr

21 hours ago

2.23ms

81.28kb

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

Daniel Yan

yansq

a day ago

2.22ms

81.28kb

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

funny_233

funny233-github

a day ago

2.38ms

81.28kb

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

Gear

macgeargear

a day ago

2.14ms

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
}

Gear

macgeargear

a day ago

2.13ms

81.28kb

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

Delta Regeer

digitalresistor

2 days ago

2.38ms

81.28kb

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

majesticalcreature

2 days ago

2.18ms

81.28kb

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

majesticalcreature

2 days ago

2.12ms

81.28kb

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

Damian Zaręba

KhazAkar

2 days ago

2.27ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    match n {
        0..=1 => 1,
        2.. => {
            let mut result: u128 = 1;
            for num in 2..=n {
                result *= num as u128;
            }
            result
        }
    }
}

Damian Zaręba

KhazAkar

2 days ago

2.05ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    match n {
        0 => 1,
        1 => 1,
        2.. => {
            let mut result: u128 = 1;
            for num in 2..=n {
                result *= num as u128;
            }
            result
        }
    }
}

今何求

jhq223

2 days ago

2.34ms

85.89kb

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

Will Barnett

xbarnett

2 days ago

2.20ms

81.28kb

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

Johnchoi913

3 days ago

2.10ms

81.28kb

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

Matei Stefanescu

matei

3 days ago

2.25ms

81.28kb

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

Ustin

3 days ago

2.12ms

81.28kb

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

Ojash Neopane

oneopane

3 days ago

2.13ms

81.28kb

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

Ojash Neopane

oneopane

3 days ago

2.04ms

81.28kb

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

Oleksandr Romanov

alexromanov

3 days ago

2.28ms

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
}

amassare

3 days ago

2.15ms

81.28kb

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

amassare

3 days ago

2.15ms

81.28kb

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

Stefano Cianciulli

CianciuStyles

3 days ago

2.09ms

81.28kb

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

Patrik Bjärterot

pbjarterot

3 days ago

2.24ms

81.28kb

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

Joel Vicente Filho

kyhou

4 days ago

2.08ms

81.28kb

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

Adi

Aditeya

4 days ago

2.20ms

81.28kb

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

Ayush Rawat

ayushrawat10

4 days ago

2.19ms

81.28kb

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

masteryachty

4 days ago

2.09ms

81.28kb

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

Igor Morozov

morigs

4 days ago

2.12ms

81.28kb

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

damascussteel21

4 days ago

2.15ms

81.28kb

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

John Truong

jtruong04

4 days ago

2.57ms

81.28kb

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

Edgar Christian

edgarcnp

5 days ago

2.27ms

81.28kb

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

Dimitris Lygkonis

xyres137

5 days ago

2.14ms

81.28kb

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

Dimitris Lygkonis

xyres137

5 days ago

2.02ms

81.28kb

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

Dimitris Lygkonis

xyres137

5 days ago

1.98ms

81.28kb

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

Dimitris Lygkonis

xyres137

5 days ago

2.13ms

81.28kb

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

Samuel

Sommos

5 days ago

2.12ms

81.28kb

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

Christian Franzl

wischi-chr

5 days ago

2.25ms

81.28kb

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

Tukan van der Borgh

tukantje

5 days ago

2.22ms

81.28kb

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

CarrotTarrot

5 days ago

2.06ms

81.28kb

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

CarrotTarrot

5 days ago

2.25ms

81.28kb

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

Danny Yoo

dyoo

5 days ago

2.03ms

81.28kb

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

Jason Green

jaswgreen

5 days ago

2.33ms

81.28kb

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

Nicolás Caracci

hilias

5 days ago

2.11ms

81.28kb

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