Uncommon Words from Two Sentences - Practice Coding Problems

Uncommon Words from Two Sentences - Problem

Ever wondered how to find the unique elements between two collections? This problem asks you to identify uncommon words between two sentences.

Given two sentences s1 and s2, where each sentence contains lowercase words separated by single spaces, you need to find all words that appear exactly once in either sentence but not in both.

A word is considered uncommon if:

It appears exactly once in one sentence, AND
It doesn't appear at all in the other sentence

Example: If s1 = "this apple is sweet" and s2 = "this apple is sour", then ["sweet", "sour"] are uncommon words.

Return the result in any order.

Input & Output

example_1.py — Basic Case

$ Input: s1 = "this apple is sweet", s2 = "this apple is sour"

› Output: ["sweet", "sour"]

💡 Note: Both 'sweet' and 'sour' appear exactly once in their respective sentences and don't appear in the other sentence, making them uncommon.

example_2.py — Repeated Words

$ Input: s1 = "apple apple", s2 = "banana"

› Output: ["banana"]

💡 Note: 'apple' appears twice in s1, so it's not uncommon. 'banana' appears exactly once and only in s2, making it uncommon.

example_3.py — No Uncommon Words

$ Input: s1 = "apple apple", s2 = "apple apple"

› Output: []

💡 Note: 'apple' appears multiple times across both sentences, so there are no uncommon words.

Constraints

1 ≤ s1.length, s2.length ≤ 200
s1 and s2 consist of lowercase English letters and spaces
s1 and s2 do not have leading or trailing spaces
Both sentences contain at least one word

Visualization

Tap to expand

Understanding the Visualization

Combine Menus

List all dishes from both restaurant menus together

Count Dish Frequency

Count how many times each dish appears across both menus

Find Signature Dishes

Dishes appearing exactly once are the unique signatures of each restaurant

Key Takeaway

🎯 Key Insight: Just like signature restaurant dishes, words appearing exactly once across both sentences are automatically uncommon - they're unique to one context and can't be shared!

Asked in

G Google 15 a Amazon 12 f Meta 8 Apple 6

The optimal solution uses a hash map to count word frequencies across both sentences in O(n) time. The key insight is that words appearing exactly once are automatically uncommon by definition - they cannot appear in both sentences or multiple times in one sentence.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(n)	Count word frequencies in one pass, then filter words with count = 1
Brute Force (Nested Comparison)	O(n²)	O(n)	Check each word against all words in both sentences

One-Pass Hash Table (Optimal) — Algorithm Steps

Split both sentences and combine all words into one list
Use a hash map to count frequency of each word in one pass
Filter and return words that have a frequency count of exactly 1

Visualization

Tap to expand

Step-by-Step Walkthrough

Combine & Split

Merge both sentences and split into words

Count Frequencies

Use hash map to count each word's occurrences

Filter Count=1

Return words that appear exactly once

Code -

solution.c — C

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

typedef struct {
    char word[50];
    int count;
} WordCount;

int main() {
    char input[1000], s1[500], s2[500];
    fgets(input, sizeof(input), stdin);
    
    char* delimiter = strchr(input, '|');
    *delimiter = '\0';
    strcpy(s1, input);
    strcpy(s2, delimiter + 1);
    
    WordCount wordCounts[200];
    int uniqueWords = 0;
    
    char combined[1000];
    strcpy(combined, s1);
    strcat(combined, " ");
    strcat(combined, s2);
    
    char* token = strtok(combined, " \n");
    while (token != NULL) {
        int found = 0;
        for (int i = 0; i < uniqueWords; i++) {
            if (strcmp(wordCounts[i].word, token) == 0) {
                wordCounts[i].count++;
                found = 1;
                break;
            }
        }
        
        if (!found) {
            strcpy(wordCounts[uniqueWords].word, token);
            wordCounts[uniqueWords].count = 1;
            uniqueWords++;
        }
        
        token = strtok(NULL, " \n");
    }
    
    printf("[");
    int first = 1;
    for (int i = 0; i < uniqueWords; i++) {
        if (wordCounts[i].count == 1) {
            if (!first) printf(", ");
            printf("\"%s\"", wordCounts[i].word);
            first = 0;
        }
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all n words to build frequency map, then one pass through map

✓ Linear Growth

Space Complexity

O(n)

Hash map stores at most n unique words with their frequencies

⚡ Linearithmic Space

85.0K Views

Medium Frequency

~15 min Avg. Time

2.1K 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

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler