Loading…

easyBasicsSometimes asked

Factorial of a Number

Basics · 6 min

Given a non-negative integer n, return n! = 1 · 2 · … · n. By definition 0! = 1.

In plain English

Multiply every integer from 1 to n. Factorials grow extremely fast, so the result needs a 64-bit type even for small n.

Examples

Example 1

Input: n = 5
Output: 120
Note: 1·2·3·4·5 = 120.

Example 2

Input: n = 0
Output: 1
Note: 0! is defined as 1.

Example 3

Input: n = 1
Output: 1
Note: 1! = 1.

Constraints

0 ≤ n ≤ 20 (beyond 20, n! overflows 64-bit)

Clarifying questions2First question: What's the maximum n?Explore questions

Q1.What's the maximum n?
Realistically 20 if returning long, since 21! overflows; beyond that you'd need BigInteger.
Q2.How should 0 be handled?
0! = 1 by definition — the seed handles it.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Loop from 2 to n multiplying into an accumulator that starts at 1. Use `long`; 21! already overflows 64 bits.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you seed an accumulator correctly and reason about the type's overflow boundary.

Where candidates slip

Mishandling 0! or overflowing an int accumulator.

How to stand out

Quote the exact limits (12! overflows int, 20! is the last that fits in long) and prefer iteration to avoid stack risk.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 1 · Optimal

Iterative product

TimeO(n)SpaceO(1)

This is the standard, expected solution — lead with it.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Multiply every integer from 1 (or 2) up to n into a running product.

2Hint 2Explore hint

Seed the product at 1 so n = 0 returns 1 automatically.

3Hint 3Explore hint

Watch the type: factorials overflow fast — long only reaches 20!.

A · Core idea

n! is the product 1·2·…·n, with 0! defined as 1. Multiply an accumulator (seeded at 1) by each integer up to n.

Why seed the accumulator at 1. 1 is the multiplicative identity, so multiplying by it changes nothing — and it doubles as the correct answer for n = 0 and n = 1, where the loop body never runs or runs once. Seeding a product at 1 (like seeding a sum at 0) makes the empty/base case fall out for free.

Why iteration over recursion here. Factorial is the textbook recursion example, but an iterative loop avoids call-stack overhead and the risk of a deep-recursion stack overflow. For an interview, iteration is the safer default; mention recursion as the elegant-but-costlier alternative.

The hard limit: overflow. Factorials explode — 13! already overflows 32-bit int, and 21! overflows 64-bit long. So even with long, the usable range is n ≤ 20. Stating that boundary shows you reason about ranges, not just write loops.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

n = 5

i = 2

1 × 2

Stateresult = 2

Final result120

C · Code with teaching comments

solution.javaJava

Iterative product — optimal

2 teaching notes

