### How to nail your Coding Interview

Here are some tips while giving your coding interviews. 1. Never try to jump to…

October 18, 2019

I will list some of the interesting usage of bitwise operators, which looks complex on first look. But, if you understand them. They are so magically wonderful that they appears to be the most optimized solution of problem.

- Basic operators are:

```
& for AND
| for OR
^ for XOR
>> for right shift
<< for left shift
~ for Negate
```

- Left or right shift does not change the signed-bit of a number
- Right shift a number is equivalent to divide a number by 2
- Left shift a number is equivalent to multiply a number by 2

Simply do an *&* operation with *1* and number.

```
num & 1
# it will simply return either 0 or 1
```

You need to get the LSB (least significant bit), and check of it is equal to 1.

Code to count number of 1s

```
public int count1s(int num) {
int count = 0;
while (num > 0) {
//or, you can do if (num & 1 != 0)
count += num & 1;
num = num >> 1;
}
return count;
}
```

Above method will run as many times as number of bits in the number. We could simply jump to 1s in the number. How?

Lets see power of masking. We have to target just the 1-bit. We can reset the 1s on LSB side one by one.

```
# example: binary representation: 1010
# we want to reset it to 1000
num & (num - 1)
# i.e. 1010 & 1000 = 1000
```

So, how do we count number of 1s

```
public int count1s(int num) {
int count = 0;
while (num > 0) {
//or, you can do if (num & 1 != 0)
count += num & 1;
num = num & (num - 1);
}
return count;
}
```

Given a number, swap ith and jth bit

```
0 1 1 0 0 1 1 0
# swap 2nd and 5th bits (from right)
```

Note: If the bits are different, only then we have to swap them. Else, no need. So, we need to first get those bits. And check for equality. If they are not same, only then swap them. And, what do we mean by swap. We just need to flip their value. To swap, we need to create a mask.

```
# num
i = 2;
j = 5;
if ((num >> i & 1) != (num >> j & 1)) {
# mask for ith, and jth bit
# (1 << i) | (1 << j)
# XOR it with num
num = num ^ ((1 << i) | (1 << j))
}
# else, no need to swap.
```

We optimized above code not to unnecessary swap bits when they are same. We just set ith and jth bit on our mask as 1. And, we will need to XOR it with the number.

```
0 1 1 0 0 1 1 0
- -
# - denote positions we want to swap
# mask:
0 0 1 0 0 1 0 0
# final XOR operation
0 1 1 0 0 1 1 0
0 0 1 0 0 1 0 0
=>
0 1 0 0 0 0 1 0
```

Here are some tips while giving your coding interviews. 1. Never try to jump to…

Problem Statement Roman numerals are represented by seven different symbols: I…

Problem Statement Given a linked list, remove the n-th node from the end of list…

Problem Statement You are given an array prices where prices[i] is the price of…

Problem Statement Given a string s, find the longest palindromic substring in s…

This topic is one of the most common studied. When somebody started preparation…

Introduction I was trying to upload images to my backend using rest APIs. I was…

Introduction In this post, we will see multiple ways to use annotation…

Introduction I was using Paypal payment on one of my website, and suddenly lot…

Introduction In a Spring boot app, we tend to use annotation, so that Spring…

Introduction In this posr, we will see how to prepare mysql query to fetch user…

Introduction Here, we will see the drupal code to fetch all the active users…