• Let's say each binary form represents its corresponding decimal number.
• But if we represent the numbers using this way then there is no scope to store negative numbers so this range is not appropriate. That's why this approach has failed.

• What if we use the last bit to represent the negative and positive sign? Would that work?
• As it is noticeable that if we ignore the last bit of all the numbers then the 0^th number is exactly the same as the 8th number in binary representation, first is similar to ninth, third to tenth and so on.
• The only difference was the last bit. In the first 8 numbers this bit is 0 and in last 8 numbers this bit is 1.
• So if we use the last bit to represent signs then this range might work.
• We represent positive signs with 0 and negative signs with 1. Now take a look at the new representation using approach-2.
• Oh! No. What is up with this 0?
• This approach also fails as using this approach we get +0 and -0 which is invalid therefore making this range also invalid.

• We keep the idea of treating the last bit (MSB: most significant bit) for sign representation; similar to approach 2.
• And the numbers with 0 as MSB (positive numbers) are simply converted into decimal numbers just like in the previous approach.
• The only change that can be spotted is while converting the number with 1 as MSB (negative numbers).
• For converting the negative numbers, we first do the 2's complement of the given binary number and then convert it into decimal form. And finally add a negative sign in front of it.
• How to calculate 2's complement of the given binary number?
• To calculate 2's complement, we first find the 1's complement the number and then add binary 1 to this 1's complement.
• To get 1's complement, simply toggle the bits i.e. change 1 to 0 and 0 to 1.
• Let's take an example to understand this. So the first number with MSB as 1 is 1000.
• Firstly we take one's complement of this number and then add a binary one to it which gives us 1000. Decimal of this binary number is 8. To get the final value, add a negative sign to the decimal number (-8).
• Similarly please try on your own, to change 1010 binary into a decimal number.
• You may cross check it from below.
• I'm sure that you got this right. If not then try converting some other binary value and for cross checking the answer you can watch this part of the video.
• This is what; all the binary numbers will correspond to, using this approach.
• Instead of looking at the different numbers in the above sequence we can also look at it in following way, where we have arranged the binary numbers with 1 as MSB above the ones with 0 as MSB:
• On doing this slight change, all decimal numbers corresponding to binary number get arranged in increasing order i.e. From -8 to 7, giving us the range for Nibble type numbers.
• We can also represent -8 as (2^3) and 7 as (2^3)-1. So we can say that the range of Nibble is ((-(2^3)) to ((2^3)-1)) or ((-(2^(4-1))) to ((2^(4-1))-1)).
• Using this representation of the range, we can also generalize the range of as ((-(2^(n-1))) to ((2^(n-1))-1)), where n represents the number of bits.
• And using this generalized range formula, we can also define the range of other types also, as shown below:
• So the idea behind talking about different approaches and then finally generalizing the formula was to ensure that you understand how we can derive the range of any type.
• So that rather than cramming the ranges of any type you can memorize it easily.
• Now there is one more possibility to discuss. What if the user initializes the number of some type which is out of its range?
• For this we need to understand how conversions take place inside the machine and to what number this new converted number corresponds to.

• Binary to decimal:
  • While converting a number from binary to decimal, first of all analyze the most significant bit.
  • If the bit is 0, then simply convert the binary number into a decimal number and put a positive sign in front of the number.
  • If the bit is 1, then first of all take a 2's complement and then put a negative sign in front of the number.
• Decimal to binary:
  • While converting a number from binary to decimal, first of all check for the sign.
  • If the sign is positive, then first of all convert the decimal number in the binary number.
  • After this, fit the binary number into bits. It means that if the converted number has more bits than the possible number of bits of a particular type then discard the extra bits from the left.
  • And if the converted number has fewer bits than the possible number of bits then we add zeros at the left of the binary number to make its size equal to the number of possible bits.
  • If the sign is negative, then first of all leave the negative sign behind and convert the decimal number into a binary number.
  • After this take a 2's complement of the converted binary number.
  • Then fit the binary number into bits.

• Bitwise OR (|):
  • In 'or' operator 1 bit is powerful and 0 bit is powerless.
  • Let's say 'a' belongs to 0 and 1.
  • And if 'a' comes in front of 1, while using this operator then the result becomes 1 because 1 is powerful. Implies; (a | 1 = 1).
  • But if 'a' comes in front of 0, while using this operator then the result becomes 'a' as 0 is powerless. Implies; (a | 0 = a).
  • And since 'a' belongs to 0 and 1, implies;
  • Another way of memorizing this can be; if there is even one '1 bit' then the result will be 1 otherwise 0.
  • This operator is basically used for switching the bits on.
• Bitwise AND (&):
  • In 'and' operator 0 bit is powerful and 1 bit is powerless.
  • Let's say 'a' belongs to 0 and 1.
  • And if 'a' comes in front of 0, while using this operator then the result becomes 0 because 0 is powerful. Implies; (a | 0 = 0).
  • But if 'a' comes in front of 1, while using this operator then the result becomes 'a' as 1 is powerless. Implies; (a | 1 = a).
  • And since 'a' belongs to 0 and 1, implies;
  • Another way of memorizing this can be; if there is even one '0 bit' then the result will be 0 otherwise 1.
  • This operator is basically used for switching the bits off.
• Bitwise XOR (^):
  • This operator basically toggles the bits.
  • In the 'xor' operator 1 bit is powerful and 0 bit is powerless.
  • Let's say 'a' belongs to 0 and 1.
  • And if 'a' comes in front of 1, while using this operator then it toggles the bit. Implies; (a | 1 = ~a).
  • But if 'a' comes in front of 0, while using this operator then it is not capable to toggle the bit as 0 is powerless. Implies; (a | 0 = a).
  • And since 'a' belongs to 0 and 1, implies;
  • Another way of memorizing this can be; if both the bits are same then the result will be 0 and if both the bits are different then the result will be 1.
• Left Shift (<<):
  • If (x << n) then x represents a binary number and n represents an integer.
  • This operator discards the n number of leftmost bits from the binary number, x and adds n number of zeroes in the right of the rest of the x.
• Right Shift (>>):
  • If (x << n) then x represents a binary number and n represents an integer.
  • This operator discards the n number of rightmost bits from the binary number, x and adds n number of bits same as the most significant bit, in the left of the rest of the x.
• Zero Fill Right Shift (>>>):
  • If (x <<< n) then x represents a binary number and n represents an integer. This operator discards the n number of rightmost bits from the binary number, x and adds n number of zeroes in the left of x.

The question is that you have to:

• ON a bit
• OFF a bit
• TOGGLE a bit
• CHECK if the bit is on or off

• We use the OR operator to ON a bit (to set the bit to 1).
• You can be asked to ON a particular bit of a binary number at a certain position.
• To do so, we use a 'mask'; this mask has the same length as that of the given binary number and it stores 0 at all the positions except one where 1 is stored at the same position at which we want to on the bit in the given string.
• To get the mask; we make the use of the left shift operator in a binary number of 1.
• And on using OR operator between the given binary number and the mask; since 1 is powerful in OR, it will change the bit to 1. And as 0 is powerless, so no other bit gets affected.

• We use the AND operator to OFF a bit (to set the bit to 0).
• You can be asked to OFF a particular bit of a binary number at a certain position.
• To do so, we use a 'mask'; this mask has the same length as that of the given binary number and it stores 1 at all the positions except one where 0 is stored at the same position at which we want to off the bit in the given string.
• To get the mask; we make the use of the left shift operator in a binary number of 1. And then take the 1's complement of it using the toggle operator.
• And on using AND operator between the given binary number and the mask; since 0 is powerful in AND, it will change the bit to 0. And as 1 is powerless, so no other bit gets affected.

• We use the XOR operator to TOGGLE a bit (to change the bit).
• You can be asked to TOGGLE a particular bit of a binary number at a certain position.
• To do so, we use a 'mask'; this mask has the same length as that of the given binary number and it stores 0 at all the positions except one where 1 is stored at the same position at which we want to off the bit in the given string.
• To get the mask; we make the use of the left shift operator in a binary number of 1.
• And on using the XOR operator between the given binary number and the mask; since 1 is powerful in XOR, it will toggle the bit. And as 0 is powerless, so no other bit gets affected.

• We can either use 'AND' or 'OR' operator to check a bit.
• You can be asked to check a particular bit of a binary number at a certain position.
• To do so, we use a 'mask'; this mask has the same length as that of the given binary number and it stores 0 at all the positions except one where 1 is stored at the same position at which we want to off the bit in the given string.
• To get the mask; we make the use of the left shift operator in a binary number of 1.
• And on using the AND operator between the given binary number and the mask; since 0 is powerful in AND, it will change all the other bits to 0. And as 1 is powerless, so that particular bit does not get affected and therefore remains the same.
• After applying the operation, we check if the resultant of XOR between the mask and the number is 0 or non zero.
• If it is zero, it implies that the bit was zero and if the resultant is non-zero then it implies that the bit was one.

1. This is an on mask with 1 at ith position from left and 0 is present at rest of the position and we have achieved this using left shift by i positions.
2. This is an off mask with 0 at jth position from left and 1 is present at rest of the position we have achieved this using left shift by j positions. And then taking its complement using the (~) operator.
3. This is a toggle mask with 1 at kth position from left and 0 is present at the rest of the position and we have achieved this using left shift by k positions.
4. This is check mask with 1 at mth position from left and 0 is present at rest of the position and we have achieved this using left shift by m positions.
5. Now we print the result for setting the bit (ON) at i, using an 'OR' operator between the number and the on mask.
6. Now we print the result for setting the bit (OFF) at j, using an 'AND' operator between the number and the off mask.
7. Now we print the result for toggling the bit at k, using a 'XOR' operator between the number and the toggle mask.
8. Now we print the result for checking the bit at m, using an 'AND' operator between the number and the check mask.