1
public long factorial(int n) {
2
    // Identity for multiplication; also the correct answer for n = 0 and n = 1.
3
    long result = 1;
4
    for (int i = 2; i <= n; i++) {
5
        // Fold each factor into the running product.
6
        result *= i;
7
    }
8
    return result;
9
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.9 lines

D · Why it works and complexityO(n) timeO(1) spaceOpen the invariant and proofExplore the proof

Calling out the overflow limit (20! fits in long, 21! doesn't) shows you think about ranges, not just logic.

ComplexityO(n) time, O(1) space — one multiplication per integer from 2 to n, so n−1 operations, and only one accumulator variable.

E · Edge cases and pitfalls5n = 0 — Loop runs zero times; the seed 1 is returned — correct, since 0! = 1.Explore edge cases

Edge cases handled

n = 0Loop runs zero times; the seed 1 is returned — correct, since 0! = 1.
n = 1Loop runs zero times (starts at 2); returns 1.
n = 21Overflows even long — the answer is outside the representable range.

Pitfalls

Returning 0 for n = 0 instead of 1.
Storing the product in int and silently overflowing past 12!.

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Editable code previewpublic long factorial(int n) { long result = 1; for (int i = 2; i <= n; i++) { result *= i; }Explore the playground

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Returning 0 for n = 0 instead of 1.
Storing the result in int and overflowing past 12!.

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Iterative accumulation

Code pattern to memorize

result = 1; for i in 2..n: result *= i

Rules to remember

1Init accumulator to 1.
2Loop 2..n multiplying in.
3Use long; 21! overflows.

Use this pattern when

Products over a range
Any accumulate-with-identity fold

Choose another pattern when

n large and exact result needed — switch to BigInteger

Interview takeaway

Seed a product with 1 so empty/zero cases fall out naturally.

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Transferable patternA core fresher pattern: Iterative accumulation. Master it on small inputs and it transfers to harder problems.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Factorial (recursion)
Coming soon
Same product expressed as n × (n−1)! with a base case of 1.
Power of a Number
Another accumulate-a-product pattern, optimised with fast exponentiation.

Same pattern

easyBasicsSometimes asked

Factorial of a Number

Basics · 6 min

Given a non-negative integer n, return n! = 1 · 2 · … · n. By definition 0! = 1.

In plain English

Multiply every integer from 1 to n. Factorials grow extremely fast, so the result needs a 64-bit type even for small n.

Examples

Example 1

Input: n = 5
Output: 120
Note: 1·2·3·4·5 = 120.

Example 2

Input: n = 0
Output: 1
Note: 0! is defined as 1.

Example 3

Input: n = 1
Output: 1
Note: 1! = 1.

Constraints

0 ≤ n ≤ 20 (beyond 20, n! overflows 64-bit)

Clarifying questions2First question: What's the maximum n?Explore questions

Q1.What's the maximum n?
Realistically 20 if returning long, since 21! overflows; beyond that you'd need BigInteger.
Q2.How should 0 be handled?
0! = 1 by definition — the seed handles it.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Loop from 2 to n multiplying into an accumulator that starts at 1. Use `long`; 21! already overflows 64 bits.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you seed an accumulator correctly and reason about the type's overflow boundary.

Where candidates slip

Mishandling 0! or overflowing an int accumulator.

How to stand out

Quote the exact limits (12! overflows int, 20! is the last that fits in long) and prefer iteration to avoid stack risk.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 1 · Optimal

Iterative product

TimeO(n)SpaceO(1)

This is the standard, expected solution — lead with it.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Multiply every integer from 1 (or 2) up to n into a running product.

2Hint 2Explore hint

Seed the product at 1 so n = 0 returns 1 automatically.

3Hint 3Explore hint

Watch the type: factorials overflow fast — long only reaches 20!.

A · Core idea

n! is the product 1·2·…·n, with 0! defined as 1. Multiply an accumulator (seeded at 1) by each integer up to n.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

n = 5

i = 2

1 × 2

Stateresult = 2

Final result120

C · Code with teaching comments

solution.javaJava

Iterative product — optimal

2 teaching notes

1
public long factorial(int n) {
2
    // Identity for multiplication; also the correct answer for n = 0 and n = 1.
3
    long result = 1;
4
    for (int i = 2; i <= n; i++) {
5
        // Fold each factor into the running product.
6
        result *= i;
7
    }
8
    return result;
9
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.9 lines

D · Why it works and complexityO(n) timeO(1) spaceOpen the invariant and proofExplore the proof

Calling out the overflow limit (20! fits in long, 21! doesn't) shows you think about ranges, not just logic.

ComplexityO(n) time, O(1) space — one multiplication per integer from 2 to n, so n−1 operations, and only one accumulator variable.

E · Edge cases and pitfalls5n = 0 — Loop runs zero times; the seed 1 is returned — correct, since 0! = 1.Explore edge cases

Edge cases handled

n = 0Loop runs zero times; the seed 1 is returned — correct, since 0! = 1.
n = 1Loop runs zero times (starts at 2); returns 1.
n = 21Overflows even long — the answer is outside the representable range.

Pitfalls

Returning 0 for n = 0 instead of 1.
Storing the product in int and silently overflowing past 12!.

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Editable code previewpublic long factorial(int n) { long result = 1; for (int i = 2; i <= n; i++) { result *= i; }Explore the playground

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Returning 0 for n = 0 instead of 1.
Storing the result in int and overflowing past 12!.

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Iterative accumulation

Code pattern to memorize

result = 1; for i in 2..n: result *= i

Rules to remember

1Init accumulator to 1.
2Loop 2..n multiplying in.
3Use long; 21! overflows.

Use this pattern when

Products over a range
Any accumulate-with-identity fold

Choose another pattern when

n large and exact result needed — switch to BigInteger

Interview takeaway

Seed a product with 1 so empty/zero cases fall out naturally.

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Transferable patternA core fresher pattern: Iterative accumulation. Master it on small inputs and it transfers to harder problems.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Factorial (recursion)
Coming soon
Same product expressed as n × (n−1)! with a base case of 1.
Power of a Number
Another accumulate-a-product pattern, optimised with fast exponentiation.

Same pattern