Split Array into Fibonacci Sequence - Practice Coding Problems

Split Array into Fibonacci Sequence - Problem

String Backtracking Medium

Imagine you have a string of digits like "123456579" and you want to split it into a Fibonacci-like sequence where each number is the sum of the two previous numbers: [123, 456, 579] (because 123 + 456 = 579).

Your task is to find any valid way to split the given string into such a sequence, following these rules:

Each number must fit in a 32-bit signed integer (0 ≤ number < 2³¹)
The sequence must have at least 3 numbers
For every three consecutive numbers: f[i] + f[i+1] = f[i+2]
No leading zeros allowed (except for the number "0" itself)

Return any valid Fibonacci-like sequence as an array, or an empty array [] if impossible.

Input & Output

example_1.py — Basic Fibonacci Split

$ Input: num = "1101111"

› Output: [1, 1, 2, 3, 5, 8, 13]

💡 Note: Split as [1,1,2,3,5,8,13] where each number equals the sum of the previous two: 1+1=2, 1+2=3, 2+3=5, 3+5=8, 5+8=13

example_2.py — Larger Numbers

$ Input: num = "123456579"

› Output: [123, 456, 579]

💡 Note: Split as [123,456,579] because 123 + 456 = 579. This is a valid 3-number Fibonacci sequence.

example_3.py — Impossible Case

$ Input: num = "11235813"

› Output: []

💡 Note: No valid split exists. While this looks like Fibonacci digits, there's no way to split it into a valid sequence with the given constraints.

Constraints

1 ≤ num.length ≤ 200
num contains only digits
Each number in sequence must be < 2³¹
No leading zeros except for number "0" itself

Visualization

Tap to expand

Understanding the Visualization

Try First Break

Place the first break to separate the first number. Try lengths 1, 2, 3...

Try Second Break

For each first number, try different positions for the second break

Follow the Pattern

Once you have two numbers, the Fibonacci rule determines where all other breaks must be

Validate or Backtrack

If the pattern works for the entire string, you found the answer. Otherwise, try the next possibility

Key Takeaway

🎯 Key Insight: In a Fibonacci sequence, the first two numbers completely determine all the rest. This constraint makes backtracking much more efficient than it might initially appear!

Asked in

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

The optimal approach uses backtracking to systematically try different ways to split the string. The key insight is that once we choose the first two numbers, the rest of the Fibonacci sequence is completely determined. We use pruning to avoid exploring impossible branches early, achieving good practical performance despite the exponential worst-case complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Backtracking	O(n³)	O(n)	Try all possible ways to split the first two numbers, then recursively build the sequence

Brute Force Backtracking — Algorithm Steps

Try all possible lengths for the first number (1 to n/2)
For each first number, try all possible lengths for the second number
Check if both numbers are valid (no leading zeros, within 32-bit range)
Use backtracking to build the rest of the sequence
At each step, check if the next number equals sum of previous two
Return the first valid sequence found, or empty array if none exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose First Number

Try different lengths for the first number: '1', '12', '123', etc.

Choose Second Number

For each first number, try different lengths for the second number

Build Sequence

Use the Fibonacci property to determine all remaining numbers

Backtrack on Failure

If we can't continue, backtrack and try the next possibility

Code -

solution.c — C

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

#define MAX_SEQ_SIZE 100

int sequence[MAX_SEQ_SIZE];
int seq_size = 0;

long long stringToLong(const char* str, int start, int end) {
    char temp[20];
    int len = end - start + 1;
    strncpy(temp, str + start, len);
    temp[len] = '\0';
    return atoll(temp);
}

int backtrack(const char* num, int index, int num_len) {
    if (index == num_len && seq_size >= 3) {
        return 1;
    }
    
    for (int i = index; i < num_len; i++) {
        if (num[index] == '0' && i > index) {
            break;
        }
        
        if (i - index + 1 > 10) {
            break;
        }
        
        long long current = stringToLong(num, index, i);
        if (current >= INT_MAX) {
            break;
        }
        
        int currentInt = (int)current;
        
        if (seq_size <= 1 || currentInt == sequence[seq_size-1] + sequence[seq_size-2]) {
            sequence[seq_size++] = currentInt;
            if (backtrack(num, i + 1, num_len)) {
                return 1;
            }
            seq_size--;
        } else if (seq_size >= 2 && currentInt > sequence[seq_size-1] + sequence[seq_size-2]) {
            break;
        }
    }
    
    return 0;
}

int main() {
    char num[1000];
    scanf("%s", num);
    
    // Remove quotes if present
    char* start = num;
    if (num[0] == '"') {
        start = num + 1;
        int len = strlen(start);
        if (start[len-1] == '"') start[len-1] = '\0';
    }
    
    seq_size = 0;
    if (backtrack(start, 0, strlen(start))) {
        printf("[");
        for (int i = 0; i < seq_size; i++) {
            if (i > 0) printf(",");
            printf("%d", sequence[i]);
        }
        printf("]\n");
    } else {
        printf("[]\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

We try O(n²) combinations for the first two numbers, and for each combination we might scan O(n) remaining characters

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth can be O(n) in the worst case, plus space for the result array

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

892 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

Brute Force Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler