Bitwise Operators Questions and Answers

Answer: A

Correct answer: True

This is the standard bit test. Build a mask with a single 1 in the position of interest, usually as 1 << k, and AND it with the value: n & (1 << k) is non-zero when the bit is set and zero when it is clear.

Note that the non-zero result is \( 2^k \), not 1, so the expression should be tested against zero rather than compared with 1. AND is the natural operator for the job because it forces every unselected position to zero, leaving only the bit being examined.

Answer: D

Correct answer: 0

The macro machinery is a distraction: M(P) expands to a main containing the printf, so the whole program reduces to printing -1 ^ ~0.

Now the arithmetic. ~0 inverts every bit of zero, giving all ones, which as a signed int is \( -1 \). So the expression is -1 ^ -1, and XOR of any value with itself is zero, since no bit position differs from itself. The answer is 0 regardless of the width of an int, which is what makes the identity \( x \mathbin{\hat{}} x = 0 \) worth knowing.

Answer: A

Correct answer: 1

^ is the bitwise exclusive OR, not exponentiation - C has no exponentiation operator. Work in binary:

\[ 2 = 10_2 \qquad 3 = 11_2 \]

XOR sets each result bit where the two input bits differ. The high bits are both 1, so that bit is 0; the low bits are 0 and 1, so that bit is 1. The result is \( 01_2 = 1 \). The distractor 9 is what \( 2^3 \) would give if ^ meant a power, and 7 is what | would give.

Answer: D

Correct answer: 8

^ is bitwise XOR, not exponentiation - C has no exponentiation operator, and pow() from math.h is what would compute \( 10^2 \).

In binary:

\[ 10 = 1010_2 \qquad 2 = 0010_2 \]

XOR sets a result bit where the inputs differ. They differ only in the fourth position, giving \( 1000_2 = 8 \). Reading ^ as a power would give 100, which is not even among the options - the distractors instead cluster around the correct answer to catch arithmetic slips.

Answer: A

Correct answer: 13

Work through the mask. 0x0f is \( 1111_2 \) and 0x02 is \( 0010_2 \), so ~0x02 is ...11111101 - every bit set except bit 1.

AND then clears exactly that bit and leaves the others: \( 1111_2 \mathbin{\&} 1101_2 = 1101_2 = 13 \). This is the clear-a-bit idiom, flag &= ~mask. The distractor d is the same value in hexadecimal, which %d does not print - it prints the decimal 13.

Answer: A

Correct answer: True

For unsigned types the arithmetic is defined to wrap modulo \( 2^n \), so a left shift by one is exactly a multiplication by two with any overflow discarded rather than undefined.

That is the whole difference from the signed case, where shifting a value whose significant bits reach the sign position is undefined behaviour. The char in the question is promoted to int before the shift, so the operation happens in a wider type; the guarantee is what makes shift-based multiplication safe on unsigned values and unsafe on signed ones.

Answer: A

Correct answer: Multiplication and Division

Each position in a binary number carries twice the weight of the one to its right, so moving every bit one place left doubles the value and moving it one place right halves it:

\[ n \ll k = n \times 2^{k} \qquad n \gg k = n \div 2^{k} \]

Two cautions attach. The right shift truncates towards zero for unsigned values, discarding the bits shifted out, so it is integer division. And the left shift is a reliable multiplication only for unsigned types, since a signed overflow is undefined behaviour.

Answer: D

Correct answer: &&

&& is the logical AND. It treats each operand as a whole truth value, yields only 0 or 1, and short-circuits - the right operand is not evaluated if the left already settles the result.

The other three are bitwise: & and | combine operands position by position, and << moves bits left. The single-character and doubled forms are the classic confusion: 4 & 8 is 0 because the numbers share no bits, while 4 && 8 is 1 because both are non-zero.

Answer: B

Correct answer: No

Multiplication by a power of two is the left shift's job: n << k multiplies by \( 2^k \).

OR cannot do it, because it only ever sets bits and never moves them. It happens to look like addition when the operands have no bits in common - \( 4 \mathbin{|} 8 = 12 \) is also \( 4 + 8 \) - but that coincidence fails the moment any position overlaps, since there is no carry: \( 3 \mathbin{|} 1 = 3 \) where \( 3 + 1 = 4 \).

Answer: B

Correct answer: I have purchased ...:Mobile, Lappy

This is the flags idiom in full. MOBILE is 0x01 and LAPPY is 0x02 - different bit positions, which is what makes them independently storable in one byte.

The two |= operations set both bits, leaving item at 0x03. Each if then tests one bit with AND, and both tests are non-zero, so both strings print. Note that if uses each test as a truth value, so the results 0x01 and 0x02 both count as true despite being different numbers.