Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

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

  • Difficulty Level : Easy
  • Last Updated : 26 May, 2021

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, 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 <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
?>
Javascript



<script>
      // JavaScript 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) {
        var pos = new Array(n).fill(0);
        var 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;
 
        var ways = 1;
        for (i = 0; i < p - 1; i++) {
          ways *= pos[i + 1] - pos[i];
        }
 
        // Return the total ways
        return ways;
      }
 
      // Driver code
      var arr = [1, 0, 1, 0, 1];
      var n = arr.length;
      document.write(countWays(arr, n));
</script>
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
Count ways to split an array into subarrays such that sum of the i-th subarray is divisible by i
13, Aug 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
Number of ways to erase exactly one element in the Binary Array to make XOR zero
10, Oct 19
Sort Array by splitting into subarrays where each element belongs to only subarray
31, Aug 21
Split array into subarrays at minimum cost by minimizing count of repeating elements in each subarray
09, Sep 20
Split array into K subarrays such that sum of maximum of all subarrays is maximized
11, Jun 21
Check if Array can be split into subarrays such that XOR of length of Longest Decreasing Subsequences of those subarrays is 0
13, Dec 21
Split given arrays into subarrays to maximize the sum of maximum and minimum in each subarrays
27, Sep 21
Equally divide into two sets such that one set has maximum distinct elements
04, Sep 18
Ways to place 4 items in n^2 positions such that no row/column contains more than one
05, Mar 19
Count of subarrays which contains a given number exactly K times
29, May 20
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
Count the number of ways to divide an array into three contiguous parts having equal sum
18, May 17
Count number of ways to divide an array into two halves with same sum
24, May 19
Number of ways to divide an array into K equal sum sub-arrays
27, May 19
Find the largest interval that contains exactly one of the given N integers.
14, May 19
Divide an array into K subarray with the given condition
26, Sep 19
Maximum length of longest increasing contiguous subarray after deleting exactly one element from array
27, Oct 21
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

Start Your Coding Journey Now!