# Count of subarrays having exactly K prime numbers

Given an array arr[] of N integers and a number K. The task is to count the number of subarray with exactly K Prime Numbers.

Example:

Input: arr[] = {1, 2, 3, 4}, K = 2
Output: 4
Explanation:
Since total number of prime number in the array are 2. So the 4 subarray with 2 prime number are:
1. {2, 3}
2. {1, 2, 3}
3. {2, 3, 4}
4. {1, 2, 3, 4}

Input: arr[] = {2, 4, 5}, K = 3
Output: 0
Explanation:
Since total number of prime number in the array are 2 which is less than K(K = 3).
So there is no such subarray with K primes.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

1. Traverse the given array arr[] and check whether the element is prime or not.
2. If the current element is prime then change the value of array that that index to 1, Else change the value at that index to 0.
3. Now the given array is converted into Binary Array.
4. Find the count of subarray with sum equals to K in the above Binary Array using the approach discussed in this article.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// A utility function to check if ` `// the number n is prime or not ` `bool` `isPrime(``int` `n) ` `{ ` `    ``int` `i; ` ` `  `    ``// Base Cases ` `    ``if` `(n <= 1) ` `        ``return` `false``; ` `    ``if` `(n <= 3) ` `        ``return` `true``; ` ` `  `    ``// Check to skip middle five ` `    ``// numbers in below loop ` `    ``if` `(n % 2 == 0 || n % 3 == 0) { ` `        ``return` `false``; ` `    ``} ` ` `  `    ``for` `(i = 5; i * i <= n; i += 6) { ` ` `  `        ``// If n is divisible by i & i+2 ` `        ``// then it is not prime ` `        ``if` `(n % i == 0 ` `            ``|| n % (i + 2) == 0) { ` `            ``return` `false``; ` `        ``} ` `    ``} ` ` `  `    ``return` `true``; ` `} ` ` `  `// Function to find number of subarrays ` `// with sum exactly equal to k ` `int` `findSubarraySum(``int` `arr[], ``int` `n, ``int` `K) ` `{ ` `    ``// STL map to store number of subarrays ` `    ``// starting from index zero having ` `    ``// particular value of sum. ` `    ``unordered_map<``int``, ``int``> prevSum; ` ` `  `    ``int` `res = 0; ` ` `  `    ``// To store the sum of element traverse ` `    ``// so far ` `    ``int` `currsum = 0; ` ` `  `    ``for` `(``int` `i = 0; i < n; i++) { ` ` `  `        ``// Add current element to currsum ` `        ``currsum += arr[i]; ` ` `  `        ``// If currsum = K, then a new ` `        ``// subarray is found ` `        ``if` `(currsum == K) { ` `            ``res++; ` `        ``} ` ` `  `        ``// If currsum > K then find the ` `        ``// no. of subarrays with sum ` `        ``// currsum - K and exclude those ` `        ``// subarrays ` `        ``if` `(prevSum.find(currsum - K) ` `            ``!= prevSum.end()) ` `            ``res += (prevSum[currsum - K]); ` ` `  `        ``// Add currsum to count of ` `        ``// different values of sum ` `        ``prevSum[currsum]++; ` `    ``} ` ` `  `    ``// Return the final result ` `    ``return` `res; ` `} ` ` `  `// Function to count the subarray with K primes ` `void` `countSubarray(``int` `arr[], ``int` `n, ``int` `K) ` `{ ` `    ``// Update the array element ` `    ``for` `(``int` `i = 0; i < n; i++) { ` ` `  `        ``// If current element is prime ` `        ``// then update the arr[i] to 1 ` `        ``if` `(isPrime(arr[i])) { ` `            ``arr[i] = 1; ` `        ``} ` ` `  `        ``// Else change arr[i] to 0 ` `        ``else` `{ ` `            ``arr[i] = 0; ` `        ``} ` `    ``} ` ` `  `    ``// Function Call ` `    ``cout << findSubarraySum(arr, n, K); ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 1, 2, 3, 4 }; ` `    ``int` `K = 2; ` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr); ` ` `  `    ``// Function Call ` `    ``countSubarray(arr, N, K); ` `    ``return` `0; ` `} `

## Java

 `// Java program for the above approach ` ` `  `import` `java.util.*; ` ` `  `class` `GFG { ` ` `  `    ``// A utility function to check if ` `    ``// the number n is prime or not ` `    ``static` `boolean` `isPrime(``int` `n) { ` `        ``int` `i; ` ` `  `        ``// Base Cases ` `        ``if` `(n <= ``1``) ` `            ``return` `false``; ` `        ``if` `(n <= ``3``) ` `            ``return` `true``; ` ` `  `        ``// Check to skip middle five ` `        ``// numbers in below loop ` `        ``if` `(n % ``2` `== ``0` `|| n % ``3` `== ``0``) { ` `            ``return` `false``; ` `        ``} ` ` `  `        ``for` `(i = ``5``; i * i <= n; i += ``6``) { ` ` `  `            ``// If n is divisible by i & i+2 ` `            ``// then it is not prime ` `            ``if` `(n % i == ``0` `|| n % (i + ``2``) == ``0``) { ` `                ``return` `false``; ` `            ``} ` `        ``} ` ` `  `        ``return` `true``; ` `    ``} ` ` `  `    ``// Function to find number of subarrays ` `    ``// with sum exactly equal to k ` `    ``static` `int` `findSubarraySum(``int` `arr[], ``int` `n, ``int` `K)  ` `    ``{ ` `        ``// STL map to store number of subarrays ` `        ``// starting from index zero having ` `        ``// particular value of sum. ` `        ``HashMap prevSum = ` `             ``new` `HashMap(); ` ` `  `        ``int` `res = ``0``; ` ` `  `        ``// To store the sum of element traverse ` `        ``// so far ` `        ``int` `currsum = ``0``; ` ` `  `        ``for` `(``int` `i = ``0``; i < n; i++) { ` ` `  `            ``// Add current element to currsum ` `            ``currsum += arr[i]; ` ` `  `            ``// If currsum = K, then a new ` `            ``// subarray is found ` `            ``if` `(currsum == K) { ` `                ``res++; ` `            ``} ` ` `  `            ``// If currsum > K then find the ` `            ``// no. of subarrays with sum ` `            ``// currsum - K and exclude those ` `            ``// subarrays ` `            ``if` `(prevSum.containsKey(currsum - K)) { ` `                ``res += (prevSum.get(currsum - K)); ` `            ``} ` `            ``// Add currsum to count of ` `            ``// different values of sum ` `            ``if` `(prevSum.containsKey(currsum)) ` `                ``prevSum.put(currsum, prevSum.get(currsum) + ``1``); ` `            ``else` `                ``prevSum.put(currsum, ``1``); ` `        ``} ` ` `  `        ``// Return the final result ` `        ``return` `res; ` `    ``} ` ` `  `    ``// Function to count the subarray with K primes ` `    ``static` `void` `countSubarray(``int` `arr[], ``int` `n, ``int` `K) { ` `        ``// Update the array element ` `        ``for` `(``int` `i = ``0``; i < n; i++) { ` ` `  `            ``// If current element is prime ` `            ``// then update the arr[i] to 1 ` `            ``if` `(isPrime(arr[i])) { ` `                ``arr[i] = ``1``; ` `            ``} ` ` `  `            ``// Else change arr[i] to 0 ` `            ``else` `{ ` `                ``arr[i] = ``0``; ` `            ``} ` `        ``} ` ` `  `        ``// Function Call ` `        ``System.out.print(findSubarraySum(arr, n, K)); ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String[] args) { ` `        ``int` `arr[] = { ``1``, ``2``, ``3``, ``4` `}; ` `        ``int` `K = ``2``; ` `        ``int` `N = arr.length; ` ` `  `        ``// Function Call ` `        ``countSubarray(arr, N, K); ` `    ``} ` `} ` ` `  `// This code contributed by Rajput-Ji `

## Python3

 `# Python3 program for the above approach ` `from` `math ``import` `sqrt ` ` `  ` `  `# A utility function to check if ` `# the number n is prime or not ` `def` `isPrime(n): ` `    ``# Base Cases ` `    ``if` `(n <``=` `1``): ` `        ``return` `False` `    ``if` `(n <``=` `3``): ` `        ``return` `True` ` `  `    ``# Check to skip middle five ` `    ``# numbers in below loop ` `    ``if` `(n ``%` `2` `=``=` `0` `or` `n ``%` `3` `=``=` `0``): ` `        ``return` `False` ` `  `    ``for` `i ``in` `range``(``5``,``int``(sqrt(n))``+``1``,``6``): ` `        ``# If n is divisible by i & i+2 ` `        ``# then it is not prime ` `        ``if` `(n ``%` `i ``=``=` `0` `or` `n ``%` `(i ``+` `2``) ``=``=` `0``): ` `            ``return` `False` ` `  `    ``return` `True` ` `  `# Function to find number of subarrays ` `# with sum exactly equal to k ` `def` `findSubarraySum(arr,n,K): ` `    ``# STL map to store number of subarrays ` `    ``# starting from index zero having ` `    ``# particular value of sum. ` `    ``prevSum ``=` `{i:``0` `for` `i ``in` `range``(``100``)} ` ` `  `    ``res ``=` `0` ` `  `    ``# To store the sum of element traverse ` `    ``# so far ` `    ``currsum ``=` `0` ` `  `    ``for` `i ``in` `range``(n): ` `        ``# Add current element to currsum ` `        ``currsum ``+``=` `arr[i] ` ` `  `        ``# If currsum = K, then a new ` `        ``# subarray is found ` `        ``if` `(currsum ``=``=` `K): ` `            ``res ``+``=` `1` ` `  `        ``# If currsum > K then find the ` `        ``# no. of subarrays with sum ` `        ``# currsum - K and exclude those ` `        ``# subarrays ` `        ``if` `(currsum ``-` `K) ``in` `prevSum: ` `            ``res ``+``=` `(prevSum[currsum ``-` `K]) ` ` `  `        ``# Add currsum to count of ` `        ``# different values of sum ` `        ``prevSum[currsum] ``+``=` `1` ` `  `    ``# Return the final result ` `    ``return` `res ` ` `  `# Function to count the subarray with K primes ` `def` `countSubarray(arr,n,K): ` `    ``# Update the array element ` `    ``for` `i ``in` `range``(n): ` `        ``# If current element is prime ` `        ``# then update the arr[i] to 1 ` `        ``if` `(isPrime(arr[i])): ` `            ``arr[i] ``=` `1` ` `  `        ``# Else change arr[i] to 0 ` `        ``else``: ` `            ``arr[i] ``=` `0` ` `  `    ``# Function Call ` `    ``print``(findSubarraySum(arr, n, K)) ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``arr ``=`  `[``1``, ``2``, ``3``, ``4``] ` `    ``K ``=` `2` `    ``N ``=` `len``(arr) ` ` `  `    ``# Function Call ` `    ``countSubarray(arr, N, K) ` ` `  `# This code is contributed by Surendra_Gangwar `

## C#

 `// C# program for the above approach ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG{ ` ` `  `// A utility function to check if ` `// the number n is prime or not ` `static` `bool` `isPrime(``int` `n) ` `{ ` `    ``int` `i; ` ` `  `    ``// Base Cases ` `    ``if` `(n <= 1) ` `        ``return` `false``; ` `    ``if` `(n <= 3) ` `        ``return` `true``; ` ` `  `    ``// Check to skip middle five ` `    ``// numbers in below loop ` `    ``if` `(n % 2 == 0 || n % 3 == 0) ` `    ``{ ` `        ``return` `false``; ` `    ``} ` ` `  `    ``for``(i = 5; i * i <= n; i += 6) ` `    ``{ ` `        `  `       ``// If n is divisible by i & i+2 ` `       ``// then it is not prime ` `       ``if` `(n % i == 0 || n % (i + 2) == 0) ` `       ``{ ` `           ``return` `false``; ` `       ``} ` `    ``} ` `    ``return` `true``; ` `} ` ` `  `// Function to find number of subarrays ` `// with sum exactly equal to k ` `static` `int` `findSubarraySum(``int` `[]arr, ``int` `n, ` `                                      ``int` `K)  ` `{ ` `     `  `    ``// STL map to store number of subarrays ` `    ``// starting from index zero having ` `    ``// particular value of sum. ` `    ``Dictionary<``int``, ``int``> prevSum = ``new` `Dictionary<``int``, ``int``>(); ` `     `  `    ``int` `res = 0; ` ` `  `    ``// To store the sum of element traverse ` `    ``// so far ` `    ``int` `currsum = 0; ` ` `  `    ``for``(``int` `i = 0; i < n; i++) ` `    ``{ ` `        `  `       ``// Add current element to currsum ` `       ``currsum += arr[i]; ` `        `  `       ``// If currsum = K, then a new ` `       ``// subarray is found ` `       ``if` `(currsum == K) ` `       ``{ ` `           ``res++; ` `       ``} ` `        `  `       ``// If currsum > K then find the ` `       ``// no. of subarrays with sum ` `       ``// currsum - K and exclude those ` `       ``// subarrays ` `       ``if` `(prevSum.ContainsKey(currsum - K)) ` `       ``{ ` `           ``res += (prevSum[currsum - K]); ` `       ``} ` `        `  `       ``// Add currsum to count of ` `       ``// different values of sum ` `       ``if` `(prevSum.ContainsKey(currsum)) ` `       ``{ ` `           ``prevSum[currsum] = prevSum[currsum] + 1; ` `       ``} ` `       ``else` `       ``{ ` `           ``prevSum.Add(currsum, 1); ` `       ``} ` `    ``} ` `     `  `    ``// Return the readonly result ` `    ``return` `res; ` `} ` ` `  `// Function to count the subarray with K primes ` `static` `void` `countSubarray(``int` `[]arr, ``int` `n, ``int` `K) ` `{ ` `     `  `    ``// Update the array element ` `    ``for``(``int` `i = 0; i < n; i++) ` `    ``{ ` `        `  `       ``// If current element is prime ` `       ``// then update the arr[i] to 1 ` `       ``if` `(isPrime(arr[i])) ` `       ``{ ` `           ``arr[i] = 1; ` `       ``} ` `        `  `       ``// Else change arr[i] to 0 ` `       ``else`  `       ``{ ` `           ``arr[i] = 0; ` `       ``} ` `    ``} ` `     `  `    ``// Function Call ` `    ``Console.Write(findSubarraySum(arr, n, K)); ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int` `[]arr = { 1, 2, 3, 4 }; ` `    ``int` `K = 2; ` `    ``int` `N = arr.Length; ` ` `  `    ``// Function Call ` `    ``countSubarray(arr, N, K); ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

Output:

```4
```

Time Complexity: O(N*log(log(N)))

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.