 Open in App
Not now

# Implementation of Bit Stuffing and Bit Destuffing

• Difficulty Level : Easy
• Last Updated : 11 Jan, 2023

Bit Stuffing is a process of inserting an extra bit as 0, once the frame sequence encountered 5 consecutive 1’s. Given an array, arr[] of size N consisting of 0’s and 1’s, the task is to return an array after the bit stuffing.

Examples:

Input: N = 6, arr[] = {1, 1, 1, 1, 1, 1}
Output: 1111101
Explanation: During the traversal of the array, 5 consecutive 1’s are encountered after the 4th index of the given array. Hence, a zero bit has been inserted into the stuffed array after the 4th index

Input: N = 6, arr[] = {1, 0, 1, 0, 1, 0}
Output: 101010

Approach: The idea is to check if the given array consists of 5 consecutive 1’s. Follow the steps below to solve the problem:

• Initialize the array brr[] which stores the stuffed array. Also, create a variable count which maintains the count of the consecutive 1’s.
• Traverse in a while loop using a variable i in the range [0, N) and perform the following tasks:
• If arr[i] is 1 then check for the next 4 bits if they are set bits as well. If they are, then insert a 0 bit after inserting all the 5 set bits into the array brr[].
• Otherwise, insert the value of arr[i] into the array brr[].

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``#include ``using` `namespace` `std;` `// Function for bit stuffing``void` `bitStuffing(``int` `N, ``int` `arr[])``{` `    ``// Stores the stuffed array``    ``int` `brr;` `    ``// Variables to traverse arrays``    ``int` `i, j, k;``    ``i = 0;``    ``j = 0;` `    ``// Loop to traverse in the range [0, N)``    ``while` `(i < N) {` `        ``// If the current bit is a set bit``        ``if` `(arr[i] == 1) {``            ``// Stores the count of consecutive ones``            ``int` `count = 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`

## C

 `// C program for the above approach``#include ``#include ` `// Function for bit stuffing``void` `bitStuffing(``int` `N, ``int` `arr[])``{``    ``// Stores the stuffed array``    ``int` `brr;` `    ``// Variables to traverse arrays``    ``int` `i, j, k;``    ``i = 0;``    ``j = 0;` `    ``// Loop to traverse in the range [0, N)``    ``while` `(i < N) {` `        ``// If the current bit is a set bit``        ``if` `(arr[i] == 1) {``          ` `            ``// Stores the count of consecutive ones``            ``int` `count = 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++)``        ``printf``(``"%d"``, brr[i]);``}` `// Driver Code``int` `main()``{``    ``int` `N = 6;``    ``int` `arr[] = { 1, 1, 1, 1, 1, 1 };` `    ``bitStuffing(N, arr);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``class` `GFG {` `    ``// Function for bit stuffing``    ``static` `void` `bitStuffing(``int` `N, ``int` `arr[])``    ``{` `        ``// Stores the stuffed array``        ``int``[] brr = ``new` `int``[``30``];` `        ``// Variables to traverse arrays``        ``int` `i, j, k;``        ``i = ``0``;``        ``j = ``0``;` `   `  `        ``// Loop to traverse in the range [0, N)``        ``while` `(i < N) {` `            ``// If the current bit is a set bit``            ``if` `(arr[i] == ``1``) {``                ``// Stores the count of consecutive ones``                ``int` `count = ``1``;` `                ``// Insert into array brr[]``                ``brr[j] = arr[i];` `                ``// Loop to check for``                ``// next 5 bits``                ``for` `(k = i + ``1``; k < N && arr[k] == ``1` `                                ``&& 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++)``            ``System.out.printf(``"%d"``, brr[i]);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `N = ``6``;``        ``int` `arr[] = { ``1``, ``1``, ``1``, ``1``, ``1``, ``1` `};` `        ``bitStuffing(N, arr);``    ``}``}` `// This code is contributed by shikhasingrajput`

## Python3

 `# Python3 program for the above approach` `# Function for bit stuffing`  `def` `bitStuffing(N, arr):` `    ``# Stores the stuffed array``    ``brr ``=` `[``0` `for` `_ ``in` `range``(``30``)]` `    ``# Variables to traverse arrays``    ``k ``=` `0``    ``i ``=` `0``    ``j ``=` `0` `    ``# Loop to traverse in the range [0, N)``    ``while` `(i < N):` `        ``# If the current bit is a set bit``        ``if` `(arr[i] ``=``=` `1``):` `            ``count ``=` `1` `            ``# Insert into array brr[]``            ``brr[j] ``=` `arr[i]` `            ``# Loop to check for``            ``# next 5 bits``            ``k ``=` `i ``+` `1``            ``while` `True``:``                ``if` `not` `(k < N ``and` `arr[k] ``=``=` `1` `and``                        ``count < ``5``):``                    ``break` `                ``j ``+``=` `1``                ``brr[j] ``=` `arr[k]``                ``count ``+``=` `1` `                ``# If 5 consecutive set bits``                ``# are found insert a 0 bit``                ``if` `(count ``=``=` `5``):``                    ``j ``+``=` `1``                    ``brr[j] ``=` `0` `                ``i ``=` `k``                ``k ``+``=` `1` `        ``# Otherwise insert arr[i] into``        ``# the array brr[]``        ``else``:``            ``brr[j] ``=` `arr[i]` `        ``i ``+``=` `1``        ``j ``+``=` `1` `    ``# Print Answer``    ``for` `i ``in` `range``(``0``, j):``        ``print``(brr[i], end``=``"")`  `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``N ``=` `6``    ``arr ``=` `[``1``, ``1``, ``1``, ``1``, ``1``, ``1``]` `    ``bitStuffing(N, arr)` `# This code is contributed by rakeshsahni`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG {` `    ``// Function for bit stuffing``    ``static` `void` `bitStuffing(``int` `N, ``int``[] arr)``    ``{` `        ``// Stores the stuffed array``        ``int``[] brr = ``new` `int``;` `        ``// Variables to traverse arrays``        ``int` `i, j, k;``        ``i = 0;``        ``j = 0;` `        ``// Loop to traverse in the range [0, N)``        ``while` `(i < N) {` `            ``// If the current bit is a set bit``            ``if` `(arr[i] == 1) {``              ` `                ``// Stores the count of consecutive ones``                ``int` `count = 1;` `                ``// Insert into array brr[]``                ``brr[j] = arr[i];` `                ``// Loop to check for``                ``// next 5 bits``                ``k = i + 1;``                ``while` `(k < N && arr[k] == 1 && count < 5) {``                    ``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;``                    ``k++;``                ``}``            ``}` `            ``// Otherwise insert arr[i] into``            ``// the array brr[]``            ``else` `{``                ``brr[j] = arr[i];``            ``}``            ``i++;``            ``j++;``        ``}` `        ``// Print Answer``        ``for` `(i = 0; i < j; i++)``            ``Console.Write(brr[i]);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``        ``int` `N = 6;``        ``int``[] arr = { 1, 1, 1, 1, 1, 1 };` `        ``bitStuffing(N, arr);``    ``}``}` `// This code is contributed by ukasp`

## Javascript

 ``

Output

`1111101`

Time Complexity: O(N)
Auxiliary Space: O(N)

Bit Destuffing or Bit Unstuffing is a process of undoing the changes in the array made during the bit stuffing process i.e, removing the extra 0 bit after encountering 5 consecutive 1’s.

Examples:

Input: N = 7, arr[] = {1, 1, 1, 1, 1, 0, 1}
Output: 111111
Explanation: During the traversal of the array, 5 consecutive 1’s are encountered after the 4th index of the given array. Hence, the next 0 bit must be removed to de-stuffed array.

Input: N = 6, arr[] = {1, 0, 1, 0, 1, 0}
Output: 101010

Approach: This problem can be solved similarly to the bit stuffing problem. The only required change in the above-discussed approach is whenever 5 consecutive 1’s are encountered, skip the next bit in the array arr[] in place of inserting a 0 bit in the array brr[]

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function for bit de-stuffing``void` `bitDestuffing(``int` `N, ``int` `arr[])``{``    ``// Stores the de-stuffed array``    ``int` `brr;` `    ``// Variables to traverse the 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 the 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 skip the next bit in arr[]``                ``if` `(count == 5) {``                    ``k++;``                ``}``                ``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 = 7;``    ``int` `arr[] = { 1, 1, 1, 1, 1, 0, 1 };` `    ``bitDestuffing(N, arr);``    ``return` `0;``}` `// This code is contributed by ajaymakvana`

## C

 `// C program for the above approach``#include ``#include ` `// Function for bit de-stuffing``void` `bitDestuffing(``int` `N, ``int` `arr[])``{``    ``// Stores the de-stuffed array``    ``int` `brr;` `    ``// Variables to traverse the 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``            ``// the 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 skip the``                ``// next bit in arr[]``                ``if` `(count == 5) {``                    ``k++;``                ``}``                ``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++)``        ``printf``(``"%d"``, brr[i]);``}` `// Driver Code``int` `main()``{``    ``int` `N = 7;``    ``int` `arr[] = { 1, 1, 1, 1, 1, 0, 1 };` `    ``bitDestuffing(N, arr);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``class` `GFG{` `// Function for bit de-stuffing``static` `void` `bitDestuffing(``int` `N, ``int` `arr[])``{``  ` `    ``// Stores the de-stuffed array``    ``int` `[]brr = ``new` `int``[``30``];` `    ``// Variables to traverse the 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``            ``// the next 5 bits``            ``for` `(k = i + ``1``; k

## Python3

 `# Python program for the above approach` `# Function for bit de-stuffing``def` `bitDestuffing(N, arr):``  ` `    ``# Stores the de-stuffed array``    ``brr ``=` `[``0` `for` `i ``in` `range``(``30``)];` `    ``# Variables to traverse the arrays``    ``k ``=` `0``;``    ``i ``=` `0``;``    ``j ``=` `0``;` `    ``# Stores the count of consecutive ones``    ``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``            ``# the next 5 bits``            ``for` `k ``in` `range``(i ``+` `1``, k < N ``and` `arr[k] ``=``=` `1` `and` `count < ``5``,``1``):``                ``j ``+``=` `1``;``                ``brr[j] ``=` `arr[k];``                ``count ``+``=` `1``;` `                ``# If 5 consecutive set``                ``# bits are found skip the``                ``# next bit in arr``                ``if` `(count ``=``=` `5``):``                    ``k ``+``=` `1``;` `                ``i ``=` `k;`   `        ``# Otherwise insert arr[i] into``        ``# the array brr``        ``else``:``            ``brr[j] ``=` `arr[i];` `        ``i ``+``=` `1``;``        ``j ``+``=` `1``;` `    ``# Print Answer``    ``for` `i ``in` `range``(``0``, j):``        ``print``(brr[i],end``=``"");` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``N ``=` `7``;``    ``arr ``=` `[``1``, ``1``, ``1``, ``1``, ``1``, ``0``, ``1``];` `    ``bitDestuffing(N, arr);` `# This code contributed by shikhasingrajput`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Function for bit de-stuffing``static` `void` `bitDestuffing(``int` `N, ``int``[] arr)``{``  ` `    ``// Stores the de-stuffed array``    ``int` `[]brr = ``new` `int``;` `    ``// Variables to traverse the 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``            ``// the next 5 bits``            ``for` `(k = i + 1; k

## Javascript

 ``

Output

`111111`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up