Array slices in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code using array slices?

Consider the following Rust code snippet. What will it print?

Rust

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

A [10, 20, 30, 40]

B [30, 40, 50]

C [20, 30, 40, 50]

D [20, 30, 40]

💡 Hint

Remember that the slice syntax [start..end] includes start but excludes end.

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

❓ Predict Output

intermediate

What is the length of this slice?

Given this Rust code, what is the length of the slice named `part`?

Rust

fn main() {
    let numbers = [5, 10, 15, 20, 25, 30];
    let part = &numbers[2..5];
    println!("{}", part.len());
}

A 2

B 4

C 3

D 5

💡 Hint

Length is end index minus start index.

The slice covers indices 2, 3, and 4, so length is 5 - 2 = 3.

🔧 Debug

advanced

Why does this Rust code cause a panic?

Examine this Rust code. Why does it panic at runtime?

Rust

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

A The slice range 3..7 goes beyond the array length, causing a panic.

B The slice syntax is invalid because it uses two dots instead of three.

C The array is immutable, so slicing is not allowed.

D The println! macro cannot print slices.

💡 Hint

Check the array length and the slice range carefully.

The array has length 5, but the slice tries to access indices 3 to 6 (7 excluded), which is out of bounds.

🧠 Conceptual

advanced

Which statement about Rust array slices is true?

Select the correct statement about array slices in Rust.

A Slices are views into arrays and do not own the data they reference.

B Slices can be resized dynamically like vectors.

C Slices own the data they contain and manage memory automatically.

D Slices can only be created from vectors, not arrays.

💡 Hint

Think about ownership and borrowing in Rust.

Slices are references to parts of arrays or vectors and do not own the data; they borrow it.

❓ Predict Output

expert

What is the output of this Rust code using mutable slices?

Analyze the following Rust code. What will it print?

Rust

fn main() {
    let mut arr = [1, 2, 3, 4, 5];
    {
        let slice = &mut arr[1..4];
        for x in slice.iter_mut() {
            *x *= 2;
        }
    }
    println!("{:?}", arr);
}

A [2, 4, 6, 8, 10]

B [1, 4, 6, 8, 5]

C [1, 2, 3, 4, 5]

D [1, 4, 6, 8, 10]

💡 Hint

The slice modifies elements at indices 1, 2, and 3 by doubling them.

Elements at indices 1, 2, and 3 are doubled: 2->4, 3->6, 4->8. Others remain unchanged.

Practice

1. What is an array slice in Rust?

easy

A. A new array created by copying elements

B. A macro to print arrays

C. A function that modifies an array

D. A reference to a part of an array without copying data

Solution

1. Step 1: Understand what a slice is

   A slice is a reference to a contiguous part of an array, not a new array.

2. Step 2: Compare options

   Only A reference to a part of an array without copying data correctly describes a slice as a reference without copying.

3. Final Answer:

   A reference to a part of an array without copying data -> Option D

4. Quick Check:

   Slice = reference to part of array [OK]

Hint: Remember: slices borrow, they don't copy [OK]

Common Mistakes:

• Thinking slices create new arrays
• Confusing slices with functions
• Assuming slices own data

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

easy

A. let slice = &arr[1..4];

B. let slice = arr.slice(1, 4);

C. let slice = arr[1:4];

D. let slice = &arr(1..4);

Solution

1. Step 1: Recall Rust slice syntax

   Rust uses &array[start..end] to create a slice referencing elements from start up to but not including end.

2. Step 2: Check each option

   let slice = &arr[1..4]; uses correct Rust syntax. Options A, B, and C use invalid syntax.

3. Final Answer:

   let slice = &arr[1..4]; -> Option A

4. Quick Check:

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

Hint: Use &array[start..end] for slices [OK]

Common Mistakes:

• Using parentheses instead of brackets
• Using colons instead of two dots
• Calling slice as a method

3. What is the output of this Rust code?

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

medium

A. [30, 40, 50]

B. [10, 20, 30]

C. [20, 30, 40]

D. [1, 4]

Solution

1. Step 1: Understand the slice range

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

2. Step 2: Check the printed output

   Printing the slice shows the elements in the slice as an array-like list.

3. Final Answer:

   [20, 30, 40] -> Option C

4. Quick Check:

   Slice arr[1..4] = [20, 30, 40] [OK]

Hint: Remember slice excludes the end index element [OK]

Common Mistakes:

• Including the element at index 4
• Starting slice at index 0
• Printing the slice as indices

4. Identify the error in this Rust code snippet:

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

medium

A. The slice range goes out of bounds

B. The slice syntax is incorrect

C. The array is not mutable

D. The println! macro is used incorrectly

Solution

1. Step 1: Check the slice range

   The array has length 5, valid indices are 0 to 4. The slice uses 2..6, which tries to access index 5 (out of bounds).

2. Step 2: Identify the error type

   Rust will panic at runtime due to out-of-bounds slicing.

3. Final Answer:

   The slice range goes out of bounds -> Option A

4. Quick Check:

   Slice range must be within array length [OK]

Hint: Slice end index must be ≤ array length [OK]

Common Mistakes:

• Using an end index beyond array length
• Confusing syntax errors with runtime errors
• Assuming arrays auto-expand

5. Given a function that takes a slice of integers and returns the sum of its elements, which of the following implementations is correct?

fn sum_slice(slice: &[i32]) -> i32 {
    // fill in
}

hard

A. slice.to_vec().sum()

B. slice.iter().sum()

C. slice[0] + slice[1]

D. slice.sum()

Solution

1. Step 1: Understand slice methods

   A slice has an iterator via .iter(), and iterators have a .sum() method to add elements.

2. Step 2: Evaluate each option

   slice.iter().sum() correctly uses slice.iter().sum(). slice.to_vec().sum() is valid because Vec<i32> has sum() method. slice[0] + slice[1] only sums two elements, not all. slice.sum() is invalid because slices don't have sum() directly.

3. Final Answer:

   slice.iter().sum() -> Option B

4. Quick Check:

   Use iter().sum() to sum slice elements [OK]

Hint: Use slice.iter().sum() to sum elements [OK]

Common Mistakes:

• Trying to call sum() directly on slice
• Summing only first two elements
• Calling sum() on Vec<i32>