Array indexing and slicing in Data Analysis Python - Time & Space Complexity

Time Complexity: Array indexing and slicing

O(1) for indexing, O(1) for slicing

Understanding Time Complexity

We want to understand how fast array indexing and slicing run as the data size grows.

How does the time to get or slice parts of an array change when the array gets bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

import numpy as np

arr = np.arange(1000)
value = arr[500]          # Indexing
sub_arr = arr[100:200]    # Slicing

This code gets one element by index and then gets a slice (view) of the array.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Accessing one element by index and creating a slice view.
• How many times: Both indexing and slicing are single constant-time operations (no loops).

How Execution Grows With Input

Getting one element by index takes the same time no matter the array size.

Getting a slice takes constant time no matter the array size or slice length (creates a view).

Input Size (n)	Approx. Operations for Indexing	Approx. Operations for Slicing
10	1	1
100	1	1
1000	1	1

Pattern observation: Both indexing and slicing times stay constant regardless of array or slice size.

Final Time Complexity

Time Complexity: O(1) for indexing, O(1) for slicing

Both indexing and slicing are constant time no matter the array size; NumPy slicing creates a view without copying data.

Common Mistake

[X] Wrong: "Slicing an array copies data and takes O(k) time where k is slice length."

[OK] Correct: NumPy basic slicing creates a view sharing memory with the original, so it's O(1) like indexing.

Interview Connect

Knowing how indexing and slicing scale helps you write efficient data code and answer questions about data access speed clearly.

Self-Check

"What if we slice the entire array instead of a small part? How would the time complexity change? (Hint: still O(1))"

Practice

1. What does the expression arr[2] do when arr is a Python list?

easy

A. Returns the first two elements of the list

B. Removes the element at index 2 from the list

C. Returns a new list with elements from index 0 to 2

D. Returns the element at index 2 (third element) of the list

Solution

1. Step 1: Understand list indexing

   In Python, list indexing starts at 0, so index 2 means the third element.

2. Step 2: Identify what arr[2] returns

   This expression returns the single element at position 2, not a range or removal.

3. Final Answer:

   Returns the element at index 2 (third element) of the list -> Option D

4. Quick Check:

   Index 2 means third element [OK]

Hint: Indexing gets one element by position [OK]

Common Mistakes:

• Thinking slicing syntax is used for single element
• Confusing index 2 with first two elements
• Assuming it removes an element

2. Which of the following is the correct syntax to get a slice of a list lst from index 1 to 4 (excluding 4)?

easy

A. lst(1:4)

B. lst[1:4]

C. lst[1,4]

D. lst[1-4]

Solution

1. Step 1: Recall Python slice syntax

   Slicing uses square brackets with colon: start:stop, where stop is excluded.

2. Step 2: Check each option

   Only lst[1:4] uses correct slice syntax to get elements at indices 1, 2, 3.

3. Final Answer:

   lst[1:4] -> Option B

4. Quick Check:

   Slice syntax uses colon [OK]

Hint: Use colon inside brackets for slicing [OK]

Common Mistakes:

• Using comma instead of colon
• Using parentheses instead of brackets
• Using dash instead of colon

3. Given arr = [10, 20, 30, 40, 50], what is the output of arr[1:4]?

medium

A. [20, 30, 40]

B. [10, 20, 30, 40]

C. [30, 40, 50]

D. [20, 30, 40, 50]

Solution

1. Step 1: Understand slicing indices

   The slice arr[1:4] includes elements from index 1 up to but not including index 4.

2. Step 2: Extract elements at indices 1, 2, 3

   These are 20 (index 1), 30 (index 2), and 40 (index 3).

3. Final Answer:

   [20, 30, 40] -> Option A

4. Quick Check:

   Slice excludes stop index [OK]

Hint: Slice includes start, excludes stop index [OK]

Common Mistakes:

• Including element at stop index
• Confusing indices with values
• Off-by-one errors in slicing

4. What is wrong with this code snippet?

arr = [1, 2, 3, 4, 5]
print(arr[2:6])

medium

A. It will print elements from index 2 to 6 including index 6

B. It will cause an IndexError because 6 is out of range

C. It will print elements from index 2 to 5 without error

D. It will print only the element at index 6

Solution

1. Step 1: Understand slicing behavior with out-of-range stop

   Python slicing does not raise error if stop index is beyond list length; it stops at the list end.

2. Step 2: Check what arr[2:6] returns

   It returns elements from index 2 to the end (index 4), which are [3, 4, 5].

3. Final Answer:

   It will print elements from index 2 to 5 without error -> Option C

4. Quick Check:

   Slicing stop can exceed length safely [OK]

Hint: Slicing stop index can exceed list length safely [OK]

Common Mistakes:

• Expecting IndexError for slicing beyond length
• Thinking slice includes stop index
• Confusing slicing with indexing

5. You have a list data = [5, 10, 15, 20, 25, 30]. How do you get every second element starting from index 1 up to index 5?

hard

A. data[1:6:2]

B. data[1:5:2]

C. data[1:5]

D. data[::2]

Solution

1. Step 1: Understand slicing with step

   Slicing syntax is start:stop:step. To get every second element, step=2.

2. Step 2: Identify correct start and stop

   Start is 1, stop is 6 to include element at index 5 (stop excluded).

3. Step 3: Verify the slice

   data[1:6:2] returns elements at indices 1, 3, 5 -> [10, 20, 30].

4. Final Answer:

   data[1:6:2] -> Option A

5. Quick Check:

   Use step in slice for skipping elements [OK]

Hint: Use third slice value for step size [OK]

Common Mistakes:

• Using wrong stop index excluding last element
• Omitting step and getting all elements
• Confusing step with start or stop