Tuple indexing and slicing in Python - Time & Space Complexity

Time Complexity: Tuple indexing and slicing

O(k)

Understanding Time Complexity

Let's see how fast we can get parts of a tuple using indexing and slicing.

We want to know how the time to get these parts changes when the tuple gets bigger.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

my_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

# Access single element by index
single_element = my_tuple[3]

# Access a slice of the tuple
slice_part = my_tuple[2:7]

# Access another slice
another_slice = my_tuple[:5]

This code gets one element and two slices from a tuple.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Accessing elements by index or slice.
• How many times: Single element access happens once; slicing creates a new tuple by copying elements in the slice range.

How Execution Grows With Input

Getting one element by index takes the same time no matter how big the tuple is.

Getting a slice takes longer if the slice is bigger because it copies each element in the slice.

Input Size (n)	Approx. Operations for single element	Approx. Operations for slice of size k
10	1	5 (if k=5)
100	1	5 (if k=5)
1000	1	5 (if k=5)

Pattern observation: Single element access stays constant; slice cost depends on slice size, not total tuple size.

Final Time Complexity

Time Complexity: O(k)

This means accessing one element is very fast and does not depend on tuple size, but slicing takes time proportional to how many elements you take.

Common Mistake

[X] Wrong: "Accessing any part of a tuple always takes the same time no matter what."

[OK] Correct: Single element access is fast, but slicing copies elements, so it takes longer if the slice is bigger.

Interview Connect

Knowing how tuple access works helps you write faster code and answer questions about data handling clearly and confidently.

Self-Check

"What if we changed the tuple to a list? How would the time complexity for slicing change?"

Practice

1.

What does my_tuple[2] return if my_tuple = (10, 20, 30, 40)?

easy

A. 30

B. 20

C. 40

D. 10

Solution

1. Step 1: Understand tuple indexing

   Indexing starts at 0, so index 2 means the third item in the tuple.

2. Step 2: Identify the item at index 2

   The tuple is (10, 20, 30, 40), so the item at index 2 is 30.

3. Final Answer:

   30 -> Option A

4. Quick Check:

   Index 2 in tuple = 30 [OK]

Hint: Remember: indexing starts at zero in tuples [OK]

Common Mistakes:

• Counting from 1 instead of 0
• Confusing index 2 with index 3
• Mixing up tuple with list indexing

2.

Which of the following is the correct syntax to get the last item of a tuple t?

easy

A. t[1]

B. t[-1]

C. t[last]

D. t[len(t)]

Solution

1. Step 1: Recall negative indexing in tuples

   Negative index -1 accesses the last item in a tuple.

2. Step 2: Check each option

   t[-1] correctly accesses the last item. t[1] accesses second item, t[last] is invalid syntax, t[len(t)] causes IndexError because indexing starts at 0.

3. Final Answer:

   t[-1] -> Option B

4. Quick Check:

   Last item index = -1 [OK]

Hint: Use -1 to get last item from any tuple [OK]

Common Mistakes:

• Using len(t) as index (out of range)
• Trying to use variable 'last' as index
• Confusing positive and negative indexes

3.

What is the output of this code?

t = (5, 10, 15, 20, 25)
print(t[1:4])

medium

A. (10, 15, 20)

B. (10, 15, 20, 25)

C. (5, 10, 15)

D. (15, 20, 25)

Solution

1. Step 1: Understand slicing syntax

   Slicing t[1:4] means start at index 1 up to but not including index 4.

2. Step 2: Extract the slice from the tuple

   Tuple is (5, 10, 15, 20, 25). Index 1 is 10, index 2 is 15, index 3 is 20. Index 4 (25) is excluded.

3. Final Answer:

   (10, 15, 20) -> Option A

4. Quick Check:

   Slicing excludes end index [OK]

Hint: Slice excludes the end index, so stop before it [OK]

Common Mistakes:

• Including the end index in slice
• Confusing indexes with values
• Using parentheses instead of brackets for slicing

4.

Find the error in this code:

t = (1, 2, 3, 4, 5)
print(t[5])

medium

A. Prints 5

B. SyntaxError

C. IndexError: tuple index out of range

D. Prints 1

Solution

1. Step 1: Check tuple length and indexing

   Tuple has 5 items indexed 0 to 4. Index 5 is outside this range.

2. Step 2: Understand what happens when accessing invalid index

   Accessing t[5] causes an IndexError because the index is out of range.

3. Final Answer:

   IndexError: tuple index out of range -> Option C

4. Quick Check:

   Index must be less than length [OK]

Hint: Index must be less than tuple length [OK]

Common Mistakes:

• Using index equal to length
• Confusing SyntaxError with IndexError
• Assuming last index is length instead of length-1

5.

Given t = (2, 4, 6, 8, 10, 12), which expression returns a tuple with every second item starting from the last item going backwards?

hard

A. t[1::2]

B. t[::2]

C. t[-2::-1]

D. t[::-2]

Solution

1. Step 1: Understand slicing with negative step

   A negative step means slicing backwards. t[::-2] starts from the end and takes every second item backwards.

2. Step 2: Check what t[::-2] returns

   Tuple is (2,4,6,8,10,12). t[::-2] picks 12 (last), 8, 4, resulting in (12, 8, 4).

3. Final Answer:

   t[::-2] -> Option D

4. Quick Check:

   Negative step slices backwards skipping items [OK]

Hint: Use negative step in slice to go backwards [OK]

Common Mistakes:

• Using positive step for backward slicing
• Starting slice incorrectly
• Confusing slice start and step positions