# Minimum count of 0s to be selected such that all 1s are adjacent to them

Last Updated : 17 Jan, 2022

Given a binary string str of size N whose every character is either ‘1’ or ‘0’. The task is to select minimum number of 0‘s such that at least one neighbor for every ‘1’ is selected. Print the count of the selected 0′s.

Examples:

Input: str = “1001”
Output: 2
Explanation: ‘0’s can be selected from index 1 and index 2.  As a result, every ‘1’ has at least one neighbor present among the selected ‘0’s.

Input: str = “01010”
Output: 1
Explanation: ‘0’ at index 2 can be selected. As a result one neighbor for both the ‘1’ s are selected.

Input: str = “111”
Output: -1
Explanation: There is no ‘0’ in the given string. So there cannot be any neighbor of ‘1’ which is ‘0’.

Input: str = “110”
Output: -1
Explanation: There is no ‘0’ as neighbor for ‘1’ at first position.

Approach: The solution is based on greedy approach. Follow the below steps to get the solution.

• Start iterating the string from the beginning.
• For each ‘1’ If possible, a ‘0’ is selected from its neighborhood.
• Now, if there is ‘0’ before as well as after current ‘1’, then always select the neighbor next to the current ‘1’ (because there can be more ‘1’s after this one and doing so will allow to select minimum number of neighbors).

Below is the implementation of the above approach:

## C++

 `// C++ code to implement the above approach` `#include ` `using` `namespace` `std;`   `// Function to count ` `// minimum number of buckets` `int` `minimumBuckets(string str)` `{` `    ``int` `bucketcount = 0;` `    ``int` `N = str.size();`   `    ``// Loop to count minimum buckets` `    ``for` `(``int` `i = 0; i < N;) {` `        ``if` `(str[i] == ``'1'``) {` `            `  `            ``// If bucket can be put,` `            ``// no need of next two indices,` `            ``// so shift to i+3` `            ``if` `(i + 1 < N && ` `                ``str[i + 1] == ``'0'``) {` `                ``bucketcount++;` `                ``i += 3;` `                ``continue``;` `            ``}` `            ``if` `(i - 1 >= 0 && ` `                ``str[i - 1] == ``'0'``) {` `                ``bucketcount++;` `                ``i++;` `                ``continue``;` `            ``}` `            ``return` `-1;` `        ``}` `        ``i++;` `    ``}` `    ``return` `bucketcount;` `}`   `// Driver code` `int` `main()` `{` `    ``string str = ``"1001"``;` `    ``cout << minimumBuckets(str)<

## Java

 `// Java code to implement the above approach` `class` `GFG {`   `    ``// Function to count` `    ``// minimum number of buckets` `    ``static` `int` `minimumBuckets(String str) {` `        ``int` `bucketcount = ``0``;` `        ``int` `N = str.length();`   `        ``// Loop to count minimum buckets` `        ``for` `(``int` `i = ``0``; i < N;) {` `            ``if` `(str.charAt(i) == ``'1'``) {`   `                ``// If bucket can be put,` `                ``// no need of next two indices,` `                ``// so shift to i+3` `                ``if` `(i + ``1` `< N && str.charAt(i + ``1``) == ``'0'``) {` `                    ``bucketcount++;` `                    ``i += ``3``;` `                    ``continue``;` `                ``}` `                ``if` `(i - ``1` `>= ``0` `&& str.charAt(i - ``1``) == ``'0'``) {` `                    ``bucketcount++;` `                    ``i++;` `                    ``continue``;` `                ``}` `                ``return` `-``1``;` `            ``}` `            ``i++;` `        ``}` `        ``return` `bucketcount;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String args[]) {` `        ``String str = ``"1001"``;` `        ``System.out.println(minimumBuckets(str));`   `        ``String str1 = ``"1010"``;` `        ``System.out.println(minimumBuckets(str1));` `    ``}` `}`   `// This code is contributed by Saurabh Jaiswal`

## Python3

 `# python code to implement the above approach`   `# Function to count` `# minimum number of buckets` `def` `minimumBuckets(``str``):`   `    ``bucketcount ``=` `0` `    ``N ``=` `len``(``str``)`   `    ``# Loop to count minimum buckets` `    ``i ``=` `0` `    ``while``(i < N):` `        ``if` `(``str``[i] ``=``=` `'1'``):`   `            ``# If bucket can be put,` `            ``# no need of next two indices,` `            ``# so shift to i+3` `            ``if` `(i ``+` `1` `< N ``and` `str``[i ``+` `1``] ``=``=` `'0'``):` `                ``bucketcount ``+``=` `1` `                ``i ``+``=` `3` `                ``continue`   `            ``if` `(i ``-` `1` `>``=` `0` `and` `str``[i ``-` `1``] ``=``=` `'0'``):` `                ``bucketcount ``+``=` `1` `                ``i ``+``=` `1` `                ``continue`   `            ``return` `-``1`   `        ``i ``+``=` `1`   `    ``return` `bucketcount`   `# Driver code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``str` `=` `"1001"` `    ``print``(minimumBuckets(``str``))`   `    ``str1 ``=` `"1010"` `    ``print``(minimumBuckets(str1))`   `    ``# This code is contributed by rakeshsahni`

## C#

 `// C# code to implement the above approach` `using` `System;` `class` `GFG {`   `    ``// Function to count` `    ``// minimum number of buckets` `    ``static` `int` `minimumBuckets(``string` `str)` `    ``{` `        ``int` `bucketcount = 0;` `        ``int` `N = str.Length;`   `        ``// Loop to count minimum buckets` `        ``for` `(``int` `i = 0; i < N;) {` `            ``if` `(str[i] == ``'1'``) {`   `                ``// If bucket can be put,` `                ``// no need of next two indices,` `                ``// so shift to i+3` `                ``if` `(i + 1 < N && str[i + 1] == ``'0'``) {` `                    ``bucketcount++;` `                    ``i += 3;` `                    ``continue``;` `                ``}` `                ``if` `(i - 1 >= 0 && str[i - 1] == ``'0'``) {` `                    ``bucketcount++;` `                    ``i++;` `                    ``continue``;` `                ``}` `                ``return` `-1;` `            ``}` `            ``i++;` `        ``}` `        ``return` `bucketcount;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main()` `    ``{` `        ``string` `str = ``"1001"``;` `        ``Console.WriteLine(minimumBuckets(str));`   `        ``string` `str1 = ``"1010"``;` `        ``Console.WriteLine(minimumBuckets(str1));` `    ``}` `}`   `// This code is contributed by ukasp.`

## Javascript

 ``

Output

```2
1```

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