Introduction

In this blog post, we will explore how to solve the LeetCode problem "842" 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

You are given a string of digits num, such as "123456579". We can split it into a Fibonacci-like sequence [123, 456, 579]. Formally, a Fibonacci-like sequence is a list f of non-negative integers such that: 0 <= f[i] < 231, (that is, each integer fits in a 32-bit signed integer type), f.length >= 3, and f[i] + f[i + 1] == f[i + 2] for all 0 <= i < f.length - 2. Note that when splitting the string into pieces, each piece must not have extra leading zeroes, except if the piece is the number 0 itself. Return any Fibonacci-like sequence split from num, or return [] if it cannot be done. Example 1: Input: num = "1101111" Output: [11,0,11,11] Explanation: The output [110, 1, 111] would also be accepted. Example 2: Input: num = "112358130" Output: [] Explanation: The task is impossible. Example 3: Input: num = "0123" Output: [] Explanation: Leading zeroes are not allowed, so "01", "2", "3" is not valid. Constraints: 1 <= num.length <= 200 num contains only digits.

Explanation

• Backtracking with Constraints: The solution employs a backtracking algorithm to explore possible Fibonacci-like sequences by splitting the input string num. It prunes invalid branches early based on Fibonacci rules, integer range, and leading zero restrictions.
  • Iterative Search for First Two Numbers: The solution iterates through all possible pairs of the first two numbers in the Fibonacci-like sequence. This drastically reduces the branching factor in the backtracking search.
  • Early Termination: The solution includes conditions to terminate the search early if a valid Fibonacci-like sequence is found or if it's determined that no such sequence exists.

• Runtime Complexity: O(N^2 log(2^31)), where N is the length of the input string. *Storage Complexity: O(N), primarily due to the recursion stack and the list to store the Fibonacci sequence.

Code

    def split_into_fibonacci(num: str) -> list[int]:
    """
    Splits a string of digits into a Fibonacci-like sequence.

    Args:
        num: The input string of digits.

    Returns:
        A Fibonacci-like sequence split from num, or [] if it cannot be done.
    """

    n = len(num)

    def backtrack(index: int, sequence: list[int]) -> list[int]:
        """
        Backtracking helper function to explore possible Fibonacci-like sequences.

        Args:
            index: The current index in the input string.
            sequence: The current Fibonacci-like sequence.

        Returns:
            A Fibonacci-like sequence if found, or [] otherwise.
        """

        if index == n and len(sequence) >= 3:
            return sequence

        if len(sequence) >= 2:
            expected_next = sequence[-1] + sequence[-2]
            expected_next_str = str(expected_next)
            if expected_next >= 2**31:
                return []

            if num[index:].startswith(expected_next_str):
                result = backtrack(index + len(expected_next_str), sequence + [expected_next])
                if result:
                    return result
                else:
                    return []

        else:
            for i in range(index + 1, n + 1):
                sub_str = num[index:i]
                if len(sub_str) > 1 and sub_str[0] == '0':
                    continue
                try:
                    val = int(sub_str)
                except ValueError:
                    continue
                if val >= 2**31:
                    continue
                result = backtrack(i, sequence + [val])
                if result:
                    return result

        return []

    for i in range(1, min(11, n)):
        if num[0] == '0' and i > 1:
            break

        try:
            first = int(num[:i])
        except ValueError:
            continue

        if first >= 2**31:
            continue
        for j in range(i + 1, min(i + 11, n + 1)):
            if num[i] == '0' and j - i > 1:
                break
            try:
                second = int(num[i:j])
            except ValueError:
                continue
            if second >= 2**31:
                continue

            result = backtrack(j, [first, second])
            if result:
                return result

    return []