LeetCode Guide

All the example problems and exercises on this site are selected from LeetCode's free public problems. We also provide links to the problems, so you can go to the official website to practice directly.

To help beginners, here is a quick introduction to how the online judge works and some tips for using it.

Core Code Mode

When you solve problems on LeetCode, you are given a function template. You need to write the logic inside this function. This is usually called Core Code Mode.

For example, the first LeetCode problem "Two Sum" asks you to complete a function like twoSum:

class Solution {
    public int[] twoSum(int[] nums, int target) {
        
    }
}

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        
    }
};

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:

func twoSum(nums []int, target int) []int {
    
}

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(nums, target) {
    
};

This means you are given an array nums and a target value target. You need to write the algorithm, and finally return an array.

When you submit your solution, the system will test your twoSum function with several predefined test cases. It compares your output with the correct answer to check if your code works.

For users, Core Code Mode is the easiest way to practice. You only need to focus on writing the algorithm. Most coding platforms and technical interviews use this mode. But just in case, we will also introduce ACM Mode.

ACM Mode

ACM mode is a bit more complicated. The input is given as a string in a specific format. You need to parse this string yourself and print the result to standard output.

When you submit your code, the system will send each test case to your program as a formatted string. It will then compare your program's output with the expected output to check if your solution is correct.

For example, Nowcoder uses this ACM mode. Here is a screenshot. The code editor has no starter code, so you have to write everything from scratch:

For ACM mode, a useful tip is to separate your code into layers. Handle the input parsing separately from the core algorithm logic, like this:

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // This part handles the input and builds the test case
        int[] nums;
        int target;
        int N = scanner.nextInt();
        ...

        // Call the algorithm function to solve the problem
        System.out.println(twoSum(nums, target));
    }

    public static int[] twoSum(int[] nums, int target) {
        // Write your core algorithm here
    }
}

This way, your code is clear. You can copy and paste the input handling part as a template. The core logic is the same as what you write on LeetCode.

My suggestion is to use the core code style when learning. It's simple and easy. Before interviews or written tests, spend one or two hours to get used to ACM mode. Nowcoder has special practice problems for ACM mode, such as this problem list.

Next, I will introduce some tips for using problem-solving platforms and explain how these platforms check if your solution is correct.

How to Read the Problem

For example, let's look at LeetCode 704: Binary Search:

Input: nums = [-1,0,3,5,9,12], target = 9
Output: 4
Explanation: 9 exists in nums and its index is 4

Input: nums = [-1,0,3,5,9,12], target = 2
Output: -1
Explanation: 2 does not exist in nums so return -1

You are given an empty function. You need to implement the search function:

class Solution {
    public int search(int[] nums, int target) {
        // your code here
    }
}

class Solution {
public:
    int search(vector<int>& nums, int target) {
        // your code here
    }
};

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        # your code here

func search(nums []int, target int) int {
    // your code here
}

var search = function(nums, target) {
    // your code here
};

The problem gives you a sorted array nums in ascending order. You need to return the index of the element target in the array. If the target is not found, return -1.

How to Solve the Problem

This problem is meant to test the binary search algorithm, which we will talk about later. But here, let's just write a simple solution:

class Solution {
    public int search(int[] nums, int target) {
        // traverse the array, return the index if found
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] == target) {
                return i;
            }
        }
        return -1;
    }
}

class Solution {
public:
    int search(vector<int>& nums, int target) {
        // traverse the array, return the index if found
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] == target) {
                return i;
            }
        }
        return -1;
    }
};

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        # traverse the array, return the index if found
        for i in range(len(nums)):
            if nums[i] == target:
                return i
        return -1

func search(nums []int, target int) int {
    // traverse the array, return the index if found
    for i, num := range nums {
        if num == target {
            return i
        }
    }
    return -1
}

var search = function(nums, target) {
    // traverse the array, return the index if found
    for (let i = 0; i < nums.length; i++) {
        if (nums[i] === target) {
            return i;
        }
    }
    return -1;
};

Copy this code into the LeetCode editor. Click the "Run" button to test it with the cases at the bottom right. Click "Submit" to see if it passes all test cases.

How to Debug

The best way is to solve problems in your local editor. This allows you to use breakpoints and debug line by line. See the guide for the vscode plugin and Jetbrains IDE plugin.

You can also use print statements when working on the web. LeetCode will show your output at the bottom right. For simple bugs, printing values can help you find the problem.

How the Judge Works

At the time of writing, the code above can pass all test cases on LeetCode and can be submitted successfully.

LeetCode has many test cases, such as:

Test case: nums = [-1,0,3,5,9,12], target = 9
Expected output: 4

Test case: nums = [-1,0,3,5,9,12], target = 2
Expected output: -1

Test case: nums = [5], target = 5
Expected output: 0

...

These test cases are passed as input to your search function. The platform checks if your result matches the expected output.

If it matches, you pass that test case. If you pass all test cases, your code is considered correct.

The solution above is not the most efficient, but it gives the correct results and does not exceed the time limit. So the judge thinks it is correct.

Common Errors When Submitting Code

If the submitted code passes all the test cases in the backend, it is considered a successful submission, often referred to as AC (Accepted).

If the submitted code fails to pass all test cases, it is considered a failed submission. Common reasons for failure include:

Notes for Submitting Code on LeetCode

If you are new to solving problems on LeetCode, here are some common mistakes beginners make.

