Strings Differ by One Character - Practice Coding Problems

Strings Differ by One Character - Problem

Given a list of strings dict where all strings have the same length, determine if there exist any two strings that differ by exactly one character at the same index position.

Your task is to return true if such a pair exists, otherwise return false.

Example: If you have strings ["abc", "axc", "def"], then "abc" and "axc" differ by only one character at index 1 (b vs x), so the answer would be true.

This problem is commonly asked in coding interviews and requires efficient string comparison techniques.

Input & Output

example_1.py — Basic Case

$ Input: ["abc", "axc", "def"]

› Output: true

💡 Note: Strings 'abc' and 'axc' differ by exactly one character at index 1 (b vs x)

example_2.py — No Match

$ Input: ["abc", "def", "ghi"]

› Output: false

💡 Note: No two strings differ by exactly one character. Each pair differs by 3 characters

example_3.py — Multiple Differences

$ Input: ["abc", "axd", "def"]

› Output: false

💡 Note: The closest pair 'abc' and 'axd' differs by 2 characters (positions 1 and 2), not exactly 1

Visualization

Tap to expand

Understanding the Visualization

Create Fingerprints

For each password, create patterns by masking one character at a time

Check Database

Store each pattern in our security database

Detect Collision

If we encounter a pattern we've seen before, we found similar passwords

Key Takeaway

🎯 Key Insight: By creating masked patterns, we transform the problem from comparing strings directly to detecting pattern collisions in a hash table, making it much more efficient!

Time & Space Complexity

Time Complexity

⏱️

O(n × m²)

n strings, m characters per string, m patterns per string to generate and hash

✓ Linear Growth

Space Complexity

O(n × m)

Hash set can store up to n×m patterns in worst case

⚡ Linearithmic Space

Constraints

1 ≤ dict.length ≤ 10⁵
1 ≤ dict[i].length ≤ 300
All strings in dict have the same length
dict[i] consists of lowercase English letters only

Asked in

G Google 45 a Amazon 38 f Meta 28 ⊞ Microsoft 22 Apple 15

The optimal solution uses pattern masking with a hash table. For each string, generate all possible patterns by replacing one character with '*'. If any pattern appears twice, we've found two strings that differ by exactly one character. This approach has O(n × m²) time complexity and O(n × m) space complexity, which is efficient for the given constraints.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table with Pattern Masking	O(n × m²)	O(n × m)	Generate masked patterns for each string and use hash table to detect collisions
Brute Force (Compare All Pairs)	O(n² × m)	O(1)	Compare every pair of strings to check if they differ by exactly one character

One-Pass Hash Table with Pattern Masking — Algorithm Steps

For each string, generate all possible masked patterns (replace each character with '*')
Store each pattern in a hash set as we generate them
If a pattern already exists in the hash set, we found two strings that differ by one character
Return true immediately upon finding a collision
If no collision is found after processing all strings, return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate patterns

For 'abc': create '*bc', 'a*c', 'ab*'

Check collision

For 'axc': create '*xc', 'a*c' (collision found!)

Return result

Pattern 'a*c' already exists, so return true

Code -

solution.c — C

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

#define MAX_PATTERNS 10000
#define MAX_LEN 100

char patterns[MAX_PATTERNS][MAX_LEN];
int patternCount = 0;

bool hasPattern(const char* pattern) {
    for (int i = 0; i < patternCount; i++) {
        if (strcmp(patterns[i], pattern) == 0) {
            return true;
        }
    }
    return false;
}

void addPattern(const char* pattern) {
    strcpy(patterns[patternCount++], pattern);
}

bool differByOne(char dict[][100], int n) {
    if (n < 2) return false;
    
    patternCount = 0;
    
    for (int i = 0; i < n; i++) {
        int len = strlen(dict[i]);
        for (int j = 0; j < len; j++) {
            char pattern[MAX_LEN];
            strcpy(pattern, dict[i]);
            pattern[j] = '*';
            
            if (hasPattern(pattern)) {
                return true;
            }
            addPattern(pattern);
        }
    }
    
    return false;
}

int main() {
    char dict[3][100] = {"abc", "axc", "def"};
    printf("%s\n", differByOne(dict, 3) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m²)

n strings, m characters per string, m patterns per string to generate and hash

✓ Linear Growth

Space Complexity

O(n × m)

Hash set can store up to n×m patterns in worst case

⚡ Linearithmic Space

Constraints

1 ≤ dict.length ≤ 10⁵
1 ≤ dict[i].length ≤ 300
All strings in dict have the same length
dict[i] consists of lowercase English letters only

28.5K Views

Medium-High Frequency

~18 min Avg. Time

850 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

One-Pass Hash Table with Pattern Masking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler