GeeksforGeeks App
Open App
Browser
Continue

# Minimize replacement of bits to make the count of 01 substring equal to 10 substring

Given a binary string str. The task is to minimize the number of replacements of ‘0’ by ‘1’ or ‘1’ by ‘0’ to balance the binary string. A binary string is said to be balanced: “if the number of “01” substring = number of “10” substring”.

Examples:

Input: str = “101010”
Output: 1
Explanation: “01” = 2  & “10” = 3. So change the last character to ‘1’. The modified string will be “101011” or “001010”.

Input: str = “0000100” // balanced, “01” = 1 & “10” = 1
Output: 0
Explanation: The string is already balanced.

Approach: One can notice that “the balanced binary string will always have it’s first character equals to last character of string.”
Only one step is required to balance it, that is s.back() = s.front(). See the proof provided below

Proof:

Above Approach can be proved by using Principle of Mathematical Induction.
NOTE: In below proof, all the cases where first character equals to last character are considered.

for n = 0    —>  empty string “”                                  // count of “10” = 0 & count of “01” = 0
for n = 1    —>  “0” or “1”                                          // count of “10” = 0 & count of “01” = 0
for n = 2    —>  “00” or “11”                                      // count of “10” = 0 & count of “01” = 0
for n = 3

—>  “000”    // count of “10” = 0 & count of “01” = 0
or     “111”    // count of “10” = 0 & count of “01” = 0
or     “010”    // count of “10” = 1 & count of “01” = 1
or     “101”    // count of “10” = 1 & count of “01” = 1

Hence, By  the principle of mathematical induction it will be true for every n, where n is a natural number.

Below is the implementation of the above approach.

## C++

 `// C++ code to implement above approach``#include ``using` `namespace` `std;` `// Function to count the minimum``// number of replacements``int` `minimizeReplacements(string str)``{``    ``unordered_map count;``    ``string temp;``    ` `    ``// Loop to count the minimum number``    ``// of replacements required``    ``for` `(``int` `i = 0; i <``        ``str.length() - 1; i++) {``        ``temp = str.substr(i, 2);``        ``count[temp]++;``    ``}` `    ``return` `abs``(count[``"10"``] - count[``"01"``]);``}` `// Driver code``int` `main()``{``    ``// Given string``    ``string str = ``"101010"``;``    ``cout << minimizeReplacements(str) << endl;``    ``return` `0;``}`

## Java

 `// Java code to implement above approach``import` `java.util.HashMap;` `class` `GFG{` `// Function to count the minimum``// number of replacements``static` `int` `minimizeReplacements(String str)``{``    ``HashMap count = ``new` `HashMap();``    ``String temp;` `    ``// Loop to count the minimum number``    ``// of replacements required``    ``for``(``int` `i = ``0``; i < str.length() - ``1``; i++)``    ``{``        ``temp = str.substring(i, i + ``2``);``        ``if` `(count.containsKey(temp))``            ``count.put(temp, count.get(temp) + ``1``);``        ``else``            ``count.put(temp, ``1``);``    ``}``    ``return` `Math.abs(count.get(``"10"``) - count.get(``"01"``));``}` `// Driver code``public` `static` `void` `main(String args[])``{``    ` `    ``// Given string``    ``String str = ``"101010"``;``    ``System.out.print(minimizeReplacements(str));``}``}` `// This code is contributed by gfgking`

## Python3

 `# Python code for the above approach` `# Function to count the minimum``# number of replacements``def` `minimizeReplacements(``str``):``    ``count ``=` `{}``    ``temp ``=` `""` `   ``# Loop to count the minimum number``   ``# of replacements required``    ``for` `i ``in` `range``(``0``, ``len``(``str``)``-``1``):``        ``temp ``=` `str``[i: i``+``2``]``        ``if` `temp ``in` `count:``            ``count[temp] ``=` `count[temp] ``+` `1``        ``else``:``            ``count[temp] ``=` `1``    ``return` `abs``(count[``"10"``] ``-` `count[``"01"``])` `    ``# Driver code` `    ``# Given string``str` `=` `"101010"``print``(minimizeReplacements(``str``))` `# This code is contributed by Potta Lokesh`

## C#

 `// C# code to implement above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG``{``  ` `    ``// Function to count the minimum``    ``// number of replacements``    ``static` `int` `minimizeReplacements(``string` `str)``    ``{``        ``Dictionary<``string``, ``int``> count``            ``= ``new` `Dictionary<``string``, ``int``>();``        ``string` `temp;` `        ``// Loop to count the minimum number``        ``// of replacements required``        ``for` `(``int` `i = 0; i < str.Length - 1; i++) {``            ``temp = str.Substring(i, 2);``            ``if` `(count.ContainsKey(temp))``                ``count[temp]++;``            ``else``                ``count[temp] = 1;``        ``}` `        ``return` `Math.Abs(count[``"10"``] - count[``"01"``]);``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``// Given string``        ``string` `str = ``"101010"``;``        ``Console.WriteLine(minimizeReplacements(str));``    ``}``}` `// This code is contributed by ukasp.`

## Javascript

 ``

Output

`1`

Time Complexity: O(N)
Auxiliary Space: O(N), for the map used.

My Personal Notes arrow_drop_up