Python Array & List Coding Interview Questions - 20 Problems

Master array and list manipulation - the most frequently tested topic in Python coding interviews. Includes Two Sum, Rotate Array, Merge Sorted Array, and more.

Optimal solutions with time/space complexity analysis and edge case handling for production interviews.

1. Two Sum (Array Hashing)

              
            
Python

          O(n) Hash Map - Most Asked
        
def twoSum(nums: list[int], target: int) -> list[int]:
    seen = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:
            return [seen[complement], i]
        seen[num] = i
    return []

# Test cases
print(twoSum([2,7,11,15], 9))     # [0,1]
print(twoSum([3,2,4], 6))         # [1,2]
print(twoSum([3,3], 6))           # [0,1]

**Time: O(n)** | **Space: O(n)** - Single pass hash map

2. Best Time to Buy and Sell Stock

              
            
Python

          One Pass O(n)
        
def maxProfit(prices: list[int]) -> int:
    min_price = float('inf')
    max_profit = 0
    
    for price in prices:
        min_price = min(min_price, price)
        max_profit = max(max_profit, price - min_price)
    return max_profit

print(maxProfit([7,1,5,3,6,4]))  # 5
print(maxProfit([7,6,4,3,1]))    # 0

3. Contains Duplicate

              
            
Python

          Hash Set O(n)
        
def containsDuplicate(nums: list[int]) -> bool:
    return len(nums) != len(set(nums))

# Alternative explicit solution
# def containsDuplicate(nums: list[int]) -> bool:
#     seen = set()
#     for num in nums:
#         if num in seen:
#             return True
#         seen.add(num)
#     return False

print(containsDuplicate([1,2,3,1]))  # True
print(containsDuplicate([1,2,3,4]))  # False

4. Rotate Array (Medium)

              
            
Python

          Reverse 3 Times O(n) In-place
        
def rotate(nums: list[int], k: int) -> None:
    """Do not return anything, modify nums in-place instead."""
    n = len(nums)
    k = k % n  # Handle k > n
    
    # Reverse entire array
    nums[:] = nums[::-1]
    # Reverse first k elements
    nums[:k] = nums[:k][::-1]
    # Reverse remaining elements
    nums[k:] = nums[k:][::-1]

nums = [1,2,3,4,5,6,7]
rotate(nums, 3)
print(nums)  # [5,6,7,1,2,3,4]

5. Move Zeroes

              
            
Python

          Two Pointers In-place
        
def moveZeroes(nums: list[int]) -> None:
    left = 0
    for right in range(len(nums)):
        if nums[right] != 0:
            nums[left], nums[right] = nums[right], nums[left]
            left += 1

nums = [0,1,0,3,12]
moveZeroes(nums)
print(nums)  # [1,3,12,0,0]

6. Single Number (Bit Manipulation)

              
            
Python

          XOR All Elements O(n)
        
def singleNumber(nums: list[int]) -> int:
    result = 0
    for num in nums:
        result ^= num
    return result

print(singleNumber([2,2,1]))      # 1
print(singleNumber([4,1,2,1,2]))  # 4

7. Product of Array Except Self (Medium)

              
            
Python

          Left & Right Pass O(n)
        
def productExceptSelf(nums: list[int]) -> list[int]:
    n = len(nums)
    result = [1] * n
    
    # Left pass
    for i in range(1, n):
        result[i] = result[i-1] * nums[i-1]
    
    # Right pass
    right = 1
    for i in range(n-2, -1, -1):
        right *= nums[i+1]
        result[i] *= right
    
    return result

print(productExceptSelf([1,2,3,4]))  # [24,12,8,6]

8. Merge Sorted Array

              
            
Python

          Three Pointers from End
        
def merge(nums1: list[int], m: int, nums2: list[int], n: int) -> None:
    # Merge from end to avoid overwriting
    p1, p2 = m - 1, n - 1
    p = m + n - 1
    
    while p1 >= 0 and p2 >= 0:
        if nums1[p1] > nums2[p2]:
            nums1[p] = nums1[p1]
            p1 -= 1
        else:
            nums1[p] = nums2[p2]
            p2 -= 1
        p -= 1
    
    # Copy remaining from nums2
    nums1[:p2+1] = nums2[:p2+1]

nums1 = [1,2,3,0,0,0]
nums2 = [2,5,6]
merge(nums1, 3, nums2, 3)
print(nums1)  # [1,2,2,3,5,6]

9. Maximum Subarray (Kadane's Algorithm)

              
            
Python

          Dynamic Programming O(n)
        
def maxSubArray(nums: list[int]) -> int:
    max_sum = current_sum = nums[0]
    
    for num in nums[1:]:
        current_sum = max(num, current_sum + num)
        max_sum = max(max_sum, current_sum)
    return max_sum

print(maxSubArray([-2,1,-3,4,-1,2,1,-5,4]))  # 6

10. Remove Duplicates from Sorted Array

              
            
Python

          Two Pointers O(n)
        
def removeDuplicates(nums: list[int]) -> int:
    if not nums:
        return 0
    
    write = 1
    for read in range(1, len(nums)):
        if nums[read] != nums[write-1]:
            nums[write] = nums[read]
            write += 1
    return write

nums = [1,1,2]
print(removeDuplicates(nums), nums[:3])  # 2 [1,2,1]

11. Missing Number

              
            
Python

          XOR Formula O(n)
        
def missingNumber(nums: list[int]) -> int:
    n = len(nums)
    xor = 0
    for i in range(n):
        xor ^= i ^ nums[i]
    return xor

# Sum formula alternative
# def missingNumber(nums: list[int]) -> int:
#     n = len(nums)
#     return n*(n+1)//2 - sum(nums)

print(missingNumber([3,0,1]))  # 2
print(missingNumber([0,1]))    # 2

12. Plus One

              
            
Python

          Reverse Carry Propagation
        
def plusOne(digits: list[int]) -> list[int]:
    for i in range(len(digits)-1, -1, -1):
        if digits[i] < 9:
            digits[i] += 1
            return digits
        digits[i] = 0
    
    # All 9s case
    return [1] + digits

print(plusOne([1,2,3]))      # [1,2,4]
print(plusOne([9,9,9]))      # [1,0,0,0]

13. Daily Temperatures (Monotonic Stack)

              
            
Python

          Stack O(n)
        
def dailyTemperatures(temperatures: list[int]) -> list[int]:
    n = len(temperatures)
    result = [0] * n
    stack = []  # [index]
    
    for i in range(n):
        while stack and temperatures[i] > temperatures[stack[-1]]:
            prev_idx = stack.pop()
            result[prev_idx] = i - prev_idx
        stack.append(i)
    return result

print(dailyTemperatures([73,74,75,71,69,72,76,73]))  # [1,1,4,2,1,1,0,0]

VS Code Practice Configuration

              
            
JSON

          launch.json for array problems
        
{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Array Interview Practice",
      "type": "python",
      "request": "launch",
      "program": "${file}",
      "console": "integratedTerminal"
    }
  ]
}

Array Interview Tips

Always check empty array first
Clarify if modification in-place allowed
Two pointers most common pattern
Hash map for existence/frequency
Sliding window for subarrays
Practice reversing techniques

Master These Patterns

Hash Map (Two Sum)
Two Pointers (Move Zeroes)
Sliding Window
Prefix/Suffix Arrays (Product Except Self)
Greedy (Max Profit)
Bit Manipulation (Single Number)

**Practice these 13 problems daily** - they cover 80% of array questions in interviews!