Some problems have no trick. The statement describes a process, and the task is to execute it exactly, without an off-by-one or a missed case. Interviewers use these deliberately: they measure whether you can hold several pieces of state straight and translate a specification faithfully — which is most of real engineering.

There are still techniques, and they are worth having ready:

• Direction vectors instead of four hard-coded branches.
• In-place state encoding when reads and writes collide.
• Recognising when not to simulate — the most valuable one, because some problems describe a billion steps and expect you to reason instead.

What you’ll learn

• Rotating a direction in one line, with no ifif chain.
• The two-bit trick for simultaneous updates in $O(1)$ space.
• Bouncing state machines — the stepstep variable that replaces modular index arithmetic.
• The cycle argument: why four iterations settle a rotation question forever.
• Three real LeetCode problems solved in the browser: 289, 1041, 6.

The cue

Trick 1 — direction vectors

Four ifif branches for up/down/left/right is where bugs live. A vector list plus an index is shorter and rotates in one line:

# clockwise order: north, east, south, west
DIRS = ((0, 1), (1, 0), (0, -1), (-1, 0))
 
facing = 0                       # index into DIRS
facing = (facing + 1) % 4        # turn RIGHT
facing = (facing - 1) % 4        # turn LEFT  (Python's % keeps it non-negative)
 
dx, dy = DIRS[facing]
x, y = x + dx, y + dy            # step forward

# clockwise order: north, east, south, west
DIRS = ((0, 1), (1, 0), (0, -1), (-1, 0))
 
facing = 0                       # index into DIRS
facing = (facing + 1) % 4        # turn RIGHT
facing = (facing - 1) % 4        # turn LEFT  (Python's % keeps it non-negative)
 
dx, dy = DIRS[facing]
x, y = x + dx, y + dy            # step forward

Keeping the directions in clockwise order is what makes +1+1 a right turn. Python’s modulo returning a non-negative result for a positive divisor means (0 - 1) % 4 == 3(0 - 1) % 4 == 3 — so turning left from index 0 correctly gives west, with no special case. In C or Java that expression yields -1-1 and needs + 4+ 4 first.

An equally clean alternative avoids the index entirely:

dx, dy = -dy, dx      # rotate LEFT  90 degrees
dx, dy = dy, -dx      # rotate RIGHT 90 degrees

dx, dy = -dy, dx      # rotate LEFT  90 degrees
dx, dy = dy, -dx      # rotate RIGHT 90 degrees

Worth memorising — it is two characters of difference, and getting the pair backwards mirrors the whole simulation.

Trick 2 — encode two states in one cell

Game of Life updates every cell based on its neighbours’ current values. Write as you read and you corrupt the input mid-pass.

The $O(1)$-space fix stores both states in the same integer: bit 0 is the present, bit 1 is the future.

def game_of_life(board):
    rows, cols = len(board), len(board[0])
 
    for r in range(rows):
        for c in range(cols):
            live = 0
            for dr in (-1, 0, 1):
                for dc in (-1, 0, 1):
                    if dr == 0 and dc == 0:
                        continue
                    nr, nc = r + dr, c + dc
                    if 0 <= nr < rows and 0 <= nc < cols:
                        live += board[nr][nc] & 1        # read ONLY bit 0
            # write the next state into bit 1
            if board[r][c] & 1:
                if live in (2, 3):
                    board[r][c] |= 2
            elif live == 3:
                board[r][c] |= 2
 
    for r in range(rows):                                # second pass: shift
        for c in range(cols):
            board[r][c] >>= 1
    return board

def game_of_life(board):
    rows, cols = len(board), len(board[0])
 
    for r in range(rows):
        for c in range(cols):
            live = 0
            for dr in (-1, 0, 1):
                for dc in (-1, 0, 1):
                    if dr == 0 and dc == 0:
                        continue
                    nr, nc = r + dr, c + dc
                    if 0 <= nr < rows and 0 <= nc < cols:
                        live += board[nr][nc] & 1        # read ONLY bit 0
            # write the next state into bit 1
            if board[r][c] & 1:
                if live in (2, 3):
                    board[r][c] |= 2
            elif live == 3:
                board[r][c] |= 2
 
    for r in range(rows):                                # second pass: shift
        for c in range(cols):
            board[r][c] >>= 1
    return board

Trick 3 — bouncing state

For zigzag traversal (LC 6), the row index goes down then up then down. Modular arithmetic on the cycle length works but is fiddly; a step variable that flips at the boundaries is much clearer:

def convert(s, num_rows):
    if num_rows == 1:
        return s                      # no zigzag exists; also avoids a hang
    rows = [[] for _ in range(num_rows)]
    row, step = 0, 1
 
    for ch in s:
        rows[row].append(ch)
        if row == 0:
            step = 1                  # bounce off the top
        elif row == num_rows - 1:
            step = -1                 # bounce off the bottom
        row += step
 
    return "".join("".join(r) for r in rows)

def convert(s, num_rows):
    if num_rows == 1:
        return s                      # no zigzag exists; also avoids a hang
    rows = [[] for _ in range(num_rows)]
    row, step = 0, 1
 
    for ch in s:
        rows[row].append(ch)
        if row == 0:
            step = 1                  # bounce off the top
        elif row == num_rows - 1:
            step = -1                 # bounce off the bottom
        row += step
 
    return "".join("".join(r) for r in rows)

Trick 4 — do not simulate

This is the most valuable habit on the page.

LC 1041 asks whether a robot stays within a bounded circle when its instruction string repeats forever. Simulating forever is impossible. The insight:

After four repetitions, the robot’s net rotation is a multiple of 360°, so its displacement pattern repeats. So it is bounded if and only if, after one pass, either it is back at the origin or it is no longer facing its original direction.

If the robot ends facing north again (unrotated) at a non-origin position, each repetition adds the same displacement and it escapes. If it has rotated at all, four passes compose into a closed loop and it is bounded.

def is_robot_bounded(instructions):
    x = y = 0
    dx, dy = 0, 1                     # facing north
    for ch in instructions:
        if ch == "G":
            x, y = x + dx, y + dy
        elif ch == "L":
            dx, dy = -dy, dx
        else:                         # "R"
            dx, dy = dy, -dx
    return (x == 0 and y == 0) or (dx, dy) != (0, 1)

def is_robot_bounded(instructions):
    x = y = 0
    dx, dy = 0, 1                     # facing north
    for ch in instructions:
        if ch == "G":
            x, y = x + dx, y + dy
        elif ch == "L":
            dx, dy = -dy, dx
        else:                         # "R"
            dx, dy = dy, -dx
    return (x == 0 and y == 0) or (dx, dy) != (0, 1)

One pass, $O(n)$, no loop over repetitions at all.

The variant map

Practice — real LeetCode problems

LC 289 — Game of Life · Medium

Problem. Given an m x nm x n board of 00 (dead) and 11 (live), compute the next state. Each cell’s fate depends on its eight neighbours: a live cell survives with 2 or 3 live neighbours; a dead cell becomes live with exactly 3. All updates happen simultaneously.

Constraints. 1 <= m, n <= 251 <= m, n <= 25, cells are 00 or 11.

Examples. [[0,1,0],[0,0,1],[1,1,1],[0,0,0]][[0,1,0],[0,0,1],[1,1,1],[0,0,0]] becomes [[0,0,0],[1,0,1],[0,1,1],[0,1,0]][[0,0,0],[1,0,1],[0,1,1],[0,1,0]] · [[1,1],[1,0]][[1,1],[1,0]] becomes [[1,1],[1,1]][[1,1],[1,1]]

LC 1041 — Robot Bounded In Circle · Medium

Problem. A robot starts at (0, 0)(0, 0) facing north and repeats an instruction string forever. "G""G" moves forward one unit, "L""L" turns left 90°, "R""R" turns right 90°. Return TrueTrue if there is a circle that the robot never leaves.

Constraints. 1 <= len(instructions) <= 1001 <= len(instructions) <= 100, characters are GG, LL or RR.

Examples. "GGLLGG""GGLLGG" gives TrueTrue (returns to the origin) · "GG""GG" gives FalseFalse (walks north forever) · "GL""GL" gives TrueTrue

LC 6 — Zigzag Conversion · Medium

Problem. Write the string ss in a zigzag pattern over numRowsnumRows rows, then read it off row by row.

Constraints. 1 <= len(s) <= 10001 <= len(s) <= 1000, 1 <= numRows <= 10001 <= numRows <= 1000, ss is letters, ,, and ...

Examples. "PAYPALISHIRING", 3"PAYPALISHIRING", 3 gives "PAHNAPLSIIGYIR""PAHNAPLSIIGYIR" · "PAYPALISHIRING", 4"PAYPALISHIRING", 4 gives "PINALSIGYAHRPI""PINALSIGYAHRPI" · "A", 1"A", 1 gives "A""A"

LeetCode problem set

Interview follow-ups

Edge-case checklist

• Single cell / single character — [[1]][[1]] dies; "A""A" with 1 row returns itself.
• numRows == 1numRows == 1 (LC 6) — must be guarded or it raises.
• numRowsnumRows greater than len(s)len(s) — ("AB", 5)("AB", 5) gives "AB""AB"; empty rows contribute nothing.
• A lone live cell (LC 289) — dies of underpopulation; not obviously so.
• All cells dead / all alive — the trivial extremes.
• Instructions with no GG (LC 1041) — "R""R" gives TrueTrue, never moving.
• Instructions with no turns — "GG""GG" gives FalseFalse, the only unbounded shape.
• Turns that cancel to zero net rotation — "GLGLGGLGL""GLGLGGLGL" gives FalseFalse; net rotation is what counts, not the presence of turns.
• Left/right rotation formulas swapped — mirrors everything, and several cases still pass by symmetry.
• Boundary reads (LC 289) — corner cells have only 3 neighbours; bound-check every offset.

Recap

• Some problems have no trick, and the skill is faithful translation of the specification plus disciplined case enumeration.
• Direction vectors or the rotation pair ((-dy, dx)(-dy, dx) left, (dy, -dx)(dy, -dx) right) replace four-branch ifif chains. Python’s non-negative %% makes (i - 1) % 4(i - 1) % 4 safe.
• For simultaneous updates, encode the next state in spare bits — read with & 1& 1, write with |= 2|= 2, then shift. Offer the $O(mn)$ copy first; the bit trick is the $O(1)$ follow-up.
• A bouncing step variable beats modular index arithmetic for zigzag traversal — and numRows == 1numRows == 1 must be guarded explicitly.
• The most valuable instinct is not simulating. When the step count is huge but the state space is small, find the cycle and reduce modulo its length. LC 1041 needs one pass and a rotation argument; LC 957 needs cycle detection.
• Build strings by joining a list, never by repeated concatenation.

Next: the advanced graph algorithms — MST, strongly connected components, and max flow.