Skip to content
Related Articles

Related Articles

Highest powers of 2 not exceeding non-repeating array elements
  • Difficulty Level : Easy
  • Last Updated : 04 Mar, 2021

Given an array arr[] of size N, the task is for every non-repeating array element is to find the highest power of 2 that does not exceed that element. Print the powers of 2 in ascending order. If the array does not contain any non-repeating element, print “0”.

Examples:

Input: arr[ ] = { 4, 5, 4, 3, 3, 4 } 
Output:
Explanation: The only non-repeating element in the array is 5. Therefore, the highest power of 2 not exceeding 5 is 4.

Input: arr[ ] = { 1, 1, 7, 6, 3 } 
Output: 2 4 4

Naive Approach: The simplest approach to solve this problem is to traverse the array and for each array element, check if it is non-repeating or not. For elements douns to be non-repeating, add them into another array. Then, for each element in the new array, find the highest powers of 2 not exceeding that element and print them in ascending order. 
Time Complexity: O(N2 * log arr[i]), where arr[i] is the largest number of the array. 
Auxiliary Space: O(N)

Efficient Approach: The optimal idea is to use Hashing. Follow the steps below to solve the problem:



Below is the implementation of the above approach:

C++




// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find thr highest power of 2 for
// every non-repeating element in the array
void uniqueElement(int arr[], int N)
{
 
    // Stores the frequency
    // of array elements
    unordered_map<int, int> freq;
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
 
        // Update frequency of each
        // element of the array
        freq[arr[i]]++;
    }
 
    // Stores the non-repeating
    // array elements
    vector<int> v;
 
    // Traverse the Map
    for (auto i : freq) {
 
        if (i.second == 1) {
 
            // Calculate log base 2
            // of the current element
            int lg = log2(i.first);
 
            // Highest power of 2 <= i.first
            int p = pow(2, lg);
 
            // Insert it into the vector
            v.push_back(p);
        }
    }
 
    // If no element is non-repeating
    if (v.size() == 0) {
        cout << "0";
        return;
    }
 
    // Sort the powers of 2 obtained
    sort(v.begin(), v.end());
 
    // Print the elements in the vector
    for (auto i : v)
        cout << i << " ";
}
 
// Driver Code
int main()
{
    int arr[] = { 4, 5, 4, 3, 3, 4 };
 
    // Size of array
    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 thr highest power of 2 for
  // every non-repeating element in the array
  static void uniqueElement(int arr[], int N)
  {
 
    // Stores the frequency
    // of array elements
    HashMap<Integer, Integer> freq
      = new HashMap<Integer, Integer>();
 
    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);
      }
    }
 
    // Stores the non-repeating
    // array elements
    ArrayList<Integer> v
      = new ArrayList<Integer>();
 
    // Traverse the Map
    for (Map.Entry i : freq.entrySet()) {
 
      if ((int)i.getValue() == 1) {
 
        // Calculate log base 2
        // of the current element
        int lg = (int)(Math.log((int)i.getKey()) / Math.log(2));
 
        // Highest power of 2 <= i.first
        int p = (int)Math.pow(2, lg);
 
        // Insert it into the vector
        v.add(p);
      }
    }
 
    // If no element is non-repeating
    if (v.size() == 0) {
      System.out.print("0");
      return;
    }
 
    // Sort the powers of 2 obtained
    Collections.sort(v);
 
    // Print the elements in the vector
    for (int i : v)
      System.out.print( i + " ");
  }
 
  // Driver Code
  public static void main(String[] args)
  {
    int arr[] = { 4, 5, 4, 3, 3, 4 };
 
    // Size of array
    int N = arr.length;
    uniqueElement(arr, N);
  }
}
 
// This code is contributed by code_hunt.


Python3




# Python3 program for the above approach
import math
 
# Function to find thr highest power of 2 for
# every non-repeating element in the array
def uniqueElement(arr, N):
 
    # Stores the frequency
    # of array elements
    freq = {}
 
    # Traverse the array
    for i in range(N) :
  
        # Update frequency
        # of arr[i]
        if arr[i] in freq :
            freq[arr[i]] += 1;
        else :
            freq[arr[i]] = 1;
     
    # Stores the non-repeating
    # array elements
    v = []
 
    # Traverse the Map
    for i in freq :
        if (freq[i] == 1) :
 
            # Calculate log base 2
            # of the current element
            lg = int(math.log2(i))
 
            # Highest power of 2 <= i.first
            p = pow(2, lg)
 
            # Insert it into the vector
            v.append(p)
         
    # If no element is non-repeating
    if (len(v) == 0) :
        print("0")
        return
     
    # Sort the powers of 2 obtained
    v.sort()
 
    # Prthe elements in the vector
    for i in v :
        print(i, end = " ")
 
# Driver Code
arr = [ 4, 5, 4, 3, 3, 4 ]
 
# Size of array
N = len(arr)
uniqueElement(arr, N)
 
# This code is contributed by sanjoy_62.


C#




// C# program for the above approach
using System;
using System.Collections.Generic;
 
public class GFG{
 
  // Function to find thr highest power of 2 for
  // every non-repeating element in the array
  static void uniqueElement(int []arr, int N)
  {
 
    // Stores the frequency
    // of array elements
    Dictionary<int, int> freq
      = new Dictionary<int, int>();
 
    for (int i = 0; i < N; i++)
    {
      if (freq.ContainsKey(arr[i]))
      {
        freq[arr[i]] = freq[arr[i]] + 1;
      }
      else
      {
        freq.Add(arr[i], 1);
      }
    }
 
    // Stores the non-repeating
    // array elements
    List<int> v
      = new List<int>();
 
    // Traverse the Map
    foreach(KeyValuePair<int, int> i in freq) {
 
      if ((int)i.Value == 1) {
 
        // Calculate log base 2
        // of the current element
        int lg = (int)(Math.Log((int)i.Key) / Math.Log(2));
 
        // Highest power of 2 <= i.first
        int p = (int)Math.Pow(2, lg);
 
        // Insert it into the vector
        v.Add(p);
      }
    }
 
    // If no element is non-repeating
    if (v.Count == 0) {
      Console.Write("0");
      return;
    }
 
    // Sort the powers of 2 obtained
    v.Sort();
 
    // Print the elements in the vector
    foreach (int i in v)
      Console.Write( i + " ");
  }
 
  // Driver Code
  public static void Main(String[] args)
  {
    int []arr = { 4, 5, 4, 3, 3, 4 };
 
    // Size of array
    int N = arr.Length;
    uniqueElement(arr, N);
  }
}
 
 
// This code is contributed by 29AjayKumar


 
 

Output: 

4

 

 

Time Complexity: O(N * log(MAXM)), where MAXM is the largest element present the array. 
Auxiliary Space: O(N)

 

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.




My Personal Notes arrow_drop_up
Recommended Articles
Page :