# 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 minimum number of characters from/in str1 so as 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.

Examples:

```Input : str1 = "heap", str2 = "pea"
Output : Minimum Deletion = 2 and
Minimum Insertion = 1
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.

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

## Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

A simple solution 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.

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
```

## 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 program to test above ` `int` `main() ` `{ ` `  ``string str1 = ``"heap"``; ` `  ``string str2 = ``"pea"``;   ` `  ``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 program to test above ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `    ``String str1 = ``new` `String(``"heap"``); ` `    ``String str2 = ``new` `String(``"pea"``);  ` `    ``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"` `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 program to test above ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``string` `str1 = ``new` `string``(``"heap"``); ` `        ``string` `str2 = ``new` `string``(``"pea"``);  ` `        ``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.