Introduction

In this blog post, we will explore how to solve the LeetCode problem "306" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like Chatmagic, we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

Problem Statement

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. Example 1: Input: "112358" Output: true Explanation: The digits can form an additive sequence: 1, 1, 2, 3, 5, 8. 1 + 1 = 2, 1 + 2 = 3, 2 + 3 = 5, 3 + 5 = 8 Example 2: Input: "199100199" Output: true Explanation: The additive sequence is: 1, 99, 100, 199. 1 + 99 = 100, 99 + 100 = 199 Constraints: 1 <= num.length <= 35 num consists only of digits. Follow up: How would you handle overflow for very large input integers?

Explanation

Here's the breakdown of the approach, complexities, and Python code for solving the additive number problem:

• Iterate through possible lengths of the first two numbers: The core idea is to systematically explore all possible lengths for the first two numbers in the potential additive sequence. This involves nested loops where the outer loop determines the length of the first number, and the inner loop determines the length of the second number.

• Check for valid additive sequence: For each pair of initial numbers, a helper function verifies if the remaining digits in the string can form a valid additive sequence. The function calculates the sum of the two numbers and checks if it matches the subsequent digits in the input string.

• Handle leading zeros: A utility function validates that the numbers in the sequence do not have leading zeros unless the number itself is zero.

• Complexity:

  • Runtime: O(n^3), where n is the length of the input string num. This is because of the nested loops to select the first two numbers and the isAdditive function's while loop.
  • Storage: O(n), where n is the length of the input string due to string slicing and function call stack.

Code

    def isAdditiveNumber(num: str) -> bool:
    """
    Determines if a string can form an additive sequence.

    Args:
        num: The input string containing only digits.

    Returns:
        True if the string is an additive number, False otherwise.
    """

    def isValid(first: str, second: str, remaining: str) -> bool:
        """
        Checks if the remaining string forms an additive sequence given the first two numbers.
        """
        if not remaining:
            return True

        sum_str = str(int(first) + int(second))

        if remaining.startswith(sum_str):
            return isValid(second, sum_str, remaining[len(sum_str):])
        else:
            return False

    def isValidNumber(s: str) -> bool:
        """
        Checks if a number is valid (no leading zeros unless it's zero).
        """
        return len(s) == 1 or (s[0] != '0')

    n = len(num)
    for i in range(1, n // 2 + 1):
        for j in range(1, (n - i) // 2 + 1):
            first = num[:i]
            second = num[i:i + j]
            remaining = num[i + j:]

            if isValidNumber(first) and isValidNumber(second):
                if isValid(first, second, remaining):
                    return True

    return False