Find First n Fibonacci Numbers

Given a number n, return an array containing the first n Fibonacci numbers.

• The first two Fibonacci numbers are 0 and 1.
• Each subsequent Fibonacci number is obtained by adding the previous two numbers.

Examples : 

Input: n = 3
Output: [0, 1, 1]
Explanation: The first 3 Fibonacci numbers are 0, 1, 1.

Input: n = 5
Output: [0, 1, 1, 2, 3]
Explanation: The first 5 Fibonacci numbers are 0, 1, 1, 2, 3.

[Naive Approach] Recursion - O(2^n) Time and O(n) Auxiliary Space

The idea is to use recursion to calculate each Fibonacci number independently.

The Fibonacci sequence follows:

• F(0) = 0
• F(1) = 1
• F(i) = F(i - 1) + F(i - 2) for i >= 2

For each index from 0 to n - 1, recursively calculate the corresponding Fibonacci number and add it to the result array.

#include <iostream>
#include <vector>
using namespace std;

int findFibonacci(int n) {
  
   // base case n = 0  n = 1
   if (n == 0) {
      return 0;
   } else if (n == 1) {
      return 1;
   } else {
      return findFibonacci(n - 2) + findFibonacci(n - 1);
   }
}

vector<int> fibonacciNumbers(int n) {
   vector<int> ans;
   for (int i = 0; i < n; i++) {
      ans.push_back(findFibonacci(i));
   }
   return ans;
}

int main() {
   int n = 7;
   vector<int> res = fibonacciNumbers(n);
   for (int i = 0; i < res.size(); i++) {
      cout << res[i] << " ";
   }
   return 0;
}

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

int findFibonacci(int n) {
    
   // base case n = 0 , n = 1
   if (n == 0) {
      return 0;
   } else if (n == 1) {
      return 1;
   } else {
      return findFibonacci(n - 2) + findFibonacci(n - 1);
   }
}

int* fibonacciNumbers(int n) {
   int* ans = (int*)malloc(n * sizeof(int));
   for (int i = 0; i < n; i++) {
      ans[i] = findFibonacci(i);
   }
   return ans;
}

int main() {
   int n = 7;
   int* res = fibonacciNumbers(n);
   for (int i = 0; i < n; i++) {
      printf("%d ", res[i]);
   }
   free(res);
   return 0;
}

import java.util.ArrayList;

class GFG {
   static int findFibonacci(int n) {
     
      // base case n = 0 , n = 1
      if (n == 0) {
         return 0;
      } else if (n == 1) {
         return 1;
      } else {
         return findFibonacci(n - 2) + findFibonacci(n - 1);
      }
   }

   static ArrayList<Integer> fibonacciNumbers(int n) {
      ArrayList<Integer> ans = new ArrayList<>();
      for (int i = 0; i < n; i++) {
         ans.add(findFibonacci(i));
      }
      return ans;
   }

   public static void main(String[] args) {
      int n = 7;
      ArrayList<Integer> res = fibonacciNumbers(n);
      for (int i = 0; i < res.size(); i++) {
         System.out.print(res.get(i) + " ");
      }
   }
}

def findFibonacci(n):
  
    #base case n = 0 , n = 1
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return findFibonacci(n-2) + findFibonacci(n-1)


def fibonacciNumbers(n):
    ans = []
    for i in range(n):
        ans.append(findFibonacci(i))
    return ans


if __name__ == '__main__':
    n = 7
    res = fibonacciNumbers(n)
    for num in res:
        print(num, end=' ')

using System;
using System.Collections.Generic;

class GFG {
    static int findFibonacci(int n) {
        
        // Base cases
        if (n == 0) {
            return 0;
        } else if (n == 1) {
            return 1;
        } else {
            return findFibonacci(n - 2) + findFibonacci(n - 1);
        }
    }

    static List<int> fibonacciNumbers(int n) {
        List<int> ans = new List<int>();

        for (int i = 0; i < n; i++) {
            ans.Add(findFibonacci(i));
        }

        return ans;
    }

    static void Main() {
        int n = 7;

        List<int> res = fibonacciNumbers(n);

        foreach (int num in res) {
            Console.Write(num + " ");
        }
    }
}

function findFibonacci(n) {

    //base case n = 0 , n = 1
    if (n === 0) {
        return 0;
    } else if (n === 1) {
        return 1;
    } else {
        return findFibonacci(n - 2) + findFibonacci(n - 1);
    }
}

function fibonacciNumbers(n) {
    let ans = [];
    for (let i = 0; i < n; i++) {
        ans.push(findFibonacci(i));
    }
    return ans;
}

// Driver Code
let n = 7;
let res = fibonacciNumbers(n);
console.log(res.join(' '));

0 1 1 2 3 5 8 

[Better Approach] Recursion with Memoization - O(n) Time and O(n) Auxiliary Space

The idea is to store each calculated Fibonacci number in a dp array so that the same value is not calculated again.

• Use 0 and 1 as the base cases.
• Before calculating a Fibonacci number, check whether it is already stored in dp.
• If it is stored, use the existing value.
• Otherwise, calculate it using fib(i - 1) + fib(i - 2) and store the result in dp.
• Calculate the Fibonacci numbers from 0 to n - 1 and store them in the result array.

Since each Fibonacci number is calculated only once, the repeated calculations of the recursive approach are avoided.

Consider: n = 5

Initially: dp = [-1, -1, -1, -1, -1] res = []

• fib(0) = 0 -> res = [0]
• fib(1) = 1 -> res = [0, 1]
• fib(2) = fib(1) + fib(0) = 1 -> store dp[2] = 1
• fib(3) = fib(2) + fib(1) = 2 -> reuse dp[2], store dp[3] = 2
• fib(4) = fib(3) + fib(2) = 3 -> reuse stored values, store dp[4] = 3

Finally: dp = [-1, -1, 1, 2, 3], res = [0, 1, 1, 2, 3]

Thus, the first 5 Fibonacci numbers are 0 1 1 2 3.

#include <iostream>
#include <vector>
using namespace std;

int fib(int n, vector<int>& dp) {
    
    // Base cases
    if (n <= 1)
        return n;
    
    // Return already calculated value
    if (dp[n] != -1)
        return dp[n];
    
    // Calculate and store the Fibonacci number
    return dp[n] = fib(n - 1, dp) + fib(n - 2, dp);
}

vector<int> fibonacciNumbers(int n) {
    vector<int> dp(n, -1);
    vector<int> res;

    // Calculate each Fibonacci number
    for (int i = 0; i < n; i++) {
        res.push_back(fib(i, dp));
    }

    return res;
}

int main() {
    int n = 7;

    vector<int> res = fibonacciNumbers(n);

    for (int x : res)
        cout << x << " ";

    return 0;
}

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

int fib(int n, int* dp) {
    
    // Base cases
    if (n <= 1)
        return n;
    
    // Return already calculated value
    if (dp[n] != -1)
        return dp[n];
    
    // Calculate and store the Fibonacci number
    dp[n] = fib(n - 1, dp) + fib(n - 2, dp);
    return dp[n];
}

int* fibonacciNumbers(int n) {
    int* dp = (int*)malloc(n * sizeof(int));
    int* res = (int*)malloc(n * sizeof(int));

    for (int i = 0; i < n; i++)
        dp[i] = -1;

    // Calculate each Fibonacci number
    for (int i = 0; i < n; i++) {
        res[i] = fib(i, dp);
    }

    free(dp);
    return res;
}

int main() {
    int n = 7;

    int* res = fibonacciNumbers(n);

    for (int i = 0; i < n; i++)
        printf("%d ", res[i]);

    free(res);

    return 0;
}

import java.util.ArrayList;
import java.util.Collections;

class GFG {

    static int fib(int n, ArrayList<Integer> dp) {
        
        // Base cases
        if (n <= 1)
            return n;
        
        // Return already calculated value
        if (dp.get(n) != -1)
            return dp.get(n);
        
        // Calculate and store the Fibonacci number
        dp.set(n, fib(n - 1, dp) + fib(n - 2, dp));
        return dp.get(n);
    }

    static ArrayList<Integer> fibonacciNumbers(int n) {
        ArrayList<Integer> dp = new ArrayList<>(Collections.nCopies(n, -1));
        ArrayList<Integer> res = new ArrayList<>();

        // Calculate each Fibonacci number
        for (int i = 0; i < n; i++) {
            res.add(fib(i, dp));
        }

        return res;
    }

    public static void main(String[] args) {
        int n = 7;

        ArrayList<Integer> res = fibonacciNumbers(n);

        for (int x : res)
            System.out.print(x + " ");
    }
}

def fib(n, dp):
    
    # Base cases
    if n <= 1:
        return n
    
    # Return already calculated value
    if dp[n] != -1:
        return dp[n]
    
    # Calculate and store the Fibonacci number
    dp[n] = fib(n - 1, dp) + fib(n - 2, dp)
    return dp[n]


def fibonacciNumbers(n):
    dp = [-1] * n
    res = []

    # Calculate each Fibonacci number
    for i in range(n):
        res.append(fib(i, dp))

    return res


if __name__ == "__main__":
    n = 7

    res = fibonacciNumbers(n)

    for x in res:
        print(x, end=" ")

using System;
using System.Collections.Generic;

class GFG {

    static int fib(int n, List<int> dp) {
        
        // Base cases
        if (n <= 1)
            return n;
        
        // Return already calculated value
        if (dp[n] != -1)
            return dp[n];
        
        // Calculate and store the Fibonacci number
        dp[n] = fib(n - 1, dp) + fib(n - 2, dp);
        return dp[n];
    }

    static List<int> fibonacciNumbers(int n) {
        List<int> dp = new List<int>();
        List<int> res = new List<int>();

        for (int i = 0; i < n; i++)
            dp.Add(-1);

        // Calculate each Fibonacci number
        for (int i = 0; i < n; i++) {
            res.Add(fib(i, dp));
        }

        return res;
    }

    static void Main() {
        int n = 7;

        List<int> res = fibonacciNumbers(n);

        foreach (int x in res)
            Console.Write(x + " ");
    }
}

