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

ikatlinsky

2 days 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 days 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

5 days 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

7 days 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

10 days 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

10 days 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

13 days 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

13 days 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

17 days 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

20 days 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

23 days ago

3.22ms

81.28kb

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

Anatma2

23 days 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

a month 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

a month 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)
}

wertion555

2 months ago

3.11ms

81.28kb

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

Hung Dinh

nhdinh

2 months ago

3.79ms

81.28kb

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

roboquaternion

2 months ago

3.44ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Note, factorials are often applied in reverse direction (5*4*..1), but it doesn't really matter algebraically. So this implementation counts up.
    match n {
        0 => 1,
        _ => (1..=n).map(|x| x as u128).product()
    }
}

roboquaternion

2 months ago

3.78ms

81.28kb

pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    if n == 0 {
        return 1;
    }
    // Note, factorials are often applied in reverse direction (5*4*..1), but it doesn't really matter algebraically. So this implementation counts up.
    (2..=n).map(|x| x as u128).product()
}

John Adams

netik

2 months ago

4.04ms

81.28kb

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

Jakub Wiśniewski

wisniewskij

2 months ago

3.84ms

81.28kb

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

Jason

Jason-fy-wang

2 months ago

4.46ms

81.28kb

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

mhd242006

2 months ago

3.13ms

81.28kb

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

Deaddy3

2 months ago

3.62ms

81.28kb

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

vijayabhaskar badireddi

ptcte

2 months ago

3.10ms

81.28kb

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

Aurimas Kuniutis

auriku

2 months ago

3.37ms

81.28kb

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

Jason

chenjie1219

2 months ago

4.82ms

81.28kb

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

Marcel Schiffel

mschiffel

3 months ago

3.19ms

81.28kb

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

javad05

3 months ago

3.12ms

81.28kb

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

javad05

3 months ago

2.95ms

81.28kb

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

syberianbull

3 months ago

3.59ms

81.28kb

//Working with while loop
/* pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    let mut i = n as u128;
    let mut temp: u128 = 1;
    while i > 0 {
        temp *= i;
        i -= 1;
    }
    temp
} */
//Working with for loop
/*  pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    //let mut i = n as u128;
    let mut fact: u128 = 1;
    for i in 2..= n as u128 {
        fact *= i;
    }
    fact
} */
//Working as recursive function
pub fn factorial(n: u32) -> u128 {
    // Implement your code here
    if n == 0 {
        1
    } else {
        n as u128 * factorial2 (n as u128 - 1)
    }
}
pub fn factorial2(n: u128) -> u128 {
    if n == 0 {
        1
    } else {
        n * factorial2(n - 1)
    }
}

syberianbull

3 months ago

5.05ms

81.28kb

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

endrin

3 months ago

6.53ms

81.28kb

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

VerweyFr

3 months ago

3.43ms

81.28kb

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

Yixian Du

duyixian1234

3 months ago

4.22ms

81.28kb

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

Dhananjay Pandit

djpandit007

3 months ago

3.48ms

81.28kb

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

Artem

tich31337

3 months ago

7.90ms

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
}

lugtester

3 months ago

4.09ms

81.28kb

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

panda wiz

pandamrx

3 months ago

3.22ms

81.28kb

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

hex-order

idan-KH

3 months ago

3.26ms

81.28kb

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

Anna Komarova

Vlasanya

3 months ago

3.08ms

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
}

Icarus

IcarusxB

3 months ago

3.23ms

81.28kb

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

no-yan

3 months ago

2.99ms

81.28kb

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

AnKarl

Zythophilus

3 months ago

3.72ms

81.28kb

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

hemulya

3 months ago

4.74ms

81.28kb

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

vojta stefan

vojtastefan

3 months ago

2.85ms

81.28kb

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

vojta stefan

vojtastefan

3 months ago

3.31ms

81.28kb

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

Ayushman Rathore

Spartan09

4 months ago

3.11ms

81.28kb

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

Lucas Deprit

lucasdeprit

4 months ago

3.17ms

81.28kb

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

Manuel Manjarres R.

manuelmj

4 months ago

3.49ms

81.28kb

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

Manuel Manjarres R.

manuelmj

4 months ago

29.48ms

81.28kb

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