Count array elements whose perfect squares are present in the given array

Last Updated : 23 Jul, 2025

Given an array arr[], the task is to find the count of array elements whose squares are already present in the array.

Examples:

Input: arr[] = {2, 4, 5, 20, 16}
Output: 2
Explanation:
{2, 4} has their squares {4, 16} present in the array.

Input: arr[] = {1, 30, 3, 8, 64}
Output: 2
Explanation:
{1, 8} has their squares {1, 64} present in the array.

Naive Approach: Follow the steps below to solve the problem:

Initialize a variable, say, count, to store the required count.
Traverse the array and for each and every array element, perform the following operations:
- Traverse the array and search if the square of the current element is present in the array.
- If the square found increment the count.
Print count as the answer.

Below is the implementation of the above approach:

C++14

// C++ program for the above approach

#include <bits/stdc++.h>
using namespace std;

// Function to find the count of elements whose
// squares are already present int the array
void countSquares(int arr[], int N)
{
    // Stores the required count
    int count = 0;

    // Traverse the array
    for (int i = 0; i < N; i++) {

        // Square of the element
        int square = arr[i] * arr[i];

        // Traverse the array
        for (int j = 0; j < N; j++) {

            // Check whether the value
            // is equal to square
            if (arr[j] == square) {

                // Increment count
                count = count + 1;
            }
        }
    }

    // Print the count
    cout << count;
}

// Driver Code
int main()
{
    // Given array
    int arr[] = { 2, 4, 5, 20, 16 };

    // Size of the array
    int N = sizeof(arr) / sizeof(arr[0]);

    countSquares(arr, N);

    return 0;
}

Java

// Java program for the above approach
import java.util.*;
class GFG{

// Function to find the count of elements whose
// squares are already present int the array
static void countSquares(int arr[], int N)
{
  
    // Stores the required count
    int count = 0;

    // Traverse the array
    for (int i = 0; i < N; i++)
    {

        // Square of the element
        int square = arr[i] * arr[i];

        // Traverse the array
        for (int j = 0; j < N; j++) 
        {

            // Check whether the value
            // is equal to square
            if (arr[j] == square)
            {

                // Increment count
                count = count + 1;
            }
        }
    }

    // Print the count
    System.out.print(count);
}

// Driver Code
public static void main(String[] args)
{
  
    // Given array
    int arr[] = { 2, 4, 5, 20, 16 };

    // Size of the array
    int N = arr.length;
    countSquares(arr, N);
}
}

// This code is contributed by shikhasingrajput

Python3

# Python program for the above approach

# Function to find the count of elements whose
# squares are already present the array
def countSquares(arr, N):
  
    # Stores the required count
    count = 0;

    # Traverse the array
    for i in range(N):

        # Square of the element
        square = arr[i] * arr[i];

        # Traverse the array
        for j in range(N):

            # Check whether the value
            # is equal to square
            if (arr[j] == square):
              
                # Increment count
                count = count + 1;

    # Print count
    print(count);

# Driver Code
if __name__ == '__main__':
  
    # Given array
    arr = [2, 4, 5, 20, 16];

    # Size of the array
    N = len(arr);
    countSquares(arr, N);

# This code is contributed by shikhasingrajput

// C# program of the above approach
using System;

class GFG{
    
// Function to find the count of elements whose 
// squares are already present int the array 
static void countSquares(int[] arr, int N) 
{ 
    
    // Stores the required count 
    int count = 0; 
    
    // Traverse the array 
    for(int i = 0; i < N; i++) 
    { 
        
        // Square of the element 
        int square = arr[i] * arr[i]; 
  
        // Traverse the array 
        for(int j = 0; j < N; j++)
        { 
            
            // Check whether the value 
            // is equal to square 
            if (arr[j] == square)
            { 
                
                // Increment count 
                count = count + 1; 
            } 
        } 
    } 
    
    // Print the count 
    Console.WriteLine(count); 
}    

// Driver code    
static void Main() 
{
    
    // Given array 
    int[] arr = { 2, 4, 5, 20, 16 }; 
    
    // Size of the array 
    int N = arr.Length; 
    
    countSquares(arr, N); 
}
}

// This code is contributed by divyeshrabadiya07

JavaScript

<script>

// Javascript program for the above approach

// Function to find the count of elements whose
// squares are already present int the array
function countSquares(arr, N)
{
    // Stores the required count
    var count = 0;

    // Traverse the array
    for (var i = 0; i < N; i++) {

        // Square of the element
        var square = arr[i] * arr[i];

        // Traverse the array
        for (var j = 0; j < N; j++) {

            // Check whether the value
            // is equal to square
            if (arr[j] == square) {

                // Increment count
                count = count + 1;
            }
        }
    }

    // Print the count
    document.write( count);
}

// Driver Code
// Given array
var arr = [2, 4, 5, 20, 16];
// Size of the array
var N = arr.length;
countSquares(arr, N);

</script>

Output:

Time Complexity: O(N²)
Auxiliary Space: O(1)

Efficient Approach: The optimal idea is to use unordered_map to keep the count of visited elements and update the variable count accordingly. Below are the steps:

Initialize a Map to store the frequency of array elements and initialize a variable, say, count.
Traverse the array and for each element, increment its count in the Map.
Again traverse the array and for each element check for the frequency of the square of the element in the map and add it to the variable count.
Print count as the number of elements whose square is already present in the array.

Below is the implementation of the above approach:

C++14

// C++ program for the above approach

#include <bits/stdc++.h>
using namespace std;

// Function to find the count of elements whose
// squares is already present int the array
int countSquares(int arr[], int N)
{
    // Stores the count of array elements
    int count = 0;

    // Stores frequency of visited elements
    unordered_map<int, int> m;

    // Traverse the array
    for (int i = 0; i < N; i++) {
        m[arr[i]] = m[arr[i]] + 1;
    }

    for (int i = 0; i < N; i++) {

        // Square of the element
        int square = arr[i] * arr[i];

        // Update the count
        count += m[square];
    }

    // Print the count
    cout << count;
}

// Driver Code
int main()
{
    // Given array
    int arr[] = { 2, 4, 5, 20, 16 };

    // Size of the array
    int N = sizeof(arr) / sizeof(arr[0]);

    // Function Call
    countSquares(arr, N);

    return 0;
}

Java

// Java program for the above approach
import java.util.*;
class GFG
{

// Function to find the count of elements whose
// squares is already present int the array
static void countSquares(int arr[], int N)
{
  
    // Stores the count of array elements
    int count = 0;

    // Stores frequency of visited elements
    HashMap<Integer,Integer> mp = new HashMap<Integer,Integer>();

    // Traverse the array
    for (int i = 0; i < N; i++) 
    {
        if(mp.containsKey(arr[i]))
        {
            mp.put(arr[i], mp.get(arr[i]) + 1);
        }
        else
        {
            mp.put(arr[i], 1);
        }
    }
    for (int i = 0; i < N; i++)
    {

        // Square of the element
        int square = arr[i] * arr[i];

        // Update the count
        count += mp.containsKey(square)?mp.get(square):0;
    }

    // Print the count
    System.out.print(count);
}

// Driver Code
public static void main(String[] args)
{
  
    // Given array
    int arr[] = { 2, 4, 5, 20, 16 };

    // Size of the array
    int N = arr.length;

    // Function Call
    countSquares(arr, N);
}
}

// This code is contributed by 29AjayKumar

Python3

# Python 3 program for the above approach
from collections import defaultdict

# Function to find the count of elements whose
# squares is already present int the array
def countSquares( arr, N):

    # Stores the count of array elements
    count = 0;

    # Stores frequency of visited elements
    m = defaultdict(int);

    # Traverse the array
    for i in range(N):
        m[arr[i]] = m[arr[i]] + 1

    for i in range( N ):

        # Square of the element
        square = arr[i] * arr[i]

        # Update the count
        count += m[square]

    # Print the count
    print(count)

# Driver Code
if __name__ == "__main__":
  
    # Given array
    arr = [ 2, 4, 5, 20, 16 ]

    # Size of the array
    N = len(arr)

    # Function Call
    countSquares(arr, N);

# This code is contributed by chitranayal.

// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG
{
  
// Function to find the count of elements whose
// squares is already present int the array
static void countSquares(int []arr, int N)
{
  
    // Stores the count of array elements
    int count = 0;

    // Stores frequency of visited elements
    Dictionary<int, int> mp = 
                    new Dictionary<int, int>();

    // Traverse the array
    for (int i = 0; i < N; i++) 
    {
        if(mp.ContainsKey(arr[i]))
        {
            mp.Add(arr[i], mp[arr[i]] + 1);
        }
        else
        {
            mp.Add(arr[i], 1);
        }
    }
    for (int i = 0; i < N; i++)
    {
        // Square of the element
        int square = arr[i] * arr[i];

        // Update the count
        count += mp.ContainsKey(square)?mp[square]:0;
    }
  
    // Print the count
    Console.Write(count);
}

// Driver Code
public static void Main()
{
    // Given array
    int []arr = { 2, 4, 5, 20, 16 };

    // Size of the array
    int N = arr.Length;

    // Function Call
    countSquares(arr, N);
}
}

// This code is contributed by Samim Hossain Mondal

JavaScript

<script>

// Javascript program for the above approach

// Function to find the count of elements whose
// squares is already present int the array
function countSquares(arr, N)
{
    // Stores the count of array elements
    var count = 0;

    // Stores frequency of visited elements
    var m = new Map();

    // Traverse the array
    for (var i = 0; i < N; i++) {
        if(m.has(arr[i]))
            m.set(arr[i], m.get(arr[i])+1)
        else    
            m.set(arr[i], 1);
    }

    for (var i = 0; i < N; i++) {

        // Square of the element
        var square = arr[i] * arr[i];

        // Update the count
        if(m.has(square))
            count += m.get(square);
    }

    // Print the count
    document.write( count);
}

// Driver Code
// Given array
var arr = [2, 4, 5, 20, 16];
// Size of the array
var N = arr.length;
// Function Call
countSquares(arr, N);

</script>

Output:

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

vikkycirus

Improve

Article Tags :

Count array elements whose perfect squares are present in the given array

Explore

DSA Fundamentals

Data Structures

Algorithms

Advanced

Interview Preparation

Practice Problem

Thank You!

What kind of Experience do you want to share?