Length of Longest Fibonacci Subsequence - Practice Coding Problems

Length of Longest Fibonacci Subsequence - Problem

Imagine you're a mathematician studying Fibonacci-like sequences within arrays of numbers. A sequence is considered Fibonacci-like if it has at least 3 elements and each element (starting from the third) equals the sum of the two preceding elements.

Your mission: Given a strictly increasing array of positive integers, find the length of the longest Fibonacci-like subsequence. If no such subsequence exists, return 0.

Key Rules:

A Fibonacci-like sequence needs at least 3 elements
For any valid sequence [a, b, c, d, ...]: a + b = c, b + c = d, etc.
You can skip elements in the array (subsequence property)
Order must be preserved

Example: In array [1, 2, 3, 4, 5, 8], the subsequence [1, 2, 3, 5, 8] is Fibonacci-like because 1+2=3, 2+3=5, 3+5=8. Its length is 5.

Input & Output

example_1.py — Basic Fibonacci Sequence

$ Input: [1,2,3,4,5,8]

› Output: 5

💡 Note: The longest Fibonacci-like subsequence is [1,2,3,5,8] with length 5. We have 1+2=3, 2+3=5, 3+5=8.

example_2.py — Multiple Sequences

$ Input: [1,3,7,11,12,14,18]

› Output: 3

💡 Note: The longest Fibonacci-like subsequence has length 3: [1,11,12] because 1+11=12. Another valid sequence is [3,11,14] with 3+11=14.

example_3.py — No Valid Sequence

$ Input: [1,2,4,8,16]

› Output: 0

💡 Note: No Fibonacci-like subsequence exists. Each element is double the previous (geometric sequence), but not sum-based (Fibonacci-like).

Constraints

3 ≤ arr.length ≤ 1000
1 ≤ arr[i] < arr[i + 1] ≤ 10⁹
Array is strictly increasing
All elements are positive integers

Visualization

Tap to expand

Understanding the Visualization

Catalog Notes

Create an index of all available note frequencies for quick lookup

Test Harmonies

For each pair of notes, check if their harmonic sum exists in our catalog

Extend Progressions

When a harmonic sum is found, extend the progression and track its length

Find Longest

Remember the longest harmonic progression discovered

Key Takeaway

🎯 Key Insight: Just like musical harmonies, each Fibonacci-like sequence is uniquely identified by its last two 'notes' - this allows us to efficiently track and extend sequences using dynamic programming!

Asked in

G Google 45 f Facebook 38 a Amazon 32 ⊞ Microsoft 28

The optimal approach uses dynamic programming with hash maps to achieve O(n²) time complexity. Key insight: every Fibonacci-like sequence is uniquely determined by its last two elements, so we can track sequence lengths using pairs as keys in our DP table.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n²)	O(n²)	Use DP with hash map to track sequence lengths ending at each pair

Dynamic Programming (Optimal) — Algorithm Steps

Create a hash map for quick element lookup and DP table for sequence lengths
For each element arr[k], check all possible pairs (arr[i], arr[j]) where i < j < k
If arr[i] + arr[j] == arr[k], extend the sequence: dp[(arr[j], arr[k])] = dp[(arr[i], arr[j])] + 1
If no previous sequence exists, start new sequence of length 3
Track the maximum length across all sequences

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Index Map

Create hash map for O(1) element lookups

Fill DP Table

For each potential third element, check if it can extend existing sequences

Update Maximum

Track the longest sequence length found

Code -

solution.c — C

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

#define MAX_SIZE 1000

typedef struct {
    int key;
    int value;
} HashEntry;

typedef struct {
    int a, b;
    int length;
} DPEntry;

int findInHash(HashEntry* hash, int size, int key) {
    for (int i = 0; i < size; i++) {
        if (hash[i].key == key) return hash[i].value;
    }
    return -1;
}

int findInDP(DPEntry* dp, int size, int a, int b) {
    for (int i = 0; i < size; i++) {
        if (dp[i].a == a && dp[i].b == b) return dp[i].length;
    }
    return 0;
}

void addToDP(DPEntry* dp, int* size, int a, int b, int length) {
    for (int i = 0; i < *size; i++) {
        if (dp[i].a == a && dp[i].b == b) {
            dp[i].length = length;
            return;
        }
    }
    dp[*size].a = a;
    dp[*size].b = b;
    dp[*size].length = length;
    (*size)++;
}

int findLengthOfLCIS(int* arr, int n) {
    if (n < 3) return 0;
    
    // Create index map
    HashEntry indexMap[MAX_SIZE];
    for (int i = 0; i < n; i++) {
        indexMap[i].key = arr[i];
        indexMap[i].value = i;
    }
    
    DPEntry dp[MAX_SIZE * MAX_SIZE];
    int dpSize = 0;
    int maxLength = 0;
    
    for (int k = 0; k < n; k++) {
        for (int j = 0; j < k; j++) {
            int target = arr[k] - arr[j];
            int i = findInHash(indexMap, n, target);
            if (i != -1 && i < j) {
                int prevLength = findInDP(dp, dpSize, arr[i], arr[j]);
                if (prevLength == 0) prevLength = 2;
                addToDP(dp, &dpSize, arr[j], arr[k], prevLength + 1);
                if (prevLength + 1 > maxLength) {
                    maxLength = prevLength + 1;
                }
            }
        }
    }
    
    return maxLength >= 3 ? maxLength : 0;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int arr[100];
    int n = 0;
    char* token = strtok(line, "[],\n ");
    while (token != NULL && n < 100) {
        arr[n++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", findLengthOfLCIS(arr, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We check each pair of elements once, and hash map operations are O(1)

⚠ Quadratic Growth

Space Complexity

O(n²)

DP table can store up to O(n²) pairs in worst case

⚠ Quadratic Space

42.4K Views

Medium Frequency

~25 min Avg. Time

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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler