1
2
3
4
5
6
7
8
9
10

def process(arr, n, k):
    l, r = 0, k
    s = sum(arr[l:r])
    m = s
    while r < n:
        s += arr[r] - arr[l]
        l += 1
        r += 1
        m = max(m, s)
    return m

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

def max_sum_subarray_of_length_k(numbers: list[int], length: int, window_size: int) -> int:
    """Find maximum sum of any contiguous subarray of exactly window_size elements."""
    window_start = 0
    window_end = window_size  # Exclusive: window is [window_start, window_end)
    
    current_sum = sum(numbers[window_start:window_end])
    max_sum = current_sum
    
    # Slide window across array
    while window_end < length:
        # Add next element, remove first element
        current_sum += numbers[window_end] - numbers[window_start]
        window_start += 1
        window_end += 1
        
        max_sum = max(max_sum, current_sum)
    
    return max_sum

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# Poor: What does 'f' mean when true?
if f:
    process()
 
# Better: But 'found' what?
if found:
    process()
 
# Best: Completely self-documenting
if targetFoundInArray:
    processMatchingElement()
 
# Boolean naming patterns:
isValid = True              # 'is' prefix for state
hasChildren = True          # 'has' prefix for possession
canProceed = True           # 'can' prefix for capability
shouldTerminate = True      # 'should' prefix for decisions
needsRebalancing = True     # 'needs' prefix for requirements

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# Poor: What are a, b, c?
def solve(a, b, c):
    pass
 
# Better: Types implied, but roles unclear
def solve(nums, target, limit):
    pass
 
# Best: Full context for caller understanding
def find_pairs_with_sum_below_limit(
    numbers: list[int],
    target_sum: int,
    max_pairs: int
) -> list[tuple[int, int]]:
    """Find pairs that sum to target_sum, returning at most max_pairs."""
    pass

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# Acceptable: 'i' scope is one line, purpose is obvious
squares = [i * i for i in range(10)]
 
# Acceptable: Mathematical convention
def distance(x1, y1, x2, y2):
    dx = x2 - x1
    dy = y2 - y1
    return math.sqrt(dx * dx + dy * dy)
 
# Acceptable: Lambda with narrow scope
sorted_by_value = sorted(items, key=lambda item: item.value)
 
# Acceptable: Swap pattern is universally recognized
a, b = b, a
 
# Acceptable: Explicitly unused value
for _ in range(repetitions):
    perform_action()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

def solve(s):
    # d maps character to its frequency
    d = {}
    # m tracks the maximum length found
    m = 0
    # l is the left pointer of our window
    l = 0
    
    for r in range(len(s)):
        c = s[r]  # c is the current character
        
        # Add current character to frequency map
        d[c] = d.get(c, 0) + 1
        
        # Shrink window while we have more than 2 distinct chars
        while len(d) > 2:
            lc = s[l]  # lc is the left character
            d[lc] -= 1
            if d[lc] == 0:
                del d[lc]
            l += 1
        
        # Update maximum
        m = max(m, r - l + 1)
    
    return m

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

def longest_substring_with_at_most_k_distinct(text: str, max_distinct: int = 2) -> int:
    """Find the longest substring containing at most k distinct characters."""
    char_frequency = {}
    max_length = 0
    window_start = 0
    
    for window_end in range(len(text)):
        current_char = text[window_end]
        char_frequency[current_char] = char_frequency.get(current_char, 0) + 1
        
        # Shrink window while distinctness constraint is violated
        while len(char_frequency) > max_distinct:
            leaving_char = text[window_start]
            char_frequency[leaving_char] -= 1
            
            if char_frequency[leaving_char] == 0:
                del char_frequency[leaving_char]
            
            window_start += 1
        
        current_window_length = window_end - window_start + 1
        max_length = max(max_length, current_window_length)
    
    return max_length

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

# Poor: What does dfs(i, j, k) compute?
def solve(grid):
    memo = {}
    
    def dfs(i, j, k):
        if (i, j, k) in memo:
            return memo[(i, j, k)]
        # ... recursive logic
        memo[(i, j, k)] = result
        return result
    
    return dfs(0, 0, 0)
 
# Better: Function name and parameters explain state meaning
def minimum_path_cost_with_constraints(grid):
    """Find minimum cost path with at most max_turns turns."""
    cache = {}
    
    def compute_min_cost_from(row, col, remaining_turns):
        """
        Compute minimum cost to reach destination from (row, col)
        with at most remaining_turns turns available.
        """
        state = (row, col, remaining_turns)
        if state in cache:
            return cache[state]
        
        # ... recursive logic
        
        cache[state] = min_cost
        return min_cost
    
    return compute_min_cost_from(0, 0, max_allowed_turns)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

