#1662

Easy

LeetCode Problem Workspace

Check If Two String Arrays are Equivalent

Determine if two string arrays form identical strings by concatenating elements in order, handling subtle array-length mismatches efficiently.

array string

Problem Statement

You are given two string arrays, word1 and word2. Determine if concatenating all strings in word1 produces the same string as concatenating all strings in word2. Return true if the resulting strings are identical, otherwise return false.

Each array element consists of lowercase letters, and the arrays may vary in length. Focus on the order of elements when forming the full string, since mismatched concatenation order or partial overlaps can lead to incorrect comparisons.

Examples

Example 1

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

Output: true

word1 represents string "ab" + "c" -> "abc" word2 represents string "a" + "bc" -> "abc" The strings are the same, so return true.

Example 2

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

Output: false

Example details omitted.

Example 3

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

Output: true

Example details omitted.

Constraints

1 <= word1.length, word2.length <= 103
1 <= word1[i].length, word2[i].length <= 103
1 <= sum(word1[i].length), sum(word2[i].length) <= 103
word1[i] and word2[i] consist of lowercase letters.

Solution Approach

Concatenate and Compare

Combine all elements of word1 into a single string, and do the same for word2. Then check if the two resulting strings are equal. This is the simplest approach and works efficiently under the given constraints.

Two-Pointer Streaming Comparison

Use pointers to traverse word1 and word2 simultaneously without fully joining the arrays. Compare characters one by one, advancing pointers through the inner strings. This reduces space usage and handles very long strings effectively.

Early Termination on Length Mismatch

Before full concatenation, track cumulative lengths of both arrays. If the total lengths differ, return false immediately. This prevents unnecessary computation and highlights a common failure mode when array sizes differ but partial strings appear similar.

Complexity Analysis

Metric	Value
Time	\mathcal{O}(N)
Space	\mathcal{O}(N)

Time complexity is (\mathcal{O}(N)) where N is the total number of characters across both arrays, because every character must be examined. Space complexity is (\mathcal{O}(N)) if concatenating the arrays fully, or (\mathcal{O}(1)) with the two-pointer approach.

What Interviewers Usually Probe

Ask about handling arrays of different lengths and empty strings.
Probe whether the candidate can optimize space using streaming comparison.
Check understanding of subtle off-by-one errors when joining array elements.

Common Pitfalls or Variants

Common pitfalls

Assuming arrays of equal length guarantee equivalent strings.
Neglecting to preserve the order of elements when concatenating.
Using inefficient nested loops instead of direct concatenation or pointer traversal.

Follow-up variants

Check equivalence ignoring case sensitivity.
Verify equivalence allowing wildcard characters in one array.
Compare arrays where elements may be reversed before concatenation.

FAQ

What is the best approach to solve Check If Two String Arrays are Equivalent?

Concatenate all strings in each array and compare the resulting strings, or use a two-pointer streaming method to reduce space.

Does the order of array elements affect equivalence?

Yes, elements must be concatenated in the original order; changing the order can make equivalent strings appear different.

Can empty strings in the arrays cause issues?

Empty strings are valid and do not affect concatenation results, but they should not be skipped in pointer traversal approaches.

How to handle very large arrays efficiently?

Use a two-pointer approach to compare characters without forming full concatenated strings, reducing space complexity.

Is this problem pattern considered Array plus String?

Yes, the core pattern involves combining array elements into strings and comparing them, which is the Array plus String pattern.

terminal

Solution

Solution 1: String Concatenation

Concatenate the strings in the two arrays into two strings, then compare whether the two strings are equal.

1

2

3

class Solution:
    def arrayStringsAreEqual(self, word1: List[str], word2: List[str]) -> bool:
        return ''.join(word1) == ''.join(word2)

Solution 2: Direct Traversal

In Solution 1, we concatenated the strings in the two arrays into two new strings, which has additional space overhead. We can also directly traverse the two arrays and compare the characters one by one.

1

2

3

class Solution:
    def arrayStringsAreEqual(self, word1: List[str], word2: List[str]) -> bool:
        return ''.join(word1) == ''.join(word2)

Continue Practicing

#1684 count the number of consistent strings #1639 number of ways to form a target string given a dictionary #1629 slowest key