Skip to content
Related Articles

Related Articles

Related Articles

Save Article
Improve Article
Save Article
Like Article

Count ways to partition a Binary String such that each substring contains exactly two 0s

  • Difficulty Level : Hard
  • Last Updated : 27 Apr, 2021

Given binary string str, the task is to find the count of ways to partition the string such that each partitioned substring contains exactly two 0s.

Examples:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: str = “00100” 
Output: 2
Explanation: 
Possible ways to partition the string such that each partition contains exactly two 0s are: { {“00”, “100”}, {“001”, “00”} }. 
Therefore, the required output is 2.



Input: str = “000” 
Output: 0

Approach: The idea is to calculate the count of 1s between every two consecutive 0s of the given string. Follow the steps below to solve the problem:

  • Initialize an array, say IdxOf0s[], to store the indices of 0s in the given string.
  • Iterate over the characters of the given string and store the indices of the 0s into IdxOf0s[].
  • Initialize a variable, say cntWays, to store the count of ways to partition the string such that each partition contains exactly two 0s.
  • If the count of 0s in the given string is odd, then update cntWays = 0.
  • Otherwise, traverse the array IdxOf0s[] and calculate the count of ways to partition the array having each partition exactly two 0s using cntWays *= (IdxOf0s[i] – IdxOf0s[i – 1])
  • Finally, print the value of cntWays.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find count of ways to partition
// the string such that each partition
// contains exactly two 0s.
int totalWays(int n, string str)
{
 
    // Stores indices of 0s in
    // the given string.
    vector<int> IdxOf0s;
 
    // Store the count of ways to partition
    // the string such that each partition
    // contains exactly two 0s.
    int cntWays = 1;
 
    // Iterate over each characters
    // of the given string
    for (int i = 0; i < n; i++) {
 
        // If current character is '0'
        if (str[i] == '0') {
 
            // Insert index
            IdxOf0s.push_back(i);
        }
    }
 
    // Stores total count of 0s in str
    int M = IdxOf0s.size();
 
    if (M == 0 or M % 2) {
 
        return 0;
    }
 
    // Traverse the array, IdxOf0s[]
    for (int i = 2; i < M; i += 2) {
 
        // Update cntWays
        cntWays = cntWays * (IdxOf0s[i]
                             - IdxOf0s[i - 1]);
    }
 
    return cntWays;
}
 
// Driver Code
int main()
{
    string str = "00100";
 
    int n = str.length();
 
    cout << totalWays(n, str);
 
    return 0;
}
Java



// Java program for the above approach
import java.util.*;
class GFG
{
       
// Function to find count of ways to partition
// the string such that each partition
// contains exactly two 0s.
static int totalWays(int n, String str)
{
   
    // Stores indices of 0s in
    // the given string.
    ArrayList<Integer> IdxOf0s = 
                    new ArrayList<Integer>();
   
    // Store the count of ways to partition
    // the string such that each partition
    // contains exactly two 0s.
    int cntWays = 1;
   
    // Iterate over each characters
    // of the given string
    for (int i = 0; i < n; i++)
    {
   
        // If current character is '0'
        if (str.charAt(i) == '0')
        {
   
            // Insert index
            IdxOf0s.add(i);
        }
    }
   
    // Stores total count of 0s in str
    int M = IdxOf0s.size();
    if ((M == 0) || ((M % 2) != 0))
    {
        return 0;
    }
   
    // Traverse the array, IdxOf0s[]
    for (int i = 2; i < M; i += 2)
    {
   
        // Update cntWays
        cntWays = cntWays * (IdxOf0s.get(i)
                             - IdxOf0s.get(i - 1));
    } 
    return cntWays;
}
   
// Driver code
public static void main(String[] args)
{
    String str = "00100";
    int n = str.length();
    System.out.print(totalWays(n, str));
}
}
 
// This code is contributed by sanjoy_62.
Python3



# Python3 program for the above approach
 
# Function to find count of ways to partition
# thesuch that each partition
# contains exactly two 0s.
def totalWays(n, str):
     
    # Stores indices of 0s in
    # the given string.
    IdxOf0s = []
 
    # Store the count of ways to partition
    # the such that each partition
    # contains exactly two 0s.
    cntWays = 1
 
    # Iterate over each characters
    # of the given string
    for i in range(n):
         
        # If current character is '0'
        if (str[i] == '0'):
             
            # Insert index
            IdxOf0s.append(i)
 
    # Stores total count of 0s in str
    M = len(IdxOf0s)
 
    if (M == 0 or M % 2):
        return 0
 
    # Traverse the array, IdxOf0s[]
    for i in range(2, M, 2):
         
        # Update cntWays
        cntWays = cntWays * (IdxOf0s[i] -
                             IdxOf0s[i - 1])
 
    return cntWays
 
# Driver Code
if __name__ == '__main__':
     
   str = "00100"
   n = len(str)
    
   print(totalWays(n, str))
 
# This code is contributed by mohit kumar 29
C#



// C# program for the above approach
using System;
using System.Collections; 
using System.Collections.Generic; 
 
class GFG
{
 
  // Function to find count of ways to partition
  // the string such that each partition
  // contains exactly two 0s.
  static int totalWays(int n, string str)
  {
 
    // Stores indices of 0s in
    // the given string.
    ArrayList IdxOf0s
      = new ArrayList();
 
    // Store the count of ways to partition
    // the string such that each partition
    // contains exactly two 0s.
    int cntWays = 1;
 
    // Iterate over each characters
    // of the given string
    for (int i = 0; i < n; i++)
    {
 
      // If current character is '0'
      if (str[i] == '0')
      {
 
        // Insert index
        IdxOf0s.Add(i);
      }
    }
 
    // Stores total count of 0s in str
    int M = IdxOf0s.Count;
    if ((M == 0) || ((M % 2) != 0)) {
      return 0;
    }
 
    // Traverse the array, IdxOf0s[]
    for (int i = 2; i < M; i += 2)
    {
 
      // Update cntWays
      cntWays = cntWays * (Convert.ToInt32(IdxOf0s[i]) -
                           Convert.ToInt32(IdxOf0s[i - 1]));
    }
    return cntWays;
  }
 
  // Driver code
  static public void Main()
  {
    string str = "00100";
    int n = str.Length;
    Console.Write(totalWays(n, str));
  }
}
 
// This code is contributed by Dharanendra L V
Javascript



<script>
 
// Javascript program for the above approach
 
// Function to find count of ways to partition
// the string such that each partition
// contains exactly two 0s.
function totalWays(n, str)
{
 
    // Stores indices of 0s in
    // the given string.
    var IdxOf0s = [];
 
    // Store the count of ways to partition
    // the string such that each partition
    // contains exactly two 0s.
    var cntWays = 1;
 
    // Iterate over each characters
    // of the given string
    for (var i = 0; i < n; i++) {
 
        // If current character is '0'
        if (str[i] == '0') {
 
            // Insert index
            IdxOf0s.push(i);
        }
    }
 
    // Stores total count of 0s in str
    var M = IdxOf0s.length;
 
    if (M == 0 || M % 2) {
 
        return 0;
    }
 
    // Traverse the array, IdxOf0s[]
    for (var i = 2; i < M; i += 2) {
 
        // Update cntWays
        cntWays = cntWays * (IdxOf0s[i]
                            - IdxOf0s[i - 1]);
    }
 
    return cntWays;
}
 
// Driver Code
var str = "00100";
var n = str.length;
document.write( totalWays(n, str));
 
</script>
Output: 
2
 
Time Complexity: O(N)
Auxiliary Space: O(N)



My Personal Notes
arrow_drop_up
Previous
ReactJS getDerivedStateFromError() Method
Next

Count all possible values of K less than Y such that GCD(X, Y) = GCD(X+K, Y)
Recommended Articles
Page :
Ways to divide a binary array into sub-arrays such that each sub-array contains exactly one 1
28, Jan 19
Partition given string in such manner that i'th substring is sum of (i-1)'th and (i-2)'th substring
15, Feb 18
Number of Positions to partition the string such that atleast m characters with same frequency are present in each substring
17, Apr 19
Ways to split string such that each partition starts with distinct character
05, Apr 18
Construct a string of length L such that each substring of length X has exactly Y distinct letters
30, Apr 20
Count ways to partition a string such that both parts have equal distinct characters
08, Apr 20
Count of binary strings of length N having equal count of 0's and 1's and count of 1's ≥ count of 0's in each prefix substring
25, Jul 20
Minimum flips required in a binary string such that all K-size substring contains 1
24, Jun 20
Count substring of Binary string such that each character belongs to a palindrome of size greater than 1
15, Jul 20
Check if the string contains consecutive letters and each letter occurs exactly once
03, Apr 19
Check if a string can be split into two substrings such that one substring is a substring of the other
23, Dec 20
Generate a string of size N whose each substring of size M has exactly K distinct characters
21, Apr 20
Find the String having each substring with exactly K distinct characters
26, Apr 20
Number of ways to partition a string into two balanced subsequences
15, Nov 18
Count ways to distribute exactly one coin to each worker
10, Sep 20
Maximum splits in binary string such that each substring is divisible by given odd number
13, May 20
Lengths of maximized partitions of a string such that each character of the string appears in one substring
15, Sep 20
Maximized partitions of a string such that each character of the string appears in one substring
15, Sep 20
Count ways to remove objects such that exactly M equidistant objects remain
18, Mar 21
Partition the string in two parts such that both parts have at least k different characters
03, Jul 19
Length of smallest substring of a given string which contains another string as subsequence
06, Oct 20
Check if a string contains an anagram of another string as its substring
15, Feb 21
Smallest String consisting of a String S exactly K times as a Substring
12, Aug 20
Count ways to partition a number into increasing sequences of digits
17, Jun 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
KrishnaHare
@KrishnaHare
Vote for difficulty
Current difficulty :
Hard





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