A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.

Given a binary string **S** of **0s** and **1s**. The task is to make the given string a sequence of alternate characters by using the below operations:

- Remove some prefix from the start and append it to the end.
- Flip some or every bit in the given string.

Print the minimum number of bits to be flipped to make the given string alternating.

**Examples:**

_ S = “001”_Input:

_ 0_Output:

Explanation:

No need to flip any element we can get alternating sequence by using left rotation: 010.

_ S = “000001100”_Input:

_ 3_Output:

Explanation:

Following steps to find minimum flips to get alternating string:

_1. After rotating string 6 times towards left we will get: 100000001 _

2. Now we can apply flip operation as following: 101000001 -> 101010001 -> 101010101

Thus, minimum flips to make string alternating is 3.

**Recommended: Please try your approach on _ {IDE}_ first, before moving on to the solution.**

**Naive Approach:** The naive approach is to take all **N** possible combinations and calculate the minimum number of bits To flip in each of those strings. Print the minimum count among all such combinations.

** Time Complexity:**_ O(N2), where N is the length of the string._

** Auxiliary Space:**_ O(N)_

**Efficient Approach: **This can be solved by observing that the final string will be either of type** “101010…”** or **“010101…”** such that all **1s** will either be at odd positions or at even positions. Follow the below steps to solve the problem:

- Create a prefix sum array where
**pref[i]**means a number of changes required until index i. - Create prefix arrays for both the above patterns.
- Check for every
**i**, if**substring[0, i]**is appended at the end how many characters to be flipped required. - Print the minimum number of flips among all the substrings in the above steps.

Below is the implementation of the above approach:

- Java
- Python3

`// Java program for the above approach`

`**import**`

`java.util.*;`

`**class**`

`GFG {`

`// Function that finds the minimum`

`// number of flips to make the`

`// binary string alternating if`

`// left circular rotation is allowed`

`**static**`

`**int**`

`MinimumFlips(String s,`

`**int**`

`n)`

`{`

`**int**``[] a =`

`**new**`

`**int**``[n];`

`**for**`

`(``**int**`

`i =`

`0``; i < n; i++) {`

`a[i] = (s.charAt(i) ==`

`'1'`

`?`

`1`

`:`

`0``);`

`}`

`// Initialize prefix arrays to store`

`// number of changes required to put`

`// 1s at either even or odd position`

`**int**``[] oddone =`

`**new**`

`**int**``[n +`

`1``];`

`**int**``[] evenone =`

`**new**`

`**int**``[n +`

`1``];`

`oddone[``0``] =`

`0``;`

`evenone[``0``] =`

`0``;`

`**for**`

`(``**int**`

`i =`

`0``; i < n; i++) {`

`// If i is odd`

`**if**`

`(i %`

`2`

`!=`

`0``) {`

`// Update the oddone`

`// and evenone count`

`oddone[i +`

`1``]`

`= oddone[i]`

`+ (a[i] ==`

`1`

`?`

`1`

`:`

`0``);`

`evenone[i +`

`1``]`

`= evenone[i]`

`+ (a[i] ==`

`0`

`?`

`1`

`:`

`0``);`

`}`

`// Else i is even`

`**else**`

`{`

`// Update the oddone`

`// and evenone count`

`oddone[i +`

`1``]`

`= oddone[i]`

`+ (a[i] ==`

`0`

`?`

`1`

`:`

`0``);`

`evenone[i +`

`1``]`

`= evenone[i]`

`+ (a[i] ==`

`1`

`?`

`1`

`:`

`0``);`

`}`

`}`

`// Initialize minimum flips`

`**int**`

`minimum = Math.min(oddone[n],`

`evenone[n]);`

`// Check if substring[0, i] is`

`// appended at end how many`

`// changes will be required`

`**for**`

`(``**int**`

`i =`

`0``; i < n; i++) {`

`**if**`

`(n %`

`2`

`!=`

`0``) {`

`minimum = Math.min(minimum,`

`oddone[n]`

`- oddone[i +`

`1``]`

`+ evenone[i +`

`1``]);`

`minimum = Math.min(minimum,`

`evenone[n]`

`- evenone[i +`

`1``]`

`+ oddone[i +`

`1``]);`

`}`

`}`

`// Return minimum flips`

`**return**`

`minimum;`

`}`

`// Driver Code`

`**public**`

`**static**`

`**void**`

`main(String[] args)`

`{`

`// Given String`

`String S =`

`"000001100"``;`

`// Length of given string`

`**int**`

`n = S.length();`

`// Function call`

`System.out.print(MinimumFlips(S, n));`

`}`

`}`

**Output:**

`3`

** Time Complexity:**_ O(N), where N is the length of the given string._

** Auxiliary Space:**_ O(N)_

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.

Minimum Count of Bit flips required to make a Binary String Palindromic ... Given an integer N, the task is to find the minimum number of bits required to be flipped to convert the binary ... _To make “1100” a palindrome, convert the string to “0110”. _ ... Take two pointers to one at the L.S.B *and another to the *M.S.B.