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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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