# Minimize flips on adjacent 2 to 3 bits to generate a binary string of all 1s

Given a **binary string** **S** consisting of **0’s** and **1’s**, The task is to find the **minimum** number of **flips** required to generate a binary string of all ones. The flip is performed on either **two** or **three** **adjacent** indices.

**Examples****:**

“0010”Input:S =2Output:Explanation:Operations performed are: 0010->0001 -> 1111

Input:S = “0011110”Output:3Explanation:Operations performed are:0011110 -> 1111110 -> 1111000-> 1111111

**Approach: **The basic idea to solve this problem is to perform flips on the **first** **2** or **3** characters and add the result of recursion with the **next** positions. It’s just a **recursive** brute forcing of all possibilities. For every **index** of the string, try **two adjacent** flips and **three adjacent** flips and then **recurse** on that subproblem. One important thing is that the result is **independent** of the order of the flips.

Follow the below steps to solve the problem:

- If the given string
**doesn’t**consist of any**zeros**then return**“0”**and if there are only “**1’s**” then no flip is needed. - If the given string, at any moment becomes equal to “
**00**” or “**000**” then return “**1**” as only**1**flip is needed to make it all**ones**. - We need a list for storing and comparing
**minimum**possibilities at any moment of the recursive call. - If the string starts with “
**0**” and the length of the string is greater than**2**or**3**then we flip the**first**two or first three characters and**recursively**call again for the**next**index. - If strings start with “
**1**“, we remove it by recursively calling it for the rest of the part. - Now in the case of “
**1**“, if “**0**” is present at the first**two**or**three**positions then we flip the first two or three positions and recursively call for the rest of the part along with appending/adding results to the lists. - Once a cycle is completed we return the
**minimum**of all the elements stored in the list.

Below is the implementation of the above approach:

## Python3

`# Python program for the above approach` `def` `minimumFlips(string):` ` ` ` ` `# No flip needed` ` ` `if` `"0"` `not` `in` `string:` ` ` `return` `0` ` ` ` ` `# Flip the whole string at once` ` ` `if` `string ` `in` `(` `"00"` `, ` `"000"` `):` ` ` `return` `1` ` ` ` ` `# Flip 1st 2 / 3 characters` ` ` `def` `flip(n):` ` ` `return` `string[:n]\` ` ` `.translate({` `48` `: ` `49` `, ` `49` `: ` `48` `})\` ` ` `+` `string[n:]` ` ` ` ` `# For tracking minimum flips` ` ` `flips ` `=` `[` `float` `(` `'inf'` `)]` ` ` ` ` `# Flip if string starts with zero` ` ` `if` `string.startswith(` `"0"` `):` ` ` `# Flip first 2 and call recursively` ` ` `if` `len` `(string) > ` `2` `:` ` ` `flips.append(` `1` `+` `minimumFlips(flip(` `2` `)[` `1` `:]))` ` ` `# Flip first 3 and call recursively` ` ` `if` `len` `(string) > ` `3` `:` ` ` `flips.append(` `1` `+` `minimumFlips(flip(` `3` `)[` `1` `:]))` ` ` `# If string starts with "1"` ` ` `else` `:` ` ` `# No flip + recursion` ` ` `flips.append(minimumFlips(string[` `1` `:]))` ` ` ` ` `# Flip if zero is at 2nd position` ` ` `if` `"0"` `in` `string[:` `2` `]:` ` ` ` ` `# Flip first 2 and call recursively` ` ` `flips.append(` `1` `+` `minimumFlips(flip(` `2` `)))` ` ` ` ` `# Flip if zero is at 2nd position` ` ` `if` `"0"` `in` `string[:` `3` `]:` ` ` ` ` `# Flip first 3 and call recursively` ` ` `flips.append(` `1` `+` `minimumFlips(flip(` `3` `)))` ` ` `return` `min` `(flips)` ` ` `# Driver code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `print` `(minimumFlips(` `"0010"` `))` |

**Output**

2

* Time Complexity*: O(N!)

*: O(N)*

**Auxiliary Space**