function fib(n, dp) {
    
    // Base cases
    if (n <= 1)
        return n;
    
    // Return already calculated value
    if (dp[n] !== -1)
        return dp[n];
    
    // Calculate and store the Fibonacci number
    dp[n] = fib(n - 1, dp) + fib(n - 2, dp);
    return dp[n];
}

function fibonacciNumbers(n) {
    let dp = new Array(n).fill(-1);
    let res = [];

    // Calculate each Fibonacci number
    for (let i = 0; i < n; i++) {
        res.push(fib(i, dp));
    }

    return res;
}

// Driver code
let n = 7;

let res = fibonacciNumbers(n);

for (let x of res)
    process.stdout.write(x + " ");

0 1 1 2 3 5 8 

[Expected Approach] Tabulation - O(n) Time and O(n) Auxiliary Space

The idea is to build the Fibonacci sequence from the beginning and store each value in a dp array.

• Initialize dp[0] = 0 and dp[1] = 1.
• For every index from 2 to n - 1, calculate the current Fibonacci number using:
• dp[i] = dp[i - 1] + dp[i - 2]
• After filling the dp array, it contains the first n Fibonacci numbers.
• Return the dp array as the result.

Consider: n = 5

Initially: dp = [0, 0, 0, 0, 0]

Set the first two Fibonacci numbers:

• dp[0] = 0
• dp[1] = 1
• dp = [0, 1, 0, 0, 0]

Now calculate the remaining values:

• i = 2 -> dp[2] = dp[1] + dp[0] = 1 + 0 = 1
• i = 3 -> dp[3] = dp[2] + dp[1] = 1 + 1 = 2
• i = 4 -> dp[4] = dp[3] + dp[2] = 2 + 1 = 3

After filling the array: dp = [0, 1, 1, 2, 3]

Therefore, the first 5 Fibonacci numbers are 0 1 1 2 3.

#include <iostream>
#include <vector>
using namespace std;

vector<int> fibonacciNumbers(int n) {
    vector<int> dp(n);

    if (n >= 1)
        dp[0] = 0;

    if (n >= 2)
        dp[1] = 1;

    // Calculate remaining Fibonacci numbers
    for (int i = 2; i < n; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }

    return dp;
}

int main() {
    int n = 7;

    vector<int> res = fibonacciNumbers(n);

    for (int x : res)
        cout << x << " ";

    return 0;
}

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

int* fibonacciNumbers(int n) {
    int* dp = (int*)calloc(n, sizeof(int));

    if (n >= 1)
        dp[0] = 0;

    if (n >= 2)
        dp[1] = 1;

    // Calculate remaining Fibonacci numbers
    for (int i = 2; i < n; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }

    return dp;
}

int main() {
    int n = 7;

    int* res = fibonacciNumbers(n);

    for (int i = 0; i < n; i++)
        printf("%d ", res[i]);

    free(res);

    return 0;
}

import java.util.ArrayList;
import java.util.Collections;

class GFG {

    static ArrayList<Integer> fibonacciNumbers(int n) {
        ArrayList<Integer> dp = new ArrayList<>(Collections.nCopies(n, 0));

        if (n >= 1)
            dp.set(0, 0);

        if (n >= 2)
            dp.set(1, 1);

        // Calculate remaining Fibonacci numbers
        for (int i = 2; i < n; i++) {
            dp.set(i, dp.get(i - 1) + dp.get(i - 2));
        }

        return dp;
    }

    public static void main(String[] args) {
        int n = 7;

        ArrayList<Integer> res = fibonacciNumbers(n);

        for (int x : res)
            System.out.print(x + " ");
    }
}

def fibonacciNumbers(n):
    dp = [0] * n

    if n >= 1:
        dp[0] = 0

    if n >= 2:
        dp[1] = 1

    # Calculate remaining Fibonacci numbers
    for i in range(2, n):
        dp[i] = dp[i - 1] + dp[i - 2]

    return dp


if __name__ == "__main__":
    n = 7

    res = fibonacciNumbers(n)

    for x in res:
        print(x, end=" ")

using System;
using System.Collections.Generic;

class GFG {

    static List<int> fibonacciNumbers(int n) {
        List<int> dp = new List<int>();

        for (int i = 0; i < n; i++)
            dp.Add(0);

        if (n >= 1)
            dp[0] = 0;

        if (n >= 2)
            dp[1] = 1;

        // Calculate remaining Fibonacci numbers
        for (int i = 2; i < n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }

        return dp;
    }

    static void Main() {
        int n = 7;

        List<int> res = fibonacciNumbers(n);

        foreach (int x in res)
            Console.Write(x + " ");
    }
}

function fibonacciNumbers(n) {
    let dp = new Array(n).fill(0);

    if (n >= 1)
        dp[0] = 0;

    if (n >= 2)
        dp[1] = 1;

    // Calculate remaining Fibonacci numbers
    for (let i = 2; i < n; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }

    return dp;
}

// Driver code
    let n = 7;

    let res = fibonacciNumbers(n);

    for (let x of res)
        process.stdout.write(x + " ");

0 1 1 2 3 5 8