Compound data types in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust tuple code?

Consider the following Rust code using tuples. What will it print?

Rust

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
    let (x, y, z) = tup;
    println!("{} {} {}", x, y, z);
}

A 6.4 500 1

B 500 6.4 1

C 500 1 6.4

D Error: cannot print tuple elements directly

💡 Hint

Remember tuple elements keep their order and types.

The tuple tup has elements in order: 500 (i32), 6.4 (f64), and 1 (u8). The pattern (x, y, z) matches them in order. So printing x y z prints 500 6.4 1.

❓ Predict Output

intermediate

What is the output of this Rust array code?

What will this Rust program print?

Rust

fn main() {
    let arr = [10, 20, 30, 40, 50];
    let slice = &arr[1..4];
    println!("{:?}", slice);
}

A [20, 30, 40]

B [10, 20, 30, 40]

C [30, 40, 50]

D Error: cannot slice arrays this way

💡 Hint

Remember Rust slices include the start index but exclude the end index.

The slice &arr[1..4] includes elements at indices 1, 2, and 3, which are 20, 30, 40. The end index 4 is excluded.

🔧 Debug

advanced

Why does this Rust struct code fail to compile?

Look at this Rust code defining and using a struct. Why does it fail to compile?

Rust

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 5 };
    println!("({}, {})", p.x, p.y);
}

A Error because Point struct must derive Debug trait

B Error because struct fields must be mutable

C Error because println! macro syntax is wrong

D Error because field 'y' is missing when creating Point

💡 Hint

Check if all struct fields are initialized when creating an instance.

The struct Point has two fields: x and y. When creating p, only x is given a value. Rust requires all fields to be initialized unless default values or other constructors are used.

❓ Predict Output

advanced

What is the output of this Rust enum and match code?

What will this Rust program print?

Rust

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
}

fn main() {
    let msg = Message::Move { x: 10, y: 20 };
    match msg {
        Message::Quit => println!("Quit message"),
        Message::Move { x, y } => println!("Move to ({}, {})", x, y),
        Message::Write(text) => println!("Write message: {}", text),
    }
}

A Move to (10, 20)

B Quit message

C Write message: Move to (10, 20)

D Error: match arms missing wildcard pattern

💡 Hint

Look at which enum variant is created and matched.

The variable msg is created as Message::Move { x: 10, y: 20 }. The match arm for Message::Move prints Move to (10, 20). Other arms do not run.

🧠 Conceptual

expert

How many elements does this nested tuple contain?

Consider this nested tuple in Rust:

let nested = ((1, 2), (3, (4, 5)));

How many individual integer elements does nested contain?

A 4

B 3

C 5

D 6

💡 Hint

Count all integers inside all inner tuples.

The tuple nested contains two elements: (1, 2) and (3, (4, 5)). The first inner tuple has 2 integers, the second has 1 integer and another tuple with 2 integers. Total is 2 + 1 + 2 = 5 integers.