Check If Two String Arrays are Equivalent

Check If Two String Arrays are Equivalent - Problem

Array String Easy

String Array Equivalence Check

You're given two arrays of strings and need to determine if they represent the same final string when concatenated.

The Challenge: Given two string arrays word1 and word2, return true if concatenating all elements in word1 produces the same string as concatenating all elements in word2.

Example:
• word1 = ["ab", "c"] → concatenated: "abc"
• word2 = ["a", "bc"] → concatenated: "abc"
• Result: true (both arrays represent the same string)

Goal: Efficiently compare the concatenated results without unnecessary memory allocation.

Input & Output

example_1.py — Basic Match

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

› Output: true

💡 Note: word1 concatenates to "abc" and word2 concatenates to "abc", so they are equivalent.

example_2.py — Different Strings

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

› Output: false

💡 Note: word1 concatenates to "acb" while word2 concatenates to "abc", so they are not equivalent.

example_3.py — Single Elements

$ Input: word1 = ["abc", "d", "defg"], word2 = ["abcddefg"]

› Output: true

💡 Note: Both arrays represent the same string "abcddefg" when concatenated.

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

Set Bookmarks

Place bookmarks at the start of both books

Read & Compare

Read one character from each book and compare them

Move Bookmarks

If characters match, advance both bookmarks to next position

Early Exit

If any characters don't match, we know books are different immediately

Key Takeaway

🎯 Key Insight: By comparing characters as we encounter them rather than building complete strings, we save memory and can exit early on the first mismatch, making the algorithm both space and time efficient.

Asked in

a Amazon 25 ⊞ Microsoft 18 Apple 12 G Google 8

The optimal approach uses two pointers to compare characters without building intermediate strings. This achieves O(1) space complexity while maintaining O(n) time complexity and enables early termination on mismatch.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Character by Character)	O(n)	O(1)	Use pointers to compare characters without building intermediate strings
Brute Force (String Concatenation)	O(n)	O(n)	Concatenate both arrays into strings and compare them directly

Two Pointers (Character by Character) — Algorithm Steps

Initialize pointers for array indices and character positions
Compare current characters from both arrays
If characters match, advance to next characters
If mismatch found, return false immediately
If one array ends first, check if other also ends

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Set up array and character pointers for both inputs

Compare Characters

Compare current characters from both arrays

Advance Pointers

Move to next characters, handling string boundaries

Check Completion

Ensure both arrays are fully consumed

Code -

solution.c — C

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

int arrayStringsAreEqual(char** word1, int word1Size, char** word2, int word2Size) {
    // Initialize pointers for arrays and characters
    int i1 = 0, j1 = 0, i2 = 0, j2 = 0;
    
    while (i1 < word1Size && i2 < word2Size) {
        // Compare current characters
        if (word1[i1][j1] != word2[i2][j2]) {
            return 0;
        }
        
        // Move to next character in word1
        j1++;
        if (j1 == strlen(word1[i1])) {
            i1++;
            j1 = 0;
        }
        
        // Move to next character in word2
        j2++;
        if (j2 == strlen(word2[i2])) {
            i2++;
            j2 = 0;
        }
    }
    
    // Both arrays should be fully consumed
    return i1 == word1Size && i2 == word2Size;
}

int main() {
    // Input parsing and solution call
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each character at most once, comparing them sequentially

✓ Linear Growth

Space Complexity

O(1)

Only using a constant number of pointer variables

✓ Linear Space

48.2K Views

Medium Frequency

~8 min Avg. Time

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