Check if Number is Even or Odd Using Bits in DSA Rust - Build from Scratch

Check if Number is Even or Odd Using Bits

📖 Scenario: You are building a simple program to check if a number is even or odd using bit operations. This is like checking if a number is divisible by 2 without using division or modulus. It is useful in low-level programming and fast calculations.

🎯 Goal: Build a Rust program that uses bitwise AND to determine if a number is even or odd and prints the result.

📋 What You'll Learn

Create a variable called number with the value 29.

Create a variable called bit_mask with the value 1.

Use a bitwise AND operation between number and bit_mask to check if the number is even or odd.

Print "29 is odd" if the number is odd, otherwise print "29 is even".

💡 Why This Matters

🌍 Real World

Bitwise operations are used in embedded systems, game programming, and performance-critical code to quickly check properties like even or odd without slow division.

💼 Career

Understanding bitwise operations is important for low-level programming jobs, systems programming, and roles that require optimization and efficient code.

1

Create the number variable

Create a variable called number and set it to 29.

DSA Rust

# Create a variable called number and set it to 29
# Your code here

Hint

Use let number = 29; inside the main function.

2

Create the bit mask variable

Create a variable called bit_mask and set it to 1 inside the main function after number.

DSA Rust

fn main() {
    let number = 29;
    # Create a variable called bit_mask and set it to 1
    # Your code here
}

Hint

Use let bit_mask = 1; after defining number.

3

Check if number is even or odd using bitwise AND

Use an if statement with the condition (number & bit_mask) == 1 to check if the number is odd. Inside the main function, write this condition after defining bit_mask.

DSA Rust

fn main() {
    let number = 29;
    let bit_mask = 1;
    # Use if (number & bit_mask) == 1 to check odd
    # Your code here
}

Hint

Use if (number & bit_mask) == 1 to check odd, then print the correct message.

4

Print the result

Run the program to print the result of the even or odd check for number 29.

DSA Rust

fn main() {
    let number = 29;
    let bit_mask = 1;
    if (number & bit_mask) == 1 {
        println!("29 is odd");
    } else {
        println!("29 is even");
    }
    # Run the program to print the result
    # Your code here
}

Hint

The program should print 29 is odd because 29 is not divisible by 2.

Practice

1. What does the expression num & 1 check when determining if a number is even or odd?

easy

A. It checks the least significant bit of the number

B. It checks if the number is greater than 1

C. It divides the number by 2

D. It adds 1 to the number

Solution

1. Step 1: Understand bitwise AND operation

   The expression num & 1 performs a bitwise AND between the number and 1, which isolates the least significant bit (rightmost bit).

2. Step 2: Interpret the least significant bit

   If the least significant bit is 1, the number is odd; if it is 0, the number is even.

3. Final Answer:

   It checks the least significant bit of the number -> Option A

4. Quick Check:

   Least significant bit = odd/even check [OK]

Hint: Check last bit with & 1 to find odd or even fast [OK]

Common Mistakes:

• Thinking & 1 divides the number
• Confusing bitwise AND with addition
• Assuming it checks if number > 1

2. Which Rust code snippet correctly checks if a number n is odd using bitwise operations?

easy

A. if n ^ 1 == 1 { println!("Odd"); }

B. if n | 1 == 1 { println!("Odd"); }

C. if n & 0 == 1 { println!("Odd"); }

D. if n & 1 == 1 { println!("Odd"); }

Solution

1. Step 1: Identify correct bitwise operator for odd check

   The bitwise AND operator & with 1 isolates the least significant bit, which indicates oddness.

2. Step 2: Verify condition correctness

   Checking if n & 1 == 1 means the number is odd. Other operators like OR | or XOR ^ do not correctly check oddness.

3. Final Answer:

   if n & 1 == 1 { println!("Odd"); } -> Option D

4. Quick Check:

   Use & 1 == 1 to check odd [OK]

Hint: Use & 1 == 1 to check odd numbers in Rust [OK]

Common Mistakes:

• Using OR or XOR instead of AND
• Comparing with 0 instead of 1
• Using bitwise operators incorrectly

3. What will be the output of this Rust code?

let num = 14;
if num & 1 == 0 {
    println!("Even");
} else {
    println!("Odd");
}

medium

A. Even

B. Odd

C. 14

D. Compilation error

Solution

1. Step 1: Evaluate bitwise AND of 14 and 1

   Binary of 14 is 1110, and 1 is 0001. 1110 & 0001 = 0.

2. Step 2: Check condition and print output

   Since num & 1 == 0 is true, the code prints "Even".

3. Final Answer:

   Even -> Option A

4. Quick Check:

   14 & 1 = 0 means Even [OK]

Hint: If num & 1 equals 0, number is even [OK]

Common Mistakes:

• Assuming 14 is odd
• Confusing bitwise AND with arithmetic AND
• Expecting output to be the number itself

4. Identify the error in this Rust code snippet that checks if a number is odd:

let n = 7;
if n & 1 = 1 {
    println!("Odd");
} else {
    println!("Even");
}

medium

A. Using & instead of && in if condition

B. Missing semicolon after println!

C. Using single = instead of == in if condition

D. Variable n is not declared

Solution

1. Step 1: Check the if condition syntax

   The condition uses single equals = which is assignment, not comparison.

2. Step 2: Correct the comparison operator

   It should use double equals == to compare n & 1 with 1.

3. Final Answer:

   Using single = instead of == in if condition -> Option C

4. Quick Check:

   Use == for comparison, not = [OK]

Hint: Use == for comparison, not = assignment [OK]

Common Mistakes:

• Confusing assignment (=) with equality (==)
• Thinking & is logical AND instead of bitwise
• Ignoring compiler error messages

5. Given a list of integers nums = [2, 3, 4, 5, 6], which Rust code correctly uses bitwise operations to filter only odd numbers and print them?

hard

A. for num in nums.iter() {
if num & 0 == 1 {
println!("{}", num);
}
}

B. for &num in &nums {
if num & 1 == 1 {
println!("{}", num);
}
}

C. for num in nums {
if num | 1 == 1 {
println!("{}", num);
}
}

D. for num in nums {
if num ^ 1 == 1 {
println!("{}", num);
}
}

Solution

1. Step 1: Understand iteration and bitwise odd check

   Iterate over references to numbers and use num & 1 == 1 to check odd numbers.

2. Step 2: Verify correct syntax and logic

   for &num in &nums { if num & 1 == 1 { println!("{}", num); } } correctly iterates with for &num in &nums and checks oddness with bitwise AND. Other options misuse operators or iteration.

3. Final Answer:

   for &num in &nums { if num & 1 == 1 { println!("{}", num); } } -> Option B

4. Quick Check:

   Use & 1 == 1 inside loop over &nums [OK]

Hint: Iterate references and use & 1 == 1 to print odd numbers [OK]

Common Mistakes:

• Using wrong bitwise operators like | or ^
• Iterating without references causing ownership errors
• Checking with & 0 instead of & 1