• Pattern recognition
• Time/space tradeoff awareness
• Edge-case handling
• Clean, readable logic

• Clarify
• Input size?
• Sorted or unsorted?
• Mutability allowed?
• Brute Force First
• State naive solution
• Time complexity
• Optimize
• Use data structures
• Recognize patterns
• Implement
• Clean variable naming
• Guard clauses
• Test
• Empty input
• Single element
• Extremes

• list append → O(1) amortized
• list insert(0) → O(n)
• dict lookup → O(1) avg
• heap push/pop → O(log n)
• set membership → O(1)

• Anagrams
• Duplicates
• Majority element

from collections import Counter
freq = Counter(nums)

• Subarray sum
• Range queries

prefix = [0]
for x in nums:
    prefix.append(prefix[-1] + x)

cur = best = nums[0]
for x in nums[1:]:
    cur = max(x, cur + x)
    best = max(best, cur)

• Sorted arrays
• Pairs / triplets
• Palindromes

l, r = 0, len(arr) - 1
while l < r:
    if condition:
        l += 1
    else:
        r -= 1

• Two Sum (sorted)
• Container With Most Water
• Remove duplicates

window_sum = sum(arr[:k])
for i in range(k, len(arr)):
    window_sum += arr[i] - arr[i-k]

l = 0
for r in range(len(arr)):
    while invalid_window:
        l += 1

• Longest substring
• Minimum window substring
• Subarray sums

• Converts lookup to O(1)
• Trades memory for speed

seen = set()
for x in arr:
    if x in seen:
        return True
    seen.add(x)

• Two Sum
• Cycle detection
• Duplicate detection

• Used for:
• Next Greater Element
• Histogram area
• Daily Temperatures

stack = []
for i in range(len(nums)):
    while stack and nums[stack[-1]] > nums[i]:
        stack.pop()
    stack.append(i)

stack = []
mapping = {')':'(', ']':'[', '}':'{'}

from collections import deque
q = deque([start])
while q:
    node = q.popleft()

dq = deque()

• Level order traversal
• Shortest path
• Window maximum

from collections import deque
q = deque([start])
while q:
    node = q.popleft()

dq = deque()

• Level order traversal
• Shortest path
• Window maximum

slow = fast = head
while fast and fast.next:
    slow = slow.next
    fast = fast.next.next

• Cycle detection
• Middle node

prev = None
cur = head
while cur:
    nxt = cur.next
    cur.next = prev
    prev = cur
    cur = nxt

l, r = 0, len(arr)-1
while l <= r:
    mid = (l+r)//2

while l < r:
    mid = (l+r)//2
    if arr[mid] < target:
        l = mid + 1
    else:
        r = mid

• Rotated arrays
• First/last position
• Search space problems

def backtrack(path):
    if condition:
        result.append(path[:])
        return
    for choice in choices:
        path.append(choice)
        backtrack(path)
        path.pop()

• Permutations
• Combinations
• Sudoku
• N-Queens

def dfs(node):
    if not node:
        return
    dfs(node.left)
    dfs(node.right)

from collections import deque

• Diameter
• Path sum
• LCA

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

heapq.heappush(heap, -x)

• Top K
• Median stream
• Scheduling

def dfs(node):
    for nei in graph[node]:
        if nei not in visited:
            dfs(nei)

queue = deque([(start, 0)])

• Adjacency list
• Visited set
• Directed vs undirected

• Define state
• Transition
• Base case
• Answer extraction

dp = [0]*(n+1)

dp = [[0]*m for _ in range(n)]

• Knapsack
• LIS
• Coin change
• Grid paths

• Identify pattern
• State complexity

• Clean loops
• No magic numbers

• Edge cases
• Dry run example

Core array and string problems that form the foundation of most coding interviews.

Sliding window techniques optimize subarray and substring problems by maintaining a dynamic range.

Two pointer techniques reduce time complexity by exploiting sorted data or symmetric traversal.

Stack-based patterns are used for matching, monotonic sequences, and range queries.

Linked list problems focus on pointer manipulation and in-place transformations.

Binary search applies to sorted data and monotonic answer spaces.

Tree problems test recursion, traversal strategies, and hierarchical reasoning.

Graph problems emphasize traversal, connectivity, and dependency resolution.

Dynamic programming evaluates optimal solutions using overlapping subproblems.

Array and string problems form the core foundation of coding interviews and emphasize efficient traversal, hashing, and prefix techniques.

Sliding window techniques optimize contiguous subarray or substring problems by maintaining a dynamic range.

Two pointer techniques reduce complexity by scanning from multiple directions simultaneously.

Stack-based patterns are used for matching problems and monotonic ordering.

Linked list problems focus on pointer manipulation and in-place transformations.

Binary search applies to sorted data and monotonic answer spaces.

Tree problems emphasize recursion, traversal strategies, and hierarchical reasoning.

Graph problems test traversal, connectivity, and dependency management.

Dynamic programming solves optimization problems using overlapping subproblems and state transitions.

Company-specific pattern focus based on real interview trends.