Bitwise operators in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this bitwise AND operation?

Consider the following Rust code snippet. What will it print?

Rust

fn main() {
    let a: u8 = 0b1100_1010;
    let b: u8 = 0b1010_1100;
    println!("{:08b}", a & b);
}

A 10000000

B 10001000

C 00000000

D 11111111

💡 Hint

Bitwise AND compares each bit of two numbers and returns 1 only if both bits are 1.

The bitwise AND of 0b11001010 and 0b10101100 results in 0b10001000 because only bits in positions 7 and 3 are both 1.

❓ Predict Output

intermediate

What is the output of this bitwise OR operation?

Look at this Rust code. What will it print?

Rust

fn main() {
    let x: u8 = 0b0101_0101;
    let y: u8 = 0b0011_1100;
    println!("{:08b}", x | y);
}

A 00111100

B 01111001

C 01111101

D 01010101

💡 Hint

Bitwise OR returns 1 if either bit is 1.

The OR of 0b01010101 and 0b00111100 is 0b01111101 because any bit set in either number becomes 1.

❓ Predict Output

advanced

What is the output of this bitwise XOR operation?

Analyze this Rust code and determine the output.

Rust

fn main() {
    let p: u8 = 0b11110000;
    let q: u8 = 0b10101010;
    println!("{:08b}", p ^ q);
}

A 00000000

B 01010010

C 11111010

D 01011010

💡 Hint

Bitwise XOR returns 1 only if bits differ.

XOR of 0b11110000 and 0b10101010 is 0b01011010 because bits differ in positions 6,4,3,1.

❓ Predict Output

advanced

What is the output after left shifting?

What will this Rust program print?

Rust

fn main() {
    let num: u8 = 0b0001_1110;
    let shifted = num << 3;
    println!("{:08b}", shifted);
}

A 11110000

B 00011110

C 11100000

D 00000000

💡 Hint

Left shift moves bits to the left, adding zeros on the right.

Shifting 0b00011110 left by 3 moves bits three places left, resulting in 0b11100000.

❓ Predict Output

expert

What is the output after combining bitwise NOT and AND?

Examine this Rust code and find the output.

Rust

fn main() {
    let a: u8 = 0b1010_1010;
    let b: u8 = 0b1100_1100;
    let result = (!a) & b;
    println!("{:08b}", result);
}

A 01000100

B 00110011

C 01010101

D 10101010

💡 Hint

Bitwise NOT flips all bits; then AND with b keeps only bits set in both.

NOT of 0b10101010 is 0b01010101; AND with 0b11001100 results in 0b01000100.

Practice

1. Which bitwise operator in Rust returns 1 only if both bits are 1?
Example: 5 & 3

easy

A. AND (&)

B. OR (|)

C. XOR (^)

D. NOT (!)

Solution

1. Step 1: Understand the AND operator

   The AND operator (&) compares each bit of two numbers and returns 1 only if both bits are 1.

2. Step 2: Compare with other operators

   OR (|) returns 1 if either bit is 1, XOR (^) returns 1 if bits differ, NOT (!) flips bits.

3. Final Answer:

   AND (&) -> Option A

4. Quick Check:

   AND returns 1 only if both bits are 1 [OK]

Hint: AND is the only operator needing both bits as 1 [OK]

Common Mistakes:

• Confusing AND with OR which returns 1 if either bit is 1
• Thinking XOR returns 1 if both bits are 1
• Using NOT (!) as a binary operator instead of unary

2. Which of the following is the correct syntax for a bitwise XOR operation in Rust between variables a and b?

easy

A. a ! b

B. a & b

C. a | b

D. a ^ b

Solution

1. Step 1: Recall XOR operator symbol

   In Rust, the bitwise XOR operator is represented by the caret symbol (^).

2. Step 2: Check other operators

   & is AND, | is OR, and ! is unary NOT, so only a ^ b is correct for XOR.

3. Final Answer:

   a ^ b -> Option D

4. Quick Check:

   XOR uses ^ symbol in Rust [OK]

Hint: XOR uses ^ symbol, not & or | [OK]

Common Mistakes:

• Using & or | instead of ^ for XOR
• Trying to use ! as a binary operator
• Confusing syntax with other languages

3. What is the output of this Rust code?

let x = 0b1010;  // binary 10
let y = 0b1100;  // binary 12
let result = x | y;
println!("{:04b}", result);

medium

A. 1000

B. 1110

C. 0110

D. 1010

Solution

1. Step 1: Convert binary to bits and apply OR

   x = 1010, y = 1100. OR (|) returns 1 if either bit is 1. 1010 | 1100 = 1110

2. Step 2: Print result in 4-bit binary

   Result is 1110 in binary, which matches 1110.

3. Final Answer:

   1110 -> Option B

4. Quick Check:

   Bitwise OR of 1010 and 1100 = 1110 [OK]

Hint: OR sets bits where either input bit is 1 [OK]

Common Mistakes:

• Mixing up OR with AND results
• Reading binary digits incorrectly
• Forgetting to print in binary format

4. Identify the error in this Rust code snippet:

let a = 0b1010;
let b = 0b0101;
let c = a && b;
println!("{}", c);

medium

A. Incorrect binary literal syntax

B. Missing semicolon after let b

C. Using && instead of & for bitwise AND

D. println! macro missing format specifier

Solution

1. Step 1: Check operator usage

   The code uses && which is a logical AND, not bitwise AND. Bitwise AND uses &.

2. Step 2: Verify other syntax

   Semicolons are present, binary literals are correct, and println! has a format specifier, so no errors there.

3. Final Answer:

   Using && instead of & for bitwise AND -> Option C

4. Quick Check:

   Bitwise AND uses & not && [OK]

Hint: Use & for bitwise AND, && is logical AND [OK]

Common Mistakes:

• Confusing logical AND (&&) with bitwise AND (&)
• Assuming binary literals need prefix changes
• Missing format specifier in println! macro

5. Given a number n, which Rust expression flips (toggles) the 3rd bit (counting from 0) of n using bitwise operators?

hard

A. n ^ (1 << 3)

B. n & (1 << 3)

C. n | (1 << 3)

D. ~n & (1 << 3)

Solution

1. Step 1: Understand bit flipping with XOR

   XOR (^) with 1 flips the bit: if bit is 0 it becomes 1, if 1 it becomes 0. Shifting 1 by 3 sets the mask for the 3rd bit.

2. Step 2: Analyze other options

   & with mask clears bits except the 3rd bit, | sets the 3rd bit to 1, ~n & mask is unrelated to flipping a single bit.

3. Final Answer:

   n ^ (1 << 3) -> Option A

4. Quick Check:

   XOR with bit mask flips that bit [OK]

Hint: XOR with 1 at bit position flips that bit [OK]

Common Mistakes:

• Using & or | which clear or set bits instead of flipping
• Confusing ~ (NOT) usage
• Not shifting 1 to correct bit position