Nitinn S Kulkarni

Posted on Apr 1

Part 2: Arrays, Lists, and Strings – Patterns, Tricks, and Pitfalls in Python

#python #learning #dsa #interview

🚀 Introduction

Arrays (or lists in Python) and strings are among the most common data structures you’ll use. They form the backbone of many algorithms and interview questions.

In this post, we’ll explore:

✅ Python’s built-in list and string capabilities

✅ Essential algorithmic patterns: sliding window, two pointers, prefix sum

✅ Real-world problems and how to solve them

✅ Best practices and Pythonic shortcuts

📦 1️⃣ Python Lists: More Than Just Arrays

Python lists are dynamic arrays that can grow or shrink in size.


arr = [1, 2, 3]
arr.append(4)       # [1, 2, 3, 4]
arr.pop()           # [1, 2, 3]
arr.insert(1, 10)   # [1, 10, 2, 3]
del arr[0]          # [10, 2, 3]

🔹 List Slicing


nums = [1, 2, 3, 4, 5]
print(nums[1:4])     # [2, 3, 4]
print(nums[::-1])    # [5, 4, 3, 2, 1] – reversed

✅ Slicing is your best friend in array problems.

🔤 2️⃣ Strings in Python

Python strings are immutable and extremely versatile.


s = "hello"
print(s.upper())        # "HELLO"
print(s[1:4])           # "ell"
print("h" in s)         # True

🔹 String Tricks


# Reversing a string
reversed_s = s[::-1]

# Check for palindrome
def is_palindrome(s):
    return s == s[::-1]

🚦 3️⃣ Pattern: Two Pointers

Use two pointers to scan a list or string from both ends or at different speeds.

🔹 Example: Is a list a palindrome?


def is_palindrome(lst):
    left, right = 0, len(lst) - 1
    while left < right:
        if lst[left] != lst[right]:
            return False
        left += 1
        right -= 1
    return True

🔹 Example: Remove Duplicates from Sorted Array


def remove_duplicates(nums):
    if not nums:
        return 0
    i = 0
    for j in range(1, len(nums)):
        if nums[j] != nums[i]:
            i += 1
            nums[i] = nums[j]
    return i + 1

✅ Use when you need to compare or update positions in-place.

🔍 4️⃣ Pattern: Sliding Window

Efficiently track values over a moving range.

🔹 Example: Max sum of subarray of size k


def max_subarray_sum(nums, k):
    window_sum = sum(nums[:k])
    max_sum = window_sum
    for i in range(k, len(nums)):
        window_sum += nums[i] - nums[i - k]
        max_sum = max(max_sum, window_sum)
    return max_sum

✅ Use when dealing with contiguous sequences like subarrays, substrings, etc.

➕ 5️⃣ Pattern: Prefix Sum

Prefix sum helps in range sum queries and cumulative processing.

🔹 Example: Range sum query


def prefix_sum(nums):
    prefix = [0]
    for num in nums:
        prefix.append(prefix[-1] + num)
    return prefix

# Sum of elements from index i to j: prefix[j+1] - prefix[i]

✅ Reduces repeated computation in range-based problems.

🧪 6️⃣ Practice Problems

Problem	Pattern	Tip
Two Sum	Hashing / Two Pointers	Use a set for complements
Maximum Subarray	Kadane’s Algorithm	Track max ending at current index
Longest Substring Without Repeating Characters	Sliding Window	Use a set or dict for seen chars
Palindrome Check	Two Pointers	Compare left and right
Product of Array Except Self	Prefix & Suffix Arrays	Avoid division

✅ Best Practices

✔️ Know when to use in-place operations to save space
✔️ Use enumerate() to loop with index
✔️ Avoid += on strings in loops (use ''.join() instead)
✔️ Leverage collections.Counter, set, and defaultdict for advanced use cases
❌ Avoid nested loops unless necessary — try sliding window or hashing

🧠 Summary

✔️ Lists and strings are the foundation of most coding problems
✔️ Learn and practice patterns like two pointers, sliding window, and prefix sums
✔️ Python’s expressive syntax helps solve these problems cleanly and concisely
✔️ Build your DSA muscle memory with hands-on problems using these patterns

🔜 Coming Up Next:

👉 Part 3: Stacks and Queues – Theory, Python Implementations, and Interview Classics

We’ll explore:

Real-world uses of stacks & queues
How to implement with Python lists and deque
Problems like parentheses validation, undo/redo, and level-order traversal

DEV Community