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

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:

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 ` `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 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.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

 ``

Output:

`2`

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