Given a number n, find the highest power of 2 that is smaller than or equal to n.
Examples :
Input : n = 10
Output : 8
Input : n = 19
Output : 16
Input : n = 32
Output : 32
A simple solution is to start checking from n and keep decrementing until we find a power of 2.
C++
#include <bits/stdc++.h>
using namespace std;
int highestPowerof2( int n)
{
int res = 0;
for ( int i = n; i >= 1; i--) {
if ((i & (i - 1)) == 0) {
res = i;
break ;
}
}
return res;
}
int main()
{
int n = 10;
cout << highestPowerof2(n);
return 0;
}
|
C
#include <stdio.h>
int highestPowerof2( int n)
{
int res = 0;
for ( int i = n; i >= 1; i--) {
if ((i & (i - 1)) == 0) {
res = i;
break ;
}
}
return res;
}
int main()
{
int n = 10;
printf ( "%d" , highestPowerof2(n));
return 0;
}
|
Java
class GFG{
static int highestPowerof2( int n)
{
int res = 0 ;
for ( int i = n; i >= 1 ; i--)
{
if ((i & (i- 1 )) == 0 )
{
res = i;
break ;
}
}
return res;
}
public static void main(String[] args)
{
int n = 10 ;
System.out.print(highestPowerof2(n));
}
}
|
Python3
def highestPowerof2(n):
res = 0 ;
for i in range (n, 0 , - 1 ):
if ((i & (i - 1 )) = = 0 ):
res = i;
break ;
return res;
n = 10 ;
print (highestPowerof2(n));
|
C#
using System;
class GFG
{
public static int highestPowerof2( int n)
{
int res = 0;
for ( int i = n; i >= 1; i--)
{
if ((i & (i - 1)) == 0)
{
res = i;
break ;
}
}
return res;
}
static public void Main ()
{
int n = 10;
Console.WriteLine(highestPowerof2(n));
}
}
|
PHP
<?php
function highestPowerof2( $n )
{
$res = 0;
for ( $i = $n ; $i >= 1; $i --)
{
if (( $i & ( $i - 1)) == 0)
{
$res = $i ;
break ;
}
}
return $res ;
}
$n = 10;
echo highestPowerof2( $n );
?>
|
Javascript
<script>
function highestPowerof2(n)
{
let res = 0;
for (let i = n; i >= 1; i--)
{
if ((i & (i - 1)) == 0)
{
res = i;
break ;
}
}
return res;
}
let n = 10;
document.write(highestPowerof2(n));
</script>
|
Time complexity : O(n). In worst case, the loop runs floor(n/2) times. The worst case happens when n is of the form 2x – 1.
Auxiliary Space : O(1) since only constant space is used for variables
An efficient solution is to use bitwise left shift operator to find all powers of 2 starting from 1. For every power check if it is smaller than or equal to n or not. Below is the implementation of the idea.
C++
#include <bits/stdc++.h>
using namespace std;
int highestPowerof2(unsigned int n)
{
if (n < 1)
return 0;
int res = 1;
for ( int i = 0; i < 8 * sizeof (unsigned int ); i++) {
int curr = 1 << i;
if (curr > n)
break ;
res = curr;
}
return res;
}
int main()
{
int n = 10;
cout << highestPowerof2(n);
return 0;
}
|
C
#include <stdio.h>
int highestPowerof2(unsigned int n)
{
if (n < 1)
return 0;
int res = 1;
for ( int i = 0; i < 8 * sizeof (unsigned int ); i++) {
int curr = 1 << i;
if (curr > n)
break ;
res = curr;
}
return res;
}
int main()
{
int n = 10;
printf ( "%d" , highestPowerof2(n));
return 0;
}
|
Java
import java.io.*;
class GFG
{
static int highestPowerof2( int n)
{
if (n < 1 )
return 0 ;
int res = 1 ;
for ( int i = 0 ; i < 8 * Integer.BYTES; i++)
{
int curr = 1 << i;
if (curr > n)
break ;
res = curr;
}
return res;
}
public static void main(String[] args)
{
int n = 10 ;
System.out.println(highestPowerof2(n));
}
}
|
python3
import sys
def highestPowerof2( n):
if (n < 1 ):
return 0
res = 1
for i in range ( 8 * sys.getsizeof(n)):
curr = 1 << i
if (curr > n):
break
res = curr
return res
if __name__ = = "__main__" :
n = 10
print (highestPowerof2(n))
|
C#
using System;
class GFG
{
static int highestPowerof2( int n)
{
if (n < 1)
return 0;
int res = 1;
for ( int i = 0; i < 8 * sizeof ( uint ); i++)
{
int curr = 1 << i;
if (curr > n)
break ;
res = curr;
}
return res;
}
static public void Main ()
{
int n = 10;
Console.WriteLine(highestPowerof2(n));
}
}
|
PHP
<?php
function highestPowerof2( $n )
{
if ( $n < 1)
return 0;
$res = 1;
for ( $i = 0; $i < 8 * PHP_INT_SIZE; $i ++)
{
$curr = 1 << $i ;
if ( $curr > $n )
break ;
$res = $curr ;
}
return $res ;
}
$n = 10;
echo highestPowerof2( $n );
?>
|
Javascript
<script>
function highestPowerof2(n)
{
if (n < 1)
return 0;
let res = 1;
for (let i=0; i<8; i++)
{
let curr = 1 << i;
if (curr > n)
break ;
res = curr;
}
return res;
}
let n = 10;
document.write(highestPowerof2(n));
</script>
|
Time Complexity: O(32)
Auxiliary Space: O(1)
A Solution using Log(n)
Thanks to Anshuman Jha for suggesting this solution.
C++
#include<bits/stdc++.h>
using namespace std;
int highestPowerof2( int n)
{
int p = ( int )log2(n);
return ( int ) pow (2, p);
}
int main()
{
int n = 10;
cout << highestPowerof2(n);
return 0;
}
|
Java
import java.io.*;
class GFG
{
static int highestPowerof2( int n)
{
int p = ( int )(Math.log(n) /
Math.log( 2 ));
return ( int )Math.pow( 2 , p);
}
public static void main (String[] args)
{
int n = 10 ;
System.out.println(highestPowerof2(n));
}
}
|
Python3
import math
def highestPowerof2(n):
p = int (math.log(n, 2 ));
return int ( pow ( 2 , p));
n = 10 ;
print (highestPowerof2(n));
|
C#
using System;
class GFG
{
static int highestPowerof2( int n)
{
int p = ( int )(Math.Log(n) /
Math.Log(2));
return ( int )Math.Pow(2, p);
}
static public void Main ()
{
int n = 10;
Console.WriteLine(highestPowerof2(n));
}
}
|
PHP
<?php
function highestPowerof2( $n )
{
$p = (int)log( $n , 2);
return (int)pow(2, $p );
}
$n = 10;
echo highestPowerof2( $n );
?>
|
Javascript
<script>
function highestPowerof2(n)
{
let p = parseInt(Math.log(n) / Math.log(2), 10);
return Math.pow(2, p);
}
let n = 10;
document.write(highestPowerof2(n));
</script>
|
Time Complexity: O(logn)
Auxiliary Space: O(1)
Solution using bitmasks :
C++
#include <iostream>
using namespace std;
unsigned highestPowerof2(unsigned x)
{
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
return x ^ (x >> 1);
}
int main()
{
int n = 10;
cout << highestPowerof2(n) << "\n" ;
return 0;
}
|
Java
import java.io.*;
class GFG
{
static int highestPowerof2( int x)
{
x |= x >> 1 ;
x |= x >> 2 ;
x |= x >> 4 ;
x |= x >> 8 ;
x |= x >> 16 ;
return x ^ (x >> 1 );
}
public static void main (String[] args)
{
int n = 10 ;
System.out.println(highestPowerof2(n));
}
}
|
Python3
def highestPowerof2(x):
x | = x >> 1
x | = x >> 2
x | = x >> 4
x | = x >> 8
x | = x >> 16
return x ^ (x >> 1 )
n = 10
print (highestPowerof2(n))
|
C#
using System;
public class GFG
{
static int highestPowerof2( int x)
{
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
return x ^ (x >> 1);
}
public static void Main(String[] args)
{
int n = 10;
Console.WriteLine(highestPowerof2(n));
}
}
|
Javascript
<script>
function highestPowerof2(x)
{
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
return x ^ (x >> 1);
}
let n = 10;
document.write(highestPowerof2(n))
</script>
|
Time Complexity: O(1)
Auxiliary Space: O(1) since only constant space is used for variables
A solution using MSB
If the given number is the power of two then it is the required number otherwise set only the most significant bit which gives us the required number.
C++
#include <iostream>
using namespace std;
long long highestPowerof2( long long N)
{
if (!(N & (N - 1)))
return N;
return 0x8000000000000000 >> (__builtin_clzll(N));
}
int main()
{
long long n = 5;
cout << highestPowerof2(n);
return 0;
}
|
Java
import java.util.*;
class GFG
{
static int highestPowerof2( int N)
{
if ((N & (N - 1 )) == 0 )
return N;
return ( 1 << (Integer.toBinaryString(N).length() - 1 ));
}
public static void main(String[] args)
{
int n = 5 ;
System.out.println(highestPowerof2(n));
}
}
|
Python3
def highestPowerof2(N):
if ( not (N & (N - 1 ))):
return N;
return 0x8000000000000000 >> ( 64 - N.bit_length())
n = 5 ;
print (highestPowerof2(n))
|
C#
using System;
using System.Collections.Generic;
class GFG
{
static int highestPowerof2( int N)
{
if ((N & (N - 1)) == 0)
return N;
return (1 << ((Convert.ToString(N, 2).Length) - 1));
}
public static void Main( string [] args)
{
int n = 5;
Console.WriteLine(highestPowerof2(n));
}
}
|
Javascript
function highestPowerof2(N)
{
if (!(N & (N - 1)))
return N;
return 1 << ((N.toString(2)).length) - 1;
}
let n = 5;
console.log(highestPowerof2(n));
|
Time Complexity : O(1) as counting leading zeroes can cause at most O(64) time complexity.
Auxiliary Space: O(1)
Application Problem:
Some people are standing in a queue. A selection process follows a rule where people standing on even positions are selected. Of the selected people a queue is formed and again out of these only people on even position are selected. This continues until we are left with one person. Find out the position of that person in the original queue.
Print the position(original queue) of that person who is left.
Examples :
Input: n = 10
Output:8
Explanation :
1 2 3 4 5 6 7 8 9 10 ===>Given queue
2 4 6 8 10
4 8
8
Input: n = 17
Input: 16
Explanation :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 ===>Given queue
2 4 6 8 10 12 14 16
4 8 12 16
8 16
16
Related Article :
Power of 2 greater than or equal to a given number.
This article is contributed by Sahil Chhabra. If you like neveropen and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the neveropen main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!