# 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 positions 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  ` `    ``// positions 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 `

## Python3

 `# Python 3 implementation of the approach ` ` `  `# Function to return the number of ways ` `# the array can be divided into sub-arrays ` `# satisfying the given condition ` `def` `countWays(are, n): ` `    ``pos ``=` `[``0` `for` `i ``in` `range``(n)] ` `    ``p ``=` `0` ` `  `    ``# for loop for saving the positions ` `    ``# of all 1s ` `    ``for` `i ``in` `range``(n): ` `        ``if` `(arr[i] ``=``=` `1``): ` `            ``pos[p] ``=` `i ``+` `1` `            ``p ``+``=` `1` ` `  `    ``# If array contains only 0s ` `    ``if` `(p ``=``=` `0``): ` `        ``return` `0` ` `  `    ``ways ``=` `1` `    ``for` `i ``in` `range``(p ``-` `1``): ` `        ``ways ``*``=` `pos[i ``+` `1``] ``-` `pos[i] ` ` `  `    ``# Return the total ways ` `    ``return` `ways ` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``arr ``=` `[``1``, ``0``, ``1``, ``0``, ``1``] ` `    ``n ``=` `len``(arr) ` `    ``print``(countWays(arr, n)) ` `     `  `# This code is contributed by ` `# Surendra_Gangwar `

## 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 positions ` `    ``// 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

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.