Compute the parity of a number using XOR and table look-up

Last Updated : 28 Aug, 2022

Parity of a number refers to whether it contains an odd or even number of 1-bits. The number has “odd parity”, if it contains odd number of 1-bits and is “even parity” if it contains even number of 1-bits.

1 --> parity of the set is odd 0 --> parity of the set is even

Examples:

Input : 254 Output : Odd Parity Explanation : Binary of 254 is 11111110.  There are 7 ones. Thus, parity is odd.  Input : 1742346774 Output : Even

Method 1 : (Naive approach) We have already discussed this method here. Method 2 : (Efficient) Pre-requisites : Table look up, X-OR magic If we break a number S into two parts S₁ and S₂ such S = S₁S₂. If we know parity of S₁ and S₂, we can compute parity of S using below facts :

If S₁ and S₂ have the same parity, i.e. they both have an even number of bits or an odd number of bits, their union S will have an even number of bits.
Therefore parity of S is XOR of parities of S₁ and S₂

The idea is to create a look up table to store parities of all 8 bit numbers. Then compute parity of whole number by dividing it into 8 bit numbers and using above facts. Steps:

1. Create a look-up table for 8-bit numbers ( 0 to 255 )    Parity of 0 is 0.    Parity of 1 is 1.    .    .    .    Parity of 255 is 0. 2. Break the number into 8-bit chunks    while performing XOR operations. 3. Check for the result in the table for     the 8-bit number.

Since a 32 bit or 64 bit number contains constant number of bytes, the above steps take O(1) time. Example :

1. Take 32-bit number : 1742346774  2. Calculate Binary of the number :     01100111110110100001101000010110  3. Split the 32-bit binary representation into    16-bit chunks : 0110011111011010 | 0001101000010110   4. Compute X-OR :   0110011111011010 ^ 0001101000010110 ___________________ = 0111110111001100  5. Split the 16-bit binary representation     into 8-bit chunks : 01111101 | 11001100  6. Again, Compute X-OR :   01111101 ^ 11001100 ___________________ = 10110001 10110001 is 177 in decimal. Check  for its parity in look-up table : Even number of 1 = Even parity.  Thus, Parity of 1742346774 is even.

Below is the implementation that works for both 32 bit and 64 bit numbers.

C++

// CPP program to illustrate Compute the parity of a // number using XOR #include <bits/stdc++.h>  // Generating the look-up table while pre-processing #define P2(n) n, n ^ 1, n ^ 1, n #define P4(n) P2(n), P2(n ^ 1), P2(n ^ 1), P2(n) #define P6(n) P4(n), P4(n ^ 1), P4(n ^ 1), P4(n) #define LOOK_UP P6(0), P6(1), P6(1), P6(0)  // LOOK_UP is the macro expansion to generate the table unsigned int table[256] = { LOOK_UP };  // Function to find the parity int Parity(int num) {     // Number is considered to be of 32 bits     int max = 16;      // Dividing the number into 8-bit     // chunks while performing X-OR     while (max >= 8) {         num = num ^ (num >> max);         max = max / 2;     }      // Masking the number with 0xff (11111111)     // to produce valid 8-bit result     return table[num & 0xff]; }  // Driver code int main() {     unsigned int num = 1742346774;      // Result is 1 for odd parity, 0 for even parity     bool result = Parity(num);      // Printing the desired result     result ? std::cout << "Odd Parity" :              std::cout << "Even Parity";      return 0; }

Java

// Java program to illustrate Compute the  // parity of a number using XOR   import java.util.ArrayList;   class GFG {          // LOOK_UP is the macro expansion to     // generate the table      static  ArrayList<Integer> table = new ArrayList<Integer>();     // Generating the look-up table while      // pre-processing      static void P2(int n)     {         table.add(n);         table.add(n ^ 1);         table.add(n ^ 1);         table.add(n);     }          static void P4(int n)     {         P2(n);         P2(n ^ 1);         P2(n ^ 1);         P2(n);     }          static void P6(int n)     {          P4(n);          P4(n ^ 1);         P4(n ^ 1);         P4(n) ;     }          static void LOOK_UP()     {         P6(0);         P6(1);         P6(1);         P6(0);     }                     // Function to find the parity      static int Parity(int num)     {              // Number is considered to be         // of 32 bits          int max = 16;              // Dividing the number o 8-bit          // chunks while performing X-OR          while (max >= 8)         {             num = num ^ (num >> max);             max = (max / 2);         }              // Masking the number with 0xff (11111111)          // to produce valid 8-bit result          return table.get(num & 0xff);     }           public static void main(String[] args) {         // Driver code          int num = 1742346774;                  LOOK_UP();                      //Function call         int result = Parity(num);                  // Result is 1 for odd parity,          // 0 for even parity          if (result != 0)             System.out.println("Odd Parity");         else             System.out.println("Even Parity");     } }  //This code is contributed by phasing17

Python3

# Python3 program to illustrate Compute the  # parity of a number using XOR   # Generating the look-up table while  # pre-processing  def P2(n, table):     table.extend([n, n ^ 1, n ^ 1, n]) def P4(n, table):     return (P2(n, table), P2(n ^ 1, table),              P2(n ^ 1, table), P2(n, table)) def P6(n, table):     return (P4(n, table), P4(n ^ 1, table),             P4(n ^ 1, table), P4(n, table))  def LOOK_UP(table):     return (P6(0, table), P6(1, table),             P6(1, table), P6(0, table))   # LOOK_UP is the macro expansion to # generate the table  table = [0] * 256 LOOK_UP(table)  # Function to find the parity  def Parity(num) :      # Number is considered to be     # of 32 bits      max = 16      # Dividing the number o 8-bit      # chunks while performing X-OR      while (max >= 8):          num = num ^ (num >> max)          max = max // 2      # Masking the number with 0xff (11111111)      # to produce valid 8-bit result      return table[num & 0xff]   # Driver code  if __name__ =="__main__":     num = 1742346774          # Result is 1 for odd parity,      # 0 for even parity      result = Parity(num)     print("Odd Parity") if result else print("Even Parity")   # This code is contributed by # Shubham Singh(SHUBHAMSINGH10)

// C# program to illustrate Compute the // parity of a number using XOR using System; using System.Collections.Generic;  class GFG {      // LOOK_UP is the macro expansion to     // generate the table     static List<int> table = new List<int>();        // Generating the look-up table while     // pre-processing     static void P2(int n)     {         table.Add(n);         table.Add(n ^ 1);         table.Add(n ^ 1);         table.Add(n);     }      static void P4(int n)     {         P2(n);         P2(n ^ 1);         P2(n ^ 1);         P2(n);     }      static void P6(int n)     {         P4(n);         P4(n ^ 1);         P4(n ^ 1);         P4(n);     }      static void LOOK_UP()     {         P6(0);         P6(1);         P6(1);         P6(0);     }      // Function to find the parity     static int Parity(int num)     {          // Number is considered to be         // of 32 bits         int max = 16;          // Dividing the number o 8-bit         // chunks while performing X-OR         while (max >= 8) {             num = num ^ (num >> max);             max = (max / 2);         }          // Masking the number with 0xff (11111111)         // to produce valid 8-bit result         return table[num & 0xff];     }      public static void Main(string[] args)     {         // Driver code         int num = 1742346774;          LOOK_UP();          // Function call         int result = Parity(num);          // Result is 1 for odd parity,         // 0 for even parity         if (result != 0)             Console.WriteLine("Odd Parity");         else             Console.WriteLine("Even Parity");     } }  // This code is contributed by phasing17

PHP

<?php // PHP program to illustrate // Compute the parity of a // number using XOR  /* Generating the look-up  table while pre-processing #define P2(n) n, n ^ 1, n ^ 1, n #define P4(n) P2(n), P2(n ^ 1),                P2(n ^ 1), P2(n) #define P6(n) P4(n), P4(n ^ 1),                P4(n ^ 1), P4(n) #define LOOK_UP P6(0), P6(1),                  P6(1), P6(0)  LOOK_UP is the macro expansion to generate the table $table = array(LOOK_UP ); */  // Function to find // the parity function Parity($num) {     global $table;          // Number is considered      // to be of 32 bits     $max = 16;      // Dividing the number      // into 8-bit chunks      // while performing X-OR     while ($max >= 8)      {         $num = $num ^ ($num >> $max);         $max = (int)$max / 2;     }      // Masking the number with      // 0xff (11111111) to produce     // valid 8-bit result     return $table[$num & 0xff]; }  // Driver code $num = 1742346774;  // Result is 1 for odd  // parity, 0 for even parity $result = Parity($num);  // Printing the desired result if($result == true)         echo "Odd Parity" ;     else         echo"Even Parity";  // This code is contributed by ajit ?>

JavaScript

//JavaScript program to illustrate Compute the  // parity of a number using XOR   // Generating the look-up table while  // pre-processing  function P2(n, table) {     table.push(n, n ^ 1, n ^ 1, n); }  function P4(n, table) {     return (P2(n, table), P2(n ^ 1, table),              P2(n ^ 1, table), P2(n, table)); }  function P6(n, table) {     return (P4(n, table), P4(n ^ 1, table),             P4(n ^ 1, table), P4(n, table)) ; }  function LOOK_UP(table) {     return (P6(0, table), P6(1, table),             P6(1, table), P6(0, table)); }  // LOOK_UP is the macro expansion to // generate the table  var table = new Array(256).fill(0); LOOK_UP(table);  // Function to find the parity  function Parity(num) {      // Number is considered to be     // of 32 bits      var max = 16;      // Dividing the number o 8-bit      // chunks while performing X-OR      while (max >= 8)     {         num = num ^ (num >> max);         max = Math.floor(max / 2);     }      // Masking the number with 0xff (11111111)      // to produce valid 8-bit result      return table[num & 0xff] ; }  // Driver code  var num = 1742346774;      //Function call var result = Parity(num); // Result is 1 for odd parity,  // 0 for even parity  console.log(result ? "Odd Parity" : "Even Parity");   // This code is contributed by phasing17

Output:

Even Parity

Time Complexity : O(1). Note that a 32 bit or 64 bit number has fixed number of bytes (4 in case of 32 bits and 8 in case of 64 bits).

Auxiliary Space: O(1)

Compute the parity of a number using XOR and table look-up

Rohit Thapliyal

Improve

Article Tags :

Practice Tags :

Compute the parity of a number using XOR and table look-up

Similar Reads

Easy Problems on Bit Manipulations and Bitwise Algorithms