Why slices are used in Rust - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code using slices?

Look at this Rust code that uses a slice to access part of an array. What will it print?

Rust

fn main() {
    let arr = [10, 20, 30, 40, 50];
    let slice = &arr[1..4];
    for &item in slice {
        print!("{} ", item);
    }
}

A 10 20 30 40

B 10 20 30 40 50

C 30 40 50

D 20 30 40

💡 Hint

Remember, slices use a range to select elements starting at the first index and up to but not including the last index.

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

🧠 Conceptual

intermediate

Why are slices preferred over copying arrays in Rust?

Which reason best explains why Rust programmers use slices instead of copying arrays?

A Slices automatically sort the data for faster access.

B Slices allow borrowing parts of data without copying, saving memory and time.

C Slices convert arrays into strings for easier printing.

D Slices duplicate the entire array to avoid ownership issues.

💡 Hint

Think about what happens when you copy data versus just referencing it.

Slices let you borrow a view into data without making a full copy, which is efficient and safe.

🔧 Debug

advanced

What error does this Rust code with slices produce?

Examine this Rust code snippet. What error will it cause when compiled?

Rust

fn main() {
    let arr = [1, 2, 3];
    let slice = &arr[0..5];
    println!("{:?}", slice);
}

A Compile-time error: slice index out of bounds

B Compile-time error: mismatched types

C Runtime panic: index out of bounds

D No error, prints [1, 2, 3]

💡 Hint

Consider what happens if you try to slice beyond the array length.

The code compiles because the slice range is valid syntax, but at runtime it panics because the range exceeds the array size.

❓ Predict Output

advanced

What is the output of this Rust function using slices?

What will this Rust program print?

Rust

fn sum_slice(slice: &[i32]) -> i32 {
    slice.iter().sum()
}

fn main() {
    let numbers = [5, 10, 15, 20];
    let result = sum_slice(&numbers[1..3]);
    println!("{}", result);
}

A 25

B 30

C 50

D 10

💡 Hint

Remember the slice range includes elements at indices 1 and 2.

The slice &numbers[1..3] contains 10 and 15. Their sum is 25.

🧠 Conceptual

expert

Why do slices improve safety and performance in Rust?

Choose the best explanation for how slices help Rust programs be both safe and fast.

A Slices allow safe borrowing of data without copying, enforcing lifetime rules at compile time.

B Slices provide a fixed-size copy of data, preventing accidental changes.

C Slices automatically parallelize data processing for faster execution.

D Slices convert data into immutable strings to avoid race conditions.

💡 Hint

Think about Rust's ownership and borrowing system and how slices fit in.

Slices let you borrow parts of data safely, with the compiler checking lifetimes to avoid bugs and without the cost of copying.

Practice

1. Why are slices used in Rust?
let arr = [1, 2, 3, 4]; let slice = &arr[1..3];

easy

A. To access a part of a collection without copying the data

B. To create a new independent array from the original

C. To permanently delete elements from the array

D. To convert an array into a string

Solution

1. Step 1: Understand what a slice does

   A slice is a reference to a part of a collection, like a section of an array, without copying the data.

2. Step 2: Analyze the example code

   The code &arr[1..3] creates a slice referencing elements at index 1 and 2, not a new array or deletion.

3. Final Answer:

   To access a part of a collection without copying the data -> Option A

4. Quick Check:

   Slices = references to parts of collections [OK]

Hint: Slices reference parts without copying data [OK]

Common Mistakes:

• Thinking slices copy data
• Confusing slices with new arrays
• Assuming slices delete elements

2. Which of the following is the correct syntax to create a slice of the first three elements of an array arr in Rust?

easy

A. let slice = arr[0..3];

B. let slice = arr[0, 3];

C. let slice = arr.slice(0, 3);

D. let slice = &arr[0..3];

Solution

1. Step 1: Recall slice syntax in Rust

   Rust slices are references, so you must use & before the range to create a slice.

2. Step 2: Check each option

   let slice = &arr[0..3]; uses &arr[0..3], which is the correct syntax. let slice = arr[0..3]; misses the reference, B uses invalid syntax, and C uses a non-existent method.

3. Final Answer:

   let slice = &arr[0..3]; -> Option D

4. Quick Check:

   Slice syntax = &array[start..end] [OK]

Hint: Slices need & before range to reference data [OK]

Common Mistakes:

• Omitting & before the slice range
• Using invalid methods like slice()
• Using comma instead of range syntax

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

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

medium

A. [30, 40]

B. [20, 30]

C. [30, 40, 50]

D. [10, 20]

Solution

1. Step 1: Understand the slice range

   The slice &arr[2..4] includes elements at index 2 and 3 (end index 4 is exclusive).

2. Step 2: Identify elements at those indices

   Index 2 is 30, index 3 is 40, so the slice contains [30, 40].

3. Final Answer:

   [30, 40] -> Option A

4. Quick Check:

   Slice range excludes end index [OK]

Hint: Slice end index is exclusive, so stop before it [OK]

Common Mistakes:

• Including the end index element
• Confusing indices with values
• Printing the whole array instead of slice

4. Find the error in this Rust code that tries to create a slice:

let arr = [1, 2, 3, 4];
let slice = arr[1..5];

medium

A. Array declaration syntax is wrong

B. Slice range is out of bounds and missing reference operator

C. Slice syntax is correct, no error

D. Slice must use parentheses instead of brackets

Solution

1. Step 1: Check the slice range validity

   The array has length 4, so index 5 is out of bounds causing an error.

2. Step 2: Check slice syntax

   The code misses the & reference operator needed to create a slice.

3. Final Answer:

   Slice range is out of bounds and missing reference operator -> Option B

4. Quick Check:

   Slice must be &array[start..end] within bounds [OK]

Hint: Slice must be referenced and within array bounds [OK]

Common Mistakes:

• Ignoring out of bounds index
• Forgetting & before slice
• Thinking brackets are wrong syntax

5. You want to write a function that takes a string slice and prints its first 3 characters safely. Which function signature and usage is correct in Rust?

hard

A. fn print_first_three(s: String) { println!("{}", &s[0..3]); }

B. fn print_first_three(s: &String) { println!("{}", s[0..3]); }

C. fn print_first_three(s: &str) { println!("{}", &s[0..3]); }

D. fn print_first_three(s: &str) { println!("{}", s[0..3]); }

Solution

1. Step 1: Understand string slices and indexing

   String slices &str are references to string data and support slicing with range syntax and & to get a slice.

2. Step 2: Analyze each function signature and usage

   fn print_first_three(s: &str) { println!("{}", &s[0..3]); } correctly takes &str and slices with &s[0..3]. fn print_first_three(s: String) { println!("{}", &s[0..3]); } takes ownership (String) but slices correctly. fn print_first_three(s: &String) { println!("{}", s[0..3]); } misses & before slice. fn print_first_three(s: &str) { println!("{}", s[0..3]); } slices without &, causing error.

3. Final Answer:

   fn print_first_three(s: &str) { println!("{}", &s[0..3]); } -> Option C

4. Quick Check:

   Use &str and &s[start..end] for safe string slices [OK]

Hint: Use &str and &s[start..end] to slice strings safely [OK]

Common Mistakes:

• Using String instead of &str for slicing
• Omitting & before slice range
• Trying to slice without reference