Python Tutorial

The edit distance between two strings measures the minimum number of operations that are needed to convert one string into another. There are various operations that may be performed, including insertion, deletion, and substitution of a single character. The edit distance is also referred to as the Levenshtein distance or the minimum edit distance.

An algorithm to find the edit distance between two strings:

Initialize a 2D array `dp` with dimensions (m+1) x (n+1), where m and n are the lengths of the two strings.
Initialize the first row and first column of `dp` with values from 0 to n and 0 to m, respectively.
Loop through the remaining cells of `dp`:
1. If the characters at the current positions in the two strings are the same, set `dp[i][j]` to the value of `dp[i-1][j-1]`.
2. Otherwise, set `dp[i][j]` to the minimum of the following values:
  1. `dp[i-1][j] + 1` (deletion)
  2. `dp[i][j-1] + 1` (insertion)
  3. `dp[i-1][j-1] + 1` (substitution)
The edit distance between the two strings is `dp[m][n]`.

Python code to implement this algorithm:

def edit_distance(s1, s2):
    m, n = len(s1), len(s2)
dp = [[0 for j in range(n+1)] for i in range(m+1)]
    for i in range(m+1):
dp[i][0] = i
    for j in range(n+1):
dp[0][j] = j
    for i in range(1, m+1):
        for j in range(1, n+1):
            if s1[i-1] == s2[j-1]:
dp[i][j] = dp[i-1][j-1]
            else:
dp[i][j] = min(dp[i-1][j] + 1, dp[i][j-1] + 1, dp[i-1][j-1] + 1)
    return dp[m][n]
s1 = "kitten"
s2 = "sitting"
print(edit_distance(s1, s2)) 
s1 = "rosettacode"
s2 = "raisethysword"
print(edit_distance(s1, s2)) 

Output:

3
8

Explanation:

In the first example, the edit distance between "kitten" and "sitting" is 3. We can transform "kitten" into "sitting" by substituting "k" with "s", substituting "e" with "i", and inserting "g" at the end.

In the second example, the edit distance between "rosettacode" and "raisethysword" is 8. We can transform "rosettacode" into "raisethysword" by deleting "o", substituting "c" with "i", substituting "d" with "s", substituting "e" with "t", inserting "h" after "t",

Time Complexity:

The nested loops iterate through all the cells of the 2D array dp. The outer loop runs m+1 times and the inner loop runs n+1 Therefore, the time complexity of the nested loops is O(mn).
The operations performed inside the inner loop are all constant time operations.

Therefore, the overall time complexity of the function edit_distance() is O(mn).

Space Complexity:

The space complexity of the 2D array dp is (m+1) x (n+1).

Therefore, the space complexity of the function edit_distance() is O(mn).

There are other approaches to calculating the edit distance between two strings in Python. Here are a few:

Recursive approach with memoization: In this approach, we can use recursion to calculate the edit distance between the two strings. We can store the result of each subproblem in a memoization table so that we can reuse the result if we encounter the same subproblem again. This approach has a time complexity of O(mn) in the worst case, where m and n are the lengths of the two strings.

For Example:

def edit_distance(s1, s2, m, n, memo):
    if memo[m][n] != -1:
        return memo[m][n]
    if m == 0:
        memo[m][n] = n
elif n == 0:
        memo[m][n] = m
elif s1[m-1] == s2[n-1]:
        memo[m][n] = edit_distance(s1, s2, m-1, n-1, memo)
    else:
        memo[m][n] = 1 + min(edit_distance(s1, s2, m-1, n, memo),
edit_distance(s1, s2, m, n-1, memo),
edit_distance(s1, s2, m-1, n-1, memo))
    return memo[m][n]
s1 = "kitten"
s2 = "sitting"
m, n = len(s1), len(s2)
memo = [[-1 for j in range(n+1)] for i in range(m+1)]
print(edit_distance(s1, s2, m, n, memo)) 

Output:

Iterative approach with a rolling array: In this approach, we can use an iterative approach to calculate the edit distance between the two strings. We can use a rolling array to store only the previous row of the memoization table instead of the entire table. This approach reduces the space complexity to O(n), where n is the length of the shorter string. The time complexity remains O(mn) in the worst case.

For Example:

def edit_distance(s1, s2):
    m, n = len(s1), len(s2)
    if m < n:
        return edit_distance(s2, s1)
dp = [[0 for j in range(n+1)] for i in range(2)]
    for j in range(n+1):
dp[0][j] = j
    for i in range(1, m+1):
dp[i%2][0] = i
        for j in range(1, n+1):
            if s1[i-1] == s2[j-1]:
dp[i%2][j] = dp[(i-1)%2][j-1]
            else:
dp[i%2][j] = 1 + min(dp[(i-1)%2][j],
dp[i%2][j-1],
dp[(i-1)%2][j-1])
    return dp[m%2][n]
s1 = "kitten"
s2 = "sitting"
print(edit_distance(s1, s2))

Output:

Using NumPy: NumPy is a popular Python library for numerical computing. It provides efficient and optimized functions for array operations. We can use the numpy library to implement the edit distance algorithm. This approach has a time complexity of O(mn) in the worst case and a space complexity of O(mn).

For Example:

import numpy as np
def edit_distance(s1, s2):
    m, n = len(s1), len(s2)
dp = np.zeros((m+1, n+1), dtype=int)
    for i in range(m+1):
dp[i][0] = i
    for j in range(n+1):
dp[0][j] = j
    for i in range(1, m+1):
        for j in range(1, n+1):
            if s1[i-1] == s2[j-1]:
dp[i][j] = dp[i-1][j-1]
            else:
dp[i][j] = 1 + min(dp[i-1][j],
dp[i][j-1],
dp[i-1][j-1])
    return dp[m][n]
s1 = "kitten"
s2 = "sitting"
print(edit_distance(s1, s2)) 

Output:

Note: The NumPy approach is similar to the first approach in terms of time and space complexity, but it provides an efficient way to perform the matrix operations using the built-in functions of the NumPy library.

One such approach is using dynamic programming.

In dynamic programming, we create a matrix where each cell represents the edit distance between two substrings. We start by initializing the first row and column with incremental values from 0 to n, where n is the length of the string. After that, we iterate over the remaining cells in the matrix and fill them using the following formula:

if s1[i-1] == s2[j-1]:
dp[i][j] = dp[i-1][j-1]
else:
dp[i][j] = 1 + min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])

The final answer will be in the last cell of the matrix, i.e., dp[n][n].

For Example:

def edit_distance(s1, s2):
    n = len(s1)
    m = len(s2)
dp = [[0 for i in range(m+1)] for j in range(n+1)]
    for i in range(n+1):
dp[i][0] = i
    for j in range(m+1):
dp[0][j] = j
    for i in range(1, n+1):
        for j in range(1, m+1):
            if s1[i-1] == s2[j-1]:
dp[i][j] = dp[i-1][j-1]
            else:
dp[i][j] = 1 + min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])
    return dp[n][m]
s1 = "kitten"
s2 = "sitting"
print(edit_distance(s1, s2)) 

Output:

Next TopicBuilding 2048 Game in Python

← prev next →