Slice syntax in Rust - Mini Project: Build & Apply

Slice syntax

📖 Scenario: You are working with a list of daily temperatures recorded over a week. You want to extract parts of this list to analyze specific days.

🎯 Goal: Learn how to use Rust slice syntax to select parts of an array.

📋 What You'll Learn

Create an array with exact temperature values

Create a variable for the slice start index

Use slice syntax to get a part of the array

Print the sliced part

💡 Why This Matters

🌍 Real World

Slicing is useful when you want to work with parts of data, like selecting specific days' temperatures from a week.

💼 Career

Understanding slice syntax is important for efficient data handling in Rust, which is used in systems programming and performance-critical applications.

1

Create the temperature array

Create an array called temps with these exact values: [23, 25, 22, 20, 19, 21, 24]

Rust

# Create the array 'temps' with the given values
# Your code here

Hint

Use let temps = [23, 25, 22, 20, 19, 21, 24]; to create the array.

2

Set the slice start index

Create a variable called start and set it to 2 to mark where the slice will begin

Rust

fn main() {
    let temps = [23, 25, 22, 20, 19, 21, 24];
    // Create 'start' variable with value 2
    // Your code here
}

Hint

Use let start = 2; to create the variable.

3

Create a slice from the array

Create a variable called slice that slices temps from start up to but not including index 5 using Rust slice syntax

Rust

fn main() {
    let temps = [23, 25, 22, 20, 19, 21, 24];
    let start = 2;
    // Create 'slice' from 'temps' using 'start' to 5
    // Your code here
}

Hint

Use let slice = &temps[start..5]; to create the slice.

4

Print the slice

Print the slice variable using println! with the format string {:?} to show the slice contents

Rust

fn main() {
    let temps = [23, 25, 22, 20, 19, 21, 24];
    let start = 2;
    let slice = &temps[start..5];
    // Print the slice
    // Your code here
}

Hint

Use println!("{:?}", slice); to print the slice.

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