Minimize count of given operations required to make two given strings permutations of each other

Given two strings str1 and str2, the task is to count the minimum number of operations of the following three types on one of the two strings that are required to make str1 and str2 permutations of each other:

  1. Insert a character into the string.
  2. Remove a character from the string.
  3. Replace a character by another character from the string.

Note: All the above operations are of equal cost.

Examples:

Input: str1 = “geeksforgeeks”, str2 = “geeksforcoder”
Output: 4
Explanation: Rearrange the string str2 to “geeksforcedor”
Replace the value of str1[8] to ‘c’.
Replace the value of str1[10] to ‘d’.
Replace the value of str1[11] to ‘o’.
Replace the value of str1[12] to ‘r’.
Therefore, the required output is 4.

Input: str1 = “geeks”, str2 = “keeg”
Output: 1

 

Approach: The problem can be solved using Hashing to store the frequency of each character of both the string. Below are the observations to solve the problem:



X = Number of characters which are present in both string, str1 and str2.
N1 – X = Number of characters present only in str1.
N2 – X = Number of characters present only in str2.
Total number of replacement operations = min(N1 – X, N2 – X)
Total number of insert/rRemove operations = max(N1 – X, N2 – X) – min(N1 – X, N2 – X).
Therefore, total number of operations = max(N1 – X, N2 – X),

Follow the steps below to solve the problem:

  1. Initialize two arrays, say freq1[] and freq2[] to store the frequency of all the characters of str1 and str2 respectively.
  2. Traverse both the strings and store the frequency of each character of both the strings in arrays freq1[] and freq2[] respectively.
  3. Traverse both the arrays freq1[] and freq2[].
  4. For every ith character, if freq1[i] exceeds freq2[i], then replace freq1[i] to freq1[i] – freq2[i] and set freq2[i] = 0 and vice-versa.
  5. Finally, calculate the sum of the arrays freq1[] and freq2[], and print the maximum between them as the answer

Below is the implement the above approach:
 

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to minimize the count of
// operations to make str1 and str2
// permutations of each other
int ctMinEdits(string str1, string str2)
{
    int N1 = str1.length();
    int N2 = str2.length();
 
    // Store the frequency of
    // each character of str1
    int freq1[256] = { 0 };
    for (int i = 0; i < N1; i++) {
        freq1[str1[i]]++;
    }
 
    // Store the frequency of
    // each character of str2
    int freq2[256] = { 0 };
    for (int i = 0; i < N2; i++) {
        freq2[str2[i]]++;
    }
 
    // Traverse the freq1[] and freq2[]
    for (int i = 0; i < 256; i++) {
 
        // If frequency of character in
        // str1 is greater than str2
        if (freq1[i] > freq2[i]) {
            freq1[i] = freq1[i]
                       - freq2[i];
            freq2[i] = 0;
        }
 
        // Otherwise
        else {
            freq2[i] = freq2[i]
                       - freq1[i];
            freq1[i] = 0;
        }
    }
 
    // Store sum of freq1[]
    int sum1 = 0;
 
    // Store sum of freq2[]
    int sum2 = 0;
 
    for (int i = 0; i < 256; i++) {
        sum1 += freq1[i];
        sum2 += freq2[i];
    }
 
    return max(sum1, sum2);
}
 
// Driver Code
int main()
{
    string str1 = "geeksforgeeks";
    string str2 = "geeksforcoder";
    cout << ctMinEdits(str1, str2);
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to implement
// the above approach
import java.util.*;
import java.io.*;
import java.lang.Math;
 
class GFG{
     
// Function to minimize the count of
// operations to make str1 and str2
// permutations of each other
static int ctMinEdits(String str1, String str2)
{
    int N1 = str1.length();
    int N2 = str2.length();
   
    // Store the frequency of
    // each character of str1
    int freq1[] = new int[256];
    Arrays.fill(freq1, 0);
     
    for(int i = 0; i < N1; i++)
    {
        freq1[str1.charAt(i)]++;
    }
   
    // Store the frequency of
    // each character of str2
    int freq2[] = new int[256];
    Arrays.fill(freq2, 0);
     
    for(int i = 0; i < N2; i++)
    {
        freq2[str2.charAt(i)]++;
    }
   
    // Traverse the freq1[] and freq2[]
    for(int i = 0; i < 256; i++)
    {
         
        // If frequency of character in
        // str1 is greater than str2
        if (freq1[i] > freq2[i])
        {
            freq1[i] = freq1[i] - freq2[i];
            freq2[i] = 0;
        }
   
        // Otherwise
        else
        {
            freq2[i] = freq2[i] - freq1[i];
            freq1[i] = 0;
        }
    }
   
    // Store sum of freq1[]
    int sum1 = 0;
   
    // Store sum of freq2[]
    int sum2 = 0;
   
    for(int i = 0; i < 256; i++)
    {
        sum1 += freq1[i];
        sum2 += freq2[i];
    }
   
    return Math.max(sum1, sum2);
}
 
// Driver Code
public static void main(final String[] args)
{
    String str1 = "geeksforgeeks";
    String str2 = "geeksforcoder";
     
    System.out.println(ctMinEdits(str1, str2));
}
}
 
// This code is contributed by bikram2001jha

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to implement
# the above approach
  
# Function to minimize the count of
# operations to make str1 and str2
# permutations of each other
def ctMinEdits(str1, str2):
     
    N1 = len(str1)
    N2 = len(str2)
  
    # Store the frequency of
    # each character of str1
    freq1 =  [0] * 256
    for i in range(N1):
        freq1[ord(str1[i])] += 1
     
    # Store the frequency of
    # each character of str2
    freq2 = [0] * 256
    for i in range(N2):
        freq2[ord(str2[i])] += 1
     
    # Traverse the freq1[] and freq2[]
    for i in range(256):
  
        # If frequency of character in
        # str1 is greater than str2
        if (freq1[i] > freq2[i]):
            freq1[i] = freq1[i] - freq2[i]
            freq2[i] = 0
  
        # Otherwise
        else:
            freq2[i] = freq2[i] - freq1[i]
            freq1[i] = 0
         
    # Store sum of freq1[]
    sum1 = 0
  
    # Store sum of freq2[]
    sum2 = 0
  
    for i in range(256):
        sum1 += freq1[i]
        sum2 += freq2[i]
     
    return max(sum1, sum2)
 
# Driver Code
str1 = "geeksforgeeks"
str2 = "geeksforcoder"
 
print(ctMinEdits(str1, str2))
 
# This code is contributed by code_hunt

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to implement
// the above approach
using System;
 
class GFG{
      
// Function to minimize the count of
// operations to make str1 and str2
// permutations of each other
static int ctMinEdits(string str1, string str2)
{
    int N1 = str1.Length;
    int N2 = str2.Length;
    
    // Store the frequency of
    // each character of str1
    int[] freq1 = new int[256];
    freq1[0] = str1[0];
      
    for(int i = 0; i < N1; i++)
    {
        freq1[str1[i]]++;
    }
    
    // Store the frequency of
    // each character of str2
    int[] freq2 = new int[256];
    freq2[0] = str2[0];
      
    for(int i = 0; i < N2; i++)
    {
        freq2[str2[i]]++;
    }
    
    // Traverse the freq1[] and freq2[]
    for(int i = 0; i < 256; i++)
    {
         
        // If frequency of character in
        // str1 is greater than str2
        if (freq1[i] > freq2[i])
        {
            freq1[i] = freq1[i] - freq2[i];
            freq2[i] = 0;
        }
    
        // Otherwise
        else
        {
            freq2[i] = freq2[i] - freq1[i];
            freq1[i] = 0;
        }
    }
    
    // Store sum of freq1[]
    int sum1 = 0;
    
    // Store sum of freq2[]
    int sum2 = 0;
    
    for(int i = 0; i < 256; i++)
    {
        sum1 += freq1[i];
        sum2 += freq2[i];
    }
    return Math.Max(sum1, sum2);
}
  
// Driver Code
public static void Main()
{
    string str1 = "geeksforgeeks";
    string str2 = "geeksforcoder";
      
    Console.WriteLine(ctMinEdits(str1, str2));
}
}
 
// This code is contributed by code_hunt

chevron_right


Output: 

4




 

Time Complexity: O(N)
Auxiliary Space: O(1)

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.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

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.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : bikram2001jha, code_hunt