Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Count of 0s to be flipped to make any two adjacent 1s at least K 0s apart

  • Last Updated : 27 Apr, 2021

Given a binary string s and a number K, the task is to find the maximum number of 0s that can be replaced by 1s such that two adjacent 1s are separated by at least K 0s in between them. 
Examples: 

Input: K = 2, s = “000000” 
Output: 2 
Explanation:
Change the 0s at position 0 and 3. Then the final string will be “100100” such that every 1 is separated by at least 2 0s.

Input: K = 1, s = “01001000100000” 
Output: 3 
Explanation:
Change the 0s at position 6, 10, and 12. Then the final string will be “01001010101010” such that every 1 is separated by at least 1 0s.

Approach: 

  1. Insert all the characters of the given string in an array(say arr[]).
  2. Traverse the array arr[] and convert all the 0s to -1 which are located at <= K places near an already existing 1. This operation gives all the possible positions of the string where 1 can be inserted.
  3. Initialize a count variable to 0.
  4. Traverse the array arr[] from the left till the end. As soon as the first 0 is encountered replace it with 1 and increase the count value.
  5. Convert all the 0s to -1 which are located at <= K places near the newly converted 1.
  6. Keep traversing the array till the end and every time a 0 is encountered, repeat the steps 4 – 5.

Below is the implementation of the above approach: 

C++




// C++ program for the above problem
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the
// count of 0s to be flipped
int count(int k, string s)
{
    int ar[s.length()];
    int end = 0;
     
    // Loop traversal to mark K
    // adjacent positions to the right
    // of already existing 1s.
    for(int i = 0; i < s.length(); i++)
    {
       if (s[i] == '1')
       {
           for(int j = i;
                   j < s.length() &&
                   j <= i + k; j++)
           {
              ar[j] = -1;
              end = j;
           }
           i = end;
       }
    }
    end = 0;
     
    // Loop traversal to mark K
    // adjacent positions to the left
    // of already existing 1s.
    for(int i = s.length() - 1;
            i >= 0; i--)
    {
       if (s[i] == '1')
       {
           for(int j = i;
                   j >= 0 &&
                   j >= i - k; j--)
           {
              ar[j] = -1;
              end = j;
           }
           i = end;
       }
    }
     
    int ans = 0;
    end = 0;
     
    // Loop to count the maximum
    // number of 0s that will be
    // replaced by 1s
    for(int j = 0;
            j < s.length(); j++)
    {
       if (ar[j] == 0)
       {
           ans++;
           for(int g = j;
                   g <= j + k &&
                   g < s.length(); g++)
           {
              ar[g] = -1;
              end = g;
           }
           j = end - 1;
       }
    }
    return ans;
}
 
// Driver code
int main()
{
    int K = 2;
    string s = "000000";
 
    cout << count(K, s) << endl;
 
    return 0;
}
 
// This code is contributed by divyeshrabadiya07
Java



// Java program for the above problem
import java.util.Scanner;
 
// Driver Code
public class Check {
 
    // Function to find the
    // count of 0s to be flipped
    public static int count(int k, String s)
    {
 
        int ar[] = new int[s.length()];
        int end = 0;
 
        // Loop traversal to mark K
        // adjacent positions to the right
        // of already existing 1s.
        for (int i = 0;
             i < s.length(); i++) {
 
            if (s.charAt(i) == '1') {
 
                for (int j = i;
                     j < s.length()
                     && j <= i + k;
                     j++) {
 
                    ar[j] = -1;
                    end = j;
                }
                i = end;
            }
        }
 
        end = 0;
 
        // Loop traversal to mark K
        // adjacent positions to the left
        // of already existing 1s.
        for (int i = s.length() - 1;
             i >= 0; i--) {
 
            if (s.charAt(i) == '1') {
                for (int j = i;
                     j >= 0 && j >= i - k;
                     j--) {
 
                    ar[j] = -1;
                    end = j;
                }
 
                i = end;
            }
        }
 
        int ans = 0;
        end = 0;
 
        // Loop to count the maximum
        // number of 0s that will be
        // replaced by 1s
        for (int j = 0;
             j < s.length(); j++) {
 
            if (ar[j] == 0) {
 
                ans++;
                for (int g = j;
                     g <= j + k
                     && g < s.length();
                     g++) {
 
                    ar[g] = -1;
                    end = g;
                }
 
                j = end - 1;
            }
        }
        return ans;
    }
 
    // Driver code
    public static void main(String[] args)
    {
 
        int K = 2;
        String s = "000000";
 
        System.out.println(count(K, s));
    }
}
Python3



# Python3 program for the above problem
 
# Function to find the 
# count of 0s to be flipped
def count(k, s):
     
    ar = [0] * len(s)
    end = 0
 
    # Loop traversal to mark K 
    # adjacent positions to the right 
    # of already existing 1s.
    for i in range(len(s)):
        if s[i] == '1':
             
            for j in range(i, len(s)):
                if (j <= i + k):
                    ar[j] = -1
                    end = j
                     
            i = end
             
    end = 0
 
    # Loop traversal to mark K 
    # adjacent positions to the left 
    # of already existing 1s.
    for i in range(len(s) - 1, -1, -1):
        if (s[i] == '1'):
             
            for j in range(i, -1, -1):
                if (j >= i - k):
                    ar[j] = -1
                    end = j
                     
            i = end
             
    ans = 0
    end = 0
 
    # Loop to count the maximum 
    # number of 0s that will be 
    # replaced by 1s
    for j in range(len(s)):
        if (ar[j] == 0):
            ans += 1
             
            for g in range(j, len(s)):
                if (g <= j + k):
                    ar[g] = -1
                    end = g
                     
            j = end - 1
             
    return ans
 
