# Minimum number of deletions and insertions to transform one string into another

Given two strings ‘str1’ and ‘str2’ of size m and n respectively. The task is to remove/delete and insert the minimum number of characters from/in str1 to transform it into str2. It could be possible that the same character needs to be removed/deleted from one point of str1 and inserted to some another point.

Example 1:

```Input :
str1 = "heap", str2 = "pea"
Output :
Minimum Deletion = 2 and
Minimum Insertion = 1
Explanation:
p and h deleted from heap
Then, p is inserted at the beginning
One thing to note, though p was required yet
it was removed/deleted first from its position and
then it is inserted to some other position.
Thus, p contributes one to the deletion_count
and one to the insertion_count.
``` Example 2:

```Input :
str1 = "geeksforgeeks", str2 = "geeks"
Output :
Minimum Deletion = 8
Minimum Insertion = 0
``` Simple Approach:

A simple approach is to consider all subsequences of str1 and for each subsequence calculate minimum deletions and insertions so as to transform it into str2. A very complex method and the time complexity of this solution is exponential.

Efficient Approach:

An efficient approach uses the concept of finding the length of the longest common subsequence of the given two sequences.

Algorithm:

• str1 and str2 be the given strings.
• m and n be their lengths respectively.
• len be the length of the longest common subsequence of str1 and str2
• minimum number of deletions minDel = m – len
• minimum number of Insertions minInsert = n – len

Below is the implementation of the above code:

## C++

 `// Dynamic Programming C++ implementation to find` `// minimum number of deletions and insertions` `#include `   `using` `namespace` `std;`   `// Returns length of length common subsequence` `// for str1[0..m-1], str2[0..n-1]` `int` `lcs(string str1, string str2, ``int` `m, ``int` `n)` `{` `    ``int` `L[m + 1][n + 1];` `    ``int` `i, j;`   `    ``// Following steps build L[m+1][n+1] in bottom` `    ``// up fashion. Note that L[i][j] contains` `    ``// length of LCS of str1[0..i-1] and str2[0..j-1]` `    ``for` `(i = 0; i <= m; i++) {` `        ``for` `(j = 0; j <= n; j++) {` `            ``if` `(i == 0 || j == 0)` `                ``L[i][j] = 0;`   `            ``else` `if` `(str1.at(i - 1) == str2.at(j - 1))` `                ``L[i][j] = L[i - 1][j - 1] + 1;`   `            ``else` `                ``L[i][j] = max(L[i - 1][j], L[i][j - 1]);` `        ``}` `    ``}`   `    ``// L[m][n] contains length of LCS` `    ``// for X[0..n-1] and Y[0..m-1]` `    ``return` `L[m][n];` `}`   `// function to find minimum number` `// of deletions and insertions` `void` `printMinDelAndInsert(string str1, string str2)` `{` `    ``int` `m = str1.size();` `    ``int` `n = str2.size();`   `    ``int` `len = lcs(str1, str2, m, n);`   `    ``cout << ``"Minimum number of deletions = "` `<< (m - len)` `         ``<< endl;`   `    ``cout << ``"Minimum number of insertions = "` `<< (n - len)` `         ``<< endl;` `}`   `// Driver Code` `int` `main()` `{` `    ``string str1 = ``"heap"``;` `    ``string str2 = ``"pea"``;` `  `  `      ``// Function Call` `    ``printMinDelAndInsert(str1, str2);` `    ``return` `0;` `}`

## Java

 `// Dynamic Programming Java implementation` `// to find minimum number of deletions and` `// insertions` `import` `java.io.*;`   `class` `GFG {`   `    ``// Returns length of length common` `    ``// subsequence for str1[0..m-1],` `    ``// str2[0..n-1]` `    ``static` `int` `lcs(String str1, String str2, ``int` `m, ``int` `n)` `    ``{` `        ``int` `L[][] = ``new` `int``[m + ``1``][n + ``1``];` `        ``int` `i, j;`   `        ``// Following steps build L[m+1][n+1] in` `        ``// bottom up fashion. Note that L[i][j]` `        ``// contains length of LCS of str1[0..i-1]` `        ``// and str2[0..j-1]` `        ``for` `(i = ``0``; i <= m; i++) {` `            ``for` `(j = ``0``; j <= n; j++) {` `                ``if` `(i == ``0` `|| j == ``0``)` `                    ``L[i][j] = ``0``;`   `                ``else` `if` `(str1.charAt(i - ``1``)` `                         ``== str2.charAt(j - ``1``))` `                    ``L[i][j] = L[i - ``1``][j - ``1``] + ``1``;`   `                ``else` `                    ``L[i][j] = Math.max(L[i - ``1``][j],` `                                       ``L[i][j - ``1``]);` `            ``}` `        ``}`   `        ``// L[m][n] contains length of LCS` `        ``// for X[0..n-1] and Y[0..m-1]` `        ``return` `L[m][n];` `    ``}`   `    ``// function to find minimum number` `    ``// of deletions and insertions` `    ``static` `void` `printMinDelAndInsert(String str1,` `                                     ``String str2)` `    ``{` `        ``int` `m = str1.length();` `        ``int` `n = str2.length();`   `        ``int` `len = lcs(str1, str2, m, n);`   `        ``System.out.println(``"Minimum number of "` `                           ``+ ``"deletions = "``);` `        ``System.out.println(m - len);`   `        ``System.out.println(``"Minimum number of "` `                           ``+ ``"insertions = "``);` `        ``System.out.println(n - len);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``String str1 = ``new` `String(``"heap"``);` `        ``String str2 = ``new` `String(``"pea"``);` `      `  `          ``// Function Call` `        ``printMinDelAndInsert(str1, str2);` `    ``}` `}` `// This code is contributed by Prerna Saini`

