# Nearest power of 2 of nearest perfect squares of non-repeating array elements

• Last Updated : 15 Jun, 2021

Given an array arr[] consisting of N positive integers, the task is to find the nearest perfect power of 2 of the nearest perfect squares of unique array elements. If the array does not contain any unique element, then print -1.

Examples:

Input: arr[] = {4, 11, 4, 3, 4}
Output: 4 8
Explanation:
The unique elements in the given array are 11 and 3.
The nearest perfect square of 11 and 3 are 9 and 4 respectively.
The nearest power of 2 of 9 and 4 are 8 and 4 respectively.

Input: arr[] = {1, 1, 2, 2, 3, 3}
Output: -1

Naive Approach: The simplest approach is to traverse the array and for each array element with single occurrence, print the nearest perfect power of 2 of the nearest perfect square of the array element. Otherwise, if there are no unique elements present in the array, then print -1

Time Complexity: O(N2*log N)
Auxiliary Space: O(1)

Efficient Approach: The above can be optimized by Hashing. Follow the steps to solve the problem:

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find nearest``// perfect square of num``int` `perfectSquare(``int` `num)``{``    ``// Calculate square root of num``    ``int` `sr = ``sqrt``(num);` `    ``// Calculate perfect square``    ``int` `a = sr * sr;``    ``int` `b = (sr + 1) * (sr + 1);` `    ``// Find the nearest perfect square``    ``if` `((num - a) < (b - num)) {``        ``return` `a;``    ``}``    ``else` `{``        ``return` `b;``    ``}``}` `// Function to find the power of 2``// nearest to the number num``int` `powerOfTwo(``int` `num)``{``    ``// Calculate log base 2 of num``    ``int` `lg = log2(num);` `    ``// Highest power of 2 which is <= num``    ``int` `p = ``pow``(2, lg);` `    ``return` `p;``}` `// Function to find the nearest perfect``// square and the nearest power of 2 of``// every array element whose occurrence is 1``void` `uniqueElement(``int` `arr[], ``int` `N)``{``    ``bool` `ans = ``true``;` `    ``// Stores frequency of array elements``    ``unordered_map<``int``, ``int``> freq;` `    ``// Traverse the array and update``    ``// frequency of current array element``    ``for` `(``int` `i = 0; i < N; i++) {``        ``freq[arr[i]]++;``    ``}` `    ``// Traverse the map freq``    ``for` `(``auto` `el : freq) {` `        ``// If the frequency is 1``        ``if` `(el.second == 1) {` `            ``ans = ``false``;` `            ``// Find nearest perfect square``            ``int` `ps = perfectSquare(el.first);` `            ``// Print the nearest power of 2``            ``cout << powerOfTwo(ps) << ``' '``;``        ``}``    ``}` `    ``// If the any does not contain``    ``// any non-repeating elements``    ``if` `(ans)``        ``cout << ``"-1"``;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 4, 11, 4, 3, 4 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``uniqueElement(arr, N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG {` `  ``// Function to find nearest``  ``// perfect square of num``  ``static` `int` `perfectSquare(``int` `num)``  ``{``    ` `    ``// Calculate square root of num``    ``int` `sr = (``int``)(Math.sqrt(num));` `    ``// Calculate perfect square``    ``int` `a = sr * sr;``    ``int` `b = (sr + ``1``) * (sr + ``1``);` `    ``// Find the nearest perfect square``    ``if` `((num - a) < (b - num)) {``      ``return` `a;``    ``}``    ``else` `{``      ``return` `b;``    ``}``  ``}` `  ``// Function to find the power of 2``  ``// nearest to the number num``  ``static` `int` `powerOfTwo(``int` `num)``  ``{``    ` `    ``// Calculate log base 2 of num``    ``int` `lg = (``int``)(Math.log(num) / Math.log(``2``));` `    ``// Highest power of 2 which is <= num``    ``int` `p = (``int``)(Math.pow(``2``, lg));` `    ``return` `p;``  ``}` `  ``// Function to find the nearest perfect``  ``// square and the nearest power of 2 of``  ``// every array element whose occurrence is 1``  ``static` `void` `uniqueElement(``int` `arr[], ``int` `N)``  ``{``    ``boolean` `ans = ``true``;` `    ``// Stores frequency of array elements``    ``HashMap freq``      ``= ``new` `HashMap();` `    ``// Traverse the array and update``    ``// frequency of current array element``    ``for` `(``int` `i = ``0``; i < N; i++) {``      ``if` `(freq.containsKey(arr[i])) {``        ``freq.put(arr[i], freq.get(arr[i]) + ``1``);``      ``}``      ``else` `{``        ``freq.put(arr[i], ``1``);``      ``}``    ``}` `    ``// Traverse the map freq``    ``for` `(Map.Entry el :``         ``freq.entrySet()) {` `      ``// If the frequency is 1``      ``if` `(el.getValue() == ``1``) {` `        ``ans = ``false``;` `        ``// Find nearest perfect square``       ` `        ``int` `ps = perfectSquare(el.getKey());` `        ``// Print the nearest power of 2``        ``System.out.print(powerOfTwo(ps) + ``" "``);``      ``}``    ``}` `    ``// If the any does not contain``    ``// any non-repeating elements``    ``if` `(ans)``      ``System.out.print(``"-1"``);``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `arr[] = { ``4``, ``11``, ``4``, ``3``, ``4` `};``    ``int` `N = arr.length;` `    ``uniqueElement(arr, N);``  ``}``}` `// This code is contributed by subhammahato348.`

## Python3

 `# Python3 program for the above approach``from` `math ``import` `sqrt, log2, ``pow` `# Function to find nearest``# perfect square of num``def` `perfectSquare(num):``    ` `    ``# Calculate square root of num``    ``sr ``=` `int``(sqrt(num))` `    ``# Calculate perfect square``    ``a ``=` `sr ``*` `sr``    ``b ``=` `(sr ``+` `1``) ``*` `(sr ``+` `1``)` `    ``# Find the nearest perfect square``    ``if` `((num ``-` `a) < (b ``-` `num)):``        ``return` `a``    ``else``:``        ``return` `b` `# Function to find the power of 2``# nearest to the number num``def` `powerOfTwo(num):``    ` `    ``# Calculate log base 2 of num``    ``lg ``=` `int``(log2(num))` `    ``# Highest power of 2 which is <= num``    ``p ``=` `int``(``pow``(``2``, lg))` `    ``return` `p` `# Function to find the nearest perfect``# square and the nearest power of 2 of``# every array element whose occurrence is 1``def` `uniqueElement(arr, N):``    ` `    ``ans ``=` `True` `    ``# Stores frequency of array elements``    ``freq ``=` `{}` `    ``# Traverse the array and update``    ``# frequency of current array element``    ``for` `i ``in` `range``(N):``        ``if` `(arr[i] ``in` `freq):``            ``freq[arr[i]] ``+``=` `1``        ``else``:``            ``freq[arr[i]] ``=` `1` `    ``# Traverse the map freq``    ``res ``=` `[]``    ``for` `key,value ``in` `freq.items():``        ` `        ``# If the frequency is 1``        ``if` `(value ``=``=` `1``):``            ``ans ``=` `False` `            ``# Find nearest perfect square``            ``ps ``=` `perfectSquare(key)` `            ``# Print the nearest power of 2``            ``res.append(powerOfTwo(ps))``            ` `    ``res.sort(reverse ``=` `False``)``    ``for` `x ``in` `res:``      ``print``(x, end ``=` `" "``)` `    ``# If the any does not contain``    ``# any non-repeating elements``    ``if` `(ans):``        ``print``(``"-1"``)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=`  `[``4``, ``11``, ``4``, ``3``, ``4``]``    ``N ``=`  `len``(arr)``    ` `    ``uniqueElement(arr, N)` `# This code is contributed by SURENDRA_GANGWAR`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;``using` `System.Linq;` `class` `GFG{` `// Function to find nearest``// perfect square of num``static` `int` `perfectSquare(``int` `num)``{``    ` `    ``// Calculate square root of num``    ``int` `sr = (``int``)(Math.Sqrt(num));` `    ``// Calculate perfect square``    ``int` `a = sr * sr;``    ``int` `b = (sr + 1) * (sr + 1);` `    ``// Find the nearest perfect square``    ``if` `((num - a) < (b - num))``    ``{``        ``return` `a;``    ``}``    ``else``    ``{``        ``return` `b;``    ``}``}` `// Function to find the power of 2``// nearest to the number num``static` `int` `powerOfTwo(``int` `num)``{``    ` `    ``// Calculate log base 2 of num``    ``int` `lg = (``int``)(Math.Log(num) / Math.Log(2));` `    ``// Highest power of 2 which is <= num``    ``int` `p = (``int``)(Math.Pow(2, lg));` `    ``return` `p;``}` `// Function to find the nearest perfect``// square and the nearest power of 2 of``// every array element whose occurrence is 1``static` `void` `uniqueElement(``int``[] arr, ``int` `N)``{``    ``bool` `ans = ``true``;` `    ``// Stores frequency of array elements``    ``Dictionary<``int``,``               ``int``> freq = ``new` `Dictionary<``int``,``                                          ``int``>();` `    ``// Traverse the array and update``    ``// frequency of current array element``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ``if` `(freq.ContainsKey(arr[i]))``        ``{``            ``freq[arr[i]] = freq[arr[i]] + 1;``        ``}``        ``else``        ``{``            ``freq[arr[i]] = 1;``        ``}``    ``}` `    ``// Traverse the map freq``    ``foreach``(``var` `el ``in` `freq.OrderBy(el => el.Key))``    ``{``        ` `        ``// If the frequency is 1``        ``if` `(el.Value == 1)``        ``{``            ``ans = ``false``;` `            ``// Find nearest perfect square``            ``int` `ps = perfectSquare(el.Key);` `            ``// Print the nearest power of 2``            ``Console.Write(powerOfTwo(ps) + ``" "``);``        ``}``    ``}` `    ``// If the any does not contain``    ``// any non-repeating elements``    ``if` `(ans)``        ``Console.Write(``"-1"``);``}` `// Driver Code``public` `static` `void` `Main(``string``[] args)``{``    ``int``[] arr = { 4, 11, 4, 3, 4 };``    ``int` `N = arr.Length;` `    ``uniqueElement(arr, N);``}``}` `// This code is contributed by ukasp`

## Javascript

 ``

Output:

`4 8`

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

My Personal Notes arrow_drop_up