# Minimum toggles to partition a binary array so that it has first 0s then 1s

Given an array of n integers containing only 0 and 1. Find the minimum toggles (switch from 0 to 1 or vice-versa) required such the array the array become partitioned, i.e., it has first 0s then 1s. There should be at least one 0 in the beginning, and there can be zero or more 1s in the end.

```Input: arr[] = {1, 0, 1, 1, 0}
Output: 2
Toggle the first and last element i.e.,
1 -> 0
0 -> 1
Final array will become:
arr[] = {0 0 1 1 1}
Since first two consecutive elements are all 0s
and rest three consecutive elements are all 1s.
Therefore minimum two toggles are required.

Input: arr[] = {0, 1, 0, 0, 1, 1, 1}
Output: 1

Input: arr[] = {1, 1}
Output: 1
There should be at least one 0.

Input: arr[] = {0, 0}
Output: 0
There can zero 1s.
```

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

If we observe the question then we will find that there will definitely exist a point from 0 to n-1 where all elements left to that point should contains all 0’s and right to point should contains all 1’s. Those indices which don’t obey this law will have to be removed. The idea is to count all 0s from left to right.

```Let zero[i] denotes the number of 0's till ith
index, then for each i, minimum number of
toggles required can be written as: i - zero[i]
+ zero[n] - zero[i] . The part i - zero[i]
indicates number of 1's to be toggled and the
part zero[n] - zero[i] indicates number of 0's
to be toggled.

After that we just need to take minimum of
all to get the final answer.
```

## C++

 `// C++ program to find minimum toggle required ` `#include ` `using` `namespace` `std; ` ` `  `// Function to calculate minimum toggling ` `// required by using Dynamic programming ` `int` `minToggle(``int` `arr[], ``int` `n) ` `{ ` `    ``int` `zero[n + 1]; ` `    ``zero = 0; ` ` `  `    ``// Fill entries in zero[] such that zero[i] ` `    ``// stores count of zeroes to the left of i ` `    ``// (exl ` `    ``for` `(``int` `i = 1; i <= n; ++i) { ` `        ``// If zero found update zero[] array ` `        ``if` `(arr[i - 1] == 0) ` `            ``zero[i] = zero[i - 1] + 1; ` `        ``else` `            ``zero[i] = zero[i - 1]; ` `    ``} ` ` `  `    ``// Finding the minimum toggle required from ` `    ``// every index(0 to n-1) ` `    ``int` `ans = n; ` `    ``for` `(``int` `i = 1; i <= n; ++i) ` `        ``ans = min(ans, i - zero[i] + zero[n] - zero[i]); ` ` `  `    ``return` `ans; ` `} ` ` `  `// Driver Program ` `int` `main() ` `{ ` `    ``int` `arr[] = { 1, 0, 1, 1, 0 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``cout << minToggle(arr, n) << ``"\n"``; ` `    ``return` `0; ` `} `

## Java

 `// Java program to find minimum ` `// toggle required ` `import` `java.io.*; ` ` `  `class` `GFG { ` ` `  `    ``// Function to calculate minimum toggling ` `    ``// required by using Dynamic programming ` `    ``static` `int` `minToggle(``int` `arr[], ``int` `n) ` `    ``{ ` `        ``int` `zero[] = ``new` `int``[n + ``1``]; ` `        ``zero[``0``] = ``0``; ` ` `  `        ``// Fill entries in zero[] such that ` `        ``// zero[i] stores count of zeroes ` `        ``// to the left of i (exl ` `        ``for` `(``int` `i = ``1``; i <= n; ++i) { ` `            ``// If zero found update zero[] array ` `            ``if` `(arr[i - ``1``] == ``0``) ` `                ``zero[i] = zero[i - ``1``] + ``1``; ` `            ``else` `                ``zero[i] = zero[i - ``1``]; ` `        ``} ` ` `  `        ``// Finding the minimum toggle required ` `        ``// from every index(0 to n-1) ` `        ``int` `ans = n; ` `        ``for` `(``int` `i = ``1``; i <= n; ++i) ` `            ``ans = Math.min(ans, i - zero[i] + zero[n] ` `                                    ``- zero[i]); ` ` `  `        ``return` `ans; ` `    ``} ` ` `  `    ``// Driver Program ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `arr[] = { ``1``, ``0``, ``1``, ``1``, ``0` `}; ` `        ``int` `n = arr.length; ` `        ``System.out.println(minToggle(arr, n)); ` `    ``} ` `} ` ` `  `// This code is contributed by vt_m. `

## Python3

 `# Python program to find ` `# minimum toggle required ` ` `  `# Function to calculate ` `# minimum toggling ` `# required by using ` `# Dynamic programming ` `def` `minToggle(arr, n): ` ` `  `    ``zero ``=``[``0` `for` `i ``in` `range``(n ``+` `1``+``1``)] ` `    ``zero[``0``] ``=` `0` `  `  `    ``# Fill entries in zero[] ` `    ``# such that zero[i] ` `    ``# stores count of zeroes ` `    ``# to the left of i ` `    ``# (exl ` `    ``for` `i ``in` `range``(``1``, n ``+` `1``): ` `     `  `        ``# If zero found ` `        ``# update zero[] array ` `        ``if` `(arr[i``-``1``] ``=``=` `0``): ` `            ``zero[i] ``=` `zero[i``-``1``] ``+` `1` `        ``else``: ` `            ``zero[i] ``=` `zero[i``-``1``] ` `  `  `    ``# Finding the minimum ` `    ``# toggle required from ` `    ``# every index(0 to n-1) ` `    ``ans ``=` `n ` `    ``for` `i ``in` `range``(``1``, n ``+` `1``): ` `        ``ans ``=` `min``(ans, i ``-` `zero[i] ``+` `zero[n] ``-` `zero[i]) ` `  `  `    ``return` `ans ` `     `  `# Driver Program ` ` `  `arr ``=` `[``1``, ``0``, ``1``, ``1``, ``0``] ` `n ``=` `len``(arr) ` ` `  `print``(minToggle(arr, n)) ` ` `  `# This code is contributed ` `# by Anant Agarwal. `

## C#

 `// C# program to find minimum ` `// toggle required ` `using` `System; ` ` `  `class` `GFG { ` ` `  `    ``// Function to calculate minimum toggling ` `    ``// required by using Dynamic programming ` `    ``static` `int` `minToggle(``int``[] arr, ``int` `n) ` `    ``{ ` `         `  `        ``int``[] zero = ``new` `int``[n + 1]; ` `        ``zero = 0; ` ` `  `        ``// Fill entries in zero[] such that ` `        ``// zero[i] stores count of zeroes ` `        ``// to the left of i (exl ` `        ``for` `(``int` `i = 1; i <= n; ++i) { ` `             `  `            ``// If zero found update zero[] ` `            ``// array ` `            ``if` `(arr[i - 1] == 0) ` `                ``zero[i] = zero[i - 1] + 1; ` `            ``else` `                ``zero[i] = zero[i - 1]; ` `        ``} ` ` `  `        ``// Finding the minimum toggle required ` `        ``// from every index(0 to n-1) ` `        ``int` `ans = n; ` `         `  `        ``for` `(``int` `i = 1; i <= n; ++i) ` `            ``ans = Math.Min(ans, i - zero[i] + ` `                            ``zero[n] - zero[i]); ` ` `  `        ``return` `ans; ` `    ``} ` ` `  `    ``// Driver Program ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int``[] arr = { 1, 0, 1, 1, 0 }; ` `        ``int` `n = arr.Length; ` `         `  `        ``Console.WriteLine(minToggle(arr, n)); ` `    ``} ` `} ` ` `  `// This code is contributed by Sam007. `

## PHP

 ` `

Output:

`2`

Time complexity: O(n)
Auxiliary space: O(n)

This article is contributed by Shubham Bansal. 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.

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.

My Personal Notes arrow_drop_up

Improved By : Sam007, nitin mittal

Article Tags :
Practice Tags :

Be the First to upvote.

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