GeeksforGeeks App
Open App
Browser
Continue

# Bit Manipulation technique to replace boolean arrays of fixed size less than 64

Space complexity is the most underestimated asset by programmers. One can barely see a Memory Limit Exceed (MLE) while submitting a solution. But, saving memory is the most important thing a programmer should take care about. If one needs to create an Application for a user, it should be made as memory efficient as one can.
Boolean arrays have been used as a container to solve different problems. This article focuses on discussing the alternatives to boolean arrays.

Integer Variable as a container

In general, the Integer variable has 4 bytes (C++ taken into consideration) resulting in having 32 boolean bits to represent a number. For example, to represent 10, the boolean bits can be written as:

int a = 10

In Memory-
00000000000000000000000000001010 (Binary of 10 in 32-bit integer)

This means one can use these bits as a boolean value inside a boolean array of size 32. A 64-bit integer can be used to increase the size if needed.

How to use Integer variable as a container?

Let’s discuss in detail how to use the Integer variable as a container.

The first step is to initialize the integer variable as 0, to get the boolean container of size 32 with all bits initially false.

Set a bit to true:
Set any bit to true for any desired location by using bitwise operators such as AND, NOT, OR, and SHIFT operators. For, example, to set a bit to true at position 7-

Use shift and bitwise OR operator to make the ith bit to 1 (true)
int a = 0;
a |= (1 << 7);
Here a will become : 00000000000000000000000010000000
↑
0th bit

Step 1: First move 1 which is (..0001) in binary to 7 steps left to make it as (..10000000).
Step 2: Next, do bitwise or with the number.
Step 3: As 1 OR 0 = 1 and 1 OR 1 = 1, this will set the 7th bit to one without affecting other bits.

Set a bit to false:

For example, to reset a bit to false at position 7

Use shift and bitwise NOT and AND operator to make the ith bit to 0(false).
int a = 0;
a |= (1 << 7); // To set 7th bit
a &= ~(1 << 7); // To reset 7th bit

Step 1: First move our 1 which is (..0001) in binary to 7 steps left to make it as (..10000000).
Step 2: Invert the bits to look like (…1101111111).
Step 3: Perform AND operation with the number.
Step 4: As 1 AND 0 = 0, 0 AND 0 = 0, 1 AND 1 = 1, this will set the 7th bit to one without affecting other bits.

Get the value of ith bit:

For example, to get the value of the 7th bit-

Use AND operator to print.
int a = 0;
a |= (1<<7); // To set 7th bit
Print((a>>7)&1);  // this will print 1(True)
a &= ~(1<<7); // To reset 7th bit
Print((a>>7)&1); // this will print 0(false)

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach``#include``using` `namespace` `std;` `// Driver code``int` `main()``{``  ``// This is an integer variable``  ``// used as a container``  ``int` `myBoolContainer = 0;``  ` `  ``// 7th bit will be used for sample``  ``int` `workingBit = 7;``  ` `  ``// Setting ith bit``  ``cout << ``"Setting "` `<<``           ``workingBit << ``"th bit to 1\n"``;``  ` `  ``myBoolContainer |= (1 << workingBit);``  ` `  ``// Printing the ith bit``  ``cout << ``"Value at "` `<< workingBit <<``          ``"th bit = "` `<<``          ``((myBoolContainer >> workingBit) & 1) <<``          ``"\n\n"``; ``  ` `  ``// Resetting the ith bit``  ``cout << ``"Resetting "` `<< workingBit <<``          ``"th bit to 0\n"``;``  ``myBoolContainer &= ~(1 << 7);``  ` `  ``// Printing the ith bit``  ``cout << ``"Value at "` `<< workingBit <<``          ``"th bit = "` `<<``          ``((myBoolContainer >> workingBit) & 1);``}`

## Java

 `// Java program to implement``// the above approach``import` `java.io.*;` `// Driver code``class` `GFG``{``    ``public` `static` `void` `main (String[] args)``    ``{``          ``// This will be the integer variable``        ``// used as boolean container``        ``int` `myBoolContainer = ``0``;``  ` `        ``// 7th bit will be used for sample``        ``int` `workingBit = ``7``;` `        ``// Setting ith bit``        ``System.out.println(``        ``"Setting "` `+ workingBit +``        ``"th bit to 1"``);``      ` `        ``myBoolContainer |= (``1` `<< workingBit);` `        ``// Printing the ith bit``        ``System.out.println(``        ``"Value at "` `+ workingBit+``"th bit = "` `+``        ``((myBoolContainer >> workingBit) & ``1``) +``        ``"\n"``); ` `        ``// Resetting the ith bit``        ``System.out.println(``        ``"Resetting "` `+ workingBit +``        ``"th bit to 0"``);``        ` `        ``myBoolContainer &= ~(``1` `<< ``7``);` `        ``// Printing the ith bit``        ``System.out.println(``        ``"Value at "` `+ workingBit +``        ``"th bit = "` `+``        ``((myBoolContainer >>workingBit) & ``1``));``    ``}``}`

## Python

 `# Python program to implement``# the above approach``# This will be the integer variable``# used as boolean container``myBoolContainer ``=` `0``;``  ` `# 7th bit will be used as example``workingBit ``=` `7``;` `# Setting ith bit``print``(``"Setting "` `+` `str``(workingBit) ``+``      ``"th bit to 1"``);``myBoolContainer |``=` `(``1` `<< workingBit);` `# Printing the ith bit``print``(``"Value at "` `+` `str``(workingBit) ``+``      ``"th bit = "` `+` `str``((myBoolContainer >>``                         ``workingBit) & ``1``) ``+` `"\n"``); ` `# Resetting the ith bit``print``(``"Resetting "` `+` `str``(workingBit) ``+``      ``"th bit to 0"``);``myBoolContainer &``=` `~(``1` `<< ``7``);` `# Printing the ith bit``print``(``"Value at "` `+` `str``(workingBit) ``+``      ``"th bit = "` `+` `str``((myBoolContainer >>``                         ``workingBit) & ``1``))`

## C#

 `//C# code for the above approach``using` `System;``public` `class` `GFG {` `    ``static` `public` `void` `Main()``    ``{` `        ``// This will be the integer variable``        ``// used as boolean container``        ``int` `myBoolContainer = 0;` `        ``// 7th bit will be used for sample``        ``int` `workingBit = 7;` `        ``// Setting ith bit``        ``Console.WriteLine(``"Setting "` `+ workingBit``                          ``+ ``"th bit to 1"``);` `        ``myBoolContainer |= (1 << workingBit);` `        ``// Printing the ith bit``        ``Console.WriteLine(``            ``"Value at "` `+ workingBit + ``"th bit = "``            ``+ ((myBoolContainer >> workingBit) & 1) + ``"\n"``);` `        ``// Resetting the ith bit``        ``Console.WriteLine(``"Resetting "` `+ workingBit``                          ``+ ``"th bit to 0"``);` `        ``myBoolContainer &= ~(1 << 7);` `        ``// Printing the ith bit``        ``Console.WriteLine(``            ``"Value at "` `+ workingBit + ``"th bit = "``            ``+ ((myBoolContainer >> workingBit) & 1));``    ``}``}` `// This code is contributed by Potta Lokesh`

## Javascript

 `// Javascript program to implement``// the above approach``// This is an integer variable``// used as a container``var` `myBoolContainer = 0;` `// 7th bit will be used sample``var` `workingBit = 7;``  ` `// Setting ith bit``console.log(``"Setting "` `+ workingBit +``            ``"th bit to 1\n"``);``myBoolContainer |= (1 << workingBit);``  ` `//Printing the ith bit``console.log(``"Value at "` `+ workingBit +``            ``"th bit = "``+ ((myBoolContainer >>``                           ``workingBit) & 1) + ``"\n\n"``);``  ` `// Resetting the ith bit``console.log(``"Resetting "` `+ workingBit +``            ``"th bit to 0\n"``);``myBoolContainer &= ~(1 << 7);``  ` `// Printing the ith bit``console.log(``"Value at "` `+ workingBit +``            ``"th bit = "` `+ ((myBoolContainer >>``                            ``workingBit) & 1));`

Output

```Setting 7th bit to 1
Value at 7th bit = 1

Resetting 7th bit to 0
Value at 7th bit = 0```

Solve Pangram Strings:

Let’s solve the problem of pangram strings using the above approach.

Approach:

It is known that English alphabets of lower case range from (a-z) are having a count of no more than 26. So, in this approach, a bool array of constant size can be used. This will optimize the space complexity of the code.

Below is the implementation of the pangram strings using a boolean array:

## C++

 `// C++ program to implement``// the above approach``#include ``using` `namespace` `std;` `bool` `checkIsPanagram(string sentence)``{``    ``// Initializing the container``    ``int` `n = 0;``  ` `    ``for``(``char` `&x:sentence)``    ``{``        ``// Checking that the char``        ``// is Alphabetic``        ``if``(``isalpha``(x)) ``          ` `            ``// setting ith bit to 1``            ``// if char is 'a' then this will``            ``// set 0th bit to 1 and so on``            ``n |= (1 << (``tolower``(x) - ``'a'``));           ``    ``}``  ` `    ``// decimal number for all ones in last``    ``// 26 bits in binary is 67108863``    ``return` `n == 67108863;``}` `// Driver code``int` `main()``{``  ``string s =``  ``"Pack mY box witH fIve dozen liquor jugs"``;``  ``cout << checkIsPanagram(s);``}`

## Java

 `// Java program to implement``// the above approach``import` `java.io.*;``class` `Panagram``{``  ``public` `boolean` `checkIsPanagram(``                 ``String sentence)``  ``{``      ``// Initializing the container``      ``int` `n = ``0``;``    ` `        ``int` `size = sentence.length();``        ``for``(``int` `i = ``0``; i < size; i++)``        ``{``            ``// Storing current character``            ``// in temp variable``            ``char` `x = sentence.charAt(i);``          ` `            ``// checking that the char is Alphabetic``            ``if``(Character.isAlphabetic(x))``            ``{``                ``// setting ith bit to 1``                ``// if char is 'a' then this will``                ``// set 0th bit to 1 and so on``                ``n |= (``1` `<< (Character.toLowerCase(x) - ``'a'``));    ``            ``}``        ``}``    ` `        ``// Decimal number for all ones in last``        ``// 26 bits in binary is 67108863``        ``return` `(n == ``67108863``);``  ``}``};` `// Driver code``class` `GFG``{``    ``public` `static` `void` `main (String[] args)``    ``{``      ``String s =``      ``"Pack mY box witH fIve dozen liquor jugs"``;``      ``Panagram panagram = ``new` `Panagram();``      ``System.out.println(``             ``panagram.checkIsPanagram(s));``    ``}``}`

## Python

 `# Python program to implement``# the above approach``def` `isPanagram(sentence):``  ` `    ``# Initializing the container``    ``n ``=` `0``    ` `    ``for` `char ``in` `sentence:``          ` `        ``# Checking that the char``        ``# is Alphabetic``        ``if` `char.isalpha():``          ` `            ``# setting ith bit to 1``            ``# if char is a then this will``            ``# set 0th bit to 1 and so on``            ``n |``=` `(``1` `<< (``ord``(char.lower()) ``-``                        ``ord``(``'a'``)))``            ` `    ` `    ``# Decimal number for all ones in``    ``# last 26 bits in binary is 67108863``    ``return` `n ``=``=` `67108863` `sentence ``=``"Pack mY box witH fIve dozen liquor jugs"``print``(isPanagram(sentence))`

## C#

 `// C# program to implement``// the above approach``using` `System;` `class` `Panagram``{``  ``public` `bool` `checkIsPanagram(``                 ``String sentence)``  ``{``    ` `      ``// Initializing the container``      ``int` `n = 0;``    ` `        ``int` `size = sentence.Length;``        ``for``(``int` `i = 0; i < size; i++)``        ``{``          ` `            ``// Storing current character``            ``// in temp variable``            ``char` `x = sentence[i];``          ` `            ``// checking that the char is Alphabetic``            ``if``(``char``.IsLetter(x))``            ``{``              ` `                ``// setting ith bit to 1``                ``// if char is 'a' then this will``                ``// set 0th bit to 1 and so on``                ``n |= (1 << (``char``.ToLower(x) - ``'a'``));    ``            ``}``        ``}``    ` `        ``// Decimal number for all ones in last``        ``// 26 bits in binary is 67108863``        ``return` `(n == 67108863);``  ``}``};` `// Driver code``public` `class` `GFG``{``    ``public` `static` `void` `Main(String[] args)``    ``{``      ``String s =``      ``"Pack mY box witH fIve dozen liquor jugs"``;``      ``Panagram panagram = ``new` `Panagram();``      ``Console.WriteLine(``             ``panagram.checkIsPanagram(s));``    ``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output

`1`

My Personal Notes arrow_drop_up