Count Common Words With One Occurrence - Practice Coding Problems

Count Common Words With One Occurrence - Problem

Given two string arrays words1 and words2, your task is to find strings that are uniquely shared between both arrays.

A string counts toward our answer if and only if:

It appears exactly once in words1
It appears exactly once in words2

Return the number of such strings.

Example:

If words1 = ["leetcode", "is", "amazing", "as", "is"] and words2 = ["amazing", "leetcode", "is"]

The word "is" appears twice in words1, so it doesn't count. The words "leetcode" and "amazing" each appear exactly once in both arrays, so our answer is 2.

Input & Output

example_1.py — 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 count. "as" doesn't appear in words2.

example_2.py — No Common Words

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

› Output: 0

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

example_3.py — All Duplicates

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

› Output: 0

💡 Note: "a" appears twice in words1, "ab" appears twice in words2. No word appears exactly once in both arrays.

Visualization

Tap to expand

Understanding the Visualization

Collect Evidence

Count how many times each statement appears in each report

Identify Reliable Statements

Find statements mentioned exactly once in both reports

Count Valid Evidence

Count the reliable statements for your final report

Key Takeaway

🎯 Key Insight: Use frequency counting with hash tables to efficiently find words that appear exactly once in both arrays, achieving optimal O(n+m) time complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Linear scan of both arrays plus one pass through frequency map

✓ Linear Growth

Space Complexity

O(n + m)

Hash maps store at most n+m unique words from both arrays

⚡ Linearithmic Space

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

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 f Meta 22

The optimal solution uses hash table frequency counting to achieve O(n+m) time complexity. Build frequency maps for both arrays, then count words that appear exactly once in both maps. This is much more efficient than the brute force O(n²) approach of manually counting each word's occurrences.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table	O(n + m)	O(n + m)	Build frequency maps first, then find common words with single occurrences
One-Pass Hash Table (Optimal)	O(n + m)	O(n + m)	Build frequency maps while processing, achieving optimal efficiency
Brute Force (Nested Loops)	O(n²)	O(n)	Count occurrences of each word manually using nested loops

Two-Pass Hash Table — Algorithm Steps

Create frequency map for words1
Create frequency map for words2
Iterate through frequency map of words1
For each word with frequency 1, check if it has frequency 1 in words2
Count all qualifying words

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Map 1

Count frequencies in words1

Build Map 2

Count frequencies in words2

Find Matches

Look for words with count=1 in both maps

Code -

solution.c — C

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

#define HASH_SIZE 1009

typedef struct Node {
    char word[51];
    int count;
    struct Node* next;
} Node;

int hash(const char* word) {
    int h = 0;
    for (int i = 0; word[i]; i++) {
        h = (h * 31 + word[i]) % HASH_SIZE;
    }
    return h;
}

void insert(Node** table, const char* word) {
    int h = hash(word);
    Node* curr = table[h];
    
    while (curr) {
        if (strcmp(curr->word, word) == 0) {
            curr->count++;
            return;
        }
        curr = curr->next;
    }
    
    Node* newNode = malloc(sizeof(Node));
    strcpy(newNode->word, word);
    newNode->count = 1;
    newNode->next = table[h];
    table[h] = newNode;
}

int getCount(Node** table, const char* word) {
    int h = hash(word);
    Node* curr = table[h];
    
    while (curr) {
        if (strcmp(curr->word, word) == 0) {
            return curr->count;
        }
        curr = curr->next;
    }
    return 0;
}

int countWords(char** words1, int words1Size, char** words2, int words2Size) {
    Node* table1[HASH_SIZE] = {NULL};
    Node* table2[HASH_SIZE] = {NULL};
    
    // Build frequency maps
    for (int i = 0; i < words1Size; i++) {
        insert(table1, words1[i]);
    }
    
    for (int i = 0; i < words2Size; i++) {
        insert(table2, words2[i]);
    }
    
    int result = 0;
    for (int i = 0; i < HASH_SIZE; i++) {
        Node* curr = table1[i];
        while (curr) {
            if (curr->count == 1 && getCount(table2, curr->word) == 1) {
                result++;
            }
            curr = curr->next;
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Two passes to build maps O(n+m), one pass to check results O(n)

✓ Linear Growth

Space Complexity

O(n + m)

Space for two frequency maps storing unique words from both arrays

⚡ Linearithmic Space

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

24.7K Views

Medium Frequency

~15 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two-Pass Hash Table — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler