Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Minimum insertions or deletions required to make two strings K-equivalent

  • Difficulty Level : Expert
  • Last Updated : 23 Apr, 2021

Given two strings str1 and str2, the task is to find the minimum number of operations required to map each character of the string str1 to K ( < 1000) similar characters of the string str2 by either inserting a character into str2 or by removing a character from str2.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: str1 = “aab”, str2 = “aaaabb”
Output: 0
Explanation: 
Map {str2[0], str2[1]} to str1[0] 
Map {str2[2], str2[3]} to str1[1]. 
Map {str2[4], str2[5]} to str1[2] 
Since no operations are required to map each character of str1 to K(= 2) similar characters of str2. 
Therefore, the required output is 0.



Input: str1 = “aaa”, str2 = “bbb”
Output: 6
Explanation: 
Removing str2[0], str2[1], str2[2] and inserting “aaa” modifies str2 to “aaa”. 
Map { str2[0] } to str1[0], str2[1] to str1[1] and {str2[2]} to str1[2]. 
Therefore, the required output is 6.

 

Approach: To solve this problem, select the best value of K such that the number of operations required is minimum. To select the optimal value of K, iterate over all possible values of K and keep a track of the count of operations required for each of them. Finally, print the minimum count obtained. Follow the steps below to solve the problem:

  1. Initialize two arrays, say a1[] and a2[], to store the frequency of each distinct character of str1 and str2 respectively.
  2. Iterate over all possible values of K and keep a track of minimum till now in ans:
    • Iterate over the range [0, 25] and check the following conditions:
      • If a character is not present in str1 and present in str2, then all these characters should be removed from str2. Hence, the count should be updated accordingly.
      • If a character is present in str1, then update the count by the absolute difference of frequency of that character in str2 and the current value of K multiplied by the frequency of that character in str1.
    • Update the ans with the count.
  3. Finally, print the count obtained, i.e. ans

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find minimum count of operations
// required to map each character of str1 to K
// same characters of str2
int minOperations(string str1, string str2)
{
 
    // Store frequency of each
    // distinct character of str1
    int a1[26] = { 0 };
 
    // Store frequency of each
    // distinct character of str2
    int a2[26] = { 0 };
 
    // Iterate over each character
    // of the string, str1
    for (auto x : str1) {
 
        // Update frequency of
        // current character
        a1[x - 'a']++;
    }
 
    // Iterate over each character
    // of the string, str2
    for (auto x : str2) {
 
        // Update frequency of
        // current character
        a2[x - 'a']++;
    }
 
    // Stores minimum count of operations
    // required to map each character of
    // str1 to K same characters of str2
    int ans = INT_MAX;
 
    // Iterate over all
    // possible values of K
    for (int k = 1; k < 1001; k++) {
 
        // Stores count of operations required
        // to map each character of str1 to k
        // same characters of str2
        int count = 0;
 
        // Iterate over possible characters
        for (int i = 0; i < 26; i++) {
 
            // If (i + 'a') is not
            // present in str1
            if (a1[i] == 0) {
 
                // Update count by removing
                // character from str2
                count += a2[i];
            }
 
            // If a character is
            // present in str1
            else {
 
                // Update count by inserting
                // character into str2
                count += abs(a1[i] * k - a2[i]);
            }
        }
 
        // Update the answer
        ans = min(ans, count);
    }
    return ans;
}
 
// Driver Code
int main()
{
    string str1 = "aaa";
    string str2 = "bbb";
 
    // Function Call
    cout << minOperations(str1, str2) << endl;
 
    return 0;
}
Java



// Java program for the above approach
class GFG
{
  // Function to find minimum count of operations
  // required to map each character of str1 to K
  // same characters of str2
  static int minOperations(String str1, String str2)
  {
 
    // Store frequency of each
    // distinct character of str1
    int[] a1 = new int[26];
 
    // Store frequency of each
    // distinct character of str2
    int[] a2 = new int[26];
 
    // Iterate over each character
    // of the string, str1
    for (int x = 0; x < str1.length(); x++)
    {
 
      // Update frequency of
      // current character
      a1[str1.charAt(x) - 'a']++;
    }
 
    // Iterate over each character
    // of the string, str2
    for (int x = 0; x < str2.length(); x++)
    {
 
      // Update frequency of
      // current character
      a2[str2.charAt(x) - 'a']++;
    }
 
    // Stores minimum count of operations
    // required to map each character of
    // str1 to K same characters of str2
    int ans = Integer.MAX_VALUE;
 
    // Iterate over all
    // possible values of K
    for (int k = 1; k < 1001; k++)
    {
 
      // Stores count of operations required
      // to map each character of str1 to k
      // same characters of str2
      int count = 0;
 
      // Iterate over possible characters
      for (int i = 0; i < 26; i++)
      {
 
        // If (i + 'a') is not
        // present in str1
        if (a1[i] == 0)
        {
 
          // Update count by removing
          // character from str2
          count += a2[i];
        }
 
        // If a character is
        // present in str1
        else
        {
 
          // Update count by inserting
          // character into str2
          count += Math.abs(a1[i] * k - a2[i]);
        }
      }
 
      // Update the answer
      ans = Math.min(ans, count);
    }
    return ans;
  }
 
  // Driver code
  public static void main(String[] args)
  {
    String str1 = "aaa";
    String str2 = "bbb";
 
    // Function Call
    System.out.println(minOperations(str1, str2));
  }
}
 
// This code is contributed by divyeshrabadiya07
Python3



# Python program for the above approach
 
# Function to find minimum count of operations
# required to map each character of str1 to K
# same characters of str2
import sys
def minOperations(str1, str2):
 
  # Store frequency of each
    # distinct character of str1
    a1 = [0] * 26;
 
    # Store frequency of each
    # distinct character of str2
    a2 = [0] * 26;
 
    # Iterate over each character
    # of the string, str1
    for x in range(len(str1)):
 
        # Update frequency of
        # current character
        a1[ord(str1[x]) - ord('a')] += 1;
 
    # Iterate over each character
    # of the string, str2
    for x in range(len(str2)):
 
        # Update frequency of
        # current character
        a2[ord(str2[x]) - ord('a')] += 1;
 
    # Stores minimum count of operations
    # required to map each character of
    # str1 to K same characters of str2
    ans = sys.maxsize;
 
    # Iterate over all
    # possible values of K
    for k in range(1, 1001):
 
        # Stores count of operations required
        # to map each character of str1 to k
        # same characters of str2
        count = 0;
 
        # Iterate over possible characters
        for i in range(26):
 
            # If (i + 'a') is not
            # present in str1
            if (a1[i] == 0):
 
                # Update count by removing
                # character from str2
                count += a2[i];
 
 
            # If a character is
            # present in str1
            else:
 
                # Update count by inserting
                # character into str2
                count += abs(a1[i] * k - a2[i]);
 
        # Update the answer
        ans = min(ans, count);
    return ans;
 
# Driver code
if __name__ == '__main__':
    str1 = "aaa";
    str2 = "bbb";
 
    # Function Call
    print(minOperations(str1, str2));
 
# This code is contributed by 29AjayKumar
C#



// C# program for the above approach
using System;
 
class GFG{
     
// Function to find minimum count of operations
// required to map each character of str1 to K
// same characters of str2
static int minOperations(string str1, string str2)
{
     
    // Store frequency of each
    // distinct character of str1
    int[] a1 = new int[26];
   
    // Store frequency of each
    // distinct character of str2
    int[] a2 = new int[26];
   
    // Iterate over each character
    // of the string, str1
    foreach(char x in str1)
    {
         
        // Update frequency of
        // current character
        a1[x - 'a']++;
    }
   
    // Iterate over each character
    // of the string, str2
    foreach(char x in str2)
    {
         
        // Update frequency of
        // current character
        a2[x - 'a']++;
    }
   
    // Stores minimum count of operations
    // required to map each character of
    // str1 to K same characters of str2
    int ans = Int32.MaxValue;
   
    // Iterate over all
    // possible values of K
    for(int k = 1; k < 1001; k++)
    {
         
        // Stores count of operations required
        // to map each character of str1 to k
        // same characters of str2
        int count = 0;
   
        // Iterate over possible characters
        for(int i = 0; i < 26; i++)
        {
             
            // If (i + 'a') is not
            // present in str1
            if (a1[i] == 0)
            {
                 
                // Update count by removing
                // character from str2
                count += a2[i];
            }
   
            // If a character is
            // present in str1
            else
            {
                 
                // Update count by inserting
                // character into str2
                count += Math.Abs(a1[i] * k - a2[i]);
            }
        }
         
        // Update the answer
        ans = Math.Min(ans, count);
    }
    return ans;
}
 
// Driver code
static void Main()
{
    string str1 = "aaa";
    string str2 = "bbb";
     
    // Function Call
    Console.WriteLine(minOperations(str1, str2));
}
}
 
// This code is contributed by divyesh072019
Javascript



<script>
 
    // Javascript program for the above approach
     
    // Function to find minimum count of operations
    // required to map each character of str1 to K
    // same characters of str2
    function minOperations(str1, str2)
    {
 
      // Store frequency of each
      // distinct character of str1
      let a1 = new Array(26);
      a1.fill(0);
       
      // Store frequency of each
      // distinct character of str2
      let a2 = new Array(26);
      a2.fill(0);
       
      // Iterate over each character
      // of the string, str1
      for(let x = 0; x < str1.length; x++)
      {
 
        // Update frequency of
        // current character
        a1[str1[x].charCodeAt() - 'a'.charCodeAt()]++;
      }
 
      // Iterate over each character
      // of the string, str2
      for(let x = 0; x < str2.length; x++)
      {
 
        // Update frequency of
        // current character
        a2[str2[x].charCodeAt() - 'a'.charCodeAt()]++;
      }
 
      // Stores minimum count of operations
      // required to map each character of
      // str1 to K same characters of str2
      let ans = Number.MAX_VALUE;
 
      // Iterate over all
      // possible values of K
      for(let k = 1; k < 1001; k++)
      {
 
        // Stores count of operations required
        // to map each character of str1 to k
        // same characters of str2
        let count = 0;
 
        // Iterate over possible characters
        for(let i = 0; i < 26; i++)
        {
 
          // If (i + 'a') is not
          // present in str1
          if (a1[i] == 0)
          {
 
            // Update count by removing
            // character from str2
            count += a2[i];
          }
 
          // If a character is
          // present in str1
          else
          {
 
            // Update count by inserting
            // character into str2
            count += Math.abs(a1[i] * k - a2[i]);
          }
        }
 
        // Update the answer
        ans = Math.min(ans, count);
      }
      return ans;
    }
     
    let str1 = "aaa";
    let str2 = "bbb";
      
    // Function Call
    document.write(minOperations(str1, str2));
   
</script>
Output: 
6
 
Time Complexity: O(N + 26 * K)
Auxiliary Space: O(N)



My Personal Notes
arrow_drop_up
Previous
Minimize cost of insertions and deletions required to make all array elements equal
Next

Sort an array by left shifting digits of array elements
Recommended Articles
Page :
Minimize insertions or deletions to make frequency of each array element equal to its value
18, Nov 21
Minimize removal or insertions required to make two strings equal
27, Jan 21
Minimum deletions required to make frequency of each letter unique
17, Sep 19
Minimize insertions required to make all characters of a given string equal
03, Feb 21
Minimum deletions required such that any number X will occur exactly X times
20, Jun 19
Minimum number of deletions to make a string palindrome
10, May 17
Minimum number of deletions to make a string palindrome | Set 2
31, Dec 17
Minimum number of deletions so that no two consecutive are same
31, Jul 17
Deletions of "01" or "10" in binary string to make it free from "01" or "10"
01, Mar 19
Minimum number of given operations required to make two strings equal
18, Nov 18
Find the minimum number of preprocess moves required to make two strings equal
15, Feb 19
Minimum number of pairs required to make two strings same
17, May 19
Minimum number of operations required to make two strings equal
07, May 20
Minimum swaps required between two strings to make one string strictly greater than the other
22, Jan 21
Minimum Number of Manipulations required to make two Strings Anagram Without Deletion of Character
28, Aug 17
Minimum number of flips or swaps of adjacent characters required to make two strings equal
12, Jul 21
Minimum Number of Manipulations required to make two Strings Anagram Without Deletion of Character | Set 2
10, Nov 21
Minimum deletions from string to reduce it to string with at most 2 unique characters
20, Nov 18
Minimum Cost of deletions such that string does not contains same consecutive characters
27, Apr 20
Minimum insertions to form shortest palindrome
16, Sep 15
Minimum insertions to form a palindrome with permutations allowed
05, Jul 17
Minimum insertions to form a palindrome | DP-28
29, Apr 13
Minimize replacements or swapping of same indexed characters required to make two given strings palindromic
03, Nov 20
Minimize count of given operations required to make two given strings permutations of each other
23, Sep 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
architgwl2000
@architgwl2000
Vote for difficulty
Current difficulty :
Expert





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!