Skip to content
Related Articles

Related Articles

Nearest power of 2 of nearest perfect squares of non-repeating array elements
  • Last Updated : 26 Mar, 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 <bits/stdc++.h>
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[0]);
 
    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<Integer, Integer> freq
      = new HashMap<Integer, Integer>();
 
    // 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<Integer, Integer> 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
Output: 
4 8

 

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

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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :