Python DSA Cheatsheet For Coding Interview

x = 5
a, b = 1, 2
a, b = b, a                  # swap

x += 1
x -= 1
x *= 2
x //= 2                     # integer division

abs(x)
min(a, b)
max(a, b)
sum(nums)

s = "Hello"

len(s)
s[i]                        # character
s[i:j]                      # substring
s[::-1]                     # reverse

s.lower()
s.upper()
s.strip()

s.split()                   # "a b c" -> ["a", "b", "c"]
" ".join(words)             # ["a", "b"] -> "a b"
"".join(sorted(s))          # sorted characters

s.isalpha()
s.isdigit()
s.isalnum()

ord('a')                    # 97
chr(97)                     # 'a'

for c in s:
    ...

for i, c in enumerate(s):
    ...

nums = []
nums = [1, 2, 3]

len(nums)

nums.append(x)
nums.pop()                  # remove last
nums.pop(i)                 # remove index i

nums[i]
nums[i:j]

nums.reverse()              # in-place
nums.sort()                 # in-place

sorted(nums)                # returns new list

nums = [0] * n              # [0, 0, 0, ...]

nums = list(range(n))       # [0, 1, 2, ..., n-1]

nums = list(range(1, n + 1))

x = nums[-1]                # last
x = nums[-2]                # second last

for x in nums:
    ...

for i in range(len(nums)):
    ...

for i, x in enumerate(nums):
    ...

for a, b in zip(nums1, nums2):
    ...

squares = [x * x for x in nums]

even = [x for x in nums if x % 2 == 0]

zeros = [0 for _ in range(n)]

mp = {}

mp[key] = value

mp[key] += 1

mp[key] = mp.get(key, 0) + 1

if key in mp:
    ...

if key not in mp:
    ...

value = mp[key]

value = mp.get(key)         # None if missing
value = mp.get(key, 0)      # 0 if missing

for key in mp:
    ...

for key, value in mp.items():
    ...

count = {}

for x in nums:
    count[x] = count.get(x, 0) + 1

mp = {x: 0 for x in nums}

seen = set()

seen.add(x)
seen.remove(x)              # must exist
seen.discard(x)             # safe if missing

if x in seen:
    ...

len(seen)

set(nums)
list(set(nums))

seen = set()

for x in nums:
    if x in seen:
        return True
    seen.add(x)

nums.sort()                 # modify nums
nums.sort(reverse=True)

sorted_nums = sorted(nums)

sorted(nums, reverse=True)

items.sort(key=lambda x: x[0])

items.sort(key=lambda x: x[1], reverse=True)

sorted(items, key=lambda x: x[0])

items.sort(key=lambda x: (x[0], -x[1]))

time_sorted = sorted(
    zip(position, speed),
    key=lambda x: x[0],
    reverse=True
)

position, speed = zip(*time_sorted)

t = (1, 2)

a, b = t

x, y = y, x

r, c = (2, 3)

queue.append((r, c))

for r, c in points:
    ...

if x > 0:
    ...

if x > 0:
    ...
else:
    ...

x = a if condition else b

mx = a if a > b else b

if x > 0 and y > 0:
    ...

if x == 0 or y == 0:
    ...

if not seen:
    ...

left = 0
right = len(nums) - 1

while left < right:
    if nums[left] + nums[right] == target:
        return [left, right]
    elif nums[left] + nums[right] < target:
        left += 1
    else:
        right -= 1

left = 0
right = len(s) - 1

while left < right:
    ...
    left += 1
    right -= 1

left = 0

for right in range(len(nums)):
    # add nums[right]

    while condition:
        # remove nums[left]
        left += 1

    # update answer

window = {}
left = 0

for right, c in enumerate(s):
    window[c] = window.get(c, 0) + 1

    while ...:
        window[s[left]] -= 1
        left += 1

stack = []

stack.append(x)             # push
x = stack.pop()             # pop
x = stack[-1]               # peek

if stack:
    ...

for x in nums:
    while stack and stack[-1] < x:
        stack.pop()

    stack.append(x)

from collections import deque

q = deque()

q.append(x)
x = q.popleft()

q = deque([start])

while q:
    node = q.popleft()

    for nei in graph[node]:
        q.append(nei)

dirs = [(1, 0), (-1, 0), (0, 1), (0, -1)]

for dr, dc in dirs:
    nr = r + dr
    nc = c + dc

import heapq

heap = []

heapq.heappush(heap, x)
x = heapq.heappop(heap)

x = heap[0]                 # smallest

heapq.heapify(nums)

heapq.heappush(heap, -x)

x = -heapq.heappop(heap)

heapq.heappush(heap, (priority, value))

left = 0
right = len(nums) - 1

while left <= right:
    mid = (left + right) // 2

    if nums[mid] == target:
        return mid
    elif nums[mid] < target:
        left = mid + 1
    else:
        right = mid - 1

return -1

import bisect

i = bisect.bisect_left(nums, target)

graph = {}

graph[u] = []
graph[u].append(v)

from collections import defaultdict

graph = defaultdict(list)

graph[u].append(v)
graph[v].append(u)

def dfs(node):
    if node in seen:
        return

    seen.add(node)

    for nei in graph[node]:
        dfs(nei)

stack = [start]
seen = set()

while stack:
    node = stack.pop()

    if node in seen:
        continue

    seen.add(node)

    for nei in graph[node]:
        stack.append(nei)

from collections import Counter, defaultdict, deque

count = Counter(s)

count['a']

count.most_common(1)

count = {}

for c in s:
    count[c] = count.get(c, 0) + 1

graph = defaultdict(list)

graph[x].append(y)

q = deque()

q.append(x)
q.popleft()

len(nums)
sum(nums)
min(nums)
max(nums)

any(condition for x in nums)
all(condition for x in nums)

enumerate(nums)
zip(a, b)

range(n)
range(start, end)
range(start, end, step)

any(x > 10 for x in nums)

all(x >= 0 for x in nums)

# 1. HashMap
mp = {}
mp[x] = mp.get(x, 0) + 1

# 2. Set
seen = set()
seen.add(x)
if x in seen:
    ...

# 3. Loop with index
for i, x in enumerate(nums):
    ...

# 4. Reverse
s[::-1]

# 5. Sort
nums.sort()
sorted(nums)

# 6. Sort with key
sorted(items, key=lambda x: x[1])

# 7. Stack
stack.append(x)
stack.pop()

# 8. Queue
from collections import deque
q = deque()
q.append(x)
q.popleft()

# 9. Heap
import heapq
heapq.heappush(heap, x)
heapq.heappop(heap)

# 10. Two pointers
left, right = 0, len(nums) - 1

while left < right:
    ...
    left += 1
    right -= 1

for x in nums:
    ...

for i in range(len(nums)):
    ...

for i, x in enumerate(nums):
    ...

Problem
   ↓
Identify DSA pattern
   ↓
Open cheatsheet only for syntax
   ↓
Write code yourself
   ↓
Get stuck
   ↓
Add ONLY that missing syntax/pattern