Background Knowledge

NumPy Array Indexing Fundamentals

NumPy arrays are the standard representation for numerical data in Python. They support efficient element access through indexing, which is a fundamental operation in array programming. NumPy indexing follows these core principles:

• Zero-based indexing: The first element is at index 0
• Positive indices: Access elements from the beginning (0, 1, 2,...)
• Negative indices: Access elements from the end (-1 is the last element, -2 is second-to-last, etc.)
• Direct access: Retrieving an element by index takes constant time $O(1)$

For 1D arrays, arr[i] returns the element at position i. For multi-dimensional arrays, arr[i, j] accesses row i, column j. This indexing mechanism is consistent across NumPy operations and is designed to be intuitive and efficient.

Algorithm Approach

This problem requires three basic indexing operations:

1. First element: Access index 0 directly
2. Last element: Use negative indexing with index -1 (or equivalently, len(arr) - 1)
3. Middle element: Calculate the middle index as len(arr) // 2 using integer division

The approach leverages NumPy's constant-time indexing capability, making this an $O(1)$ operation per access.

Step-by-Step Strategy

Step 1: Get the first element

first = arr

Step 2: Get the last element using negative indexing

last = arr[-1]

Step 3: Calculate and access the middle element

middle_index = len(arr) // 2
middle = arr[middle_index]

Step 4: Return results as a dictionary

return {"first": first, "last": last, "middle": middle}

Complete Solution:

import numpy as np

def get_elements(arr):
 return {
 "first": arr,
 "last": arr[-1],
 "middle": arr[len(arr) // 2]
 }

Common Pitfalls

• Off-by-one errors: Remember that indexing is zero-based; the first element is at index 0, not 1
• Forgetting negative indexing: Using arr[len(arr) - 1] instead of arr[-1] is valid but less Pythonic
• Integer division: Use // (floor division) instead of / (float division) to get an integer index
• Empty arrays: The constraints guarantee at least 1 element, but in production code, always validate array length
• Type conversion: Ensure the result values are extracted as Python scalars (NumPy handles this automatically with single-element indexing)

Time & Space Complexity

• Time Complexity: $O(1)$ — Each indexing operation (first, last, middle) is a constant-time lookup regardless of array size
• Space Complexity: $O(1)$ — The dictionary stores only three scalar values, consuming constant extra space independent of input size