Given an integer **K** and an array **arr[]**, the task is to find the number of subsequences from the given array such that each subsequence consists exactly K prime numbers.**Example:**

Input:K = 2, arr = [2, 3, 4, 6]Output:4Explanation:

There are 4 subsequences which consists exaclty 2 prime numbers {2, 3} {2, 3, 4} {2, 3, 6} {2, 3, 4, 6}Input:K = 3, arr = [1, 2, 3, 4, 5, 6, 7]Output:32Explanation:

There are 32 subsequences which consists exaclty 3 prime numbers.

**Approach:** To solve the problem mentioned above we have to find the count of prime numbers in the given array.

- Let the count of prime numbers is
*m*. - We can choose any K integers among
*m*prime numbers. - So the possible combination of choosing prime numbers in the subsequence is and in the subsequence we can add any number of non – prime numbers because there is no restriction on the non prime numbers where count of non prime numbers will be (N – m).
- We can choose any subset of the (N – m) for nonprime numbers in our subsequence.
- Possibility of choosing all subset of size (N – m) is
**pow(2, (m – N))**. - For generating subsequences, we will multiply prime number possibility with nonprime number possibility.

Sub sequence count = (Count of prime numbers) C (K) * pow(2, count of non-prime numbers)

Below is the implementation of the above approach:

## C++

`// C++ implementation to find` `// the count of subsequences` `// which consist exactly K primes` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Returns factorial of n` `int` `fact(` `int` `n)` `{` ` ` `int` `res = 1;` ` ` `for` `(` `int` `i = 2; i <= n; i++)` ` ` `res = res * i;` ` ` `return` `res;` `}` `// Function to return total` `// number of combinations` `int` `nCr(` `int` `n, ` `int` `r)` `{` ` ` `return` `fact(n)` ` ` `/ (fact(r)` ` ` `* fact(n - r));` `}` `// Function check whether a number` `// is prime or not` `bool` `isPrime(` `int` `n)` `{` ` ` `// Corner case` ` ` `if` `(n <= 1)` ` ` `return` `false` `;` ` ` `// Check from 2 to n-1` ` ` `for` `(` `int` `i = 2; i < n; i++)` ` ` `if` `(n % i == 0)` ` ` `return` `false` `;` ` ` `return` `true` `;` `}` `// Function for finding number of subsequences` `// which consists exactly K primes` `int` `countSubsequences(` `int` `arr[], ` `int` `n, ` `int` `k)` `{` ` ` `int` `countPrime = 0;` ` ` `for` `(` `int` `i = 0; i < n; i++) {` ` ` `if` `(isPrime(arr[i]))` ` ` `countPrime++;` ` ` `}` ` ` `// if number of primes are less thn k` ` ` `if` `(countPrime < k)` ` ` `return` `0;` ` ` `return` `nCr(countPrime, k)` ` ` `* ` `pow` `(2, (n - countPrime));` `}` `// Driver code` `int` `main()` `{` ` ` `int` `arr[] = { 1, 2, 3, 4, 5, 6, 7 };` ` ` `int` `K = 3;` ` ` `int` `n = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]);` ` ` `cout << countSubsequences(arr, n, K);` ` ` `return` `0;` `}` |

## Java

`// Java implementation to find the` `// count of subsequences which` `// consist exactly K primes` `import` `java.util.*;` `class` `GFG{` ` ` `// Returns factorial of n` `static` `int` `fact(` `int` `n)` `{` ` ` `int` `res = ` `1` `;` ` ` `for` `(` `int` `i = ` `2` `; i <= n; i++)` ` ` `res = res * i;` ` ` ` ` `return` `res;` `}` `// Function to return total` `// number of combinations` `static` `int` `nCr(` `int` `n, ` `int` `r)` `{` ` ` `return` `fact(n) / (fact(r) *` ` ` `fact(n - r));` `}` `// Function check whether a number` `// is prime or not` `static` `boolean` `isPrime(` `int` `n)` `{` ` ` ` ` `// Corner case` ` ` `if` `(n <= ` `1` `)` ` ` `return` `false` `;` ` ` `// Check from 2 to n-1` ` ` `for` `(` `int` `i = ` `2` `; i < n; i++)` ` ` `if` `(n % i == ` `0` `)` ` ` `return` `false` `;` ` ` `return` `true` `;` `}` `// Function for finding number of subsequences` `// which consists exactly K primes` `static` `int` `countSubsequences(` `int` `arr[],` ` ` `int` `n, ` `int` `k)` `{` ` ` `int` `countPrime = ` `0` `;` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++)` ` ` `{` ` ` `if` `(isPrime(arr[i]))` ` ` `countPrime++;` ` ` `}` ` ` ` ` `// If number of primes are less thn k` ` ` `if` `(countPrime < k)` ` ` `return` `0` `;` ` ` `return` `nCr(countPrime, k) *` ` ` `(` `int` `)Math.pow(` `2` `, (n - countPrime));` `}` `// Driver code` `public` `static` `void` `main(String args[])` `{` ` ` `int` `arr[] = { ` `1` `, ` `2` `, ` `3` `, ` `4` `, ` `5` `, ` `6` `, ` `7` `};` ` ` `int` `K = ` `3` `;` ` ` `int` `n = arr.length;` ` ` `System.out.println(countSubsequences(arr, n, K));` `}` `}` `// This code is contributed by ANKITKUMAR34` |

## Python3

`# Python3 implementation to find the` `# count of subsequences which consist` `# exactly K primes` `# Returns factorial of n` `def` `fact(n):` ` ` ` ` `res ` `=` `1` `;` ` ` `for` `i ` `in` `range` `(` `2` `, n ` `+` `1` `):` ` ` `res ` `=` `res ` `*` `i` ` ` ` ` `return` `res` `# Function to return total` `# number of combinations` `def` `nCr(n, r):` ` ` ` ` `return` `(fact(n) ` `/` `/` `(fact(r) ` `*` ` ` `fact(n ` `-` `r)))` `# Function check whether a number` `# is prime or not` `def` `isPrime(n):` ` ` ` ` `# Corner case` ` ` `if` `(n <` `=` `1` `):` ` ` `return` `False` `;` ` ` `# Check from 2 to n-1` ` ` `for` `i ` `in` `range` `(` `2` `, n):` ` ` `if` `(n ` `%` `i ` `=` `=` `0` `):` ` ` `return` `False` ` ` `return` `True` `# Function for finding number of subsequences` `# which consists exactly K primes` `def` `countSubsequences(arr, n, k):` ` ` ` ` `countPrime ` `=` `0` ` ` `for` `i ` `in` `range` `(n):` ` ` `if` `(isPrime(arr[i])):` ` ` `countPrime ` `+` `=` `1` ` ` ` ` `# If number of primes are less than k` ` ` `if` `(countPrime < k):` ` ` `return` `0` ` ` `return` `(nCr(countPrime, k) ` `*` ` ` `pow` `(` `2` `, (n ` `-` `countPrime)))` `# Driver code` `arr ` `=` `[ ` `1` `, ` `2` `, ` `3` `, ` `4` `, ` `5` `, ` `6` `, ` `7` `]` `K ` `=` `3` `n ` `=` `len` `(arr)` `print` `(countSubsequences(arr, n, K))` `# This code is contributed by ANKITKUMAR34` |

## C#

`// C# implementation to find the` `// count of subsequences which` `// consist exactly K primes` `using` `System;` `class` `GFG{` ` ` `// Returns factorial of n` `static` `int` `fact(` `int` `n)` `{` ` ` `int` `res = 1;` ` ` `for` `(` `int` `i = 2; i <= n; i++)` ` ` `res = res * i;` ` ` ` ` `return` `res;` `}` `// Function to return total` `// number of combinations` `static` `int` `nCr(` `int` `n, ` `int` `r)` `{` ` ` `return` `fact(n) / (fact(r) *` ` ` `fact(n - r));` `}` `// Function check whether a number` `// is prime or not` `static` `bool` `isPrime(` `int` `n)` `{` ` ` ` ` `// Corner case` ` ` `if` `(n <= 1)` ` ` `return` `false` `;` ` ` `// Check from 2 to n-1` ` ` `for` `(` `int` `i = 2; i < n; i++)` ` ` `if` `(n % i == 0)` ` ` `return` `false` `;` ` ` `return` `true` `;` `}` `// Function for finding number of subsequences` `// which consists exactly K primes` `static` `int` `countSubsequences(` `int` `[]arr,` ` ` `int` `n, ` `int` `k)` `{` ` ` `int` `countPrime = 0;` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `{` ` ` `if` `(isPrime(arr[i]))` ` ` `countPrime++;` ` ` `}` ` ` ` ` `// If number of primes are less than k` ` ` `if` `(countPrime < k)` ` ` `return` `0;` ` ` `return` `nCr(countPrime, k) *` ` ` `(` `int` `)Math.Pow(2, (n - countPrime));` `}` `// Driver code` `public` `static` `void` `Main(String []args)` `{` ` ` `int` `[]arr = { 1, 2, 3, 4, 5, 6, 7 };` ` ` `int` `K = 3;` ` ` `int` `n = arr.Length;` ` ` `Console.WriteLine(countSubsequences(arr, n, K));` `}` `}` `// This code is contributed by gauravrajput1` |

## Javascript

`<script>` `// Javascript implementation to find` `// the count of subsequences` `// which consist exactly K primes` `// Returns factorial of n` `function` `fact(n)` `{` ` ` `var` `res = 1;` ` ` `for` `(` `var` `i = 2; i <= n; i++)` ` ` `res = res * i;` ` ` `return` `res;` `}` `// Function to return total` `// number of combinations` `function` `nCr(n, r)` `{` ` ` `return` `fact(n)` ` ` `/ (fact(r)` ` ` `* fact(n - r));` `}` `// Function check whether a number` `// is prime or not` `function` `isPrime(n)` `{` ` ` `// Corner case` ` ` `if` `(n <= 1)` ` ` `return` `false` `;` ` ` `// Check from 2 to n-1` ` ` `for` `(` `var` `i = 2; i < n; i++)` ` ` `if` `(n % i == 0)` ` ` `return` `false` `;` ` ` `return` `true` `;` `}` `// Function for finding number of subsequences` `// which consists exactly K primes` `function` `countSubsequences(arr, n, k)` `{` ` ` `var` `countPrime = 0;` ` ` `for` `(` `var` `i = 0; i < n; i++) {` ` ` `if` `(isPrime(arr[i]))` ` ` `countPrime++;` ` ` `}` ` ` `// if number of primes are less thn k` ` ` `if` `(countPrime < k)` ` ` `return` `0;` ` ` `return` `nCr(countPrime, k)` ` ` `* Math.pow(2, (n - countPrime));` `}` `// Driver code` `var` `arr = [ 1, 2, 3, 4, 5, 6, 7 ];` `var` `K = 3;` `var` `n = arr.length;` `document.write( countSubsequences(arr, n, K));` `</script>` |

**Output:**

32

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the **Essential Maths for CP Course** at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**