Open in App
Not now

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

• Difficulty Level : Easy
• Last Updated : 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: 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 ` `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

 ``

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 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 ` `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 mp = ``new` `HashMap();`   `    ``// 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

 ``

Output:

`2`

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

My Personal Notes arrow_drop_up
Related Articles