17 releases (5 stable)

1.2.4 Sep 9, 2023
1.2.3 Sep 4, 2023
1.0.2 Jan 17, 2022
1.0.0 Nov 24, 2020
0.1.16 Nov 19, 2020

#320 in Command line utilities

Download history 23/week @ 2023-11-01 2/week @ 2023-11-08 22/week @ 2023-11-15 20/week @ 2023-11-22 70/week @ 2023-11-29 1/week @ 2023-12-06 20/week @ 2023-12-13 18/week @ 2023-12-20 22/week @ 2023-12-27 17/week @ 2024-01-03 1/week @ 2024-01-10 29/week @ 2024-01-17 21/week @ 2024-01-24 18/week @ 2024-01-31 1/week @ 2024-02-07 132/week @ 2024-02-14

172 downloads per month

MIT/Apache and LGPL-3.0

120KB
3K SLoC

If you use neovim, try this Neovim plugin leetup.nvim

Rust crates Downloads

Solve Leetcode problems

Install

  • MacOS:
brew install leetup
  • Linux:
    Download from releases. Extract the zipped file and set the PATH.
  • Cargo:
cargo install leetup
  • Windows:
    Download from releases. Extract the zipped x86_64 windows target file.

Note: You will need to add leetup.exe to PATH to access from Command Prompt.

Quick Start:

  • Login using Cookie: leetup user -c

    • You need to login on leetcode.com first.
    • Copy csrftoken and LEETCODE_SESSION from cookie storage in the browser.
  • Pick a problem: leetup pick -l python 1

  • Test a problem: leetup test two-sum.py -t "[1,2]\n3" or redirect test data using stdin

    leetup test 3sum.java -t << END
    [1,-1,0]
    [0, 1, 1, 1, 2, -3, -1]
    [1,2,3]
    END
    
  • Submit a problem: leetup submit two-sum.py

  • List/Show problems: leetup list

    • Search by keyword: leetup list <keyword>
    • Query easy: leetup list -q e
    • Order by Id, Title, Difficulty: leetup list -qE -oIdT
  • More Commands

Inject code fragments:

You can inject pieces of code that you frequently use in certain positions of the generated code file. Example: Standard library imports for each language can be put into a config. Leetup will pick it up and insert into the generated file.

Config:

Create ~/.leetup/config.json and customize according to your preference:

{
    "inject_code": {
        "rust": {
            "before_code": ["use std::rc::Rc;", "use std::collections::{HashMap, VecDeque};", "use std::cell::RefCell;"],
            "before_code_exclude": ["// Test comment", "// Test code"],
            "after_code": "\nstruct Solution; \n\nfn main() {\n    let solution = Solution::$func();\n\n}\n",
            "before_function_definition": null
        },
        "java": {
            "before_code": "import java.util.*;",
            "before_code_exclude": ["// Test comment", "// Test code"],
            "after_code": null,
            "before_function_definition": null
        },
        "python3": {
            "before_code": "import math",
            "before_code_exclude": ["# Test comment", "# Test code"],
            "after_code": ["if __name__ = \"__main__\":", "    solution = Solution()"],
            "before_function_definition": null
        }
    }
}

Generated code looks something like this in Rust:

// @leetup=custom
// @leetup=info id=1 lang=rust slug=two-sum

/*
* [SNIP]
*/
// @leetup=custom

// @leetup=inject:before_code_ex
// Test comment
// Test code
// @leetup=inject:before_code_ex

// @leetup=code

// @leetup=inject:before_code
use std::cell::RefCell;
use std::collections::{HashMap, VecDeque};
use std::rc::Rc;
// @leetup=inject:before_code

impl Solution {
    pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {}
}
// @leetup=code

// @leetup=inject:after_code
// This is helpful when you want to run this program locally
// and avoid writing this boilerplate code for each problem.
struct Solution;

fn main() {
    let solution = Solution::two_sum();
}

// @leetup=inject:after_code

During testing and submitting to Leetcode, only the chunk of code between @leetup=code will be submitted:

// @leetup=inject:before_code
use std::cell::RefCell;
use std::collections::{HashMap, VecDeque};
use std::rc::Rc;
// @leetup=inject:before_code

impl Solution {
    pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
    }
}

Others are ignored!

Hook up script for Pick:

Run scripts before/after code generation. It's useful when you want more ergonomics to move around the generated file e.g. create a directory, move the generated file to the directory, rename, etc. @leetup=working_dir will be replaced by working_dir in config.
@leetup=problem will be replaced by the current problem tile e.g. two-sum.

{
    "inject_code": {
        ...SNIP...
    },
    "pick_hook": {
        "rust": {
            "working_dir": "~/lc/rust",
            "script": {
                "pre_generation": ["cd @leetup=working_dir; mkdir -p @leetup=problem"],
                "post_generation": ["mv @leetup=working_dir/@leetup=problem.rs @leetup=working_dir/@leetup=problem/Solution.rs"]
            }
        },
        "java": {
            "working_dir": "~/lc/java",
            "script": {
                "pre_generation": ["cd @leetup=working_dir", "mvn archetype:generate -DartifactId=@leetup=problem  -DgroupId=leetup  -DarchetypeGroupId=org.apache.maven.archetypes -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false"], 
                "post_generation": ["mv @leetup=working_dir/@leetup=problem.java @leetup=working_dir/@leetup=problem/src/main/java/App.java"]
            }
        }
    }
}

Credit:

This project is inspired by: https://github.com/leetcode-tools/leetcode-cli

Dependencies

~12–29MB
~443K SLoC