 Open in App
Not now

# Minimum moves to make count of lowercase and uppercase letters equal

• Last Updated : 10 Aug, 2021

Given a string, S of even length N, the task is to find the minimum number of moves needed to convert the string to a string consisting of half upper case and half lower case characters.

Examples:

Input: S = “AbcdEf”
Output:
ABcdEf
Explanation:
One possible way to modify the string is by converting the second character to S( =’b’) to an uppercase character. Thereafter, the string modifies to “ABcdEf” which consists of 3 lower case and upper case characters.

Input: S = “ABCdef”
Output:  0
ABCdef

Approach: The idea is to convert only those characters that are extra in any of the cases. Follow the steps below to solve the problem:

• Find the count of the upper case English alphabet and lower case English alphabet and store them in variables, say upper and lower respectively.
• Initialize a variable, say moves as 0, to store the minimum number of moves to modify the string.
• If upper case characters are more, then traverse the string and convert upper case characters into the lower case until both cases characters are equal in number.
• Otherwise, if the lower case characters are more, traverse the string S and convert the lower case characters into the upper case until both cases characters are equal in number.
• Finally, after completing the above steps, print the value of moves as the answer and string S as the modified string.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to calculate minimum` `// number of moves required to` `// convert the string` `void` `minimumTimeToConvertString(string S, ``int` `N)` `{` `    ``// Stores Count of upper and` `    ``// lower case characters` `    ``int` `upper = 0, lower = 0;` `                                                                                                                                     `  `    ``// Traverse the string S` `    ``for` `(``int` `i = 0; i < N; i++) {`   `        ``char` `c = S[i];`   `        ``// If current character is` `        ``// uppercase` `        ``if` `(``isupper``(c)) {`   `            ``// Increment count` `            ``// of Uppercase characters` `            ``upper++;` `        ``}` `        ``// Otherwise,` `        ``else` `{`   `            ``// Increment count` `            ``// of Lowercase characters` `            ``lower++;` `        ``}` `    ``}`   `    ``// Stores minimum number of moves needed` `    ``int` `moves = 0;`   `    ``// If there are more upper` `    ``// case characters` `    ``if` `(upper > N / 2) {`   `        ``int` `i = 0;` `        ``// Iterate until upper is greater` `        ``// than N/2` `        ``while` `(upper > N / 2 && i < N) {`   `            ``// Convert uppercase into` `            ``// lowercase until upper=N/2` `            ``if` `(``isupper``(S[i])) {`   `                ``S[i] += 32;` `                ``moves++;` `                ``upper--;` `                ``lower++;` `            ``}`   `            ``// Increment the pointer` `            ``i++;` `        ``}` `    ``}` `    ``// If there are more lower` `    ``// case characters` `    ``else` `if` `(lower > N / 2) {`   `        ``int` `i = 0;` `        ``// Iterate until lower is greater` `        ``// than N/2` `        ``while` `(lower > N / 2 && i < N) {`   `            ``// Convert lowercase into` `            ``// uppercase until lower=N/2` `            ``if` `(``islower``(S[i])) {`   `                ``S[i] -= 32;` `                ``moves++;` `                ``upper++;` `                ``lower--;` `            ``}`   `            ``// Increment the pointer` `            ``i++;` `        ``}` `    ``}`   `    ``// Print moves required` `    ``cout << moves << endl;`   `    ``// Print resultant string` `    ``cout << S << endl;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given string` `    ``string S = ``"AbcdEf"``;` `    ``int` `N = S.length();`   `    ``// Function call` `    ``minimumTimeToConvertString(S, N);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `class` `GFG{`   `// Function to calculate minimum` `// number of moves required to` `// convert the string` `static` `void` `minimumTimeToConvertString(String S, ``int` `N)` `{` `    `  `    ``// Stores Count of upper and` `    ``// lower case characters` `    ``int` `upper = ``0``, lower = ``0``;`   `    ``// Traverse the string S` `    ``for``(``int` `i = ``0``; i < N; i++)` `    ``{` `        ``char` `c = S.charAt(i);`   `        ``// If current character is` `        ``// uppercase` `        ``if` `(Character.isUpperCase(c))` `        ``{` `            `  `            ``// Increment count` `            ``// of Uppercase characters` `            ``upper++;` `        ``}` `        `  `        ``// Otherwise,` `        ``else` `        ``{` `            `  `            ``// Increment count` `            ``// of Lowercase characters` `            ``lower++;` `        ``}` `    ``}`   `    ``// Stores minimum number of moves needed` `    ``int` `moves = ``0``;`   `    ``// If there are more upper` `    ``// case characters` `    ``if` `(upper > N / ``2``) ` `    ``{` `        ``int` `i = ``0``;` `        `  `        ``// Iterate until upper is greater` `        ``// than N/2` `        ``while` `(upper > N / ``2` `&& i < N) ` `        ``{` `            `  `            ``// Convert uppercase into` `            ``// lowercase until upper=N/2` `            ``if` `(Character.isUpperCase(S.charAt(i))) ` `            ``{` `                ``S = S.substring(``0``, i) + ` `                   ``(``char``)(S.charAt(i) + ``32``) + ` `                        ``S.substring(i + ``1``);` `                ``moves++;` `                ``upper--;` `                ``lower++;` `            ``}`   `            ``// Increment the pointer` `            ``i++;` `        ``}` `    ``}` `    `  `    ``// If there are more lower` `    ``// case characters` `    ``else` `if` `(lower > N / ``2``)` `    ``{` `        ``int` `i = ``0``;` `        `  `        ``// Iterate until lower is greater` `        ``// than N/2` `        ``while` `(lower > N / ``2` `&& i < N) ` `        ``{` `            `  `            ``// Convert lowercase into` `            ``// uppercase until lower=N/2` `            ``if` `(Character.isLowerCase(S.charAt(i)))` `            ``{` `                ``S = S.substring(``0``, i) + ` `                   ``(``char``)(S.charAt(i) - ``32``) + ` `                        ``S.substring(i + ``1``);` `                        `  `                ``moves++;` `                ``upper++;` `                ``lower--;` `            ``}`   `            ``// Increment the pointer` `            ``i++;` `        ``}` `    ``}`   `    ``// Print moves required` `    ``System.out.println(moves);`   `    ``// Print resultant string` `    ``System.out.println(S);` `}`   `// Driver code` `public` `static` `void` `main(String[] args)` `{` `    `  `    ``// Given string` `    ``String S = ``"AbcdEf"``;` `    ``int` `N = S.length();`   `    ``// Function call` `    ``minimumTimeToConvertString(S, N);` `}` `}`   `// This code is contributed by abhinavjain194`

## Python3

 `# Python3 program for the above approach`   `# Function to calculate minimum` `# number of moves required to` `# convert the string` `def` `minimumTimeToConvertString(S, N):` `    `  `    ``S ``=` `[i ``for` `i ``in` `S]` `    `  `    ``# Stores Count of upper and` `    ``# lower case characters` `    ``upper ``=` `0` `    ``lower ``=` `0`   `    ``# Traverse the S` `    ``for` `i ``in` `range``(N):` `        ``c ``=` `S[i]`   `        ``# If current character is` `        ``# uppercase` `        ``if` `(c.isupper()):`   `            ``# Increment count` `            ``# of Uppercase characters` `            ``upper ``+``=` `1` `            `  `        ``# Otherwise,` `        ``else``:`   `            ``# Increment count` `            ``# of Lowercase characters` `            ``lower ``+``=` `1`   `    ``# Stores minimum number of moves needed` `    ``moves ``=` `0`   `    ``# If there are more upper` `    ``# case characters` `    ``if` `(upper > N ``/``/` `2``):` `        ``i ``=` `0` `        `  `        ``# Iterate until upper is greater` `        ``# than N/2` `        ``while` `(upper > N ``/``/` `2` `and` `i < N):`   `            ``# Convert uppercase into` `            ``# lowercase until upper=N/2` `            ``if` `(S[i].isupper()):` `                ``S[i] ``+``=` `32` `                ``moves ``+``=` `1` `                ``upper ``-``=` `1` `                ``lower ``+``=` `1`   `            ``# Increment the pointer` `            ``i ``+``=` `1` `            `  `    ``# If there are more lower` `    ``# case characters` `    ``elif` `(lower > N ``/``/` `2``):` `        ``i ``=` `0` `        `  `        ``# Iterate until lower is greater` `        ``# than N/2` `        ``while` `(lower > N ``/``/` `2` `and` `i < N):`   `            ``# Convert lowercase into` `            ``# uppercase until lower=N/2` `            ``if` `(S[i].islower()):` `                ``S[i] ``=` `chr``(``ord``(S[i]) ``-` `32``)` `                ``moves ``+``=` `1` `                ``upper ``+``=` `1` `                ``lower ``-``=` `1`   `            ``# Increment the pointer` `            ``i ``+``=` `1`   `    ``# Print moves required` `    ``print``(moves)`   `    ``# Print resultant string` `    ``print``("".join(S))`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``# Given string` `    ``S ``=` `"AbcdEf"` `    ``N ``=` `len``(S)`   `    ``# Function call` `    ``minimumTimeToConvertString(S, N)`   `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach` `using` `System;` `class` `GFG {` `    `  `    ``// Function to calculate minimum` `    ``// number of moves required to` `    ``// convert the string` `    ``static` `void` `minimumTimeToConvertString(``char``[] S, ``int` `N)` `    ``{` `        ``// Stores Count of upper and` `        ``// lower case characters` `        ``int` `upper = 0, lower = 0;` `                                                                                                                                          `  `        ``// Traverse the string S` `        ``for` `(``int` `i = 0; i < N; i++) {` `     `  `            ``char` `c = S[i];` `     `  `            ``// If current character is` `            ``// uppercase` `            ``if` `(Char.IsUpper(c)) {` `     `  `                ``// Increment count` `                ``// of Uppercase characters` `                ``upper++;` `            ``}` `            ``// Otherwise,` `            ``else` `{` `     `  `                ``// Increment count` `                ``// of Lowercase characters` `                ``lower++;` `            ``}` `        ``}` `     `  `        ``// Stores minimum number of moves needed` `        ``int` `moves = 0;` `     `  `        ``// If there are more upper` `        ``// case characters` `        ``if` `(upper > N / 2) {` `     `  `            ``int` `i = 0;` `            ``// Iterate until upper is greater` `            ``// than N/2` `            ``while` `(upper > N / 2 && i < N) {` `     `  `                ``// Convert uppercase into` `                ``// lowercase until upper=N/2` `                ``if` `(Char.IsUpper(S[i])) {` `     `  `                    ``S[i] += (``char``)32;` `                    ``moves++;` `                    ``upper--;` `                    ``lower++;` `                ``}` `     `  `                ``// Increment the pointer` `                ``i++;` `            ``}` `        ``}` `        ``// If there are more lower` `        ``// case characters` `        ``else` `if` `(lower > N / 2) {` `     `  `            ``int` `i = 0;` `            ``// Iterate until lower is greater` `            ``// than N/2` `            ``while` `(lower > N / 2 && i < N) {` `     `  `                ``// Convert lowercase into` `                ``// uppercase until lower=N/2` `                ``if` `(Char.IsLower(S[i])) {` `     `  `                    ``S[i] = (``char``)((``int``)S[i] - 32);` `                    ``moves++;` `                    ``upper++;` `                    ``lower--;` `                ``}` `     `  `                ``// Increment the pointer` `                ``i++;` `            ``}` `        ``}` `     `  `        ``// Print moves required` `        ``Console.WriteLine(moves);` `     `  `        ``// Print resultant string` `        ``Console.WriteLine(``new` `string``(S));` `    ``}`   `  ``static` `void` `Main() {` `    ``// Given string` `    ``string` `S = ``"AbcdEf"``;` `    ``int` `N = S.Length;` ` `  `    ``// Function call` `    ``minimumTimeToConvertString(S.ToCharArray(), N);` `  ``}` `}`   `// This code is contributed by mukesh07.`

## Javascript

 ``

Output

```1
ABcdEf```

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

My Personal Notes arrow_drop_up
Related Articles