# Poor: What does dp[i][j] mean?
def solve(s, t):
    dp = [[0] * (len(t) + 1) for _ in range(len(s) + 1)]
    
    for i in range(1, len(s) + 1):
        for j in range(1, len(t) + 1):
            if s[i-1] == t[j-1]:
                dp[i][j] = dp[i-1][j-1] + 1
            else:
                dp[i][j] = max(dp[i-1][j], dp[i][j-1])
    
    return dp[len(s)][len(t)]
 
# Better: Table name describes the subproblem
def longest_common_subsequence_length(text1: str, text2: str) -> int:
    """
    Find the length of the longest common subsequence.
    
    LCS_LENGTH[i][j] = length of LCS of text1[:i] and text2[:j]
    """
    len1, len2 = len(text1), len(text2)
    
    # lcs_length[i][j] = LCS length of first i chars of text1 and first j chars of text2
    lcs_length = [[0] * (len2 + 1) for _ in range(len1 + 1)]
    
    for i in range(1, len1 + 1):
        for j in range(1, len2 + 1):
            char1 = text1[i - 1]  # Current char in text1 (0-indexed)
            char2 = text2[j - 1]  # Current char in text2 (0-indexed)
            
            if char1 == char2:
                # Characters match: extend LCS from previous state
                lcs_length[i][j] = lcs_length[i-1][j-1] + 1
            else:
                # Characters don't match: take best of skipping either char
                lcs_length[i][j] = max(lcs_length[i-1][j], lcs_length[i][j-1])
    
    return lcs_length[len1][len2]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

def minimum_edit_distance(source: str, target: str) -> int:
    """
    Compute minimum edits to transform source into target.
    Allowed operations: insert, delete, replace (each costs 1).
    
    edit_dist[i][j] = min edits to transform source[:i] to target[:j]
    """
    source_len, target_len = len(source), len(target)
    
    # Initialize DP table
    edit_dist = [[0] * (target_len + 1) for _ in range(source_len + 1)]
    
    # Base cases: transforming to/from empty string
    for i in range(source_len + 1):
        edit_dist[i][0] = i  # Delete all chars from source
    for j in range(target_len + 1):
        edit_dist[0][j] = j  # Insert all chars into empty source
    
    # Fill table with transitions
    for i in range(1, source_len + 1):
        for j in range(1, target_len + 1):
            source_char = source[i - 1]
            target_char = target[j - 1]
            
            if source_char == target_char:
                # No operation needed
                edit_dist[i][j] = edit_dist[i-1][j-1]
            else:
                cost_if_insert = edit_dist[i][j-1] + 1
                cost_if_delete = edit_dist[i-1][j] + 1
                cost_if_replace = edit_dist[i-1][j-1] + 1
                
                edit_dist[i][j] = min(cost_if_insert, cost_if_delete, cost_if_replace)
    
    return edit_dist[source_len][target_len]

1
2
3
4
5
6
7
8
9
10
11

# Bad: Type is already evident from context
numsList = [1, 2, 3]
resultDict = {}
countInt = 0
is_valid_bool = True
 
# Good: Name describes meaning, not type
numbers = [1, 2, 3]
frequency = {}
items_remaining = 0
is_valid = True

1
2
3
4
5
6
7
8
9

# Bad: What is the difference between these?
arr1 = original_array
arr2 = sorted_version
arr3 = filtered_elements
 
# Good: Names express the distinction
original = original_array
sorted_copy = sorted(original_array)
valid_elements = [x for x in original if x > 0]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# Bad: Mixed abbreviation conventions
idx = 0
index = 1
i = 2
 
cnt = 10
count = 20
num_items = 30
 
# Good: Pick one convention and stick to it
current_index = 0
next_index = 1
target_index = 2
 
item_count = 10
valid_count = 20
total_count = 30

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# Dangerous: Name suggests one thing, behavior is another
def get_items():
    # Actually MODIFIES the database!
    items = database.query()
    database.mark_as_read(items)
    return items
 
# Better: Name reflects side effects
def get_items_and_mark_read():
    items = database.query()
    database.mark_as_read(items)
    return items
 
# Another example:
sum = [1, 2, 3]  # Misleading: 'sum' sounds like a number, not a list
total = sum(values)  # Confusion: did we shadow the builtin?

1
2
3
4
5
6
7
8
9
10
11

# Bad: What data? What value? What result?
data = get_input()
value = process(data)
result = transform(value)
output = format(result)
 
# Good: Names describe the specific data
user_transactions = get_input()
validated_transactions = process(user_transactions)
aggregated_totals = transform(validated_transactions)
formatted_report = format(aggregated_totals)