Slice syntax in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust slice code?

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 [30, 40, 50]

B [20, 30, 40]

C [20, 30, 40, 50]

D [10, 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 does this Rust code print with negative indexing attempt?

What will happen when running this Rust code?

Rust

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

A Runtime panic

B [3, 4, 5]

C Compile-time error

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

💡 Hint

Rust slice indices must be usize and cannot be negative.

Rust does not allow negative indices in slices. This code will not compile because -3 is not a valid usize index.

❓ Predict Output

advanced

What is the output of this Rust slice with step-like pattern?

What will this Rust code print?

Rust

fn main() {
    let arr = [5, 10, 15, 20, 25, 30];
    let slice = &arr[1..6];
    let filtered: Vec<_> = slice.iter().step_by(2).collect();
    println!("{:?}", filtered);
}

A [10, 20, 30]

B [10, 15, 20, 25, 30]

C [5, 15, 25]

D [15, 25]

💡 Hint

step_by(2) picks every second element starting from the first in the slice.

The slice is [10, 15, 20, 25, 30]. step_by(2) picks elements at indices 0, 2, 4 in the slice, which are 10, 20, 30.

🔧 Debug

advanced

Why does this Rust slice code panic at runtime?

This Rust code panics when run. Why?

Rust

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

A The code has a syntax error in slice syntax

B Slice start index 2 is invalid because it is less than end index 6

C Rust slices cannot be created from arrays

D Slice end index 6 is out of bounds for array length 4, causing panic

💡 Hint

Check if the slice indices are within the array length.

The slice tries to access elements up to index 6, but the array length is 4, so it panics at runtime.

🧠 Conceptual

expert

How many elements are in this Rust slice?

Given the Rust code below, how many elements does the slice contain?

Rust

fn main() {
    let arr = [100, 200, 300, 400, 500, 600];
    let slice = &arr[2..=4];
    println!("{}", slice.len());
}

A 3

B 2

C 4

D 5

💡 Hint

The inclusive range syntax [start..=end] includes the end index.

The slice includes elements at indices 2, 3, and 4, so length is 3.

Practice

1. What does the slice syntax &array[2..5] mean in Rust?

easy

A. It creates a view of elements from index 2 up to but not including 5.

B. It copies elements from index 2 to 5 inclusive into a new array.

C. It creates a slice starting at index 5 and ending at index 2.

D. It returns the element at index 2 only.

Solution

1. Step 1: Understand slice range syntax

   The syntax start..end means from start index up to but not including end index.

2. Step 2: Apply to given slice

   So &array[2..5] means elements at indices 2, 3, and 4 are included in the slice.

3. Final Answer:

   It creates a view of elements from index 2 up to but not including 5. -> Option A

4. Quick Check:

   Slice range excludes end index = A [OK]

Hint: Remember slice excludes the end index, like half-open intervals [OK]

Common Mistakes:

• Thinking the slice copies elements instead of borrowing
• Including the end index element in the slice
• Confusing slice with single element access

2. Which of the following is the correct way to get a slice of the first 4 elements of an array named nums?

easy

A. &nums[1..4]

B. &nums[0..4]

C. &nums[0..5]

D. &nums[4..0]

Solution

1. Step 1: Identify slice start and end for first 4 elements

   The first 4 elements are at indices 0, 1, 2, and 3, so slice should start at 0 and end at 4 (exclusive).

2. Step 2: Check options for correct syntax

   &nums[0..4] uses &nums[0..4], which correctly slices elements 0 to 3.

3. Final Answer:

   &nums[0..4] -> Option B

4. Quick Check:

   Slice first 4 elements = &nums[0..4] [OK]

Hint: Start at 0, end at count for first N elements [OK]

Common Mistakes:

• Starting slice at 1 instead of 0
• Including one extra element by using end index too high
• Using reversed range which is invalid

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. [20, 30, 40, 50]

B. [10, 20, 30, 40]

C. [20, 30, 40]

D. [30, 40, 50]

Solution

1. Step 1: Identify slice indices and elements

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

2. Step 2: Understand print output

   Printing the slice with {:?} shows the elements in array-like format.

3. Final Answer:

   [20, 30, 40] -> Option C

4. Quick Check:

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

Hint: Slice excludes end index, so count elements carefully [OK]

Common Mistakes:

• Including element at index 4 mistakenly
• Printing the whole array instead of slice
• Confusing slice with copying elements

4. What is wrong with this Rust code?

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

medium

A. The slice start index is greater than the end index, causing a panic.

B. The slice syntax is correct and will return an empty slice.

C. The code will compile but slice will contain elements 3 and 2.

D. The slice must use parentheses instead of brackets.

Solution

1. Step 1: Analyze slice indices order

   The slice &arr[3..2] has start index 3 and end index 2, which is invalid because start must be less than or equal to end.

2. Step 2: Understand Rust slice behavior

   Rust panics at runtime if slice start is greater than end; it does not return empty slice or reorder indices.

3. Final Answer:

   The slice start index is greater than the end index, causing a panic. -> Option A

4. Quick Check:

   Slice start > end causes panic [OK]

Hint: Slice start must be ≤ end; else panic occurs [OK]

Common Mistakes:

• Assuming reversed slice returns empty slice
• Thinking slice silently swaps indices
• Using parentheses instead of brackets for slices

5. Given a string let text = "hello world";, which slice expression extracts the word "world" correctly?

hard

A. &text[..5]

B. &text[5..10]

C. &text[6..10]

D. &text[6..]

Solution

1. Step 1: Identify indices of "world" in the string

   "hello world" has "world" starting at index 6 and goes to the end (index 10 inclusive).

2. Step 2: Check slice options

   &text[6..] uses &text[6..] which means from index 6 to the end, correctly extracting "world".

3. Final Answer:

   &text[6..] -> Option D

4. Quick Check:

   Slice from start index to end = &text[6..] [OK]

Hint: Use start.. to slice from start index to string end [OK]

Common Mistakes:

• Using wrong end index excluding last character
• Confusing byte indices with character indices (not in this example)
• Using slice that extracts wrong substring