Given a message bit in the form of an array msgBit[], the task is to find the Hamming Code of the given message bit.

Examples:

Input:_ S = “0101”_

Output:

Generated codeword:

r1 r2 m1 r4 m2 m3 m4

0 1 0  0 1  0  1

Explanation:

Initially r1, r2, r4 is set to ‘0’.

r1 = Bitwise XOR of all bits position that has ‘1’ in its 0th-bit position.

r2 = Bitwise XOR of all bits that has ‘1’ in its 1st-bit position.

r3 = Bitwise XOR of all bits that has ‘1’ in its 2nd-bit position.

Input:_ S = “0111”_

Output:

_Generated codeword: _

_r1 r2 m1 r4 m2 m3 m4 _

_0 0 0  1 1  1  1 _

Approach: The idea is to first find the number of redundant bits which can be found by initializing **r **with **1 **and then incrementing it by 1 each time while 2r is smaller than (m + r + 1) where **m **is the number of bits in the input message. Follow the below steps to solve the problem:

• Initialize **r **by **1 **and increment it by **1 **until 2r is smaller than m+r+1.
• Initialize a vector **hammingCode **of size r + m which will be the length of the output message.
• Initialize all the positions of redundant bits with -1 by traversing from i = 0 to r – 1 and setting hammingCode [2i – 1] = -1. Then place the input message bits in all the positions where hammingCode[j] is not -1 in order where 0 <= j < (r + m).
• Initialize a variable **one_count **with **0 **to store the number of ones and then traverse from i = 0 to (r + m – 1).
• If the current bit i.e., hammingCode[i] is not -1 then find the message bit containing set bit at log2(i+1)th position by traversing from j = i+2 to r+m by incrementing one_count by 1 if (j & (1<<x)) is not 0 and hammingCode[j – 1] is 1.
• If for index i, **one_count **is even, set hammingCode[i] = 0 otherwise set hammingCode[i] = 1.
• After traversing, print the **hammingCode[] **vector as the output message.

Below is the implementation of the above approach:

• C
• C++

`// C program for the above approach`

`#include <math.h>`

`#include <stdio.h>`

`// Store input bits`

`**int**` `input[32];`

`// Store hamming code`

`**int**` `code[32];`

`**int**` `ham_calc(``**int**``,` `**int**``);`

`**void**` `solve(``**int**` `input[],` `**int**``);`

`// Function to calculate bit for`

`// ith position`

`**int**` `ham_calc(``**int**` `position,` `**int**` `c_l)`

`{`

`**int**` `count = 0, i, j;`

`i = position - 1;`

`// Traverse to store Hamming Code`

`**while**` `(i < c_l) {`

`**for**` `(j = i; j < i + position; j++) {`

`// If current boit is 1`

`**if**` `(code[j] == 1)`

`count++;`

`}`

`// Update i`

`i = i + 2 * position;`

`}`

`**if**` `(count % 2 == 0)`

`**return**` `0;`

`**else**`

`**return**` `1;`

`}`

`// Function to calculate hamming code`

`**void**` `solve(``**int**` `input[],` `**int**` `n)`

`{`

`**int**` `i, p_n = 0, c_l, j, k;`

`i = 0;`

`// Find msg bits having set bit`

`// at x'th position of number`

`**while**` `(n > (``**int**``)``**pow**``(2, i) - (i + 1)) {`

`p_n++;`

`i++;`

`}`

`c_l = p_n + n;`

`j = k = 0;`

`// Traverse the msgBits`

`**for**` `(i = 0; i < c_l; i++) {`

`// Update the code`

`**if**` `(i == ((``**int**``)``**pow**``(2, k) - 1)) {`

`code[i] = 0;`

`k++;`

`}`

`// Update the code[i] to the`

`// input character at index j`

`**else**` `{`

`code[i] = input[j];`

`j++;`

`}`

`}`

`// Traverse and update the`

`// hamming code`

`**for**` `(i = 0; i < p_n; i++) {`

`// Find current position`

`**int**` `position = (``**int**``)``**pow**``(2, i);`

`// Find value at current position`

`**int**` `value = ham_calc(position, c_l);`

`// Update the code`

`code[position - 1] = value;`

`}`

`// Print the Hamming Code`

`**printf**``(``"\nThe generated Code Word is: "``);`

`**for**` `(i = 0; i < c_l; i++) {`

`**printf**``(``"%d"``, code[i]);`

`}`

`}`

`// Driver Code`

`**void**` `main()`

`{`

`// Given input message Bit`

`input[0] = 0;`

`input[1] = 1;`

`input[2] = 1;`

`input[3] = 1;`

`**int**` `N = 4;`

`// Function Call`

`solve(input, N);`

`}`

Output:

``````The generated Code Word is: 0001111
``````

Time Complexity:_ O((M + R)2) where M is the number of bits in the input message and R is the number of redundant bits _

Auxiliary Space:_ O(M + R)_

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

#bit magic #c programs #c++ programs #computer networks #strings #bit #maths-power

63.65 GEEK