What is Rust - Practice Questions & Exercises

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the main focus of Rust?

Rust is a programming language designed with a special focus. What is its main focus?

A Primarily for web page styling

B Dynamic typing and rapid prototyping

C Automatic memory management with garbage collection

D Memory safety without using a garbage collector

💡 Hint

Think about how Rust handles memory compared to languages like Java or Python.

Rust focuses on memory safety without a garbage collector by using ownership and borrowing rules.

❓ Predict Output

intermediate

What is the output of this Rust code?

Look at this Rust code snippet. What will it print?

Rust

fn main() {
    let x = 5;
    let y = &x;
    println!("{}", y);
}

A 5

B Compilation error

C Memory address of x

D x

💡 Hint

Remember that &x is a reference to x, and println! with {} prints the value.

The code prints the value 5 because y is a reference to x, and println! dereferences it automatically.

❓ Predict Output

advanced

What error does this Rust code produce?

What error will this Rust code cause when compiled?

Rust

fn main() {
    let mut s = String::from("hello");
    let r1 = &s;
    let r2 = &s;
    let r3 = &mut s;
    println!("{} {} {}", r1, r2, r3);
}

A Syntax error: missing semicolon

B Cannot borrow `s` as mutable because it is also borrowed as immutable

C No error, prints: hello hello hello

D Use of moved value `s`

💡 Hint

Rust does not allow mutable and immutable references at the same time.

The code tries to borrow `s` as mutable while immutable references exist, which Rust forbids.

🚀 Application

advanced

How does Rust ensure thread safety?

Rust uses a special system to ensure safe access to data across threads. What is this system called?

A Garbage collection with locks

B Manual memory management with pointers

C Ownership and borrowing rules enforced at compile time

D Dynamic typing with runtime checks

💡 Hint

Think about how Rust prevents data races without runtime overhead.

Rust uses ownership and borrowing rules checked at compile time to prevent data races and ensure thread safety.

🧠 Conceptual

expert

What is the role of the Rust compiler's borrow checker?

What does the borrow checker in Rust do?

A It enforces rules about references to prevent invalid memory access at compile time

B It manages garbage collection automatically during runtime

C It optimizes code for faster execution by reordering instructions

D It converts Rust code into machine code without checks

💡 Hint

Consider how Rust prevents bugs related to references before the program runs.

The borrow checker enforces ownership and borrowing rules at compile time to prevent invalid memory access.

Practice

1. What is Rust primarily known for?

easy

A. A fast and safe programming language

B. A type of database

C. A web browser

D. A mobile operating system

Solution

1. Step 1: Understand Rust's main features

   Rust is designed to be fast and safe, focusing on preventing bugs.

2. Step 2: Compare options with Rust's purpose

   Only A fast and safe programming language describes Rust as a fast and safe programming language.

3. Final Answer:

   A fast and safe programming language -> Option A

4. Quick Check:

   Rust = fast and safe language [OK]

Hint: Rust is a language, not software or hardware [OK]

Common Mistakes:

• Confusing Rust with a database
• Thinking Rust is a browser
• Mixing Rust with operating systems

2. Which of the following is the correct way to declare a variable in Rust?

easy

A. int x = 5;

B. var x = 5;

C. let x = 5;

D. x := 5;

Solution

1. Step 1: Recall Rust variable declaration syntax

   Rust uses the keyword let to declare variables.

2. Step 2: Check each option

   Only let x = 5; uses let correctly; others use syntax from other languages.

3. Final Answer:

   let x = 5; -> Option C

4. Quick Check:

   Rust variables start with let [OK]

Hint: Rust uses 'let' to declare variables [OK]

Common Mistakes:

• Using var instead of let
• Using type declarations like int
• Using := which is Go syntax

3. What will the following Rust code print?

fn main() {
    let x = 10;
    let y = 20;
    println!("{}", x + y);
}

medium

A. 1020

B. Compilation error

C. x + y

D. 30

Solution

1. Step 1: Understand the code operations

   Variables x and y hold 10 and 20. The code adds them: 10 + 20 = 30.

2. Step 2: Check the print statement

   The println! macro prints the sum as a number, not concatenated strings.

3. Final Answer:

   30 -> Option D

4. Quick Check:

   10 + 20 = 30 [OK]

Hint: Add numbers inside println! to get output [OK]

Common Mistakes:

• Thinking + concatenates strings
• Expecting variable names printed
• Assuming syntax error

4. Identify the error in this Rust code:

fn main() {
    let mut x = 5;
    x = "hello";
    println!("{}", x);
}

medium

A. Cannot assign a string to an integer variable

B. Missing semicolon after println!

C. Variable x should not be mutable

D. println! macro syntax is incorrect

Solution

1. Step 1: Analyze variable type and assignment

   Variable x is initially an integer (5). Later, it is assigned a string "hello" which is invalid.

2. Step 2: Check other syntax elements

   Semicolons and println! syntax are correct; mutability is allowed but types must match.

3. Final Answer:

   Cannot assign a string to an integer variable -> Option A

4. Quick Check:

   Type mismatch error = Cannot assign a string to an integer variable [OK]

Hint: Variable types cannot change after declaration [OK]

Common Mistakes:

• Ignoring type mismatch
• Thinking mut allows any type
• Assuming println! needs semicolon fix

5. You want to write a Rust program that safely handles user input and prevents bugs before running. Which feature of Rust helps achieve this?

hard

A. Garbage collection like Java

B. Ownership and borrowing system

C. Dynamic typing for flexibility

D. Automatic memory allocation without checks

Solution

1. Step 1: Understand Rust's safety features

   Rust uses ownership and borrowing rules to manage memory safely at compile time.

2. Step 2: Compare with other options

   Rust does not use garbage collection or dynamic typing; it enforces strict checks before running.

3. Final Answer:

   Ownership and borrowing system -> Option B

4. Quick Check:

   Rust safety = ownership and borrowing [OK]

Hint: Rust's safety comes from ownership rules [OK]

Common Mistakes:

• Confusing Rust with garbage collected languages
• Thinking Rust is dynamically typed
• Ignoring ownership concept