Skip to content
Related Articles

Related Articles

Count array elements whose perfect squares are present in the given array
  • Difficulty Level : Easy
  • Last Updated : 18 Feb, 2021

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 te 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;
 
    # Prthe 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

 
 

Output: 
2

 

Time Complexity: O(N2)
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 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#




# 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)

 
 

Output: 
2

 

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

competitive-programming-img

My Personal Notes arrow_drop_up
Recommended Articles
Page :