Precondition:It is recommended to referInteresting Facts about Bitwise Operators To set a bit in the number "num":
If we want to start a littleNposition in the number "num" this can be done with the "OR" operator ( | ).
- First we shift the '1' to the left via (1<<n) to position n.
- Then use the "OR" operator to set the bit at that position. The OR operator is used because it sets the bit even if the bit was not previously set in the binary representation of the number num.
Observation:If the bit was already set, it would remain unchanged.
C++
#include<iostream>
to use namespace Standard;
// num is the number and pos is the position
// where we want to set the bit.
Empty Phrase(int & num,int pos)
{
// First step is shift '1', second
// step is bitwise OR
ob |= (1 << pos);
}
int mainly()
{
int num = 4, pos = 1;
set(num, pos);
cause << (int)(num) << endl;
to return 0;
}
Java
/*any package //don't write package names here */
matter java.io.*;
Classroom GFG {
public static Empty principal (String[] argumentos) {
int number =4, Pos =1;
num = set(num, pos);
System.out.println(num);
}
public static int Phrase(int Number,int pos){
// First step is shift '1', second
// step is bitwise OR
number |= (1 << Pos);
to return Number;
}
}
// This code is contributed by geeky01adash.
Python3
# num = number, pos = position where we want to set the bit
def Phrase (obs, pos):
# First step = Shift '1'
# Second pass = bitwise OR
number |= (1 <<pos)
press(Number)
ob, pos= 4,1
Phrase(I can)
# This code is contributed by sarajadhav12052009
C #
to use System;
public Classroom GFG{
static public Empty Mainly ()
{
int num = 4, pos = 1;
Phrase(ob, pos);
}
// num = number, pos = position where we want to set the bit
static public Empty Phrase(int Number,int pos)
{
// First step: Shift '1'
// Second step: bitwise OR
ob |= (1 << pos);
Console.WriteLine(num);
}
}
// This code is contributed by sarajadhav12052009
Javascript
<script>
// num is the number and pos is the position
// where we want to set the bit.
function set(num,pos)
{
// First step is shift '1', second
// step is bitwise OR
ob |= (1 << pos);
console.log(parseInt(num));
}
sei num = 4;
last pos = 1;
set(num, pos);
// This code is contributed by akashish__
</script>
Exit
6
Time complexity:O(1)
auxiliary room:O(1)
We pass the parameter via 'call by reference' to make permanent changes to the number.
2. To set/clear a bit at the nth position in number num:
Suppose we want to redefine something at the nth position at number "num", then we need to do it using "AND" (&) operator.
- First, we move the offset of "1" to position n via (1<<n) and then use the bitwise NOT operator "~" to reset this offset "1".
- After we delete that "1" shifted to the left, that is, H. set them to "0", we do "AND" (&) with the number "num" that resets the bit in the nth position.
C++
#include <iostream>
to use namespace Standard;
// The first step is to get a number that contains only 1 except for the specified position.
Empty not configured (int &num,int pos)
{
//Second step is bitwise and this number with the given number
ob &= (~(1 <<pos));
}
int mainly()
{
int number = 7;
int Pos = 1;
unset(ob, pos);
cout << num << endl;
to return 0;
}
Java
/*any package //don't write package names here */
matter java.io.*;
Classroom GFG {
public static Empty main(String[] argumentos)
{
int number =7, Pos =1;
num = unset(num, pos);
System.out.println(num);
}
public static int not configured (int Number,int pos)
{
// The second step is bitwise and this number with
// given number
number = number & (~(1 << Pos));
to return Number;
}
}
Python3
# First step: get all '1's except have
# position given
def undefined(num, pos):
# Second step: bitwise And this number with the given number
num &= (~(1 <<pos))
press(Number)
ob, pos= 7,1
disarm
C #
to use System;
public Classroom GFG {
static public Empty Mainly()
{
// First step: Get a number consisting only of 1
// except for the given position
int num = 7, pos = 1;
unset(ob, pos);
}
static public Empty not configured (int Number,int pos)
{
// Second step: And bitwise this number with the
// given number
ob &= (~(1 <<pos));
Console.WriteLine(num);
}
}
Javascript
// The first step is to get a number that contains only 1 except for the specified position.
function undefined(num,pos)
{
//Second step is bitwise and this number with the given number
ob &= ( ~ (1 << pos));
to return Number;
}
sei num = 7;
last pos = 1;
console.log (unset (num, pos));
// This code is contributed by akashish__
Exit
5
Time complexity:O(1)
auxiliary room:O(1)
3. Toggle something in the nth position:
Toggle means turning bit on (1) if it was "off" (0) and "off" (0) if previously it was "on" (1). Let's use the 'XOR' operator here, which is this '^'. The reason for the "XOR" operator is in its properties.
- 'XOR' operator properties.
- 1^1 = 0
- 0^0 = 0
- 1^0 = 1
- 0^1 = 1
- If two bits are different, the "XOR" operator returns a set bit (1), otherwise it returns an unset bit (0).
C++
#include <iostream>
to use namespace Standard;
// First step is to change 1, second step is XOR with data
// number
Empty Trocar(int& num,int pos) { num ^= (1 << pos); }
int mainly()
{
int number = 4;
int Pos = 1;
toggle(num, pos);
cout << num << endl;
to return 0;
}
Java
/*any package //don't write package names here */
matter java.io.*;
Classroom GFG {
public static Empty principal (String[] argumentos) {
int number =4, Pos =1;
num = toggle(num, pos);
System.out.println(num);
}
public static int Trocar(int Number,int pos){
// First step is offset 1, second step is XOR with given number
number ^= (1 << Pos);
to return Number;
}
}
// This code is contributed by geeky01adash.
Python3
def toggle(num, pos):
# First step: move '1'
# Second step: XOR num
number ^= (1 <<pos)
press(Number)
ob, pos= 4,1
toggle(num, pos)
# This code is contributed by sarajadhav12052009
C #
to use System;
public Classroom GFG{
static public Empty Mainly ()
{
int num = 4, pos = 1;
toggle(num, pos);
}
static public Empty Trocar(int Number,int pos)
{
// First step: Shift '1'
// Second step: XOR num
ob ^= (1 << pos);
Console.WriteLine(num);
}
}
// This code is contributed by sarajadhav12052009
Javascript
function toggle(num, pos) {
// First step is offset 1, second step is XOR with given number
ob ^= (1 << pos);
to return Number;
}
know num = 4,
Pos = 1;
num = toggle(num, pos);
console.log(num);
// This code is contributed by Prajwal Kandekar
Exit
6
Time complexity:O(1)
auxiliary room:O(1)
4. Check whether the bit in the nth position is set or not:
This is easy to do with the "AND" operator.
- Left shift "1" to the specified position, then "AND" ("&").
C++
#include <iostream>
to use namespace Standard;
bool a position(int Number,int pos)
{
bool bit = num & (1 << pos);
to return Chunk;
}
int mainly()
{
int number = 5;
int Pos = 0;
bool bit = at_position (num, pos);
cout << bit << endl;
to return 0;
}
Java
/*any package //don't write package names here */
matter java.io.*;
Classroom GFG {
public static Empty main(String[] argumentos)
{
int number =5;
int Pos =0;
int bit = at_position (num, pos);
System.out.println (Bit);
}
public static int a position(int Number,int pos)
{
int bit = ob & (1 << Pos);
to return Chunk;
}
}
Python3
#-Code
def at_position(num,pos):
Chunk= num & (1<<pos)
to return Chunk
Number= 5
pos= 0
Chunk= at_position(num, pos)
press(Chunk)
C #
to use System;
Classroom GFG {
static Empty Mainly(line[ ] Arguments)
{
int number = 5;
int Pos = 0;
int bit = at_position (num, pos);
Console.WriteLine (Bit);
}
static int a position(int Number,int pos)
{
int bit = num & (1 << pos);
to return Chunk;
}
}
Javascript
<script>
function at_position(num,pos)
{
to return ob & (1<<pos);
}
sei num = 5;
let pos = 0;
console.log (at_position (num, pos));
// contribution from akashish__
</script>
Exit
1
Time complexity:O(1)
auxiliary room:O(1)
Note that we first shift "1" to the left and then use the "AND" operator to get a bit at that position. So if there is '1' in position 'pos' in 'num' then our variable 'bit' stores '1' after 'AND' otherwise if there is '0' in position 'pos' in number then 'num' will provide. than after 'AND' stores our variable '0' bit.
A few more quick hacks:
- Inverting each bit of a number/1's complement:If we want to invert each bit of a number, that is, change bit '0' to '1' and bit '1' to '0', we can do it with the help of the '~' operator. For example: if the number is num =00101100 (binary representation), then '~num' will be '11010011'.
This is also the "1's complement of the number".
C++
#include <iostream>
to use namespace Standard;
int mainly()
{
int number = 4;
// reverse each bit of number num
cout << (~num);
to return 0;
}
Java
/*any package //don't write package names here */
matter java.io.*;
Classroom GFG {
public static Empty principal (String[] argumentos) {
int number =4;
// reverse each bit of number num
number = (~number);
System.out.println(num);
}
}
Python3
Number= 4
# Invert each bit of number num
press(~number)
C #
to use System;
public Classroom GFG{
static public Empty Mainly ()
{
int number = 4;
// reverse each bit of number num
Console.WriteLine(~num);
}
}
Javascript
<script>
sei num = 4;
// reverse each bit of number num
console.log(~num);
</script>
Exit
-5
Time complexity:O(1)
auxiliary room:O(1)
- Two's complement of the number:The two's complement of a number is one's complement + 1.
So formally we can have the 2's complement by finding the 1's complement and adding 1 to the result i.e. (~num+1) or what else we can do is use the '-' operator.
C++
#include <iostream>
to use namespace Standard;
int mainly()
{
int number = 4;
int twos_complement = -num;
cause <<"This is two's complement" << two's complement << endl;
cause <<"This is also two's complement" << (~num+1) << endl;
to return 0;
}
Java
/*any package //don't write package names here */
matter java.io.*;
Classroom GFG {
public static Empty main(String[] argumentos)
{
int number =4;
int twos_complement = -num;
System.out.println("This is two's complement"
+ two's complement);
System.out.println("This is also two's complement"
+ (~number +1));
}
}
// This code is contributed by geeky01adash.
Python3
Number= 4
two's complement= -Number
press(F"This is two's complement {twos_complement}")
press(F"This is also two's complement {~num + 1}")
# This code is contributed by sarajadhav12052009
C #
to use System;
public Classroom GFG{
static public Empty Mainly ()
{
int number = 4;
int twos_complement = -num;
Console.WriteLine("This is two's complement" + two's complement);
Console.WriteLine("This is also two's complement" + (~num+1));
}
}
// This code is contributed by sarajadhav12052009
Javascript
<script>
sei num = 4;
let twos_complement = -num;
Console.log ("This is two's complement" + two's complement);
Console.log ("This is also two's complement" + (~num+1));
// This code is contributed by akashish__
</script>
Exit
This is two's complement -4. This is also two's complement -4
Time complexity:O(1)
auxiliary room:O(1)
Removing the lowest bitset:
In many situations we want to remove the lowest bit set, for example in a binary indexed tree data structure counting the number of bits set in a number. We do something like this:
X = X & (X-1)
But how does it work? Let's see this with an example, let X = 1100.
- (X-1) inverts all bits until it finds the smallest quantity "1", and also inverts this smallest quantity "1".
- X-1 becomes 1011. After "WALKING" X with X-1, we remove the lowest set bit.
C++
#include <iostream>
to use namespace Standard;
Empty strip_last_set_bit(int &num)
{
num = num & (num-1);
}
int mainly()
{
int number = 7;
strip_last_set_bit(num);
cout << num << endl;
to return 0;
}
Java
matter java.io.*;
Classroom GFG {
public static Empty main(String[] argumentos)
{
int number =7;
num = strip_last_set_bit(num);
System.out.println(num);
}
public static int strip_last_set_bit(int Number)
{
to return I know -1);
}
}
Python3
def strip_last_set_bit(num):
num &= (Anz- 1)
press(Number)
Number= 7
strip_last_set_bit(num)
C #
to use System;
public Classroom GFG{
static public Empty Mainly ()
{
int number = 7;
strip_last_set_bit(num);
}
static public Empty strip_last_set_bit(int Number)
{
number &= (number - 1);
Console.WriteLine(num);
}
}
Javascript
<script>
function strip_last_set_bit(num)
{
to return number & (number-1);
}
sei num = 7;
console.log(strip_last_set_bit(num));
</script>
Exit
6
Time complexity:O(1)
auxiliary room:O(1)
Get the lowest register bit of a number:
This is achieved using the expression 'X &(-X)'. Let's see this with an example: Let X = 00101100. Then ~X(1's complement) will be '11010011' and 2's complement will be (~X+ 1 or -X), ie '11010100'. So if 'E' the original number 'X' with its two's complement, which is '-X', we get the lowest bit set.
00101100& 11010100----------- 00000100
C++
#include <iostream>
to use namespace Standard;
int menor_bit_set(int Number)
{
int ret = num & (-num);
to return turn back;
}
int mainly()
{
int number = 10;
int ans = less_set_bit(num);
cout << ans << endl;
to return 0;
}
Java
matter java.io.*;
Classroom GFG {
public static Empty main(String[] argumentos)
{
int number =10;
int ans = less_set_bit(num);
System.out.println(ans);
}
public static int menor_bit_set(int Number)
{
int ret = num & (-num);
to return turn back;
}
}
Python3
def minor_set_bit(num):
num &= (-Number)
press(Number)
Number= 10
minor_bit_set(num)
Javascript
// Function to set the lowest bit
function minor_bit_set(num)
{
// Take e from num and -ve from num
let ret = num & (-num);
to return turn back;
}
// driver code
I know num = 10
let ans = smallest_set_bit(num)
console.log(ans)
C #
to use System;
public Classroom GFG {
static public Empty Mainly()
{
int number = 10;
bit_set_minor(num);
}
static public Empty menor_bit_set(int Number)
{
number &= (~number + 1);
Console.WriteLine(num);
}
}
Exit
2
Divide by 2 and multiply by 2 are also very common in loops in competitive programming, so using bitwise operators can help speed up code.
Divide by 2 using the right shift operator:
00001100 >> 1 (00001100 is 12)------------00000110 (00000110 is 6)
C++
#include <iostream>
to use namespace Standard;
int mainly()
{
int number = 12;
int ans = num>>1;
cout << ans << endl;
to return 0;
}
Java
matter java.io.*;
Classroom GFG {
public static Empty main(String[] argumentos)
{
int number =12;
int years = ob >>1;
System.out.println(ans);
}
}
Python3
Number= 12
press(Number >>1)
C #
to use System;
public Classroom GFG{
static public Empty Mainly ()
{
int number = 12;
Console.WriteLine(num >> 1);
}
}
Javascript
<script>
Guerra number = 12;
Guerra ans = num>>1;
console.log(ans);
</script>
Exit
6
Time complexity:O(1)
auxiliary room:O(1)
Multiply by 2 using the left shift operator:
00001100 << 1 (00001100 is 12)------------00011000 (00000110 is 24)
C++
#include <iostream>
to use namespace Standard;
int mainly()
{
int number = 12;
int ans = num<<1;
cout << ans << endl;
to return 0;
}
Java
/*any package //don't write package names here */
matter java.io.*;
Classroom GFG {
public static Empty principal (String[] argumentos) {
int number =12;
int ans = num<<1;
System.out.println(ans);
}
}
// This code is contributed by geeky01adash.
C #
to use System;
public Classroom GFG{
static public Empty Mainly ()
{
int number = 12;
Console.WriteLine(num << 1);
}
}
// This code is contributed by sarajadhav12052009
Python3
# Python program for the above approach
Number= 12
response= number <<1
press(response)
# This code is contributed by Shubham Singh
Javascript
<script>
// Javascript program for the above approach
Guerra number = 12;
Guerra ans = num<<1;
document.write(ans);
//This code is contributed by Shubham Singh
</script>
Exit
24
Time complexity:O(1)
auxiliary room:O(1)
Bit tricks for competitive programming
ReferBitWise Operator Articlesfor more articles on bit hacks.
This article was contributed byPankaj Mishra. If you like GeeksforGeeks and want to contribute, you can also write an article and send your article to review-team@geeksforgeeks.org. See your article appear on the main page of GeeksforGeeks and help other geeks.
Please write comments if you find something wrong or if you want to share more information about the topic discussed above.
my personal notesarrow_drop_up