Writing first Rust program - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to print "Hello, world!" in Rust.

Rust

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

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

AHello, world!

B"Hello, world!"

Cprintln!("Hello, world!")

Dprint!("Hello, world!")

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting the quotes around the text.

Using print! instead of println! for a new line.

The println! macro prints text to the screen. The text must be inside double quotes.

2fill in blank

medium

Complete the code to declare the main function in Rust.

Rust

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

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

Amain

Bbegin

Cstart

Drun

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different function name instead of main.

Forgetting the parentheses after the function name.

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

3fill in blank

hard

Fix the error in the code to correctly print a message.

Rust

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

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

Aprint!("Hello, Rust!")

BHello, Rust!

Cprintln!("Hello, Rust!")

D"Hello, Rust!"

Attempts:

3 left

💡 Hint

Common Mistakes

Leaving out the quotes causes a compile error.

Using print! instead of println! changes output formatting.

The argument to println! must be a string literal enclosed in double quotes.

4fill in blank

hard

Fill both blanks to create a function that prints a greeting.

Rust

fn [1]() {
    println!([2]);
}

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

Agreet

B"Welcome to Rust!"

C"Hello, friend!"

Dmain

Attempts:

3 left

💡 Hint

Common Mistakes

Using a message without quotes.

Using main as function name when a different name is asked.

The function name can be greet, and the message must be a string literal like "Hello, friend!".

5fill in blank

hard

Fill all three blanks to print a custom message inside the main function.

Rust

fn [1]() {
    let message = [2];
    println!([3]);
}

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

Amain

B"Rust is fun!"

Cmessage

D"Hello from Rust!"

Attempts:

3 left

💡 Hint

Common Mistakes

Printing the string literal directly instead of the variable.

Using wrong function name or missing quotes around the string.

The main function is named main. The variable message holds the string "Rust is fun!". The println! macro prints the variable message.

Practice

1. What is the correct way to start a basic Rust program?

easy

A. By defining a fn main() function

B. By writing start() function

C. By using begin() function

D. By declaring a program() function

Solution

1. Step 1: Understand Rust program entry point

   Rust programs always start execution from the main function.

2. Step 2: Identify the correct function name

   The correct function to start a Rust program is fn main().

3. Final Answer:

   By defining a fn main() function -> Option A

4. Quick Check:

   Rust program entry point = fn main() [OK]

Hint: Rust programs always start with fn main() [OK]

Common Mistakes:

• Using incorrect function names like start() or begin()
• Omitting the main function entirely
• Confusing Rust with other languages' entry points

2. Which of the following is the correct syntax to print "Hello, world!" in Rust?

easy

A. print!("Hello, world!");

B. println!("Hello, world!");

C. echo("Hello, world!");

D. console.log("Hello, world!");

Solution

1. Step 1: Identify Rust's print macro

   Rust uses the macro println! to print text with a newline.

2. Step 2: Compare options

   Only println!("Hello, world!"); is valid Rust syntax for printing with a newline.

3. Final Answer:

   println!("Hello, world!"); -> Option B

4. Quick Check:

   Print with newline = println! macro [OK]

Hint: Use println! to print with a newline in Rust [OK]

Common Mistakes:

• Using print! without newline when newline is expected
• Using functions from other languages like echo or console.log
• Missing the exclamation mark after println

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

fn main() {
    println!("{}", 5 + 3);
}

medium

A. 8

B. 5 + 3

C. {}

D. Compilation error

Solution

1. Step 1: Understand the println! macro with placeholders

   The {} inside the string is a placeholder for the value following the string.

2. Step 2: Calculate the expression inside println!

   The expression 5 + 3 evaluates to 8, which replaces the {}.

3. Final Answer:

   8 -> Option A

4. Quick Check:

   5 + 3 = 8 printed [OK]

Hint: {} prints evaluated expression inside println! [OK]

Common Mistakes:

• Expecting the literal string '5 + 3' to print
• Confusing {} as a string literal
• Thinking it causes a compile error

4. Identify the error in this Rust program:

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

medium

A. Missing quotation marks around string

B. Incorrect function name main

C. Missing semicolon after println! macro

D. println! macro does not exist

Solution

1. Step 1: Check syntax of println! macro call

   In Rust, statements must end with a semicolon unless they are the last expression in a block.

2. Step 2: Identify missing semicolon

   The println!("Hello, world!") line is missing a semicolon at the end.

3. Final Answer:

   Missing semicolon after println! macro -> Option C

4. Quick Check:

   Statements need semicolon unless last expression [OK]

Hint: Add semicolon after println! unless last expression [OK]

Common Mistakes:

• Forgetting semicolon after macro calls
• Thinking main function name is wrong
• Assuming println! is not a macro

5. You want to write a Rust program that prints "Hello, <name>!" where <name> is a variable. Which code correctly does this?

hard

A. fn main() {
let name = "Alice";
println!("Hello, {name}!");
}

B. fn main() {
let name = "Alice";
println!("Hello, name!");
}

C. fn main() {
let name = "Alice";
print!("Hello, {}!", name);
}

D. fn main() {
let name = "Alice";
println!("Hello, {}!", name);
}

Solution

1. Step 1: Understand variable interpolation in println!

   Rust uses {} as a placeholder and variables are passed after the string.

2. Step 2: Check each option for correct syntax and output

   fn main() { let name = "Alice"; println!("Hello, {}!", name); } correctly uses println!("Hello, {}!", name); to print the variable's value.

3. Final Answer:

   fn main() { let name = "Alice"; println!("Hello, {}!", name); } -> Option D

4. Quick Check:

   Use {} and pass variable to println! [OK]

Hint: Use {} and pass variable to println! for interpolation [OK]

Common Mistakes:

• Putting variable name inside quotes without {}
• Using print! instead of println! (missing newline)
• Trying to use {name} without Rust 1.58+ raw identifiers