Count Common Words With One Occurrence

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

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

✓ Brute Force with Nested Loops

⏱️ Time: O(n³) Space: O(n)

For each word in words1, count its occurrences in both arrays. If it appears exactly once in both, increment result. Use nested loops to avoid duplicates by only checking each unique word once.

Frequency Count with Hash Maps

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

First pass builds frequency maps for each array. Second pass iterates through one frequency map and checks if the word appears exactly once in both maps. This eliminates redundant counting.

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>
#include <ctype.h>

int solution(char words1[][50], int len1, char words2[][50], int len2) {
    int result = 0;
    int processed[1000] = {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 parseJsonArray(char* line, char words[][50]) {
    int count = 0;
    char* pos = line;
    
    while (*pos) {
        if (*pos == '"') {
            pos++; // Skip opening quote
            char* start = pos;
            while (*pos && *pos != '"') pos++;
            if (*pos == '"') {
                int len = pos - start;
                strncpy(words[count], start, len);
                words[count][len] = '\0';
                count++;
                pos++; // Skip closing quote
            }
        } else {
            pos++;
        }
    }
    
    return count;
}

int main() {
    char words1[1000][50], words2[1000][50];
    char line[10000];
    
    fgets(line, sizeof(line), stdin);
    int len1 = parseJsonArray(line, words1);
    
    fgets(line, sizeof(line), stdin);
    int len2 = parseJsonArray(line, words2);
    
    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

✓ Linear 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