CareerCup

int Ceiling2(int x){

while(x & (x-1)){
// Removing the extra set bit.
   x &= (x-1);
}
return x<<1;

}

void main()
{
   int n,num=1;
   cout<<"Enter number";
   cin>>n;
   while(n)
   {
     n>>=1;
     num<<=1;
   }
   cout<<num;
}

Round up log_2(k)

Find the MSB position , then set MSB+1 position to 1 and all other positions to 0

int roundOff(const int n) {
if (n == 0 ) {
return 1;
}
int k = n;
int i = 1;
while(true) {
k = k >> 1;
i = i << 1;
if (k == 0) {
return i;
}
}
return 0;
}

#include<stdio.h>

int roundOff(int number){
        int maxBit = 0;
        int mask = 1;

        while(number != 0){
                number >>= 1;
                maxBit++;
        }

        mask <<= maxBit;
        return mask;
}      

int main(){
        printf("%d\n",roundOff(1));
        printf("%d\n",roundOff(2));
        printf("%d\n",roundOff(3));
}

int roundpow(int num)
{
if( num <=0 )
return -1;
if( num & num-1 )
return num;

while( num & num+1 )
{
num++;
}
return num+1;
}

n ^ n + 1
i.e.
add xor of the number to itself, then add 1

Check the case when n=24 ,lets assume 8 bit numbers ,24=00011000 24 OR 25 would be 00011001 adding 1 to it gives 00011011.While the answer got to be 32 ie 00100000

exactly, ran is correct. n by the way, is it a must that v need to use bit wise operators only?

if(x%2!=0)
int q=x/2+1;
else q=x/2;
return (pow(2,q));

Hi Ankush Bindlish,

Try your function with 4, you will get 8 which is wrong. it should return 4 only.

Below function will work good:

unsigned int
CeilingToPowerOfTwo (unsigned int n) {
unsigned int mask = 1;
while (mask < n) {
mask <<= 1;
}
return mask;
}

Not sure it is optimized or not ..
1. Given a number, find its binary equivalent.
2. Count the length of the binary number.
3. Result = pow(2, length)

Eg, 5 = 101 ; length = 3
Result = pow(2,3) = 8

The function takes n as the input and rounds it to the next power of 2.
int pow(int n){
int i=1;
while(i<=n)
i<<1;

return i;
}

return Math.pow(2,Math.ceil(log x)+1);

log x is of base 10

log x is of base 2

Ofcourse, log x is of base 2

this wont work for 1,2,4,8,16,....2^n

Ran is correct except that while loop should be less than [not less than or equal to]
int pow(int n){
int i=1;
while(i<n) // Change here instead of i<=n which makes it invalid for n = 2^k
i<<=1;

return i;
}

int main() {
int i=0;
int nearestpowoftwo = 1;
while(givenNumber > nearestpowoftwo) {
i++;
nearestpowoftwo = powoftwo(i);
}
givenNumber = nearestpowoftwo;
printf("%d ", givenNumber);
return 1;
}

int powoftwo(int index) {
int ans=1;
while(index) {
ans = ans * 2;
index --;
}
return ans;
}

This can be one of teh solutions:

if ((x&(x-1)) == 0)
   return x;
while(x&(j))
   j = j+1;
return j;

how about

(n | ~n) + 1

?

Func(N)
{
int i = 1;
while(N>>2 - 1)
{
i++;
N = N >> 2;
}
return 2<<i;
}

find the most significant bit k (wiki Most_significant_bit)

return 2^(k+1)

I think if you input 4, you should receive 8.

int nearestPowerOfTwo(int number){
int position = 0;
while(((number >>= 1) | 0) != 0){
position += 1;
}
return (int) Math.pow(2, position + 1);
}

(n|~n +1) wont work..since all the 32 bits be set when u do n|~n

(n|~n +1) wont work..since all the 32 bits will be set when u do n|~n

whats the complexity of the solution

while(n!=0){
n = n>>1;
counter++;
}
n = 1;
while(counter!=0){
n = n<<1;
counter--;
}

while(n&(n-1))n++;

public class next {


public static void main(String[] a)
{
boolean h = true;
int c =0;
int f = 201;
while(h ==true)
{
c++;
if((Math.pow(2, c))>=f)
{
System.out.print((int)Math.pow(2, c));
h = false;
}
}

}
}