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
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:
- Traverse the given array arr[] and check whether the element is Perfect Square or not.
- 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.
- Now the given array is converted into Binary Array.
- 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++ program to Count of subarrays having // exactly K perfect square numbers. #include <bits/stdc++.h> 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[0]);
// Function Call
countSubarray(arr, N, K);
return 0;
} |
// 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<Integer, Integer> 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 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# 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 |
<script> // Javascript program to Count of subarrays having // exactly K perfect square numbers. // A utility function to check if // the number n is perfect square // or not function isPerfectSquare(x)
{ // Find floating point value of
// square root of x.
let 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 function findSubarraySum(arr, n, k)
{ // Map to store number of subarrays
// starting from index zero having
// particular value of sum.
let prevSum = new Map();
let res = 0;
// To store the sum of element
// traverse so far
let currsum = 0;
for (let 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.has(currsum - K))
res += (prevSum.get(currsum - K));
// Add currsum to count of
// different values of sum
prevSum.set(currsum,
prevSum.get(currsum)== null ?1:prevSum.get(currsum) + 1);
}
// Return the final result
return res;
} // Function to count the subarray with K // perfect square numbers function countSubarray(arr, n, k)
{ // Update the array element
for (let 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
document.write(findSubarraySum(arr, n, K));
} // Driver code let arr=[2, 4, 9, 2]; let K = 2; let N = arr.length; // Function Call countSubarray(arr, N, K); // This code is contributed by avanitrachhadiya2155 </script> |
4
Time Complexity: O(N)
Space Complexity: O(N)
Related Topic: Subarrays, Subsequences, and Subsets in Array