# Ways to divide a binary array into sub-arrays such that each sub-array contains exactly one 1

Give an integer array arr[] consisting of elements from the set {0, 1}. The task is to print the number of ways the array can be divided into sub-arrays such that each sub-array contains exactly one 1.

Examples:

Input: arr[] = {1, 0, 1, 0, 1}
Output: 4
Below are the possible ways:

• {1, 0}, {1, 0}, {1}
• {1}, {0, 1, 0}, {1}
• {1, 0}, {1}, {0, 1}
• {1}, {0, 1}, {0, 1}

Input: arr[] = {0, 0, 0}
Output: 0

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

• When all the elements of the array are 0 then the result will be zero.
• Else, between two adjacent ones we must have only one separation. So, answer equals to product of values posi + 1 – posi (for all valid pairs) where posi is the position of ith 1.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return the number of ways ` `// the array can be divided into sub-arrays ` `// satisfying the given condition ` `int` `countWays(``int` `arr[], ``int` `n) ` `{ ` ` `  `    ``int` `pos[n], p = 0, i; ` ` `  `    ``// for loop for saving the postions of all 1s ` `    ``for` `(i = 0; i < n; i++) { ` `        ``if` `(arr[i] == 1) { ` `            ``pos[p] = i + 1; ` `            ``p++; ` `        ``} ` `    ``} ` ` `  `    ``// If array contains only 0s ` `    ``if` `(p == 0) ` `        ``return` `0; ` ` `  `    ``int` `ways = 1; ` `    ``for` `(i = 0; i < p - 1; i++) { ` `        ``ways *= pos[i + 1] - pos[i]; ` `    ``} ` ` `  `    ``// Return the total ways ` `    ``return` `ways; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 1, 0, 1, 0, 1 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]); ` `    ``cout << countWays(arr, n); ` `    ``return` `0; ` `} `

## Java

// Java implementation of the approach
class GFG
{

// Function to return the number of ways
// the array can be divided into sub-arrays
// satisfying the given condition
static int countWays(int arr[], int n)
{
int pos[] = new int[n];
int p = 0, i;

// for loop for saving the
// postions of all 1s
for (i = 0; i < n; i++) { if (arr[i] == 1) { pos[p] = i + 1; p++; } } // If array contains only 0s if (p == 0) return 0; int ways = 1; for (i = 0; i < p - 1; i++) { ways *= pos[i + 1] - pos[i]; } // Return the total ways return ways; } // Driver code public static void main(String args[]) { int[] arr = { 1, 0, 1, 0, 1 }; int n = arr.length; System.out.println(countWays(arr, n)); } } // This code is contributed // by Akanksha Rai [tabby title="C#"]

 `// C# implementation of the approach ` `using` `System; ` ` `  `class` `GFG ` `{ ` `     `  `// Function to return the number of ways ` `// the array can be divided into sub-arrays ` `// satisfying the given condition ` `static` `int` `countWays(``int``[] arr, ``int` `n) ` `{ ` `    ``int``[] pos = ``new` `int``[n];  ` `    ``int` `p = 0, i; ` ` `  `    ``// for loop for saving the postions ` `    ``// of all 1s ` `    ``for` `(i = 0; i < n; i++)  ` `    ``{ ` `        ``if` `(arr[i] == 1)  ` `        ``{ ` `            ``pos[p] = i + 1; ` `            ``p++; ` `        ``} ` `    ``} ` ` `  `    ``// If array contains only 0s ` `    ``if` `(p == 0) ` `        ``return` `0; ` ` `  `    ``int` `ways = 1; ` `    ``for` `(i = 0; i < p - 1; i++)  ` `    ``{ ` `        ``ways *= pos[i + 1] - pos[i]; ` `    ``} ` ` `  `    ``// Return the total ways ` `    ``return` `ways; ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main() ` `{ ` `    ``int``[] arr = { 1, 0, 1, 0, 1 }; ` `    ``int` `n = arr.Length; ` `    ``Console.Write(countWays(arr, n)); ` `} ` `} ` ` `  `// This code is contributed  ` `// by Akanksha Rai `

## PHP

 ` `

Output:

```4
```

My Personal Notes arrow_drop_up