Additive Number

Additive Number - Problem

String Backtracking Medium

An additive number is a string whose digits can form an additive sequence. A valid additive sequence should contain at least three numbers. Except for the first two numbers, each subsequent number in the sequence must be the sum of the preceding two.

Given a string containing only digits, return true if it is an additive number or false otherwise.

Note: Numbers in the additive sequence cannot have leading zeros, so sequence 1, 2, 03 or 1, 02, 3 is invalid.

Input & Output

Example 1 — Valid Additive Number

$ Input: num = "112358"

› Output: true

💡 Note: The digits can form additive sequence: 1, 1, 2, 3, 5, 8. 1+1=2, 1+2=3, 2+3=5, 3+5=8

Example 2 — Invalid Sequence

$ Input: num = "199100199"

› Output: true

💡 Note: The additive sequence is: 1, 99, 100, 199. 1+99=100, 99+100=199

Example 3 — No Valid Sequence

$ Input: num = "1023"

› Output: false

💡 Note: Cannot form a valid additive sequence without leading zeros

Constraints

1 ≤ num.length ≤ 35
num consists only of digits

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 a Amazon 22 M Microsoft 18

The key insight is that once you choose the first two numbers in an additive sequence, the rest of the sequence is completely determined. Use backtracking to try all possible ways to split the string into the first two numbers, then recursively verify if the remaining digits form a valid additive sequence. Best approach uses optimized backtracking with pruning. Time: O(n³), Space: O(n)

Common Approaches

✓ Backtracking with Early Termination

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

Start by trying all possible first two numbers, then recursively check if the remaining string can form a valid additive sequence. Use backtracking to avoid unnecessary computations when a path is clearly invalid.

Brute Force - Try All Splits

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

For every possible position to split the first number and every possible position to split the second number, check if the remaining string can form a valid additive sequence. This approach systematically tries all combinations.

Optimized Backtracking with Pruning

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

Uses improved pruning conditions to eliminate invalid paths early and optimizes string operations for better performance. Includes bounds checking and smarter iteration limits.

Backtracking with Early Termination — Algorithm Steps

Step 1: Try each possible length for first number
Step 2: Try each possible length for second number
Step 3: Recursively check if sequence continues correctly
Step 4: Backtrack when sequence becomes invalid

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose Split

Pick first two numbers

Validate

Check if sequence continues correctly

Backtrack

Return to try next option if invalid

Code -

solution.c — C

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

char* addStrings(const char* num1, const char* num2) {
    int len1 = strlen(num1);
    int len2 = strlen(num2);
    int maxLen = len1 > len2 ? len1 + 2 : len2 + 2;
    char* result = (char*)malloc(maxLen);
    
    int carry = 0;
    int i = len1 - 1;
    int j = len2 - 1;
    int k = 0;
    
    while (i >= 0 || j >= 0 || carry) {
        int sum = carry;
        if (i >= 0) sum += num1[i--] - '0';
        if (j >= 0) sum += num2[j--] - '0';
        result[k++] = sum % 10 + '0';
        carry = sum / 10;
    }
    
    result[k] = '\0';
    
    for (int l = 0; l < k / 2; l++) {
        char temp = result[l];
        result[l] = result[k - 1 - l];
        result[k - 1 - l] = temp;
    }
    
    return result;
}

bool backtrack(const char* num1, const char* num2, const char* remaining) {
    if (strlen(remaining) == 0) return true;
    
    char* expected = addStrings(num1, num2);
    int expectedLen = strlen(expected);
    int remainingLen = strlen(remaining);
    
    if (expectedLen > remainingLen || strncmp(remaining, expected, expectedLen) != 0) {
        free(expected);
        return false;
    }
    
    bool result = backtrack(num2, expected, remaining + expectedLen);
    free(expected);
    return result;
}

bool solution(const char* num) {
    int n = strlen(num);
    
    for (int i = 1; i <= n / 2; i++) {
        if (i > 1 && num[0] == '0') break;
        
        for (int j = 1; j <= (n - i) / 2; j++) {
            if (j > 1 && num[i] == '0') break;
            
            char num1[20], num2[20];
            strncpy(num1, num, i);
            num1[i] = '\0';
            strncpy(num2, num + i, j);
            num2[j] = '\0';
            
            if (backtrack(num1, num2, num + i + j)) {
                return true;
            }
        }
    }
    
    return false;
}

int main() {
    char num[100];
    fgets(num, sizeof(num), stdin);
    num[strcspn(num, "\n")] = 0;
    
    bool result = solution(num);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Two loops for initial splits (O(n²)) and recursive validation with string operations (O(n))

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and string operations for number arithmetic

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

756 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

Backtracking with Early Termination — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler