* * Time: O(log(n)) * * @param {number} num * @return void

* * Time: O(log(n)) * * @return {number}

* * Problem: * Given an unsorted array of numbers, find Kth smallest number in it. * * Example 1: * Input: [1, 5, 12, 2, 11, 5], K = 3 * Output:

* Time: O(n) the original quick sort time complexity is O(n log(n)), where log(n) is * the tree depth, for each tree level, it requires O(n) to do pa

* * Problem: * Given an array of numbers sorted in ascending order, find the element in the array * that has the minimum difference with the given

* * Problem: * Given a Bitonic array, find if a given 'key' is present in it. An array is considered * bitonic if it is monotonically increasing an

* * Problem: * Given an array of numbers which is sorted in ascending order and also rotated by some * arbitrary number, find if a given 'key' is p

* Get the next index based on the `currentIndex`.

* * Time: O(log(k)) * * @param {number} val

* * Problem: * Given an array of numbers sorted in an ascending order, find the ceiling of a given * number 'key'. The ceiling of the 'key' will be

* * Problem: * Find the maximum index in a given Bitonic array. An array is considered bitonic if it * is monotonically increasing and then monoton

* * Problem: * Given an infinite sorted array (or an array with unknown size), find if a given * number "key" is present in the array. Write a func

* * Problem: * Given a sorted array of numbers, find if a given number key is present in the array. * Though we know that the array is sorted, we d

* * Solution 1: recursive brute force. * * @param {number[]} nums * @return {boolean}

* * Problem: * Given a sequence originalSeq and an array of sequences, write a method to find if * originalSeq can be uniquely reconstructed from t

* * Problem: * There is a dictionary containing words from an alien language for which we don’t know * the ordering of the alphabets. Write a metho

* * Problem: * There are N tasks, labeled from 0 to N-1. Each task can have some prerequisite * tasks which need to be completed before it can be s

* * Problem: * Given the head of a Singly LinkedList that contains a cycle, write a function to * find the starting node of the cycle. * https://l

* * Problem: * Given the head of a Singly LinkedList, write a method to return the middle node of * the LinkedList. If the total number of nodes in

* * Problem: * We are given an undirected graph that has characteristics of a k-ary tree. In such a * graph, we can choose any node as the root to

* * Problem: * We are given an array containing n distinct numbers taken from the range 0 to * n. Since the array has only n numbers out of the tot

* * Problem: * We are given an array containing n distinct numbers taken from the range 0 to * n. Since the array has only n numbers out of the tot

* * Problem: * Given an array of numbers sorted in ascending order, find the range of a given * number "key". The range of the "key" will be the fi

* * Problem: * Given an array of intervals, find the next interval of each interval. In a list of * intervals, for an interval `i` its next interva

* * Solution 1: recursive brute force. * * @param {number[]} nums * @param {number} targetSum * @return {number}

* * Solution 2: top-down dynamic programming with memoization. * The only changing variable are again `currentIndex` and `targetSum`, the possible

* * Solution 3: bottom-up dynamic programming. * The meaning of `dp[i][j]` is given the first i numbers, how many ways we can find * to make its "s

* * Solution 4: bottom-up dynamic programming with reduced space. * * Time: O(mn) m: 2 * targetSum * Space: O(m) <- for `dp` and `cache` * * @pa

* Solution 5: Smaller sum range. * Based on the above analysis, the sum range for DP will be [-totalSum, totalSum], * we can shrink this range by ut

* * Problem: * We are given an array containing positive and negative numbers. Suppose the array * contains a number M at a particular index. Now,

* * Solution 1: recursive brute force. * * @param {number[]} nums * @return {number}

* * Solution 2: top-down dynamic programming with memoization. * * @param {number[]} nums * @return {number}

* * Solution 3: bottom-up dynamic programming. * How to derive the formula from row `i - 1` to row `i`? From the above solutions * we know that the

* * Solution 4: bottom-up dynamic programming with reduced space. * * Time: O(mn) m: total sum * Space: O(m) * * @param {number[]} nums * @retu

* * Problem: * Given a string and a number K, find if the string can be rearranged such that the * same characters are at least K distance apart fr

* * Problem: * Given a string, find if its letters can be rearranged in such a way that no two * same characters come next to each other. * https:

* * Another solution with better time complexity. * * Time: O(n) * Space: O(n) <- for `freqMap` and `buckets` * * @param {string} str * @return

* * Problem: * Given a string, find the length of the longest substring in it with no more than * K distinct characters. * https://leetcode.com/pr

* * For each number, we have 2 options: make it positive or make it negative, so it's * similar as the 0_0-1-knapsack problem (choose or skip). One

* * Similar as the problem 416_partition-equal-subset-sum, the only difference here * is we need to return the count, so if we have a match return 1

* * Time: O(2^n) <- for each number, we can choose to select or skip, 2 options. * Space: O(nm) m: targetSum <- for recursion stack * * @param {*}

* * Consider we have two subsets S1 and S2, we have `S1 + S2 = totalSum`, if we assume * S1's sum is less than S2, we can get `S2 - diff + S2 = tota

* * We can think about the whole process as a decision tree. For example, * Item: A B C * Weights: 1 2 3 * Profits: 1 6

* * Reverse the linked list from node p (inclusive) and node q (exclusive). * * @param {ListNode} p * @param {ListNode} q * @return {ListNode}

* * Problem: * Given a binary tree, populate an array to represent the averages of all of its * levels. * https://leetcode.com/problems/average-of

* * Problem: * Given two strings containing backspaces (identified by the character ‘#’), check if the * two strings are equal. Note that after bac

* * Problem: * Given an array of intervals representing ‘N’ appointments, find out if a person * can attend all the appointments. * * Example 1:

* * Problem: * Given a collection of candidate numbers (`candidates`) and a target number * (`target`), find all unique combinations in `candidates

* * Problem: * Given a binary tree, connect each node with its level order successor. The last * node of each level should point to the first node

* * Problem: * Given a binary tree, connect each node with its level order successor. The last * node of each level should point to a null node. *

* * Solution 1: recursive brute force. * * @param {number[]} nums * @param {number} targetSum * @return {number}

* * Solution 2: top-down dynamic programming with memoization. * * @param {number[]} nums * @param {number} targetSum * @return {number}

* * Solution 3: bottom-up dynamic programming. * The meaning of `dp[i][j]` here is given the first i numbers in the array, * what is the count of a

* * Solution 4: bottom-up dynamic programming with reduced space. * * Time: O(mn) m: `targetSum` * Space: O(m) <- for `dp` * * @param {number[]}

* * Problem: * Given a binary tree and a number S, find all paths in the tree such that the sum * of all the node values of each path equals S. Ple

* * Problem: * Given a number n, write a function to return the count of structurally unique Binary * Search Trees (BST) that can store values 1 to

* * Problem: * Given an array containing all the number from 1 to n without any duplicates, write * a function to sort the array in-place in O(n) a

* * Problem: * Given the head of a Singly LinkedList, write a function to determine if the * LinkedList has a cycle in it or not. * https://leetco

* * Problem: * Given a binary tree, find the length of its diameter. The diameter of a tree is * the number of nodes on the longest path between an

* * Problem: * Given an expression containing digits and operations (+, -, *), find all possible * ways in which the expression can be evaluated by

* * Problem: * Given a string and a pattern, find all anagrams of the pattern in the given string. * "Anagram" is actually a Permutation of a strin

* * Problem: * We are given an unsorted array containing n numbers taken from the range 1 to n. * The array has some numbers appearing twice, find

* * Problem: * We are given an unsorted array containing numbers taken from the range 1 to n. * The array can have duplicates, which means some num

* * Problem: * Every non-negative integer N has a binary representation, for example, 8 can be * represented as "1000" in binary and 7 as "0111" in

* * Problem: * We are given an unsorted array containing n numbers taken from the range 1 to n. * The array originally contained all the numbers fr

* * Problem: * We are given an unsorted array containing n+1 numbers taken from the range 1 to * n. The array has only one duplicate but it can be

* * How to do this without modifying the array? * * We can think about the array as a linked list, take `[1, 4, 4, 3, 2]` as an * example, array c

* * Problem: * For K employees, we are given a list of intervals representing the working hours * of each employee. Our goal is to find out if ther

* * Problem: * Given an unsorted array containing numbers and a number ‘k’, find the first ‘k’ * missing positive numbers in the array. * * Examp

* * Problem: * Given a sorted number array and two integers K and X, find K closest numbers to * X in the array. Return the numbers in the sorted o

* * Problem: * Given an array of points in the a 2D plane, find K closest points to the origin * (0, 0). Here, the distance between two points on a

* * Problem: * Given two sorted arrays in ascending order, find K pairs with the smallest sum where * each pair consists of numbers from both the a

* * We can also think about this problem as "Merge 2 sorted lists", here the "list" is * not the original array, instead we need to construct a list

* * Problem: * Given an unsorted array of numbers, find the Kth largest numbers in it. * https://leetcode.com/problems/kth-largest-element-in-an-ar

* * Problem: * Given an array of integers and an integer k. Find the least number of unique * integers after removing exactly k elements. * https:

* * Problem: * Given a string, find all of its permutations preserving the character sequence but * changing case. * https://leetcode.com/problems