Bitwise Operators Questions and Answers

Answer: A

The program prints z K S.

'P' is 80 = 0101 0000 and 'x' is 120 = 0111 1000 in binary.

• a & b = 0101 0000 = 80; adding '*' (42) gives 122, which is 'z'.
• a | b = 0111 1000 = 120; subtracting '-' (45) gives 75, which is 'K'.
• a ^ b = 0010 1000 = 40; adding '+' (43) gives 83, which is 'S'.

The format %c prints characters, not numbers, so '122 75 83' is the right values in the wrong form. '* - +' and 'P x +' ignore the bitwise operations and simply echo the operand characters.

Answer: B

Correct answer: 11

0xAB is 10101011 in binary, and 0x0F is 00001111. A mask of four low ones ANDed against a value keeps that value’s low four bits and zeroes everything above them:

  0xAB = 1 0 1 0 1 0 1 1
  0x0F = 0 0 0 0 1 1 1 1
  ---------------------
     & = 0 0 0 0 1 0 1 1

The result 00001011 is 0x0B, or 11 in decimal.

The shortcut worth learning is that one hexadecimal digit is exactly four bits, so masking with 0x0F simply keeps the last hex digit - the B of 0xAB, which is 11. By the same reasoning c >> 4 would give the other digit, 10. The distractor 171 is 0xAB itself, unmasked.

Answer: A

Correct answer: Yes

OR with a mask forces every position named by the mask to 1 and leaves the others as they were, and a mask may name any number of positions at once.

So item |= MOBILE | LAPPY sets both flags in a single operation. This is why OR is the natural operator for accumulating flags: each |= adds to the set without disturbing what is already there, and the operation is idempotent, so setting a bit that is already on changes nothing.

Answer: C

Correct answer: ffdf

Write 32 in the given width first:

\[ 32 = 0000\,0000\,0010\,0000_2 = \mathtt{0x0020} \]

~ inverts every bit:

\[ 1111\,1111\,1101\,1111_2 = \mathtt{0xffdf} \]

The quick check is that inverting a hex digit means subtracting it from f: 0 becomes f, 0 becomes f, 2 becomes d, 0 becomes f. The distractor ffff would be ~0, and the width matters - on a 4-byte int the answer would be ffffffdf.

Answer: B

Correct answer: True

The complement operator takes a single operand and inverts every one of its bits. The other bitwise operators - AND, OR, XOR and the two shifts - are all binary, taking an operand on each side.

Answer: B

Correct answer: 2

a >> 1 computes a value; it does not modify a. Only the compound form a >>= 1 would assign back.

So the test evaluates \( 2 \gg 1 = 1 \), which is non-zero and therefore true, and the printf then prints a - still 2, exactly as it was declared. The distractor 1 is the value of the shift expression, which is tested but never stored, and "No Output" would require the test to be false.

Answer: A

Correct answer: Yes

Setting a single bit is n |= (1 << k). The shift builds a mask with one 1 in position \( k \); OR forces that position to 1 and leaves every other bit unchanged, since \( b \mathbin{|} 0 = b \).

The three basic single-bit operations follow the same shape and differ only in the operator: OR with the mask to set, AND with its complement to clear, and XOR with the mask to toggle. Testing uses AND with the mask without storing the result.

Answer: D

Correct answer: -6

Complementing inverts every bit, and in two’s complement that is equivalent to \(\sim n = -(n+1)\).

\[\sim 5 = -(5+1) = -6\]

Checking with 8 bits: 5 is 00000101, its complement is 11111010, and that pattern read as a two’s complement number is -6.

Answer: A

Correct answer: 20

XOR keeps a 1 exactly where the two numbers differ:

  13 = 0 1 1 0 1
  25 = 1 1 0 0 1
  --------------
   ^  = 1 0 1 0 0

The first bits differ, so 1; the second are both 1, so 0; the third differ, so 1; the fourth are both 0, so 0; the fifth are both 1, so 0. The result 10100 is \( 16 + 4 = 20 \).

Two properties of XOR are worth carrying away. Applying it twice restores the original - \( (a \oplus b) \oplus b = a \) - which is why it appears in simple ciphers and in the swap-without-a-temporary trick. And \( a \oplus a = 0 \) for any value, which makes XOR the standard way to find the one unpaired element in a list where everything else appears twice.

Answer: B

Correct answer: False

Such a shift is undefined behaviour: the standard requires the shift count to be non-negative and less than the width of the promoted left operand. Different processors handle an oversized count differently, which is why no result is guaranteed.