Expression evaluation in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust expression?

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

Rust

fn main() {
    let x = 5;
    let y = 10;
    let result = x + y * 2 - 3;
    println!("{}", result);
}

A 19

B 22

C 27

D 24

💡 Hint

Remember the order of operations: multiplication before addition and subtraction.

The expression is evaluated as 5 + (10 * 2) - 3 = 5 + 20 - 3 = 22.

❓ Predict Output

intermediate

What is the value of variable `z` after this code runs?

Look at this Rust code. What value does `z` hold at the end?

Rust

fn main() {
    let x = 4;
    let y = 3;
    let z = (x + y) * (x - y);
    println!("{}", z);
}

A 21

B 1

C 7

D 0

💡 Hint

Calculate inside parentheses first, then multiply.

First, (4 + 3) = 7 and (4 - 3) = 1. Then multiply: 7 * 1 = 7.

❓ Predict Output

advanced

What does this Rust code print?

Analyze this Rust code and determine its output.

Rust

fn main() {
    let a = 10;
    let b = 3;
    let c = a / b * b + a % b;
    println!("{}", c);
}

A 10

B 9

C 12

D 13

💡 Hint

Remember integer division and remainder operations.

Integer division 10 / 3 = 3, then 3 * 3 = 9, plus remainder 10 % 3 = 1, total 10.

❓ Predict Output

advanced

What is the output of this Rust code with boolean expressions?

Check the output of this Rust program.

Rust

fn main() {
    let x = true;
    let y = false;
    let result = x && !y || y && !x;
    println!("{}", result);
}

A CompilationError

B false

C SyntaxError

D true

💡 Hint

Evaluate NOT first, then AND, then OR.

x && !y is true && true = true; y && !x is false && false = false; true || false = true.

❓ Predict Output

expert

What is the output of this Rust code involving mixed types and casting?

Analyze this Rust code and determine what it prints.

Rust

fn main() {
    let x: i32 = 7;
    let y: f64 = 2.5;
    let z = x as f64 * y;
    println!("{}", z);
}

A 17.5

B SyntaxError

C 15

D 12.5

💡 Hint

Casting changes types before multiplication. Check the order carefully.

x as f64 = 7.0, y = 2.5, so 7.0 * 2.5 = 17.5.

Practice

1. What does the following Rust expression do?
let result = 5 + 3 * 2;
Choose the correct description.

easy

A. Calculates 3 times 2, then adds 5

B. Multiplies 5 by 3, then adds 2

C. Calculates 5 plus 3, then multiplies by 2

D. Adds 5, 3, and 2 together

Solution

1. Step 1: Understand operator precedence in Rust

   Multiplication (*) has higher precedence than addition (+), so 3 * 2 is calculated first.

2. Step 2: Calculate the expression step-by-step

   3 * 2 = 6, then 5 + 6 = 11.

3. Final Answer:

   Calculates 3 times 2, then adds 5 -> Option A

4. Quick Check:

   5 + (3 * 2) = 11 [OK]

Hint: Remember multiplication before addition in expressions [OK]

Common Mistakes:

• Adding numbers left to right ignoring precedence
• Multiplying after addition
• Confusing operator precedence

2. Which of the following is the correct way to assign the result of 4 + 7 to a variable named sum in Rust?

easy

A. let sum : 4 + 7;

B. sum = let 4 + 7;

C. let sum = 4 + 7;

D. let sum == 4 + 7;

Solution

1. Step 1: Recall Rust variable assignment syntax

   In Rust, use let variable = expression; to assign a value.

2. Step 2: Check each option for correct syntax

   let sum = 4 + 7; uses correct syntax: let sum = 4 + 7;. Others have syntax errors.

3. Final Answer:

   let sum = 4 + 7; -> Option C

4. Quick Check:

   Correct Rust assignment syntax [OK]

Hint: Use 'let var = expression;' to assign values [OK]

Common Mistakes:

• Using '==' instead of '=' for assignment
• Placing 'let' after variable name
• Using ':' instead of '=' for assignment

3. What is the output of this Rust code?

fn main() {
    let x = 10;
    let y = 3;
    let result = x / y + x % y;
    println!("{}", result);
}

medium

A. 13

B. 3

C. 1

D. 4

Solution

1. Step 1: Calculate integer division and remainder

   10 / 3 = 3 (integer division), 10 % 3 = 1 (remainder).

2. Step 2: Add the results

   3 + 1 = 4.

3. Final Answer:

   4 -> Option D

4. Quick Check:

   10 / 3 + 10 % 3 = 4 [OK]

Hint: Remember integer division drops decimals, % gives remainder [OK]

Common Mistakes:

• Treating division as float division
• Confusing remainder with division result
• Adding operands incorrectly

4. Identify the error in this Rust code snippet:

fn main() {
    let a = 5;
    let b = 0;
    let c = a / b;
    println!("{}", c);
}

medium

A. Division by zero causes a runtime panic

B. Variable 'c' is not declared properly

C. Missing semicolon after 'let b = 0'

D. println! macro syntax is incorrect

Solution

1. Step 1: Analyze the division operation

   The code divides 'a' by 'b', where 'b' is zero.

2. Step 2: Understand Rust runtime behavior

   Dividing by zero in Rust causes a runtime panic (crash), not a compile error.

3. Final Answer:

   Division by zero causes a runtime panic -> Option A

4. Quick Check:

   Division by zero panics in Rust [OK]

Hint: Check for zero divisor before division to avoid panic [OK]

Common Mistakes:

• Thinking division by zero is a compile error
• Ignoring runtime panics
• Assuming variable declaration errors

5. Given a list of numbers, which Rust expression correctly calculates the sum of all even numbers?

let numbers = [1, 2, 3, 4, 5, 6];
let sum_even = /* fill here */;
println!("{}", sum_even);

Choose the correct expression to replace /* fill here */.

hard

A. numbers.iter().map(|x| x * 2).sum::<i32>()

B. numbers.iter().filter(|&&x| x % 2 == 0).sum::<i32>()

C. numbers.iter().filter(|&x| x % 2 != 0).sum::<i32>()

D. numbers.iter().sum::<i32>()

Solution

1. Step 1: Understand the goal

   We want to sum only even numbers from the list.

2. Step 2: Analyze each option

   numbers.iter().filter(|&&x| x % 2 == 0).sum::<i32>() filters even numbers (x % 2 == 0) and sums them. numbers.iter().map(|x| x * 2).sum::<i32>() doubles all numbers then sums (wrong). numbers.iter().filter(|&x| x % 2 != 0).sum::<i32>() sums odd numbers (wrong). numbers.iter().sum::<i32>() sums all numbers (wrong).

3. Final Answer:

   numbers.iter().filter(|&&x| x % 2 == 0).sum::<i32>() -> Option B

4. Quick Check:

   Filter evens then sum [OK]

Hint: Filter even numbers before summing with iterator methods [OK]

Common Mistakes:

• Summing all numbers without filtering
• Filtering odd numbers instead of even
• Mapping values incorrectly before sum