Open In App
Related Articles

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

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

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 S1 and S2 such S = S1S2. If we know parity of S1 and S2, we can compute parity of S using below facts :

  1. If S1 and S2 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.
  2. Therefore parity of S is XOR of parities of S1 and S2

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#

// 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)



Last Updated : 28 Aug, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads