LeetCode Custom Test Cases: Quick Validation or Full‑Proof?

Why Custom Test Cases Matter

When you’re tackling a LeetCode problem, the first thing that pops up is the code editor. Beneath the “Run Code” button, most problems expose a Custom Testcase panel. It lets you paste an input that follows the problem’s format and see the output instantly, without touching your submission history. For interview prep, that’s a quick sanity check that can save hours of back‑and‑forth.

How the Feature Works

The editor runs your solution inside LeetCode’s sandbox. The sandbox is a lightweight container that compiles (or interprets) your code, feeds it the custom input, and returns the result, runtime, and memory usage. The UI shows:

• Output text (what your code prints or returns)
• Runtime & memory metrics
• Compile or runtime error messages, if any

Because the sandbox mimics the judge environment, you can spot syntax errors, infinite loops, or obvious logic mistakes before you hit the official “Submit” button.

Getting the Input Right

LeetCode’s custom input must match the problem’s serialization rules. The most common formats are:

• Arrays: [1,2,3]
• Linked lists: [1,2,3] (LeetCode interprets it as a list)
• Binary trees: level‑order with null placeholders, e.g. [3,9,20,null,null,15,7]
• Strings: "hello world"

If you paste an incorrectly formatted string, the sandbox will either throw a parse error or silently misinterpret the data. Always double‑check the Input Format section of the problem statement.

Concrete Example: Two Sum

Let’s walk through a simple problem that returns indices of two numbers that add up to a target. The official LeetCode test cases include hidden edge cases like large arrays or negative numbers. We’ll use the custom runner to validate the core logic first.

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        lookup = {}
        for i, num in enumerate(nums):
            complement = target - num
            if complement in lookup:
                return [lookup[complement], i]
            lookup[num] = i
        return []

Open the problem page, switch to Python, and paste the following into the custom input box:

[2,7,11,15], 9

Click Run. You should see the output [0,1] and a runtime of 0.4 ms. This confirms that the basic logic works. Now try a trickier case:

[3,3], 6

The output should be [0,1]. If you get an empty array or an error, the sandbox will show it immediately.

Trade‑Offs and Limitations

Custom runs are a great first‑pass filter, but they’re not a guarantee of success on the official judge. Hidden tests may:

• Use larger inputs that exceed the time limits you see locally.
• Include edge cases you didn’t think of, such as duplicate values, very large integers, or empty structures.
• Check for additional constraints like space complexity or specific algorithmic properties.

Because the sandbox environment is the same as the judge’s, you’ll see the same runtime and memory metrics. However, the judge may run your code on a different set of inputs, so a passing custom run doesn’t eliminate the possibility of failure on submission.

Practical Checklist for Using Custom Test Cases

1. Verify the input format. Re‑read the Input Format section and match the serialization exactly.
2. Start with trivial cases. Empty arrays, single elements, or minimal trees help catch basic bugs.
3. Add edge cases. Duplicate values, negative numbers, maximum allowed sizes, or null pointers.
4. Check the metrics. Runtime and memory should be within acceptable bounds for the problem’s constraints.
5. Submit and compare. If the official judge fails, review the hidden test hints (if any) and adjust.

Bottom Line

LeetCode’s custom test case feature is a low‑cost, high‑value tool for early feedback during interview prep. Use it to catch obvious bugs, validate your algorithm’s logic, and get a feel for performance. But treat it as a first filter, not a final verdict. After a passing custom run, run through a series of edge cases and then submit to the official judge to confirm full compliance.