Program structure in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define the main function in Rust.

Rust

fn [1]() {
    println!("Hello, world!");
}

Drag options to blanks, or click blank then click option'

Arun

Bstart

Cmain

Dbegin

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different function name instead of main.

Adding parameters to the main function.

The main function is the entry point of a Rust program.

2fill in blank

medium

Complete the code to print a message inside the main function.

Rust

fn main() {
    [1]!("Welcome to Rust!");
}

Drag options to blanks, or click blank then click option'

Aprint

Bprintln

Cecho

Dwrite

Attempts:

3 left

💡 Hint

Common Mistakes

Using print which does not add a newline.

Trying to use functions instead of macros.

The println! macro prints text with a newline at the end.

3fill in blank

hard

Fix the error in the function declaration to make it valid Rust code.

Rust

fn main[1] {
    println!("Fixed function");
}

Drag options to blanks, or click blank then click option'

A()

B{}

C<()>

D[]

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting parentheses after the function name.

Using braces {} instead of parentheses.

Functions in Rust require parentheses () after the name, even if no parameters.

4fill in blank

hard

Fill both blanks to create a valid Rust program that prints a message.

Rust

fn [1]() {
    [2]!("Hello from Rust!");
}

Drag options to blanks, or click blank then click option'

Amain

Bprint

Cprintln

Dstart

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect function names.

Using print instead of println.

The program needs the main function and the println! macro to print the message.

5fill in blank

hard

Fill all three blanks to define a main function that prints a formatted message.

Rust

fn [1]() {
    [2]!("Number: {}", [3]);
}

Drag options to blanks, or click blank then click option'

Amain

Bprintln

C42

Dprint

Attempts:

3 left

💡 Hint

Common Mistakes

Using print instead of println.

Not providing a value for the placeholder.

The main function uses println! macro to print the number 42 formatted inside the string.

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