Sentence Similarity

Sentence Similarity - Problem

We can represent a sentence as an array of words. For example, the sentence "I am happy with leetcode" can be represented as arr = ["I","am","happy","with","leetcode"].

Given two sentences sentence1 and sentence2 each represented as a string array and given an array of string pairs similarPairs where similarPairs[i] = [xi, yi] indicates that the two words xi and yi are similar.

Return true if sentence1 and sentence2 are similar, or false if they are not similar.

Two sentences are similar if:

They have the same length (i.e., the same number of words)
sentence1[i] and sentence2[i] are similar for all i

Note: A word is always similar to itself. The similarity relation is not transitive. For example, if words a and b are similar, and words b and c are similar, a and c are not necessarily similar.

Input & Output

Example 1 — Basic Similarity

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

› Output: false

💡 Note: Both sentences have length 2. Position 0: "great" and "fine" are not identical and there's no direct similarity pair ["great","fine"] or ["fine","great"]. Since similarity is not transitive, having both relate to "good" doesn't make them similar to each other.

Example 2 — Direct Similarity

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

› Output: true

💡 Note: Single word sentences. "great" is identical to "great", so they are similar even with no similarity pairs.

Example 3 — No Similarity

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

› Output: false

💡 Note: "great" and "doubleplus" are not identical and there's no similarity pair connecting them directly.

Constraints

1 ≤ sentence1.length, sentence2.length ≤ 1000
1 ≤ sentence1[i].length, sentence2[i].length ≤ 20
0 ≤ similarPairs.length ≤ 1000
similarPairs[i].length == 2

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to efficiently check word similarity using a hash set. The optimal approach builds a hash set of all similarity pairs (bidirectional) for O(1) lookup, then compares each word position. Time: O(m + n), Space: O(m).

Common Approaches

✓ Brute Force Linear Search

⏱️ Time: O(n × m) Space: O(1)

Check if sentences have same length, then for each position, search through all similarity pairs to see if the words are similar or identical.

Hash Set Optimization

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

First pass builds a hash set containing all similarity pairs (both directions). Second pass checks each word pair against the hash set for instant lookup.

Brute Force Linear Search — Algorithm Steps

Check if both sentences have the same length
For each word position, check if words are identical or find them in similarity pairs
Return false if any pair is not similar

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Lengths

Verify both sentences have same number of words

Compare Each Position

For each word pair, search all similarity pairs

Result

Return true if all positions are similar

Code -

solution.c — C

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

bool solution(char sentence1[][101], int len1, char sentence2[][101], int len2, char similarPairs[][2][101], int pairsLen) {
    if (len1 != len2) {
        return false;
    }
    
    for (int i = 0; i < len1; i++) {
        if (strcmp(sentence1[i], sentence2[i]) == 0) {
            continue;
        }
        
        // Search for similarity in pairs
        bool found = false;
        for (int j = 0; j < pairsLen; j++) {
            if ((strcmp(similarPairs[j][0], sentence1[i]) == 0 && strcmp(similarPairs[j][1], sentence2[i]) == 0) ||
                (strcmp(similarPairs[j][0], sentence2[i]) == 0 && strcmp(similarPairs[j][1], sentence1[i]) == 0)) {
                found = true;
                break;
            }
        }
        
        if (!found) {
            return false;
        }
    }
    
    return true;
}

int main() {
    char sentence1[100][101], sentence2[100][101];
    char similarPairs[1000][2][101];
    int len1 = 0, len2 = 0, pairsLen = 0;
    
    // Simple parsing - in real implementation would need proper JSON parsing
    char line[10000];
    fgets(line, sizeof(line), stdin);
    // Parse sentence1
    
    fgets(line, sizeof(line), stdin);
    // Parse sentence2
    
    fgets(line, sizeof(line), stdin);
    // Parse similarPairs
    
    bool result = solution(sentence1, len1, sentence2, len2, similarPairs, pairsLen);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

n words to check, each requiring O(m) search through m similarity pairs

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Linear Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler