 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
Related Articles