Sentence Similarity - Practice Coding Problems

Sentence Similarity - Problem

Sentence Similarity is a fascinating problem that explores word relationships and pattern matching. Given two sentences represented as arrays of words and a list of word pairs that are considered similar, determine if the two sentences are equivalent.

The challenge is to check if two sentences are similar based on the following rules:
• Both sentences must have the same length
• Each word at position i in sentence1 must be similar to the word at position i in sentence2
• A word is always similar to itself
• Similarity is not transitive - if A~B and B~C, it doesn't mean A~C

For example, if we have sentences ["I", "love", "coding"] and ["I", "enjoy", "programming"] with similar pairs [["love", "enjoy"], ["coding", "programming"]], the sentences would be similar because each corresponding position has similar words.

Input & Output

example_1.py — Basic Similarity

$ Input: sentence1 = ["great", "acting", "skills"] sentence2 = ["fine", "drama", "talent"] similarPairs = [["great","fine"],["acting","drama"],["skills","talent"]]

› Output: true

💡 Note: Each word at corresponding positions has a similarity pair: great~fine, acting~drama, and skills~talent. All positions match, so the sentences are similar.

example_2.py — Different Lengths

$ Input: sentence1 = ["great"] sentence2 = ["great", "good"] similarPairs = []

› Output: false

💡 Note: The sentences have different lengths (1 vs 2 words), so they cannot be similar regardless of the similarity pairs.

example_3.py — No Similarity Found

$ Input: sentence1 = ["awesome", "acting", "skills"] sentence2 = ["fine", "drama", "talent"] similarPairs = [["great","fine"],["acting","drama"],["skills","talent"]]

› Output: false

💡 Note: The first words 'awesome' and 'fine' are not similar (no pair exists), so the sentences are not similar even though the other positions would match.

Visualization

Tap to expand

Understanding the Visualization

Check Dictionary Size

Both sentences must have the same number of words to be translatable

Build Translation Map

Create a fast lookup table from all word pair translations (both directions)

Position-by-Position Check

For each word position, check if words are identical or translatable

Instant Lookup

Use hash set for O(1) translation checking instead of scanning entire dictionary

Key Takeaway

🎯 Key Insight: Converting similarity pairs to a hash set transforms O(m) searches into O(1) lookups, dramatically improving efficiency from O(n×m) to O(n+m)

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

n is sentence length, m is number of similar pairs. We iterate through sentences once (n) and build hash set once (m)

✓ Linear Growth

Space Complexity

O(m)

Hash set stores all similarity pairs, which is proportional to number of pairs (m)

✓ Linear Space

Constraints

1 ≤ sentence1.length, sentence2.length ≤ 1000
1 ≤ sentence1[i].length, sentence2[i].length ≤ 20
sentence1[i] and sentence2[i] consist of lowercase English letters
0 ≤ similarPairs.length ≤ 2000
similarPairs[i].length == 2
1 ≤ x_i.length, y_i.length ≤ 20
x_i and y_i consist of lowercase English letters

Asked in

G Google 45 f Facebook 38 a Amazon 28 ⊞ Microsoft 22

The optimal solution uses a hash set to store all similarity pairs, enabling O(1) lookups instead of linear searching. We first check if sentences have equal length, then build a hash set containing both directions of each similarity pair. Finally, we iterate through positions once, checking if words are identical or similar via hash set lookup. This achieves O(n + m) time complexity where n is sentence length and m is number of similarity pairs.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(n × m)	O(1)	For each word pair, linearly search through all similarity pairs
One-Pass Hash Set (Optimal)	O(n + m)	O(m)	Build hash set of similarity pairs and check in one pass

Brute Force (Linear Search) — Algorithm Steps

Check if both sentences have the same length
For each position i in the sentences
If words are identical, continue to next position
Otherwise, search through all similarPairs to find a match
If no match found, return false
If all positions pass, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare Lengths

First check if both sentences have the same length

Position by Position

Compare words at each corresponding position

Linear Search

For non-identical words, search through all similarity pairs

Match Found

Continue if similarity found, otherwise return false

Code -

solution.c — C

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

bool areSentencesSimilar(char** sentence1, int sentence1Size, char** sentence2, int sentence2Size, char*** similarPairs, int similarPairsSize, int* similarPairsColSize) {
    if (sentence1Size != sentence2Size) {
        return false;
    }
    
    for (int i = 0; i < sentence1Size; i++) {
        char* word1 = sentence1[i];
        char* word2 = sentence2[i];
        
        // Words are identical
        if (strcmp(word1, word2) == 0) {
            continue;
        }
        
        // Search for similarity in pairs
        bool found = false;
        for (int j = 0; j < similarPairsSize; j++) {
            if ((strcmp(similarPairs[j][0], word1) == 0 && strcmp(similarPairs[j][1], word2) == 0) ||
                (strcmp(similarPairs[j][0], word2) == 0 && strcmp(similarPairs[j][1], word1) == 0)) {
                found = true;
                break;
            }
        }
        
        if (!found) {
            return false;
        }
    }
    
    return true;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

n is sentence length, m is number of similar pairs. For each word position, we search through all m pairs

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, no additional data structures

✓ Linear Space

Constraints

1 ≤ sentence1.length, sentence2.length ≤ 1000
1 ≤ sentence1[i].length, sentence2[i].length ≤ 20
sentence1[i] and sentence2[i] consist of lowercase English letters
0 ≤ similarPairs.length ≤ 2000
similarPairs[i].length == 2
1 ≤ x_i.length, y_i.length ≤ 20
x_i and y_i consist of lowercase English letters

23.6K Views

Medium Frequency

~18 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

Brute Force (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler