Skip to content
Related Articles

Related Articles

Count of pairs in an array whose sum is a perfect square

View Discussion
Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 09 Sep, 2022
View Discussion
Improve Article
Save Article

Given an array arr   of distinct elements, the task is to find the total number of two element pairs from the array whose sum is a perfect square

Examples:

Input: arr[] = {2, 3, 6, 9, 10, 20} 
Output: 2 Only possible pairs are (3, 6) and (6, 10) 

Input: arr[] = {9, 2, 5, 1} 
Output: 0

Naive Approach: Use nested loops and check every possible pair for whether their sum is a perfect square or not. This technique is not effective when the length of the array is very large. 

Efficient Approach:

  • Store all the elements of the array in a HashSet named nums and save the sum of the maximum two elements in a variable named max.
  • It is clear that the sum of any two elements from the array will not exceed max. So, find all the perfect squares which are ≤ max and save it in an ArrayList named perfectSquares.
  • Now for every element in the array say arr[i] and for every perfect square saved in perfectSquares, check whether perfectSquares.get(i) – arr[i] exists in nums or not i.e. if there is any element in the original array that when added with the currently chosen element gives any perfect square from the list.
  • If the above condition is satisfied, increment the count variable.
  • Print the value of count in the end.

Below is the implementation of the above approach: 

C++




// CPP implementation of the approach
 
#include <bits/stdc++.h>
using namespace std;
 
 
// Function to return an ArrayList containing
// all the perfect squares upto n
vector<int> getPerfectSquares(int n)
{
    vector<int> perfectSquares;
    int current = 1, i = 1;
 
    // while current perfect square is less than or equal to n
    while (current <= n)
    {
        perfectSquares.push_back(current);
        current = static_cast<int>(pow(++i, 2));
    }
    return perfectSquares;
}
 
// Function to print the sum of maximum
// two elements from the array
int maxPairSum(vector<int> &arr)
{
    int n = arr.size();
    int max, secondMax;
    if (arr[0] > arr[1])
    {
        max = arr[0];
        secondMax = arr[1];
    }
    else
    {
        max = arr[1];
        secondMax = arr[0];
    }
 
    for (int i = 2; i < n; i++)
    {
        if (arr[i] > max)
        {
            secondMax = max;
            max = arr[i];
        }
        else if (arr[i] > secondMax)
        {
            secondMax = arr[i];
        }
    }
    return (max + secondMax);
}
 
// Function to return the count of numbers that
// when added with n give a perfect square
int countPairsWith(int n, vector<int> &perfectSquares, unordered_set<int> &nums)
{
    int count = 0;
    for (int i = 0; i < perfectSquares.size(); i++)
    {
        int temp = perfectSquares[i] - n;
 
        // temp > n is checked so that pairs
        // (x, y) and (y, x) don't get counted twice
        if (temp > n && find(nums.begin(), nums.end(), temp) != nums.end())
        {
            count++;
        }
    }
    return count;
}
 
// Function to count the pairs whose sum is a perfect square
int countPairs(vector<int> &arr)
{
    int i, n = arr.size();
 
    // Sum of the maximum two elements from the array
    int max = maxPairSum(arr);
 
    // List of perfect squares upto max
    vector<int> perfectSquares = getPerfectSquares(max);
 
    // Contains all the array elements
    unordered_set<int> nums;
    for (i = 0; i < n; i++)
    {
        nums.insert(arr[i]);
    }
 
    int count = 0;
    for (i = 0; i < n; i++)
    {
 
        // Add count of the elements that when
        // added with arr[i] give a perfect square
        count += countPairsWith(arr[i], perfectSquares, nums);
    }
    return count;
}
 
// Driver code
int main()
{
    vector<int> arr = {2, 3, 6, 9, 10, 20};
 
    cout << countPairs(arr) << endl;
    return 0;
}
// This code is contributed by mits

Java




// Java implementation of the approach
import java.util.*;
 
public class GFG {
 
    // Function to return an ArrayList containing
    // all the perfect squares upto n
    public static ArrayList<Integer> getPerfectSquares(int n)
    {
        ArrayList<Integer> perfectSquares = new ArrayList<>();
        int current = 1, i = 1;
 
        // while current perfect square is less than or equal to n
        while (current <= n) {
            perfectSquares.add(current);
            current = (int)Math.pow(++i, 2);
        }
        return perfectSquares;
    }
 
    // Function to print the sum of maximum
    // two elements from the array
    public static int maxPairSum(int arr[])
    {
        int n = arr.length;
        int max, secondMax;
        if (arr[0] > arr[1]) {
            max = arr[0];
            secondMax = arr[1];
        }
        else {
            max = arr[1];
            secondMax = arr[0];
        }
 
        for (int i = 2; i < n; i++) {
            if (arr[i] > max) {
                secondMax = max;
                max = arr[i];
            }
            else if (arr[i] > secondMax) {
                secondMax = arr[i];
            }
        }
        return (max + secondMax);
    }
 
    // Function to return the count of numbers that
    // when added with n give a perfect square
    public static int countPairsWith(
        int n, ArrayList<Integer> perfectSquares,
                            HashSet<Integer> nums)
    {
        int count = 0;
        for (int i = 0; i < perfectSquares.size(); i++) {
            int temp = perfectSquares.get(i) - n;
 
            // temp > n is checked so that pairs
            // (x, y) and (y, x) don't get counted twice
            if (temp > n && nums.contains(temp))
                count++;
        }
        return count;
    }
 
    // Function to count the pairs whose sum is a perfect square
    public static int countPairs(int arr[])
    {
        int i, n = arr.length;
 
        // Sum of the maximum two elements from the array
        int max = maxPairSum(arr);
 
        // List of perfect squares upto max
        ArrayList<Integer> perfectSquares =
                                    getPerfectSquares(max);
 
        // Contains all the array elements
        HashSet<Integer> nums = new HashSet<>();
        for (i = 0; i < n; i++)
            nums.add(arr[i]);
 
        int count = 0;
        for (i = 0; i < n; i++) {
 
            // Add count of the elements that when
            // added with arr[i] give a perfect square
            count += countPairsWith(arr[i], perfectSquares, nums);
        }
        return count;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int arr[] = { 2, 3, 6, 9, 10, 20 };
 
        System.out.println(countPairs(arr));
    }
}

Python3




# Python3 implementation of the approach
 
# Function to return an ArrayList containing
# all the perfect squares upto n
def getPerfectSquares(n):
 
    perfectSquares = [];
    current = 1;
    i = 1;
 
    # while current perfect square is
    # less than or equal to n
    while (current <= n):
        perfectSquares.append(current);
        i += 1;
        current = int(pow(i, 2));
 
    return perfectSquares;
 
# Function to print the sum of maximum
# two elements from the array
def maxPairSum(arr):
 
    n = len(arr);
    max = 0;
    secondMax = 0;
    if (arr[0] > arr[1]):
        max = arr[0];
        secondMax = arr[1];
    else:
        max = arr[1];
        secondMax = arr[0];
 
    for i in range(2, n):
        if (arr[i] > max):
            secondMax = max;
            max = arr[i];
        elif (arr[i] > secondMax):
            secondMax = arr[i];
 
    return (max + secondMax);
 
# Function to return the count of numbers that
# when added with n give a perfect square
def countPairsWith(n, perfectSquares, nums):
 
    count = 0;
    for i in range(len(perfectSquares)):
        temp = perfectSquares[i] - n;
 
        # temp > n is checked so that pairs
        # (x, y) and (y, x) don't get counted twice
        if (temp > n and (temp in nums)):
            count += 1;
 
    return count;
 
# Function to count the pairs whose
# sum is a perfect square
def countPairs(arr):
 
    n = len(arr);
 
    # Sum of the maximum two elements
    # from the array
    max = maxPairSum(arr);
 
    # List of perfect squares upto max
    perfectSquares = getPerfectSquares(max);
 
    # Contains all the array elements
    nums = [];
    for i in range(n):
        nums.append(arr[i]);
 
    count = 0;
    for i in range(n):
 
        # Add count of the elements that when
        # added with arr[i] give a perfect square
        count += countPairsWith(arr[i],
                 perfectSquares, nums);
    return count;
 
# Driver code
arr = [ 2, 3, 6, 9, 10, 20 ];
print(countPairs(arr));
 
# This code is contributed by mits

C#




// C# implementation of the approach
using System;
using System.Collections;
using System.Collections.Generic;
 
public class GFG {
 
    // Function to return an ArrayList containing
    // all the perfect squares upto n
    public static ArrayList getPerfectSquares(int n)
    {
        ArrayList perfectSquares = new ArrayList();
        int current = 1, i = 1;
 
        // while current perfect square is less than or equal to n
        while (current <= n) {
            perfectSquares.Add(current);
            current = (int)Math.Pow(++i, 2);
        }
        return perfectSquares;
    }
 
    // Function to print the sum of maximum
    // two elements from the array
    public static int maxPairSum(int[] arr)
    {
        int n = arr.Length;
        int max, secondMax;
        if (arr[0] > arr[1]) {
            max = arr[0];
            secondMax = arr[1];
        }
        else {
            max = arr[1];
            secondMax = arr[0];
        }
 
        for (int i = 2; i < n; i++) {
            if (arr[i] > max) {
                secondMax = max;
                max = arr[i];
            }
            else if (arr[i] > secondMax) {
                secondMax = arr[i];
            }
        }
        return (max + secondMax);
    }
 
    // Function to return the count of numbers that
    // when added with n give a perfect square
    public static int countPairsWith(
        int n, ArrayList perfectSquares, ArrayList nums)
    {
        int count = 0;
        for (int i = 0; i < perfectSquares.Count; i++) {
            int temp = (int)perfectSquares[i] - n;
 
            // temp > n is checked so that pairs
            // (x, y) and (y, x) don't get counted twice
            if (temp > n && nums.Contains(temp))
                count++;
        }
        return count;
    }
 
    // Function to count the pairs whose sum is a perfect square
    public static int countPairs(int[] arr)
    {
        int i, n = arr.Length;
 
        // Sum of the maximum two elements from the array
        int max = maxPairSum(arr);
 
        // List of perfect squares upto max
        ArrayList perfectSquares = getPerfectSquares(max);
 
        // Contains all the array elements
        ArrayList nums = new ArrayList();
        for (i = 0; i < n; i++)
            nums.Add(arr[i]);
 
        int count = 0;
        for (i = 0; i < n; i++) {
 
            // Add count of the elements that when
            // added with arr[i] give a perfect square
            count += countPairsWith(arr[i], perfectSquares, nums);
        }
        return count;
    }
 
    // Driver code
    public static void Main()
    {
        int[] arr = { 2, 3, 6, 9, 10, 20 };
 
        Console.WriteLine(countPairs(arr));
    }
}
// This code is contributed by mits

PHP




<?php
// PHP implementation of the approach
 
// Function to return an ArrayList containing
// all the perfect squares upto n
function getPerfectSquares($n)
{
    $perfectSquares = array();
    $current = 1;
    $i = 1;
 
    // while current perfect square
    // is less than or equal to n
    while ($current <= $n)
    {
        array_push($perfectSquares, $current);
        $current = (int)pow(++$i, 2);
    }
    return $perfectSquares;
}
 
// Function to print the sum of maximum
// two elements from the array
function maxPairSum($arr)
{
    $n = count($arr);
    $max;
    $secondMax;
    if ($arr[0] > $arr[1])
    {
        $max = $arr[0];
        $secondMax = $arr[1];
    }
    else
    {
        $max = $arr[1];
        $secondMax = $arr[0];
    }
 
    for ($i = 2; $i < $n; $i++)
    {
        if ($arr[$i] > $max)
        {
            $secondMax = $max;
            $max = $arr[$i];
        }
        else if ($arr[$i] > $secondMax)
        {
            $secondMax = $arr[$i];
        }
    }
    return ($max + $secondMax);
}
 
