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

13 Jan, 2022
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: 2Explanation:{2, 4} has their squares {4, 16} present in the array.
Input: arr[] = {1, 30, 3, 8, 64}Output: 2Explanation:{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.
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
Java
Python3
C#
Javascript
// 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 arrayvoid 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 Codeint 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 program for the above approachimport java.util.*;class GFG{ // Function to find the count of elements whose// squares are already present int the arraystatic 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 Codepublic 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
# Python program for the above approach # Function to find the count of elements whose# squares are already present the arraydef 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 Codeif __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 approachusing System; class GFG{     // Function to find the count of elements whose// squares are already present int the arraystatic 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
<script> // Javascript program for the above approach // Function to find the count of elements whose// squares are already present int the arrayfunction 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 arrayvar arr = [2, 4, 5, 20, 16];// Size of the arrayvar N = arr.length;countSquares(arr, N); </script>
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 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
Java
Python3
C#
Javascript
// 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 arrayint 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 Codeint 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 program for the above approachimport java.util.*;class GFG{ // Function to find the count of elements whose// squares is already present int the arraystatic 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 Codepublic 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
# Python 3 program for the above approachfrom collections import defaultdict # Function to find the count of elements whose# squares is already present int the arraydef 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 Codeif __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 approachusing System;using System.Collections.Generic;class GFG{   // Function to find the count of elements whose// squares is already present int the arraystatic 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 Codepublic 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
<script> // Javascript program for the above approach // Function to find the count of elements whose// squares is already present int the arrayfunction 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 arrayvar arr = [2, 4, 5, 20, 16];// Size of the arrayvar N = arr.length;// Function CallcountSquares(arr, N); </script>
2
 
Time Complexity: O(N)Auxiliary Space: O(N) 
divyeshrabadiya07
shikhasingrajput
29AjayKumar
ukasp
itsok
famously
samim2000
khushboogoyal499
Algorithms-Analysis of Algorithms
Arrays
cpp-unordered_map
Competitive Programming
Arrays
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Top 15 Websites for Coding Challenges and Competitions
Breadth First Traversal ( BFS ) on a 2D array
Shortest path in a directed graph by Dijkstra’s algorithm
Runtime Errors
Multistage Graph (Shortest Path)
Graph implementation using STL for competitive programming | Set 2 (Weighted graph)
Most important type of Algorithms
5 Best Languages for Competitive Programming
5 Best Books for Competitive Programming
Check whether two strings contain same characters in same order