## Introduction

Space advancement is a computerized interaction for distinguishing properties that can be abandoned by moving the tasks and resources inside those properties to different properties with appropriate abundance space. Bit control is the demonstration of algorithmically controlling pieces or other bits of information more limited than a word. PC programming undertakings that require digit control incorporate low-level gadget control, blunder discovery and adjustment calculations, information pressure, encryption calculations, and enhancement.

## Space optimization using bit manipulations

There are numerous circumstances where we use whole number qualities as files in the cluster to see presence or nonattendance; we can utilize bit controls to streamline space in such issues.

Allow us to consider underneath issues, for instance.

Given two numbers, say an and b, mark the products of 2 and 5 among an and b utilizing not exactly O(|b - a|) space and result in every one of the products.

Note: We need to stamp the products, i.e., save (key, esteem) matches in memory with the end goal that each key has affection as 1 or 0 addressing as various of 2 or 5 or not separately.

### Example

Input : 2 10

Output : 2 4 5 6 8 10

Input: 60 92

Output: 60 62 64 65 66 68 70 72 74 75 76 78 80 82 84 85 86 88 90 92

### Approach 1 (Simple):

Hash the lists in an exhibit from a to b and imprint every one of the records as 1 or 0.

Space complexity : O(max(a, b))

### Approach 2 (Better than straightforward):

Save memory by interpreting a to 0th record and b to (b-a)th list.

Space complexity : O(|b-a|).

### Approach 3 (Using Bit Manipulations):

Here is a space improvement that utilizes a bit control procedure applied to issues planning two-fold qualities in exhibits.

The size of the int variable in the 64-cycle compiler is 4 bytes. Eight cycle positions in memory address one byte. Thus, 32 cycle positions(4 Bytes) address a whole number in memory. These 32 digit positions can be utilized rather than only one file to hash paired valuesC

### Code

```
// C++ code to for marking multiples
#include <bits/stdc++.h>
using namespace std;
// index >> 5 corresponds to dividing index by 32
// index & 31 corresponds to modulo operation of
// index by 32
// Function to check value of bit position whether
// it is zero or one
bool checkbit(int array[], int index)
{
return array[index >> 5] & (1 << (index & 31));
}
// Sets value of bit for corresponding index
void setbit(int array[], int index)
{
array[index >> 5] |= (1 << (index & 31));
}
/* Driver program to test above functions*/
int main()
{
int a = 2, b = 10;
int size = abs(b - a);
// Size that will be used is actual_size/32
// ceil is used to initialize the array with
// positive number
size = ceil(size / 32);
// Array is dynamically initialized as
// we are calculating size at run time
int* array = new int[size];
// Iterate through every index from a to b and
// call setbit() if it is a multiple of 2 or 5
for (int i = a; i <= b; i++)
if (i % 2 == 0 || i % 5 == 0)
setbit(array, i - a);
cout << "MULTIPLES of 2 and 5:\n";
for (int i = a; i <= b; i++)
if (checkbit(array, i - a))
cout << i << " ";
return 0;
}
```