Skip to content

Primitive root of a prime number n modulo n

Cyclic Redundancy Check and Modulo-2 Division

Last Updated : 27 Apr, 2025

Cyclic Redundancy Check or CRC is a method of detecting accidental changes/errors in the communication channel. CRC uses Generator Polynomial which is available on both sender and receiver side.
An example generator polynomial is of the form like x³ + x + 1. This generator polynomial represents key 1011. Another example is x² + 1 that represents key 101.
There are two primary variables in CRC:

n: Number of bits in data to be sent from sender side
k: Number of bits in the key obtained from generator polynomial.

Encoded Data Generation from Generator Polynomial (Sender Side)

The binary data is first augmented by adding k-1 zeros in the end of the data.
Then, modulo – 2 binary division is used to divide binary data by the key and remainder of division is stored.
At last the the remainder is appended at the end of the data to form the encoded data which is later sent.

Checking Error in Transmission (Receiver Side)

After receiving the data, to check if the data is error free, perform the modulo-2 division again.
If the remainder is 0, then there are not errors, otherwise, the data is faulty and contain transmission errors.

Modulo 2 Division

The process of modulo-2 binary division is the same as the familiar division process we use for decimal numbers. Just that instead of subtraction, we use XOR here.

In each step, a copy of the divisor (or data) is XORed with the k bits of the dividend (or key).
The result of the XOR operation (remainder) is (n-1) bits, which is used for the next step after 1 extra bit is pulled down to make it n bits long.
When there are no bits left to pull down, we have a result. The (n-1)-bit remainder which is appended at the sender side.

Examples:

Case 1: No error in transmission

Data = 100100, Generator Polynomial (Key) = x³ + x² + 1 (1101)

Sender Side

The remainder is 001. Thus the data sent is 100100001.

Receiver Side
Code word received at the receiver side 100100001

The remainder is 0, hence the data received has no errors.

CRC Implementation – O(n) Time and O(n) Space

Case 2: Error in Transmission

Data = 100100, Generator Polynomial (Key) = x³ + x² + 1 (1101)

Sender Side

The remainder is 001. Thus the data sent is 100100001.

Receiver Side
Let there be an error and code word received at the receiver side 100000001.

As the remainder is not 0, hence there is some error detected in the receiver side.

Implementation of Cyclic Redundancy Check

The idea is to firstly generate the encoded data by appending the remainder of modulo – 2 division of data and key in the given data. Then, repeat the same process for the data received, and if the decoded data contains any ‘1’, then there is some error in transmission, otherwise the correct data is received.

Follow the below given step-by-step process:

Start by appending n-1 zeroes to data to form a new string str, where n is the length of key.
Compute the remainder by calling mod2div with dividend set to str and divisor set to key. In mod2div, first slice dividend to the length of divisor, then repeatedly perform the following:
- If the first character of the current slice (tmp) is ‘1’, call findXor with divisor and tmp; otherwise, call findXor with a string of pick zeroes and tmp.
- Append the next bit of dividend to the result and increment pick.
The function findXor calculates the XOR of two strings a and b by traversing from index 1 to the end: if corresponding bits are the same, it appends “0” to result, otherwise “1”.
After processing the entire dividend, mod2div returns the final remainder. Append this remainder to data to form the encoded codeword.
At the receiver side, extract the first n bits of code and perform mod2div with key to obtain curXor. Then, while cur is not equal to code.size, if curXor’s length is not equal to key’s length, append the next bit from code; otherwise, update curXor by performing mod2div on it.
Finally, if curXor’s length equals key’s length, perform a final mod2div. If curXor contains any ‘1’, the data is incorrect; otherwise, the data is correct.

Below is given the implementation:

C++

#include <bits/stdc++.h> using namespace std;  // Returns XOR of 'a' and 'b' string findXor(string a, string b) {     int n = b.length();      // Initialize result     string result = "";      // Traverse all bits, if bits are     // same, then XOR is 0, else 1     for (int i = 1; i < n; i++) {         if (a[i] == b[i])             result += "0";         else             result += "1";     }     return result; }  // Performs Modulo-2 division string mod2div(string dividend, string divisor) {     int n = dividend.length();      // Number of bits to be XORed at a time.     int pick = divisor.length();      // Slicing the dividend to appropriate     // length for particular step     string tmp = dividend.substr(0, pick);      while (pick < n) {         if (tmp[0] == '1')              // Replace the dividend by the result             // of XOR and pull 1 bit down             tmp = findXor(divisor, tmp) + dividend[pick];         else              // If leftmost bit is '0', the step cannot             // use the regular divisor; we need to use an             // all-0s divisor.             tmp = findXor(std::string(pick, '0'), tmp)                   + dividend[pick];          // Increment pick to move further         pick += 1;     }      // For the last n bits, we have to carry it out     // normally as increased value of pick will cause     // Index Out of Bounds.     if (tmp[0] == '1')         tmp = findXor(divisor, tmp);     else         tmp = findXor(std::string(pick, '0'), tmp);      return tmp; }  // Function used at the sender side to encode data string encodeData(string data, string key) {     int n = key.length();      // Appends n-1 zeroes at end of data     string str= data + std::string(n - 1, '0');      // find remainder of mod 2 division     string remainder = mod2div(str, key);      // Append remainder in the original data     string codeword = data + remainder;     return codeword; }  // checking if the message received by receiver  // is correct i.e. the remainder is 0 or not int receiver(string code, string key) {     int n = key.length();      // Perform Modulo-2 division and get the remainder     string curXor = mod2div(code.substr(0, n), key);     int cur = n;      // if code and key are of different length     while (cur != code.size()) {         if (curXor.size() != key.size()) {             curXor.push_back(code[cur++]);         }         else {             curXor = mod2div(curXor, key);         }     }      if (curXor.size() == key.size()) {         curXor = mod2div(curXor, key);     }      // Check if the remainder contains any '1'     if (curXor.find('1') != string::npos) {          // Data is incorrect         return 0;      }     else {          // Data is correct         return 1;      } }  int main() {     string data = "100100";     string key = "1101";     cout << "Sender Side" << endl;     cout << "Data : " << data << endl;     cout << "Key : " << key << endl;     cout << "Encoded Data : ";     string code = encodeData(data, key);     cout << code << endl << endl;      cout << "Receiver Side" << endl;     if(receiver(code, key))         cout << "Data is correct";     else         cout << "Data is incorrect";      return 0; }

Java

import java.util.*;  public class GfG {      // Returns XOR of 'a' and 'b'     static String findXor(String a, String b) {         int n = b.length();          // Initialize result         String result = "";          // Traverse all bits, if bits are         // same, then XOR is 0, else 1         for (int i = 1; i < n; i++) {             if (a.charAt(i) == b.charAt(i))                 result += "0";             else                 result += "1";         }         return result;     }      // Performs Modulo-2 division     static String mod2div(String dividend, String divisor) {         int n = dividend.length();          // Number of bits to be XORed at a time.         int pick = divisor.length();          // Slicing the dividend to appropriate         // length for particular step         String tmp = dividend.substring(0, pick);          while (pick < n) {             if (tmp.charAt(0) == '1')                  // Replace the dividend by the result                 // of XOR and pull 1 bit down                 tmp = findXor(divisor, tmp) + dividend.charAt(pick);             else                  // If leftmost bit is '0', the step cannot                 // use the regular divisor; we need to use an                 // all-0s divisor.                 tmp = findXor("0".repeat(pick), tmp) + dividend.charAt(pick);              // Increment pick to move further             pick += 1;         }          // For the last n bits, we have to carry it out         // normally as increased value of pick will cause         // Index Out of Bounds.         if (tmp.charAt(0) == '1')             tmp = findXor(divisor, tmp);         else             tmp = findXor("0".repeat(pick), tmp);          return tmp;     }      // Function used at the sender side to encode data     static String encodeData(String data, String key) {         int n = key.length();          // Appends n-1 zeroes at end of data         String str = data + "0".repeat(n - 1);          // find remainder of mod 2 division         String remainder = mod2div(str, key);          // Append remainder in the original data         String codeword = data + remainder;         return codeword;     }      // checking if the message received by receiver      // is correct i.e. the remainder is 0 or not     static int receiver(String code, String key) {         int n = key.length();          // Perform Modulo-2 division and get the remainder         String curXor = mod2div(code.substring(0, n), key);         int cur = n;          // if code and key are of different length         while (cur != code.length()) {             if (curXor.length() != key.length()) {                 curXor = curXor + code.charAt(cur);                 cur++;             }             else {                 curXor = mod2div(curXor, key);             }         }          if (curXor.length() == key.length()) {             curXor = mod2div(curXor, key);         }          // Check if the remainder contains any '1'         if (curXor.indexOf('1') != -1) {              // Data is incorrect             return 0;          }         else {              // Data is correct             return 1;          }     }      public static void main(String[] args) {         String data = "100100";         String key = "1101";         System.out.println("Sender Side");         System.out.println("Data : " + data);         System.out.println("Key : " + key);         System.out.print("Encoded Data : ");         String code = encodeData(data, key);         System.out.println(code + "\n");         System.out.println("Receiver Side");         if(receiver(code, key) == 1)             System.out.println("Data is correct");         else             System.out.println("Data is incorrect");     } }

Python

# Returns XOR of 'a' and 'b' def findXor(a, b):     n = len(b)      # Initialize result     result = ""      # Traverse all bits, if bits are     # same, then XOR is 0, else 1     for i in range(1, n):         if a[i] == b[i]:             result += "0"         else:             result += "1"     return result  # Performs Modulo-2 division def mod2div(dividend, divisor):     n = len(dividend)      # Number of bits to be XORed at a time.     pick = len(divisor)      # Slicing the dividend to appropriate     # length for particular step     tmp = dividend[:pick]      while pick < n:         if tmp[0] == '1':              # Replace the dividend by the result             # of XOR and pull 1 bit down             tmp = findXor(divisor, tmp) + dividend[pick]         else:              # If leftmost bit is '0', the step cannot             # use the regular divisor; we need to use an             # all-0s divisor.             tmp = findXor("0" * pick, tmp) + dividend[pick]          # Increment pick to move further         pick += 1      # For the last n bits, we have to carry it out     # normally as increased value of pick will cause     # Index Out of Bounds.     if tmp[0] == '1':         tmp = findXor(divisor, tmp)     else:         tmp = findXor("0" * pick, tmp)      return tmp  # Function used at the sender side to encode data def encodeData(data, key):     n = len(key)      # Appends n-1 zeroes at end of data     str_val = data + "0" * (n - 1)      # find remainder of mod 2 division     remainder = mod2div(str_val, key)      # Append remainder in the original data     codeword = data + remainder     return codeword  # checking if the message received by receiver  # is correct i.e. the remainder is 0 or not def receiver(code, key):     n = len(key)      # Perform Modulo-2 division and get the remainder     curXor = mod2div(code[:n], key)     cur = n      # if code and key are of different length     while cur != len(code):         if len(curXor) != len(key):             curXor += code[cur]             cur += 1         else:             curXor = mod2div(curXor, key)      if len(curXor) == len(key):         curXor = mod2div(curXor, key)      # Check if the remainder contains any '1'     if '1' in curXor:          # Data is incorrect         return 0      else:          # Data is correct         return 1   if __name__ == "__main__":     data = "100100"     key = "1101"     print("Sender Side")     print("Data : " + data)     print("Key : " + key)     print("Encoded Data : ", end="")     code = encodeData(data, key)     print(code + "\n")     print("Receiver Side")     if receiver(code, key):         print("Data is correct")     else:         print("Data is incorrect")

C#

using System; using System.Collections.Generic;  public class GfG {      // Returns XOR of 'a' and 'b'     public static string findXor(string a, string b) {         int n = b.Length;          // Initialize result         string result = "";          // Traverse all bits, if bits are         // same, then XOR is 0, else 1         for (int i = 1; i < n; i++) {             if (a[i] == b[i])                 result += "0";             else                 result += "1";         }         return result;     }      // Performs Modulo-2 division     public static string mod2div(string dividend, string divisor) {         int n = dividend.Length;          // Number of bits to be XORed at a time.         int pick = divisor.Length;          // Slicing the dividend to appropriate         // length for particular step         string tmp = dividend.Substring(0, pick);          while (pick < n) {             if (tmp[0] == '1')                  // Replace the dividend by the result                 // of XOR and pull 1 bit down                 tmp = findXor(divisor, tmp) + dividend[pick];             else                  // If leftmost bit is '0', the step cannot                 // use the regular divisor; we need to use an                 // all-0s divisor.                 tmp = findXor(new string('0', pick), tmp) + dividend[pick];              // Increment pick to move further             pick += 1;         }          // For the last n bits, we have to carry it out         // normally as increased value of pick will cause         // Index Out of Bounds.         if (tmp[0] == '1')             tmp = findXor(divisor, tmp);         else             tmp = findXor(new string('0', pick), tmp);          return tmp;     }      // Function used at the sender side to encode data     public static string encodeData(string data, string key) {         int n = key.Length;          // Appends n-1 zeroes at end of data         string str = data + new string('0', n - 1);          // find remainder of mod 2 division         string remainder = mod2div(str, key);          // Append remainder in the original data         string codeword = data + remainder;         return codeword;     }      // checking if the message received by receiver      // is correct i.e. the remainder is 0 or not     public static int receiver(string code, string key) {         int n = key.Length;          // Perform Modulo-2 division and get the remainder         string curXor = mod2div(code.Substring(0, n), key);         int cur = n;          // if code and key are of different length         while (cur != code.Length) {             if (curXor.Length != key.Length) {                 curXor += code[cur];                 cur++;             }             else {                 curXor = mod2div(curXor, key);             }         }          if (curXor.Length == key.Length) {             curXor = mod2div(curXor, key);         }          // Check if the remainder contains any '1'         if (curXor.IndexOf('1') != -1) {              // Data is incorrect             return 0;          }         else {              // Data is correct             return 1;          }     }      public static void Main(string[] args) {         string data = "100100";         string key = "1101";         Console.WriteLine("Sender Side");         Console.WriteLine("Data : " + data);         Console.WriteLine("Key : " + key);         Console.Write("Encoded Data : ");         string code = encodeData(data, key);         Console.WriteLine(code + "\n");         Console.WriteLine("Receiver Side");         if (receiver(code, key) == 1)             Console.WriteLine("Data is correct");         else             Console.WriteLine("Data is incorrect");     } }

JavaScript

// Returns XOR of 'a' and 'b' function findXor(a, b) {     let n = b.length;      // Initialize result     let result = "";      // Traverse all bits, if bits are     // same, then XOR is 0, else 1     for (let i = 1; i < n; i++) {         if (a.charAt(i) === b.charAt(i))             result += "0";         else             result += "1";     }     return result; }  // Performs Modulo-2 division function mod2div(dividend, divisor) {     let n = dividend.length;      // Number of bits to be XORed at a time.     let pick = divisor.length;      // Slicing the dividend to appropriate     // length for particular step     let tmp = dividend.substr(0, pick);      while (pick < n) {         if (tmp.charAt(0) === '1')              // Replace the dividend by the result             // of XOR and pull 1 bit down             tmp = findXor(divisor, tmp) + dividend.charAt(pick);         else              // If leftmost bit is '0', the step cannot             // use the regular divisor; we need to use an             // all-0s divisor.             tmp = findXor("0".repeat(pick), tmp) + dividend.charAt(pick);          // Increment pick to move further         pick += 1;     }      // For the last n bits, we have to carry it out     // normally as increased value of pick will cause     // Index Out of Bounds.     if (tmp.charAt(0) === '1')         tmp = findXor(divisor, tmp);     else         tmp = findXor("0".repeat(pick), tmp);      return tmp; }  // Function used at the sender side to encode data function encodeData(data, key) {     let n = key.length;      // Appends n-1 zeroes at end of data     let str = data + "0".repeat(n - 1);      // find remainder of mod 2 division     let remainder = mod2div(str, key);      // Append remainder in the original data     let codeword = data + remainder;     return codeword; }  // checking if the message received by receiver  // is correct i.e. the remainder is 0 or not function receiver(code, key) {     let n = key.length;      // Perform Modulo-2 division and get the remainder     let curXor = mod2div(code.substr(0, n), key);     let cur = n;      // if code and key are of different length     while (cur !== code.length) {         if (curXor.length !== key.length) {             curXor = curXor + code.charAt(cur);             cur++;         }         else {             curXor = mod2div(curXor, key);         }     }      if (curXor.length === key.length) {         curXor = mod2div(curXor, key);     }      // Check if the remainder contains any '1'     if (curXor.indexOf('1') !== -1) {          // Data is incorrect         return 0;      }     else {          // Data is correct         return 1;      } }  function main() {     let data = "100100";     let key = "1101";     console.log("Sender Side");     console.log("Data : " + data);     console.log("Key : " + key);     let code = encodeData(data, key);     console.log("Encoded Data : " + code);     console.log();     console.log("Receiver Side");     if (receiver(code, key))         console.log("Data is correct");     else         console.log("Data is incorrect"); }  main();

Output

Sender Side Data : 100100 Key : 1101 Encoded Data : 100100001  Receiver Side Data is correct

CRC Implementation Using Bit Manipulation – O(n) Time and O(n) Space

The idea is to manipulate the given binary strings by converting them to decimal numbers, and process them. After processing the numbers, convert them back to binary strings.

Follow the below given step-by-step approach:

Determine n as key.length() and convert key to decimal using toDec(key) to get gen, and convert data to decimal using toDec(data) to get code.
Append n-1 zeroes to data by left-shifting code by (n – 1) and store the result in dividend.
Compute shft as ceill(log2l(dividend + 1)) – n, which represents the number of least significant bits not involved in the XOR operation.
While (dividend >= gen) or (shft >= 0):
- Calculate rem as (dividend >> shft) XOR gen.
- Update dividend by combining the unchanged lower shft bits (dividend & ((1 << shft) – 1)) with the new bits (rem << shft) resulting from the XOR operation.
- Recalculate shft as ceill(log2l(dividend + 1)) – n.
After the loop, compute codeword as the bitwise OR of (code << (n – 1)) and dividend.
Finally, output the remainder (obtained by converting dividend to binary using toBin(dividend)) and the codeword (obtained by converting codeword to binary using toBin(codeword)).

Below is given the implementation:

C++

// C++ Program to generate CRC codeword #include <bits/stdc++.h> using namespace std; #define int long long int  // function to convert integer to binary string string toBin(int num) {     string bin = "";     while (num) {         if (num & 1)             bin += "1";         else             bin += "0";         num = num >> 1;     }     reverse(bin.begin(), bin.end());      // if the binary string is empty, return "0"     if(bin == "")         bin = "0";     return bin; }  // function to convert binary string to decimal int toDec(string bin) {     int n = bin.size();      // if the binary string is empty, return 0     if (n == 0)         return 0;     int num = 0;     for (int i = 0; i < n; i++) {         if (bin[i] == '1')             num += 1 << (n - i - 1);     }     return num; }  // function to compute CRC and codeword void CRC(string data, string key) {     int n = key.length();      // convert key and data to decimal     int gen = toDec(key);     int code = toDec(data);      // append 0s to dividend     int dividend = code << (n - 1);      // shft specifies the no. of least     // significant bits not being XORed     int shft = (int)ceill(log2l(dividend + 1)) - n;     int rem;      while ((dividend >= gen) || (shft >= 0)) {          // Perform bitwise XOR on the most significant bits          // of the dividend with the key and replace the          // bits in the dividend with the generated remainder         rem = (dividend >> shft) ^ gen;         dividend = (dividend & ((1 << shft) - 1)) | (rem << shft);          // change shft variable         shft = ceill(log2l(dividend + 1)) - n;     }      // find OR of initial dividend with the remainder     int codeword = (code << (n - 1)) | dividend;     cout << "Remainder: " << toBin(dividend) << endl;     cout << "Codeword : " << toBin(codeword); }  signed main() {     string data, key;     data = "100100";     key = "1101";     CRC(data, key);     return 0; }

Java

import java.util.*;  public class GfG {      // function to convert integer to binary string     static String toBin(long num) {         String bin = "";         while (num != 0) {             if ((num & 1) == 1)                 bin += "1";             else                 bin += "0";             num = num >> 1;         }         StringBuilder sb = new StringBuilder(bin);         bin = sb.reverse().toString();          // if the binary string is empty, return "0"         if (bin.equals(""))             bin = "0";         return bin;     }      // function to convert binary string to decimal     static long toDec(String bin) {         int n = bin.length();          // if the binary string is empty, return 0         if (n == 0)             return 0;         long num = 0;         for (int i = 0; i < n; i++) {             if (bin.charAt(i) == '1')                 num += 1L << (n - i - 1);         }         return num;     }      // function to compute CRC and codeword     static void CRC(String data, String key) {         int n = key.length();          // convert key and data to decimal         long gen = toDec(key);         long code = toDec(data);          // append 0s to dividend         long dividend = code << (n - 1);          // shft specifies the no. of least         // significant bits not being XORed         int shft = (int)          Math.ceil(Math.log(dividend + 1) / Math.log(2)) - n;         long rem;          while ((dividend >= gen) || (shft >= 0)) {              // Perform bitwise XOR on the most significant bits              // of the dividend with the key and replace the              // bits in the dividend with the generated remainder             rem = (dividend >> shft) ^ gen;             dividend = (dividend & ((1L << shft) - 1)) | (rem << shft);              // change shft variable             shft = (int)              Math.ceil(Math.log(dividend + 1) / Math.log(2)) - n;         }          // find OR of initial dividend with the remainder         long codeword = (code << (n - 1)) | dividend;         System.out.println("Remainder: " + toBin(dividend));         System.out.println("Codeword : " + toBin(codeword));     }      public static void main(String[] args) {         String data = "100100";         String key = "1101";         CRC(data, key);     } }

Python

import math  # function to convert integer to binary string def toBin(num):     bin = ""     while num:         if num & 1:             bin += "1"         else:             bin += "0"         num = num >> 1     bin = bin[::-1]      # if the binary string is empty, return "0"     if bin == "":         bin = "0"     return bin  # function to convert binary string to decimal def toDec(bin):     n = len(bin)      # if the binary string is empty, return 0     if n == 0:         return 0     num = 0     for i in range(n):         if bin[i] == '1':             num += 1 << (n - i - 1)     return num  # function to compute CRC and codeword def CRC(data, key):     n = len(key)      # convert key and data to decimal     gen = toDec(key)     code = toDec(data)      # append 0s to dividend     dividend = code << (n - 1)      # shft specifies the no. of least     # significant bits not being XORed     shft = math.ceil(math.log(dividend + 1, 2)) - n     rem = 0      while (dividend >= gen) or (shft >= 0):          # Perform bitwise XOR on the most significant bits          # of the dividend with the key and replace the          # bits in the dividend with the generated remainder         rem = (dividend >> shft) ^ gen         dividend = (dividend & ((1 << shft) - 1)) | (rem << shft)          # change shft variable         shft = math.ceil(math.log(dividend + 1, 2)) - n      # find OR of initial dividend with the remainder     codeword = (code << (n - 1)) | dividend     print("Remainder: " + toBin(dividend))     print("Codeword : " + toBin(codeword))  if __name__ == "__main__":     data = "100100"     key = "1101"     CRC(data, key)

C#

using System;  public class GfG {      // function to convert integer to binary string     public static string toBin(long num) {         string bin = "";         while (num != 0) {             if ((num & 1) == 1)                 bin += "1";             else                 bin += "0";             num = num >> 1;         }         char[] arr = bin.ToCharArray();         Array.Reverse(arr);         bin = new string(arr);          // if the binary string is empty, return "0"         if (bin == "")             bin = "0";         return bin;     }      // function to convert binary string to decimal     public static long toDec(string bin) {         int n = bin.Length;          // if the binary string is empty, return 0         if (n == 0)             return 0;         long num = 0;         for (int i = 0; i < n; i++) {             if (bin[i] == '1')                 num += 1L << (n - i - 1);         }         return num;     }      // function to compute CRC and codeword     public static void CRC(string data, string key) {         int n = key.Length;          // convert key and data to decimal         long gen = toDec(key);         long code = toDec(data);          // append 0s to dividend         long dividend = code << (n - 1);          // shft specifies the no. of least         // significant bits not being XORed         int shft = (int)Math.Ceiling(Math.Log(dividend + 1, 2)) - n;         long rem;          while ((dividend >= gen) || (shft >= 0)) {              // Perform bitwise XOR on the most significant bits              // of the dividend with the key and replace the              // bits in the dividend with the generated remainder             rem = (dividend >> shft) ^ gen;             dividend = (dividend & ((1L << shft) - 1)) | (rem << shft);              // change shft variable             shft = (int)Math.Ceiling(Math.Log(dividend + 1, 2)) - n;         }          // find OR of initial dividend with the remainder         long codeword = (code << (n - 1)) | dividend;         Console.WriteLine("Remainder: " + toBin(dividend));         Console.WriteLine("Codeword : " + toBin(codeword));     }      public static void Main(string[] args) {         string data = "100100";         string key = "1101";         CRC(data, key);     } }

JavaScript

// C++ Program to generate CRC codeword // Translated to JavaScript function toBin(num) {     let bin = "";     while (num) {         if (num & 1)             bin += "1";         else             bin += "0";         num = num >> 1;     }     bin = bin.split("").reverse().join("");      // if the binary string is empty, return "0"     if (bin === "")         bin = "0";     return bin; }  function toDec(bin) {     let n = bin.length;      // if the binary string is empty, return 0     if (n === 0)         return 0;     let num = 0;     for (let i = 0; i < n; i++) {         if (bin.charAt(i) === '1')             num += 1 << (n - i - 1);     }     return num; }  function CRC(data, key) {     let n = key.length;      // convert key and data to decimal     let gen = toDec(key);     let code = toDec(data);      // append 0s to dividend     let dividend = code << (n - 1);      // shft specifies the no. of least     // significant bits not being XORed     let shft = Math.ceil(Math.log2(dividend + 1)) - n;     let rem;      while ((dividend >= gen) || (shft >= 0)) {          // Perform bitwise XOR on the most significant bits          // of the dividend with the key and replace the          // bits in the dividend with the generated remainder         rem = (dividend >> shft) ^ gen;         dividend = (dividend & ((1 << shft) - 1)) | (rem << shft);          // change shft variable         shft = Math.ceil(Math.log2(dividend + 1)) - n;     }      // find OR of initial dividend with the remainder     let codeword = (code << (n - 1)) | dividend;     console.log("Remainder: " + toBin(dividend));     console.log("Codeword : " + toBin(codeword)); }  function main() {     let data, key;     data = "100100";     key = "1101";     CRC(data, key); }  main();

Output

Remainder: 1 Codeword : 100100001

Primitive root of a prime number n modulo n

J

Jay Patel

Improve

Article Tags :

Practice Tags :

Similar Reads

Number Theory for DSA & Competitive Programming

What is Number Theory?Number theory is a branch of pure mathematics that deals with the properties and relationships of numbers, particularly integers. It explores the fundamental nature of numbers and their mathematical structures. Number theory has been studied for centuries and has deep connectio

Number Theory (Interesting Facts and Algorithms)

Questions based on various concepts of number theory and different types of number are quite frequently asked in programming contests. In this article, we discuss some famous facts and algorithms:Interesting Facts of Number Theory :1. All 4 digit palindromic numbers are divisible by 11.2. If we repe

How to prepare for ACM - ICPC?

ACM ICPC(Association for Computing Machinery - International Collegiate Programming Contest) is a worldwide annual multi-tiered programming contest being organized for over thirteen years. The contest is sponsored by IBM. This article focuses on what all topics that are important for competitive pro