I'm converting an unsigned integer to binary using bitwise operators, and currently do integer & 1 to check if bit is 1 or 0 and output, then right shift by 1 to divide by 2. However the bits are returned in the wrong order (reverse), so I thought to reverse the bits order in the integer before beginning.
Is there a simple way to do this?
Example: So if I'm given the unsigned int 10 = 1010
while (x not eq 0)
if (x & 1)
output a '1'
else
output a '0'
right shift x by 1
this returns 0101 which is incorrect... so I was thinking to reverse the order of the bits originally before running the loop, but I'm unsure how to do this?
Reversing the bits in a word is annoying and it's easier just to output them in reverse order. E.g.,
void write_u32(uint32_t x)
{
int i;
for (i = 0; i < 32; ++i)
putchar((x & ((uint32_t) 1 << (31 - i)) ? '1' : '0');
}
Here's the typical solution to reversing the bit order:
uint32_t reverse(uint32_t x)
{
x = ((x >> 1) & 0x55555555u) | ((x & 0x55555555u) << 1);
x = ((x >> 2) & 0x33333333u) | ((x & 0x33333333u) << 2);
x = ((x >> 4) & 0x0f0f0f0fu) | ((x & 0x0f0f0f0fu) << 4);
x = ((x >> 8) & 0x00ff00ffu) | ((x & 0x00ff00ffu) << 8);
x = ((x >> 16) & 0xffffu) | ((x & 0xffffu) << 16);
return x;
}
you could move from left to right instead, that is shift a one from the MSB to the LSB, for example:
unsigned n = 20543;
unsigned x = 1<<31;
while (x) {
printf("%u ", (x&n)!=0);
x = x>>1;
}
You could just loop through the bits from big end to little end.
#define N_BITS (sizeof(unsigned) * CHAR_BIT)
#define HI_BIT (1 << (N_BITS - 1))
for (int i = 0; i < N_BITS; i++) {
printf("%d", !!(x & HI_BIT));
x <<= 1;
}
Where !! can also be written !=0 or >> (N_BITS - 1).
You could reverse the bits like you output them, and instead store them in another integer, and do it again :
for (i = 0; i < (sizeof(unsigned int) * CHAR_BIT); i++)
{
new_int |= (original_int & 1);
original_int = original_int >> 1;
new_int = new_int << 1;
}
Or you could just do the opposite, shift your mask :
unsigned int mask = 1 << ((sizeof(unsigned int) * CHAR_BIT) - 1);
while (mask > 0)
{
bit = original_int & mask;
mask = mask >> 1;
printf("%d", (bit > 0));
}
If you want to remove leading 0's you can either wait for a 1 to get printed, or do a preliminary go-through :
unsigned int mask = 1 << ((sizeof(unsigned int) * CHAR_BIT) - 1);
while ((mask > 0) && ((original_int & mask) == 0))
mask = mask >> 1;
do
{
bit = original_int & mask;
mask = mask >> 1;
printf("%d", (bit > 0));
} while (mask > 0);
this way you will place the mask on the first 1 to be printed and forget about the leading 0's
But remember : printing the binary value of an integer can be done just with printf
unsigned int rev_bits(unsigned int input)
{
unsigned int output = 0;
unsigned int n = sizeof(input) << 3;
unsigned int i = 0;
for (i = 0; i < n; i++)
if ((input >> i) & 0x1)
output |= (0x1 << (n - 1 - i));
return output;
}
The Best way to reverse the bit in an integer is:
- It is very efficient.
- It only runs upto when the leftmost bit is 1.
int reverse ( unsigned int n )
{
int x = 0;
int mask = 1;
while ( n > 0 )
{
x = x << 1;
if ( mask & n )
x = x | 1;
n = n >> 1;
}
return x;
}
I came up with a solution which dosesn't involve any application of bitwise operators. it is inefficient in terms of both space and time.
int arr[32];
for(int i=0;i<32;i++)
{
arr[i]=A%2;
A=A/2;
}
double res=1;
double re=0;
for(int i=0;i<32;i++)
{
int j=31-i;
res=arr[i];
while(j>0)
{
res=res*2;
j--;
}
re=re+res;
}
cout<<(unsigned int )re;
Here's a golang version of reverse bits in an integer, if anyone is looking for one. I wrote this with an approach similar to string reverse in c. Going over from bits 0 to 15 (31/2), swap bit i with bit (31-i). Please check the following code.
package main
import "fmt"
func main() {
var num = 2
//swap bits at index i and 31-i for i between 0-15
for i := 0; i < 31/2; i++ {
swap(&num, uint(i))
}
fmt.Printf("num is %d", num)
}
//check if bit at index is set
func isSet(num *int, index uint) int {
return *num & (1 << index)
}
//set bit at index
func set(num *int, index uint) {
*num = *num | (1 << index)
}
//reset bit at index
func reSet(num *int, index uint) {
*num = *num & ^(1 << index)
}
//swap bits on index and 31-index
func swap(num *int, index uint) {
//check index and 31-index bits
a := isSet(num, index)
b := isSet(num, uint(31)-index)
if a != 0 {
//bit at index is 1, set 31-index
set(num, uint(31)-index)
} else {
//bit at index is 0, reset 31-index
reSet(num, uint(31)-index)
}
if b != 0 {
set(num, index)
} else {
reSet(num, index)
}
}`
You can reverse an unsigned 32-bit integer and return using the following reverse function :
unsigned int reverse(unsigned int A) {
unsigned int B = 0;
for(int i=0;i<32;i++){
unsigned int j = pow(2,31-i);
if((A & (1<<i)) == (1<<i)) B += j;
}
return B;
}
Remember to include the math library. Happy coding :)
I believe the question is asking how to not output in reverse order.
Fun answer (recursion):
#include <stdio.h>
void print_bits_r(unsigned int x){
if(x==0){
printf("0");
return;
}
unsigned int n=x>>1;
if(n!=0){
print_bits_r(n);
}
if(x&1){
printf("1");
}else{
printf("0");
}
}
void print_bits(unsigned int x){
printf("%u=",x);
print_bits_r(x);
printf("\n");
}
int main(void) {
print_bits(10u);//1010
print_bits((1<<5)+(1<<4)+1);//110001
print_bits(498598u);//1111001101110100110
return 0;
}
Expected output:
10=1010
49=110001
498598=1111001101110100110
Sequential version (picks off the high-bits first):
#include <limits.h>//Defines CHAR_BIT
//....
void print_bits_r(unsigned int x){
//unsigned int mask=(UINT_MAX>>1)+1u;//Also works...
unsigned int mask=1u<<(CHAR_BIT*sizeof(unsigned int)-1u);
int start=0;
while(mask!=0){
if((x&mask)!=0){
printf("1");
start=1;
}else{
if(start){
printf("0");
}
}
mask>>=1;
}
if(!start){
printf("0");
}
}
The 2nd answer by Dietrich Epp is likely what's best on a modern processor with high speed caches. On typical microcontrollers however that is not the case and there the following is not only much faster but also more versatile and more compact (in C):
// reverse a byte
uint8_t reverse_u8(uint8_t x)
{
const unsigned char * rev = "\x0\x8\x4\xC\x2\xA\x6\xE\x1\x9\x5\xD\x3\xB\x7\xF";
return rev[(x & 0xF0) >> 4] | (rev[x & 0x0F] << 4);
}
// reverse a word
uint16_t reverse_u16(uint16_t x)
{
return reverse_u8(x >> 8) | (reverse_u8(x & 0xFF) << 8);
}
// reverse a long
uint32_t reverse_u32(uint32_t x)
{
return reverse_u16(x >> 16) | (reverse_u16(x & 0xFFFF) << 16);
}
The code is easily translated to Java, Go, Rust etc. Of course if you only need to print the digits, it is best to simply print in reverse order (see the answer by Dietrich Epp).
来源：https://stackoverflow.com/questions/9144800/c-reverse-bits-in-unsigned-integer