Bit Masking

[John Weiss]

I'm trying to understand the code here

To view this content we will need your consent to set third party cookies.
For more detailed information, see our cookies page.

Accept third party cookies

View: https://www.youtube.com/watch?v=NLKQEOgBAnw&t=443s

I don't understand this notation:
(x&(1<<i)) != 0

I understand we want to AND the bit at i position with 1, and see if it's equal to 1. So i assume that's what the formula is doing. Is this C code?
& must mean AND
i must be the position, 6 in the example: (x&(1 << 6)) != 0. Correct?
What's x?
What's <<? Does it mean "get the digit at position i"?
Why don't we say = 1 instead of != 0?

 

[JosiahMaybe]

Okay, x is probably a variable, & means logical and so x logical and thing in parentheses, << is bit shift, 1 bit shifted i places, != means not equal, so left side not equal to 0. X E.

 

[John Weiss]

Okay, x is probably a variable, & means logical and so x logical and thing in parentheses, << is bit shift, 1 bit shifted i places, != means not equal, so left side not equal to 0. X E.

i think you're right, << is bit shift.
So x must be the byte we're evaluating.
I don't get why we say !=0 instead of =1.

 

[JavaJames]

It’s testing the ith bit. Returns true if the ith bit is 1

Eg suppose x is 00001000 and I is 3
The 1 is 00000001
1<<3 is 00001000
X is. 00001000
AND is 00001000. Which is != 0, so the result is. True

Now suppose I = 2
1<<2 is 00000100
X is. 00001000
AND is 00000000. Which is not != 0, so the result is. False

(Examples show x as a byte, but it’s probably an int with a lot more leading 0 bits - doesn’t change the logic)

 

[Multi Find]

To rephrase it:
1) the operator & is doing the logic "and" operation between every single bit of its left-hand operand x and its right-hand operand (1<<i).
2) 1<<i takes the value 1 and shift it i times to the left. The result is a number with all bits at 0 except the ith which is 1.
So the result is either 0 (if the ith bit of x is 0) or i<<i (if the ith bit of x is 1)
This means you could replace
(x&(1<<i)) != 0
by
(x&(1<<i)) == (1<<i)
but the first expression is easier to read (and needs less processing time).