reverse the bits in an interger?

[KG]

Could any one tell me how to reverse the bits in an interger?

[Richard Heathfield]

KG said:

Could any one tell me how to reverse the bits in an interger?

int reverse_bits(in t n)
{
return ~n;
}

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at the above domain, - www.

[Joachim Schmitz]

"Richard Heathfield" <rj*@see.sig.in validschrieb im Newsbeitrag
news:Jb******** *************** *******@bt.com. ..

KG said:

>Could any one tell me how to reverse the bits in an interger?

int reverse_bits(in t n)
{
return ~n;
}

That's inverting (1 turn into 0 and vice versa), not reverting. I understood
the OP wants the laest significant bit being the most significate, the 2nd
least being the second most and so on.

Bye, Jojo

[Michal Nazarewicz]

KG <Kr************ **@gmail.comwri tes:

Could any one tell me how to reverse the bits in an interger?

Use a loop. For instance here you have a pseudocode (foo[i] represents
ith bit):

#v+
output := 0;
FOR i := 0 TO number of bits:
IF input[i] is set
set output[number of bits - i];
#v-

--
Best regards, _ _
.o. | Liege of Serenly Enlightened Majesty of o' \,=./ `o
..o | Computer Science, Michal "mina86" Nazarewicz (o o)
ooo +--<mina86*tlen.pl >---<jid:mina86*chr ome.pl>--ooO--(_)--Ooo--

[Anonymous]

On Jun 20, 2:40 pm, KG <Kriti.Goyal.t. [e-mail] te:

Could any one tell me how to reverse the bits in an interger?

First of all you need to know the size of integer, then you should go
somthing like this:

<snip>
int cnt=0,num=0,tem p=0,res=0;
while(cnt<32) // here i consider size of integer to be 32-bit
{
temp=num & 1; // num contains the value of integer
res=res | temp;
num=0;
num=num>>1;
res=res<<1;
cnt++;
}
</snip>

I havent checked it. But still the idea will like this only. Also
check for the 32 iteration.
Thanks and Regards,
ar
--
"Let's plan a murder, or start a new religion."

[Chris Dollin]

Michal Nazarewicz wrote:

KG <Kr************ **@gmail.comwri tes:

>Could any one tell me how to reverse the bits in an interger?

Use a loop. For instance here you have a pseudocode (foo[i] represents
ith bit):

#v+
output := 0;
FOR i := 0 TO number of bits:

Suppose we have 2-bit integers, so number of bits is 2; and assuming
the usual reading of a FOR-TO loop ...

IF input[i] is set

.... there will be an array indexing problem, since `i` will take on
the values 0, 1, 2 and either the index `0` or `2` will be wrong.
I suspect you want `number of bits - 1`. Or even better

for i from lowestBitIndex to highestBitIndex do

or, since the ordering doesn't matter

for i in validIndexes do

where `validIndexes` is the set of legal index values.

Encoding these is C is of course straightforward .

--
Chris "unless I play a Rune card" Dollin

Hewlett-Packard Limited registered office: Cain Road, Bracknell,
registered no: 690597 England Berks RG12 1HN

[Torsten Karwoth]

KG wrote:

Could any one tell me how to reverse the bits in an interger?

---------snip------------
#include <string.h>
#include <stdio.h>

unsigned int revbits(unsigne d int n)
{
unsigned int i, result = 0;

for (i = sizeof(int) * 8; i; --i)
{
result <<= 1;
if (n & 1)
result |= 1;
n >>= 1;
}
return result;
}

int main(void)
{
int i = (sizeof(int) * 8);

while (--i >= 0)
printf("IN:0x%. 08x OUT:0x%.08x\n",
1<<i, revbits(1<<i));
return 0;
};
-----------snap----------
tk@localhost ~/test $ gcc -O2 -Wall -o test test.c
tk@localhost ~/test $ ./test
IN:0x80000000 OUT:0x00000001
IN:0x40000000 OUT:0x00000002
IN:0x20000000 OUT:0x00000004
IN:0x10000000 OUT:0x00000008
..............
IN:0x00000004 OUT:0x20000000
IN:0x00000002 OUT:0x40000000
IN:0x00000001 OUT:0x80000000

(the printf doesnt take sizeof(int) into account)

[Richard Heathfield]

Joachim Schmitz said:

"Richard Heathfield" <rj*@see.sig.in validschrieb im Newsbeitrag
news:Jb******** *************** *******@bt.com. ..

>KG said:

>>Could any one tell me how to reverse the bits in an interger?

int reverse_bits(in t n)
{
return ~n;
}

That's inverting (1 turn into 0 and vice versa), not reverting.

It reverses the sense of each bit.

I understood the OP wants the laest significant bit being the most
significate, the 2nd least being the second most and so on.

And so you have (unwittingly?) made explicit the implicit lesson that
specifications *matter*.

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at the above domain, - www.

[Army1987]

"Torsten Karwoth" <ag******@gmx.d eha scritto nel messaggio news:5d******** *****@mid.uni-berlin.de...

KG wrote:

>Could any one tell me how to reverse the bits in an interger?

---------snip------------
#include <string.h>
#include <stdio.h>

unsigned int revbits(unsigne d int n)
{
unsigned int i, result = 0;

for (i = sizeof(int) * 8; i; --i)

#include <limits.hand use CHAR_BIT instead of 8.
Also, what if there are padding bits?
To be *totally* portable: (yes, most machines have 8-bit bytes and
no padding in unsigned int's, but that's not required by the C
standard)
#include <limits.h>

int count_bits(unsi gned int n)
{
int result = 1;
while (n /= 2)
result++;
return result;
}

unsigned int revbits(unsigne d int n)
{
unsigned int i, result = 0;
for (i = count_bits(UINT _MAX); i; --i)

{
result <<= 1;
if (n & 1)
result |= 1;
n >>= 1;
}
return result;
}

int main(void)
{
int i = (sizeof(int) * 8);

while (--i >= 0)
printf("IN:0x%. 08x OUT:0x%.08x\n",
1<<i, revbits(1<<i));
return 0;
};
-----------snap----------
tk@localhost ~/test $ gcc -O2 -Wall -o test test.c
tk@localhost ~/test $ ./test
IN:0x80000000 OUT:0x00000001
IN:0x40000000 OUT:0x00000002
IN:0x20000000 OUT:0x00000004
IN:0x10000000 OUT:0x00000008
..............
IN:0x00000004 OUT:0x20000000
IN:0x00000002 OUT:0x40000000
IN:0x00000001 OUT:0x80000000

(the printf doesnt take sizeof(int) into account)

printf("IN:0x%. *x OUT:0x%.*x\n", CHAR_BIT * sizeof(int) / 4,
i<<i, CHAR_BIT * sizeof(int) / 4, revbits(1<<i));

[borkhuis]

On Jun 20, 11:56 am, "Joachim Schmitz" <nospam.j...@sc hmitz-
digital.dewrote :

int reverse_bits(in t n)
{
return ~n;
}

That's inverting (1 turn into 0 and vice versa), not reverting. I understood
the OP wants the laest significant bit being the most significate, the 2nd
least being the second most and so on.

I did not understand that: the OP asked for to "reverse the bits in an
interger". This function reverses all bits in the integer. What you
are proposing is reversing the order of the bits, which is different.

Kind regards,
Johan Borkhuis