# Minimum Swaps required to group all 1’s together

Given an array of 0’s and 1’s, we need to write a program to find the minimum number of swaps required to group all 1’s present in the array together.

Examples:

```Input : arr[] = {1, 0, 1, 0, 1}
Output : 1
Explanation: Only 1 swap is required to
group all 1's together. Swapping index 1
and 4 will give arr[] = {1, 1, 1, 0, 0}

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

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

A simple solution is to first count total number of 1’s in the array. Suppose this count is x, now we need to find the subarray of length x of this array with maximum number of 1’s. And minimum swaps required will be the number of 0’s in the subarray of length x with maximum number of 1’s.
Time Complexity: O(n2)

An efficient solution is to optimize the brute force technique of finding the subarray in above approach using the concept of sliding window technique. We can maintain a preCount array to find number of 1’s present in a subarray in O(1) time complexity.

Below is the implementation of above idea:

## C++

 `// C++ program to find minimum swaps ` `// required to group all 1's together ` `#include ` `#include ` ` `  `using` `namespace` `std; ` ` `  `// Function to find minimum swaps ` `// to group all 1's together ` `int` `minSwaps(``int` `arr[], ``int` `n) { ` ` `  `  ``int` `noOfOnes = 0; ` ` `  `  ``// find total number of all in the array ` `  ``for` `(``int` `i = 0; i < n; i++) { ` `    ``if` `(arr[i] == 1) ` `      ``noOfOnes++; ` `  ``} ` ` `  `  ``// length of subarray to check for ` `  ``int` `x = noOfOnes; ` ` `  `  ``int` `maxOnes = INT_MIN; ` ` `  `  ``// array to store number of 1's upto ` `  ``// ith index ` `  ``int` `preCompute[n] = {0}; ` ` `  `  ``// calculate number of 1's upto ith ` `  ``// index and store in the array preCompute[] ` `  ``if` `(arr == 1) ` `    ``preCompute = 1; ` `  ``for` `(``int` `i = 1; i < n; i++) { ` `    ``if` `(arr[i] == 1) { ` `      ``preCompute[i] = preCompute[i - 1] + 1; ` `    ``} ``else` `      ``preCompute[i] = preCompute[i - 1]; ` `  ``} ` ` `  `  ``// using sliding window technique to find ` `  ``// max number of ones in subarray of length x ` `  ``for` `(``int` `i = x - 1; i < n; i++) { ` `    ``if` `(i == (x - 1))  ` `      ``noOfOnes = preCompute[i]; ` `    ``else`  `      ``noOfOnes = preCompute[i] - preCompute[i - x]; ` `     `  `    ``if` `(maxOnes < noOfOnes) ` `      ``maxOnes = noOfOnes; ` `  ``} ` ` `  `  ``// calculate number of zeros in subarray ` `  ``// of length x with maximum number of 1's ` `  ``int` `noOfZeroes = x - maxOnes; ` ` `  `  ``return` `noOfZeroes; ` `} ` ` `  `// Driver Code ` `int` `main() { ` `  ``int` `a[] = {1, 0, 1, 0, 1}; ` `  ``int` `n = ``sizeof``(a) / ``sizeof``(a); ` `  ``cout << minSwaps(a, n); ` `  ``return` `0; ` `} `

## Java

 `// Java  program to find minimum swaps ` `// required to group all 1's together ` ` `  `import` `java.io.*; ` ` `  `class` `GFG { ` ` `  `// Function to find minimum swaps ` `// to group all 1's together ` ` ``static` `int` `minSwaps(``int` `arr[], ``int` `n) { ` ` `  `int` `noOfOnes = ``0``; ` ` `  `// find total number of all in the array ` `for` `(``int` `i = ``0``; i < n; i++) { ` `    ``if` `(arr[i] == ``1``) ` `    ``noOfOnes++; ` `} ` ` `  `// length of subarray to check for ` `int` `x = noOfOnes; ` ` `  `int` `maxOnes = Integer.MIN_VALUE; ` ` `  `// array to store number of 1's upto ` `// ith index ` `int` `preCompute[] = ``new` `int``[n]; ` ` `  `// calculate number of 1's upto ith ` `// index and store in the array preCompute[] ` `if` `(arr[``0``] == ``1``) ` `    ``preCompute[``0``] = ``1``; ` `for` `(``int` `i = ``1``; i < n; i++) { ` `    ``if` `(arr[i] == ``1``) { ` `    ``preCompute[i] = preCompute[i - ``1``] + ``1``; ` `    ``} ``else` `    ``preCompute[i] = preCompute[i - ``1``]; ` `} ` ` `  `// using sliding window technique to find ` `// max number of ones in subarray of length x ` `for` `(``int` `i = x - ``1``; i < n; i++) { ` `    ``if` `(i == (x - ``1``))  ` `    ``noOfOnes = preCompute[i]; ` `    ``else` `    ``noOfOnes = preCompute[i] - preCompute[i - x]; ` `     `  `    ``if` `(maxOnes < noOfOnes) ` `    ``maxOnes = noOfOnes; ` `} ` ` `  `// calculate number of zeros in subarray ` `// of length x with maximum number of 1's ` `int` `noOfZeroes = x - maxOnes; ` ` `  `return` `noOfZeroes; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main (String[] args) { ` `int` `a[] = {``1``, ``0``, ``1``, ``0``, ``1``}; ` `int` `n = a.length; ` `System.out.println( minSwaps(a, n)); ` `     `  `    ``} ` `} ` ` `  `// This code is contributed by vt_m. `

## Python3

 `# Python program to ` `# find minimum swaps ` `# required to group ` `# all 1's together ` ` `  `# Function to find minimum swaps ` `# to group all 1's together ` `def` `minSwaps(arr,n): ` `     `  `    ``noOfOnes ``=` `0` `  `  `    ``# find total number of ` `    ``# all in the array ` `    ``for` `i ``in` `range``(n): ` `        ``if` `(arr[i] ``=``=` `1``): ` `            ``noOfOnes``=``noOfOnes``+``1` `   `  `  `  `    ``# length of subarray to check for ` `    ``x ``=` `noOfOnes ` `  `  `    ``maxOnes ``=` `-``2147483648` `  `  `    ``# array to store number of 1's upto ` `    ``# ith index ` `    ``preCompute``=``{} ` `  `  `    ``# calculate number of 1's upto ith ` `    ``# index and store in the ` `    ``# array preCompute[] ` `    ``if` `(arr[``0``] ``=``=` `1``): ` `        ``preCompute[``0``] ``=` `1` `    ``for` `i ``in` `range``(``1``,n): ` `        ``if` `(arr[i] ``=``=` `1``): ` `            ``preCompute[i] ``=` `preCompute[i ``-` `1``] ``+` `1` `        ``else``: ` `            ``preCompute[i] ``=` `preCompute[i ``-` `1``] ` `   `  `  `  `    ``# using sliding window ` `    ``# technique to find ` `    ``# max number of ones in ` `    ``# subarray of length x ` `    ``for` `i ``in` `range``(x``-``1``,n): ` `        ``if` `(i ``=``=` `(x ``-` `1``)):  ` `            ``noOfOnes ``=` `preCompute[i] ` `        ``else``: ` `            ``noOfOnes ``=` `preCompute[i] ``-` `preCompute[i ``-` `x] ` `      `  `        ``if` `(maxOnes < noOfOnes): ` `            ``maxOnes ``=` `noOfOnes ` `   `  `  `  `    ``# calculate number of zeros in subarray ` `    ``# of length x with maximum number of 1's ` `    ``noOfZeroes ``=` `x ``-` `maxOnes ` `  `  `    ``return` `noOfZeroes ` `   `  `# Driver code ` ` `  `a ``=` `[``1``, ``0``, ``1``, ``0``, ``1``] ` `n ``=` `len``(a) ` ` `  `print``(minSwaps(a, n)) ` ` `  `# This code is contributed ` `# by Anant Agarwal. `

## C#

 `// C# program to find minimum swaps ` `// required to group all 1's together ` ` `  `using` `System; ` ` `  `class` `GFG { ` ` `  `    ``// Function to find minimum swaps ` `    ``// to group all 1's together ` `    ``static` `int` `minSwaps(``int` `[]arr, ``int` `n) { ` `     `  `        ``int` `noOfOnes = 0; ` `         `  `        ``// find total number of all in the array ` `        ``for` `(``int` `i = 0; i < n; i++) { ` `            ``if` `(arr[i] == 1) ` `            ``noOfOnes++; ` `        ``} ` `         `  `        ``// length of subarray to check for ` `        ``int` `x = noOfOnes; ` `         `  `        ``int` `maxOnes = ``int``.MinValue; ` `         `  `        ``// array to store number of 1's upto ` `        ``// ith index ` `        ``int` `[]preCompute = ``new` `int``[n]; ` `         `  `        ``// calculate number of 1's upto ith ` `        ``// index and store in the array preCompute[] ` `        ``if` `(arr == 1) ` `            ``preCompute = 1; ` `        ``for` `(``int` `i = 1; i < n; i++) { ` `            ``if` `(arr[i] == 1) { ` `            ``preCompute[i] = preCompute[i - 1] + 1; ` `            ``} ``else` `            ``preCompute[i] = preCompute[i - 1]; ` `        ``} ` `         `  `        ``// using sliding window technique to find ` `        ``// max number of ones in subarray of length x ` `        ``for` `(``int` `i = x - 1; i < n; i++) { ` `            ``if` `(i == (x - 1))  ` `            ``noOfOnes = preCompute[i]; ` `            ``else` `            ``noOfOnes = preCompute[i] - preCompute[i - x]; ` `             `  `            ``if` `(maxOnes < noOfOnes) ` `            ``maxOnes = noOfOnes; ` `        ``} ` `         `  `        ``// calculate number of zeros in subarray ` `        ``// of length x with maximum number of 1's ` `        ``int` `noOfZeroes = x - maxOnes; ` `         `  `        ``return` `noOfZeroes; ` `    ``} ` `     `  `    ``// Driver Code ` `    ``public` `static` `void` `Main ()  ` `    ``{ ` `        ``int` `[]a = {1, 0, 1, 0, 1}; ` `        ``int` `n = a.Length; ` `        ``Console.WriteLine( minSwaps(a, n)); ` `         `  `    ``} ` `} ` ` `  `// This code is contributed by vt_m. `

## PHP

 ` `

Output:

```1
```

Time Complexity: O(n)
Auxiliary Space: O(n)

Another efficient approach :
First count total number of 1’s in the array. Suppose this count is x, now find the subarray of length x of this array with maximum number of 1’s using the concept of window-sliding technique. Maintain a variable to find number of 1’s present in a subarray in O(1) extra space and for each sub array maintain maxOnes Variable and at last Return numberOfZeros (numberOfZeroes = x – maxOnes).

## C++

 `// C++ code for minimum swaps ` `// required to group all 1's together ` `#include ` `#include ` ` `  `using` `namespace` `std; ` ` `  `// Function to find minimum swaps ` `// to group all 1's together ` `int` `minSwaps(``int` `arr[], ``int` `n) ` `{ ` ` `  `int` `numberOfOnes = 0; ` ` `  `// find total number of all 1's in the array ` `for` `(``int` `i = 0; i < n; i++) { ` `    ``if` `(arr[i] == 1) ` `    ``numberOfOnes++; ` `} ` ` `  `// length of subarray to check for ` `int` `x = numberOfOnes; ` ` `  `int` `count_ones = 0, maxOnes; ` ` `  `// Find 1's for first subarray of length x ` `for``(``int` `i = 0; i < x; i++){ ` `    ``if``(arr[i] == 1) ` `    ``count_ones++; ` `} ` `     `  `maxOnes = count_ones; ` `     `  `// using sliding window technique to find ` `// max number of ones in subarray of length x ` `for` `(``int` `i = 1; i <= n-x; i++) { ` `     `  `    ``// first remove leading element and check ` `    ``// if it is equal to 1 then decreament the  ` `    ``// value of count_ones by 1 ` `    ``if` `(arr[i-1] == 1)  ` `    ``count_ones--; ` `     `  `    ``// Now add trailing element and check ` `    ``// if it is equal to 1 Then increment  ` `    ``// the value of count_ones by 1 ` `    ``if``(arr[i+x-1] == 1) ` `    ``count_ones++; ` `     `  `    ``if` `(maxOnes < count_ones) ` `    ``maxOnes = count_ones; ` `} ` ` `  `// calculate number of zeros in subarray ` `// of length x with maximum number of 1's ` `int` `numberOfZeroes = x - maxOnes; ` ` `  `return` `numberOfZeroes; ` `} ` ` `  `// Driver Code ` `int` `main() { ` `     `  `int` `a[] = {0, 0, 1, 0, 1, 1, 0, 0, 1}; ` `int` `n = ``sizeof``(a) / ``sizeof``(a); ` ` `  `cout << minSwaps(a, n); ` ` `  `return` `0; ` ` `  `} `

## Java

 `// java program to find largest number ` `// smaller than equal to n with m set ` `// bits then m-1 0 bits. ` `public` `class` `GFG { ` `     `  `    ``// Function to find minimum swaps ` `    ``// to group all 1's together ` `    ``static` `int` `minSwaps(``int` `arr[], ``int` `n) ` `    ``{ ` `     `  `        ``int` `numberOfOnes = ``0``; ` `         `  `        ``// find total number of all 1's ` `        ``// in the array ` `        ``for` `(``int` `i = ``0``; i < n; i++) { ` `            ``if` `(arr[i] == ``1``) ` `                ``numberOfOnes++; ` `        ``} ` `         `  `        ``// length of subarray to check for ` `        ``int` `x = numberOfOnes; ` `         `  `        ``int` `count_ones = ``0``, maxOnes; ` `         `  `        ``// Find 1's for first subarray ` `        ``// of length x ` `        ``for``(``int` `i = ``0``; i < x; i++){ ` `            ``if``(arr[i] == ``1``) ` `                ``count_ones++; ` `        ``} ` `             `  `        ``maxOnes = count_ones; ` `             `  `        ``// using sliding window technique  ` `        ``// to find max number of ones in ` `        ``// subarray of length x ` `        ``for` `(``int` `i = ``1``; i <= n-x; i++) { ` `             `  `            ``// first remove leading element  ` `            ``// and check if it is equal to ` `            ``// 1 then decreament the  ` `            ``// value of count_ones by 1 ` `            ``if` `(arr[i - ``1``] == ``1``)  ` `                ``count_ones--; ` `             `  `            ``// Now add trailing element  ` `            ``// and check if it is equal  ` `            ``// to 1 Then increment the ` `            ``// value of count_ones by 1 ` `            ``if``(arr[i + x - ``1``] == ``1``) ` `                ``count_ones++; ` `             `  `            ``if` `(maxOnes < count_ones) ` `            ``maxOnes = count_ones; ` `        ``} ` `         `  `        ``// calculate number of zeros in ` `        ``// subarray of length x with ` `        ``// maximum number of 1's ` `        ``int` `numberOfZeroes = x - maxOnes; ` `         `  `        ``return` `numberOfZeroes; ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `main(String args[])  ` `    ``{ ` `        ``int` `a[] = ``new` `int``[]{``0``, ``0``, ``1``, ``0``,  ` `                            ``1``, ``1``, ``0``, ``0``, ``1``}; ` `        ``int` `n = a.length; ` `         `  `        ``System.out.println(minSwaps(a, n)); ` `    ``} ` `} ` ` `  `// This code is contributed by Sam007 `

## Python3

 `# Python code for minimum  ` `# swaps required to group  ` `# all 1's together ` ` `  `# Function to find minimum  ` `# swaps to group all 1's ` `# together ` `def` `minSwaps(arr, n) : ` ` `  `    ``numberOfOnes ``=` `0` `     `  `    ``# find total number of  ` `    ``# all 1's in the array ` `    ``for` `i ``in` `range``(``0``, n) : ` ` `  `        ``if` `(arr[i] ``=``=` `1``) : ` `            ``numberOfOnes ``=` `numberOfOnes ``+` `1` `     `  `    ``# length of subarray ` `    ``# to check for ` `    ``x ``=` `numberOfOnes ` `     `  `    ``count_ones ``=` `0` `    ``maxOnes ``=` `0` `     `  `    ``# Find 1's for first  ` `    ``# subarray of length x ` `    ``for` `i ``in` `range``(``0``, x) : ` ` `  `        ``if``(arr[i] ``=``=` `1``) : ` `            ``count_ones ``=` `count_ones ``+` `1` `         `  `    ``maxOnes ``=` `count_ones ` `         `  `    ``# using sliding window  ` `    ``# technique to find ` `    ``# max number of ones in ` `    ``# subarray of length x ` `    ``for` `i ``in` `range``(``1``, (n ``-` `x ``+` `1``)) : ` `         `  `        ``# first remove leading ` `        ``# element and check ` `        ``# if it is equal to 1  ` `        ``# then decreament the  ` `        ``# value of count_ones by 1 ` `        ``if` `(arr[i ``-` `1``] ``=``=` `1``) :  ` `            ``count_ones ``=` `count_ones ``-` `1` `         `  `        ``# Now add trailing  ` `        ``# element and check ` `        ``# if it is equal to 1  ` `        ``# Then increment  ` `        ``# the value of count_ones by 1 ` `        ``if``(arr[i ``+` `x ``-` `1``] ``=``=` `1``) : ` `            ``count_ones ``=` `count_ones ``+` `1` `         `  `        ``if` `(maxOnes < count_ones) : ` `                ``maxOnes ``=` `count_ones ` `     `  `    ``# calculate number of  ` `    ``# zeros in subarray ` `    ``# of length x with  ` `    ``# maximum number of 1's ` `    ``numberOfZeroes ``=` `x ``-` `maxOnes ` `     `  `    ``return` `numberOfZeroes ` ` `  `# Driver Code ` `a ``=` `[``0``, ``0``, ``1``, ``0``, ``1``, ``1``, ``0``, ``0``, ``1``] ` `n ``=` `9` `print` `(minSwaps(a, n))  ` ` `  `# This code is contributed  ` `# by Manish Shaw(manishshaw1) `

## C#

 `// C# code for minimum swaps ` `// required to group all 1's together ` `using` `System; ` ` `  `class` `GFG{ ` `     `  `    ``// Function to find minimum swaps ` `    ``// to group all 1's together ` `    ``static` `int` `minSwaps(``int` `[]arr, ``int` `n) ` `    ``{ ` `     `  `        ``int` `numberOfOnes = 0; ` `         `  `        ``// find total number of all 1's in the array ` `        ``for` `(``int` `i = 0; i < n; i++) { ` `            ``if` `(arr[i] == 1) ` `            ``numberOfOnes++; ` `        ``} ` `         `  `        ``// length of subarray to check for ` `        ``int` `x = numberOfOnes; ` `         `  `        ``int` `count_ones = 0, maxOnes; ` `         `  `        ``// Find 1's for first subarray of length x ` `        ``for``(``int` `i = 0; i < x; i++){ ` `            ``if``(arr[i] == 1) ` `            ``count_ones++; ` `        ``} ` `             `  `        ``maxOnes = count_ones; ` `             `  `        ``// using sliding window technique to find ` `        ``// max number of ones in subarray of length x ` `        ``for` `(``int` `i = 1; i <= n-x; i++) { ` `             `  `            ``// first remove leading element and check ` `            ``// if it is equal to 1 then decreament the  ` `            ``// value of count_ones by 1 ` `            ``if` `(arr[i - 1] == 1)  ` `            ``count_ones--; ` `             `  `            ``// Now add trailing element and check ` `            ``// if it is equal to 1 Then increment  ` `            ``// the value of count_ones by 1 ` `            ``if``(arr[i + x - 1] == 1) ` `            ``count_ones++; ` `             `  `            ``if` `(maxOnes < count_ones) ` `            ``maxOnes = count_ones; ` `        ``} ` `         `  `        ``// calculate number of zeros in subarray ` `        ``// of length x with maximum number of 1's ` `        ``int` `numberOfZeroes = x - maxOnes; ` `         `  `        ``return` `numberOfZeroes; ` `    ``} ` `     `  `    ``// Driver Code ` `    ``static` `public` `void` `Main () ` `    ``{ ` `        ``int` `[]a = {0, 0, 1, 0, 1, 1, 0, 0, 1}; ` `        ``int` `n = a.Length; ` `     `  `        ``Console.WriteLine(minSwaps(a, n)); ` `         `  `    ``} ` `} ` `// This code is contributed by vt_m. `

## PHP

 ` `

Output:

```1
```

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

Thanks to Mr. Gera for suggesting this approach.

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 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 :

6

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