Variable lifetime basics in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code with lifetimes?

Consider the following Rust code that uses references with explicit lifetimes. What will it print?

Rust

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

fn main() {
    let string1 = String::from("apple");
    let string2 = "banana";
    let result = longest(string1.as_str(), string2);
    println!("{}", result);
}

A banana

B apple

C Compilation error due to lifetime mismatch

D applebanana

💡 Hint

Think about which string slice is longer and how lifetimes ensure safety.

The function longest returns the longer string slice. "banana" is longer than "apple", so it prints "banana".

❓ Predict Output

intermediate

What error does this Rust code produce?

Look at this Rust code snippet. What error will the compiler show?

Rust

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

A Compilation error: cannot assign twice to immutable variable

B Prints 5

C Compilation error: borrowed value does not live long enough

D Runtime error: use after free

💡 Hint

Check the scope of x and the reference r.

The variable x is dropped at the end of the inner block, but r tries to reference it outside that scope. Rust prevents this with a compile-time error.

🔧 Debug

advanced

Why does this Rust code fail to compile due to lifetimes?

Identify the reason this Rust code does not compile and what lifetime rule it violates.

Rust

fn get_str<'a>() -> &'a str {
    let s = String::from("hello");
    &s
}

fn main() {
    let result = get_str();
    println!("{}", result);
}

A Returns reference to a local variable that is dropped, causing dangling reference

B Missing lifetime annotation on function parameter

C Cannot return a reference without specifying 'static lifetime

D Function should return String, not &str

💡 Hint

Think about the lifetime of s inside the function.

The function returns a reference to s, which is dropped when the function ends. This causes a dangling reference, which Rust forbids.

📝 Syntax

advanced

Which option correctly declares a function with lifetime parameters?

Choose the correct Rust function signature that returns the longer of two string slices with proper lifetime annotations.

A fn longest(x: &str, y: &str) -> &str

B fn longest<'a>(x: &'a str, y: &'a str) -> &'a str

C fn longest<'a, 'b>(x: &'a str, y: &'b str) -> &'a str

D fn longest(x: &'a str, y: &'a str) -> &'a str

💡 Hint

Remember to declare lifetime parameters before using them in references.

Option B correctly declares a single lifetime parameter 'a and uses it consistently for both parameters and the return type.

🚀 Application

expert

How many items does this Rust code store in the vector?

Given this Rust code using references with lifetimes, how many items will be stored in the vector vec after execution?

Rust

fn main() {
    let mut vec = Vec::new();
    {
        let s = String::from("hello");
        vec.push(&s);
    }
    println!("{}", vec.len());
}

A 1

B 0

C Runtime panic due to invalid reference

D Compilation error due to lifetime mismatch

💡 Hint

Consider the lifetime of s and the reference stored in the vector.

The reference to s is pushed into the vector, but s is dropped at the end of the inner block. Rust prevents storing a reference that may become invalid, causing a compile-time error.