Array Slicing

1. Background Knowledge

NumPy arrays are the foundational data structure for numerical computing in Python, enabling efficient vectorized operations on multi-dimensional data. Slicing extracts portions of arrays using the syntax arr[start:stop:step], where:

• start: Inclusive starting index (default: 0)
• stop: Exclusive ending index (default: array length)
• step: Increment between indices (default: 1, negative for reverse)

Slices create views (shallow copies) by default, sharing memory with the original array for efficiency—modifications affect the source. This contrasts with indexing, which often returns copies. Prerequisites: Basic Python lists/arrays and NumPy ndarray creation via np.array().

2. Algorithm Approach

Use pure slicing operations without loops or conditionals, leveraging NumPy's vectorized indexing:

• Prefix slicing: arr[:3] for first n elements.
• Suffix slicing: arr[-3:] for last n elements (negative indices count from end).
• Strided slicing: arr[::2] for every kth element.
• Reversal: arr[::-1] (step = -1).

Convert slices to lists via .tolist() for dictionary output. This exploits NumPy's $O(1)$ slice creation time due to view semantics.

3. Step-by-Step Strategy

1. Access input: Function receives arr (1D NumPy array, length $\geq 3$).
2. Extract slices:

• "first_three": arr[:3]
• "last_three": arr[-3:]
• "every_other": arr[::2] (starts at 0, step 2)
• "reversed": arr[::-1]

3. Convert to lists: Apply .tolist() to each slice.
4. Build dictionary: Return {"first_three":..., "last_three":...,...}.
5. Test: Verify with sample [0,1,2,3,4,5,6,7,8,9].

import numpy as np

def slice_array(arr):
 return {
 "first_three": arr[:3].tolist(),
 "last_three": arr[-3:].tolist(),
 "every_other": arr[::2].tolist(),
 "reversed": arr[::-1].tolist()
 }

4. Common Pitfalls

• Forgetting .tolist(): Slices return ndarray, not list—dictionary requires lists.
• Index errors: Constraints guarantee $\geq 3$ elements, but arr[-3:] fails on length=2.
• Modifying views: slice_arr = arr[:3]; slice_arr = 99 alters original arr.
• Step confusion: ::2 skips every other (even indices); 1::2 for odds.
• Multi-D arrays: Problem assumes 1D; higher dims need arr[0, :3] etc.
• Inclusive/exclusive mix-up: stop is exclusive (arr[:3] gets indices 0,1,2).

5. Time & Space Complexity

• Time: $O(n)$ where $n = \text{len}(\rm arr)$—slicing is $O(1)$ (view creation), but .tolist() copies data: first_three/last_three = $O(1)$, every_other = $O(n/2)$, reversed = $O(n)$.
• Space: $O(n)$ worst-case for full copies in lists; slices themselves use $O(1)$ extra (views share memory).

Total: $\Theta(n)$ time and space, optimal for output size. No loops ensure vectorized efficiency.