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

kylenoteboom

4 hours ago

2.75ms

81.28kb

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

martin-unit

12 hours ago

2.70ms

81.28kb

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

Esteban Soba

XtebanUy

20 hours ago

2.72ms

81.28kb

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

Jim Lawton

jimlawton

20 hours ago

3.91ms

81.28kb

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

Markus Bergkvist

mbergkvist

a day ago

2.86ms

81.28kb

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

Ando “Thor” Nando

DivineGod

2 days ago

2.76ms

81.28kb

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

mehdihmr

2 days ago

3.45ms

81.28kb

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

Andreas

StimhackSoftware

2 days ago

2.63ms

81.28kb

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

Algorab

2 days ago

3.00ms

81.28kb

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

Stefan Roas

sroas

2 days ago

3.13ms

81.28kb

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

xiuchiliudu

3 days ago

3.71ms

81.28kb

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

yoakemae

3 days ago

2.81ms

81.28kb

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

qiyuan711

3 days ago

3.49ms

81.28kb

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

Nt2311

nt2311-vn

3 days ago

4.99ms

81.28kb

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

tinthid

4 days ago

8.20ms

81.28kb

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

devarajang

4 days ago

3.19ms

81.28kb

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

Max

maxemontio

4 days ago

3.28ms

81.28kb

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

miku

BaroqueEngine

4 days ago

3.59ms

81.28kb

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

jon-a-miller

4 days ago

3.02ms

81.28kb

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

Philip Mercer

DV-13

4 days ago

3.11ms

81.28kb

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

nichideropa

4 days ago

3.00ms

81.28kb

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

Elizabeth Doughty

Thymelizabeth

5 days ago

2.86ms

81.28kb

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

Elizabeth Doughty

Thymelizabeth

5 days ago

2.89ms

81.28kb

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

Elizabeth Doughty

Thymelizabeth

5 days ago

3.19ms

81.28kb

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

pabiadzinski

5 days ago

2.76ms

81.28kb

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

Lauri Sarap

LauriSarap

5 days ago

2.80ms

81.28kb

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

Masayuki Sunahara

tamanishi

6 days ago

3.67ms

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
}

s.konishi

konishu

6 days ago

2.81ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    if n == 0 {
        return 1;
    }
    let mut ans: u128 = 1;
    for idx in 1..=n { // 型指定は不要
        ans *= idx as u128; // 必要に応じて型キャスト
        println!("{}",ans)
    }
    ans
}

Babuuu

aynugek

6 days ago

3.24ms

81.28kb

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

Jan

jeypiti

6 days ago

3.21ms

81.28kb

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

0xsmarter

6 days ago

2.96ms

81.28kb

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

Võ Thanh Bình

pynhpo

7 days ago

3.56ms

85.89kb

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

tsuchiya-d

tsucchinoko

7 days ago

3.38ms

81.28kb

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

Ankeet Parikh

ankeetparikh

7 days ago

4.04ms

81.28kb

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

maxvi

8 days ago

2.90ms

81.28kb

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

Denis SOURON

Brack0

9 days ago

2.83ms

81.28kb

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

Rocky.C

cloki0610

9 days ago

3.61ms

81.28kb

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

Sabin Howard

whitwulf

9 days ago

2.84ms

81.28kb

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

Nakagawa

nknknknkn2

10 days ago

2.89ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    return match n {
        0 => 1,
        1 => 1,
        2 => 2,
        _ => {
            let mut result: u128 = 1;
            let mut i: u128 = 2;
            let target: u128 = n.into();
            
            loop {
                if i > target {
                    break;
                }
                result = result * i;
                i += 1;
            }
            
            return result;
        }
    }
}

Lucas Heck

lucas-heck

10 days ago

3.32ms

81.28kb

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

Lucas Heck

lucas-heck

10 days ago

4.51ms

81.28kb

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

Lucas Heck

lucas-heck

10 days ago

6.72ms

81.28kb

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

Joe Schneider

josschne

10 days ago

2.95ms

81.28kb

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

Rolando1994

10 days ago

3.89ms

81.28kb

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

Anthony Cabrera-Lara

anthonycabreralara

10 days ago

2.96ms

81.28kb

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

Anthony Cabrera-Lara

anthonycabreralara

10 days ago

2.91ms

81.28kb

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

sergepin

11 days ago

2.96ms

81.28kb

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

Satoshi Watanabe

sassy

11 days ago

2.81ms

81.28kb

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

Bryce Verdier

btv

11 days ago

3.30ms

81.28kb

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

Anak Mirasing

igroomgrim

11 days ago

2.79ms

81.28kb

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