Convert characters of string1 to characters present in string2 by incrementing or decrementing lexicographically

• Difficulty Level : Basic
• Last Updated : 07 Jan, 2022

Given two strings A and B having lower case English alphabets, the task is to find the number of operations required to convert string A such that it only contains letters that are also in the string B where at each operation, the current character can be changed to either the next character or the previous character. Also, the next character after ‘z‘ is ‘a‘ and the previous character after ‘a‘ is ‘z‘.

Examples:

Input: A = “abcd”, B = “bc”
Output: 2
Explanation: The given string A = “abcd” can be converted into the string “bbcc” by incrementing the 1st character of the string in 1st move and decrementing the last character in 2nd move. Hence, A = “bbcc” has all the characters that are also in string B. Therefore, the required number of moves is 2 which is the minimum possible.

Input: A = “abcde”, B = “yg”
Output: 14

Approach: The given problem can be solved using a greedy approach. The idea is to convert all the characters in string A that are not in the string B into the nearest possible character that exists in string B which can be done by following the below steps:

• Store the frequency of characters of the string B in an unordered map m.
• Iterate through the given string A and check for each character in B, the number of steps required to convert the current character to it.
• The ways to convert a character x to y can be of two different types as follows:
• The 1st one is to increment the character x until y is reached i.e, clockwise rotation.
• The 2nd one is to decrement the character x until y is reached, i.e, anticlockwise rotation.
• Hence, maintain the sum of all the minimum of the moves in clockwise and anticlockwise rotations for each character in A, in a variable ans, which is the required value.

Below is the implementation of the above approach:

C++

 // C++ implementation of the above approach#include using namespace std; // Function to calculate minimum number// of operations required to convert A// such that it only contains letters// in the string Bint minOperations(string a, string b){    // Stores the characters in string B    unordered_map m;    for (int i = 0; i < b.size(); i++) {        m[b[i]]++;    }     // Stores the min count of operations    int ans = 0;     // Loop to iterte the given array    for (int i = 0; i < a.size(); i++) {         // Stores the minimum number of        // moves required for ith index        int mn = INT_MAX;         // Loop to calculate the number        // of moves required to convert        // the current index        for (int j = 0; j < 26; j++) {            int val = a[i] - 'a';             // If the current character            // is also in b            if (m[a[i]] > 0) {                mn = 0;                break;            }            else if (m['a' + j] > 0) {                 // Minimum of abs(val - j),                // clockwise rotation and                // anti clockwise rotation                mn = min(mn, min(abs(val - j),                                 min((26 - val) + j,                                     val + (26 - j))));            }        }         // Update answer        ans += mn;    }     // Return Answer    return ans;} int main(){    string A = "abcde";    string B = "yg";     cout << minOperations(A, B);     return 0;}

Java

 // Java implementation of the above approachimport java.util.*;class GFG{ // Function to calculate minimum number// of operations required to convert A// such that it only contains letters// in the String Bstatic int minOperations(String a, String b){       // Stores the characters in String B    HashMap m = new HashMap();    for (int i = 0; i < b.length(); i++) {         if(m.containsKey(b.charAt(i))){                m.put(b.charAt(i), m.get(b.charAt(i))+1);            }            else{                m.put(b.charAt(i), 1);            }    }     // Stores the min count of operations    int ans = 0;     // Loop to iterte the given array    for (int i = 0; i < a.length(); i++) {         // Stores the minimum number of        // moves required for ith index        int mn = Integer.MAX_VALUE;         // Loop to calculate the number        // of moves required to convert        // the current index        for (int j = 0; j < 26; j++) {            int val = a.charAt(i) - 'a';             // If the current character            // is also in b            if (m.containsKey(a.charAt(i))&&m.get(a.charAt(i)) > 0) {                mn = 0;                break;            }            else if (m.containsKey((char)('a' + j))&&m.get((char)('a' + j)) > 0) {                 // Minimum of Math.abs(val - j),                // clockwise rotation and                // anti clockwise rotation                mn = Math.min(mn, Math.min(Math.abs(val - j),                                 Math.min((26 - val) + j,                                     val + (26 - j))));            }        }         // Update answer        ans += mn;    }     // Return Answer    return ans;} public static void main(String[] args){    String A = "abcde";    String B = "yg";     System.out.print(minOperations(A, B)); }} // This code is contributed by 29AjayKumar

Python3

 # Python3 implementation of the above approachINT_MAX = 2147483647 # Function to calculate minimum number# of operations required to convert A# such that it only contains letters# in the string Bdef minOperations(a, b):         # Stores the characters in string B    m = {}    for i in range(0, len(b)):        if b[i] in m:            m[b[i]] += 1        else:            m[b[i]] = 1     # Stores the min count of operations    ans = 0     # Loop to iterte the given array    for i in range(0, len(a)):                 # Stores the minimum number of        # moves required for ith index        mn = INT_MAX         # Loop to calculate the number        # of moves required to convert        # the current index        for j in range(0, 26):            val = ord(a[i]) - ord('a')             # If the current character            # is also in b            if (a[i] in m and m[a[i]] > 0):                mn = 0                break             elif (chr(ord('a') + j) in m and m[chr(ord('a') + j)] > 0):                                 # Minimum of abs(val - j),                # clockwise rotation and                # anti clockwise rotation                mn = min(mn, min(abs(val - j),                                 min((26 - val) + j,                               val + (26 - j))))         # Update answer        ans += mn     # Return Answer    return ans # Driver codeif __name__ == "__main__":     A = "abcde"    B = "yg"     print(minOperations(A, B)) # This code is contributed by rakeshsahni

C#

 // C# implementation of the above approachusing System;using System.Collections.Generic;class GFG{     // Function to calculate Minimum number    // of operations required to convert A    // such that it only contains letters    // in the String B    static int MinOperations(String a, String b)    {         // Stores the characters in String B        Dictionary m = new Dictionary();        for (int i = 0; i < b.Length; i++)        {            if (m.ContainsKey(b[i]))            {                m[b[i]] += 1;            }            else            {                m[b[i]] = 1;            }        }         // Stores the Min count of operations        int ans = 0;         // Loop to iterte the given array        for (int i = 0; i < a.Length; i++)        {             // Stores the Minimum number of            // moves required for ith index            int mn = int.MaxValue;             // Loop to calculate the number            // of moves required to convert            // the current index            for (int j = 0; j < 26; j++)            {                int val = a[i] - 'a';                 // If the current character                // is also in b                if (m.ContainsKey(a[i]) && m[a[i]] > 0)                {                    mn = 0;                    break;                }                else if (m.ContainsKey((char)('a' + j)) && m[(char)('a' + j)] > 0)                {                     // Minimum of Math.abs(val - j),                    // clockwise rotation and                    // anti clockwise rotation                    mn = Math.Min(mn, Math.Min(Math.Abs(val - j),                                     Math.Min((26 - val) + j,                                         val + (26 - j))));                }            }             // Update answer            ans += mn;        }         // Return Answer        return ans;    }     public static void Main()    {        String A = "abcde";        String B = "yg";         Console.Write(MinOperations(A, B));     }} // This code is contributed by gfgking

Javascript


Output
14

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

My Personal Notes arrow_drop_up