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

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

✓ Concatenate and Compare

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

Build complete strings by concatenating all elements in each array, then compare the resulting strings for equality. This is the most straightforward approach.

Two Pointers Character-by-Character

⏱️ Time: O(n + m) Space: O(1)

Maintain pointers for array indices and character positions within each string. Compare characters one by one without creating intermediate strings, making it more space-efficient.

Concatenate and Compare — Algorithm Steps

Concatenate all strings in word1 to form string1
Concatenate all strings in word2 to form string2
Return whether string1 equals string2

Visualization

Tap to expand

Step-by-Step Walkthrough

Concatenate Arrays

Build complete strings from both arrays

Compare Strings

Check if the resulting strings are equal

Result

Return true if strings match, false otherwise

Code -

solution.c — C

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

static char word1[1000][1001];
static char word2[1000][1001];

int solution(char word1[][1001], int size1, char word2[][1001], int size2) {
    static char string1[10001];
    static char string2[10001];
    
    string1[0] = '\0';
    string2[0] = '\0';
    
    for (int i = 0; i < size1; i++) {
        strcat(string1, word1[i]);
    }
    
    for (int i = 0; i < size2; i++) {
        strcat(string2, word2[i]);
    }
    
    return strcmp(string1, string2) == 0;
}

int parseStringArray(const char* line, char arr[][1001]) {
    int count = 0;
    int i = 0, len = strlen(line);
    
    // Handle empty array
    if (strstr(line, "[]") != NULL) {
        return 0;
    }
    
    while (i < len && line[i] != '[') i++;
    i++; // skip '['
    
    while (i < len && line[i] != ']') {
        if (line[i] == '"') {
            i++; // skip opening quote
            int start = i;
            while (i < len && line[i] != '"') i++;
            int wordLen = i - start;
            strncpy(arr[count], line + start, wordLen);
            arr[count][wordLen] = '\0';
            count++;
            i++; // skip closing quote
        }
        while (i < len && (line[i] == ',' || line[i] == ' ')) i++;
    }
    
    return count;
}

int main() {
    char line[20001];
    
    fgets(line, sizeof(line), stdin);
    int size1 = parseStringArray(line, word1);
    
    fgets(line, sizeof(line), stdin);
    int size2 = parseStringArray(line, word2);
    
    int result = solution(word1, size1, word2, size2);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

We traverse all characters in both arrays once to build the strings

✓ Linear Growth

Space Complexity

O(n + m)

We store two complete strings of total length n + m

⚡ Linearithmic 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

Concatenate and Compare — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler