CareerCup

Count = 0;
temp = num;
while(temp != 0)
{
if((temp & 1) == 1)
{
count++;
temp = temp>>1;
}
}

divided by 2? (n%2 == 1)? Count++ : Count

Nithesh is correct. But right shift always has problem with signed numbers. If it is an negative number, then right shift gets 1's coming from left rather than 0's. Thus, it would be better to use left shift of 1 as the bit mask instead.

#include<iostream>
using namespace std;

int main()
{
int num = 13;
int count = 0;
while(num!=0)
{
if((num & 256) == 256)
{
count++;
num = num << 1;
}
else
num = num << 1;
}
cout << count;
}

nitish's answer is missing the else. but i am still not entirely sure whether this answer is correct or not :|

I guess above should work.. btw, the if loop should be
if((num & 1) == 1) { count++; ..... }
num&256 would give the same number and num&1 would give 1 if last bit is 1 else 0.

For an unsigned integer n:

int bitcount (unsigned int n) {
int count = 0 ;
while (n) {
count++ ;
n &= (n - 1) ;
}
return count ;
}

int n=0x1;
int count=0;

for(i=0;i<31;++i)
{
count=count+ x&n;
x=x>>1;
}
printf("%d",count);

int bitCounter(int number){
int counter = 0;
int n = sizeof(int) * 8;
int mask = 1 << (n - 1);
for(int i = 1; i <= n; ++i)
{
if((mask & number) != 0)
++counter;
number <<= 1;
}

return counter;
}

works for signed number

A lookup table for the 255 bit patterns in a byte provides constant time performance.

int number; //the number we'r considering.
int counter=0;
for(int c=number;c;counter++)
c&=c-1;
u'll get it..

int byte;
int cnt = 0;
for(int i=0;i<8;i++)
if(byte & (int)pow(2,i))
cnt++;
cout<<cnt;

n = (n & 0x55555555) + ((n & 0xaaaaaaaa) >> 1); //Only this line if 2 bits can represent the integer
n = (n & 0x33333333) + ((n & 0xcccccccc) >> 2); //This and all above if 4 (or less) bits can represent the integer
n = (n & 0x0f0f0f0f) + ((n & 0xf0f0f0f0) >> 4); //This and all above if 8 (or less) bits can represent the integer
n = (n & 0x00ff00ff) + ((n & 0xff00ff00) >> 8); //This and all above if 16 (or less) bits can represent the integer
n = (n & 0x0000ffff) + ((n & 0xffff0000) >> 16); //This and all above if 32 (or less) bits can represent the integer

So all above four lines can be used for any 32 bit integer.

One of the best implementations of the above algorithm is that if we do a & operator with the digit 1 and then if the result comes to be 1 which means that the variable temp contains a bit which is 1 and then, we can increment the counter variable and then we can shift the number to right side and then again check till the number is not equal to zero.

Implementation:

#include<bits/stdc++.h>
using namespace std;
int findbits(int num){
  int count = 0; 
  int temp = num; 
  while(temp != 0){ 
    if((temp & 1) == 1){ 
        count++; 
        temp = temp>>1; 
    } 
  }
  return count;
}
int main(){
    cout<<findbits(3)<<endl;

}