// Function to return the count of numbers that
// when added with n give a perfect square
function countPairsWith($n, $perfectSquares, $nums)
{
    $count = 0;
    for ($i = 0; $i < count($perfectSquares); $i++)
    {
        $temp = $perfectSquares[$i] - $n;
 
        // temp > n is checked so that pairs
        // (x, y) and (y, x) don't get counted twice
        if ($temp > $n && in_array($temp, $nums))
            $count++;
    }
    return $count;
}
 
// Function to count the pairs whose
// sum is a perfect square
function countPairs($arr)
{
    $n = count($arr);
 
    // Sum of the maximum two elements
    // from the array
    $max = maxPairSum($arr);
 
    // List of perfect squares upto max
    $perfectSquares = getPerfectSquares($max);
 
    // Contains all the array elements
    $nums = array();
    for ($i = 0; $i < $n; $i++)
        array_push($nums, $arr[$i]);
 
    $count = 0;
    for ($i = 0; $i < $n; $i++)
    {
 
        // Add count of the elements that when
        // added with arr[i] give a perfect square
        $count += countPairsWith($arr[$i],
                                 $perfectSquares, $nums);
    }
    return $count;
}
 
// Driver code
$arr = array( 2, 3, 6, 9, 10, 20 );
 
echo countPairs($arr);
 
// This code is contributed by mits    
?>

Javascript




<script>
// Javascript implementation of the approach
 
// Function to return an ArrayList containing
// all the perfect squares upto n
function getPerfectSquares(n)
{
    let perfectSquares = [];
    let current = 1;
    let i = 1;
 
    // while current perfect square
    // is less than or equal to n
    while (current <= n)
    {
        perfectSquares.push(current);
        current = Math.pow(++i, 2);
    }
    return perfectSquares;
}
 
// Function to print the sum of maximum
// two elements from the array
function maxPairSum(arr)
{
    let n = arr.length
    let max;
    let secondMax;
    if (arr[0] > arr[1])
    {
        max = arr[0];
        secondMax = arr[1];
    }
    else
    {
        max = arr[1];
        secondMax = arr[0];
    }
 
    for (let i = 2; i < n; i++)
    {
        if (arr[i] > max)
        {
            secondMax = max;
            max = arr[i];
        }
        else if (arr[i] > secondMax)
        {
            secondMax = arr[$i];
        }
    }
    return (max + secondMax);
}
 
// Function to return the count of numbers that
// when added with n give a perfect square
function countPairsWith(n, perfectSquares, nums)
{
    let count = 0;
    for (let i = 0; i < perfectSquares.length; i++)
    {
        let temp = perfectSquares[i] - n;
 
        // temp > n is checked so that pairs
        // (x, y) and (y, x) don't get counted twice
        if (temp > n && nums.includes(temp))
            count++;
    }
    return count;
}
 
// Function to count the pairs whose
// sum is a perfect square
function countPairs(arr)
{
    let n = arr.length
 
    // Sum of the maximum two elements
    // from the array
    let max = maxPairSum(arr);
 
    // List of perfect squares upto max
    let perfectSquares = getPerfectSquares(max);
 
    // Contains all the array elements
    let nums = [];
    for (let i = 0; i < n; i++)
        nums.push(arr[i]);
 
    let count = 0;
    for (let i = 0; i < n; i++)
    {
 
        // Add count of the elements that when
        // added with arr[i] give a perfect square
        count += countPairsWith(arr[i], perfectSquares, nums);
    }
    return count;
}
 
// Driver code
let arr = new Array( 2, 3, 6, 9, 10, 20 );
 
document.write(countPairs(arr));
 
// This code is contributed by Saurabh jaiswal
 
</script>

Output

2

My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!