The factorial of a nonnegative integer n, written n!, is the product of every integer from 1 through n. By definition, 0! = 1.
Remember
n! = 1 × 2 × 3 × … × n (for n ≥ 1)
0! = 1
Example: 5!
5 × 4 × 3 × 2 × 1 = 120
Recurrence:
n! = n × (n − 1)!
with base case 0! = 1! = 1
n
Expansion
n!
0
(empty product)
1
1
1
1
5
5 × 4 × 3 × 2 × 1
120
6
6 × 5!
720
Approach
How to Find Factorial in C#
Four clear steps — then pick a loop or recursion.
Reject negative inputs (factorial is not defined for them).
Treat 0 and 1 as the base case: return 1.
Multiply all integers from 2 through n (loop), or use n × (n − 1)! (recursion).
Remember long is exact only through 20!.
Method
Idea
Time
Best for
Iterative loop
Multiply 2..n into a running product
O(n)
Production, large n, interviews
Recursion
n × Factorial(n − 1) with base ≤ 1
O(n)
Showing the recurrence clearly
Pseudocode
Pseudocode
function Factorial(n):
if n < 0:
error "not defined"
if n <= 1:
return 1
result = 1
for i from 2 to n:
result = result * i
return result
Reference
Cheat Sheet
Keep these facts handy while writing the program.
Topic
Detail
Definition
Product of 1..n; 0! = 1
Base cases
0 and 1 both return 1
Recurrence
n! = n × (n − 1)!
long limit
Exact through 20! only
Negatives
Reject — undefined for integers
Classic check
5! → 120
Try it
Live Preview
Enter a nonnegative integer (0–20) to see the product chain and n!.
Whole numbers from 0 to 20 (exact in this preview). Tap a chip or type a value.
Result
n = 5
Chain: 1 × 2 × 3 × 4 × 5
5! = 120
Trace
Worked Walkthrough — n = 5
Start at 1 and multiply each next integer until you reach 5.
Calculation
result = 1
i = 2 → result = 1 × 2 = 2
i = 3 → result = 2 × 3 = 6
i = 4 → result = 6 × 4 = 24
i = 5 → result = 24 × 5 = 120
Stop (i reached n)
5! = 120
Recursive view:
5! = 5 × 4!
4! = 4 × 3!
3! = 3 × 2!
2! = 2 × 1!
1! = 1
→ 120
Code
C# Programs
Start with the iterative loop for interviews and real code. Use recursion when you want to show the recurrence clearly.
Example 1 — Iterative Loop
Multiply integers from 2 to n into a running product. No recursion-depth risk.
C#
using System;
class Program
{
static long Factorial(int n)
{
if (n < 0)
{
throw new ArgumentException("Factorial is not defined for negatives.");
}
long result = 1;
for (int i = 2; i <= n; i++)
{
result *= i;
}
return result;
}
static void Main()
{
int number = 5;
Console.WriteLine(number + "! = " + Factorial(number));
}
}
Output
5! = 120
How It Works
Reject n < 0 — integer factorial is undefined there.
Start with result = 1 (covers both 0! and 1!).
Loop i from 2 to n and multiply into result.
For n = 5: 1 → 2 → 6 → 24 → 120.
Extra space is O(1) — prefer this style in real code.
Example 2 — Recursion
Direct translation of n! = n × (n − 1)! with base cases 0 and 1.
C#
using System;
class Program
{
static long Factorial(int n)
{
if (n < 0)
{
throw new ArgumentException("Factorial is not defined for negatives.");
}
if (n <= 1)
{
return 1;
}
return n * Factorial(n - 1);
}
static void Main()
{
Console.WriteLine(Factorial(5)); // 120
Console.WriteLine(Factorial(0)); // 1
}
}
Output
120
1
How It Works
Validate n >= 0 first.
Base case: if n <= 1, return 1 (stops the recursion).
Otherwise return n * Factorial(n - 1).
For 5: calls unwind as 5×4×3×2×1 = 120.
Uses O(n) stack frames — fine for interviews; use a loop for large n.
Edge Cases & Pitfalls
Check these before calling the solution done.
0! / 1!
Both equal 1
The loop body never runs; recursion hits the base case immediately.
Negatives
Reject early
Do not silently return a wrong product — validate n >= 0.
Overflow
long maxes at 20!
Use BigInteger when n > 20.
Recursion
Stack depth
Deep recursion can throw StackOverflowException — prefer a loop.
Analysis
Time and Space Complexity
Program
Time
Extra space
Iterative loop
O(n)
O(1)
Recursion
O(n)
O(n) call stack
Both need about n multiplications. Space differs: the loop keeps one product; recursion keeps one frame per level.
