Factorial Generator - Practice Coding Problems

Factorial Generator - Problem

JavaScript Easy

Create a generator function that produces the factorial sequence! 🔢

Given an integer n, your generator should yield factorials starting from 0! up to n!. The factorial of a number k is defined as:

0! = 1 (by definition)
k! = k × (k-1) × (k-2) × ... × 2 × 1 for k > 0

Example: For n = 4, your generator should yield: 1, 1, 2, 6, 24 representing 0!, 1!, 2!, 3!, 4!

This problem tests your understanding of generator functions and iterative computation - perfect for building efficient, memory-friendly solutions!

Input & Output

example_1.py — Basic Case

$ Input: n = 4

› Output: [1, 1, 2, 6, 24]

💡 Note: Generator yields 0!=1, 1!=1, 2!=2, 3!=6, 4!=24 in sequence

example_2.py — Edge Case Zero

$ Input: n = 0

› Output: [1]

💡 Note: Only yields 0! = 1 by mathematical definition

example_3.py — Small Sequence

$ Input: n = 2

› Output: [1, 1, 2]

💡 Note: Yields factorials: 0!=1, 1!=1, 2!=2×1=2

Constraints

0 ≤ n ≤ 18
Generator must yield exactly n+1 values
Important: 0! = 1 by mathematical convention
Results may become very large (18! = 6.4 × 10¹⁵)

Visualization

Tap to expand

Understanding the Visualization

Foundation

Start with factorial = 1 (representing 0!)

Build Up

For each new level i, multiply current height by i

Yield Result

Report the new tower height (factorial value)

Continue

Repeat until we reach level n

Key Takeaway

🎯 Key Insight: Rather than recalculating each factorial from scratch (O(n²)), we can build each factorial from the previous one using the relationship n! = (n-1)! × n, achieving optimal O(n) time complexity.

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal solution uses a running product approach with O(n) time complexity. Instead of recalculating each factorial from scratch, we maintain a running factorial value and multiply it by the next number in sequence. This leverages the mathematical relationship n! = (n-1)! × n to build each result efficiently from the previous one.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Recalculate Each Factorial)	O(n²)	O(1)	Calculate each factorial from scratch using nested loops
Optimized Generator (Running Product)	O(n)	O(1)	Build each factorial using the previous result in a single pass

Brute Force (Recalculate Each Factorial) — Algorithm Steps

Create a generator function that takes parameter n
For each i from 0 to n:
Initialize factorial = 1
Multiply factorial by each number from 1 to i
Yield the calculated factorial

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate 0!

Start with 1 (base case)

Calculate 1!

Multiply: 1 = 1

Calculate 2!

Multiply: 1 × 2 = 2

Calculate 3!

Multiply: 1 × 2 × 3 = 6

Calculate 4!

Multiply: 1 × 2 × 3 × 4 = 24

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int current;
    int n;
} FactorialGenerator;

FactorialGenerator* createGenerator(int n) {
    FactorialGenerator* gen = malloc(sizeof(FactorialGenerator));
    gen->current = 0;
    gen->n = n;
    return gen;
}

int hasNext(FactorialGenerator* gen) {
    return gen->current <= gen->n;
}

long long next(FactorialGenerator* gen) {
    long long factorial = 1;
    for (int j = 1; j <= gen->current; j++) {
        factorial *= j;
    }
    gen->current++;
    return factorial;
}

int main() {
    FactorialGenerator* gen = createGenerator(5);
    while (hasNext(gen)) {
        printf("%lld ", next(gen));
    }
    free(gen);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n factorials, we perform up to n multiplications, resulting in n² total operations

⚠ Quadratic Growth

Space Complexity

O(1)

Only uses a constant amount of extra space for the factorial variable

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Recalculate Each Factorial) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler