# Minimum swaps to group all 0s together in Binary Circular Array

Given a** binary circular** array **arr[]** of size **N**, the task is to find the **minimum swaps** to group all **0s** together in the array.

**Examples**:

Input:arr[] = {1, 0, 1, 0, 0, 1, 1}Output:1Explanation:Here are a few of the ways to group all the 0’s together:

- {1,
1, 0,0, 0, 1, 1} using 1 swap.- {1, 0,
0,0,1,1, 1} using 1 swap.- {0, 0, 1, 1, 1, 1, 0} using 2 swaps (using the circular property of the array).
There is no way to group all 0’s together with 0 swaps. Thus, the minimum number of swaps required is 1.

Input:arr[] = {0, 0, 1, 1, 0}Output:0Explanation:All the 0’s are already grouped together due to the circular property of the array.

Thus, the minimum number of swaps required is 0.

**Approach: **The task can be solved using the sliding window technique. Follow the below steps to solve the problem:

- Count the total number of 0s. Let m be that number
- Find the
**contiguous**region of length**m**that has the most**0s**in it - The number of
**1s**in this region is the**minimum**required swaps. Each swap will move one 0 into the region and one 1 out of the region. - Finally, use modulo operation for handling the case of the circular arrays.

Below is the implementation of the above approach.

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to count min swap` `// to get all zeros together` `int` `minSwaps(` `int` `nums[], ` `int` `N)` `{` ` ` `int` `count_1 = 0;` ` ` `if` `(N == 1)` ` ` `return` `0;` ` ` `for` `(` `int` `i = 0; i < N; i++) {` ` ` `if` `(nums[i] == 0)` ` ` `count_1++;` ` ` `}` ` ` `// Window size for counting` ` ` `// maximum no. of 1s` ` ` `int` `windowsize = count_1;` ` ` `count_1 = 0;` ` ` `for` `(` `int` `i = 0; i < windowsize; i++) {` ` ` `if` `(nums[i] == 0)` ` ` `count_1++;` ` ` `}` ` ` `// For storing maximum count of 1s in` ` ` `// a window` ` ` `int` `mx = count_1;` ` ` `for` `(` `int` `i = windowsize; i < N + windowsize; i++) {` ` ` `if` `(nums[i % N] == 0)` ` ` `count_1++;` ` ` `if` `(nums[(i - windowsize) % N] == 0)` ` ` `count_1--;` ` ` `mx = max(count_1, mx);` ` ` `}` ` ` `return` `windowsize - mx;` `}` `// Driver code` `int` `main()` `{` ` ` `int` `nums[] = { 1, 0, 1, 0, 0, 1, 1 };` ` ` `int` `N = ` `sizeof` `(nums) / ` `sizeof` `(nums[0]);` ` ` `cout << minSwaps(nums, N);` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `import` `java.io.*;` `import` `java.lang.*;` `import` `java.util.*;` `class` `GFG {` ` ` `// Function to count min swap` ` ` `// to get all zeros together` ` ` `static` `int` `minSwaps(` `int` `nums[], ` `int` `N)` ` ` `{` ` ` `int` `count_1 = ` `0` `;` ` ` `if` `(N == ` `1` `)` ` ` `return` `0` `;` ` ` `for` `(` `int` `i = ` `0` `; i < N; i++) {` ` ` `if` `(nums[i] == ` `0` `)` ` ` `count_1++;` ` ` `}` ` ` `// Window size for counting` ` ` `// maximum no. of 1s` ` ` `int` `windowsize = count_1;` ` ` `count_1 = ` `0` `;` ` ` `for` `(` `int` `i = ` `0` `; i < windowsize; i++) {` ` ` `if` `(nums[i] == ` `0` `)` ` ` `count_1++;` ` ` `}` ` ` `// For storing maximum count of 1s in` ` ` `// a window` ` ` `int` `mx = count_1;` ` ` `for` `(` `int` `i = windowsize; i < N + windowsize; i++) {` ` ` `if` `(nums[i % N] == ` `0` `)` ` ` `count_1++;` ` ` `if` `(nums[(i - windowsize) % N] == ` `0` `)` ` ` `count_1--;` ` ` `mx = Math.max(count_1, mx);` ` ` `}` ` ` `return` `windowsize - mx;` ` ` `}` ` ` `// Driver code` ` ` `public` `static` `void` `main (String[] args) {` ` ` `int` `nums[] = { ` `1` `, ` `0` `, ` `1` `, ` `0` `, ` `0` `, ` `1` `, ` `1` `};` ` ` `int` `N = nums.length;` ` ` `System.out.println( minSwaps(nums, N));` ` ` `}` `}` `// This code is contributed by hrithikgarg03188.` |

## Python3

`# python3 program for the above approach` `# Function to count min swap` `# to get all zeros together` `def` `minSwaps(nums, N):` ` ` `count_1 ` `=` `0` ` ` `if` `(N ` `=` `=` `1` `):` ` ` `return` `0` ` ` `for` `i ` `in` `range` `(` `0` `, N):` ` ` `if` `(nums[i] ` `=` `=` `0` `):` ` ` `count_1 ` `+` `=` `1` ` ` `# Window size for counting` ` ` `# maximum no. of 1s` ` ` `windowsize ` `=` `count_1` ` ` `count_1 ` `=` `0` ` ` `for` `i ` `in` `range` `(` `0` `, windowsize):` ` ` `if` `(nums[i] ` `=` `=` `0` `):` ` ` `count_1 ` `+` `=` `1` ` ` `# For storing maximum count of 1s in` ` ` `# a window` ` ` `mx ` `=` `count_1` ` ` `for` `i ` `in` `range` `(windowsize, N ` `+` `windowsize):` ` ` `if` `(nums[i ` `%` `N] ` `=` `=` `0` `):` ` ` `count_1 ` `+` `=` `1` ` ` `if` `(nums[(i ` `-` `windowsize) ` `%` `N] ` `=` `=` `0` `):` ` ` `count_1 ` `-` `=` `1` ` ` `mx ` `=` `max` `(count_1, mx)` ` ` `return` `windowsize ` `-` `mx` `# Driver code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `nums ` `=` `[` `1` `, ` `0` `, ` `1` `, ` `0` `, ` `0` `, ` `1` `, ` `1` `]` ` ` `N ` `=` `len` `(nums)` ` ` `print` `(minSwaps(nums, N))` ` ` `# This code is contributed by rakeshsahni` |

## C#

`// C# program for the above approach` `using` `System;` `class` `GFG` `{` ` ` `// Function to count min swap` ` ` `// to get all zeros together` ` ` `static` `int` `minSwaps(` `int` `[]nums, ` `int` `N)` ` ` `{` ` ` `int` `count_1 = 0;` ` ` `if` `(N == 1)` ` ` `return` `0;` ` ` `for` `(` `int` `i = 0; i < N; i++) {` ` ` `if` `(nums[i] == 0)` ` ` `count_1++;` ` ` `}` ` ` `// Window size for counting` ` ` `// maximum no. of 1s` ` ` `int` `windowsize = count_1;` ` ` `count_1 = 0;` ` ` `for` `(` `int` `i = 0; i < windowsize; i++) {` ` ` `if` `(nums[i] == 0)` ` ` `count_1++;` ` ` `}` ` ` `// For storing maximum count of 1s in` ` ` `// a window` ` ` `int` `mx = count_1;` ` ` `for` `(` `int` `i = windowsize; i < N + windowsize; i++) {` ` ` `if` `(nums[i % N] == 0)` ` ` `count_1++;` ` ` `if` `(nums[(i - windowsize) % N] == 0)` ` ` `count_1--;` ` ` `mx = Math.Max(count_1, mx);` ` ` `}` ` ` `return` `windowsize - mx;` ` ` `}` ` ` `// Driver code` ` ` `public` `static` `void` `Main()` ` ` `{` ` ` `int` `[]nums = { 1, 0, 1, 0, 0, 1, 1 };` ` ` `int` `N = nums.Length;` ` ` `Console.Write(minSwaps(nums, N));` ` ` `}` `}` `// This code is contributed by Samim Hossain Mondal.` |

## Javascript

`<script>` ` ` `// JavaScript code for the above approach` ` ` `// Function to count min swap` ` ` `// to get all zeros together` ` ` `function` `minSwaps(nums, N) {` ` ` `let count_1 = 0;` ` ` `if` `(N == 1)` ` ` `return` `0;` ` ` `for` `(let i = 0; i < N; i++) {` ` ` `if` `(nums[i] == 0)` ` ` `count_1++;` ` ` `}` ` ` `// Window size for counting` ` ` `// maximum no. of 1s` ` ` `let windowsize = count_1;` ` ` `count_1 = 0;` ` ` `for` `(let i = 0; i < windowsize; i++) {` ` ` `if` `(nums[i] == 0)` ` ` `count_1++;` ` ` `}` ` ` `// For storing maximum count of 1s in` ` ` `// a window` ` ` `let mx = count_1;` ` ` `for` `(let i = windowsize; i < N + windowsize; i++) {` ` ` `if` `(nums[i % N] == 0)` ` ` `count_1++;` ` ` `if` `(nums[(i - windowsize) % N] == 0)` ` ` `count_1--;` ` ` `mx = Math.max(count_1, mx);` ` ` `}` ` ` `return` `windowsize - mx;` ` ` `}` ` ` `// Driver code` ` ` `let nums = [1, 0, 1, 0, 0, 1, 1];` ` ` `let N = nums.length;` ` ` `document.write(minSwaps(nums, N));` ` ` `// This code is contributed by Potta Lokesh` ` ` `</script>` |

**Output**

1

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