Skip to content
Related Articles

Related Articles

Minimize changes to make all characters equal by changing vowel to consonant and vice versa

Improve Article
Save Article
  • Last Updated : 31 Oct, 2022
Improve Article
Save Article

Given a string str[] of lower-case characters, the task is to make all characters of the string equal in the minimum number of operations such that in each operation either chooses a vowel and changes it to a consonant or vice-versa.

Examples:

Input: str[] = “geeksforgeeks”
Output: 10
Explanation: To make all the characters equal, make the following changes – 

  1. Change ‘o’ to a consonant(let’s say) ‘z’ and then to ‘e’
  2. Change every other consonant(‘g’, ‘k’, ‘s’, ‘ f’, ‘r’, ) to ‘e’

This results in the string str = “eeeeeeeeeeeee” and the total number of operations performed is 10.

Input: str[] = “coding”
Output: 6

Approach: It can be deduced from the problem that in order to change a consonant to a vowel, 1 operation is required and in order to change a vowel to a vowel or a consonant to a consonant, 2 steps are required as it is needed to change a vowel to a consonant and then again back to a vowel in case of changing a vowel to a vowel or changing a consonant to a vowel and then again back to a consonant in case of changing a consonant to a consonant. The idea would be to maintain two variables –

  • Cv = the cost of changing all the characters to the maximum occurring vowel = no. of consonants + ( total number of vowels – frequency of maximum occurring vowel  ) * 2
  • Cc = the cost of changing all the characters to the maximum occurring consonant = no. of vowels + (total number of consonants – frequency of maximum occurring consonant) * 2

Now the minimum of these 2 i.e., min(Cv, Cc) will give the required minimum number of steps in which we can transform the string. Follow the steps below to solve the problem:

  • Initialize the variable ans, vowels and consonants as 0 to store the answer, number of vowels and the number of consonants.
  • Initialize 2 variables max_vowels and max_consonants as INT_MIN to find the maximum occurring vowel and maximum occurring consonant in the given string.
  • Initialize 2 unordered_map<char, int> freq_vowels[] and freq_consonant[] to store the frequency of vowels and consonants.
  • Iterate over the range [0, N) using the variable i and perform the following steps:
    • If the current character is a vowel, then increase the count of vowels by 1 and it’s frequency in the map by 1 otherwise do it for the consonant.
  • Traverse both the unordered_maps and find the maximum occurring vowel and consonant.
  • Using the above formula, calculate the ans.
  • After performing the above steps, print the value of ans as the answer.

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 number
// of steps to make all characters equal
int operations(string s)
{
 
    // Initializing the variables
    int ans = 0;
    int vowels = 0, consonants = 0;
    int max_vowels = INT_MIN;
    int max_consonants = INT_MIN;
 
    // Store the frequency
    unordered_map<char, int> freq_consonants;
    unordered_map<char, int> freq_vowels;
 
    // Iterate over the string
    for (int i = 0; i < s.size(); i++) {
        if (s[i] == 'a' or s[i] == 'e' or s[i] == 'i'
            or s[i] == 'o' or s[i] == 'u') {
 
            // Calculate the total
            // number of vowels
            vowels += 1;
 
            // Storing frequency of
            // each vowel
            freq_vowels[s[i]] += 1;
        }
        else {
 
            // Count the consonants
            consonants += 1;
 
            // Storing the frequency of
            // each consonant
            freq_consonants[s[i]] += 1;
        }
    }
 
    // Iterate over the 2 maps
    for (auto it = freq_consonants.begin();
         it != freq_consonants.end(); it++) {
 
        // Maximum frequency of consonant
        max_consonants = max(
            max_consonants,
            it->second);
    }
    for (auto it = freq_vowels.begin();
         it != freq_vowels.end(); it++) {
 
        // Maximum frequency of vowel
        max_vowels
            = max(max_vowels,
                  it->second);
    }
 
    // Find the result
    ans = min((2 * (vowels - max_vowels)
               + consonants),
              (2 * (consonants - max_vowels)
               + consonants));
 
    return ans;
}
 
// Driver Code
int main()
{
    string S = "geeksforgeeks";
    cout << operations(S);
 
    return 0;
}

Java




// Java program to implement the above approach
import java.io.*;
import java.util.*;
 
class GFG {
 
  // Function to find the minimum number of steps to make
  // all characters equal
  static int operations(String s)
  {
 
    // Initializign the variables
    int ans = 0;
    int vowels = 0, consonants = 0;
    int max_vowels = Integer.MIN_VALUE;
    int max_consonants = Integer.MIN_VALUE;
 
    // Store the frequency
    HashMap<Character, Integer> freq_consonants
      = new HashMap<>();
    HashMap<Character, Integer> freq_vowels
      = new HashMap<>();
 
    // Iterate over the string
    for (int i = 0; i < s.length(); i++) {
      if (s.charAt(i) == 'a' || s.charAt(i) == 'e'
          || s.charAt(i) == 'i' || s.charAt(i) == 'o'
          || s.charAt(i) == 'u') {
 
        // Calculate the total
        // number of vowels
        vowels += 1;
 
        // Storing frequency of
        // each vowel
        freq_vowels.put(
          s.charAt(i),
          freq_vowels.getOrDefault(s.charAt(i), 0)
          + 1);
      }
      else {
 
        // Count the consonants
        consonants += 1;
 
        // Storing the frequency of
        // each consonant
        freq_consonants.put(
          s.charAt(i),
          freq_consonants.getOrDefault(
            s.charAt(i), 0)
          + 1);
      }
    }
 
    // Iterate over the 2 maps
    for (Map.Entry<Character, Integer> it :
         freq_consonants.entrySet()) {
 
      // Maximum frequency of consonant
      max_consonants
        = Math.max(max_consonants, it.getValue());
    }
 
    for (Map.Entry<Character, Integer> it :
         freq_vowels.entrySet()) {
 
      // Maximum frequency of vowel
      max_vowels
        = Math.max(max_vowels, it.getValue());
    }
 
    // Find the result
    ans = Math.min(
      (2 * (vowels - max_vowels) + consonants),
      (2 * (consonants - max_vowels) + consonants));
 
    return ans;
  }
 
  public static void main(String[] args)
  {
    String S = "geeksforgeeks";
    System.out.print(operations(S));
  }
}
 
// This code is contributed by lokeshmvs21.

Python3




# Python 3 program for the above approach
import sys
from collections import defaultdict
 
# Function to find the minimum number
# of steps to make all characters equal
def operations(s):
 
    # Initializing the variables
    ans = 0
    vowels = 0
    consonants = 0
    max_vowels = -sys.maxsize-1
    max_consonants = -sys.maxsize-1
 
    # Store the frequency
    freq_consonants = defaultdict(int)
    freq_vowels = defaultdict(int)
 
    # Iterate over the string
    for i in range(len(s)):
        if (s[i] == 'a' or s[i] == 'e' or s[i] == 'i'
                or s[i] == 'o' or s[i] == 'u'):
 
            # Calculate the total
            # number of vowels
            vowels += 1
 
            # Storing frequency of
            # each vowel
            freq_vowels[s[i]] += 1
 
        else:
 
            # Count the consonants
            consonants += 1
 
            # Storing the frequency of
            # each consonant
            freq_consonants[s[i]] += 1
 
    # Iterate over the 2 maps
    for it in freq_consonants:
 
        # Maximum frequency of consonant
        max_consonants = max(
            max_consonants,
            freq_consonants[it])
 
    for it in freq_vowels:
 
        # Maximum frequency of vowel
        max_vowels = max(max_vowels,
                         freq_vowels[it])
 
    # Find the result
    ans = min((2 * (vowels - max_vowels)
               + consonants),
              (2 * (consonants - max_vowels)
               + consonants))
 
    return ans
 
# Driver Code
if __name__ == "__main__":
 
    S = "geeksforgeeks"
    print(operations(S))
 
    # This code is contributed by ukasp.

Javascript




<script>
        // JavaScript Program to implement
        // the above approach
 
        // Function to find the minimum number
        // of steps to make all characters equal
        function operations(s) {
 
            // Initializing the variables
            let ans = 0;
            let vowels = 0, consonants = 0;
            let max_vowels = Number.MIN_VALUE;
            let max_consonants = Number.MIN_VALUE;
 
            // Store the frequency
            let freq_consonants = new Map();
            let freq_vowels = new Map();
 
            // Iterate over the string
            for (let i = 0; i < s.length; i++)
            {
                if (s.charAt(i) == 'a' || s.charAt(i) == 'e' || s.charAt(i) == 'i'
                    || s.charAt(i) == 'o' || s.charAt(i) == 'u') {
 
                    // Calculate the total
                    // number of vowels
                    vowels += 1;
 
                    // Storing frequency of
                    // each vowel
                    if (freq_vowels.has(s.charAt(i))) {
                        freq_vowels.set(s.charAt(i), freq_vowels.get(s.charAt(i)) + 1)
                    }
                    else {
                        freq_vowels.set(s.charAt(i), 1);
                    }
 
                }
                else {
 
                    // Count the consonants
                    consonants += 1;
 
                    // Storing the frequency of
                    // each consonant
                    if (freq_consonants.has(s.charAt(i))) {
                        freq_consonants.set(s.charAt(i), freq_consonants.get(s.charAt(i)) + 1)
                    }
                    else {
                        freq_consonants.set(s.charAt(i), 1);
                    }
 
                }
            }
 
            // Iterate over the 2 maps
            for (let [key, value] of freq_consonants) {
 
                // Maximum frequency of consonant
                max_consonants = Math.max(
                    max_consonants,
                    value);
            }
            for (let [key1, value1] of freq_vowels) {
 
                // Maximum frequency of vowel
                max_vowels
                    = Math.max(max_vowels,
                        value1);
            }
 
            // Find the result
            ans = Math.min((2 * (vowels - max_vowels)
                + consonants),
                (2 * (consonants - max_vowels)
                    + consonants));
 
            return ans;
        }
 
        // Driver Code
        let S = "geeksforgeeks";
        document.write(operations(S));
 
     // This code is contributed by Potta Lokesh
    </script>

Output: 

10

 

Time Complexity: O(N)
Auxiliary Space: O(1) as it is using constant space for variables and map to store frequency of characters


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!