## Python3

 `# Dynamic Programming Python3` `# implementation to find minimum` `# number of deletions and insertions`   `# Returns length of length` `# common subsequence for` `# str1[0..m-1], str2[0..n-1]`     `def` `lcs(str1, str2, m, n):`   `    ``L ``=` `[[``0` `for` `i ``in` `range``(n ``+` `1``)]` `         ``for` `i ``in` `range``(m ``+` `1``)]`   `    ``# Following steps build L[m+1][n+1]` `    ``# in bottom up fashion. Note that` `    ``# L[i][j] contains length of LCS` `    ``# of str1[0..i-1] and str2[0..j-1]` `    ``for` `i ``in` `range``(m ``+` `1``):` `        ``for` `j ``in` `range``(n ``+` `1``):` `            ``if` `(i ``=``=` `0` `or` `j ``=``=` `0``):` `                ``L[i][j] ``=` `0` `            ``elif``(str1[i ``-` `1``] ``=``=` `str2[j ``-` `1``]):` `                ``L[i][j] ``=` `L[i ``-` `1``][j ``-` `1``] ``+` `1` `            ``else``:` `                ``L[i][j] ``=` `max``(L[i ``-` `1``][j],` `                              ``L[i][j ``-` `1``])`   `    ``# L[m][n] contains length of LCS` `    ``# for X[0..n-1] and Y[0..m-1]` `    ``return` `L[m][n]`   `# function to find minimum number` `# of deletions and insertions`     `def` `printMinDelAndInsert(str1, str2):` `    ``m ``=` `len``(str1)` `    ``n ``=` `len``(str2)` `    ``leng ``=` `lcs(str1, str2, m, n)` `    ``print``(``"Minimum number of deletions = "``,` `          ``m ``-` `leng, sep``=``' '``)` `    ``print``(``"Minimum number of insertions = "``,` `          ``n ``-` `leng, sep``=``' '``)`     `# Driver Code` `str1 ``=` `"heap"` `str2 ``=` `"pea"`   `# Function Call` `printMinDelAndInsert(str1, str2)`   `# This code is contributed` `# by sahilshelangia`

## C#

 `// Dynamic Programming C# implementation` `// to find minimum number of deletions and` `// insertions` `using` `System;`   `class` `GFG {`   `    ``// Returns length of length common` `    ``// subsequence for str1[0..m-1],` `    ``// str2[0..n-1]` `    ``static` `int` `lcs(``string` `str1, ``string` `str2, ``int` `m, ``int` `n)` `    ``{` `        ``int``[, ] L = ``new` `int``[m + 1, n + 1];` `        ``int` `i, j;`   `        ``// Following steps build L[m+1][n+1] in` `        ``// bottom up fashion. Note that L[i][j]` `        ``// contains length of LCS of str1[0..i-1]` `        ``// and str2[0..j-1]` `        ``for` `(i = 0; i <= m; i++) {` `            ``for` `(j = 0; j <= n; j++) {` `                ``if` `(i == 0 || j == 0)` `                    ``L[i, j] = 0;`   `                ``else` `if` `(str1[i - 1] == str2[j - 1])` `                    ``L[i, j] = L[i - 1, j - 1] + 1;`   `                ``else` `                    ``L[i, j] = Math.Max(L[i - 1, j],` `                                       ``L[i, j - 1]);` `            ``}` `        ``}`   `        ``// L[m][n] contains length of LCS` `        ``// for X[0..n-1] and Y[0..m-1]` `        ``return` `L[m, n];` `    ``}`   `    ``// function to find minimum number` `    ``// of deletions and insertions` `    ``static` `void` `printMinDelAndInsert(``string` `str1,` `                                     ``string` `str2)` `    ``{` `        ``int` `m = str1.Length;` `        ``int` `n = str2.Length;`   `        ``int` `len = lcs(str1, str2, m, n);`   `        ``Console.Write(``"Minimum number of "` `                      ``+ ``"deletions = "``);` `        ``Console.WriteLine(m - len);`   `        ``Console.Write(``"Minimum number of "` `                      ``+ ``"insertions = "``);` `        ``Console.Write(n - len);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main()` `    ``{` `        ``string` `str1 = ``new` `string``(``"heap"``);` `        ``string` `str2 = ``new` `string``(``"pea"``);` `      `  `          ``// Function Call` `        ``printMinDelAndInsert(str1, str2);` `    ``}` `}`   `// This code is contributed by nitin mittal.`

Output

```Minimum number of deletions = 2
Minimum number of insertions = 1
```

Time Complexity: O(m * n)

This article is contributed by Ayush Jauhari. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.