Skip to content
Related Articles

Related Articles

Ways to divide a binary array into sub-arrays such that each sub-array contains exactly one 1
  • Difficulty Level : Easy
  • Last Updated : 24 May, 2019

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

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 <bits/stdc++.h>
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



<?php
// PHP implementation of the approach 
  
// Function to return the number of ways 
// the array can be divided into sub-arrays 
// satisfying the given condition 
function countWays($arr, $n) 
{ 
    $pos = array_fill(0, $n, 0); 
    $p = 0 ;
  
    // 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; 
  
    $ways = 1; 
    for ($i = 0; $i < $p - 1; $i++) 
    { 
        $ways *= $pos[$i + 1] - $pos[$i]; 
    } 
  
    // Return the total ways 
    return $ways; 
} 
  
// Driver code 
$arr = array(1, 0, 1, 0, 1); 
$n = sizeof($arr); 
echo countWays($arr, $n); 
  
// This code is contributed by Ryuga
?>
Output:
4




My Personal Notes
arrow_drop_up
Previous
Wipro National Elite Talent Hunt 2019 Interview Experience
Next

Make all numbers of an array equal
Recommended Articles
Page :
Count ways to partition a Binary String such that each substring contains exactly two 0s
13, Jan 21
Split array into K disjoint subarrays such that sum of each subarray is odd.
25, Mar 20
Count ways to split array into two equal sum subarrays by changing sign of any one array element
03, Dec 20
Count ways to split array into two equal sum subarrays by replacing each array element to 0 once
13, Nov 20
Partition array into two subarrays with every element in the right subarray strictly greater than every element in left subarray
01, Mar 21
Count ways to distribute exactly one coin to each worker
10, Sep 20
Split array into subarrays at minimum cost by minimizing count of repeating elements in each subarray
09, Sep 20
Number of ways to erase exactly one element in the Binary Array to make XOR zero
10, Oct 19
Equally divide into two sets such that one set has maximum distinct elements
04, Sep 18
Count of subarrays which contains a given number exactly K times
29, May 20
Ways to place 4 items in n^2 positions such that no row/column contains more than one
05, Mar 19
Split array into maximum subarrays such that every distinct element lies in a single subarray
27, Sep 20
Find if it is possible to choose subarray that it contains exactly K even integers
13, Apr 20
Divide an array into K subarray with the given condition
26, Sep 19
Number of ways to divide an array into K equal sum sub-arrays
27, May 19
Count number of ways to divide an array into two halves with same sum
24, May 19
Count the number of ways to divide an array into three contiguous parts having equal sum
18, May 17
Find the largest interval that contains exactly one of the given N integers.
14, May 19
Check if all subarrays contains at least one unique element
25, Oct 20
Divide array into two sub-arrays such that their averages are equal
27, Jan 17
Count of ways to split an Array into three contiguous Subarrays having increasing Sum
15, Aug 20
Count ways to split array into two subarrays with equal GCD
19, Nov 20
Number of ways to choose an integer such that there are exactly K elements greater than it in the given array
04, Feb 19
Divide binary array into three equal parts with same value
04, Nov 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Aditya98
@Aditya98
Vote for difficulty
Current difficulty :
Easy





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