Sentence Similarity III - Practice Coding Problems

Sentence Similarity III - Problem

Imagine you're building a smart text editor that can detect if two sentences are essentially the same, even when one has some extra words inserted in the middle.

You're given two strings sentence1 and sentence2, each representing a sentence composed of words separated by single spaces (no leading or trailing spaces). Your task is to determine if these sentences are similar.

Two sentences are considered similar if you can insert an arbitrary sentence (possibly empty) into one of them to make both sentences identical. The inserted sentence must be properly separated by spaces.

Examples:

✅ "Hello Jane" and "Hello my name is Jane" → Similar (insert "my name is" between "Hello" and "Jane")
❌ "Frog cool" and "Frogs are cool" → Not similar ("Frog" ≠ "Frogs", can't insert partial words)

Return true if the sentences are similar, false otherwise.

Input & Output

example_1.py — Basic Insertion

$ Input: sentence1 = "Hello Jane", sentence2 = "Hello my name is Jane"

› Output: true

💡 Note: We can insert "my name is" between "Hello" and "Jane" in sentence1 to make it identical to sentence2. The common prefix is "Hello" and common suffix is "Jane".

example_2.py — Invalid Word Modification

$ Input: sentence1 = "Frog cool", sentence2 = "Frogs are cool"

› Output: false

💡 Note: "Frog" and "Frogs" are different words. We cannot insert a sentence to make "Frog" become "Frogs" since we can only insert complete words, not modify existing ones.

example_3.py — Empty Insertion

$ Input: sentence1 = "A", sentence2 = "a A b A"

› Output: false

💡 Note: Case matters: "A" ≠ "a". Even though "A" appears in sentence2, the first "a" is lowercase, so no valid insertion exists.

Constraints

1 ≤ sentence1.length, sentence2.length ≤ 100
sentence1 and sentence2 consist of lowercase and uppercase English letters and spaces
The words in sentence1 and sentence2 are separated by a single space
There are no leading or trailing spaces

Visualization

Tap to expand

Understanding the Visualization

Identify the bread slices

Find matching words at the start (prefix) and end (suffix)

Check the filling

See if the remaining middle part can be cleanly inserted

Validate the sandwich

Ensure the bread pieces cover the entire shorter sentence

Key Takeaway

🎯 Key Insight: Two sentences are similar if one can be formed by inserting words into a contiguous gap in the other, preserving common prefix and suffix words.

Asked in

f Meta 15 G Google 12 ⊞ Microsoft 8 Apple 5

The optimal solution uses a two-pointer technique to find the longest common prefix and suffix between the two sentences. If the sum of prefix and suffix lengths covers the entire shorter sentence, then the sentences are similar. This approach runs in O(n + m) time and is much more efficient than trying all possible insertion points.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n + m)	O(n + m)	Match common prefix and suffix, check if middle can be inserted
Brute Force (Try All Splits)	O(n³)	O(n²)	Try inserting each sentence into every possible position of the other

Two Pointers (Optimal) — Algorithm Steps

Split both sentences into word arrays
Use left pointer to find longest common prefix
Use right pointer to find longest common suffix
Check if remaining middle section forms a valid insertion

Visualization

Tap to expand

Step-by-Step Walkthrough

Find prefix

Move left pointer to find longest matching prefix

Find suffix

Move right pointer to find longest matching suffix

Check validity

Verify if prefix + suffix covers entire shorter sentence

Code -

solution.c — C

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

char** split(char* sentence, int* count) {
    char** words = malloc(1000 * sizeof(char*));
    *count = 0;
    char* s = malloc(strlen(sentence) + 1);
    strcpy(s, sentence);
    char* token = strtok(s, " ");
    while (token != NULL) {
        words[*count] = malloc(strlen(token) + 1);
        strcpy(words[*count], token);
        (*count)++;
        token = strtok(NULL, " ");
    }
    return words;
}

bool areSentencesSimilar(char* sentence1, char* sentence2) {
    int n, m;
    char** words1 = split(sentence1, &n);
    char** words2 = split(sentence2, &m);
    
    // Find longest common prefix
    int left = 0;
    while (left < (n < m ? n : m) && strcmp(words1[left], words2[left]) == 0) {
        left++;
    }
    
    // Find longest common suffix
    int right = 0;
    while (right < (n < m ? n : m) - left && 
           strcmp(words1[n - 1 - right], words2[m - 1 - right]) == 0) {
        right++;
    }
    
    bool result = left + right >= (n < m ? n : m);
    
    // Cleanup
    for (int i = 0; i < n; i++) free(words1[i]);
    for (int i = 0; i < m; i++) free(words2[i]);
    free(words1);
    free(words2);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Single pass through both sentences to find prefix/suffix matches

✓ Linear Growth

Space Complexity

O(n + m)

Space for storing word arrays from both sentences

⚡ Linearithmic Space

23.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

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler