Count Common Words With One Occurrence - Practice Coding Problems

Count Common Words With One Occurrence - Problem

Given two string arrays words1 and words2, return the number of strings that appear exactly once in each of the two arrays.

A string appears exactly once in an array if it occurs exactly once and does not appear in any other position in that array.

Input & Output

Example 1 — Basic Case

$ Input: words1 = ["leetcode","is","amazing","as","is"], words2 = ["amazing","leetcode","is"]

› Output: 2

💡 Note: "leetcode" appears once in each array, "amazing" appears once in each array. "is" appears twice in words1, so it doesn't qualify.

Example 2 — No Common Single Words

$ Input: words1 = ["b","bb","bbb"], words2 = ["a","aa","aaa"]

› Output: 0

💡 Note: No words appear in both arrays, so the count is 0.

Example 3 — All Qualify

$ Input: words1 = ["a","ab"], words2 = ["a","a","a","ab"]

› Output: 1

💡 Note: "a" appears once in words1 but three times in words2. "ab" appears once in both arrays, so result is 1.

Constraints

1 ≤ words1.length, words2.length ≤ 1000
1 ≤ words1[i].length, words2[j].length ≤ 30
words1[i] and words2[j] consist only of lowercase English letters

Visualization

Tap to expand

Understanding the Visualization

Input Arrays

Two string arrays with possibly duplicate words

Count Frequencies

Build frequency maps for both arrays

Find Intersection

Count words with frequency 1 in both arrays

Key Takeaway

🎯 Key Insight: Only words appearing exactly once in both arrays qualify - frequency maps make this check efficient

Asked in

a Amazon 15 M Microsoft 8

The key insight is to count word frequencies in both arrays and find intersection of words with frequency 1. The optimal approach uses hash maps for O(n+m) frequency counting, then checks intersection in O(n) time. Time: O(n+m), Space: O(n+m).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force with Nested Loops	O(n³)	O(n)	Check each word in words1 against all words in words2 with manual frequency counting
Frequency Count with Hash Maps	O(n + m)	O(n + m)	Build frequency maps for both arrays, then count words with frequency 1 in both

Brute Force with Nested Loops — Algorithm Steps

Iterate through each word in words1
Count occurrences in both words1 and words2
If count is 1 in both arrays, increment result
Track processed words to avoid duplicates

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Each Word

Take each word from words1 and count in both arrays

Count Occurrences

Scan through both arrays to count frequency

Check Condition

If count is 1 in both arrays, increment result

Code -

solution.c — C

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

int solution(char words1[][50], int len1, char words2[][50], int len2) {
    int result = 0;
    int processed[100] = {0};
    
    for (int i = 0; i < len1; i++) {
        if (processed[i]) continue;
        
        int count1 = 0, count2 = 0;
        for (int j = 0; j < len1; j++) {
            if (strcmp(words1[i], words1[j]) == 0) {
                count1++;
                if (j > i) processed[j] = 1;
            }
        }
        for (int j = 0; j < len2; j++) {
            if (strcmp(words1[i], words2[j]) == 0) {
                count2++;
            }
        }
        
        if (count1 == 1 && count2 == 1) {
            result++;
        }
        processed[i] = 1;
    }
    
    return result;
}

int main() {
    char words1[100][50], words2[100][50];
    int len1 = 0, len2 = 0;
    char line[1000];
    
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line, "[],\"\n");
    while (token != NULL) {
        if (strlen(token) > 0) {
            strcpy(words1[len1++], token);
        }
        token = strtok(NULL, "[],\"\n");
    }
    
    fgets(line, sizeof(line), stdin);
    token = strtok(line, "[],\"\n");
    while (token != NULL) {
        if (strlen(token) > 0) {
            strcpy(words2[len2++], token);
        }
        token = strtok(NULL, "[],\"\n");
    }
    
    printf("%d\n", solution(words1, len1, words2, len2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each word in words1 (n), we scan both arrays (n each) to count occurrences

⚠ Quadratic Growth

Space Complexity

O(n)

Set to track processed words to avoid duplicates

⚡ Linearithmic Space

27.4K Views

Medium Frequency

~15 min Avg. Time

856 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

Brute Force with Nested Loops — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler