Errors to look out for

The code breaks the language's grammar, so it can't even be read. Python wants a colon after if / for / while / def; Java and C++ want a semicolon after each statement.

In DSA problems: Usually a missing colon after for i in range(n) or if left < right, or a missing semicolon after i++ in Java and C++. The line it names is sometimes the one after the real mistake.

def total(nums):
    s = 0
    for x in nums
        s += x
    return s

def total(nums):
    s = 0
    for x in nums:
        s += x
    return s

In Python the indent is the structure: the lines inside an if or a loop are the ones indented under it. A line indented too much, too little, or not at all breaks that.

In DSA problems: Common after pasting code, or after leaving a loop: the return lands inside the loop (it then runs on the first pass) or one space off from the lines around it.

def has_zero(nums):
    for x in nums:
    if x == 0:
        return True
    return False

def has_zero(nums):
    for x in nums:
        if x == 0:
            return True
    return False

An opening ( [ or { has no partner, so the language reads to the end of the file looking for it.

In DSA problems: Nested calls like max(best, len(s[i:j]) and long conditions are the usual suspects; in Java and C++, a missing } after an if or a loop.

def longest(words):
    best = 0
    for w in words:
        best = max(best, len(w)
    return best

def longest(words):
    best = 0
    for w in words:
        best = max(best, len(w))
    return best

A variable or function is used before it exists, or under a slightly different name. Python only finds out when that line runs; Java and C++ refuse to compile. UnboundLocalError is the same mistake inside a function: count += 1 before count = 0.

In DSA problems: A typo (lenght, nums vs num), a counter never set to 0, forgetting self. before a method of the Solution class, or a nested DFS helper doing count += 1 on the outer function's variable (it needs nonlocal count).

def count_evens(nums):
    evens = 0
    for x in nums:
        if x % 2 == 0:
            evens += 1
    return even

def count_evens(nums):
    evens = 0
    for x in nums:
        if x % 2 == 0:
            evens += 1
    return evens

Java and C++ check every value's type before running. Putting a long into an int (it might not fit), a String into a char, or a whole list into a single number is refused.

In DSA problems: int mid = (long) left + right style mixes, char c = "a" (double quotes make a String; a char uses single quotes), and returning int[] where the signature says List<Integer>.

class Main {
  static int sum(int[] nums) {
    long total = 0;
    for (int x : nums) total += x;
    return total;
  }
  public static void main(String[] a) { System.out.println(sum(new int[]{1, 2})); }
}

class Main {
  static long sum(int[] nums) {
    long total = 0;
    for (int x : nums) total += x;
    return total;
  }
  public static void main(String[] a) { System.out.println(sum(new int[]{1, 2})); }
}

Java proves that every path through a function returns a value. If a loop or an if can finish without returning, it refuses to compile. C++ compiles it anyway and returns garbage on that path, which is worse.

In DSA problems: A search that returns inside the loop when it finds the answer, with nothing after the loop for when it doesn't (binary search, two pointers, "find the index").

class Main {
  static int find(int[] nums, int target) {
    for (int i = 0; i < nums.length; i++)
      if (nums[i] == target) return i;
  }
  public static void main(String[] a) { System.out.println(find(new int[]{4, 7}, 7)); }
}

class Main {
  static int find(int[] nums, int target) {
    for (int i = 0; i < nums.length; i++)
      if (nums[i] == target) return i;
    return -1;
  }
  public static void main(String[] a) { System.out.println(find(new int[]{4, 7}, 7)); }
}

A local variable is read before it has a value. Java refuses; C++ allows it and the variable holds whatever was in memory, so results change from run to run.

In DSA problems: int sum; or int best; declared and then updated in a loop. Give it a starting value: 0 for sums, the first element or a huge value for minimums.

class Main {
  public static void main(String[] a) {
    int sum;
    for (int x : new int[]{1, 2, 3}) sum += x;
    System.out.println(sum);
  }
}

class Main {
  public static void main(String[] a) {
    int sum = 0;
    for (int x : new int[]{1, 2, 3}) sum += x;
    System.out.println(sum);
  }
}

An index past the last element (or below 0 in Java and C++). A list of length n has indexes 0 to n − 1, so nums[n] is already one too far. In C++, v[i] doesn't check at all: it reads garbage or crashes; LeetCode's checker reports it as a heap-buffer-overflow.

In DSA problems: The most common error in DSA. Looking ahead with nums[i + 1] on the last index, range(len(nums) + 1), while i <= len(s), two pointers that step past each other, and nums[0] on an empty input.

def count_rises(nums):
    rises = 0
    for i in range(len(nums)):
        if nums[i + 1] > nums[i]:
            rises += 1
    return rises

def count_rises(nums):
    rises = 0
    for i in range(len(nums) - 1):
        if nums[i + 1] > nums[i]:
            rises += 1
    return rises

Reading a key the dictionary doesn't have. Python raises KeyError; Java's get returns null, which crashes as soon as it's used as a number. C++'s map[key] silently adds the key with 0, which hides the bug instead.

In DSA problems: Counting with count[x] += 1 before x is in the map, or looking up a complement in Two Sum without checking it's there first.

def freq(s):
    count = {}
    for ch in s:
        count[ch] += 1
    return count

def freq(s):
    count = {}
    for ch in s:
        count[ch] = count.get(ch, 0) + 1
    return count

Something that should be a node (or an object) is actually None / null, and the code reaches into it. In C++ that's a null pointer, and the program crashes with a segmentation fault.

In DSA problems: Linked lists and trees, all the time: node.next.next when node.next is the last node, root.left.val on a leaf, or a function that returns None in one branch.

class Node:
    def __init__(self, val, next=None):
        self.val, self.next = val, next

def middle(head):
    slow = fast = head
    while fast.next:
        slow, fast = slow.next, fast.next.next
    return slow.val

class Node:
    def __init__(self, val, next=None):
        self.val, self.next = val, next

def middle(head):
    slow = fast = head
    while fast and fast.next:
        slow, fast = slow.next, fast.next.next
    return slow.val

for x in ... needs something to walk through (a list, a string, a range). A single number isn't one.

In DSA problems: Almost always for i in len(nums):. The loop over indexes is for i in range(len(nums)):.

def total(nums):
    s = 0
    for i in len(nums):
        s += nums[i]
    return s

def total(nums):
    s = 0
    for i in range(len(nums)):
        s += nums[i]
    return s

In Python, / always gives a float (7 / 2 is 3.5, and even 4 / 2 is 2.0), and a list can't be indexed with a float. // divides and rounds down to a whole number.

In DSA problems: Binary search: mid = (left + right) / 2. Use //. Java and C++ don't have this problem, since int / int is already a whole number there.

def search(nums, target):
    left, right = 0, len(nums) - 1
    while left <= right:
        mid = (left + right) / 2
        if nums[mid] == target:
            return mid
        if nums[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

def search(nums, target):
    left, right = 0, len(nums) - 1
    while left <= right:
        mid = (left + right) // 2
        if nums[mid] == target:
            return mid
        if nums[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

Set items and dictionary keys must never change, and a list can. So a list can't go in a set or be a key; a tuple (which can't change) can.

In DSA problems: Group Anagrams (groups[sorted(word)]), keeping visited [row, col] cells in a set, or storing a path as a key. Turn it into a tuple first.

def group(words):
    groups = {}
    for w in words:
        groups.setdefault(sorted(w), []).append(w)
    return list(groups.values())

def group(words):
    groups = {}
    for w in words:
        groups.setdefault(tuple(sorted(w)), []).append(w)
    return list(groups.values())

A Python string can't be edited: s[i] = ... is refused. (Java's String is the same: there's no setter.) Build a new string, or edit a list of characters and join it.

In DSA problems: Reversing, swapping characters, or replacing letters in place: Reverse Vowels, valid palindromes after edits, string compression.

def reverse(s):
    i, j = 0, len(s) - 1
    while i < j:
        s[i], s[j] = s[j], s[i]
        i, j = i + 1, j - 1
    return s

def reverse(s):
    chars = list(s)
    i, j = 0, len(chars) - 1
    while i < j:
        chars[i], chars[j] = chars[j], chars[i]
        i, j = i + 1, j - 1
    return ''.join(chars)

An operation between values that don't go together: a number plus a string, or None plus a number (usually a helper that forgot to return).

In DSA problems: Building an answer string from numbers ('#' + count), digit problems mixing '7' and 7, and recursive helpers that return None on one path, then get added up.

def encode(words):
    out = ''
    for w in words:
        out += len(w) + '#' + w
    return out

def encode(words):
    out = ''
    for w in words:
        out += str(len(w)) + '#' + w
    return out

A function was called with more or fewer values than it takes. Inside a class, Python passes the object as the first argument (self), so a method written without self gets one argument too many.

In DSA problems: LeetCode's Solution class: def twoSum(nums, target) without self, or calling your own helper as helper(x) instead of self.helper(x).

class Solution:
    def double(nums):
        return [2 * x for x in nums]

class Solution:
    def double(self, nums):
        return [2 * x for x in nums]

Dividing (or taking % of) a number by 0. C++ crashes with a "floating point exception", even for whole numbers.

In DSA problems: An average of an empty list, x % k with k = 0, slopes between two points with the same x (Max Points on a Line), and Koko-style rates when the speed starts at 0.

def average(nums):
    return sum(nums) / len(nums)

def average(nums):
    if not nums:
        return 0
    return sum(nums) / len(nums)

Popping or peeking at an empty stack, queue or heap, or taking the max of nothing. C++ doesn't check: st.top() on an empty stack reads garbage or crashes.

In DSA problems: Valid Parentheses with a closing bracket first ()(), monotonic stacks popping one time too many, BFS queues, and heaps in k-largest problems.

def is_valid(s):
    pairs = {')': '(', ']': '['}
    stack = []
    for ch in s:
        if ch in pairs:
            if stack.pop() != pairs[ch]:
                return False
        else:
            stack.append(ch)
    return not stack

def is_valid(s):
    pairs = {')': '(', ']': '['}
    stack = []
    for ch in s:
        if ch in pairs:
            if not stack or stack.pop() != pairs[ch]:
                return False
        else:
            stack.append(ch)
    return not stack

A function called itself too many times without finishing. Usually the base case is missing or never reached, so it would recurse forever; sometimes the input is just very deep (Python stops at about 1000 calls).

In DSA problems: A base case that misses (if n == 0 when n can skip past 0, if not node missing), recursing on the same input (f(n) instead of f(n - 1)), or DFS on a graph without a visited set, going back and forth between two nodes.

def count_down_steps(n):
    if n == 0:
        return 0
    return 1 + count_down_steps(n - 2)

def count_down_steps(n):
    if n <= 0:
        return 0
    return 1 + count_down_steps(n - 2)

C++ read or wrote memory it doesn't own, and the operating system stopped it. There's no friendly message: it's always one of a few causes.

In DSA problems: An index outside the vector (v[i] doesn't check), a null pointer (node->next when node is nullptr), st.top() on an empty stack, or recursion so deep the call stack runs out.

#include <bits/stdc++.h>
using namespace std;
struct Node { int val; Node* next; };
int second(Node* head) { return head->next->val; }
int main() { Node a{1, nullptr}; cout << second(&a); }

#include <bits/stdc++.h>
using namespace std;
struct Node { int val; Node* next; };
int second(Node* head) { return head && head->next ? head->next->val : -1; }
int main() { Node a{1, nullptr}; cout << second(&a); }

Adding or removing items from the collection a loop is walking through. Dictionaries and sets in Python, and lists in Java, refuse. A Python list doesn't complain: it silently skips items, which is worse.

In DSA problems: Removing zero counts from a frequency map inside the loop, deleting from a list while filtering it, or changing an adjacency list while traversing it.

def drop_zeros(count):
    for k in count:
        if count[k] == 0:
            del count[k]
    return count

def drop_zeros(count):
    for k in list(count):
        if count[k] == 0:
            del count[k]
    return count

A Python function without a return (or that ends without reaching one) returns None. The tests then see None instead of your answer.

In DSA problems: Building the answer in a variable and never returning it, returning only inside an if, or calling a recursive helper without returning its result (self.dfs(...) instead of return self.dfs(...)).

def squares(nums):
    out = [x * x for x in nums]

def squares(nums):
    out = [x * x for x in nums]
    return out

Prints None, then [1, 4] once fixed.

You'll notice: The test shows your output as None, though the list looked right.

Methods that change a list in place (sort, append, reverse, extend) return None, not the list. So nums = nums.sort() throws the list away.

In DSA problems: return nums.sort(), path = path.append(x) in backtracking, res = res.reverse(). Use sorted(nums) when you want a new sorted list.

def sorted_squares(nums):
    nums = [x * x for x in nums]
    return nums.sort()

def sorted_squares(nums):
    nums = [x * x for x in nums]
    nums.sort()
    return nums

Prints None, then [1, 4, 9] once fixed.

You'll notice: The answer appears under "What your code printed", and every test still fails.

The tests call your function and look at what it returns. Printing the answer shows it on screen, but the function still returns None.

In DSA problems: Very common coming from HackerRank-style problems that read input and print output. On LeetCode and here, the values arrive as parameters and the answer goes out with return.

def add(a, b):
    print(a + b)

def add(a, b):
    return a + b

Prints 5 · returned None, then returned 5 once fixed.

You'll notice: Your output is one more or one less than expected, often only on some tests.

A loop that runs one time too many or too few, or a range that includes or skips one element. range(a, b) stops before b; a window from i to j has j − i + 1 elements.

In DSA problems: Binary search bounds (< or <=, mid or mid ± 1), window lengths (right - left + 1), the last element of a loop, and inclusive vs exclusive ranges in prefix sums.

def longest_ones(nums):
    best = left = 0
    for right, x in enumerate(nums):
        if x == 0:
            left = right + 1
        best = max(best, right - left)
    return best

def longest_ones(nums):
    best = left = 0
    for right, x in enumerate(nums):
        if x == 0:
            left = right + 1
        best = max(best, right - left + 1)
    return best

Prints 2, then 3 once fixed.

You'll notice: Setting one cell changes the same column in every row.

[[0] * n] * m makes m references to the same row, so writing to one row writes to all of them. Each row needs to be its own list.

In DSA problems: DP tables and visited grids: dp = [[0] * cols] * rows makes every row change together and gives wrong answers with no error.

grid = [[0] * 2] * 2
grid[0][0] = 1
print(grid)

grid = [[0] * 2 for _ in range(2)]
grid[0][0] = 1
print(grid)

Prints [[1, 0], [1, 0]], then [[1, 0], [0, 0]] once fixed.

You'll notice: The right number of answers, but all of them empty (or all the same).

res.append(path) stores the list itself, not a snapshot. Backtracking keeps changing path (and empties it at the end), so every saved answer ends up the same, usually empty.

In DSA problems: Subsets, Permutations, Combination Sum and every other backtracking problem: the answer has the right count of lists, all empty or identical.

def subsets(nums):
    res, path = [], []
    def go(i):
        if i == len(nums):
            res.append(path)
            return
        go(i + 1)
        path.append(nums[i])
        go(i + 1)
        path.pop()
    go(0)
    return res

def subsets(nums):
    res, path = [], []
    def go(i):
        if i == len(nums):
            res.append(path[:])
            return
        go(i + 1)
        path.append(nums[i])
        go(i + 1)
        path.pop()
    go(0)
    return res

Prints [[], [], [], []], then [[], [2], [1], [1, 2]] once fixed.

You'll notice: The first test passes; later ones fail with answers that include earlier tests' values.

Something outlives one call: a class-level variable, a global, or a default argument like seen=[] (created once and reused). The first test passes; later ones see its leftovers.

In DSA problems: A memo dict or counter declared on the class instead of inside the method, or def dfs(node, path=[]). LeetCode runs many tests in one go, so this fails there too.

def add_item(x, items=[]):
    items.append(x)
    return items

def add_item(x, items=None):
    if items is None:
        items = []
    items.append(x)
    return items

Prints [1, 2], then [2] once fixed.

An int holds up to about 2.1 billion (2³¹ − 1). Go past it and Java wraps around to a negative number with no warning; in C++ it's undefined behaviour, which LeetCode reports as a runtime error. Python's integers never overflow.

In DSA problems: Sums and products of big values, mid = (left + right) / 2 with large indexes, and counting answers that need % 1_000_000_007. Look for constraints like nums[i] ≤ 10⁹.

class Main {
  public static void main(String[] a) {
    int left = 1_500_000_000, right = 2_000_000_000;
    int mid = (left + right) / 2;
    System.out.println(mid);
  }
}

class Main {
  public static void main(String[] a) {
    int left = 1_500_000_000, right = 2_000_000_000;
    int mid = left + (right - left) / 2;
    System.out.println(mid);
  }
}

Prints -397483648, then 1750000000 once fixed.

Python's // rounds down (−7 // 2 is −4) and % follows it (−7 % 3 is 2); Java and C++ round toward zero (−7 / 2 is −3) and % can be negative (−7 % 3 is −1). Same code, different answers.

In DSA problems: Evaluate Reverse Polish Notation (division truncates toward zero), negative prefix sums with % k (Subarray Sums Divisible by K), and hashing with negative numbers.

def divide(a, b):
    return a // b

def divide(a, b):
    return int(a / b)

Prints -4, then -3 once fixed.

In Java, == on objects (Integer, String, lists) asks "is this the same object?", not "is the value equal?". It happens to work for small Integers (−128 to 127) and literal strings, which makes the bug look random.

In DSA problems: Comparing counts read from two HashMaps (map1.get(c) == map2.get(c)), stack tops (stack.peek() == x), and strings built in a loop.

import java.util.*;
class Main {
  public static void main(String[] a) {
    Map<Character, Integer> m1 = new HashMap<>(), m2 = new HashMap<>();
    m1.put('a', 1000); m2.put('a', 1000);
    System.out.println(m1.get('a') == m2.get('a'));
  }
}

import java.util.*;
class Main {
  public static void main(String[] a) {
    Map<Character, Integer> m1 = new HashMap<>(), m2 = new HashMap<>();
    m1.put('a', 1000); m2.put('a', 1000);
    System.out.println(m1.get('a').equals(m2.get('a')));
  }
}

Prints false, then true once fixed.

Either the loop never ends, or the approach does far too much work for the input size. Both look the same: no answer in time.

In DSA problems: A while loop whose pointers don't move on some branch (binary search with left = mid), or an O(n²) loop where n is 10⁵. Rule of thumb: about 10⁸ simple steps per second, so n = 10⁵ needs O(n log n) or better.

def has_pair(nums, target):
    for i in range(len(nums)):
        for j in range(i + 1, len(nums)):
            if nums[i] + nums[j] == target:
                return True
    return False

def has_pair(nums, target):
    seen = set()
    for x in nums:
        if target - x in seen:
            return True
        seen.add(x)
    return False

Prints True, then True once fixed.

The program keeps too much at once: a huge table, a copy of the input on every call, or a list that grows forever in a loop.

In DSA problems: A full 2D DP table when only the previous row is needed, slicing lists in recursion (nums[1:] copies every time), or a queue that never stops growing because visited nodes are added again.

def total(nums):
    if not nums:
        return 0
    return nums[0] + total(nums[1:])

def total(nums, i=0):
    if i == len(nums):
        return 0
    return nums[i] + total(nums, i + 1)

Prints 6, then 6 once fixed.

You'll notice: All tests pass in the editor; LeetCode says Wrong Answer and shows one failing input.

The sample tests pass, but LeetCode's hidden tests include cases the samples don't: empty input, one element, duplicates, negatives, the largest values.

In DSA problems: LeetCode shows the failing input after a Wrong Answer: run that exact input by hand. It's almost always one of the edge cases below.

def max_sum(nums):
    best = 0
    cur = 0
    for x in nums:
        cur = max(x, cur + x)
        best = max(best, cur)
    return best

def max_sum(nums):
    best = nums[0]
    cur = 0
    for x in nums:
        cur = max(x, cur + x)
        best = max(best, cur)
    return best

Prints 0, then -1 once fixed.