Factorial Generator

Factorial Generator - Problem

JavaScript Easy

Write a generator function that takes an integer n as an argument and returns a generator object which yields the factorial sequence.

The factorial sequence is defined by the relation n! = n * (n-1) * (n-2) * ... * 2 * 1. The factorial of 0 is defined as 1.

The generator should yield factorials starting from 0! up to n!.

Input & Output

Example 1 — Basic Case

$ Input: n = 4

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

💡 Note: Generate factorials from 0! to 4!: 0!=1, 1!=1, 2!=2, 3!=6, 4!=24

Example 2 — Minimum Case

$ Input: n = 0

› Output: [1]

💡 Note: Only 0! = 1 by definition

Example 3 — Small Sequence

$ Input: n = 2

› Output: [1, 1, 2]

💡 Note: Generate 0!=1, 1!=1, 2!=2×1=2

Constraints

0 ≤ n ≤ 10
All factorials will fit in 32-bit integer

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that each factorial can be built incrementally from the previous one using the relation n! = (n-1)! × n. Best approach is the optimized incremental calculation which eliminates redundant computations. Time: O(n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Optimized - Incremental Calculation	O(n)	O(1)	Build each factorial from the previous one using multiplication
Brute Force - Recalculate Each Factorial	O(n²)	O(1)	Calculate each factorial from scratch using a separate loop

Optimized - Incremental Calculation — Algorithm Steps

Step 1: Start with factorial = 1 (which is 0!)
Step 2: For each i from 1 to n, multiply factorial by i
Step 3: Yield the current factorial value

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with 0!

factorial = 1

Build 1!

factorial = factorial × 1 = 1

Build 2!

factorial = factorial × 2 = 2

Code -

solution.c — C

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

void solution(int n, int* result) {
    int factorial = 1;
    result[0] = factorial; // 0! = 1
    
    for (int i = 1; i <= n; i++) {
        factorial *= i;
        result[i] = factorial;
    }
}

int main() {
    int n;
    scanf("%d", &n);
    int* result = (int*)malloc((n + 1) * sizeof(int));
    solution(n, result);
    printf("[");
    for (int i = 0; i <= n; i++) {
        printf("%d", result[i]);
        if (i < n) printf(",");
    }
    printf("]\n");
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single loop through n values, each doing O(1) work

✓ Linear Growth

Space Complexity

O(1)

Only storing current factorial value, no extra arrays

✓ Linear Space

22.1K Views

Medium Frequency

~15 min Avg. Time

850 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

Optimized - Incremental Calculation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler