# Count of subarrays having exactly K perfect square numbers

Given a unsorted integer array arr[] and an integer K. The task is to count the number of subarray with exactly K Perfect Square Numbers.
Examples:

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

Input: arr[] = {4, 2, 5}, K = 3
Output: 0

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

Simple Approach:
Generate all the subarrays and count the number of perfect numbers in the given subarray if the count is equal to K increment the count for ans variable.
Time Complexity: O(N2)

Efficient Approach:

1. Traverse the given array arr[] and check whether the element is Perfect Square or not.
2. If the current element is Perfect Square then change the value of array at that index to 1, Else change the value at that index to 0.
3. Now the given array is converted into Binary Array.
4. Now, 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 to Count of subarrays having ` `// exactly K perfect square numbers. ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// A utility function to check if ` `// the number n is perfect square ` `// or not ` `bool` `isPerfectSquare(``long` `double` `x) ` `{ ` `    ``// Find floating point value of ` `    ``// square root of x. ` `    ``long` `double` `sr = ``sqrt``(x); ` ` `  `    ``// If square root is an integer ` `    ``return` `((sr - ``floor``(sr)) == 0); ` `} ` ` `  `// 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 ` `// perfect square numbers ` `void` `countSubarray(``int` `arr[], ``int` `n, ``int` `K) ` `{ ` `    ``// Update the array element ` `    ``for` `(``int` `i = 0; i < n; i++) { ` ` `  `        ``// If current element is perfect ` `        ``// square then update the ` `        ``// arr[i] to 1 ` `        ``if` `(isPerfectSquare(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[] = { 2, 4, 9, 2 }; ` `    ``int` `K = 2; ` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr); ` ` `  `    ``// Function Call ` `    ``countSubarray(arr, N, K); ` `    ``return` `0; ` `} `

## Java

 `// Java program to Count of subarrays having ` `// exactly K perfect square numbers. ` `import` `java.util.*; ` ` `  `class` `GFG { ` ` `  `// A utility function to check if ` `// the number n is perfect square ` `// or not ` `static` `boolean` `isPerfectSquare(``double` `x) ` `{ ` `         `  `    ``// Find floating point value of ` `    ``// square root of x. ` `    ``double` `sr = Math.sqrt(x); ` ` `  `    ``// If square root is an integer ` `    ``return` `((sr - Math.floor(sr)) == ``0``); ` `} ` ` `  `// Function to find number of subarrays ` `// with sum exactly equal to k ` `static` `int` `findSubarraySum(``int` `arr[],  ` `                           ``int` `n, ``int` `K) ` `{ ` `     `  `    ``// Map to store number of subarrays ` `    ``// starting from index zero having ` `    ``// particular value of sum. ` `    ``Map 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 ` `       ``prevSum.put(currsum,  ` `                   ``prevSum.getOrDefault(currsum, ``0``) + ``1``); ` `    ``} ` `     `  `    ``// Return the final result ` `    ``return` `res; ` `} ` ` `  `// Function to count the subarray with K ` `// perfect square numbers ` `static` `void` `countSubarray(``int` `arr[], ``int` `n, ``int` `K) ` `{ ` `     `  `    ``// Update the array element ` `    ``for``(``int` `i = ``0``; i < n; i++) ` `    ``{ ` `         `  `       ``// If current element is perfect ` `       ``// square then update the ` `       ``// arr[i] to 1 ` `       ``if` `(isPerfectSquare(arr[i])) ` `       ``{ ` `           ``arr[i] = ``1``; ` `       ``} ` `        `  `       ``// Else change arr[i] to 0 ` `       ``else`  `       ``{ ` `           ``arr[i] = ``0``; ` `       ``} ` `    ``} ` ` `  `    ``// Function Call ` `    ``System.out.println(findSubarraySum(arr, n, K)); ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `arr[] = { ``2``, ``4``, ``9``, ``2` `}; ` `    ``int` `K = ``2``; ` `    ``int` `N = arr.length; ` ` `  `    ``// Function Call ` `    ``countSubarray(arr, N, K); ` `} ` `} ` ` `  `// This code is contributed by offbeat `

## Python3

 `# Python3 program to count of subarrays  ` `# having exactly K perfect square numbers. ` `from` `collections ``import` `defaultdict  ` `import` `math  ` ` `  `# A utility function to check if ` `# the number n is perfect square ` `# or not ` `def` `isPerfectSquare(x): ` ` `  `    ``# Find floating point value of ` `    ``# square root of x. ` `    ``sr ``=` `math.sqrt(x) ` ` `  `    ``# If square root is an integer ` `    ``return` `((sr ``-` `math.floor(sr)) ``=``=` `0``) ` ` `  `# 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 ``=` `defaultdict(``int``) ` ` `  `    ``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 ` `# perfect square numbers ` `def` `countSubarray(arr, n, K): ` ` `  `    ``# Update the array element ` `    ``for` `i ``in` `range``(n): ` ` `  `        ``# If current element is perfect ` `        ``# square then update the ` `        ``# arr[i] to 1 ` `        ``if` `(isPerfectSquare(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 ``=` `[ ``2``, ``4``, ``9``, ``2` `] ` `    ``K ``=` `2` `    ``N ``=` `len``(arr) ` ` `  `    ``# Function Call ` `    ``countSubarray(arr, N, K) ` ` `  `# This code is contributed by chitranayal `

## C#

 `// C# program to count of subarrays having ` `// exactly K perfect square numbers. ` `using` `System;  ` `using` `System.Collections;  ` `using` `System.Collections.Generic;  ` ` `  `class` `GFG{ ` `     `  `// A utility function to check if ` `// the number n is perfect square ` `// or not ` `static` `bool` `isPerfectSquare(``double` `x) ` `{ ` `         `  `    ``// Find floating point value of ` `    ``// square root of x. ` `    ``double` `sr = Math.Sqrt(x); ` ` `  `    ``// If square root is an integer ` `    ``return` `((sr - Math.Floor(sr)) == 0); ` `} ` ` `  `// Function to find number of subarrays ` `// with sum exactly equal to k ` `static` `int` `findSubarraySum(``int` `[]arr,  ` `                           ``int` `n, ``int` `K) ` `{ ` `     `  `    ``// 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]++; ` `        ``} ` `        ``else` `        ``{ ` `            ``prevSum[currsum] = 1; ` `        ``} ` `    ``} ` `     `  `    ``// Return the final result ` `    ``return` `res; ` `} ` ` `  `// Function to count the subarray with K ` `// perfect square numbers ` `static` `void` `countSubarray(``int` `[]arr, ``int` `n, ` `                                     ``int` `K) ` `{ ` `     `  `    ``// Update the array element ` `    ``for``(``int` `i = 0; i < n; i++) ` `    ``{ ` `         `  `        ``// If current element is perfect ` `        ``// square then update the ` `        ``// arr[i] to 1 ` `        ``if` `(isPerfectSquare(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 = { 2, 4, 9, 2 }; ` `    ``int` `K = 2; ` `    ``int` `N = arr.Length; ` ` `  `    ``// Function call ` `    ``countSubarray(arr, N, K); ` `} ` `} ` ` `  `// This code is contributed by rutvik_56 `

Output:

```4
```

Time Complexity: O(N)
Space Complexity: O(N)

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.

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.

Improved By : offbeat, chitranayal, rutvik_56