Factorial Using Recursion in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define the base case for the factorial function.

DSA Rust

fn factorial(n: u32) -> u32 {
    if n == [1] {
        1
    } else {
        n * factorial(n - 1)
    }
}

Drag options to blanks, or click blank then click option'

A0

B1

Cn

D2

Attempts:

3 left

💡 Hint

Common Mistakes

Using 1 instead of 0 as the base case.

Forgetting to return 1 in the base case.

The base case for factorial is when n is 0, factorial(0) = 1.

2fill in blank

medium

Complete the recursive call to calculate factorial of n-1.

DSA Rust

fn factorial(n: u32) -> u32 {
    if n == 0 {
        1
    } else {
        n * factorial([1])
    }
}

Drag options to blanks, or click blank then click option'

An - 1

Bn + 1

Cn

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using n + 1 which causes infinite recursion.

Using n which does not reduce the problem.

The recursive call should be factorial(n - 1) to reduce the problem size.

3fill in blank

hard

Fix the error in the function signature to correctly return the factorial result.

DSA Rust

fn factorial(n: u32) -> [1] {
    if n == 0 {
        1
    } else {
        n * factorial(n - 1)
    }
}

Drag options to blanks, or click blank then click option'

Abool

Bf64

Cu32

DString

Attempts:

3 left

💡 Hint

Common Mistakes

Using floating point types like f64 which are unnecessary here.

Using bool or String which are incorrect return types.

The factorial function returns an unsigned 32-bit integer (u32) because factorial results are whole numbers.

4fill in blank

hard

Fill both blanks to complete the main function that prints factorial of 5.

DSA Rust

fn main() {
    let result = factorial([1]);
    println!("Factorial is: {}", [2]);
}

Drag options to blanks, or click blank then click option'

A5

Bresult

C6

Dfactorial(5)

Attempts:

3 left

💡 Hint

Common Mistakes

Printing factorial(5) directly instead of the stored result.

Using wrong input like 6.

We call factorial with 5 and print the stored result variable.

5fill in blank

hard

Fill all three blanks to create a recursive factorial function with input and output.

DSA Rust

fn factorial([1]: [2]) -> [3] {
    if [1] == 0 {
        1
    } else {
        [1] * factorial([1] - 1)
    }
}

Drag options to blanks, or click blank then click option'

An

Bu32

Dnum

Attempts:

3 left

💡 Hint

Common Mistakes

Using inconsistent parameter names.

Using incorrect types like num or missing return type.

The function parameter is named 'n' of type u32, and the return type is u32.

Practice

1. What does the factorial of a number represent in mathematics?

easy

A. The number multiplied by 2

B. The sum of all positive integers up to that number

C. The number divided by 2

D. The product of all positive integers up to that number

Solution

1. Step 1: Understand factorial definition

   Factorial of a number n (written as n!) is the product of all positive integers from 1 to n.

2. Step 2: Compare options

   Only The product of all positive integers up to that number correctly describes factorial as a product, not sum or division.

3. Final Answer:

   The product of all positive integers up to that number -> Option D

4. Quick Check:

   Factorial = product of integers [OK]

Hint: Factorial multiplies numbers down to 1 [OK]

Common Mistakes:

• Confusing factorial with sum
• Thinking factorial divides the number
• Assuming factorial doubles the number

2. Which of the following is the correct Rust function signature for a recursive factorial function?

easy

A. fn factorial(n: String) -> u32

B. fn factorial(n: u32) -> String

C. fn factorial(n: u32) -> u32

D. fn factorial(n: i32) -> bool

Solution

1. Step 1: Identify input and output types

   Factorial takes a positive integer (u32) and returns a positive integer (u32).

2. Step 2: Match function signature

   fn factorial(n: u32) -> u32 matches input and output types correctly for factorial.

3. Final Answer:

   fn factorial(n: u32) -> u32 -> Option C

4. Quick Check:

   Input and output types match factorial [OK]

Hint: Factorial input/output are unsigned integers [OK]

Common Mistakes:

• Using String type for input or output
• Using signed integer when unsigned is better
• Returning bool instead of number

3. What is the output of this Rust code?

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

fn main() {
    println!("{}", factorial(4));
}

medium

A. 120

B. 24

C. 16

D. 10

Solution

1. Step 1: Trace recursive calls for factorial(4)

   factorial(4) = 4 * factorial(3) factorial(3) = 3 * factorial(2) factorial(2) = 2 * factorial(1) factorial(1) = 1 * factorial(0) factorial(0) = 1 (base case)

2. Step 2: Calculate values bottom-up

   factorial(1) = 1 * 1 = 1 factorial(2) = 2 * 1 = 2 factorial(3) = 3 * 2 = 6 factorial(4) = 4 * 6 = 24

3. Final Answer:

   24 -> Option B

4. Quick Check:

   4! = 24 [OK]

Hint: Recall 4! = 24 from multiplication table [OK]

Common Mistakes:

• Confusing factorial with sum
• Forgetting base case returns 1
• Multiplying incorrectly in recursion

4. Identify the error in this Rust factorial function:

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

medium

A. Base case should be n == 0, not n == 1

B. Function should return bool instead of u32

C. Recursive call should be factorial(n + 1)

D. Missing semicolon after return statement

Solution

1. Step 1: Check base case correctness

   Factorial base case is when n == 0, factorial(0) = 1. Using n == 1 misses factorial(0).

2. Step 2: Understand recursion impact

   If base case is n == 1, factorial(0) call will recurse infinitely causing stack overflow.

3. Final Answer:

   Base case should be n == 0, not n == 1 -> Option A

4. Quick Check:

   Base case at zero prevents infinite recursion [OK]

Hint: Base case for factorial is zero [OK]

Common Mistakes:

• Setting base case at 1 instead of 0
• Changing recursion direction incorrectly
• Ignoring missing semicolons (Rust warns)

5. How would you modify the recursive factorial function to handle large inputs without overflow in Rust?

hard

A. Use u128 type and add a check for input range to avoid overflow

B. Change return type to i32 and multiply normally

C. Remove recursion and use a loop with u8 type

D. Use f64 type and return floating-point factorial

Solution

1. Step 1: Understand overflow in factorial

   Factorial grows very fast; u32 overflows quickly. Using u128 allows larger values.

2. Step 2: Add input range check

   To prevent overflow, check input is within safe range before calculation.

3. Final Answer:

   Use u128 type and add a check for input range to avoid overflow -> Option A

4. Quick Check:

   Use larger integer type and validate input [OK]

Hint: Use bigger integer type and check input size [OK]

Common Mistakes:

• Using signed integers causing negative overflow
• Using floating-point loses precision
• Ignoring overflow checks