Slice syntax in Rust - Time & Space Complexity

Time Complexity: Slice syntax

O(n)

Understanding Time Complexity

We want to understand how the time it takes to work with slices changes as the slice size grows.

Specifically, how does accessing or iterating over a slice behave as it gets bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

fn sum_slice(slice: &[i32]) -> i32 {
    let mut total = 0;
    for &item in slice {
        total += item;
    }
    total
}

This code adds up all the numbers in a slice of integers.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping through each element in the slice.
• How many times: Once for every element in the slice.

How Execution Grows With Input

As the slice gets bigger, the number of additions grows in the same way.

Input Size (n)	Approx. Operations
10	10 additions
100	100 additions
1000	1000 additions

Pattern observation: The work grows directly with the number of items.

Final Time Complexity

Time Complexity: O(n)

This means the time to sum the slice grows in a straight line as the slice gets bigger.

Common Mistake

[X] Wrong: "Accessing a slice element takes longer as the slice grows."

[OK] Correct: Accessing any single element by index is fast and does not depend on slice size. Only looping over all elements takes longer as the slice grows.

Interview Connect

Understanding how slice operations scale helps you explain how your code handles data efficiently, a key skill in many programming tasks.

Self-Check

"What if we changed the loop to only sum the first half of the slice? How would the time complexity change?"

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