Reverse bytes of a Hexadecimal Number

Given an unsigned integer N. The task is to reverse all bytes of N without using a temporary variable and print the reversed number. 

Examples:

Input: N = 0xaabbccdd 
Output: 0xddccbbaa 
Input: N = 0xa912cbd4 
Output: 0xd4cb12a9

The naive approach is to extract the appropriate byte is to use mask(&) with shift operators.

#define REV(x) ( ((x&0xff000000)>>24) | (((x&0x00ff0000)<<8)>>16) | (((x&0x0000ff00)>>8)<<16) | ((x&0x000000ff) << 24) )

Efficient approach: The idea is to use shift operators only.

• Move the position of the last byte to the first byte using left shift operator(<<).
• Move the position of the first byte to the last byte using right shift operator(>>).
• Move the middle bytes using the combination of left shift and right shift operator.
• Apply logical OR (|) to the output of all the above expression, to get the desired output.

Below is the implementation of the above approach : 

// C program to reverse bytes of a hexadecimal number 
#include <stdio.h> 
// macro which reverse the hexadecimal integer 
#define REV(n) ((n << 24) | (((n>>16)<<24)>>16) |  (((n<<16)>>24)<<16) | (n>>24)) 
// Driver code 
int main() 
{ unsigned int n = 0xa912cbd4; 
// n = 0xaabbccdd 
// (n >> 24) - 0x000000aa 
// (n << 24) - 0xdd000000 
// (((n >> 16) << 24) >> 16) - 0xbb00 
// (((n >> 8) << 24) >> 8) - 0xcc0000 
// If output of all the above expression is 
// OR'ed then it results in 0xddccbbaa 
printf("%x is reversed to %x", n, REV(n)); 
return 0; }

// C++ program to reverse bytes of a hexadecimal number
#include <iostream>
using namespace std;

int REV(int n)
{
    return ((n >> 24) & 0xff) | ((n << 8) & 0xff0000)
           | ((n >> 8) & 0xff00) | ((n << 24) & 0xff000000);
    // If output of all the above expression is
    // OR'ed then it results in 0xddccbbaa
}

int main()
{
    int n = 0xa912cbd4;
    cout << hex << n << " is reversed to " << REV(n)
         << endl;
    return 0;
}

// Java program to reverse bytes of a hexadecimal number

class GFG {
    public static int REV(int n)
    {
        return ((n >> 24) & 0xff)
            | // (n >> 24) - 0x000000aa
            ((n << 8) & 0xff0000)
            | // (n << 24) - 0xdd000000
            ((n >> 8) & 0xff00)
            | // (((n >> 16) << 24) >> 16) - 0xbb00
            ((n << 24) & 0xff000000); // (((n >> 8) << 24)
                                      // >> 8) - 0xcc0000
        // If output of all the above expression is
        // OR'ed then it results in 0xddccbbaa
    }

    public static void main(String[] args)
    {
        int n = 0xa912cbd4;
        System.out.println(Integer.toHexString(n) + " is reversed to " + Integer.toHexString(REV(n)));
    }
}

//this code is contributed by phasing17

// C# program to reverse bytes of a hexadecimal number
using System;

class GFG {
  public static ulong REV(uint n)
  {
    return (ulong)((n >> 24) & 0xff)
      | // (n >> 24) - 0x000000aa
      (ulong)((n << 8) & 0xff0000)
      | // (n << 24) - 0xdd000000
      (ulong)((n >> 8) & 0xff00)
      | // (((n >> 16) << 24) >> 16) - 0xbb00
      (ulong)((n << 24)
              & 0xff000000); // (((n >> 8) << 24)
    // >> 8) - 0xcc0000
    // If output of all the above expression is
    // OR'ed then it results in 0xddccbbaa
  }

  // Driver code
  public static void Main(string[] args)
  {
    uint n = 0xa912cbd4;

    // Function call
    Console.WriteLine(n.ToString("X")
                      + " is reversed to "
                      + REV(n).ToString("X"));
  }
}

// This code is contributed by phasing17

def REV(n: int) -> int:
    return ((n >> 24) & 0xff) | ((n << 8) & 0xff0000) | ((n >> 8) & 0xff00) | ((n << 24) & 0xff000000)
    # If output of all the above expression is
    # OR'ed then it results in 0xddccbbaa


if __name__ == '__main__':
    n = 0xa912cbd4
    print(f"{n:x} is reversed to {REV(n):x}")

// JavaScript program to reverse bytes of a hexadecimal number

function REV(n) {
    return (BigInt(n) >> 24n & 0xffn)
    | // (n >> 24) - 0x000000aa
    (BigInt(n) << 8n & 0xff0000n)
    | // (n << 24) - 0xdd000000
    (BigInt(n) >> 8n & 0xff00n)
    | // (((n >> 16) << 24) >> 16) - 0xbb00
    (BigInt(n) << 24n & 0xff000000n); // (((n >> 8) << 24)
    // >> 8) - 0xcc0000
    // If output of all the above expression is
    // OR'ed then it results in 0xddccbbaa
}

const n = 0xa912cbd4;
// Function call
console.log(n.toString(16)
              + " is reversed to "
              + REV(n).toString(16));


// This code is contributed by phasing17

a912cbd4 is reversed to d4cb12a9

Time complexity: O(1)
Auxiliary space: O(1)