One Edit Distance - Practice Coding Problems

One Edit Distance - Problem

One Edit Distance

Given two strings s and t, determine if they are exactly one edit distance apart. Two strings are considered one edit distance apart if you can perform exactly one of the following operations to transform string s into string t:

📝 Insert exactly one character into s
✂️ Delete exactly one character from s
🔄 Replace exactly one character in s

Return true if the strings are exactly one edit distance apart, false otherwise.

Note: If the strings are identical or require more than one edit, return false.

Input & Output

example_1.py — Basic Replace

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

› Output: true

💡 Note: We can insert 'c' into s to get t: "ab" → "acb" (insert 'c' at position 1)

example_2.py — Basic Delete

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

› Output: true

💡 Note: We can remove 'c' from s to get t: "cab" → "ab" (delete 'c' at position 0)

example_3.py — Identical Strings

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

› Output: false

💡 Note: The strings are identical, so no edit is needed. We need exactly one edit distance, not zero.

Visualization

Tap to expand

Understanding the Visualization

Read Side by Side

Compare characters at the same position in both strings

Find the Difference

Stop when you encounter the first mismatch

Identify Edit Type

Based on string lengths, determine if it's insert/delete/replace

Verify Fix

Check if the rest matches after applying the single edit

Key Takeaway

🎯 Key Insight: By using two pointers to find the first mismatch and then determining the edit type based on string lengths, we can solve this problem in O(n) time with O(1) space, avoiding the need to generate all possible edits.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the O(n) positions, we try O(n) operations, each taking O(n) time to create and compare strings

⚠ Quadratic Growth

Space Complexity

O(n)

Space needed to store the generated strings during comparison

⚡ Linearithmic Space

Constraints

0 ≤ s.length, t.length ≤ 10⁴
s and t consist of lowercase English letters, digits, and/or space characters
The strings may be empty

Asked in

G Google 45 f Facebook 38 a Amazon 32 ⊞ Microsoft 28 🍎 Apple 22

The optimal solution uses two pointers to traverse both strings simultaneously until the first mismatch is found. Based on the string lengths, we determine the required edit operation (insert, delete, or replace) and verify that the remaining characters match. This achieves O(n) time complexity with O(1) space, making it much more efficient than the brute force approach that generates all possible edits.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Operations)	O(n²)	O(n)	Try all possible single edit operations and check if any results in the target string
Two Pointers (Optimal)	O(n)	O(1)	Use two pointers to find the first difference and verify the edit type

Brute Force (Try All Operations) — Algorithm Steps

Try inserting every character (a-z) at every position in string s
Try deleting every character from string s
Try replacing every character in string s with every other character
Check if any resulting string equals string t

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Deletions

Try removing each character one by one

Generate Insertions

Try inserting each letter at each position

Generate Replacements

Try replacing each character with each letter

Check Target

See if target string exists in generated edits

Code -

solution.c — C

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

bool isOneEditDistance(char* s, char* t) {
    int sLen = strlen(s);
    int tLen = strlen(t);
    
    // Try deletion
    for (int i = 0; i < sLen; i++) {
        char* temp = malloc((sLen) * sizeof(char));
        strncpy(temp, s, i);
        strcpy(temp + i, s + i + 1);
        if (strcmp(temp, t) == 0) {
            free(temp);
            return true;
        }
        free(temp);
    }
    
    // Try insertion
    for (int i = 0; i <= sLen; i++) {
        for (char c = 'a'; c <= 'z'; c++) {
            char* temp = malloc((sLen + 2) * sizeof(char));
            strncpy(temp, s, i);
            temp[i] = c;
            strcpy(temp + i + 1, s + i);
            if (strcmp(temp, t) == 0) {
                free(temp);
                return true;
            }
            free(temp);
        }
    }
    
    // Try replacement
    for (int i = 0; i < sLen; i++) {
        for (char c = 'a'; c <= 'z'; c++) {
            if (c != s[i]) {
                char* temp = malloc((sLen + 1) * sizeof(char));
                strcpy(temp, s);
                temp[i] = c;
                if (strcmp(temp, t) == 0) {
                    free(temp);
                    return true;
                }
                free(temp);
            }
        }
    }
    
    return false;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the O(n) positions, we try O(n) operations, each taking O(n) time to create and compare strings

⚠ Quadratic Growth

Space Complexity

O(n)

Space needed to store the generated strings during comparison

⚡ Linearithmic Space

Constraints

0 ≤ s.length, t.length ≤ 10⁴
s and t consist of lowercase English letters, digits, and/or space characters
The strings may be empty

42.3K Views

High Frequency

~25 min Avg. Time

1.9K 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 (Try All Operations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler