Copy types in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of copying a simple type

What is the output of this Rust code snippet?

Rust

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

A x = 5, y = 5

B x = 5, y = 0

C x = 0, y = 5

D Compilation error due to move

💡 Hint

Simple integer types implement the Copy trait, so the value is copied, not moved.

In Rust, integers implement the Copy trait, so assigning x to y copies the value. Both x and y remain valid and equal to 5.

❓ Predict Output

intermediate

Copy trait with tuples

What will this Rust program print?

Rust

fn main() {
    let a = (10, 20);
    let b = a;
    println!("a = {:?}, b = {:?}", a, b);
}

A a = (10, 20), b = (10, 20)

B a = (10, 20), b = (0, 0)

C a = (0, 0), b = (10, 20)

D Compilation error: move occurs because tuple does not implement Copy

💡 Hint

Tuples of Copy types are also Copy.

Since both elements of the tuple are integers (Copy types), the tuple itself implements Copy. So a is copied to b, both remain valid.

❓ Predict Output

advanced

Copy trait with custom struct

What is the output of this Rust code?

Rust

#[derive(Debug, Copy, Clone)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = p1;
    println!("p1 = {:?}, p2 = {:?}", p1, p2);
}

A p1 = Point { x: 0, y: 0 }, p2 = Point { x: 1, y: 2 }

B p1 = Point { x: 1, y: 2 }, p2 = Point { x: 0, y: 0 }

C p1 = Point { x: 1, y: 2 }, p2 = Point { x: 1, y: 2 }

D Compilation error: missing Copy trait implementation

💡 Hint

The struct derives Copy and Clone, so it can be copied.

The #[derive(Copy, Clone)] attribute allows Point to be copied. Assigning p1 to p2 copies the data, so both remain valid and equal.

❓ Predict Output

advanced

Copy trait and references

What will this Rust code print?

Rust

fn main() {
    let s = String::from("hello");
    let r1 = &s;
    let r2 = r1;
    println!("r1 = {}, r2 = {}", r1, r2);
}

A Compilation error: cannot copy &String reference

B r1 = hello, r2 =

C Compilation error: cannot copy String

D r1 = hello, r2 = hello

💡 Hint

References implement Copy, so copying references is allowed.

References (&String) implement Copy, so r1 is copied to r2. Both references point to the same String, so printing both works fine.

❓ Predict Output

expert

Copy trait with arrays and slices

What is the output of this Rust program?

Rust

fn main() {
    let arr1 = [1, 2, 3];
    let arr2 = arr1;
    let slice1 = &arr1[..];
    let slice2 = slice1;
    println!("arr1 = {:?}, arr2 = {:?}", arr1, arr2);
    println!("slice1 = {:?}, slice2 = {:?}", slice1, slice2);
}

A

arr1 = [1, 2, 3], arr2 = [0, 0, 0]
slice1 = [1, 2, 3], slice2 = []

B

arr1 = [1, 2, 3], arr2 = [1, 2, 3]
slice1 = [1, 2, 3], slice2 = [1, 2, 3]

C Compilation error: arrays do not implement Copy

D Compilation error: slices do not implement Copy

💡 Hint

Arrays of Copy types implement Copy; slices are references and also Copy.

Arrays of integers implement Copy, so arr1 is copied to arr2. Slices are references and implement Copy, so slice1 is copied to slice2. Both print the same values.

Practice

1. Which of the following types in Rust is a Copy type by default?

easy

A. A String

B. An integer like i32

C. A vector like Vec<i32>

D. A struct with a String field

Solution

1. Step 1: Identify primitive types with Copy trait

   Primitive scalar types like integers (i32) implement Copy by default.

2. Step 2: Understand ownership of heap data

   Types like String and Vec own heap data and do not implement Copy automatically.

3. Final Answer:

   An integer like i32 -> Option B

4. Quick Check:

   Primitive types = Copy [OK]

Hint: Primitive scalars like i32 are Copy by default [OK]

Common Mistakes:

• Thinking String is Copy because it looks simple
• Assuming all structs are Copy without checking fields
• Confusing heap-allocated types with Copy types

2. Which syntax correctly derives the Copy trait for a struct in Rust?

easy

A. struct Point { x: i32, y: i32 } // Copy is automatic

B. #[derive(Clone)] struct Point { x: i32, y: i32 }

C. #[derive(Copy, Clone)] struct Point { x: i32, y: i32 }

D. #[derive(Copy)] struct Point { x: i32, y: i32 }

Solution

1. Step 1: Recall trait derivation rules

   To make a struct Copy, you must derive both Copy and Clone traits.

2. Step 2: Check each option

   #[derive(Copy, Clone)] struct Point { x: i32, y: i32 } correctly derives both traits. #[derive(Clone)] struct Point { x: i32, y: i32 } misses Copy. struct Point { x: i32, y: i32 } // Copy is automatic is wrong because Copy is not automatic for structs. #[derive(Copy)] struct Point { x: i32, y: i32 } misses Clone.

3. Final Answer:

   #[derive(Copy, Clone)] struct Point { x: i32, y: i32 } -> Option C

4. Quick Check:

   Copy requires Copy + Clone traits [OK]

Hint: Always derive both Copy and Clone for Copy types [OK]

Common Mistakes:

• Deriving only Copy without Clone
• Assuming Copy is automatic for structs
• Forgetting to derive Clone along with Copy

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

#[derive(Copy, Clone)]
struct Color(u8, u8, u8);

fn main() {
    let c1 = Color(255, 0, 0);
    let c2 = c1;
    println!("{} {} {}", c1.0, c1.1, c1.2);
}

medium

A. 255 0 0

B. Compile error: use of moved value

C. 0 0 0

D. Runtime panic

Solution

1. Step 1: Understand Copy trait effect on assignment

   Since Color derives Copy, assigning c1 to c2 copies the data, not moves it.

2. Step 2: Check usage after assignment

   Because c1 is still valid, printing its fields outputs the original values.

3. Final Answer:

   255 0 0 -> Option A

4. Quick Check:

   Copy means no move, data duplicated [OK]

Hint: Copy types allow use after assignment without move errors [OK]

Common Mistakes:

• Expecting a move error after assignment
• Thinking c1 is invalid after c2 = c1
• Confusing Copy with Clone behavior

4. Identify the error in this Rust code snippet:

#[derive(Copy)]
struct Point { x: i32, y: i32 }

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

medium

A. Assignment moves ownership, so p1 is invalid

B. Cannot print struct fields directly

C. No error, code runs fine

D. Missing Clone trait derivation causes compile error

Solution

1. Step 1: Check trait derivations

   The struct derives only Copy, but Copy requires Clone to be implemented too.

2. Step 2: Understand compiler requirements

   Rust compiler will error because Clone is missing, even if Copy is derived.

3. Final Answer:

   Missing Clone trait derivation causes compile error -> Option D

4. Quick Check:

   Copy needs Clone too [OK]

Hint: Derive Clone along with Copy to avoid errors [OK]

Common Mistakes:

• Assuming Copy alone is enough
• Thinking printing fields causes error
• Confusing move error with trait error

5. You want to create a struct Pixel with fields x: u32, y: u32, and color: (u8, u8, u8). You want Pixel to be a Copy type. Which of the following is the correct approach?

hard

A. Derive Copy and Clone for Pixel since all fields are Copy types

B. Implement Copy manually without Clone

C. Use String for color and derive Copy

D. Derive only Clone for Pixel

Solution

1. Step 1: Check field types for Copy trait

   Fields u32 and tuple of u8 are all Copy types.

2. Step 2: Derive Copy and Clone for struct

   Since all fields are Copy, deriving both Copy and Clone for Pixel makes it a Copy type.

3. Final Answer:

   Derive Copy and Clone for Pixel since all fields are Copy types -> Option A

4. Quick Check:

   All fields Copy + derive Copy & Clone = Copy type [OK]

Hint: All fields Copy? Derive Copy and Clone for struct [OK]

Common Mistakes:

• Using String for color which is not Copy
• Deriving only Clone without Copy
• Trying to implement Copy manually