Function parameters in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of function with mutable reference parameter

What is the output of this Rust code?

Rust

fn add_one(x: &mut i32) {
    *x += 1;
}

fn main() {
    let mut num = 5;
    add_one(&mut num);
    println!("{}", num);
}

A 5

B Compilation error

C 6

D Runtime panic

💡 Hint

Think about how mutable references allow modifying the original variable.

The function takes a mutable reference and increments the value it points to. So num changes from 5 to 6.

❓ Predict Output

intermediate

Output of function with default parameter simulation

Rust does not support default parameters directly. What is the output of this code simulating default parameters?

Rust

fn greet(name: Option<&str>) {
    let name = name.unwrap_or("Guest");
    println!("Hello, {}!", name);
}

fn main() {
    greet(Some("Alice"));
    greet(None);
}

A Hello, Alice!\nHello, Guest!

B Hello, Guest!\nHello, Alice!

C Compilation error

D Hello, None!\nHello, None!

💡 Hint

Look at how Option and unwrap_or work.

The function prints 'Hello, Alice!' when Some("Alice") is passed, and 'Hello, Guest!' when None is passed.

🔧 Debug

advanced

Identify the error with lifetime in function parameters

What error does this Rust code produce?

Rust

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

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

A Prints 'short'

B Compilation error: missing lifetime specifier

C Prints 'long string'

D Runtime panic due to dangling reference

💡 Hint

Check the function signature for lifetime annotations.

The function returns a reference but does not specify lifetimes, so Rust cannot guarantee safety. This causes a compilation error.

📝 Syntax

advanced

Which function parameter syntax is invalid?

Which of these Rust function parameter declarations is invalid?

A fn foo(&mut x: i32) {}

B fn foo(mut x: i32) {}

C fn foo(x: i32, y: &str) {}

D fn foo(x: &mut i32) {}

💡 Hint

Consider how mutability is declared in parameters.

You cannot write &mut x: i32 in parameter list. The correct syntax is x: &mut i32.

🚀 Application

expert

Determine the output of function with pattern matching parameters

What is the output of this Rust code using pattern matching in function parameters?

Rust

fn print_point(&(x, y): &(i32, i32)) {
    println!("x: {}, y: {}", x, y);
}

fn main() {
    let point = (10, 20);
    print_point(&point);
}

A Runtime panic

B x: (10, 20), y: (10, 20)

C Compilation error: cannot destructure in parameters

D x: 10, y: 20

💡 Hint

Look at how the tuple is destructured in the parameter.

The function parameter destructures the tuple reference into x and y, so it prints their values.

Practice

1. What is the purpose of function parameters in Rust?

easy

A. To send data into functions so they can use it

B. To define the return type of a function

C. To declare variables inside a function

D. To create loops inside functions

Solution

1. Step 1: Understand what parameters do

   Parameters allow functions to receive input data when called.

2. Step 2: Identify the correct purpose

   Sending data into functions makes them flexible and reusable.

3. Final Answer:

   To send data into functions so they can use it -> Option A

4. Quick Check:

   Function parameters = input data [OK]

Hint: Parameters pass data into functions for flexibility [OK]

Common Mistakes:

• Confusing parameters with return types
• Thinking parameters declare variables inside functions
• Mixing parameters with control flow like loops

2. Which of the following is the correct way to declare a function with one parameter named num of type i32 in Rust?

easy

A. fn example(num) -> i32 {}

B. fn example(i32 num) {}

C. fn example(num: i32) {}

D. fn example(num: int) {}

Solution

1. Step 1: Recall Rust function parameter syntax

   Parameters are declared as name: type, e.g., num: i32.

2. Step 2: Check each option

   fn example(num: i32) {} matches correct syntax. fn example(i32 num) {} reverses order. fn example(num) -> i32 {} misses type. fn example(num: int) {} uses wrong type name.

3. Final Answer:

   fn example(num: i32) {} -> Option C

4. Quick Check:

   Parameter syntax = name: type [OK]

Hint: Use name: type for parameters in Rust functions [OK]

Common Mistakes:

• Swapping type and name order
• Omitting the parameter type
• Using incorrect type names like 'int'

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

fn greet(name: &str) {
    println!("Hello, {}!", name);
}

fn main() {
    greet("Alice");
}

medium

A. Hello, Alice!

B. Hello, name!

C. Hello, &str!

D. Compilation error

Solution

1. Step 1: Understand the function call and parameter

   The function greet takes a string slice &str and prints a greeting with the given name.

2. Step 2: Trace the function call in main

   Calling greet("Alice") passes "Alice" as the parameter, so it prints "Hello, Alice!".

3. Final Answer:

   Hello, Alice! -> Option A

4. Quick Check:

   Function prints greeting with passed name [OK]

Hint: Parameters replace placeholders in print statements [OK]

Common Mistakes:

• Printing the parameter name instead of its value
• Confusing &str with variable name
• Expecting a compilation error due to &str

4. Identify the error in this Rust function declaration:

fn add(a i32, b: i32) -> i32 {
    a + b
}

medium

A. Parameters should be declared as 'i32 a' and 'i32 b'

B. Missing return type declaration

C. Function body missing braces

D. Missing colon between parameter name and type for 'a'

Solution

1. Step 1: Check parameter syntax

   Each parameter must have a colon between name and type, e.g., a: i32.

2. Step 2: Identify the error

   Parameter a i32 is missing the colon, causing a syntax error.

3. Final Answer:

   Missing colon between parameter name and type for 'a' -> Option D

4. Quick Check:

   Parameter syntax requires colon [OK]

Hint: Always put colon between parameter name and type [OK]

Common Mistakes:

• Omitting colon between name and type
• Confusing parameter order syntax
• Forgetting return type after ->

5. Given this function:

fn calculate_area(width: f64, height: f64) -> f64 {
    width * height
}

Which call correctly uses the function parameters to calculate the area of a 5.0 by 3.0 rectangle?

hard

A. calculate_area(5, 3)

B. calculate_area(5.0, 3.0)

C. calculate_area("5", "3")

D. calculate_area(width=5.0, height=3.0)

Solution

1. Step 1: Check parameter types

   The function expects two f64 (floating-point) parameters.

2. Step 2: Evaluate each call

   calculate_area(5, 3) uses integer literals, which Rust automatically coerces to f64 (implicit conversion). calculate_area(5.0, 3.0) uses floating-point literals matching the f64 parameter type exactly. calculate_area("5", "3") uses strings, type mismatch. calculate_area(width=5.0, height=3.0) uses named arguments, which Rust does not support.

3. Final Answer:

   calculate_area(5.0, 3.0) -> Option B

4. Quick Check:

   Use correct types and order for parameters [OK]

Hint: Match argument types exactly to parameter types [OK]

Common Mistakes:

• Using integers instead of floats without suffix
• Passing strings instead of numbers
• Trying named arguments (not supported in Rust)