Array Access and Update at Index in DSA Python - Time & Space Complexity

Time Complexity: Array Access and Update at Index

O(1)

Understanding Time Complexity

We want to understand how fast we can get or change a value in an array at a certain position.

The question is: How does the time to access or update an element change as the array grows?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

arr = [10, 20, 30, 40, 50]
index = 2
value = arr[index]  # Access element at index 2
arr[index] = 100    # Update element at index 2

This code gets the value at position 2 and then changes it to 100.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Direct access to an array element by index.
• How many times: Exactly once for access and once for update.

How Execution Grows With Input

Accessing or updating an element does not depend on the size of the array.

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

Pattern observation: The number of operations stays the same no matter how big the array is.

Final Time Complexity

Time Complexity: O(1)

This means accessing or updating an element takes the same small amount of time no matter how big the array is.

Common Mistake

[X] Wrong: "Accessing an element takes longer if the array is bigger because it has to look through all elements."

[OK] Correct: Arrays allow direct access by index, so it jumps straight to the element without checking others.

Interview Connect

Knowing that array access and update are very fast helps you choose the right data structure for quick lookups and changes.

Self-Check

"What if we used a linked list instead of an array? How would the time complexity for access and update change?"

Practice

1. What does the expression arr[2] do in an array arr?

easy

A. Returns the length of the array

B. Adds a new element at index 2

C. Deletes the element at index 2

D. Accesses the element at index 2 in the array

Solution

1. Step 1: Understand array indexing

   Array elements are accessed using their index inside square brackets, starting from 0.

2. Step 2: Access element at index 2

   The expression arr[2] retrieves the third element in the array (index 2).

3. Final Answer:

   Accesses the element at index 2 in the array -> Option D

4. Quick Check:

   arr[2] means element at position 2 [OK]

Hint: Indexing with brackets gets element at that position [OK]

Common Mistakes:

• Thinking index starts at 1 instead of 0
• Confusing access with insertion or deletion
• Assuming arr[2] returns length

2. Which of the following is the correct syntax to update the element at index 1 of array arr to 10?

easy

A. arr[1] = 10

B. arr{1} = 10

C. arr(1) = 10

D. arr.1 = 10

Solution

1. Step 1: Identify correct syntax for array update

   In Python, arrays or lists use square brackets to access or update elements by index.

2. Step 2: Use square brackets for assignment

   To update element at index 1, write arr[1] = 10.

3. Final Answer:

   arr[1] = 10 -> Option A

4. Quick Check:

   Use square brackets for indexing and assignment [OK]

Hint: Use square brackets [] to access or update array elements [OK]

Common Mistakes:

• Using parentheses () instead of brackets []
• Using curly braces {} which are for sets or dicts
• Trying dot notation for indexing

3. What will be the output of the following code?

arr = [5, 10, 15, 20]
arr[2] = 25
print(arr)

medium

A. [5, 10, 25, 20]

B. [5, 10, 15, 20]

C. [25, 10, 15, 20]

D. Error

Solution

1. Step 1: Understand initial array and update

   Initial array is [5, 10, 15, 20]. The statement arr[2] = 25 updates the element at index 2 (third element) to 25.

2. Step 2: Print updated array

   After update, array becomes [5, 10, 25, 20]. Printing it shows this updated list.

3. Final Answer:

   [5, 10, 25, 20] -> Option A

4. Quick Check:

   arr[2] changed to 25, rest unchanged [OK]

Hint: Update changes element at index, print shows new array [OK]

Common Mistakes:

• Thinking arr[2] updates first element
• Expecting original array without change
• Assuming syntax error

4. Identify the error in the following code and choose the correct fix:

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

medium

A. TypeError because arr is immutable; fix by converting to list

B. SyntaxError due to wrong assignment; fix by using arr(3) = 4

C. IndexError because index 3 is out of range; fix by using arr.append(4)

D. No error; output is [1, 2, 3, 4]

Solution

1. Step 1: Analyze index used for update

   Array has indices 0,1,2. Trying to assign at index 3 causes IndexError (out of range).

2. Step 2: Correct way to add new element

   To add element at end, use arr.append(4) instead of assigning at invalid index.

3. Final Answer:

   IndexError because index 3 is out of range; fix by using arr.append(4) -> Option C

4. Quick Check:

   Index 3 invalid, append adds element safely [OK]

Hint: Use append() to add beyond last index, not assignment [OK]

Common Mistakes:

• Assigning to index beyond array length
• Using parentheses instead of brackets
• Assuming no error occurs

5. Given arr = [2, 4, 6, 8, 10], which code snippet correctly doubles the value at index 3 and then swaps it with the value at index 1?

hard

A. arr[3] *= 2
arr[1] = arr[3]
arr[3] = arr[1]

B. arr[3] = arr[3] * 2
arr[1], arr[3] = arr[3], arr[1]

C. arr[3] = arr[1]
arr[1] = arr[3] * 2

D. arr[1], arr[3] = arr[3] * 2, arr[1]

Solution

1. Step 1: Double value at index 3

   Original arr[3] is 8. Doubling: arr[3] = 8 * 2 = 16.

2. Step 2: Swap values at index 1 and 3

   Swap arr[1] (4) and arr[3] (16) using tuple unpacking: arr[1], arr[3] = arr[3], arr[1].

3. Final Answer:

   arr[3] = arr[3] * 2 arr[1], arr[3] = arr[3], arr[1] -> Option B

4. Quick Check:

   Double then swap using tuple unpacking [OK]

Hint: Double first, then swap with tuple unpacking [OK]

Common Mistakes:

• Overwriting values before swap
• Incorrect swap order or syntax
• Not doubling before swapping