Assignment operators in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code using assignment operators?

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

Rust

fn main() {
    let mut x = 5;
    x += 3;
    x *= 2;
    println!("{}", x);
}

A 16

B 10

C 13

D 8

💡 Hint

Remember that += adds and assigns, and *= multiplies and assigns.

Starting with x = 5, x += 3 makes x = 8. Then x *= 2 makes x = 16. So the output is 16.

❓ Predict Output

intermediate

What value does variable y hold after this code?

Analyze the Rust code below and determine the final value of y.

Rust

fn main() {
    let mut y = 10;
    y -= 4;
    y /= 3;
    println!("{}", y);
}

A 3

B 2

C 1

D 0

💡 Hint

Integer division truncates towards zero in Rust.

Starting with y = 10, y -= 4 makes y = 6. Then y /= 3 divides 6 by 3, resulting in 2.

❓ Predict Output

advanced

What is printed by this Rust code using bitwise assignment operators?

Look at the Rust code below. What will it print?

Rust

fn main() {
    let mut z = 0b1100u8; // binary 12
    z &= 0b1010; // binary 10
    z |= 0b0101; // binary 5
    println!("{:b}", z);
}

A 1101

B 1000

C 1111

D 1010

💡 Hint

Apply bitwise AND then OR step by step on the binary numbers.

Start: z = 1100 (12)
After z &= 1010: z = 1000 (8)
After z |= 0101: z = 1101 (13)
Printed in binary: 1101

❓ Predict Output

advanced

What error does this Rust code produce?

Examine the Rust code below. What error will it cause when compiled?

Rust

fn main() {
    let x = 5;
    x += 1;
    println!("{}", x);
}

A no error, prints 6

B error: expected `;` after expression

C error: mismatched types

D error: cannot assign twice to immutable variable `x`

💡 Hint

Variables are immutable by default in Rust unless declared mut.

The variable x is not mutable, so x += 1 causes a compile-time error about assigning to an immutable variable.

🧠 Conceptual

expert

How many times is the variable a updated in this Rust code?

Consider the following Rust code snippet. How many times is the variable a updated (assigned a new value) during execution?

Rust

fn main() {
    let mut a = 1;
    a += 2;
    a *= 3;
    a -= 4;
    a /= 2;
    a %= 3;
    println!("{}", a);
}

A 5

B 4

C 6

D 7

💡 Hint

Count each assignment operator usage as one update.

The variable a is initialized once, then updated 5 times by the assignment operators: +=, *=, -=, /=, and %=. Each counts as one update.

Practice

1. What does the Rust assignment operator += do?

easy

A. Subtracts the right value from the left variable and stores the result in the variable

B. Adds the right value to the left variable and stores the result in the variable

C. Multiplies the right value with the left variable and stores the result in the variable

D. Divides the left variable by the right value and stores the result in the variable

Solution

1. Step 1: Understand the += operator

   The += operator adds the right-hand side value to the left-hand side variable.

2. Step 2: Effect on the variable

   The result of the addition is stored back into the same variable, updating its value.

3. Final Answer:

   Adds the right value to the left variable and stores the result in the variable -> Option B

4. Quick Check:

   += means add and assign [OK]

Hint: Think: add then store back in the same variable [OK]

Common Mistakes:

• Confusing += with subtraction or multiplication
• Forgetting that the variable must be mutable
• Thinking it creates a new variable instead of updating

2. Which of the following is the correct way to use the *= operator in Rust?

easy

A. let x = 5; x *= 2;

B. let mut x = 5; *= x 2;

C. let x = 5; mut x *= 2;

D. let mut x = 5; x *= 2;

Solution

1. Step 1: Check variable mutability

   In Rust, to change a variable's value, it must be declared with mut. So let mut x = 5; is correct.

2. Step 2: Correct operator usage

   The operator *= is used as x *= 2; to multiply and assign.

3. Final Answer:

   let mut x = 5; x *= 2; -> Option D

4. Quick Check:

   Mutable variable + operator syntax = correct [OK]

Hint: Declare variable mutable before using assignment operators [OK]

Common Mistakes:

• Not declaring variable as mutable
• Placing mut in wrong position
• Incorrect operator syntax like *= x 2

3. What is the output of the following Rust code?

let mut a = 10;
a += 5;
a *= 2;
println!("{}", a);

medium

A. 30

B. 25

C. 20

D. 15

Solution

1. Step 1: Perform a += 5;

   Starting with a = 10, adding 5 gives a = 15.

2. Step 2: Perform a *= 2;

   Multiplying 15 by 2 updates a = 30.

3. Final Answer:

   30 -> Option A

4. Quick Check:

   10 + 5 = 15; 15 * 2 = 30 [OK]

Hint: Calculate step-by-step updates to variable [OK]

Common Mistakes:

• Adding and multiplying in wrong order
• Forgetting variable is mutable
• Misreading operator effects

4. Identify the error in this Rust code snippet:

let x = 8;
x -= 3;
println!("{}", x);

medium

A. The println! macro is used incorrectly

B. The operator -= is not valid in Rust

C. Variable x is not mutable but is modified

D. Missing semicolon after println!

Solution

1. Step 1: Check variable mutability

   The variable x is declared without mut, so it is immutable.

2. Step 2: Check assignment operator usage

   The operator -= tries to subtract and assign a new value to x, which is not allowed for immutable variables.

3. Final Answer:

   Variable x is not mutable but is modified -> Option C

4. Quick Check:

   Immutable variable cannot be changed [OK]

Hint: Mutable variables needed for assignment operators [OK]

Common Mistakes:

• Assuming all variables are mutable by default
• Thinking operator syntax is wrong
• Ignoring Rust's immutability rules

5. Given the code below, what is the final value of result?

let mut result = 50;
let change = 7;
result %= change;
result += 3;
result *= 4;

hard

A. 16

B. 12

C. 28

D. 14

Solution

1. Step 1: Calculate result %= change;

   50 % 7 equals 1 because 7 * 7 = 49 and remainder is 1, so result = 1.

2. Step 2: Calculate result += 3;

   Add 3 to 1 gives result = 4.

3. Step 3: Calculate result *= 4;

   Multiply 4 by 4 gives result = 16.

4. Final Answer:

   16 -> Option A

5. Quick Check:

   50 % 7 = 1; 1 + 3 = 4; 4 * 4 = 16 [OK]

Hint: Apply each operator stepwise carefully [OK]

Common Mistakes:

• Miscomputing modulus operation
• Skipping steps or doing operations out of order
• Choosing wrong multiplication result