Skip to content
Related Articles

Related Articles

Improve Article
Minimize cost to convert all occurrences of each distinct character to lowercase or uppercase
  • Last Updated : 08 Jun, 2021

Given a string S consisting of N alphabets and two positive integers L and U, representing the cost of converting any character to lowercase and uppercase respectively, the task is to modify the string S such that every occurrence of the alphabet in the string S is either lowercase or uppercase and the cost of converting the original string to the modified string must be minimum.

Examples:

Input: S = “aabbAA”, L = 1, U = 1
Output: AAbbAA
Explanation:
The cost of converting “aabbAA” to “AAbbAA” is 1*2 = 2, which is minimum among all the possible combinations of conversions.

Input: S = “aApbBp”, L = 1, U = 2
Output: aapbbp

Approach: The given problem can be solved by using the Greedy Approach, the idea is to check if the cost to convert all occurrences of a character to its lowercase is less than that of uppercase, then convert all its occurrences to lowercase. Otherwise, convert all its occurrences to uppercase. Follow the steps below to solve the problem:



  • Store the frequency of all lowercase and uppercase characters in the arrays lowerFreq[26] and upperFreq[26] respectively.
  • Initialize another array say, result[26] as 0 where result[i] = 1 denotes that the ith character needs to be in lowercase, otherwise it needs to be in uppercase.
  • Iterate over the range [0, 25] using the variable i and perform the following steps:
    • Store the cost to convert every occurrence of character i to lowercase and uppercase in variables costLower and costUpper respectively.
    • Find the value of costLower by multiplying the cost to convert 1 character to lowercase, i.e., L with its uppercase frequencies, i.e., upperFreq[i]. Similarly, find the value of costUpper by multiplying U with lowerFreq[i].
    • If the value of costLower < costUpper, then update the value of result[i] to 1.
  • Traverse the string S using the variable i and perform the following steps:
  • After completing the above steps, print the string S as the modified string.

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 the minimum cost
// to convert all distinct characters
// to either uppercase or lowercase
void minimumCost(string s, int L, int U)
{
    // Store the size of the string
    int N = s.size();
 
    string ans = "";
 
    // Stores the frequency of lowercase
    // & uppercase characters respectively
    int lowerFreq[26] = { 0 };
    int upperFreq[26] = { 0 };
 
    // Traverse the string S
    for (int i = 0; i < N; i++) {
 
        // Update uppercase
        // frequency of s[i]
        if (isupper(s[i]))
            upperFreq[s[i] - 'A']++;
 
        // Otherwise, update lowercase
        // frequency of s[i]
        else
            lowerFreq[s[i] - 'a']++;
    }
 
    // Stores if the i-th character
    //should be lowercase or not
    int result[26] = { 0 };
 
    // Iterate over the range [0, 25]
    for (int i = 0; i < 26; i++) {
 
        // If the character is present
        // in the string
        if (lowerFreq[i] != 0
            || upperFreq[i] != 0) {
 
            // Store the cost to convert
            // every occurence of i to
            // uppercase and lowercase
            int costToUpper = U * lowerFreq[i];
            int costToLower = L * upperFreq[i];
 
            // Update result[i] to 1 if
            // lowercase cost is less
            if (costToLower < costToUpper) {
                result[i] = 1;
            }
        }
    }
 
    // Traverse the string S
    for (int i = 0; i < N; i++) {
 
        // Store the index
        // of the character
        int index = 0;
 
        if (islower(s[i]))
            index = s[i] - 'a';
        else
            index = s[i] - 'A';
 
        // Convert the current character
        // to uppercase or lowercase
        // according to the condition
        if (result[index] == 1) {
 
            // Update s[i]
            s[i] = tolower(s[i]);
        }
        else {
 
            // Update s[i]
            s[i] = toupper(s[i]);
        }
    }
 
    // Print the modified string
    cout << s;
}
 
// Driver Code
int main()
{
    string S = "aabbAA";
    int L = 1, U = 1;
    minimumCost(S, L, U);
 
    return 0;
}


Java




// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
 
class GFG{
 
// Function to find the minimum cost
// to convert all distinct characters
// to either uppercase or lowercase
static void minimumCost(String str, int L, int U)
{
     
    // Store the size of the string
    int N = str.length();
    char s[] = str.toCharArray();
 
    String ans = "";
 
    // Stores the frequency of lowercase
    // & uppercase characters respectively
    int lowerFreq[] = new int[26];
    int upperFreq[] = new int[26];
 
    // Traverse the string S
    for(int i = 0; i < N; i++)
    {
         
        // Update uppercase
        // frequency of s[i]
        if (Character.isUpperCase(s[i]))
            upperFreq[s[i] - 'A']++;
 
        // Otherwise, update lowercase
        // frequency of s[i]
        else
            lowerFreq[s[i] - 'a']++;
    }
 
    // Stores if the i-th character
    // should be lowercase or not
    int result[] = new int[26];
 
    // Iterate over the range [0, 25]
    for(int i = 0; i < 26; i++)
    {
         
        // If the character is present
        // in the string
        if (lowerFreq[i] != 0 || upperFreq[i] != 0)
        {
             
            // Store the cost to convert
            // every occurence of i to
            // uppercase and lowercase
            int costToUpper = U * lowerFreq[i];
            int costToLower = L * upperFreq[i];
 
            // Update result[i] to 1 if
            // lowercase cost is less
            if (costToLower < costToUpper)
            {
                result[i] = 1;
            }
        }
    }
 
    // Traverse the string S
    for(int i = 0; i < N; i++)
    {
         
        // Store the index
        // of the character
        int index = 0;
 
        if (Character.isLowerCase(s[i]))
            index = s[i] - 'a';
        else
            index = s[i] - 'A';
 
        // Convert the current character
        // to uppercase or lowercase
        // according to the condition
        if (result[index] == 1)
        {
             
            // Update s[i]
            s[i] = Character.toLowerCase(s[i]);
        }
        else
        {
             
            // Update s[i]
            s[i] = Character.toUpperCase(s[i]);
        }
    }
 
    // Print the modified string
    System.out.println(new String(s));
}
 
// Driver Code
public static void main(String[] args)
{
    String S = "aabbAA";
    int L = 1, U = 1;
    minimumCost(S, L, U);
}
}
 
// This code is contributed by Kingash


Python3




# Python3 program for above approach
 
# Function to find the minimum cost
# to convert all distinct characters
# to either uppercase or lowercase
def minimumCost(s, L, U):
     
    ans = []
 
    # Stores the frequency of lowercase
    # & uppercase characters respectively
    lowerFreq = [0] * 26
    upperFreq = [0] * 26
 
    # Traverse the string S
    for c in s:
        if c.isupper():
 
        # Update uppercase
        # frequency of s[i]
            upperFreq[ord(c) - ord('A')] += 1
 
        # Otherwise, update lowercase
        # frequency of s[i]
        else:
            lowerFreq[ord(c) - ord('a')] += 1
 
    # stores if the i-th character
    # should be lowercase or not
    result = [0] * 26
 
    # Iterate over the range [0, 25]
    for i in range(26):
 
        # If the character is present
        # in the string
        if lowerFreq[i] != 0 or upperFreq[i] != 0:
 
            # Store the cost to convert
            # every occurence of i to
            # uppercase and lowercase
            costToUpper = U * lowerFreq[i];
            costToLower = L * upperFreq[i];
 
            # Update result[i] to 1 if
            # lowercase cost is less
            if costToLower < costToUpper:
                result[i] = 1
 
    # Traverse the string S
    for i in range(len(s)):
 
        # Store the index
        # of the character
        index = 0
 
        if s[i].islower():
            index = ord(s[i]) - ord('a')
        else:
            index = ord(s[i]) - ord('A')
 
        # Convert the current character
        # to uppercase or lowercase
        # according to the condition
        if result[index] == 1:
 
            # Update the character at the
            # ith index of s
            ans.append(s[i].lower())
        else:
 
            # Update the character at the
            # ith index of s
            ans.append(s[i].upper())
 
    s = ''.join(ans)
     
    # Print the modified string
    print(s)
 
# Driver code
S = "aabbAA"
L = 1
U = 1
 
minimumCost(S, L, U)
 
# This code is contributed by Md Zaid Alam


C#




// C# program for the above approach
using System;
 
class GFG {
 
    // Function to find the minimum cost
    // to convert all distinct characters
    // to either uppercase or lowercase
    static void minimumCost(string str, int L, int U)
    {
 
        // Store the size of the string
        int N = str.Length;
        char[] s = str.ToCharArray();
 
        // string ans = "";
 
        // Stores the frequency of lowercase
        // & uppercase characters respectively
        int[] lowerFreq = new int[26];
        int[] upperFreq = new int[26];
 
        // Traverse the string S
        for (int i = 0; i < N; i++) {
 
            // Update uppercase
            // frequency of s[i]
            if (char.IsUpper(s[i]))
                upperFreq[s[i] - 'A']++;
 
            // Otherwise, update lowercase
            // frequency of s[i]
            else
                lowerFreq[s[i] - 'a']++;
        }
 
        // Stores if the i-th character
        // should be lowercase or not
        int[] result = new int[26];
 
        // Iterate over the range [0, 25]
        for (int i = 0; i < 26; i++) {
 
            // If the character is present
            // in the string
            if (lowerFreq[i] != 0 || upperFreq[i] != 0) {
 
                // Store the cost to convert
                // every occurence of i to
                // uppercase and lowercase
                int costToUpper = U * lowerFreq[i];
                int costToLower = L * upperFreq[i];
 
                // Update result[i] to 1 if
                // lowercase cost is less
                if (costToLower < costToUpper) {
                    result[i] = 1;
                }
            }
        }
 
        // Traverse the string S
        for (int i = 0; i < N; i++) {
 
            // Store the index
            // of the character
            int index = 0;
 
            if (char.IsLower(s[i]))
                index = s[i] - 'a';
            else
                index = s[i] - 'A';
 
            // Convert the current character
            // to uppercase or lowercase
            // according to the condition
            if (result[index] == 1) {
 
                // Update s[i]
                s[i] = char.ToLower(s[i]);
            }
            else {
 
                // Update s[i]
                s[i] = char.ToUpper(s[i]);
            }
        }
 
        // Print the modified string
        Console.WriteLine(new string(s));
    }
 
    // Driver Code
    public static void Main(string[] args)
    {
        string S = "aabbAA";
        int L = 1, U = 1;
        minimumCost(S, L, U);
    }
}
 
// This code is contributed by ukasp.


Javascript




<script>
      // JavaScript program for the above approach
      // Function to find the minimum cost
      // to convert all distinct characters
      // to either uppercase or lowercase
      function minimumCost(str, L, U) {
        // Store the size of the string
        var N = str.length;
        var s = str.split("");
 
        // string ans = "";
 
        // Stores the frequency of lowercase
        // & uppercase characters respectively
        var lowerFreq = new Array(26).fill(0);
        var upperFreq = new Array(26).fill(0);
 
        // Traverse the string S
        for (var i = 0; i < N; i++) {
          // Update uppercase
          // frequency of s[i]
          if (s[i] === s[i].toUpperCase())
            upperFreq[s[i].charCodeAt(0) - "A".charCodeAt(0)]++;
          // Otherwise, update lowercase
          // frequency of s[i]
          else lowerFreq[s[i].charCodeAt(0) - "a".charCodeAt(0)]++;
        }
 
        // Stores if the i-th character
        // should be lowercase or not
        var result = new Array(26).fill(0);
 
        // Iterate over the range [0, 25]
        for (var i = 0; i < 26; i++) {
          // If the character is present
          // in the string
          if (lowerFreq[i] !== 0 || upperFreq[i] !== 0) {
            // Store the cost to convert
            // every occurence of i to
            // uppercase and lowercase
            var costToUpper = U * lowerFreq[i];
            var costToLower = L * upperFreq[i];
 
            // Update result[i] to 1 if
            // lowercase cost is less
            if (costToLower < costToUpper) {
              result[i] = 1;
            }
          }
        }
 
        // Traverse the string S
        for (var i = 0; i < N; i++) {
          // Store the index
          // of the character
          var index = 0;
 
          if (s[i] === s[i].toLowerCase())
            index = s[i].charCodeAt(0) - "a".charCodeAt(0);
          else index = s[i].charCodeAt(0) - "A".charCodeAt(0);
 
          // Convert the current character
          // to uppercase or lowercase
          // according to the condition
          if (result[index] === 1)
          {
           
            // Update s[i]
            s[i] = s[i].toLowerCase();
          }
          else
          {
           
            // Update s[i]
            s[i] = s[i].toUpperCase();
          }
        }
 
        // Print the modified string
        document.write(s.join(""));
      }
 
      // Driver Code
      var S = "aabbAA";
      var L = 1,
        U = 1;
      minimumCost(S, L, U);
       
      // This code is contributed by rdtank.
    </script>


Output: 

AAbbAA

 

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.  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 industry experts, please refer DSA Live Classes




My Personal Notes arrow_drop_up
Recommended Articles
Page :