• ✅/✔️ For finished
• 👷 For working in progress
• ❌ For unfinished due to complicity or challenging
• ❗For marking good questions
• ❓with doubt or unfinished
• Strikedthrough For not bothering (e.g. too easy)
• MARK in code for paying extra attention

• 🟢(Easy)
• 🟠(Medium)
• 🔴(Hard) 🤨

Since I use kotlin, I have created some convenient utility functions, mostly for testing/debugging purpose. (I might just create a branch with just the utility functions, however.. )

Note: To enable assertion for kotlin, pass in -ea as jvm launch argument, see this link

Other than those listed below, check out _util.kt for more

1. Run timed tests on a list of method variable. Sample usage checkout this Update: I noticed that this method may not be accurate, not sure of the cause

@OptIn(ExperimentalTime::class)
inline fun<reified T : KCallable<*>, reified R> List<T>.runTimedTests(
    testName: String? = Thread.currentThread().stackTrace.getOrNull(1)?.className?.split("$", limit = 0)?.get(0),
    printTime: Boolean = true,
    block: T.()->R
) {
    forEachIndexed { index, it ->
        val timeValue = measureTimedValue{ it.block() }
        val prefix = if (testName.isNullOrEmpty()) "" else "${testName}."
        if (printTime) println("execution for ${prefix}${it.name} finished, took ${timeValue.duration.inWholeNanoseconds} Nanoseconds")
    }
}

Sample print out:

execution for _2022._05.Leetcode_15.MY1.threeSum finished, took 476348 Nanoseconds
execution for _2022._05.Leetcode_15.MY1.threeSum finished, took 423606 Nanoseconds
execution for _2022._05.Leetcode_15.MY2.threeSum finished, took 435733 Nanoseconds

2. Assertion (assertEqual)

test() assertEqual "expected" // for single answer
test().assertEqual("possible_output1", "possible_output2") // for multiple correct answers 

3. Build-in data types
   1. Node (typealias IntNode = Node<Int>) and some built-in functions, e.g:
      1. fun <T> linkedNodesOf(vararg nodes: T) : Node<T> usage:linkedNodesOf(1, 2, 3) to create a linked nodes like 1 -> 2 -> 3
      2. fun <T> Node<T>.toList() : List<T> usage: linkedNodesOf(1, 2, 3).toList() gets: [1,2,3]
      3. fun <T, R> Node<T>.mapValue(transform: ((T)->R)) : List<R> usage: linkedNodesOf(1, 2, 3).mapValue{ it * 2 } gets [2,4,6]
      4. others see this file: Node

youngyangyang04/leetcode-master/0001.两数之和.md · GitHub

youngyangyang04/leetcode-master/0005.最长回文子串.md · GitHub

youngyangyang04/leetcode-master/0005.最长回文子串.md · GitHub

labuladong

TODO:

• https://labuladong.github.io/algo/2/17/18/

TODO: Leetcode_710

Leetcode 370: Range Addition

                                        |            |

• 572: can use a utility method isSameTree to check or need to be careful (see solution)

• 235: Binary search tree: left <= val <= right
• 746: Build an array dp where dp[i] is the minimum cost to climb to the top starting from the ith staircase.

• 191: use mod n = n % 2

Note:

• 130: reverse thinking, thanks all non-surrounded region to T and change all O to X then change Ts back to O

Notes:

• 55: M4
• 134: S1

Notes:

• bfs - order level traversal
• 98: binary search tree - sorted order
• 230: solution

Notes:

• 1584: Read S2 and link

Notes:!!

• 143: slow -> 0 and fast -> 1, fast jumps two steps while slow jumps one, when fast became null slow is at the end of the first half

• 207: S1

• 2385: S1

• 8: stupid ass question, not worth looking at

• 213: run house robber 1 two times with either first house included or the last

• 209: sliding window (left/right pointers)

• Union-Find/Disjoint Set

• Quick sort
• Quick select
• depth first search

• when there are multiple same value (not distinct), how to get the left most index of the given value (or right)
• l < r vs l <= r

• you can go either way
  • starting from position 0, and for each layer down the line you can either add or not add the next element (Leetcode_46), or
  • starting form all the element including, you can have any many children as the element, and for each child, consider the corresponding element removed (Leetcode_90)

• LeetCode Top 100 Problem Selection | Step-by-step Data Science
• GitHub - youngyangyang04/leetcode-master: 🚀 《代码随想录》LeetCode 刷题攻略：200道经典题目刷题顺序
• LABULADONG 的算法网站

• https://leetcode.com/problems/number-of-connected-components-in-an-undirected-graph/
• https://leetcode.com/problems/graph-valid-tree/
• https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/
• https://leetcode.com/problems/palindrome-partitioning/submissions/
• https://leetcode.cn/problems/construct-binary-tree-from-preorder-and-inorder-traversal/