Compute the parity of a number using XOR and table look-up
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 :
- 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.
- 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++
#include <bits/stdc++.h>
#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)
unsigned int table[256] = { LOOK_UP };
int Parity( int num)
{
int max = 16;
while (max >= 8) {
num = num ^ (num >> max);
max = max / 2;
}
return table[num & 0xff];
}
int main()
{
unsigned int num = 1742346774;
bool result = Parity(num);
result ? std::cout << "Odd Parity" :
std::cout << "Even Parity" ;
return 0;
}
|
Java
import java.util.ArrayList;
class GFG {
static ArrayList<Integer> table = new ArrayList<Integer>();
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 );
}
static int Parity( int num)
{
int max = 16 ;
while (max >= 8 )
{
num = num ^ (num >> max);
max = (max / 2 );
}
return table.get(num & 0xff );
}
public static void main(String[] args) {
int num = 1742346774 ;
LOOK_UP();
int result = Parity(num);
if (result != 0 )
System.out.println( "Odd Parity" );
else
System.out.println( "Even Parity" );
}
}
|
Python3
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))
table = [ 0 ] * 256
LOOK_UP(table)
def Parity(num) :
max = 16
while ( max > = 8 ):
num = num ^ (num >> max )
max = max / / 2
return table[num & 0xff ]
if __name__ = = "__main__" :
num = 1742346774
result = Parity(num)
print ( "Odd Parity" ) if result else print ( "Even Parity" )
|
C#
using System;
using System.Collections.Generic;
class GFG {
static List< int > table = new List< int >();
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);
}
static int Parity( int num)
{
int max = 16;
while (max >= 8) {
num = num ^ (num >> max);
max = (max / 2);
}
return table[num & 0xff];
}
public static void Main( string [] args)
{
int num = 1742346774;
LOOK_UP();
int result = Parity(num);
if (result != 0)
Console.WriteLine( "Odd Parity" );
else
Console.WriteLine( "Even Parity" );
}
}
|
PHP
<?php
function Parity( $num )
{
global $table ;
$max = 16;
while ( $max >= 8)
{
$num = $num ^ ( $num >> $max );
$max = (int) $max / 2;
}
return $table [ $num & 0xff];
}
$num = 1742346774;
$result = Parity( $num );
if ( $result == true)
echo "Odd Parity" ;
else
echo "Even Parity" ;
?>
|
Javascript
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));
}
var table = new Array(256).fill(0);
LOOK_UP(table);
function Parity(num)
{
var max = 16;
while (max >= 8)
{
num = num ^ (num >> max);
max = Math.floor(max / 2);
}
return table[num & 0xff] ;
}
var num = 1742346774;
var result = Parity(num);
console.log(result ? "Odd Parity" : "Even Parity" );
|
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
Share your thoughts in the comments
Please Login to comment...