Tools/LeetCode Typing

LeetCode Typing Practice

Solving LeetCode problems is one skill. Translating solutions to code quickly under time pressure is another. Both matter. Practice the most common patterns until your fingers type them without thinking.

Why Typing Speed Matters on LeetCode

•Time limits are real. LeetCode contests give 90 minutes for 3–4 problems. Slow typing eats into problem-solving time.
•Flow state requires fluent typing. If transcribing your solution costs mental effort, you have less available for debugging.
•Pattern templates get reused. The two-pointer template, the BFS setup, the DP table init — type these thousands of times and they become automatic.
•Interviews are observed. Hesitating on syntax looks like uncertainty on the concept itself.

Common LeetCode Patterns to Master

Two Pointers

Left/right indices on a sorted array. Used in pair sum, palindrome check, container with most water.

left, right = 0, len(arr) - 1
while left < right:
    if arr[left] + arr[right] == target:
        return [left, right]
    elif arr[left] + arr[right] < target:
        left += 1
    else:
        right -= 1

Binary Search

O(log n) search on a sorted structure. Many interview problems reduce to this pattern.

lo, hi = 0, len(nums) - 1
while lo <= hi:
    mid = (lo + hi) // 2
    if nums[mid] == target:
        return mid
    elif nums[mid] < target:
        lo = mid + 1
    else:
        hi = mid - 1
return -1

BFS (Breadth-First Search)

Level-order graph/tree traversal using a queue. Used in shortest path, nearest cell, word ladder.

from collections import deque
queue = deque([start])
visited = {start}
while queue:
    node = queue.popleft()
    for neighbor in graph[node]:
        if neighbor not in visited:
            visited.add(neighbor)
            queue.append(neighbor)

DFS (Depth-First Search)

Recursive or stack-based graph traversal. Used in path finding, connected components, islands.

def dfs(node, visited):
    visited.add(node)
    for neighbor in graph[node]:
        if neighbor not in visited:
            dfs(neighbor, visited)

visited = set()
dfs(start, visited)

Dynamic Programming

Memoization or tabulation to cache subproblem results. Foundation of LeetCode medium/hard.

dp = [0] * (n + 1)
dp[0] = 1  # base case
for i in range(1, n + 1):
    for coin in coins:
        if i >= coin:
            dp[i] += dp[i - coin]
return dp[amount]

Sliding Window

Maintain a window of elements over an array. Used in max subarray, longest substring.

left = 0
max_sum = 0
current_sum = 0
for right in range(len(nums)):
    current_sum += nums[right]
    while current_sum > target:
        current_sum -= nums[left]
        left += 1
    max_sum = max(max_sum, right - left + 1)
return max_sum

Practice by Language

Python

Start Practicing Now

Open typing test →Try daily challenges