Check If Two String Arrays are Equivalent

Check If Two String Arrays are Equivalent - Problem

Array String Easy

Given two string arrays word1 and word2, return true if the two arrays represent the same string, and false otherwise.

A string is represented by an array if the array elements concatenated in order forms the string.

Input & Output

Example 1 — Basic Case

$ Input: word1 = ["ab", "c"], word2 = ["a", "bc"]

› Output: true

💡 Note: word1 represents "ab" + "c" = "abc", word2 represents "a" + "bc" = "abc". Both form the same string "abc".

Example 2 — Different Lengths

$ Input: word1 = ["a", "cb"], word2 = ["ab", "c"]

› Output: false

💡 Note: word1 represents "a" + "cb" = "acb", word2 represents "ab" + "c" = "abc". The strings "acb" and "abc" are different.

Example 3 — Single Characters

$ Input: word1 = ["abc"], word2 = ["a", "b", "c"]

› Output: true

💡 Note: word1 represents "abc", word2 represents "a" + "b" + "c" = "abc". Both form the same string.

Constraints

1 ≤ word1.length, word2.length ≤ 10³
1 ≤ word1[i].length, word2[i].length ≤ 10³
1 ≤ sum(word1[i].length), sum(word2[i].length) ≤ 10³
word1[i] and word2[i] consist of lowercase letters.

Visualization

Tap to expand

Understanding the Visualization

Input

Two string arrays that need to be compared

Process

Check if concatenated strings are equivalent

Output

Return true if equivalent, false otherwise

Key Takeaway

🎯 Key Insight: Two string arrays are equivalent if their concatenated forms produce identical strings

Asked in

a Amazon 15 G Google 12 f Facebook 8

The key insight is that we can compare string arrays either by concatenating them first or by using pointers to compare character-by-character. The optimal two-pointer approach uses O(1) space while maintaining O(n + m) time complexity by avoiding intermediate string creation.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers Character-by-Character	O(n + m)	O(1)	Use four pointers to compare characters without building full strings
Concatenate and Compare	O(n + m)	O(n + m)	Concatenate both arrays into strings and compare them directly

Two Pointers Character-by-Character — Algorithm Steps

Initialize array and character pointers for both arrays
Compare current characters from both arrays
Advance pointers appropriately when characters match or reach end of current string
Return false if characters don't match, true if both arrays are fully traversed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Set array and character pointers for both arrays

Compare Characters

Compare current characters and advance pointers

Result

Return true if both arrays are fully traversed with matches

Code -

solution.c — C

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

int solution(char word1[][101], int size1, char word2[][101], int size2) {
    int i1 = 0, i2 = 0;
    int j1 = 0, j2 = 0;
    
    while (i1 < size1 && i2 < size2) {
        if (word1[i1][j1] != word2[i2][j2]) {
            return 0;
        }
        
        j1++;
        j2++;
        
        if (j1 == strlen(word1[i1])) {
            i1++;
            j1 = 0;
        }
        
        if (j2 == strlen(word2[i2])) {
            i2++;
            j2 = 0;
        }
    }
    
    return i1 == size1 && i2 == size2;
}

int main() {
    char line[10001];
    char word1[1000][101];
    char word2[1000][101];
    int size1 = 0, size2 = 0;
    
    fgets(line, sizeof(line), stdin);
    char *token = strtok(line, "[],\"\n");
    while (token != NULL && size1 < 1000) {
        if (strlen(token) > 0) {
            strcpy(word1[size1++], token);
        }
        token = strtok(NULL, "[],\"\n");
    }
    
    fgets(line, sizeof(line), stdin);
    token = strtok(line, "[],\"\n");
    while (token != NULL && size2 < 1000) {
        if (strlen(token) > 0) {
            strcpy(word2[size2++], token);
        }
        token = strtok(NULL, "[],\"\n");
    }
    
    int result = solution(word1, size1, word2, size2);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

We visit each character in both arrays exactly once

✓ Linear Growth

Space Complexity

O(1)

Only using a constant number of pointer variables

✓ Linear Space

156.0K Views

Medium Frequency

~15 min Avg. Time

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

Two Pointers Character-by-Character — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler