code.txt

//1 Dimensional parity check for both even and odd parity
#include<iostream>
using namespace std;
int main(){
    int length[60], size, choice, sum=0;
    cout<<"Enter the length of the bits: ";
    cin>>size;
    cout<<"Enter the bits: ";
    for (int i = 0; i < size; i++)
    {
        cin>>length[i];
    }
    cout<<"Your bits are: ";
    for (int i = 0; i < size; i++)
    {
        cout<<length[i];
    }
    for (int i = 0; i < size; i++)
    {
        sum += length[i];
    }
    cout<<"\nCheck for even(0) bits or odd(1) bits parity?";
    cin>>choice;
    switch (choice)
    {
    case 0:
        cout<<"Even Parity";
        if (sum%2==0)
            length[size]=0;
        else if (sum%2!=0)
            length[size]=1;
        break;
    
    case 1:
        cout<<"Odd Parity";
        if (sum%2==0)
            length[size]=1;
        else if (sum%2!=0)
            length[size]=0;
        break;    

    default:
        cout<<"Choose a valid option!";
        exit(0);
        break;
    }    
    cout<<"\nYour bits with parity are: ";
    for (int i = 0; i <= size; i++)
    {
        cout<<length[i];
    }
}
-----------------------------------------------------------------------
// C++ program for Hamming Code Implementation

#include <bits/stdc++.h>
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 positions 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;
}
-----------------------------------------------------------------------
// C++ program for the above approach
#include <bits/stdc++.h>
#include <iostream>
using namespace std;

// Function for bit stuffing
void bitStuffing(int N, int arr[])
{
	
	// Stores the stuffed array
	int brr[30];

	// Variables to traverse arrays
	int i, j, k;
	i = 0;
	j = 0;

	// Stores the count of consecutive ones
	int count = 1;

	// Loop to traverse in the range [0, N)
	while (i < N)
	{
		
		// If the current bit is a set bit
		if (arr[i] == 1)
		{
			
			// Insert into array brr[]
			brr[j] = arr[i];

			// Loop to check for
			// next 5 bits
			for(k = i + 1; arr[k] == 1 && k < N && count < 5;
				k++)
			{
				j++;
				brr[j] = arr[k];
				count++;

				// If 5 consecutive set bits
				// are found insert a 0 bit
				if (count == 5)
				{
					j++;
					brr[j] = 0;
				}
				i = k;
			}
		}

		// Otherwise insert arr[i] into
		// the array brr[]
		else
		{
			brr[j] = arr[i];
		}
		i++;
		j++;
	}

	// Print Answer
	for(i = 0; i < j; i++)
		cout << brr[i];
}

// Driver code
int main()
{
	int N = 6;
	int arr[] = { 1, 1, 1, 1, 1, 1 };

	bitStuffing(N, arr);;
	return 0;
}

// This code is contributed by target_2