Skip to content
Related Articles
Find a subarray of size K whose sum is a perfect square
• Difficulty Level : Easy
• Last Updated : 08 Jun, 2021

Given an array arr[] and an integer K, the task is to find a subarray of length K having a 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: The 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 the 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 print the 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`

## Javascript

 ``
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up