How to Crack Data Structures Interviews Without Experience

def two_sum(nums, target):
    """Return indices of two numbers adding up to target."""
    seen = {}  # value -> index
    for i, n in enumerate(nums):
        need = target - n
        if need in seen:
            return [seen[need], i]
        seen[n] = i
    return []

print(two_sum([2, 7, 11, 15], 9))   # [0, 1]
# Time O(n), space O(n)

def is_valid(s):
    """Check if brackets are balanced."""
    pairs = {')': '(', ']': '[', '}': '{'}
    stack = []
    for ch in s:
        if ch in '([{':
            stack.append(ch)
        elif ch in pairs:
            if not stack or stack.pop() != pairs[ch]:
                return False
    return not stack

print(is_valid("([]{})"))  # True
print(is_valid("(]"))      # False

def longest_unique(s):
    """Length of longest substring without repeating chars."""
    last = {}
    start = best = 0
    for i, ch in enumerate(s):
        if ch in last and last[ch] >= start:
            start = last[ch] + 1
        last[ch] = i
        best = max(best, i - start + 1)
    return best

print(longest_unique("abcabcbb"))  # 3

from collections import deque

def num_islands(grid):
    rows, cols = len(grid), len(grid[0])
    seen = set()
    count = 0
    for r in range(rows):
        for c in range(cols):
            if grid[r][c] == "1" and (r, c) not in seen:
                count += 1
                q = deque([(r, c)])
                seen.add((r, c))
                while q:
                    x, y = q.popleft()
                    for dx, dy in ((1,0),(-1,0),(0,1),(0,-1)):
                        nx, ny = x + dx, y + dy
                        if 0 <= nx < rows and 0 <= ny < cols \
                           and grid[nx][ny] == "1" and (nx, ny) not in seen:
                            seen.add((nx, ny))
                            q.append((nx, ny))
    return count

print(num_islands([["1","1","0"],["0","1","0"],["0","0","1"]]))  # 2

1. Restate: "So I need to return ... given ..."
2. Clarify: size limits? duplicates? negatives? empty?
3. Example: work one small example by hand
4. Brute force: describe it + time/space complexity
5. Optimise: name the pattern, explain the idea
6. Code: clear variable names, small helper functions
7. Test: normal case, edge case, large case
8. Complexity: state final time and space

Always check these before saying "done":

- Empty input ([], "", None)
- Single element
- All elements the same
- Negative numbers or zero
- Already sorted / reverse sorted
- Very large input (complexity matters)
- Duplicates
- Disconnected graph or null tree

Date | Problem | Pattern | Difficulty | Time | Solved alone? | Revisit on
-----|---------|---------|------------|------|---------------|-----------
     |         |         |            |      |               |
     |         |         |            |      |               |

Rule: any problem not solved alone -> revisit after 3 days,
then after 7 days, until it is solved without help.

Mon - Arrays & hashing (3 problems)
Tue - Two pointers / sliding window (3)
Wed - Stacks, queues, linked lists (3)
Thu - Trees: DFS, BFS (3)
Fri - Graphs or DP (2)
Sat - Timed mock: 2 problems in 60 minutes, out loud
Sun - Revisit failed problems + update pattern notes

Mock interview feedback sheet

Problem: _______________________
Clarified the problem?      Yes / Partly / No
Stated brute force first?   Yes / No
Named the right pattern?    Yes / No
Code clean and readable?    1 2 3 4 5
Tested edge cases?          Yes / No
Explained complexity?       Yes / No

One thing to improve next time:
________________________________