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.

Practice

1. In a Rust program, where does the execution start?

easy

A. At the last line of the file

B. Inside the main function

C. Inside a function named start

D. At the first line of the file outside any function

Solution

1. Step 1: Understand Rust program entry point

   Rust programs always begin execution from the main function.

2. Step 2: Check other options

   Code outside functions or other function names like start are not entry points.

3. Final Answer:

   Inside the main function -> Option B

4. Quick Check:

   Rust starts at main() [OK]

Hint: Rust always runs code starting from main() [OK]

Common Mistakes:

• Thinking code outside main() runs first
• Assuming a function named start() runs automatically
• Believing execution starts at the last line

2. Which of the following is the correct way to write the main function in Rust?

easy

A. function main() { println!("Hello, world!"); }

B. main() { println!("Hello, world!"); }

C. fn main() { println!("Hello, world!"); }

D. def main() { println!("Hello, world!"); }

Solution

1. Step 1: Identify Rust function syntax

   Rust functions start with fn, followed by the name and parentheses.

2. Step 2: Check each option

   Only fn main() { println!("Hello, world!"); } uses fn main() correctly; others use wrong keywords.

3. Final Answer:

   fn main() { println!("Hello, world!"); } -> Option C

4. Quick Check:

   Rust functions start with fn [OK]

Hint: Rust functions start with fn keyword [OK]

Common Mistakes:

• Using function or def instead of fn
• Omitting fn keyword
• Missing parentheses after function name

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

fn main() {
    println!("Start");
    {
        println!("Inside block");
    }
    println!("End");
}

medium

A. Start\nInside block\nEnd

B. Start\nEnd\nInside block

C. Inside block\nStart\nEnd

D. Start\nInside block

Solution

1. Step 1: Follow the code execution order

   The program prints "Start", then enters the block and prints "Inside block", then prints "End" after the block.

2. Step 2: Confirm output sequence

   The output lines appear in the order: Start, Inside block, End.

3. Final Answer:

   Start\nInside block\nEnd -> Option A

4. Quick Check:

   Code runs top to bottom inside blocks [OK]

Hint: Code runs step by step inside braces [OK]

Common Mistakes:

• Assuming block runs after all code
• Mixing order of print statements
• Ignoring braces as code grouping

4. Identify the error in this Rust program:

fn main() {
    println!("Hello");
    // Missing closing brace

medium

A. println! macro is misspelled

B. Missing semicolon after println!

C. Incorrect comment syntax

D. Missing closing brace '}' for main function

Solution

1. Step 1: Check code structure

   The main function starts with fn main() { but never closes with a }.

2. Step 2: Verify other syntax

   The semicolon after println! is present, comment syntax is correct, and println! is spelled correctly.

3. Final Answer:

   Missing closing brace '}' for main function -> Option D

4. Quick Check:

   Every { needs a matching } [OK]

Hint: Count opening and closing braces carefully [OK]

Common Mistakes:

• Forgetting to close function with }
• Confusing comment syntax with errors
• Missing semicolon errors instead of braces

5. You want to add a comment explaining why your Rust program prints "Hello". Which is the correct way to add a single-line comment inside the main function?

hard

A. // This prints Hello
println!("Hello");

B. # This prints Hello
println!("Hello");

C. /* This prints Hello */ println!("Hello");

D. println!("Hello");

Solution

1. Step 1: Identify Rust comment syntax

   Rust uses // for single-line comments and /* */ for block comments.

2. Step 2: Check each option

   Only // This prints Hello println!("Hello"); uses Rust's single-line comment syntax correctly; /* ... */ is a block comment, # is Python-style, and <!-- ... --> is HTML.

3. Final Answer:

   // This prints Hello println!("Hello"); -> Option A

4. Quick Check:

   Single-line comments start with // [OK]

Hint: Use // for single-line comments in Rust [OK]

Common Mistakes:

• Using # or for comments
• Confusing block comments with single-line
• Placing comments inside println! macro