Skip to content
Related Articles

Related Articles

Count sub-sets that satisfy the given condition

Improve Article
Save Article
  • Difficulty Level : Basic
  • Last Updated : 12 Sep, 2022
Improve Article
Save Article

Given an array arr[] and an integer x, the task is to count the number of sub-sets of arr[] sum of all of whose sub-sets (individually) is divisible by x.

Examples: 

Input: arr[] = {2, 4, 3, 7}, x = 2 
Output:
All valid sub-sets are {2}, {4} and {2, 4} 
{2} => 2 is divisible by 2 
{4} => 4 is divisible by 2 
{2, 4} => 2, 4 and 6 are all divisible by 2

Input: arr[] = {2, 3, 4, 5}, x = 1 
Output: 15 

Approach: To choose a sub-set sum of all of whose sub-sets is divisible by x, all the elements of the sub-set must be divisible by x. So, 

  • Count all the elements from the array that is divisible by x and store them in a variable count.
  • Now, all possible sub-sets satisfying the condition will be 2count – 1

Below is the implementation of the above approach:

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
#define ll long long int
using namespace std;
 
// Function to return the count of the required sub-sets
ll count(int arr[], int n, int x)
{
 
    // Every element is divisible by 1
    if (x == 1) {
        ll ans = pow(2, n) - 1;
        return ans;
    }
 
    // Count of elements which are divisible by x
    int count = 0;
    for (int i = 0; i < n; i++) {
        if (arr[i] % x == 0)
            count++;
    }
 
    ll ans = pow(2, count) - 1;
    return ans;
}
 
// Driver code
int main()
{
    int arr[] = { 2, 4, 3, 5 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int x = 1;
    cout << count(arr, n, x) << endl;
    return 0;
}

Java




// Java implementation of the approach
import java.util.*;
 
class solution
{
 
// Function to return the count of the required sub-sets
static long count(int arr[], int n, int x)
{
 
    // Every element is divisible by 1
    if (x == 1) {
        long ans = (long)Math.pow(2, n) - 1;
        return ans;
    }
 
    // Count of elements which are divisible by x
    int count = 0;
    for (int i = 0; i < n; i++) {
        if (arr[i] % x == 0)
            count++;
    }
 
    long ans = (long)Math.pow(2, count) - 1;
    return ans;
}
 
// Driver code
public static void main(String args[])
{
    int []arr = { 2, 4, 3, 5 };
    int n = arr.length;
    int x = 1;
    System.out.println(count(arr, n, x));
}
}

Python3




# Python3 implementation of the approach
 
# Function to return the count of
# the required sub-sets
def count(arr, n, x) :
 
    # Every element is divisible by 1
    if (x == 1) :
        ans = pow(2, n) - 1
        return ans;
     
    # Count of elements which are
    # divisible by x
    count = 0
    for i in range(n) :
        if (arr[i] % x == 0) :
            count += 1
 
    ans = pow(2, count) - 1
    return ans
 
# Driver code
if __name__ == "__main__" :
 
    arr = [ 2, 4, 3, 5 ]
    n = len(arr)
    x = 1
    print(count(arr, n, x))
 
# This code is contributed by Ryuga

C#




//C# implementation of the approach
 
using System;
 
public class GFG{
     
// Function to return the count of the required sub-sets
static double count(int []arr, int n, int x)
{
    double ans=0;
    // Every element is divisible by 1
    if (x == 1) {
        ans = (Math.Pow(2, n) - 1);
        return ans;
    }
 
    // Count of elements which are divisible by x
    int count = 0;
    for (int i = 0; i < n; i++) {
        if (arr[i] % x == 0)
            count++;
    }
 
    ans = (Math.Pow(2, count) - 1);
    return ans;
}
 
// Driver code
     
    static public void Main (){
     
    int []arr = { 2, 4, 3, 5 };
    int n = arr.Length;
    int x = 1;
    Console.WriteLine(count(arr, n, x));
    }
}

PHP




<?php
// PHP  implementation of the approach
 
// Function to return the count of the required sub-sets
function count_t($arr, $n, $x)
{
    // Every element is divisible by 1
    if ($x == 1) {
    $ans = pow(2, $n) - 1;
        return $ans;
    }
 
    // Count of elements which are divisible by x
    $count = 0;
    for ($i = 0; $i < $n; $i++) {
        if ($arr[$i] % $x == 0)
            $count++;
    }
 
    $ans = pow(2, $count) - 1;
    return $ans;
}
 
// Driver code
 
    $arr = array( 2, 4, 3, 5 );
    $n = sizeof($arr) / sizeof($arr[0]);
    $x = 1;
    echo  count_t($arr, $n, $x);
     
#This code is contributed by akt_mit
?>

Javascript




<script>
 
    // Javascript implementation of the approach
     
    // Function to return the count of
    // the required sub-sets
    function count(arr, n, x)
    {
        let ans=0;
        // Every element is divisible by 1
        if (x == 1) {
            ans = (Math.pow(2, n) - 1);
            return ans;
        }
 
        // Count of elements which are divisible by x
        let count = 0;
        for (let i = 0; i < n; i++) {
            if (arr[i] % x == 0)
                count++;
        }
 
        ans = (Math.pow(2, count) - 1);
        return ans;
    }
     
    let arr = [ 2, 4, 3, 5 ];
    let n = arr.length;
    let x = 1;
    document.write(count(arr, n, x));
     
</script>

Output

15

Complexity Analysis:

  • Time complexity: O(n) because using a for loop
  • Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!