# 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:1Explanation:“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” = 1Output:0Explanation: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 Principal 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” = 1Hence, By the principal of mathematical induction it will be true

for every n, wheren is a natural number.

Below is the implementation of the above approach.

## C++

`// C++ code to implement above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to count the minimum` `// number of replacements` `int` `minimizeReplacements(string str)` `{` ` ` `unordered_map<string, ` `int` `> 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<String, ` ` ` `Integer> count = ` `new` `HashMap<String, ` ` ` `Integer>();` ` ` `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

`<script>` ` ` `// JavaScript code to implement above approach` ` ` `// Function to count the minimum` ` ` `// number of replacements` ` ` `const minimizeReplacements = (str) => {` ` ` `count = {};` ` ` `let temp = ` `""` `;` ` ` `// Loop to count the minimum number` ` ` `// of replacements required` ` ` `for` `(let i = 0; i <` ` ` `str.length - 1; i++) {` ` ` `temp = str.substring(i, i + 2);` ` ` `if` `(temp ` `in` `count) count[temp]++;` ` ` `else` `count[temp] = 1;` ` ` `}` ` ` `return` `Math.abs(count[` `"10"` `] - count[` `"01"` `]);` ` ` `}` ` ` `// Driver code` ` ` `// Given string` ` ` `let str = ` `"101010"` `;` ` ` `document.write(minimizeReplacements(str));` ` ` `// This code is contributed by rakeshsahni` `</script>` |

**Output**

1

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