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

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#

// 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:

2

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#

// 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:

2

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