Uncommon Words from Two Sentences - Practice Coding Problems

Uncommon Words from Two Sentences - Problem

A sentence is a string of single-space separated words where each word consists only of lowercase letters.

A word is uncommon if it appears exactly once in one of the sentences, and does not appear in the other sentence.

Given two sentences s1 and s2, return a list of all the uncommon words. You may return the answer in any order.

Input & Output

Example 1 — Basic Case

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

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

💡 Note: Words "this", "apple", "is" appear in both sentences. Only "sweet" and "sour" appear exactly once.

Example 2 — Single Word Sentences

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

› Output: ["apple", "banana"]

💡 Note: Both words appear exactly once, so both are uncommon.

Example 3 — Repeated Words

$ Input: s1 = "a a", s2 = "b b"

› Output: []

💡 Note: Word 'a' appears twice in s1, word 'b' appears twice in s2. No word appears exactly once.

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
All words in s1 and s2 are separated by a single space

Visualization

Tap to expand

Understanding the Visualization

Input Sentences

Two sentences with space-separated words

Count Frequencies

Track how many times each word appears total

Filter Results

Return words that appear exactly once

Key Takeaway

🎯 Key Insight: A word is uncommon if it appears exactly once total across both sentences

Asked in

a Amazon 15 G Google 12 M Microsoft 8

The key insight is that uncommon words appear exactly once total across both sentences. Best approach uses frequency counting with a hash map: split both sentences into words, count frequency of each word, then return words with frequency = 1. Time: O(n), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force	O(n²)	O(1)	Check each word individually against all other words
Frequency Counter	O(n)	O(n)	Use hash map to count word frequencies, then filter for count = 1

Brute Force — Algorithm Steps

Split both sentences into words
For each word, count occurrences in both sentences
Keep words with exactly one occurrence

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Sentences

Break both sentences into individual words

Count Each Word

For each word, scan through all words to count occurrences

Filter Results

Keep only words that appear exactly once

Code -

solution.c — C

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

char** solution(char* s1, char* s2, int* returnSize) {
    char words1[1000][100], words2[1000][100];
    char allWords[2000][100];
    int count1 = 0, count2 = 0, totalWords = 0;
    
    char* token = strtok(s1, " ");
    while (token != NULL) {
        strcpy(words1[count1++], token);
        token = strtok(NULL, " ");
    }
    
    token = strtok(s2, " ");
    while (token != NULL) {
        strcpy(words2[count2++], token);
        token = strtok(NULL, " ");
    }
    
    for (int i = 0; i < count1; i++) {
        strcpy(allWords[totalWords++], words1[i]);
    }
    for (int i = 0; i < count2; i++) {
        strcpy(allWords[totalWords++], words2[i]);
    }
    
    char** result = malloc(totalWords * sizeof(char*));
    *returnSize = 0;
    
    for (int i = 0; i < totalWords; i++) {
        int count = 0;
        for (int j = 0; j < totalWords; j++) {
            if (strcmp(allWords[i], allWords[j]) == 0) {
                count++;
            }
        }
        if (count == 1) {
            result[*returnSize] = malloc(100 * sizeof(char));
            strcpy(result[*returnSize], allWords[i]);
            (*returnSize)++;
        }
    }
    
    return result;
}

int main() {
    char s1[1000], s2[1000];
    fgets(s1, sizeof(s1), stdin);
    fgets(s2, sizeof(s2), stdin);
    s1[strcspn(s1, "\n")] = 0;
    s2[strcspn(s2, "\n")] = 0;
    
    int returnSize;
    char** result = solution(s1, s2, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize - 1) printf(",");
        free(result[i]);
    }
    printf("]\n");
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each word, we scan through all words to count occurrences

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables, no extra data structures

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

842 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler