 Open in App
Not now

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

• Last Updated : 17 Jan, 2023

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 choose a vowel and change 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 statement that in order to change a consonant to a vowel or vice versa, 1 operation is required. In order to change a vowel to a vowel or a consonant to a consonant, 2 operations are required. Because for changing vowel to vowel, first we need to change vowel -> consonant and then consonant -> vowel. Similarly, for changing consonant to consonant, first we need to change consonant -> vowel and then vowel -> consonant . The idea would be to maintain two variables in parallel :-

• 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 ``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 freq_consonants``      ``= ``new` `HashMap<>();``    ``HashMap 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 it :``         ``freq_consonants.entrySet()) {` `      ``// Maximum frequency of consonant``      ``max_consonants``        ``= Math.max(max_consonants, it.getValue());``    ``}` `    ``for` `(Map.Entry 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

 ``

## C#

 `using` `System;``using` `System.Collections.Generic;` `class` `Program {``    ``// Function to find the minimum number``    ``// of steps to make all characters equal``    ``static` `int` `Operations(``string` `s)``    ``{``        ``// Initializing the variables``        ``int` `ans = 0;``        ``int` `vowels = 0, consonants = 0;``        ``int` `maxVowels = ``int``.MinValue;``        ``int` `maxConsonants = ``int``.MinValue;` `        ``// Store the frequency``        ``var` `freqConsonants = ``new` `Dictionary<``char``, ``int``>();``        ``var` `freqVowels = ``new` `Dictionary<``char``, ``int``>();` `        ``// Iterate over the string``        ``for` `(``int` `i = 0; i < s.Length; i++) {``            ``if` `(s[i] == ``'a'` `|| s[i] == ``'e'` `|| s[i] == ``'i'``                ``|| s[i] == ``'o'` `|| s[i] == ``'u'``) {``                ``// Calculate the total``                ``// number of vowels``                ``vowels += 1;` `                ``// Storing frequency of``                ``// each vowel``                ``if` `(!freqVowels.ContainsKey(s[i])) {``                    ``freqVowels[s[i]] = 1;``                ``}``                ``else` `{``                    ``freqVowels[s[i]] += 1;``                ``}``            ``}``            ``else` `{``                ``// Count the consonants``                ``consonants += 1;` `                ``// Storing the frequency of``                ``// each consonant``                ``if` `(!freqConsonants.ContainsKey(s[i])) {``                    ``freqConsonants[s[i]] = 1;``                ``}``                ``else` `{``                    ``freqConsonants[s[i]] += 1;``                ``}``            ``}``        ``}` `        ``// Iterate over the 2 dictionaries``        ``foreach``(``var` `pair ``in` `freqConsonants)``        ``{``            ``// Maximum frequency of consonant``            ``maxConsonants``                ``= Math.Max(maxConsonants, pair.Value);``        ``}``        ``foreach``(``var` `pair ``in` `freqVowels)``        ``{``            ``// Maximum frequency of vowel``            ``maxVowels = Math.Max(maxVowels, pair.Value);``        ``}` `        ``// Find the result``        ``ans = Math.Min(``            ``(2 * (vowels - maxVowels) + consonants),``            ``(2 * (consonants - maxVowels) + consonants));` `        ``return` `ans;``    ``}` `    ``// Driver Code``    ``static` `void` `Main()``    ``{``        ``string` `S = ``"geeksforgeeks"``;``        ``Console.WriteLine(Operations(S));``    ``}``}`

Output:

`10`

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

My Personal Notes arrow_drop_up