Ownership and functions in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code involving ownership and function calls?

Consider the following Rust code. What will be printed when it runs?

Rust

fn take_ownership(s: String) {
    println!("Inside function: {}", s);
}

fn main() {
    let s = String::from("hello");
    take_ownership(s);
    // println!("Outside function: {}", s); // What happens if uncommented?
}

A Inside function: hello

B

Inside function: hello
Outside function: hello

C Compilation error: use of moved value 's'

D Runtime error: use of invalid memory

💡 Hint

Think about what happens to ownership of s when passed to the function.

When s is passed to take_ownership, ownership moves into the function. After the function ends, s is dropped. Trying to use s outside causes a compile error, so the commented line would not compile. The program prints only inside the function.

❓ Predict Output

intermediate

What is the output when borrowing a value in a function?

Look at this Rust code. What will it print?

Rust

fn borrow_string(s: &String) {
    println!("Inside function: {}", s);
}

fn main() {
    let s = String::from("world");
    borrow_string(&s);
    println!("Outside function: {}", s);
}

A Runtime error: use of moved value

B

Inside function: world
Outside function: world

C Compilation error: cannot borrow 's' as immutable because it is also borrowed as mutable

D Inside function: world

💡 Hint

Consider how borrowing works in Rust and whether ownership moves.

The function borrows s immutably, so ownership is not moved. The variable s remains valid after the function call, so both prints work.

🔧 Debug

advanced

What error does this Rust code produce related to ownership?

Examine the code below. What error will the Rust compiler report?

Rust

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;
    println!("{}", s1);
}

A error: expected `String`, found `&str`

B error: cannot assign twice to immutable variable `s1`

C error: use of moved value: `s1`

D error: mismatched types in assignment

💡 Hint

Think about what happens when you assign s1 to s2.

Assigning s1 to s2 moves ownership. After that, s1 is invalid. Using s1 causes a 'use of moved value' error.

📝 Syntax

advanced

Which function signature correctly takes ownership of a vector and returns its length?

Choose the correct Rust function signature that takes ownership of a Vec and returns its length as usize.

A fn vec_length(v: &mut Vec<i32>) -> usize { v.len() }

B fn vec_length(v: &Vec<i32>) -> usize { v.len() }

C fn vec_length(v: Vec<i32>) { v.len() }

D fn vec_length(v: Vec<i32>) -> usize { v.len() }

💡 Hint

Focus on ownership transfer and return type.

Option D takes ownership of the vector and returns its length. Options A and B borrow the vector, not take ownership. Option D takes ownership but returns nothing (unit type), so it does not return the length.

🚀 Application

expert

What is the value of `result` after this ownership and function call sequence?

Analyze the following Rust code. What is the value of result after main runs?

Rust

fn consume_and_return(s: String) -> String {
    let mut new_s = s;
    new_s.push_str(" world");
    new_s
}

fn main() {
    let s1 = String::from("hello");
    let result = consume_and_return(s1);
    // println!("{}", s1); // Would cause error
}

A "hello world"

B "hello"

C Compilation error: use of moved value 's1'

D " world"

💡 Hint

Consider how ownership moves and what the function returns.

The function takes ownership of s, appends " world", and returns the new string. The returned string is assigned to result. The original s1 is moved and cannot be used after.

Practice

1. What happens when a function in Rust takes ownership of a variable passed to it?

easy

A. The variable is shared between the function and the caller simultaneously.

B. The variable is copied and both original and function have ownership.

C. The function borrows the variable temporarily without taking ownership.

D. The original variable can no longer be used after the function call.

Solution

1. Step 1: Understand ownership transfer in Rust functions

   When a function takes ownership, it means the variable's ownership moves to the function.

2. Step 2: Effect on original variable after function call

   Since ownership moved, the original variable cannot be used anymore after the call.

3. Final Answer:

   The original variable can no longer be used after the function call. -> Option D

4. Quick Check:

   Ownership transfer = original variable unusable [OK]

Hint: Ownership moves to function, original variable becomes invalid [OK]

Common Mistakes:

• Thinking ownership is shared, not moved
• Assuming variable is copied automatically
• Confusing borrowing with ownership transfer

2. Which of the following function signatures correctly borrows a string slice without taking ownership?

easy

A. fn print_name(name: String) { println!("{}", name); }

B. fn print_name(name: &String) { println!("{}", name); }

C. fn print_name(name: &str) { println!("{}", name); }

D. fn print_name(name: String) -> String { name }

Solution

1. Step 1: Identify borrowing syntax for string slices

   Borrowing a string slice uses &str type, which is a reference to a string slice.

2. Step 2: Check each signature for borrowing without ownership

   fn print_name(name: &str) { println!("{}", name); } uses &str, which borrows without taking ownership. fn print_name(name: &String) { println!("{}", name); } borrows a String reference but &str is more idiomatic for slices.

3. Final Answer:

   fn print_name(name: &str) { println!("{}", name); } -> Option C

4. Quick Check:

   Borrow string slice = &str parameter [OK]

Hint: Use &str to borrow string slices without ownership [OK]

Common Mistakes:

• Using String parameter takes ownership
• Confusing &String with &str
• Returning ownership when not needed

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

fn take_ownership(s: String) {
    println!("Inside function: {}", s);
}

fn main() {
    let s = String::from("hello");
    take_ownership(s);
    println!("Outside function: {}", s);
}

medium

A. Inside function: hello
Compile error: use of moved value 's'

B. Inside function: hello
Outside function: hello

C. Inside function: hello
Outside function: <empty>

D. Runtime error: variable s not found

Solution

1. Step 1: Analyze ownership transfer in function call

   The function take_ownership takes ownership of s, so s is moved into the function.

2. Step 2: Check usage of s after function call

   After the call, s is no longer valid in main, so using it causes a compile error.

3. Final Answer:

   Inside function: hello Compile error: use of moved value 's' -> Option A

4. Quick Check:

   Ownership moved, use after move = compile error [OK]

Hint: Using moved variable after function call causes compile error [OK]

Common Mistakes:

• Assuming variable is copied automatically
• Expecting output after ownership moved
• Ignoring Rust's ownership rules

4. Identify the error in this Rust code and how to fix it:

fn calculate_length(s: String) -> usize {
    s.len()
}

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(s1);
    println!("The length of '{}' is {}.", s1, len);
}

medium

A. Error: s1 is moved into calculate_length; fix by passing &s1 instead.

B. Error: calculate_length returns wrong type; fix by returning &usize.

C. Error: println! macro syntax incorrect; fix by removing quotes.

D. No error; code runs and prints length correctly.

Solution

1. Step 1: Identify ownership issue in function call

   calculate_length takes ownership of s1, so s1 is moved and invalid after call.

2. Step 2: Fix by borrowing s1 instead of moving

   Change function parameter to &String and pass &s1 to avoid moving ownership.

3. Final Answer:

   Error: s1 is moved into calculate_length; fix by passing &s1 instead. -> Option A

4. Quick Check:

   Pass reference to avoid moving ownership [OK]

Hint: Pass references to keep ownership when calling functions [OK]

Common Mistakes:

• Trying to return reference to local variable
• Ignoring ownership move on function parameters
• Misunderstanding borrowing syntax

5. You want to write a function that takes ownership of a vector, doubles each element, and returns ownership back. Which function signature and body correctly implement this in Rust?

hard

A. fn double_vec(v: &Vec<i32>) -> Vec<i32> { v.iter().map(|x| x * 2).collect() }

B. fn double_vec(v: Vec<i32>) -> Vec<i32> { v.iter().map(|x| x * 2).collect() }

C. fn double_vec(v: Vec<i32>) { for x in &v { println!("{}", x * 2); } }

D. fn double_vec(v: &mut Vec<i32>) { for x in v { *x *= 2; } }

Solution

1. Step 1: Understand ownership and return requirements

   The function must take ownership of the vector and return ownership back after doubling elements.

2. Step 2: Analyze each option for ownership and functionality

   fn double_vec(v: Vec<i32>) -> Vec<i32> { v.iter().map(|x| x * 2).collect() } takes ownership (Vec<i32>), creates a new doubled vector, and returns it, satisfying requirements.

3. Final Answer:

   fn double_vec(v: Vec<i32>) -> Vec<i32> { v.iter().map(|x| x * 2).collect() } -> Option B

4. Quick Check:

   Take ownership, return new doubled vector [OK]

Hint: Take Vec ownership and return new Vec after processing [OK]

Common Mistakes:

• Borrowing vector but not returning ownership
• Not returning anything from function
• Modifying borrowed vector without ownership