Minimum flips to make all 1s in left and 0s in right | Set 2

Given a binary array, we can flip all the 1 are in the left part and all the 0 to the right part.Calculate the minimum flips required to make all 1s in left and all 0s in right.

Examples :

Input: 1011000  
Output: 1
1 flip is required to make it 1111000.

Input : 00001 
Output : 2
2 flips required to make it 10000.



We have discussed a bitmask based solution in below post. Minimum flips to make all 1s in left and 0s in right | Set 1 (Using Bitmask)

It can be done with O(N) time complexity (where N – number of bits) and O(N) extra memory

  1. Calculate number of flips of ‘0’ needed to be done while moving from left to right to have all ‘1’ in bits.
  2. Calculate number of flips of ‘1’ needed to be done while moving from right to left to have all ‘0’ in bits.
  3. Traversing through all positions between bits and find minimal sum of ‘0’-flips+’1′-flips from both arrays.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to find minimum flips required
// to make all 1s in left and 0s in right.
#include <bits/stdc++.h>
using namespace std;
  
int minimalFilps(string bits)
{
    int n = bits.length();
  
    // two arrays will keep the count for number
    // of 0s' and 1s' to be flipped while 
    // traversing from left to right and right to
    // left respectively
    int flipsFromLeft[n];
    int flipsFromRight[n];
  
    // Fill flipsFromLeft[]
    int flips = 0; 
    for (int i = 0; i < n; i++) {
        if (bits[i] == '0'
            flips++;         
        flipsFromLeft[i] = flips; 
    }
  
    // Fill flipsFromRight[] 
    flips = 0;
    for (int i = n - 1; i >= 0; i--) {
        if (bits[i] == '1'
            flips++;         
        flipsFromRight[i] = flips; 
    }
  
    // initialize minFlip to highest int value. If sum 
    // of leftflip and rightFlip is smaller than minflips, 
    // then update minFlips
    int minFlips = INT_MAX; 
    for (int i = 1; i < n; i++) {
        if (flipsFromLeft[i - 1] + flipsFromRight[i] < minFlips)
            minFlips = flipsFromLeft[i - 1] + flipsFromRight[i];
    }
  
    return minFlips;
}
  
// Driver code
int main()
{
    string bits = "00001";
    cout << minimalFilps(bits) << endl;
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to find minimum flips required
// to make all 1s in left and 0s in right.
import java.io.*;
  
class GFG 
{
    static int minimalFilps(String bits)
    {
        int n = bits.length();
      
        // two arrays will keep the count 
        // for number of 0s' and 1s' to be
        // flipped while traversing from 
        // left to right and right to
        // left respectively
        int flipsFromLeft[] = new int[n];
        int flipsFromRight[] =new int[n] ;
      
        // Fill flipsFromLeft[]
        int flips = 0
        for (int i = 0; i < n; i++) 
        {
            if (bits.charAt(i) == '0'
                flips++;         
            flipsFromLeft[i] = flips; 
        }
      
        // Fill flipsFromRight[] 
        flips = 0;
        for (int i = n - 1; i >= 0; i--) 
        {
            if (bits.charAt(i) == '1'
                flips++;         
            flipsFromRight[i] = flips; 
        }
      
        // initialize minFlip to highest int value. If sum 
        // of leftflip and rightFlip is smaller than minflips, 
        // then update minFlips
        int minFlips = Integer.MAX_VALUE; 
        for (int i = 1; i < n; i++) 
        {
            if (flipsFromLeft[i - 1] + flipsFromRight[i] 
                                              < minFlips)
                minFlips = flipsFromLeft[i - 1
                           + flipsFromRight[i];
        }
      
        return minFlips;
    }
      
    // Driver code
    public static void main (String[] args) 
    {
        String bits = "00001";
        System.out.println(minimalFilps(bits)); 
          
    }
}
  
// This code is contributed by vt_m.

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python 3 program to find minimum flips required
# to make all 1s in left and 0s in right.
import sys
  
def minimalFilps(bits):
    n = len(bits)
  
    # two arrays will keep the count for number
    # of 0s' and 1s' to be flipped while 
    # traversing from left to right and right to
    # left respectively
    flipsFromLeft = [0 for i in range(n)]
    flipsFromRight = [0 for i in range(n)]
  
    # Fill flipsFromLeft[]
    flips = 0
    for i in range(0, n, 1):
        if (bits[i] == '0'):
            flips = flips + 1    
        flipsFromLeft[i] = flips 
      
    # Fill flipsFromRight[] 
    flips = 0
    i = n - 1
    while(i >= 0):
        if (bits[i] == '1'):
            flips = flips + 1
        i = i - 1
        flipsFromRight[i] = flips 
      
    # initialize minFlip to highest int value. 
    # If sum of leftflip and rightFlip is smaller 
    # than minflips, then update minFlips
    minFlips = sys.maxsize 
    for i in range(1, n, 1):
        if (flipsFromLeft[i - 1] + 
            flipsFromRight[i] < minFlips):
            minFlips = (flipsFromLeft[i - 1] + 
                        flipsFromRight[i])
      
    return minFlips
  
# Driver code
if __name__ == '__main__':
    bits = "00001"
    print(minimalFilps(bits))
  
# This code is contributed by
# Surendra_Gangwar

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to find minimum flips required
// to make all 1s in left and 0s in right.
using System;
  
class GFG 
{
    static int minimalFilps(String bits)
    {
        int n = bits.Length;
      
        // two arrays will keep the count 
        // for number of 0s' and 1s' to be
        // flipped while traversing from 
        // left to right and right to
        // left respectively
        int []flipsFromLeft = new int[n];
        int []flipsFromRight =new int[n] ;
      
        // Fill flipsFromLeft[]
        int flips = 0; 
        for (int i = 0; i < n; i++) 
        {
            if (bits[i] == '0'
                flips++;         
            flipsFromLeft[i] = flips; 
        }
      
        // Fill flipsFromRight[] 
        flips = 0;
        for (int i = n - 1; i >= 0; i--) 
        {
            if (bits[i] == '1'
                flips++;         
            flipsFromRight[i] = flips; 
        }
      
        // initialize minFlip to highest int value.
        // If sum of leftflip and rightFlip is smaller
        // than minflips, then update minFlips
        int minFlips = int.MaxValue; 
        for (int i = 1; i < n; i++) 
        {
            if (flipsFromLeft[i - 1] + flipsFromRight[i] < minFlips)
            minFlips = flipsFromLeft[i - 1] + flipsFromRight[i];
        }
      
        return minFlips;
    }
      
    // Driver code
    public static void Main () 
    {
        string bits = "00001";
        Console.WriteLine(minimalFilps(bits)); 
          
    }
}
  
// This code is contributed by vt_m.

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP program to find minimum 
// flips required to make all 
// 1s in left and 0s in right.
  
function minimalFilps($bits)
{
    $n = strlen($bits);
  
    // two arrays will keep the
    // count for number of 0s' 
    // and 1s' to be flipped 
    // while traversing from 
    // left to right and right 
    // to left respectively
    $flipsFromLeft[$n] = 0;
    $flipsFromRight[$n] = 0;
  
    // Fill flipsFromLeft[]
    $flips = 0; 
    for ($i = 0; $i < $n; $i++) {
        if ($bits[$i] == '0'
            $flips++;         
        $flipsFromLeft[$i] = $flips
    }
  
    // Fill flipsFromRight[] 
    $flips = 0;
    for ($i = $n - 1; $i >= 0; $i--) 
    {
        if ($bits[$i] == '1'
            $flips++;         
        $flipsFromRight[$i] = $flips
    }
  
    // initialize minFlip to 
    // highest int value. If sum 
    // of leftflip and rightFlip 
    // is smaller than minflips, 
    // then update minFlips
    $INT_MAX=2147483647;
    $minFlips = $INT_MAX
    for ($i = 1; $i < $n; $i++) 
    {
        if ($flipsFromLeft[$i - 1] + 
            $flipsFromRight[$i] < $minFlips)
            $minFlips = $flipsFromLeft[$i - 1] + 
                        $flipsFromRight[$i];
    }
  
    return $minFlips;
}
  
    // Driver Code
    $bits = "00001";
    echo minimalFilps($bits) ;
  
// This code is contributed by nitin mittal.
?>

chevron_right



Output:

2


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.





Article Tags :
Practice Tags :


1


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.