Count Substrings That Differ by One Character

Count Substrings That Differ by One Character - Problem

Given two strings s and t, find the number of ways you can choose a non-empty substring of s and replace a single character by a different character such that the resulting substring is a substring of t.

In other words, find the number of substrings in s that differ from some substring in t by exactly one character.

For example, the underlined substrings in "computer" and "computation" only differ by the 'e'/'a', so this is a valid way.

Return the number of substrings that satisfy the condition above.

A substring is a contiguous sequence of characters within a string.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: The substring "a" from s differs from substring "b" from t by exactly one character (a ≠ b). This is the only valid substring pair.

Example 2 — Multiple Matches

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

› Output: 6

💡 Note: Valid pairs: "a"→"b" (2 ways), "b"→"a" (2 ways), "ab"→"ba" (1 way), "ba"→"ab" (1 way). Total: 6 substring pairs with exactly one difference.

Example 3 — No Differences

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

› Output: 0

💡 Note: All corresponding substrings are identical, so no substring differs by exactly one character.

Constraints

1 ≤ s.length, t.length ≤ 100
s and t consist of lowercase English letters only

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is to use dynamic programming to count matching prefixes and suffixes around each character difference position. Best approach uses DP with prefix/suffix tables to achieve optimal Time: O(nm), Space: O(nm)

Common Approaches

✓ Brute Force

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

Generate all possible substrings from both strings and compare each pair to count those differing by exactly one character. For each substring pair of equal length, count character differences.

Dynamic Programming with Prefix/Suffix

⏱️ Time: O(nm) Space: O(nm)

For each possible difference position, use dynamic programming to count how many matching characters extend to the left and right. Multiply left and right counts to get total valid substrings containing that difference.

Optimized Enumeration

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

For each pair of starting positions in both strings, extend the comparison character by character while tracking prefix matches, differences, and suffix matches. This avoids generating explicit substrings.

Brute Force — Algorithm Steps

Step 1: Generate all substrings of s
Step 2: Generate all substrings of t
Step 3: Compare each pair and count those with exactly 1 difference

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Create all substrings from both strings

Compare Pairs

Count character differences for each pair

Count Valid

Increment count when exactly 1 difference found

Code -

solution.c — C

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

static int prefix[1005][1005];
static int suffix[1005][1005];
static char s[1005];
static char t[1005];

int solution(const char* s, const char* t) {
    int n = strlen(s), m = strlen(t);
    
    // Clear DP arrays
    memset(prefix, 0, sizeof(prefix));
    memset(suffix, 0, sizeof(suffix));
    
    // Fill prefix matches
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (s[i] == t[j]) {
                prefix[i + 1][j + 1] = prefix[i][j] + 1;
            }
        }
    }
    
    // Fill suffix matches (reverse direction)
    for (int i = n - 1; i >= 0; i--) {
        for (int j = m - 1; j >= 0; j--) {
            if (s[i] == t[j]) {
                suffix[i][j] = suffix[i + 1][j + 1] + 1;
            }
        }
    }
    
    int count = 0;
    // For each position where characters differ
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (s[i] != t[j]) {
                // Count substrings with this difference
                int left = prefix[i][j] + 1;  // +1 for empty prefix
                int right = suffix[i + 1][j + 1] + 1;  // +1 for empty suffix
                count += left * right;
            }
        }
    }
    
    return count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³m³)

O(n²) substrings from s, O(m²) from t, O(min(n,m)) to compare each pair

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables for counting, no extra data structures

✓ Linear Space

28.5K Views

Medium Frequency

~25 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler