Additive Number - Practice Coding Problems

Additive Number - Problem

String Backtracking Medium

Additive Number is a fascinating string validation problem that tests your ability to find patterns in digit sequences.

An additive number is a string whose digits can be partitioned to form an additive sequence - similar to the famous Fibonacci sequence! The rules are:

🔢 At least three numbers must be in the sequence
➕ Each number (after the first two) must equal the sum of the two preceding numbers
🚫 No leading zeros allowed (except for the number "0" itself)

For example: "112358" → [1, 1, 2, 3, 5, 8] (Fibonacci!)
But "199100199" → [199, 100, 299] won't work because 199 + 100 = 299, not 199

Goal: Return true if the string can form a valid additive sequence, false otherwise.

Input & Output

example_1.py — Basic Fibonacci

$ Input: "112358"

› Output: true

💡 Note: Can be split as [1, 1, 2, 3, 5, 8] where 1+1=2, 1+2=3, 2+3=5, 3+5=8 (Fibonacci sequence)

example_2.py — Invalid Sequence

$ Input: "199100199"

› Output: false

💡 Note: Cannot form valid additive sequence. 199+100=299, not 199. No other valid splits exist.

example_3.py — Leading Zeros

$ Input: "101"

› Output: true

💡 Note: Can be split as [1, 0, 1] where 1+0=1. The number '0' itself is valid, but '01' would not be.

Visualization

Tap to expand

Understanding the Visualization

Choose First Gene

Select the length of the first number in the sequence

Choose Second Gene

Select the length of the second number, ensuring no leading zeros

Predict Pattern

Generate the expected additive sequence: next = first + second

Validate Match

Check if the predicted sequence matches the remaining digits

Continue or Backtrack

If match found, continue; otherwise try next combination

Key Takeaway

🎯 Key Insight: Once you fix the first two numbers, the entire sequence is determined! The challenge is efficiently trying different splits while respecting the no-leading-zeros constraint.

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for trying all pairs of first two numbers, O(n) for validating each sequence

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing the generated sequence and recursive call stack

⚡ Linearithmic Space

Constraints

1 ≤ num.length ≤ 35
num consists only of digits
No leading zeros allowed except for the number "0" itself

Asked in

G Google 15 a Amazon 8 f Meta 6 ⊞ Microsoft 4

The optimal approach uses backtracking to systematically try different ways to split the string into the first two numbers, then validate if the remaining digits can form the required additive sequence. Key insight: once the first two numbers are chosen, the entire sequence is determined - we just need to check if it matches the remaining string. Time complexity is O(n³) in the worst case, but with good pruning in practice.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Splits)	O(n³)	O(n)	Try every possible way to split the string into first two numbers, then validate the sequence

Brute Force (Try All Splits) — Algorithm Steps

Try all possible lengths for the first number (1 to n/2)
Try all possible lengths for the second number (1 to remaining length)
Check if both numbers have valid format (no leading zeros except '0')
Generate the expected additive sequence and compare with remaining string
Return true if any combination works

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose First Split

Try different positions for the first number

Choose Second Split

For each first number, try different second numbers

Validate Sequence

Check if remaining digits form valid additive sequence

Return Result

Return true if any combination works

Code -

solution.c — C

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

char* addStrings(const char* a, const char* b) {
    int lenA = strlen(a);
    int lenB = strlen(b);
    int maxLen = lenA > lenB ? lenA : lenB;
    char* result = malloc(maxLen + 2);
    
    int carry = 0;
    int i = lenA - 1;
    int j = lenB - 1;
    int k = maxLen;
    result[k + 1] = '\0';
    
    while (i >= 0 || j >= 0 || carry) {
        int sum = carry;
        if (i >= 0) sum += a[i--] - '0';
        if (j >= 0) sum += b[j--] - '0';
        
        result[k--] = sum % 10 + '0';
        carry = sum / 10;
    }
    
    return result + k + 1;
}

bool isValid(const char* numStr) {
    return strcmp(numStr, "0") == 0 || numStr[0] != '0';
}

bool checkSequence(const char* num1, const char* num2, const char* remaining) {
    if (strlen(remaining) == 0) return true;
    
    char* nextNum = addStrings(num1, num2);
    int nextLen = strlen(nextNum);
    
    if (strncmp(remaining, nextNum, nextLen) != 0) {
        return false;
    }
    
    return checkSequence(num2, nextNum, remaining + nextLen);
}

bool isAdditiveNumber(const char* num) {
    int n = strlen(num);
    
    for (int i = 1; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            char num1[i + 1];
            char num2[j - i + 1];
            
            strncpy(num1, num, i);
            num1[i] = '\0';
            strncpy(num2, num + i, j - i);
            num2[j - i] = '\0';
            
            const char* remaining = num + j;
            
            if (!isValid(num1) || !isValid(num2) || strlen(remaining) == 0) {
                continue;
            }
            
            if (checkSequence(num1, num2, remaining)) {
                return true;
            }
        }
    }
    
    return false;
}

int main() {
    char num[1000];
    fgets(num, sizeof(num), stdin);
    
    // Remove newline and quotes
    num[strcspn(num, "\n")] = '\0';
    if (num[0] == '"') {
        memmove(num, num + 1, strlen(num));
        num[strlen(num) - 1] = '\0';
    }
    
    printf("%s\n", isAdditiveNumber(num) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for trying all pairs of first two numbers, O(n) for validating each sequence

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing the generated sequence and recursive call stack

⚡ Linearithmic Space

Constraints

1 ≤ num.length ≤ 35
num consists only of digits
No leading zeros allowed except for the number "0" itself

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Splits) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler