Open in App
Not now

# Count array elements whose highest power of 2 less than or equal to that number is present in the given array

• Last Updated : 20 Jul, 2021

Given an array arr[] consisting of N positive integers, the task is to find the number of array elements whose highest power of 2 less than or equal to that number is present in the array.

Examples:

Input: arr[] = {3, 4, 6, 9}
Output: 2
Explanation:
There are 2 array elements (4 and 6), whose highest power of 2 is less than it (i.e. 4) are present in the array.

Input: arr[] = {3, 9, 10, 8, 1}
Output: 3

Naive Approach: The given problem can be solved by count those elements whose highest power of 2 exists in the given array and that can be found by traversing the array again. After checking for all the elements, print the total count obtained.

Time Complexity: O(N2)
Auxiliary Space: O(1)

Efficient Approach: The above approach can also be optimized by using an unordered_map to keep the count of visited elements and update the count of resultant elements accordingly. Follow the steps below to solve the given problem:

• Initialize a variable, say count that stores the count of elements whose highest power of 2 less than or equals to that is present in the array.
• Initialize a map M and store the frequency of array elements.
• Traverse the given array and for each element, if the frequency of the highest power of 2 of arr[i] not exceeding the element exists in the map then increment the value of count by 1.
• After completing the above steps, print the value of count as the resultant count of elements.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to count array elements` `// whose highest power of 2 is less` `// than or equal to that number is` `// present in the given array` `int` `countElement(``int` `arr[], ``int` `N)` `{` `    ``// Stores the resultant count` `    ``// of array elements` `    ``int` `count = 0;`   `    ``// Stores frequency of` `    ``// visited array elements` `    ``unordered_map<``int``, ``int``> m;`   `    ``// Traverse the array` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``m[arr[i]]++;` `    ``}`   `    ``for` `(``int` `i = 0; i < N; i++) {`   `        ``// Calculate log base 2` `        ``// of the element arr[i]` `        ``int` `lg = log2(arr[i]);`   `        ``// Highest power of 2 whose` `        ``// value is at most arr[i]` `        ``int` `p = ``pow``(2, lg);`   `        ``// Increment the count by 1` `        ``if` `(m[p]) {` `            ``count++;` `        ``}` `    ``}`   `    ``// Return the resultant count` `    ``return` `count;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 3, 4, 6, 9 };` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``cout << countElement(arr, N);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.HashMap;` `import` `java.io.*;`   `class` `GFG{` `    `  `static` `int` `log2(``int` `N) ` `{ ` `    `  `    ``// Calculate log2 N indirectly ` `    ``// using log() method ` `    ``int` `result = (``int``)(Math.log(N) / ` `                       ``Math.log(``2``)); ` `    `  `    ``return` `result; ` `} `   `// Function to count array elements` `// whose highest power of 2 is less` `// than or equal to that number is` `// present in the given array` `static` `int` `countElement(``int` `arr[], ``int` `N)` `{` `    `  `    ``// Stores the resultant count` `    ``// of array elements` `    ``int` `count = ``0``;`   `    ``// Stores frequency of` `    ``// visited array elements` `   ``HashMap m = ``new` `HashMap<>();` `   `  `    ``// Traverse the array` `    ``for``(``int` `i = ``0``; i < N; i++)` `    ``{` `        ``if` `(m.containsKey(arr[i]))` `        ``{ ` `            ``m.put(arr[i], m.get(arr[i]) + ``1``); ` `        ``} ` `        ``else` `        ``{ ` `            ``m.put(arr[i], ``1``); ` `        ``} ` `    ``}`   `    ``for``(``int` `i = ``0``; i < N; i++) ` `    ``{` `        `  `        ``// Calculate log base 2` `        ``// of the element arr[i]` `        ``int` `lg = log2(arr[i]);`   `        ``// Highest power of 2 whose` `        ``// value is at most arr[i]` `        ``int` `p = (``int``)Math.pow(``2``, lg);`   `        ``// Increment the count by 1` `        ``if` `(m.containsKey(p))` `        ``{` `            ``count++;` `        ``}` `    ``}`   `    ``// Return the resultant count` `    ``return` `count;` `}`   `// Driver Code` `public` `static` `void` `main (String[] args)` `{` `    ``int` `arr[] = { ``3``, ``4``, ``6``, ``9` `};` `    ``int` `N = arr.length;` `    `  `    ``System.out.println(countElement(arr, N));` `}` `}`   `// This code is contributed by Potta Lokesh`

## Python3

 `# Python program for the above approach` `from` `math ``import` `log2`   `# Function to count array elements` `# whose highest power of 2 is less` `# than or equal to that number is` `# present in the given array` `def` `countElement(arr, N):` `    ``# Stores the resultant count` `    ``# of array elements` `    ``count ``=` `0`   `    ``# Stores frequency of` `    ``# visited array elements` `    ``m ``=` `{}`   `    ``# Traverse the array` `    ``for` `i ``in` `range``(N):` `        ``m[arr[i]] ``=` `m.get(arr[i], ``0``) ``+` `1`     `    ``for` `i ``in` `range``(N):` `        ``# Calculate log base 2` `        ``# of the element arr[i]` `        ``lg ``=` `int``(log2(arr[i]))`   `        ``# Highest power of 2 whose` `        ``# value is at most arr[i]` `        ``p ``=` `pow``(``2``, lg)`   `        ``# Increment the count by 1` `        ``if` `(p ``in` `m):` `            ``count ``+``=` `1`   `    ``# Return the resultant count` `    ``return` `count`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``arr``=` `[``3``, ``4``, ``6``, ``9``]` `    ``N ``=` `len``(arr)` `    ``print` `(countElement(arr, N))`   `# This code is contributed by mohit kumar 29.`

## C#

 `// C# program for the above approach`   `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG{`   `// Function to count array elements` `// whose highest power of 2 is less` `// than or equal to that number is` `// present in the given array` `static` `int` `countElement(``int` `[]arr, ``int` `N)` `{` `    ``// Stores the resultant count` `    ``// of array elements` `    ``int` `count = 1;`   `    ``// Stores frequency of` `    ``// visited array elements` `    ``Dictionary<``int``,``int``> m = ``new` `Dictionary<``int``,``int``>();`   `    ``// Traverse the array` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``if``(m.ContainsKey(arr[i]))` `         ``m[arr[i]]++;` `        ``else` `         ``m.Add(arr[i],1);` `    ``}`   `    ``for``(``int` `i = 0; i < N; i++) {`   `        ``// Calculate log base 2` `        ``// of the element arr[i]` `        ``int` `lg = (``int``)Math.Log(arr[i]);`   `        ``// Highest power of 2 whose` `        ``// value is at most arr[i]` `        ``int` `p = (``int``)Math.Pow(2, lg);`   `        ``// Increment the count by 1` `        ``if` `(m.ContainsKey(p)) {` `            ``count++;` `        ``}` `    ``}`   `    ``// Return the resultant count` `    ``return` `count;` `}`   `// Driver Code` `public` `static` `void` `Main()` `{` `    ``int` `[]arr = { 3, 4, 6, 9 };` `    ``int` `N = arr.Length;` `    ``Console.Write(countElement(arr, N));`   `}` `}`   `// This code is contributed by bgangwar59.`

## Javascript

 ``

Output:

`2`

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

My Personal Notes arrow_drop_up
Related Articles