Skip to content
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 ` `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);`   `    ``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 freq` `      ``= ``new` `HashMap();`   `    ``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 v ` `      ``= ``new` `ArrayList(); `   `    ``// 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 :