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

• Difficulty Level : Hard
• 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```
Recommended Practice

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 `   `// 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 table = ``new` `ArrayList();` `    ``// 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

 `= 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)