Minimum flips required to form given binary string where every flip changes all bits to its right as well

Given a string S, the task is to find minimum flips required to convert an initial binary string consisting of only zeroes to S where every flip of a character flips all succeeding characters as well. 
Examples:

Input: S = “01011” 
Output: 3 
Explanation:
Initial String – “00000” 
Flip the 2nd bit – “01111” 
Flip the 3rd bit – “01000” 
Flip the 4th bit – “01011” 
Total Flips = 3
Input: S = “01001” 
Output: 3 
Explanation:
Initial String – “00000” 
Flip the 2nd bit – “01111” 
Flip the 3rd bit – “01000” 
Flip the 5th bit – “01001” 
Total Flips = 3 

Approach:
In order to solve the problem, follow the steps below: 

• Store ‘1’ in curr initially.
• Traverse S and find the first occurrence of curr. Increase count when curr is encountered. Store ‘0’ if curr is ‘1’ or vice versa.
• Repeat the above step for entire traversal of S.
• Final value of count gives the required answer.

Below is the implementation of the above approach.

C++

// C++ program for the above approach
#include<bits/stdc++.h>
using namespace std;

// Function to return the count
// of minimum flips required
int minFlips(string target)
{
    char curr = '1';
    int count = 0;
    for(int i = 0; i < target.length(); i++)
    {

       // If curr occurs in the final string
       if (target[i] == curr)
       {
           count++;

           // Switch curr to '0' if '1'
           // or vice-versa
           curr = (char)(48 + (curr + 1) % 2);
       }
    }
    return count;
}

// Driver Code
int main()
{
    string S = "011000";

    cout << (minFlips(S));
}

// This code is contributed by rock_cool

Java

// Java program for the above approach
import java.util.Arrays;

public class GFG {
    // Function to return the count of
    // minimum flips required
    public static int minFlips(String target)
    {

        char curr = '1';
        int count = 0;
        for (int i = 0; i < target.length(); i++) {

            // If curr occurs in the final string
            if (target.charAt(i) == curr) {

                count++;

                // Switch curr to '0' if '1'
                // or vice-versa
                curr = (char)(48 + (curr + 1) % 2);
            }
        }

        return count;
    }

    // Driver Code
    public static void main(String args[])
    {

        String S = "011000";
        System.out.println(minFlips(S));
    }
}

Python3

# Python3 program for the above approach

# Function to return the count
# of minimum flips required
def minFlips(target):

    curr = '1'
    count = 0

    for i in range(len(target)):

        # If curr occurs in the final string
        if (target[i] == curr):
            count += 1

            # Switch curr to '0' if '1'
            # or vice-versa
            curr = chr(48 + (ord(curr) + 1) % 2)

    return count

# Driver Code
if __name__ == "__main__":

    S = "011000"

    print(minFlips(S))

# This code is contributed by chitranayal

C#

// C# program for the above approach
using System;

class GFG{

// Function to return the count of
// minimum flips required
public static int minFlips(String target)
{
    char curr = '1';
    int count = 0;
    for(int i = 0; i < target.Length; i++)
    {

       // If curr occurs in the readonly string
       if (target[i] == curr)
       {
           count++;

           // Switch curr to '0' if '1'
           // or vice-versa
           curr = (char)(48 + (curr + 1) % 2);
       }
    }
    return count;
}

// Driver code
public static void Main(String []args)
{
    String S = "011000";
    Console.WriteLine(minFlips(S));
}
}

// This code is contributed by 29AjayKumar

Javascript

<script>

    // Javascript program for the above approach

    // Function to return the count
    // of minimum flips required
    function minFlips(target)
    {
        let curr = '1';
        let count = 0;
        for(let i = 0; i < target.length; i++)
        {

           // If curr occurs in the final string
           if (target[i] == curr)
           {
               count++;

               // Switch curr to '0' if '1'
               // or vice-versa
               curr = String.fromCharCode(48 + (curr.charCodeAt() + 1) % 2);
           }
        }
        return count;
    }

    let S = "011000";

    document.write(minFlips(S));

</script>

Output:

2

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