a fanny question

[xinxin]

hi eyeryone
001101000000000000100000000000000 is a number in binary system.how can
i get the number of '1's ?
thanks in advance

[Joachim Schmitz]

xinxin wrote:

hi eyeryone
001101000000000000100000000000000 is a number in binary system.how can
i get the number of '1's ?

Easy: just count them. I count 4.

Bye, Jojo

[zerg]

On 22 abr, 11:10, "Joachim Schmitz" <[e-mail]>
wrote:

xinxin wrote:

hi eyeryone
001101000000000000100000000000000 is a number in binary system.how can
i get the number of '1's ?

Easy: just count them. I count 4.

Bye, Jojo

Are you using a string?
Maybe "for" can help you.

[xinxin]

On 4ÔÂ22ÈÕ, ÏÂÎç10ʱ03·Ö, xinxin <jnzhouxin...@gmail..comwrote:

hi eyeryone
001101000000000000100000000000000 is a number in binary system.how can
i get the number of '1's ?
thanks in advance

oh ,i must add something .there is little '1's .and it's not a string
but
a unsinged long type. that's to say i what to know how many '1's
a number in decimal system has when it showed in binary system.anyone
get any idea.

[bryan-webelos]

On Apr 22, 10:03 am, xinxin <[e-mail]:

hi eyeryone
001101000000000000100000000000000 is a number in binary system.how can
i get the number of '1's ?
thanks in advance

http://graphics.stanford.edu/~seander/bithacks.html

[Bartc]

"xinxin" <jn**********@gmail.comwrote in message
news:75**********************************@t54g2000 hsg.googlegroups.com...

hi eyeryone
001101000000000000100000000000000 is a number in binary system.how can
i get the number of '1's ?
thanks in advance

I used this code. But I'm not sure if it's guaranteed to complete.

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

#define int_bits sizeof(unsigned int)*CHAR_BIT

/* return number of set bits in n */
int countbits(unsigned int n) {
int count,bitno;
unsigned m;

count=0;

while (n) {
bitno = rand() & (int_bits-1); /* assume 2^k bits */
m=1;
if (bitno) m<<=bitno; /* m<<0 legal? don't know */

if (n & m) {
++count;
n &= (~m);
};
};

return count;
}

char* strbits(unsigned int n) {
static char s[int_bits+2];
int i,j;

j=int_bits;
s[int_bits]=0;
for (i=0; i<int_bits; ++i) {
s[--j] = ((n & 1) ?'1':'0');
n>>=1;
};

return s;
}

int main(void)
{
int count,bitno;
unsigned int number=0x55555555;

printf("Number = %u\n",number);
printf(" = %sB\n",strbits(number));
printf("1 Bits = %d\n",countbits(number));

}

--
Bartc

[santosh]

xinxin wrote:

[misleading subject line]

hi eyeryone
001101000000000000100000000000000 is a number in binary system.how can
i get the number of '1's ?
thanks in advance

You can use a combnation of shifts and bit masks to calculate the number
of set bits. Code for this has often been posted to this group. A
Google search might help.

Here is a quick and dirty program I cobbled up. Haven't tested it much.

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <limits.h>

unsigned n_setbits(unsigned long);

int main(int argc, char **argv) {
unsigned long n;

if (argc != 2) {
puts("Usage: program number.");
exit(EXIT_FAILURE);
}
else {
errno = 0;
n = strtoul(argv[1], NULL, 0);
if (errno == ERANGE) {
puts("Conversion error.");
exit(EXIT_FAILURE);
}
printf("Set bits = %u\n", n_setbits(n));
}
return 0;
}

unsigned n_setbits(unsigned long n) {
unsigned setbits, ctr;
unsigned long mask;

for (ctr = setbits = 0, mask = 1;
ctr <= sizeof(unsigned long) * CHAR_BIT;
ctr++, mask <<= 1) {
if (n & mask) {
setbits++;
}
}
return setbits;
}

[Sjouke Burry]

xinxin wrote:

hi eyeryone
001101000000000000100000000000000 is a number in binary system.how can
i get the number of '1's ?
thanks in advance

Count them.

[Peter Nilsson]

santosh wrote:

unsigned n_setbits(unsigned long n) {
unsigned setbits, ctr;
unsigned long mask;

for (ctr = setbits = 0, mask = 1;
ctr <= sizeof(unsigned long) * CHAR_BIT;

WHY?!!!

Work with _values_, not _representations_.

The expression sizeof(unsigned long) * CHAR_BIT needn't
match the number of value bits in unsigned long.

The mask you're using will become zero when you run out
of bits. You don't need to count how many bits there might
be when you're already traversing the bits that are.

That said, I generally prefer...

for (mask = -1, mask = mask / 2 + 1; mask; mask <<= 1)

....because it's portable to unsigned types with rank lower
than int. [Note that it's theoretically possible that USHRT_MAX
== INT_MAX.]

ctr++, mask <<= 1) {
if (n & mask) {
setbits++;
}
}
return setbits;
}

--
Peter

[xinxin]

On 4ÔÂ23ÈÕ, ÉÏÎç2ʱ03·Ö, santosh <[e-mail]:

xinxin wrote:

[misleading subject line]

hi eyeryone
001101000000000000100000000000000 is a number in binary system.how can
i get the number of '1's ?
thanks in advance

You can use a combnation of shifts and bit masks to calculate the number
of set bits. Code for this has often been posted to this group. A
Google search might help.

the idea is great. and it work perfectly. but as i said before ,there
is little '1' in the number of binary system. must i get the number of
'1's
it contains(or includes,i don't know which word to choose) by checking
it bit by bit .that's maybe the most fanny as well as most challenging
part
of this small question

[Keith Thompson]

xinxin <jn**********@gmail.comwrites:

On 4月23日, 上�2时03分, santosh <[e-mail]:

>xinxin wrote:

[misleading subject line]

hi eyeryone
001101000000000000100000000000000 is a number in binary system.how can
i get the number of '1's ?
thanks in advance

You can use a combnation of shifts and bit masks to calculate the number
of set bits. Code for this has often been posted to this group. A
Google search might help.

the idea is great. and it work perfectly. but as i said before ,there
is little '1' in the number of binary system. must i get the number of
'1's
it contains(or includes,i don't know which word to choose) by checking
it bit by bit .that's maybe the most fanny as well as most challenging
part
of this small question

I think what you're saying is that you have a binary number with
relatively few 1s, and you'd like a way to count the 1s that's more
efficient than traversing all the bits.

As santosh said, this has been discussed here before. A Google search
will likely turn up a number of solutions. Here's one I just found:
<http://infolab.stanford.edu/~manku/bitcount/bitcount.html(I do not
vouch for the accuracy of the information).

Incidentally, you should look up the word "fanny" in your English
dictionary. I don't know what you're trying to say, but it doesn't
mean what you think it means.
--
Keith Thompson (The_Other_Keith) <ks***@mib.org>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Ian Collins]

Keith Thompson wrote:

>
Incidentally, you should look up the word "fanny" in your English
dictionary. I don't know what you're trying to say, but it doesn't
mean what you think it means.

It doesn't even mean the same in American and British English...

--
Ian Collins.

[CBFalconer]

Sjouke Burry wrote:

xinxin wrote:

>001101000000000000100000000000000 is a number in binary system.
how can i get the number of '1's ?

Count them.

Load the phrase into your text editor. Place the cursor on the
first digit. Record the column number shown by the editor as l.
Move the cursor to just past the last digit. Record the column
number as r. Now count the number of zeroes in the whole number,
and record as m. Then solve the equation:

n + m = r - l

for n. Notice that you can also count 1's and solve for the number
of zeroes. Ain't maths wonderful!

--
[mail]: Chuck F (cbfalconer at maineline dot net)
[page]: <http://cbfalconer.home.att.net>
Try the download section.

** Posted from http://www.teranews.com **

[xinxin]

On 4ÔÂ23ÈÕ, ÉÏÎç9ʱ14·Ö, Keith Thompson <[e-mail]:

xinxin <[e-mail]:

On 4ÔÂ23ÈÕ, ÉÏÎç2ʱ03·Ö, santosh <[e-mail]:

xinxin wrote:

[misleading subject line]

hi eyeryone
001101000000000000100000000000000 is a number in binary system.how can
i get the number of '1's ?
thanks in advance

You can use a combnation of shifts and bit masks to calculate the number
of set bits. Code for this has often been posted to this group. A
Google search might help.

the idea is great. and it work perfectly. but as i said before ,there
is little '1' in the number of binary system. must i get the number of
'1's
it contains(or includes,i don't know which word to choose) by checking
it bit by bit .that's maybe the most fanny as well as most challenging
part
of this small question

I think what you're saying is that you have a binary number with
relatively few 1s, and you'd like a way to count the 1s that's more
efficient than traversing all the bits.

As santosh said, this has been discussed here before. A Google search
will likely turn up a number of solutions. Here's one I just found:
<http://infolab.stanford.edu/~manku/bitcount/bitcount.html(I do not
vouch for the accuracy of the information).

Incidentally, you should look up the word "fanny" in your English
dictionary. I don't know what you're trying to say, but it doesn't
mean what you think it means.

--
Keith Thompson (The_Other_Keith) <[e-mail]>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"- Òþ²Ø±»ÒýÓÃÎÄ×Ö -

- ÏÔʾÒýÓõÄÎÄ×Ö -

oh, you give me the best solution to my quetion. and maybe i should
learn english harder .english is important for a chinese to learn
software.

[Nick Keighley]

On 23 Apr, 01:44, xinxin <[e-mail]:

the idea is great. and it work perfectly. but as i said before ,there
is little '1' in the number of binary system.

a "little '1'" is presumably ~0.9 and a "big '1'" ~1.1
:-)
--
Nick keighley

[Doug Miller]

In article <87************@kvetch.smov.org>, Keith Thompson <ks***@mib.orgwrote:

>Incidentally, you should look up the word "fanny" in your English
dictionary. I don't know what you're trying to say, but it doesn't
mean what you think it means.

And, of course, the meaning given in the dictionary will depend on which side
of the Atlantic Ocean the dictionary was printed on. <g>

[pete]

xinxin wrote:

hi eyeryone
001101000000000000100000000000000 is a number in binary system.how can
i get the number of '1's ?
thanks in advance

long unsigned bit_count(long unsigned n)
{
long unsigned count;

for (count = 0; n != 0; n &= n - 1) {
++count;
}
return count;
}

--
pete

[=?ISO-8859-1?Q?Tom=E1s_=D3_h=C9ilidhe?=]

long unsigned bit_count(long unsigned n)
{
* * *long unsigned count;

* * *for (count = 0; n != 0; n &= n - 1) {
* * * * *++count;
* * *}
* * *return count;

}

Or another alternative:

unsigned HighCount(IntType val)
{
unsigned count = 0;

for ( ; val; val >>= 1)
count += (count & (IntType)1);

return count;
}

I could have replaced the body of the loop with:
if (count & (IntType)1) ++count;

but I think an addition would be faster than a branching.

[user923005]

On Apr 24, 5:38*pm, Tomás Ó hÉilidhe <[e-mail]:

long unsigned bit_count(long unsigned n)
{
* * *long unsigned count;

* * *for (count = 0; n != 0; n &= n - 1) {
* * * * *++count;
* * *}
* * *return count;

}

Or another alternative:

unsigned HighCount(IntType val)
{
* * unsigned count = 0;

* * for ( ; val; val >>= 1)
* * * * count += (count & (IntType)1);

* * return count;

}

I could have replaced the body of the loop with:
* * if (count & (IntType)1) ++count;

but I think an addition would be faster than a branching.

This problem arises all the time in game programming. It's typically
called "population count" or "popcount". Here is the Chess
Programming Wiki entry on it:
http://chessprogramming.wikispaces.com/Population+Count

[pete]

Tomás Ó hÉilidhe wrote:

>long unsigned bit_count(long unsigned n)
{
long unsigned count;

for (count = 0; n != 0; n &= n - 1) {
++count;
}
return count;

}

Or another alternative:

unsigned HighCount(IntType val)
{
unsigned count = 0;

for ( ; val; val >>= 1)
count += (count & (IntType)1);

return count;
}

I could have replaced the body of the loop with:
if (count & (IntType)1) ++count;

but I think an addition would be faster than a branching.

HighCount uses a very different algorithm from bit_count.
The running time of bit_count
is proportional to the return value.

--
pete

[Chris Torek]

In article <bf**********************************@j22g2000hsf. googlegroups.com>
Tomás Ó hÉilidhe <to*@lavabit.comwrote:

unsigned count = 0;
for ( ; val; val >>= 1)
count += (count & (IntType)1);

I am surprised no one else pointed this out yet: since count
is initially 0, (count & 1) is 0, so this always adds 0 to 0,
leaving count 0. So the total count is always 0.

(Obviously you meant:

count += (val & 1);

and the cast to IntType is not needed, so I left it out.)
--
In-Real-Life: Chris Torek, Wind River Systems
Salt Lake City, UT, USA (40°39.22'N, 111°50.29'W) [phone]
email: gmail (figure it out) http://web.torek.net/torek/index.html