# Driver code
K = 2
s = "000000"
 
print(count(K, s))
 
# This code is contributed by avanitrachhadiya2155
C#



// C# program for the above problem
using System;
 
class GFG{
 
// Function to find the
// count of 0s to be flipped
public static int count(int k, String s)
{
 
    int []ar = new int[s.Length];
    int end = 0;
 
    // Loop traversal to mark K
    // adjacent positions to the right
    // of already existing 1s.
    for(int i = 0; i < s.Length; i++)
    {
       if (s[i] == '1')
       {
           for(int j = i;
                   j < s.Length &&
                   j <= i + k; j++)
           {
              ar[j] = -1;
              end = j;
           }
           i = end;
       }
    }
    end = 0;
     
    // Loop traversal to mark K
    // adjacent positions to the left
    // of already existing 1s.
    for(int i = s.Length - 1; i >= 0; i--)
    {
       if (s[i] == '1')
       {
           for(int j = i;
                   j >= 0 &&
                   j >= i - k; j--)
           {
              ar[j] = -1;
              end = j;
           }
           i = end;
       }
    }
     
    int ans = 0;
    end = 0;
 
    // Loop to count the maximum
    // number of 0s that will be
    // replaced by 1s
    for(int j = 0; j < s.Length; j++)
    {
       if (ar[j] == 0)
       {
           ans++;
           for(int g = j;
                   g <= j + k &&
                   g < s.Length; g++)
           {
              ar[g] = -1;
              end = g;
           }
           j = end - 1;
       }
    }
    return ans;
}
 
// Driver code
public static void Main(String[] args)
{
    int K = 2;
    String s = "000000";
 
    Console.WriteLine(count(K, s));
}
}
 
// This code is contributed by amal kumar choubey
Javascript



<script>
 
// Javascript program for the above problem
 
// Function to find the
// count of 0s to be flipped
function count(k, s)
{
    var ar = Array(s.length).fill(0);
    var end = 0;
     
    var i,j;
    // Loop traversal to mark K
    // adjacent positions to the right
    // of already existing 1s.
    for(i = 0; i < s.length; i++)
    {
       if (s[i] == '1')
       {
           for(j = i; j < s.length &&
               j <= i + k; j++)
           {
              ar[j] = -1;
              end = j;
           }
           i = end;
       }
    }
    end = 0;
     
    // Loop traversal to mark K
    // adjacent positions to the left
    // of already existing 1s.
    for(i = s.length - 1; i >= 0; i--)
    {
       if (s[i] == '1')
       {
           for(j = i; j >= 0 &&
               j >= i - k; j--)
           {
              ar[j] = -1;
              end = j;
           }
           i = end;
       }
    }
     
    var ans = 0;
    end = 0;
     
    // Loop to count the maximum
    // number of 0s that will be
    // replaced by 1s
    var g;
    for(j = 0;j < s.length; j++)
    {
       if (ar[j] == 0)
       {
           ans++;
           for(g = j; g <= j + k &&
               g < s.length; g++)
           {
              ar[g] = -1;
              end = g;
           }
           j = end - 1;
       }
    }
    return ans;
}
 
// Driver code
    var K = 2;
    var s = "000000";
 
    document.write(count(K, s));
 
</script>
Output: 
2
 
Time Complexity: O(N * K) 
Auxiliary Space: O(1)
 

My Personal Notes
arrow_drop_up
Previous
Count of occurrences of each prefix in a string using modified KMP algorithm
Next

Count of elements having Euler's Totient value one less than itself
Recommended Articles
Page :
Check if a number is prime in Flipped Upside Down, Mirror Flipped and Mirror Flipped Upside Down
04, Oct 20
Maximum sum of pairs that are at least K distance apart in an array
29, Apr 21
Check if every pair of 1 in the array is at least K length apart from each other
05, May 20
Check if all the Nodes in a Binary Tree having common values are at least D distance apart
11, Aug 20
Minimum Sum of a pair at least K distance apart from an Array
10, Aug 20
Maximize 0s to be flipped in given Binary array such that there are at least K 0s between two 1s
27, Oct 21
Maximum number of 0s that can be flipped such that Array has no adjacent 1s
13, Jun 20
Check if K '0's can be flipped such that Binary String contains no pair of adjacent '1's
14, Feb 21
Maximum sub-sequence sum such that indices of any two adjacent elements differs at least by 3
26, Jun 19
Smallest indexed array element required to be flipped to make sum of array equal to 0
28, Dec 20
Maximum length of a substring required to be flipped repeatedly to make all characters of binary string equal to 0
05, Aug 21
Minimum number of bits of array elements required to be flipped to make all array elements equal
19, Apr 21
Check whether Strings are k distance apart or not
09, Feb 17
Maximum subsequence sum such that all elements are K distance apart
06, Sep 19
Count of total bits toggled/flipped in binary representation of 0 to N
24, Jun 20
Count number of bits to be flipped to convert A to B | Set-2
20, Aug 19
Count number of bits to be flipped to convert A to B
05, Sep 09
Minimum days to make Array elements with value at least K sum at least X
07, Jul 21
Minimum cells to be flipped to get a 2*2 submatrix with equal elements
06, Dec 19
Minimum number of bits required to be flipped such that Bitwise OR of A and B is equal to C
19, Apr 21
Minimum prefixes required to be flipped to convert a Binary String to another
11, May 21
Minimize bits to be flipped in X and Y such that their Bitwise OR is equal to Z
29, Apr 20
Find zeroes to be flipped so that number of consecutive 1's is maximized
07, Nov 15
Count pairs (p, q) such that p occurs in array at least q times and q occurs at least p times
25, Feb 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
abhinavpande
@abhinavpande
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!