Program structure in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a simple Rust program with functions

What is the output of this Rust program?

Rust

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

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

A Hello, Bob!\nHello, Alice!

B Hello, Alice! Hello, Bob!

C Hello, Alice!\nHello, Alice!

D Hello, Alice!\nHello, Bob!

💡 Hint

Look at how the greet function is called twice with different names.

The greet function prints a greeting with the given name. It is called first with "Alice" then with "Bob", so the output prints two lines, each greeting the respective name.

🧠 Conceptual

intermediate

Understanding Rust's main function and program entry

Which statement about the Rust program entry point is true?

A Rust programs start from the first function defined in the file.

B The program starts execution from the main function.

C Rust requires a function named start as the entry point.

D The entry point is determined by the order of function calls.

💡 Hint

Think about what function the Rust compiler looks for to begin running the program.

In Rust, the main function is the designated entry point where execution begins. Other functions are called from main or indirectly.

🔧 Debug

advanced

Identify the error in this Rust program structure

What error does this Rust code produce when compiled?

Rust

fn main() {
    println!("Start");
}

fn main() {
    println!("Duplicate main");
}

A error: multiple definitions of `main` function

B error: function main must return a value

C error: missing semicolon after println!

D error: println! macro not found

💡 Hint

Check if Rust allows more than one main function in the same program.

Rust programs cannot have more than one main function. Defining main twice causes a compilation error about multiple definitions.

📝 Syntax

advanced

Correct syntax for defining a module and using it

Which option correctly defines a module named `math` with a function `add` and calls it from main?

A

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

fn main() {
    let sum = math::add(2, 3);
    println!("{}", sum);
}

B

module math {
    fn add(a: i32, b: i32) -> i32 {
        return a + b;
    }
}

fn main() {
    let sum = math.add(2, 3);
    println!("{}", sum);
}

C

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

fn main() {
    let sum = math::add(2, 3);
    println!("{}", sum);
}

D

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

fn main() {
    let sum = add(2, 3);
    println!("{}", sum);
}

💡 Hint

Remember that functions inside modules must be public to be accessed outside, and the module syntax is `mod`.

Option C correctly defines a public function inside a module and calls it with the module path. Option C uses invalid syntax `module` and dot notation. Option C's function is private, so calling it outside causes error. Option C calls add without module prefix, which is invalid.

🚀 Application

expert

Predict the number of items in a vector after conditional push

Consider this Rust code. How many elements does the vector `numbers` contain after execution?

Rust

fn main() {
    let mut numbers = Vec::new();
    for i in 0..5 {
        if i % 2 == 0 {
            numbers.push(i);
        }
    }
    println!("Count: {}", numbers.len());
}

A 3

B 5

C 2

D 4

💡 Hint

Count how many numbers from 0 to 4 are even.

The loop runs from 0 to 4. It pushes only even numbers (0, 2, 4) into the vector. So the vector has 3 elements.