# Find a subarray of size K whose sum is a perfect square

Given an array arr[] and an integer K, the task is to find a subarray of length K having sum which is a perfect square. If no such subarray exists, then print -1. Otherwise, print the subarray.

Note: There can be more than one possible subarray. Print any one of them.
Examples:

Input: arr[] = {20, 34, 51, 10, 99, 87, 23, 45}, K = 3
Output: {10, 99, 87}
Explanation: Sum of the elements of the subarray {10, 99, 87} is 196 which is a perfect square (162 = 196).

Input: arr[] = {20, 34, 51, 10, 99, 87, 23, 45}, K = 4
Output: -1
Explanation: None of the subarrays of size K has a sum which is a perfect square.

Naive Approach: The simplest approach to solve the problem is to generate all possible subarrays of size K and check whether the sum of any subarray generated is a perfect square or not. If found to be true, print that subarray. If no subarray satisfies the condition, print “-1”
Time Complexity: O(N*K)
Auxiliary Space: O(K)

Efficient Approach: An efficient approach is to use a sliding window technique to find the sum of a contiguous subarray of size K and then check if the sum is a perfect square or not using Binary Search. Below are the steps to solve this problem:

1. Compute the sum of first K array elements and store it in a variable, say curr_sum.
2. Then iterate over the remaining array elements one by one, and update curr_sum by adding ith element and removing (i – K)th element from the array.
3. For every value of curr_sum obtained, check if it is a perfect square number or not.
4. If found to be true for any value of curr_sum, then print the corresponding subarray.
5. Otherwise, print -1.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to check if a given number` `// is a perfect square or not` `bool` `isPerfectSquare(``int` `n)` `{` `    ``// Find square root of n` `    ``double` `sr = ``sqrt``(n);`   `    ``// Check if the square root` `    ``// is an integer or not` `    ``return` `((sr - ``floor``(sr)) == 0);` `}`   `// Function to print the subarray` `// whose sum is a perfect square` `void` `SubarrayHavingPerfectSquare(` `    ``vector<``int``> arr, ``int` `k)` `{` `    ``pair<``int``, ``int``> ans;` `    ``int` `sum = 0, i;`   `    ``// Sum of first K elements` `    ``for` `(i = 0; i < k; i++) {` `        ``sum += arr[i];` `    ``}`   `    ``bool` `found = ``false``;`   `    ``// If the first k elements have` `    ``// a sum as perfect square` `    ``if` `(isPerfectSquare(sum)) {` `        ``ans.first = 0;` `        ``ans.second = i - 1;` `    ``}` `    ``else` `{`   `        ``// Iterate through the array` `        ``for` `(``int` `j = i;` `             ``j < arr.size(); j++) {`   `            ``sum = sum + arr[j] - arr[j - k];`   `            ``// If sum is perfect square` `            ``if` `(isPerfectSquare(sum)) {` `                ``found = ``true``;` `                ``ans.first = j - k + 1;` `                ``ans.second = j;` `            ``}` `        ``}`   `        ``for` `(``int` `k = ans.first;` `             ``k <= ans.second; k++) {` `            ``cout << arr[k] << ``" "``;` `        ``}` `    ``}`   `    ``// If subarray not found` `    ``if` `(found == ``false``) {` `        ``cout << ``"-1"``;` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given array` `    ``vector<``int``> arr;`   `    ``arr = { 20, 34, 51, 10,` `            ``99, 87, 23, 45 };`   `    ``// Given subarray size K` `    ``int` `K = 3;`   `    ``// Function Call` `    ``SubarrayHavingPerfectSquare(arr, K);`   `    ``return` `0;` `}`

## Java

 `// Java program for ` `// the above approach` `class` `GFG{` `    `  `static` `class` `pair` `{ ` `  ``int` `first, second; ` `}` `// Function to check if a given number` `// is a perfect square or not` `static` `boolean` `isPerfectSquare(``int` `n)` `{` `  ``// Find square root of n` `  ``double` `sr = Math.sqrt(n);`   `  ``// Check if the square root` `  ``// is an integer or not` `  ``return` `((sr - Math.floor(sr)) == ``0``);` `}`   `// Function to print the subarray` `// whose sum is a perfect square` `static` `void` `SubarrayHavingPerfectSquare(``int``[] arr, ` `                                        ``int` `k)` `{` `  ``pair ans = ``new` `pair();` `  ``int` `sum = ``0``, i;`   `  ``// Sum of first K elements` `  ``for` `(i = ``0``; i < k; i++) ` `  ``{` `    ``sum += arr[i];` `  ``}`   `  ``boolean` `found = ``false``;`   `  ``// If the first k elements have` `  ``// a sum as perfect square` `  ``if` `(isPerfectSquare(sum)) ` `  ``{` `    ``ans.first = ``0``;` `    ``ans.second = i - ``1``;` `  ``}` `  ``else` `  ``{` `    ``// Iterate through the array` `    ``for` `(``int` `j = i; j < arr.length; j++) ` `    ``{` `      ``sum = sum + arr[j] - arr[j - k];`   `      ``// If sum is perfect square` `      ``if` `(isPerfectSquare(sum)) ` `      ``{` `        ``found = ``true``;` `        ``ans.first = j - k + ``1``;` `        ``ans.second = j;` `      ``}` `    ``}`   `    ``for` `(``int` `k1 = ans.first; ` `             ``k1 <= ans.second; k1++) ` `    ``{` `      ``System.out.print(arr[k1] + ``" "``);` `    ``}` `  ``}`   `  ``// If subarray not found` `  ``if` `(found == ``false``) ` `  ``{` `    ``System.out.print(``"-1"``);` `  ``}` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `  ``// Given array` `  ``int` `[]arr = {``20``, ``34``, ``51``, ``10``,` `               ``99``, ``87``, ``23``, ``45``};`   `  ``// Given subarray size K` `  ``int` `K = ``3``;`   `  ``// Function Call` `  ``SubarrayHavingPerfectSquare(arr, K);`   `}` `}`   `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 program for the above approach` `from` `math ``import` `sqrt, ceil, floor`   `# Function to check if a given number` `# is a perfect square or not` `def` `isPerfectSquare(n):`   `    ``# Find square root of n` `    ``sr ``=` `sqrt(n)`   `    ``# Check if the square root` `    ``# is an integer or not` `    ``return` `((sr ``-` `floor(sr)) ``=``=` `0``)`   `# Function to prthe subarray` `# whose sum is a perfect square` `def` `SubarrayHavingPerfectSquare(arr, k):`   `    ``ans ``=` `[ ``0``, ``0` `]` `    ``sum` `=` `0`   `    ``# Sum of first K elements` `    ``i ``=` `0` `    ``while` `i < k:` `        ``sum` `+``=` `arr[i]` `        ``i ``+``=` `1`   `    ``found ``=` `False`   `    ``# If the first k elements have` `    ``# a sum as perfect square` `    ``if` `(isPerfectSquare(``sum``)):` `        ``ans[``0``] ``=` `0` `        ``ans[``1``] ``=` `i ``-` `1`   `    ``else``:`   `        ``# Iterate through the array` `        ``for` `j ``in` `range``(i, ``len``(arr)):` `            ``sum` `=` `sum` `+` `arr[j] ``-` `arr[j ``-` `k]`   `            ``# If sum is perfect square` `            ``if` `(isPerfectSquare(``sum``)):` `                ``found ``=` `True` `                ``ans[``0``] ``=` `j ``-` `k ``+` `1` `                ``ans[``1``] ``=` `j`   `        ``for` `k ``in` `range``(ans[``0``], ans[``1``] ``+` `1``):` `            ``print``(arr[k], end ``=` `" "``)`   `    ``# If subarray not found` `    ``if` `(found ``=``=` `False``):` `        ``print``(``"-1"``)`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``# Given array` `    ``arr ``=` `[ ``20``, ``34``, ``51``, ``10``,` `            ``99``, ``87``, ``23``, ``45` `]`   `    ``# Given subarray size K` `    ``K ``=` `3`   `    ``# Function call` `    ``SubarrayHavingPerfectSquare(arr, K)`   `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for ` `// the above approach` `using` `System;` `class` `GFG{` `    `  `class` `pair` `{ ` `  ``public` `int` `first, second; ` `}` `  `  `// Function to check if a given number` `// is a perfect square or not` `static` `bool` `isPerfectSquare(``int` `n)` `{` `  ``// Find square root of n` `  ``double` `sr = Math.Sqrt(n);`   `  ``// Check if the square root` `  ``// is an integer or not` `  ``return` `((sr - Math.Floor(sr)) == 0);` `}`   `// Function to print the subarray` `// whose sum is a perfect square` `static` `void` `SubarrayHavingPerfectSquare(``int``[] arr, ` `                                        ``int` `k)` `{` `  ``pair ans = ``new` `pair();` `  ``int` `sum = 0, i;`   `  ``// Sum of first K elements` `  ``for` `(i = 0; i < k; i++) ` `  ``{` `    ``sum += arr[i];` `  ``}`   `  ``bool` `found = ``false``;`   `  ``// If the first k elements have` `  ``// a sum as perfect square` `  ``if` `(isPerfectSquare(sum)) ` `  ``{` `    ``ans.first = 0;` `    ``ans.second = i - 1;` `  ``}` `  ``else` `  ``{` `    ``// Iterate through the array` `    ``for` `(``int` `j = i; j < arr.Length; j++) ` `    ``{` `      ``sum = sum + arr[j] - arr[j - k];`   `      ``// If sum is perfect square` `      ``if` `(isPerfectSquare(sum)) ` `      ``{` `        ``found = ``true``;` `        ``ans.first = j - k + 1;` `        ``ans.second = j;` `      ``}` `    ``}`   `    ``for` `(``int` `k1 = ans.first; ` `             ``k1 <= ans.second; k1++) ` `    ``{` `      ``Console.Write(arr[k1] + ``" "``);` `    ``}` `  ``}`   `  ``// If subarray not found` `  ``if` `(found == ``false``) ` `  ``{` `    ``Console.Write(``"-1"``);` `  ``}` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `  ``// Given array` `  ``int` `[]arr = {20, 34, 51, 10,` `               ``99, 87, 23, 45};`   `  ``// Given subarray size K` `  ``int` `K = 3;`   `  ``// Function Call` `  ``SubarrayHavingPerfectSquare(arr, K);`   `}` `}`   `// This code is contributed by Rajput-Ji`

Output:

```10 99 87

```

Time Complexity: O(N*log(sum))
Auxiliary Space:O(1)

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 