Count Substrings That Differ by One Character

Count Substrings That Differ by One Character - Problem

Imagine you're a text editor developer working on a "smart suggestion" feature. Given two strings s and t, you need to find how many substrings from s can be transformed into substrings of t by changing exactly one character.

More formally, count the number of ways you can:

Choose a non-empty substring from s
Replace exactly one character in it
Make it match some substring in t

For example, in "computer" and "computation", the substring "comput" from the first string differs from "comput" in the second string by exactly one character (position doesn't matter for counting).

Goal: Return the total count of such valid transformations.

Input & Output

example_1.py — Basic Example

$ Input: s = "aba", t = "baba"

› Output: 6

💡 Note: The substrings are: "a" from s → "b" from t (change a→b), "b" from s → "a" from t (change b→a), "ab" from s → "ba" from t (change a→b), "ba" from s → "ab" from t (change b→a), "aba" from s → "bab" from t (change a→b), "aba" from s → "aba" from t (change b→a)

example_2.py — Same Characters

$ Input: s = "ab", t = "bb"

› Output: 3

💡 Note: The valid transformations are: "a" → "b" (change a→b), "ab" → "bb" (change a→b), "b" → "b" is not valid since no change needed

example_3.py — Single Character

$ Input: s = "a", t = "a"

› Output: 0

💡 Note: No valid substrings because "a" and "a" are identical, so we cannot make exactly one character change

Visualization

Tap to expand

Understanding the Visualization

Identify difference positions

Find all positions where the two strings have different characters

Count matching neighbors

For each difference, count how many characters match before and after

Calculate combinations

Multiply prefix and suffix counts to get total valid substrings

Sum all possibilities

Add up counts from all difference positions

Key Takeaway

🎯 Key Insight: Instead of generating all substrings, we fix each difference position and count how many valid substrings can be formed around it using mathematical combinations.

Time & Space Complexity

Time Complexity

⏱️

O(nm)

We process each character pair once, where n and m are string lengths

✓ Linear Growth

Space Complexity

O(nm)

Two DP arrays to store prefix and suffix matching lengths

⚡ Linearithmic Space

Constraints

1 ≤ s.length, t.length ≤ 100
s and t consist of lowercase English letters only
Must differ by exactly one character - not zero, not two or more

Asked in

G Google 25 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses dynamic programming to avoid generating all substrings explicitly. For each position pair where characters differ, we count matching prefixes and suffixes, then multiply these counts to get the total number of valid substrings with exactly one difference at that position.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(nm)	O(nm)	Use DP to track matching prefixes and suffixes efficiently
Brute Force (Check All Pairs)	O(n²m²k)	O(1)	Compare every substring of s with every substring of t

Dynamic Programming (Optimal) — Algorithm Steps

For each position i in s and j in t, calculate matching prefix length
For each position i in s and j in t, calculate matching suffix length
If characters at positions i and j are different, combine prefix and suffix counts
Sum all possible substring combinations using the precomputed values

Visualization

Tap to expand

Step-by-Step Walkthrough

Find difference position

Identify positions where characters differ between strings

Count left matches

Count how many characters match going leftward from difference

Count right matches

Count how many characters match going rightward from difference

Calculate combinations

Multiply (left+1) × (right+1) for total substring count

Code -

solution.c — C

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

int countSubstrings(char* s, char* t) {
    int n = strlen(s), m = strlen(t);
    int result = 0;
    
    // For each position pair (i,j), try to make them the differing position
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (s[i] != t[j]) { // This will be our one difference
                // Count matching characters before this position
                int left = 0;
                while (i - left - 1 >= 0 && j - left - 1 >= 0 && 
                       s[i - left - 1] == t[j - left - 1]) {
                    left++;
                }
                
                // Count matching characters after this position  
                int right = 0;
                while (i + right + 1 < n && j + right + 1 < m &&
                       s[i + right + 1] == t[j + right + 1]) {
                    right++;
                }
                
                // Number of valid substrings with difference at (i,j)
                result += (left + 1) * (right + 1);
            }
        }
    }
    
    return result;
}

int main() {
    char s[101], t[101];
    scanf("%s %s", s, t);
    printf("%d\n", countSubstrings(s, t));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(nm)

We process each character pair once, where n and m are string lengths

✓ Linear Growth

Space Complexity

O(nm)

Two DP arrays to store prefix and suffix matching lengths

⚡ Linearithmic Space

Constraints

1 ≤ s.length, t.length ≤ 100
s and t consist of lowercase English letters only
Must differ by exactly one character - not zero, not two or more

28.5K Views

Medium Frequency

~25 min Avg. Time

890 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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler