One Edit Distance

One Edit Distance - Problem

Given two strings s and t, return true if they are both one edit distance apart, otherwise return false.

A string s is said to be one distance apart from a string t if you can:

Insert exactly one character into s to get t
Delete exactly one character from s to get t
Replace exactly one character of s with a different character to get t

Input & Output

Example 1 — Insert Operation

$ Input: s = 'ab', t = 'abc'

› Output: true

💡 Note: We can insert 'c' at the end of 'ab' to get 'abc', which requires exactly one edit operation.

Example 2 — Replace Operation

$ Input: s = 'cab', t = 'ad'

› Output: false

💡 Note: Length difference is 2, which exceeds the maximum of 1 edit distance. No single edit can transform 'cab' to 'ad'.

Example 3 — Already Equal

$ Input: s = 'abc', t = 'abc'

› Output: false

💡 Note: The strings are already equal, so zero edits are needed, not exactly one edit.

Constraints

0 ≤ s.length, t.length ≤ 10⁴
s and t consist of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 M Microsoft 8

The key insight is that we can use two pointers to scan both strings simultaneously, and when we find the first mismatch, we try the appropriate edit operation based on string lengths. The optimal two-pointer approach runs in O(n) time with O(1) space by handling each case (insert/delete/replace) directly without generating intermediate strings.

Common Approaches

✓ Brute Force - Generate All Single Edits

⏱️ Time: O(n × 26) Space: O(n)

For each position in string s, try inserting, deleting, or replacing each character and check if the result equals t. This approach generates all possible single-edit variations.

Two Pointers - Direct Comparison

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

Compare strings using two pointers, allowing exactly one difference. When a mismatch is found, try all three edit operations and continue comparison.

Brute Force - Generate All Single Edits — Algorithm Steps

Step 1: Try deleting each character from s
Step 2: Try replacing each character in s with all possible characters
Step 3: Try inserting each character at all positions in s
Step 4: Check if any generated string equals t

Visualization

Tap to expand

Step-by-Step Walkthrough

Input

Two strings s='ab' and t='abc'

Generate Edits

Create all possible single edits of s

Check Match

See if any generated string equals t

Code -

solution.c — C

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

bool solution(char* s, char* t) {
    int sLen = strlen(s);
    int tLen = strlen(t);
    
    if (abs(sLen - tLen) > 1) {
        return false;
    }
    
    if (sLen == tLen) {
        // For replace operation, strings must differ by exactly 1 character
        int diffCount = 0;
        for (int i = 0; i < sLen; i++) {
            if (s[i] != t[i]) diffCount++;
        }
        return diffCount == 1;
    }
    
    // For different lengths, use simplified approach
    if (sLen < tLen) {
        // Insert operation needed
        int i = 0, j = 0;
        bool inserted = false;
        while (i < sLen && j < tLen) {
            if (s[i] == t[j]) {
                i++; j++;
            } else {
                if (inserted) return false;
                inserted = true;
                j++; // skip character in t
            }
        }
        return true;
    } else {
        // Delete operation needed
        int i = 0, j = 0;
        bool deleted = false;
        while (i < sLen && j < tLen) {
            if (s[i] == t[j]) {
                i++; j++;
            } else {
                if (deleted) return false;
                deleted = true;
                i++; // skip character in s
            }
        }
        return true;
    }
}

int main() {
    char s[1001], t[1001];
    fgets(s, sizeof(s), stdin);
    fgets(t, sizeof(t), stdin);
    s[strcspn(s, "\n")] = 0;
    t[strcspn(t, "\n")] = 0;
    bool result = solution(s, t);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 26)

For each position (n), try all 26 characters for insert/replace operations

✓ Linear Growth

Space Complexity

O(n)

Creating new strings for each edit operation

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~15 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Generate All Single Edits — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler