# Implementation of Bit Stuffing and Bit Destuffing

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)

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next