Better LeetCode

Refactor LeetCode solutions to follow clean code principles: clear logic, intuitive variable names, minimal comments, and idiomatic patterns.

Core Principles

1. •Clear over clever: Prefer readable solutions that are easy to understand at first glance
2. •Minimal comments: Code should be self-documenting through good naming and clear structure
3. •Idiomatic patterns: Use well-known algorithms and data structures with their standard implementations
4. •Concise variable names: Use short but meaningful names that follow common conventions

Refactoring Guidelines

Variable Naming

Use standard, memorable variable names for common patterns:

• •Pointers: slow, fast, left, right, i, j, k
• •Lists/Arrays: nums, arr, res, ans
• •Trees: root, node, left, right
• •Graphs: graph, node, visited, adj
• •Strings: s, t, word, pattern
• •Counters: count, cnt, freq
• •Results: res, ans, result

Code Structure

Do:

• •Keep functions focused and simple
• •Use early returns to reduce nesting
• •Prefer while loops for unclear iteration counts
• •Use for loops with range for known iterations
• •Initialize variables close to usage

Avoid:

• •Excessive comments explaining obvious logic
• •Overly complex one-liners that sacrifice readability
• •Unnecessary temporary variables
• •Deep nesting (>3 levels)

Common Patterns

Two Pointers:

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

Sliding Window:

left = 0
for right in range(len(s)):
    # expand window
    while condition:
        # shrink window
        left += 1

Binary Search:

left, right = 0, 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

DFS (Tree):

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

BFS:

from collections import deque

queue = deque([start])
while queue:
    node = queue.popleft()
    # process node
    if condition:
        queue.append(next_node)

Optimization Process

When refactoring code:

1. •Analyze: Identify the algorithm/pattern being used
2. •Simplify: Remove unnecessary complexity and redundancy
3. •Rename: Apply standard variable naming conventions
4. •Structure: Organize code for maximum readability
5. •Verify: Ensure logic correctness is maintained

Focus on readability and maintainability over micro-optimizations unless performance is explicitly required.