Related Articles
Hamming code Implementation in C/C++
• Difficulty Level : Medium
• Last Updated : 26 Oct, 2020

Pre-requisite: Hamming Code

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 program for the above approach`` ` `#include ``#include `` ` `// Store input bits``int` `input;`` ` `// Store hamming code``int` `code;`` ` `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;``    ``input = 1;``    ``input = 1;``    ``input = 1;`` ` `    ``int` `N = 4;`` ` `    ``// Function Call``    ``solve(input, N);``}`

## C++

 `// C++ program for the above approach`` ` `#include ``using` `namespace` `std;`` ` `// Function to generate hamming code``vector<``int``> generateHammingCode(``    ``vector<``int``> msgBits, ``int` `m, ``int` `r)``{``    ``// Stores the Hamming Code``    ``vector<``int``> hammingCode(r + m);`` ` `    ``// Find positions of redundant bits``    ``for` `(``int` `i = 0; i < r; ++i) {`` ` `        ``// Placing -1 at redundant bits``        ``// place to identify it later``        ``hammingCode[``pow``(2, i) - 1] = -1;``    ``}`` ` `    ``int` `j = 0;`` ` `    ``// Iterate to update the code``    ``for` `(``int` `i = 0; i < (r + m); i++) {`` ` `        ``// Placing msgBits where -1 is``        ``// absent i.e., except redundant``        ``// bits all postions are msgBits``        ``if` `(hammingCode[i] != -1) {``            ``hammingCode[i] = msgBits[j];``            ``j++;``        ``}``    ``}`` ` `    ``for` `(``int` `i = 0; i < (r + m); i++) {`` ` `        ``// If current bit is not redundant``        ``// bit then continue``        ``if` `(hammingCode[i] != -1)``            ``continue``;`` ` `        ``int` `x = log2(i + 1);``        ``int` `one_count = 0;`` ` `        ``// Find msg bits containing``        ``// set bit at x'th position``        ``for` `(``int` `j = i + 2;``             ``j <= (r + m); ++j) {`` ` `            ``if` `(j & (1 << x)) {``                ``if` `(hammingCode[j - 1] == 1) {``                    ``one_count++;``                ``}``            ``}``        ``}`` ` `        ``// Generating hamming code for``        ``// even parity``        ``if` `(one_count % 2 == 0) {``            ``hammingCode[i] = 0;``        ``}``        ``else` `{``            ``hammingCode[i] = 1;``        ``}``    ``}`` ` `    ``// Return the generated code``    ``return` `hammingCode;``}`` ` `// Function to find the hamming code``// of the given message bit msgBit[]``void` `findHammingCode(vector<``int``>& msgBit)``{`` ` `    ``// Message bit size``    ``int` `m = msgBit.size();`` ` `    ``// r is the number of redundant bits``    ``int` `r = 1;`` ` `    ``// Find no. of redundant bits``    ``while` `(``pow``(2, r) < (m + r + 1)) {``        ``r++;``    ``}`` ` `    ``// Generating Code``    ``vector<``int``> ans``        ``= generateHammingCode(msgBit, m, r);`` ` `    ``// Print the code``    ``cout << ``"Message bits are: "``;``    ``for` `(``int` `i = 0; i < msgBit.size(); i++)``        ``cout << msgBit[i] << ``" "``;`` ` `    ``cout << ``"\nHamming code is: "``;``    ``for` `(``int` `i = 0; i < ans.size(); i++)``        ``cout << ans[i] << ``" "``;``}`` ` `// Driver Code``int` `main()``{``    ``// Given message bits``    ``vector<``int``> msgBit = { 0, 1, 0, 1 };`` ` `    ``// Function Call``    ``findHammingCode(msgBit);`` ` `    ``return` `0;``}`
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)

Want to learn from the best curated videos and practice problems, check out the C++ Foundation Course for Basic to Advanced C++ and C++ STL Course for the language and STL.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
My Personal Notes arrow_drop_up