Fibonacci Number

Fibonacci Number - Problem

The Fibonacci numbers, commonly denoted F(n), form a sequence called the Fibonacci sequence, such that each number is the sum of the two preceding ones, starting from 0 and 1.

That is:

F(0) = 0
F(1) = 1
F(n) = F(n - 1) + F(n - 2), for n > 1

Given n, calculate F(n).

Input & Output

Example 1 — Small Number

$ Input: n = 2

› Output: 1

💡 Note: F(2) = F(1) + F(0) = 1 + 0 = 1

Example 2 — Medium Number

$ Input: n = 3

› Output: 2

💡 Note: F(3) = F(2) + F(1) = 1 + 1 = 2

Example 3 — Base Case

$ Input: n = 4

› Output: 3

💡 Note: F(4) = F(3) + F(2) = 2 + 1 = 3

Constraints

0 ≤ n ≤ 30

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8 🍎 Apple 6

The key insight is that each Fibonacci number is just the sum of the previous two numbers. The optimal approach uses space-optimized DP with two variables to track the last two values. Time: O(n), Space: O(1).

Common Approaches

✓ Bottom-Up DP (Tabulation)

⏱️ Time: O(n) Space: O(n)

Create an array to store Fibonacci values from 0 to n. Start with base cases F(0)=0 and F(1)=1, then iteratively calculate each subsequent value using previously computed values.

Memoization (Top-Down DP)

⏱️ Time: O(n) Space: O(n)

Use a cache (dictionary/map) to store previously calculated Fibonacci values. When F(n) is called, first check if the result is already cached. This transforms exponential time to linear time.

Recursive (Brute Force)

⏱️ Time: O(2ⁿ) Space: O(n)

Implement the Fibonacci formula directly: F(n) = F(n-1) + F(n-2). This creates a binary tree of recursive calls where the same values are computed multiple times.

Space-Optimized DP

⏱️ Time: O(n) Space: O(1)

Since each Fibonacci number only depends on the previous two, we don't need to store the entire sequence. Use two variables to track F(i-2) and F(i-1), then update them as we progress.

Bottom-Up DP (Tabulation) — Algorithm Steps

Create DP array of size n+1
Initialize F(0)=0 and F(1)=1
For i from 2 to n: dp[i] = dp[i-1] + dp[i-2]
Return dp[n]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with F(0)=0, F(1)=1

Fill Table

Each F(i) = F(i-1) + F(i-2)

Result

F(n) is our final answer

Code -

solution.c — C

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

int solution(int n) {
    if (n <= 1) {
        return n;
    }
    
    int* dp = (int*)malloc((n + 1) * sizeof(int));
    dp[0] = 0;
    dp[1] = 1;
    
    for (int i = 2; i <= n; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }
    
    int result = dp[n];
    free(dp);
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    int result = solution(n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single loop from 2 to n, each iteration does constant work

✓ Linear Growth

Space Complexity

O(n)

DP array stores n+1 Fibonacci values

⚡ Linearithmic Space

172.8K Views

Medium Frequency

~15 min Avg. Time

4.8K 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

Bottom-Up DP (Tabulation) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler