Find the Occurrence of First Almost Equal Substring

Find the Occurrence of First Almost Equal Substring - Problem

You are given two strings s and pattern.

A string x is called almost equal to y if you can change at most one character in x to make it identical to y.

Return the smallest starting index of a substring in s that is almost equal to pattern. If no such index exists, return -1.

A substring is a contiguous non-empty sequence of characters within a string.

Input & Output

Example 1 — Basic Almost Equal

$ Input: s = "leetcode", pattern = "leotcode"

› Output: 0

💡 Note: The substring "leetcode" starting at index 0 differs from "leotcode" by only 1 character (e vs o at position 2), so it's almost equal.

Example 2 — No Match Found

$ Input: s = "abcdef", pattern = "xyz"

› Output: -1

💡 Note: No substring of length 3 in "abcdef" is almost equal to "xyz" (all would have 3 mismatches).

Example 3 — Exact Match

$ Input: s = "hello", pattern = "ell"

› Output: 0

💡 Note: The substring "hel" starting at index 0 differs from "ell" by only 1 character (h vs e at position 0), so it's almost equal and is the first valid match.

Constraints

1 ≤ s.length, pattern.length ≤ 10⁵
s and pattern consist of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 15 M Meta 12 M Microsoft 8

The key insight is that we need to find substrings with at most 1 character difference. The best approach uses brute force with early termination - check each position and count mismatches, stopping early when count exceeds 1. Time: O(n×m), Space: O(1).

Common Approaches

✓ Two Pass Hash

⏱️ Time: N/A Space: N/A

Brute Force - Check Every Position

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

For each position in s, extract a substring of pattern's length and count how many characters differ. If differences ≤ 1, we found an almost equal substring.

Early Termination Optimization

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

Similar to brute force but we immediately stop comparing characters once we find more than 1 mismatch, avoiding unnecessary comparisons.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(char* s, char* pattern) {
    int n = strlen(s);
    int m = strlen(pattern);
    
    for (int i = 0; i <= n - m; i++) {
        int differences = 0;
        for (int j = 0; j < m; j++) {
            if (s[i + j] != pattern[j]) {
                differences++;
                if (differences > 1) {
                    break;
                }
            }
        }
        
        if (differences <= 1) {
            return i;
        }
    }
    
    return -1;
}

int main() {
    char s[1000];
    char pattern[1000];
    
    fgets(s, sizeof(s), stdin);
    fgets(pattern, sizeof(pattern), stdin);
    
    // Remove newlines
    s[strcspn(s, "\n")] = 0;
    pattern[strcspn(pattern, "\n")] = 0;
    
    int result = solution(s, pattern);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

12.5K Views

Medium Frequency

~15 min Avg. Time

450 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