# Hamming code Implementation in C/C++

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)

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.