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

• Difficulty Level : Easy
• Last Updated : 15 Sep, 2022

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:
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:

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, the answer equals the 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

 ``

## Javascript

 ``

Output

`4`

Complexity Analysis:

• Time Complexity: O(n), where n is the size of the given array
• Auxiliary Space: O(n), as extra space of size n was used

My Personal Notes arrow_drop_up