Do Not Use File-Level Global Variables

LeetCode will run your code with several predefined test cases, and check if your return values are correct. So, there is an important rule:

Do not use file-level global variables in your code. Otherwise, data from one test case may affect another. LeetCode also explains this here: https://support.leetcode.cn/hc/kb/article/1194344/

Some readers say their code works for one test case, but fails when they submit. This usually happens because the code only works for a single test case, but when submitted, different test cases share the same global variable, causing errors.

In this tutorial, when I talk about "global variables", I mean class-level variables, not file-level global variables.

Here is an example. For the problem of preorder traversal of a binary tree, you are given the root of a binary tree and asked to return the preorder traversal result. You can write:

class Solution {
    // correct example, class-level global variable
    LinkedList<Integer> res = new LinkedList<>();

    public List<Integer> preorderTraversal(TreeNode root) {
        traverse(root);
        return res;
    }

    void traverse(TreeNode root) {
        if (root == null) {
            return;
        }
        // other functions within the class can access res
        res.add(root.val);
        traverse(root.left);
        traverse(root.right);
    }
}

// Incorrect example, do not define global variables at the file level
// vector<int> res;

class Solution {
public:
    // Correct example, class-level global variable
    vector<int> res;

    vector<int> preorderTraversal(TreeNode* root) {
        traverse(root);
        return res;
    }

    void traverse(TreeNode* root) {
        if (!root) {
            return;
        }
        // Other functions within the class can access res
        res.push_back(root->val);
        traverse(root->left);
        traverse(root->right);
    }
};

# Wrong example, do not define global variables at the file level
# res = []

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        # Correct example, class-level global variable
        self.res = []
        self.traverse(root)
        return self.res

    def traverse(self, root):
        if not root:
            return
        # Other functions within the class can access res
        self.res.append(root.val)
        self.traverse(root.left)
        self.traverse(root.right)

// Incorrect example, do not define global variables at the file level
// var res []int

func preorderTraversal(root *TreeNode) []int {
    // Correct example, use closure to allow the
    // traverse function to also access the res variable
    var res []int

    var traverse func(*TreeNode)
    traverse = func(root *TreeNode) {
        if root == nil {
            return
        }
        // Access and modify the res variable
        res = append(res, root.Val)
        traverse(root.Left)
        traverse(root.Right)
    }
    traverse(root)
    return res
}

// Incorrect example, do not define global variables at the file level
// let res = [];

/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var preorderTraversal = function(root) {
    // Correct example, use closure to allow the traverse
    // function to access the res variable internally
    let res = [];

    var traverse = (root) => {
        if (!root) {
            return;
        }
        // Access and modify the res variable
        res.push(root.val);
        traverse(root.left);
        traverse(root.right);
    }
    traverse(root);
    return res;
};

For languages like Java/C++/Python, which use a Solution class, you can put shared variables inside the class. For Go/JavaScript, which do not use classes, you can define higher-order functions and use closures to let inner functions access shared variables.

Or, you can pass the variable as a function parameter. This is also a good solution:

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        // correct example, passed as an argument to other functions
        LinkedList<Integer> res = new LinkedList<>();
        traverse(root, res);
        return res;
    }

    void traverse(TreeNode root, LinkedList<Integer> res) {
        if (root == null) {
            return;
        }
        // access and modify the res variable
        res.add(root.val);
        traverse(root.left, res);
        traverse(root.right, res);
    }
}

// Incorrect example, do not define global variables at the file level
// vector<int> res;

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        // Correct example, pass as a parameter to other functions
        vector<int> res;
        traverse(root, res);
        return res;
    }

    void traverse(TreeNode* root, vector<int>& res) {
        if (!root) {
            return;
        }
        // Access and modify the res variable
        res.push_back(root->val);
        traverse(root->left, res);
        traverse(root->right, res);
    }
};

# Wrong example, do not define global variables at the file level
# res = []

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        # Correct example, pass as a parameter to other functions
        res = []
        self.traverse(root, res)
        return res

    def traverse(self, root, res):
        if not root:
            return
        # Access and modify the res variable
        res.append(root.val)
        self.traverse(root.left, res)
        self.traverse(root.right, res)

// Wrong example, do not define global variables at the file level
// var res []int

func preorderTraversal(root *TreeNode) []int {
    // Correct example, pass as a parameter to other functions
    var res []int
    traverse(root, &res)
    return res
}

func traverse(root *TreeNode, res *[]int) {
    if root == nil {
        return
    }
    // Access and modify the res variable
    *res = append(*res, root.Val)
    traverse(root.Left, res)
    traverse(root.Right, res)
}

// Wrong example, do not define global variables at the file level
// let res = [];

/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var preorderTraversal = function(root) {
    // Correct example, pass it as a parameter to other functions
    let res = [];
    traverse(root, res);
    return res;
}

var traverse = (root, res) => {
    if (!root) {
        return;
    }
    // Access and modify the res variable
    res.push(root.val);
    traverse(root.left, res);
    traverse(root.right, res);
}

Remove Print Statements Before Submitting

When running test cases, LeetCode will show your code's standard output. You can use print statements to debug. But, before you submit your code, always comment out all print statements.

Standard output is an IO operation, which is slow. If you keep print statements, your code may be optimal, but it will run slowly or even fail because of timeouts.

That's all for now. Next, I will guide you through some easy LeetCode problems for practice. Reading is not enough—you need to try it yourself!