# Count sub-sets that satisfy the given condition

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 = 2Output:3

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 2Input:arr[] = {2, 3, 4, 5}, x = 1Output: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
**2**^{count}– 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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.