DEV Community: tracelit

Python Tutor Alternative for LeetCode: Why TraceLit Exists

tracelit — Thu, 09 Apr 2026 07:55:04 +0000

If you've used Python Tutor to understand code execution, you already know how powerful visual tracing can be. But if you've tried using it for LeetCode problems — especially linked lists and trees — you've probably hit its limits.

What Python Tutor Does Well

Python Tutor is an incredible tool for learning programming fundamentals. It shows you:

How variables are stored in memory
How the call stack grows with function calls
How references and pointers work at the memory level

For intro CS courses, it's unmatched. There's a reason it's used by millions of students worldwide.

Where Python Tutor Falls Short for LeetCode

When you're grinding LeetCode for a technical interview, you need something different:

Feature	Python Tutor	TraceLit
Linked list rendering	Memory box diagram	Interactive graph with pointer labels
Binary tree rendering	Memory box diagram	Tree layout with L/R edges
Pointer tracking	Manual reference following	Auto-highlights head, curr, prev, slow, fast
LeetCode format	Doesn't understand `ListNode`/`TreeNode`	Built-in support, paste input like `[1,2,3,4,5]`
AI debugging	None	One-click bug detection with fix suggestion
Step controls	Forward only	Forward, backward, slider, auto-play

The Core Difference

Python Tutor shows you how memory works. TraceLit shows you how your algorithm works.

When you're debugging "why does my reverse linked list return the wrong answer", you don't need to see heap addresses. You need to see:

Where curr is pointing right now
What prev looks like after the pointer swap
The exact step where the list breaks

That's what TraceLit does.

Try It Yourself

Here's LeetCode 206 (Reverse Linked List) running in TraceLit. Watch how the pointers move at each step:

When to Use Which

Learning Python basics → Python Tutor
Understanding memory and references → Python Tutor
Grinding LeetCode for interviews → TraceLit
Debugging linked list / tree problems → TraceLit
Building intuition for pointer manipulation → TraceLit

They're complementary tools. Python Tutor taught you how code executes. TraceLit helps you see your algorithm think.

TraceLit is free during beta. 130+ NeetCode 150 problems with step-by-step visual traces.

LeetCode 46: Permutations — Step-by-Step Visual Trace

tracelit — Thu, 09 Apr 2026 07:06:06 +0000

Medium — Backtracking | Array | Recursion

The Problem

Given an array of distinct integers, return all possible permutations of the array elements in any order.

Approach

Uses backtracking with in-place swapping to generate permutations. At each position, we try placing each remaining element, recursively generate permutations for the rest, then backtrack by swapping elements back to their original positions.

Time: O(n! × n) · Space: O(n)

Code

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        def backtrack(start):
            if start == len(nums) - 1:
                permutations.append(nums[:])  # Append a copy of the current permutation

            for i in range(start, len(nums)):
                nums[start], nums[i] = nums[i], nums[start]  # Swap elements
                backtrack(start + 1)
                nums[start], nums[i] = nums[i], nums[start]  # Backtrack

        permutations = []
        backtrack(0)
        return permutations

Watch It Run

Built with TraceLit — the visual algorithm tracer for LeetCode practice.

LeetCode 235: Lowest Common Ancestor Of A Binary Search Tree — Step-by-Step Visual Trace

tracelit — Thu, 09 Apr 2026 07:06:04 +0000

Medium — Binary Search Tree | Tree | Recursion

The Problem

Find the lowest common ancestor (LCA) of two given nodes in a binary search tree, where the LCA is the deepest node that has both nodes as descendants.

Approach

Leverage the BST property to recursively navigate the tree. If both nodes are smaller than current node, go left; if both are larger, go right; otherwise the current node is the LCA.

Time: O(h) · Space: O(h)

Code

class Solution:
    def lowestCommonAncestor(
        self, root: TreeNode, p: TreeNode, q: TreeNode
    ) -> TreeNode:
        if root.val > p.val and root.val > q.val:
            return self.lowestCommonAncestor(root.left, p, q)
        elif root.val < p.val and root.val < q.val:
            return self.lowestCommonAncestor(root.right, p, q)
        else:
            return root

Watch It Run

Built with TraceLit — the visual algorithm tracer for LeetCode practice.

LeetCode 309: Best Time To Buy And Sell Stock With Cooldown — Step-by-Step Visual Trace

tracelit — Thu, 09 Apr 2026 07:05:30 +0000

Medium — Dynamic Programming | Array | State Machine

The Problem

Find the maximum profit from buying and selling stocks with a cooldown period of one day after each sale. You can complete multiple transactions but must wait one day after selling before buying again.

Approach

Use dynamic programming with three states: buy (maximum profit after buying), sell (maximum profit after selling), and cooldown (maximum profit during cooldown). Track the optimal profit for each state at every day by considering all possible transitions.

Time: O(n) · Space: O(1)

Code

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        if not prices:
            return 0

        # Initialize variables to represent the maximum profit after each action.
        buy = -prices[
            0
        ]  # Maximum profit after buying on day 0 (negative because we spend money).
        sell = 0  # Maximum profit after selling on day 0 (no profit yet).
        cooldown = 0  # Maximum profit after cooldown on day 0 (no profit yet).

        for i in range(1, len(prices)):
            # To maximize profit on day 'i', we can either:

            # 1. Buy on day 'i'. We subtract the price of the stock from the maximum profit after cooldown on day 'i-2'.
            new_buy = max(buy, cooldown - prices[i])

            # 2. Sell on day 'i'. We add the price of the stock to the maximum profit after buying on day 'i-1'.
            new_sell = buy + prices[i]

            # 3. Do nothing (cooldown) on day 'i'. We take the maximum of the maximum profit after cooldown on day 'i-1' and after selling on day 'i-1'.
            new_cooldown = max(cooldown, sell)

            # Update the variables for the next iteration.
            buy, sell, cooldown = new_buy, new_sell, new_cooldown

        # The maximum profit will be the maximum of the profit after selling on the last day and the profit after cooldown on the last day.
        return max(sell, cooldown)

Watch It Run

Built with TraceLit — the visual algorithm tracer for LeetCode practice.

LeetCode 20: Valid Parentheses — Step-by-Step Visual Trace

tracelit — Thu, 09 Apr 2026 07:05:12 +0000

Easy — Stack | String | Hash Table

The Problem

Determine if a string containing only parentheses characters is valid, where every opening bracket has a corresponding closing bracket in the correct order.

Approach

Use a stack data structure to track opening brackets. Push opening brackets onto the stack, and when encountering closing brackets, check if they match the most recent opening bracket. The string is valid if the stack is empty at the end.

Time: O(n) · Space: O(n)

Code

class Solution:
    def isValid(self, s: str) -> bool:
        stack = []
        parentheses_map = {")": "(", "}": "{", "]": "["}

        for char in s:
            if char in parentheses_map.values():
                stack.append(char)
            elif char in parentheses_map:
                if not stack or stack[-1] != parentheses_map[char]:
                    return False
                stack.pop()
            else:
                return False

        return not stack

Watch It Run

Built with TraceLit — the visual algorithm tracer for LeetCode practice.

LeetCode 239: Sliding Window Maximum — Step-by-Step Visual Trace

tracelit — Thu, 09 Apr 2026 07:04:39 +0000

Hard — Sliding Window | Deque | Queue | Array

The Problem

Find the maximum element in each sliding window of size k as it moves from left to right through an array. Return an array containing the maximum value for each window position.

Approach

Use a deque to maintain indices of array elements in decreasing order of their values. For each element, remove smaller elements from the back, add current index, remove indices outside the current window from front, and collect maximums when window is full.

Time: O(n) · Space: O(k)

Code

from collections import deque

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        if not nums or k <= 0:
            return []

        result = []
        window = deque()

        for i, num in enumerate(nums):
            while window and nums[window[-1]] < num:
                window.pop()

            window.append(i)

            if i - window[0] >= k:
                window.popleft()

            if i >= k - 1:
                result.append(nums[window[0]])

        return result

Watch It Run

Built with TraceLit — the visual algorithm tracer for LeetCode practice.

LeetCode 206: Reverse Linked List — Step-by-Step Visual Trace

tracelit — Thu, 09 Apr 2026 07:04:36 +0000

The Problem

Given the head of a singly linked list, reverse the list and return the reversed list.

Input: head = [1, 2, 3, 4, 5]
Output: [5, 4, 3, 2, 1]

This is one of the most classic interview questions — simple enough to explain in 30 seconds, but tricky enough that getting the pointer manipulation right under pressure trips people up.

The Approach: Three Pointers

The iterative approach uses three pointers: prev, current, and next_node.

Start with prev = None and current = head
At each step:
- Save the next node: next_node = current.next
- Reverse the pointer: current.next = prev
- Move forward: prev = current, current = next_node
When current is None, prev points to the new head

Time: O(n) — single pass through the list
Space: O(1) — only three pointer variables

The Code

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        prev = None
        current = head

        while current:
            next_node = current.next
            current.next = prev
            prev = current
            current = next_node

        return prev

Watch It Run

The best way to understand pointer manipulation is to see it happen. TraceLit traces your code line by line and shows you exactly how prev, current, and next_node move through the list at each step.

Key Insight

The trick is the order of operations. If you reverse current.next = prev before saving current.next, you lose the reference to the rest of the list. That's why next_node = current.next must come first.

This pattern — save, reverse, advance — shows up in many linked list problems:

LeetCode 92: Reverse Linked List II
LeetCode 25: Reverse Nodes in k-Group
LeetCode 234: Palindrome Linked List

Built with TraceLit — the visual algorithm tracer for LeetCode practice.

LeetCode 191: Number Of 1 Bits — Step-by-Step Visual Trace

tracelit — Thu, 09 Apr 2026 07:04:03 +0000

Easy — Bit Manipulation | Math

The Problem

Given a positive integer n, count and return the number of set bits (1s) in its binary representation.

Approach

Use bit manipulation to check each bit position by performing bitwise AND with 1 to detect if the least significant bit is set, then right shift to examine the next bit. Continue until all bits are processed.

Time: O(log n) · Space: O(1)

Code

class Solution:
    def hammingWeight(self, n: int) -> int:
        count = 0
        while n:
            count += n & 1
            n = n >> 1
        return count

Watch It Run

Built with TraceLit — the visual algorithm tracer for LeetCode practice.

LeetCode 56: Merge Intervals — Step-by-Step Visual Trace

tracelit — Thu, 09 Apr 2026 07:04:01 +0000

Medium — Array | Sorting | Intervals | Greedy

The Problem

Given an array of intervals where intervals[i] = [starti, endi], merge all overlapping intervals and return an array of the non-overlapping intervals that cover all the intervals in the input.

Approach

Sort intervals by start time, then iterate through them maintaining a result list. For each interval, if it overlaps with the last merged interval (current start ≤ last end), merge them by updating the end time to the maximum of both ends, otherwise add it as a new interval.

Time: O(n log n) · Space: O(1)

Code

class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        if not intervals:
            return []

        intervals.sort(key=lambda x: x[0])
        result = [intervals[0]]

        for interval in intervals[1:]:
            if interval[0] <= result[-1][1]:
                result[-1][1] = max(result[-1][1], interval[1])
            else:
                result.append(interval)

        return result

Watch It Run

Built with TraceLit — the visual algorithm tracer for LeetCode practice.

LeetCode 1046: Last Stone Weight — Step-by-Step Visual Trace

tracelit — Thu, 09 Apr 2026 07:03:27 +0000

Easy — Heap | Priority Queue | Array | Simulation

The Problem

Given an array of stone weights, repeatedly smash the two heaviest stones together until at most one stone remains, returning the weight of the last stone or 0 if no stones remain.

Approach

Use a max-heap to efficiently find the two heaviest stones at each step. Since Python's heapq implements a min-heap, we store negative values to simulate a max-heap. Extract the two largest stones, and if their weights differ, push the difference back into the heap.

Time: O(n log n) · Space: O(n)

Code

import heapq

class Solution:
    def lastStoneWeight(self, stones: List[int]) -> int:
        max_heap = [-stone for stone in stones]  # Use negative values for max-heap

        heapq.heapify(max_heap)

        while len(max_heap) > 1:
            x = -heapq.heappop(max_heap)  # Extract the largest stone
            y = -heapq.heappop(max_heap)  # Extract the second largest stone

            if x != y:
                heapq.heappush(max_heap, -(x - y))  # Push the remaining weight

        return -max_heap[0] if max_heap else 0

Watch It Run

Built with TraceLit — the visual algorithm tracer for LeetCode practice.

LeetCode 97: Interleaving String — Step-by-Step Visual Trace

tracelit — Thu, 09 Apr 2026 07:03:25 +0000

Medium — Dynamic Programming | String | Two Pointers

The Problem

Given three strings s1, s2, and s3, determine if s3 can be formed by interleaving the characters of s1 and s2 while maintaining the relative order of characters within each string.

Approach

Use dynamic programming with a 2D table where dp[i][j] represents whether the first i characters of s1 and first j characters of s2 can interleave to form the first i+j characters of s3. Fill the table by checking if characters from s1 or s2 match the current position in s3.

Time: O(m*n) · Space: O(m*n)

Code

class Solution:
    def isInterleave(self, s1: str, s2: str, s3: str) -> bool:
        # Get the lengths of s1, s2, and s3.
        m, n, p = len(s1), len(s2), len(s3)

        # If the sum of lengths of s1 and s2 is not equal to the length of s3, return False.
        if m + n != p:
            return False

        # Initialize a 2D DP array dp of size (m + 1) x (n + 1) to store intermediate results.
        dp = [[False] * (n + 1) for _ in range(m + 1)]

        # Base case: dp[0][0] is True since two empty strings can form an empty string.
        dp[0][0] = True

        # Fill in the first row of dp.
        for j in range(1, n + 1):
            dp[0][j] = dp[0][j - 1] and s2[j - 1] == s3[j - 1]

        # Fill in the first column of dp.
        for i in range(1, m + 1):
            dp[i][0] = dp[i - 1][0] and s1[i - 1] == s3[i - 1]

        # Fill in the rest of dp.
        for i in range(1, m + 1):
            for j in range(1, n + 1):
                # For dp[i][j] to be True, one of the following conditions must be met:
                # 1. dp[i-1][j] is True and s1[i-1] matches s3[i+j-1].
                # 2. dp[i][j-1] is True and s2[j-1] matches s3[i+j-1].
                dp[i][j] = (dp[i - 1][j] and s1[i - 1] == s3[i + j - 1]) or (
                    dp[i][j - 1] and s2[j - 1] == s3[i + j - 1]
                )

        # The result is stored in dp[m][n].
        return dp[m][n]

Watch It Run

Built with TraceLit — the visual algorithm tracer for LeetCode practice.

LeetCode 207: Course Schedule — Step-by-Step Visual Trace

tracelit — Thu, 09 Apr 2026 07:02:51 +0000

Medium — Graph | Topological Sort | BFS | Cycle Detection

The Problem

Determine if it's possible to finish all courses given a list of prerequisite pairs, where each pair [a,b] indicates course a requires course b to be completed first.

Approach

Use topological sorting with Kahn's algorithm to detect cycles in the course dependency graph. Build a graph and track in-degrees, then process courses with no prerequisites first, removing edges and checking if all courses can eventually be processed.

Time: O(V + E) · Space: O(V + E)

Code

class Solution:
    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
        graph = {i: [] for i in range(numCourses)}
        in_degree = [0] * numCourses

        # Construct the graph and count in-degrees
        for course, prereq in prerequisites:
            graph[prereq].append(course)
            in_degree[course] += 1

        # Initialize a queue with nodes having in-degree zero
        queue = collections.deque(
            [course for course, degree in enumerate(in_degree) if degree == 0]
        )

        # Perform topological sorting and update in-degrees
        while queue:
            node = queue.popleft()
            for neighbor in graph[node]:
                in_degree[neighbor] -= 1
                if in_degree[neighbor] == 0:
                    queue.append(neighbor)

        # If any course has in-degree greater than zero, there's a cycle
        return all(degree == 0 for degree in in_degree)

Watch It Run

Built with TraceLit — the visual algorithm tracer for LeetCode practice.