Find the Occurrence of First Almost Equal Substring

Find the Occurrence of First Almost Equal Substring - Problem

Find the First Almost Equal Substring

You're given two strings s and pattern. Your task is to find the smallest starting index of a substring in s that is almost equal to the pattern.

🔍 What does "almost equal" mean?
Two strings are almost equal if you can change at most one character in one string to make it identical to the other. This means:
• Strings can be exactly equal (0 changes needed)
• Strings can differ by exactly 1 character (1 change needed)

📝 Goal: Return the smallest starting index where such a substring exists, or -1 if no such substring is found.

Example: If s = "abcdef" and pattern = "bcd", the substring starting at index 1 is exactly equal to the pattern, so return 1.

Input & Output

example_1.py — Basic Match

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

› Output: 1

💡 Note: The substring starting at index 1 is "eet" which exactly matches the pattern (0 differences ≤ 1)

example_2.py — Almost Equal Match

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

› Output: 0

💡 Note: The substring starting at index 0 is "abc". Comparing with "axd": 'a'='a' (match), 'b'≠'x' (diff), 'c'≠'d' (diff). Total 2 differences > 1, so check next position. At index 1: "bcd" vs "axd" has 3 differences. Continue... Actually, no valid match exists, should return -1

example_3.py — No Match Found

$ Input: s = "abc", pattern = "def"

› Output: -1

💡 Note: The only possible substring is "abc" which differs from "def" in all 3 positions (3 > 1), so return -1

Visualization

Tap to expand

Understanding the Visualization

Start the Investigation

Begin at the first person in the lineup (index 0)

Feature Comparison

Compare each feature (character) with the description (pattern)

Count Discrepancies

Keep track of how many features don't match

Make Decision

If ≤1 feature differs, we found our match! Otherwise, move to next person

Report Results

Return the position of first match, or -1 if no match found

Key Takeaway

🎯 Key Insight: We systematically check each position from left to right, counting character differences. The first position with ≤1 differences is our answer, ensuring we find the smallest valid index.

Time & Space Complexity

Time Complexity

⏱️

O(n*m)

We check at most (n-m+1) starting positions, and for each position we compare m characters

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track differences and indices

✓ Linear Space

Constraints

1 ≤ pattern.length ≤ s.length ≤ 10⁵
s and pattern consist only of lowercase English letters
Return the smallest index if multiple valid positions exist

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 22

The brute force approach systematically checks each possible substring position and counts character differences. With early termination when differences exceed 1, this approach achieves O(n*m) time complexity where n is the length of string s and m is the length of the pattern. The key insight is that we need to find the first occurrence, so we must check positions sequentially from left to right.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Character Comparison	O(n*m)	O(1)	Check each possible substring position and count character differences

Brute Force Character Comparison — Algorithm Steps

Iterate through each valid starting position i in string s
Extract substring s[i:i+len(pattern)]
Compare each character with corresponding character in pattern
Count the number of differences
If differences ≤ 1, return the current index i
If no valid substring found, return -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Compare first substring with pattern character by character

Count differences

Track how many characters don't match

Check next position

Move to next starting position if current doesn't match

Return first match

Return index when we find substring with ≤1 differences

Code -

solution.c — C

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

int findFirstAlmostEqual(char* s, char* pattern) {
    int sLen = strlen(s);
    int patternLen = strlen(pattern);
    
    if (patternLen > sLen) {
        return -1;
    }
    
    for (int i = 0; i <= sLen - patternLen; i++) {
        int differences = 0;
        
        // Count differences between substring and pattern
        for (int j = 0; j < patternLen; j++) {
            if (s[i + j] != pattern[j]) {
                differences++;
                if (differences > 1) { // Early termination
                    break;
                }
            }
        }
        
        if (differences <= 1) {
            return i;
        }
    }
    
    return -1;
}

int main() {
    char s[1001], pattern[1001];
    printf("Enter s: ");
    scanf("%s", s);
    printf("Enter pattern: ");
    scanf("%s", pattern);
    printf("%d\n", findFirstAlmostEqual(s, pattern));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*m)

We check at most (n-m+1) starting positions, and for each position we compare m characters

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track differences and indices

✓ Linear Space

Constraints

1 ≤ pattern.length ≤ s.length ≤ 10⁵
s and pattern consist only of lowercase English letters
Return the smallest index if multiple valid positions exist

38.2K Views

Medium-High Frequency

~18 min Avg. Time

1.2K 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 Character Comparison — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler