Option enum usage in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code using Option?

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

Rust

fn main() {
    let x: Option<i32> = Some(10);
    let y: Option<i32> = None;
    println!("{}", x.unwrap_or(5) + y.unwrap_or(3));
}

A 8

B 10

C None

D 13

💡 Hint

Remember unwrap_or returns the value inside Some or the default if None.

x.unwrap_or(5) returns 10 because x is Some(10). y.unwrap_or(3) returns 3 because y is None. Their sum is 13.

❓ Predict Output

intermediate

What does this Rust code print when matching Option?

Look at this Rust code using match with Option. What is printed?

Rust

fn main() {
    let val = Some("hello");
    match val {
        Some(s) if s.len() > 3 => println!("Long: {}", s),
        Some(s) => println!("Short: {}", s),
        None => println!("No value"),
    }
}

A Long: hello

B Short: hello

C No value

D Compilation error

💡 Hint

Check the length of the string inside Some and the if guard.

The string "hello" has length 5, which is greater than 3, so the first arm matches and prints "Long: hello".

🔧 Debug

advanced

What error does this Rust code produce?

This Rust code tries to unwrap an Option. What error will it cause when run?

Rust

fn main() {
    let val: Option<i32> = None;
    println!("{}", val.unwrap());
}

A panic at 'called `Option::unwrap()` on a `None` value'

B Prints 0

C Compilation error: cannot unwrap None

D Prints None

💡 Hint

unwrap on None causes a runtime panic, not a compile error.

Calling unwrap on None causes a panic at runtime with the message 'called `Option::unwrap()` on a `None` value'.

🧠 Conceptual

advanced

How many items are in the resulting vector after filtering Options?

Given this Rust code, how many elements does the vector 'numbers' contain after filtering?

Rust

fn main() {
    let values = vec![Some(1), None, Some(3), Some(5), None];
    let numbers: Vec<i32> = values.into_iter().filter_map(|x| x).collect();
    println!("{}", numbers.len());
}

A 5

B 2

C 3

D 0

💡 Hint

filter_map removes None and unwraps Some values.

There are three Some values in the vector, so after filtering, numbers has length 3.

❓ Predict Output

expert

What is the output of this nested Option handling code?

Analyze this Rust code with nested Options and unwrap_or_else. What does it print?

Rust

fn main() {
    let a: Option<Option<i32>> = Some(None);
    let result = a.unwrap_or_else(|| Some(10)).unwrap_or(20);
    println!("{}", result);
}

A 10

B 20

C None

D Compilation error

💡 Hint

unwrap_or_else returns the inner Option or default; then unwrap_or unwraps inner Option or default.

a is Some(None), so unwrap_or_else returns None (the inner Option). Then unwrap_or(20) returns 20 because inner Option is None.

Practice

1. What does the Option enum represent in Rust?

easy

A. A way to handle errors explicitly.

B. A value that can be either something (Some) or nothing (None).

C. A type of loop in Rust.

D. A macro for printing output.

Solution

1. Step 1: Understand the purpose of Option enum

   The Option enum is used to represent a value that might be present or absent.

2. Step 2: Match the description to the correct option

   A value that can be either something (Some) or nothing (None). correctly describes Option as either Some(value) or None, representing presence or absence.

3. Final Answer:

   A value that can be either something (Some) or nothing (None). -> Option B

4. Quick Check:

   Option enum = Some or None [OK]

Hint: Option means value or no value, like a yes/no box [OK]

Common Mistakes:

• Confusing Option with error handling Result type
• Thinking Option is a loop or macro
• Assuming Option always contains a value

2. Which of the following is the correct way to create an Option containing the integer 5?

easy

A. let x = Some(5);

B. let x = Option(5);

C. let x = Some[5];

D. let x = Option::new(5);

Solution

1. Step 1: Recall the syntax for creating an Option with a value

   In Rust, Some(value) wraps a value inside an Option.

2. Step 2: Identify the correct syntax among options

   let x = Some(5); uses Some(5), which is the correct syntax. Others are invalid or do not exist.

3. Final Answer:

   let x = Some(5); -> Option A

4. Quick Check:

   Use Some(value) to create Option with value [OK]

Hint: Use Some(value) to wrap a value in Option [OK]

Common Mistakes:

• Using Option(5) instead of Some(5)
• Using square brackets instead of parentheses
• Trying to call Option::new which doesn't exist

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

let x: Option<i32> = Some(10);
match x {
    Some(val) if val > 5 => println!("Greater than 5: {}", val),
    Some(val) => println!("Value: {}", val),
    None => println!("No value"),
}

medium

A. Value: 10

B. No value

C. Greater than 5: 10

D. Compilation error

Solution

1. Step 1: Analyze the Option value and match arms

   The variable x is Some(10). The match checks if val > 5 first.

2. Step 2: Determine which match arm runs

   Since 10 > 5, the first arm runs, printing "Greater than 5: 10".

3. Final Answer:

   Greater than 5: 10 -> Option C

4. Quick Check:

   Some(10) with val > 5 prints "Greater than 5: 10" [OK]

Hint: Match with if guards runs first matching condition [OK]

Common Mistakes:

• Ignoring the if guard and picking second arm
• Thinking None arm runs for Some value
• Assuming compilation error due to if guard

4. Identify the error in this Rust code snippet using Option:

let x: Option<i32> = None;
let y = x.unwrap();
println!("Value: {}", y);

medium

A. No error, prints "Value: None"

B. unwrap returns Option, not value

C. Compilation error due to type mismatch

D. Runtime panic because unwrap on None

Solution

1. Step 1: Understand unwrap behavior on None

   Calling unwrap() on None causes a runtime panic because there is no value.

2. Step 2: Check the code behavior

   Since x is None, unwrap() panics and program crashes at runtime.

3. Final Answer:

   Runtime panic because unwrap on None -> Option D

4. Quick Check:

   unwrap on None panics at runtime [OK]

Hint: unwrap on None causes panic, avoid without check [OK]

Common Mistakes:

• Thinking unwrap returns None safely
• Expecting compilation error instead of runtime panic
• Assuming unwrap returns Option instead of value

5. Given a vector of integers, how can you use Option to safely find the first even number and print it, or print "No even number" if none exist? Choose the correct Rust code snippet.

hard

A. let nums = vec![1, 3, 5];
if let Some(even) = nums.iter().find(|&&x| x % 2 == 0) {
println!("First even: {}", even);
} else {
println!("No even number");
}

B. let nums = vec![1, 3, 5];
let even = nums.iter().find(|x| x % 2 == 0).unwrap();
println!("First even: {}", even);

C. let nums = vec![1, 3, 5];
let even = nums.iter().filter(|x| x % 2 == 0).next().unwrap();
println!("First even: {}", even);

D. let nums = vec![1, 3, 5];
let even = nums.iter().find(|&&x| x % 2 == 0).unwrap_or(0);
println!("First even: {}", even);

Solution

1. Step 1: Understand safe Option handling with find()

   nums.iter().find returns Option<&i32>. Using if let Some(even) safely handles Some or None.

2. Step 2: Check each option for correctness and safety

   let nums = vec![1, 3, 5]; if let Some(even) = nums.iter().find(|&&x| x % 2 == 0) { println!("First even: {}", even); } else { println!("No even number"); } uses if let to print the even number or fallback message safely. Others use unwrap() which panics if no even number.

3. Final Answer:

   Option A code safely finds and prints first even or fallback message. -> Option A

4. Quick Check:

   Use if let Some(...) to safely handle Option from find() [OK]

Hint: Use if let Some(...) to safely unwrap Option without panic [OK]

Common Mistakes:

• Using unwrap() without checking for None causes panic
• Incorrect closure syntax in find/filter
• Using unwrap_or with incompatible types