# Write an Efficient C Program to Reverse Bits of a Number

Given an unsigned integer, reverse all bits of it and return the number with reversed bits.

Input : n = 1
Output : 2147483648
Explanation : On a machine with size of unsigned bit as 32. Reverse of 0….001 is 100….0.

Input : n = 2147483648
Output : 1

Recommended Practice

Method1 – Simple: Loop through all the bits of an integer. If a bit at ith position is set in the i/p no. then set the bit at (NO_OF_BITS – 1) – i in o/p. Where NO_OF_BITS is number of bits present in the given number.

Below is the implementation of the above approach:

## C++

 `#include ` `using` `namespace` `std;`   `// Function to reverse bits of num` `unsigned ``int` `reverseBits(unsigned ``int` `num)` `{` `    ``unsigned ``int` `NO_OF_BITS = ``sizeof``(num) * 8;` `    ``unsigned ``int` `reverse_num = 0;` `    ``int` `i;` `    ``for` `(i = 0; i < NO_OF_BITS; i++) {` `        ``if` `((num & (1 << i)))` `            ``reverse_num |= 1 << ((NO_OF_BITS - 1) - i);` `    ``}` `    ``return` `reverse_num;` `}`   `// Driver code` `int` `main()` `{` `    ``unsigned ``int` `x = 2;` `    ``cout << reverseBits(x);` `    ``return` `0;` `}`   `// This code is contributed By Shivam Tiwari`

## c

 `// C code to implement the approach` `#include `   `// Function to reverse bits of num` `unsigned ``int` `reverseBits(unsigned ``int` `num)` `{` `    ``unsigned ``int` `NO_OF_BITS = ``sizeof``(num) * 8;` `    ``unsigned ``int` `reverse_num = 0;` `    ``int` `i;` `    ``for` `(i = 0; i < NO_OF_BITS; i++) {` `        ``if` `((num & (1 << i)))` `            ``reverse_num |= 1 << ((NO_OF_BITS - 1) - i);` `    ``}` `    ``return` `reverse_num;` `}`   `// Driver code` `int` `main()` `{` `    ``unsigned ``int` `x = 2;` `    ``printf``(``"%u"``, reverseBits(x));` `    ``getchar``();` `}`

## Python

 `def` `reverse_bits(num):` `    ``NO_OF_BITS ``=` `32` `    ``reverse_num ``=` `0` `    ``for` `i ``in` `range``(NO_OF_BITS):` `        ``if` `(num & (``1` `<< i)):` `            ``reverse_num |``=` `1` `<< ((NO_OF_BITS ``-` `1``) ``-` `i)` `    ``return` `reverse_num`   `# Driver code` `x ``=` `2` `print``(reverse_bits(x))`

## C#

 `using` `System;`   `public` `class` `GFG {` `    ``// Function to reverse bits of num` `    ``public` `static` `uint` `ReverseBits(``uint` `num)` `    ``{` `        ``uint` `NO_OF_BITS = (``uint``)(``sizeof``(``uint``) * 8);` `        ``uint` `reverse_num = 0;` `        ``int` `i;` `        ``for` `(i = 0; i < NO_OF_BITS; i++) {` `            ``if` `((num & (1u << i)) != 0)` `                ``reverse_num` `                    ``|= 1u << ((``int``)(NO_OF_BITS - 1) - i);` `        ``}`   `        ``// Return the reversed number` `        ``return` `reverse_num;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main()` `    ``{` `        ``uint` `x = 2u;` `        ``Console.WriteLine(ReverseBits(x));` `    ``}` `}`

## Javascript

 `function` `reverseBits(num) {` `    ``let NO_OF_BITS = 32;` `    ``let reverse_num = 0;` `    ``for` `(let i = 0; i < NO_OF_BITS; i++) {` `        ``if` `((num & (1 << i)) !== 0) {` `            ``reverse_num |= 1 << (NO_OF_BITS - 1) - i;` `        ``}` `    ``}` `    ``return` `reverse_num;` `}`   `// Driver code` `let x = 2;` `console.log(reverseBits(x));`

Output

```1073741824

```

Time Complexity: O(Log n). Time complexity would be Log(num) as there are log(num) bits in a binary number “num” and we’re looping through all bits.
Auxiliary space: O(1)

Method 2 – Standard: The idea is to keep putting set bits of the num in reverse_num until num becomes zero. After num becomes zero, shift the remaining bits of reverse_num. Let num is stored using 8 bits and num be 00000110. After the loop you will get reverse_num as 00000011. Now you need to left shift reverse_num 5 more times and you get the exact reverse 01100000.

Below is the implementation of the above approach:

## C++

 `#include `   `using` `namespace` `std;`   `// Function to reverse bits of num` `unsigned ``int` `reverseBits(unsigned ``int` `num)` `{` `    ``unsigned ``int` `count = ``sizeof``(num) * 8 - 1;` `    ``unsigned ``int` `reverse_num = num;`   `    ``num >>= 1;` `    ``while` `(num) {` `        ``reverse_num <<= 1;` `        ``reverse_num |= num & 1;` `        ``num >>= 1;` `        ``count--;` `    ``}` `    ``reverse_num <<= count;` `    ``return` `reverse_num;` `}`   `// Driver's code` `int` `main()` `{` `    ``unsigned ``int` `x = 1;` `    ``cout << reverseBits(x) << endl;` `    ``return` `0;` `}`   `// This code is contributed By Shivam Tiwari`

## C

 `// C code to implement the approach` `#include `   `// Function to reverse bits of num` `unsigned ``int` `reverseBits(unsigned ``int` `num)` `{` `    ``unsigned ``int` `count = ``sizeof``(num) * 8 - 1;` `    ``unsigned ``int` `reverse_num = num;`   `    ``num >>= 1;` `    ``while` `(num) {` `        ``reverse_num <<= 1;` `        ``reverse_num |= num & 1;` `        ``num >>= 1;` `        ``count--;` `    ``}` `    ``reverse_num <<= count;` `    ``return` `reverse_num;` `}`   `// Driver's code` `int` `main()` `{` `    ``unsigned ``int` `x = 1;` `    ``printf``(``"%u"``, reverseBits(x));` `    ``getchar``();` `}`

## Python3

 `def` `reverseBits(num):` `    ``count ``=` `32` `-` `1` `    ``reverse_num ``=` `num`   `    ``num >>``=` `1` `    ``while` `(num):` `        ``reverse_num <<``=` `1` `        ``reverse_num |``=` `num & ``1` `        ``num >>``=` `1` `        ``count ``-``=` `1`   `    ``reverse_num <<``=` `count` `    ``return` `reverse_num`     `# Driver's code` `if` `__name__ ``=``=` `'__main__'``:` `    ``x ``=` `1` `    ``print``(reverseBits(x))` `# This code is contributed by shivhack999`

## C#

 `using` `System;`   `class` `Program` `{` `    ``// Function to reverse bits of num` `    ``static` `uint` `ReverseBits(``uint` `num)` `    ``{` `        ``uint` `count = ``sizeof``(``uint``) * 8 - 1;` `        ``uint` `reverse_num = num;`   `        ``num >>= 1;` `        ``while` `(num != 0)` `        ``{` `            ``reverse_num <<= 1;` `            ``reverse_num |= num & 1;` `            ``num >>= 1;` `            ``count--;` `        ``}` `        ``reverse_num <<= (``int``)count;` `        ``return` `reverse_num;` `    ``}`   `    ``// Driver's code` `    ``static` `void` `Main()` `    ``{` `        ``uint` `x = 1;` `        ``Console.WriteLine(ReverseBits(x));` `    ``}` `}` `// This Code is Contributed by Shivam Tiwari`

## Javascript

 `// Javascript code to implement the approach`   `// Function to reverse bits of num` `function` `reverseBits(num) {` `    ``let count = 32;` `    ``let reverseNum = 0;`   `    ``while` `(num) {` `        ``reverseNum = (reverseNum << 1) | (num & 1);` `        ``num >>>= 1;` `        ``count--;` `    ``}`   `    ``reverseNum <<= count;` `    ``return` `reverseNum >>> 0; ``// Convert back to unsigned 32-bit integer` `}`   `// Driver's code` `let x = 1;` `console.log(reverseBits(x));`     `// This code is contributed by Taranpreet Singh.`

Output

```2147483648

```

Time Complexity: O(logn) where n is the given number
Auxiliary space: O(1)

Method 3 – Lookup Table: We can reverse the bits of a number in O(1) if we know the size of the number. We can implement it using look up table. Please refer Reverse bits using lookup table in O(1) time for details.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next