Why variables are needed in Rust - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a variable named x with the value 5.

Rust

let [1] = 5;

Drag options to blanks, or click blank then click option'

Avar

B5

Clet

Dx

Attempts:

3 left

💡 Hint

Common Mistakes

Using a number instead of a variable name.

Trying to use var which is not Rust syntax.

In Rust, let declares a variable. Here, x is the variable name.

2fill in blank

medium

Complete the code to print the value of the variable y.

Rust

println!("The value is: {}", [1]);

Drag options to blanks, or click blank then click option'

A"y"

By

Cprintln!

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Putting the variable name in quotes, which prints the word, not the value.

Using a wrong identifier.

To print the value of a variable, use its name without quotes.

3fill in blank

hard

Fix the error by completing the code to make the variable mutable.

Rust

let [1] counter = 0;

Drag options to blanks, or click blank then click option'

Amut

Bis

Clet

Dvar

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to use var which is not Rust syntax.

Putting mut in the wrong place.

In Rust, mut makes a variable mutable so its value can change.

4fill in blank

hard

Fill both blanks to declare a mutable variable score with value 10 and then increase it by 5.

Rust

let [1] score = 10;
score [2] 5;

Drag options to blanks, or click blank then click option'

Amut

B+=

C=

Dlet

Attempts:

3 left

💡 Hint

Common Mistakes

Using = instead of += which replaces the value.

Not making the variable mutable before changing it.

Use mut to make score mutable and += to add 5 to it.

5fill in blank

hard

Fill all three blanks to declare a variable name with value "Alice", print it, and then change it to "Bob".

Rust

let [1] name = "Alice";
println!("Name: {}", [2]);
name [3] "Bob";

Drag options to blanks, or click blank then click option'

Amut

Bname

C=

Dlet

Attempts:

3 left

💡 Hint

Common Mistakes

Not making the variable mutable before changing it.

Using quotes around the variable name when printing.

Using the wrong operator to change the value.

Make name mutable with mut, print it by its name, and assign a new value with =.

Practice

1. Why do we need variables in Rust programming?

easy

A. To make the program run faster

B. To store data with a name for later use

C. To avoid writing code

D. To create errors intentionally

Solution

1. Step 1: Understand the purpose of variables

   Variables hold data so we can use or change it later in the program.

2. Step 2: Compare options with this purpose

   Only To store data with a name for later use correctly states that variables store data with a name for later use.

3. Final Answer:

   To store data with a name for later use -> Option B

4. Quick Check:

   Variables store data = A [OK]

Hint: Variables hold data to use later in code [OK]

Common Mistakes:

• Thinking variables speed up the program
• Believing variables are for creating errors
• Confusing variables with shortcuts to avoid coding

2. Which of the following is the correct way to declare a variable named score with value 10 in Rust?

easy

A. let score = 10;

B. var score = 10;

C. score := 10;

D. int score = 10;

Solution

1. Step 1: Recall Rust variable declaration syntax

   Rust uses let keyword to declare variables.

2. Step 2: Check each option

   let score = 10; uses let score = 10; which is correct Rust syntax. Others use syntax from other languages.

3. Final Answer:

   let score = 10; -> Option A

4. Quick Check:

   Rust variable declaration = let [OK]

Hint: Use 'let' to declare variables in Rust [OK]

Common Mistakes:

• Using 'var' instead of 'let'
• Using ':=' which is Go syntax
• Using type declarations like in C or Java

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

let mut count = 5;
count = count + 3;
println!("{}", count);

medium

A. Error: cannot assign to immutable variable

B. 5

C. 8

D. 3

Solution

1. Step 1: Understand variable mutability

   The variable count is declared with mut, so it can be changed.

2. Step 2: Calculate the new value

   Initial value is 5, then 3 is added, so count becomes 8.

3. Final Answer:

   8 -> Option C

4. Quick Check:

   5 + 3 = 8 [OK]

Hint: Use 'mut' to change variable values [OK]

Common Mistakes:

• Forgetting 'mut' causes error on assignment
• Assuming variable stays 5 without change
• Confusing output with the added number only

4. Identify the error in this Rust code snippet:

let x = 10;
x = 20;
println!("{}", x);

medium

A. Cannot assign to immutable variable x

B. Missing semicolon after first line

C. println! macro syntax is wrong

D. Variable x is not declared

Solution

1. Step 1: Check variable mutability

   Variable x is declared without mut, so it is immutable.

2. Step 2: Identify assignment error

   Trying to assign 20 to x causes an error because x cannot be changed.

3. Final Answer:

   Cannot assign to immutable variable x -> Option A

4. Quick Check:

   Immutable variable reassignment = error [OK]

Hint: Add 'mut' to variable to allow reassignment [OK]

Common Mistakes:

• Ignoring mut keyword requirement
• Thinking semicolon is missing
• Assuming println! syntax is incorrect

5. You want to keep track of a user's score that changes during the game. Which Rust code correctly declares this variable so you can update it later?

1. let score = 0;
2. let mut score = 0;
3. var score = 0;
4. const score = 0;

hard

A. Line 1 only

B. Lines 3 and 4

C. Lines 1 and 4

D. Line 2 only

Solution

1. Step 1: Understand mutability for changing values

   To update a variable, it must be declared with mut in Rust.

2. Step 2: Analyze each line

   Line 2 uses let mut score = 0; which allows updates. Line 1 is immutable, line 3 uses invalid syntax, line 4 is constant and cannot change.

3. Final Answer:

   Line 2 only -> Option D

4. Quick Check:

   Use 'let mut' for changeable variables [OK]

Hint: Use 'let mut' for variables that change [OK]

Common Mistakes:

• Using 'let' without 'mut' for changeable data
• Confusing 'const' with mutable variable
• Using 'var' which is not Rust syntax