Check if an Original String Exists Given Two Encoded Strings

Check if an Original String Exists Given Two Encoded Strings - Problem

An original string, consisting of lowercase English letters, can be encoded by the following steps:

Arbitrarily split it into a sequence of some number of non-empty substrings.
Arbitrarily choose some elements (possibly none) of the sequence, and replace each with its length (as a numeric string).
Concatenate the sequence as the encoded string.

For example, one way to encode an original string "abcdefghijklmnop" might be:

Split it as a sequence: ["ab", "cdefghijklmn", "o", "p"].
Choose the second and third elements to be replaced by their lengths, respectively. The sequence becomes ["ab", "12", "1", "p"].
Concatenate the elements of the sequence to get the encoded string: "ab121p".

Given two encoded strings s1 and s2, consisting of lowercase English letters and digits 1-9 (inclusive), return true if there exists an original string that could be encoded as both s1 and s2. Otherwise, return false.

Note: The test cases are generated such that the number of consecutive digits in s1 and s2 does not exceed 3.

Input & Output

Example 1 — Different Interpretations

$ Input: s1 = "a5b", s2 = "a5b"

› Output: true

💡 Note: Both strings are identical, so they can definitely encode the same original string (either "a5b" or "a" + 5 characters + "b")

Example 2 — Number as Length

$ Input: s1 = "ab", s2 = "a2"

› Output: false

💡 Note: s1 = "ab" means original has 'a' then 'b'. s2 = "a2" could mean 'a' + 2 characters, but that would be 3 total chars vs 2 in s1

Example 3 — Complex Case

$ Input: s1 = "a5b", s2 = "abc"

› Output: false

💡 Note: s1 could be "a5b" (3 chars) or "a" + 5chars + "b" (7 chars). s2 is "abc" (3 chars). Only 3-char interpretation works, but "a5b" ≠ "abc"

Constraints

1 ≤ s1.length, s2.length ≤ 40
s1 and s2 consist of digits 1-9 and lowercase English letters
The number of consecutive digits in s1 and s2 does not exceed 3

Visualization

Tap to expand

Asked in

G Google 42 f Facebook 38 M Microsoft 25

The key insight is to track the character difference between the two strings as we decode them. We use recursive exploration with memoization to try all possible interpretations of digits (as lengths or literals). Best approach is memoized recursion. Time: O(n×m×D), Space: O(n×m×D).

Common Approaches

✓ Frequency Count

⏱️ Time: N/A Space: N/A

Optimized

⏱️ Time: N/A Space: N/A

Memoized Recursion

⏱️ Time: O(n × m × D) Space: O(n × m × D)

Same recursive approach but store results for (i, j, diff) states to avoid redundant calculations. Uses a hash map to remember previously computed results.

Recursive Backtracking

⏱️ Time: O(2^(n+m)) Space: O(n+m)

For each position, try interpreting numbers as either actual digits or as lengths of original substrings. Use recursion to explore all combinations.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_MEMO 100000

struct MemoEntry {
    int i, j, diff;
    bool result;
    bool used;
};

static struct MemoEntry memo[MAX_MEMO];
static int memo_size = 0;

bool get_memo(int i, int j, int diff, bool* result) {
    for (int k = 0; k < memo_size; k++) {
        if (memo[k].used && memo[k].i == i && memo[k].j == j && memo[k].diff == diff) {
            *result = memo[k].result;
            return true;
        }
    }
    return false;
}

void set_memo(int i, int j, int diff, bool result) {
    if (memo_size < MAX_MEMO) {
        memo[memo_size].i = i;
        memo[memo_size].j = j;
        memo[memo_size].diff = diff;
        memo[memo_size].result = result;
        memo[memo_size].used = true;
        memo_size++;
    }
}

int min(int a, int b) {
    return a < b ? a : b;
}

bool solve(const char* s1, const char* s2, int i, int j, int diff) {
    bool cached_result;
    if (get_memo(i, j, diff, &cached_result)) {
        return cached_result;
    }
    
    int s1_len = strlen(s1);
    int s2_len = strlen(s2);
    
    if (i == s1_len && j == s2_len) {
        bool result = (diff == 0);
        set_memo(i, j, diff, result);
        return result;
    }
    
    if (i < s1_len && isalpha(s1[i])) {
        bool result = solve(s1, s2, i + 1, j, diff + 1);
        set_memo(i, j, diff, result);
        return result;
    }
    
    if (j < s2_len && isalpha(s2[j])) {
        bool result = solve(s1, s2, i, j + 1, diff - 1);
        set_memo(i, j, diff, result);
        return result;
    }
    
    if (i < s1_len && isdigit(s1[i])) {
        int num = 0;
        for (int k = i; k < min(i + 3, s1_len); k++) {
            if (isdigit(s1[k])) {
                num = num * 10 + (s1[k] - '0');
                if (solve(s1, s2, k + 1, j, diff + num)) {
                    set_memo(i, j, diff, true);
                    return true;
                }
            } else {
                break;
            }
        }
    }
    
    if (j < s2_len && isdigit(s2[j])) {
        int num = 0;
        for (int k = j; k < min(j + 3, s2_len); k++) {
            if (isdigit(s2[k])) {
                num = num * 10 + (s2[k] - '0');
                if (solve(s1, s2, i, k + 1, diff - num)) {
                    set_memo(i, j, diff, true);
                    return true;
                }
            } else {
                break;
            }
        }
    }
    
    set_memo(i, j, diff, false);
    return false;
}

bool solution(const char* s1, const char* s2) {
    memo_size = 0;
    return solve(s1, s2, 0, 0, 0);
}

int main() {
    char s1[1000], s2[1000];
    fgets(s1, sizeof(s1), stdin);
    fgets(s2, sizeof(s2), stdin);
    
    // Remove newlines
    s1[strcspn(s1, "\n")] = 0;
    s2[strcspn(s2, "\n")] = 0;
    
    bool result = solution(s1, s2);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~35 min Avg. Time

890 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