reverse.json

{
    "Given two strings str1 and str2,\u00a0return the shortest string that has both str1\u00a0and str2\u00a0as subsequences.\u00a0\u00a0If multiple answers exist, you may return any of them.(A string S is a subsequence of string T if deleting some number of characters from T (possibly 0, and the characters are chosen anywhere from T) results in the string S.)\u00a0": [
        "shortest-common-supersequence",
        [
            "longest-common-subsequence"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Given a file and assume that you can only read the file using a given method\u00a0read4, implement a method to read n characters.\u00a0Method read4: The API\u00a0read4 reads 4 consecutive characters from the file, then writes those characters into the buffer array buf.The return value is the number of actual characters read.": [
        "read-n-characters-given-read4",
        [
            "read-n-characters-given-read4-ii-call-multiple-times"
        ],
        [
            "String"
        ]
    ],
    "Design and implement a TwoSum class. It should support the following operations: add and find.add - Add the number to an internal data structure.find - Find if there exists any pair of numbers which sum is equal to the value.": [
        "two-sum-iii-data-structure-design",
        [
            "two-sum-iv-input-is-a-bst",
            "unique-word-abbreviation",
            "two-sum"
        ],
        [
            "Hash Table",
            "Design"
        ]
    ],
    "Given a list of words and two words word1 and word2, return the shortest distance between these two words in the list.": [
        "shortest-word-distance",
        [
            "shortest-word-distance-iii",
            "shortest-word-distance-ii"
        ],
        [
            "Array"
        ]
    ],
    "A strobogrammatic number is a number that looks the same when rotated 180 degrees (looked at upside down).Write a function to determine if a number is strobogrammatic. The number is represented as a string.\u00a0": [
        "strobogrammatic-number",
        [
            "confusing-number",
            "strobogrammatic-number-iii",
            "strobogrammatic-number-ii"
        ],
        [
            "Hash Table",
            "Math"
        ]
    ],
    "Given an array of meeting time intervals consisting of start and end times [[s1,e1],[s2,e2],...] (si < ei), determine if a person could attend all meetings.": [
        "meeting-rooms",
        [
            "meeting-rooms-ii",
            "merge-intervals"
        ],
        [
            "Sort"
        ]
    ],
    "There are a row of n houses, each house can be painted with one of the three colors: red, blue or green. The cost of painting each house with a certain color is different. You have to paint all the houses such that no two adjacent houses have the same color.The cost of painting each house with a certain color is represented by a n x 3 cost matrix. ": [
        "paint-house",
        [
            "paint-fence",
            "paint-house-ii",
            "house-robber-ii",
            "house-robber"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Given a string, determine if a permutation of the string could form a palindrome.": [
        "palindrome-permutation",
        [
            "longest-palindrome",
            "palindrome-permutation-ii",
            "valid-anagram",
            "longest-palindromic-substring"
        ],
        [
            "Hash Table"
        ]
    ],
    "Given a non-empty binary search tree and a target value, find the value in the BST that is closest to the target.": [
        "closest-binary-search-tree-value",
        [
            "search-in-a-binary-search-tree",
            "closest-binary-search-tree-value-ii",
            "count-complete-tree-nodes"
        ],
        [
            "Binary Search",
            "Tree"
        ]
    ],
    "There is a fence with n posts, each post can be painted with one of the k colors.You have to paint all the posts such that no more than two adjacent fence posts have the same color.Return the total number of ways you can paint the fence.": [
        "paint-fence",
        [
            "paint-house-ii",
            "paint-house",
            "house-robber-ii",
            "house-robber"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "You are playing the following Flip Game with your friend: Given a string that contains only these two characters: + and -, you and your friend take turns to flip two consecutive \"++\" into \"--\". The game ends when a person can no longer make a move and therefore the other person will be the winner.Write a function to compute all possible states of the string after one valid move.": [
        "flip-game",
        [
            "flip-game-ii"
        ],
        [
            "String"
        ]
    ],
    "Given a nested list of integers, return the sum of all integers in the list weighted by their depth.Each element is either an integer, or a list -- whose elements may also be integers or other lists.": [
        "nested-list-weight-sum",
        [
            "employee-importance",
            "array-nesting",
            "nested-list-weight-sum-ii"
        ],
        [
            "Depth-first Search"
        ]
    ],
    "Given a stream of integers and a window size, calculate the moving average of all integers in the sliding window.": [
        "moving-average-from-data-stream",
        [],
        [
            "Design",
            "Queue"
        ]
    ],
    "Design a logger system that receive stream of messages along with its timestamps, each message should be printed if and only if it is not printed in the last 10 seconds.Given a message and a timestamp (in seconds granularity), return true if the message should be printed in the given timestamp, otherwise returns false.It is possible that several messages arrive roughly at the same time.": [
        "logger-rate-limiter",
        [
            "design-hit-counter"
        ],
        [
            "Hash Table",
            "Design"
        ]
    ],
    "    Given a non-empty string s and an abbreviation abbr, return whether the string matches with the given abbreviation.    A string such as \"word\" contains only the following valid abbreviations:[\"word\", \"1ord\", \"w1rd\", \"wo1d\", \"wor1\", \"2rd\", \"w2d\", \"wo2\", \"1o1d\", \"1or1\", \"w1r1\", \"1o2\", \"2r1\", \"3d\", \"w3\", \"4\"]    Notice that only the above abbreviations are valid abbreviations of the string \"word\". Any other string is not a valid abbreviation of \"word\".": [
        "valid-word-abbreviation",
        [
            "word-abbreviation",
            "minimum-unique-word-abbreviation"
        ],
        [
            "String"
        ]
    ],
    "Given a sequence of words, check whether it forms a valid word square.A sequence of words forms a valid word square if the kth row and column read the exact same string, where 0 \u2264 k < max(numRows, numColumns).": [
        "valid-word-square",
        [
            "toeplitz-matrix",
            "word-squares"
        ],
        []
    ],
    "Design and implement a data structure for a compressed string iterator. The given compressed string will be in the form of each letter followed by a positive integer representing the number of this letter existing in the original uncompressed string.Implement the\u00a0StringIterator class:next()\u00a0Returns the next character if the original string still has uncompressed characters, otherwise returns a white space.hasNext()\u00a0Returns true if\u00a0there is any letter needs to be uncompressed in the original string, otherwise returns false.\u00a0": [
        "design-compressed-string-iterator",
        [
            "string-compression",
            "lru-cache"
        ],
        [
            "Design"
        ]
    ],
    "    Given m arrays, and each array is sorted in ascending order. Now you can pick up two integers from two different arrays (each array picks one) and calculate the distance. We define the distance between two integers a and b to be their absolute difference |a-b|. Your task is to find the maximum distance.    ": [
        "maximum-distance-in-arrays",
        [],
        [
            "Array",
            "Hash Table"
        ]
    ],
    "Design a max stack that supports push, pop, top, peekMax and popMax.": [
        "max-stack",
        [
            "min-stack"
        ],
        [
            "Design",
            "Design"
        ]
    ],
    "We can represent a\u00a0sentence as an array of words, for example, the\u00a0sentence \"I am happy with leetcode\" can be represented as arr = [\"I\",\"am\",happy\",\"with\",\"leetcode\"].Given two\u00a0sentences\u00a0sentence1 and\u00a0sentence2 each represented as a string array and given an array of string pairs similarPairs where\u00a0similarPairs[i] = [xi, yi]\u00a0indicates that the two words\u00a0xi and\u00a0yi are similar.Return true if\u00a0sentence1\u00a0and\u00a0sentence2\u00a0are similar, or false if they are not similar.Two sentences are similar if:They have the same length (i.e. the same number of words)sentence1[i] and\u00a0sentence2[i]\u00a0are similar.Notice that a word is always similar to itself, also notice that the similarity relation is not transitive. ": [
        "sentence-similarity",
        [],
        [
            "Hash Table"
        ]
    ],
    "Given a set of keywords words and a string S, make all appearances of all keywords in S bold. Any letters between <b> and </b> tags become bold.The returned string should use the least number of tags possible, and of course the tags should form a valid combination.": [
        "bold-words-in-string",
        [],
        [
            "String"
        ]
    ],
    "    Given two lists Aand B, and B is an anagram of A. B is an anagram of A means B is made by randomizing the order of the elements in A.        We want to find an index mapping P, from A to B. A mapping P[i] = j means the ith element in A appears in B at index j.        These lists A and B may contain duplicates.  If there are multiple answers, output any of them.        ": [
        "find-anagram-mappings",
        [],
        [
            "Hash Table"
        ]
    ],
    "In the following, every capital letter represents some hexadecimal digit from 0 to f.The red-green-blue color \"#AABBCC\"\u00a0can be written\u00a0as\u00a0\"#ABC\" in\u00a0shorthand.\u00a0 ": [
        "similar-rgb-color",
        [],
        [
            "Math",
            "String"
        ]
    ],
    "Given a number N, return true if and only if it is a confusing number, which satisfies the following condition:We can rotate digits by 180 degrees to form new digits. When 0, 1, 6, 8, 9 are rotated 180 degrees, they become 0, 1, 9, 8, 6 respectively. When 2, 3, 4, 5 and 7 are rotated 180 degrees, they become invalid. A confusing number is a number that when rotated 180 degrees becomes a different number with each digit valid.\u00a0": [
        "confusing-number",
        [
            "confusing-number-ii",
            "strobogrammatic-number"
        ],
        [
            "Math"
        ]
    ],
    "Given an array A of distinct integers sorted in ascending order, return the smallest index i that satisfies A[i] == i.\u00a0 Return -1 if no such i exists.\u00a0": [
        "fixed-point",
        [],
        [
            "Array",
            "Binary Search"
        ]
    ],
    "Given a text\u00a0string and words (a list of strings), return all index pairs [i, j] so that the substring text[i]...text[j]\u00a0is in the list of words.\u00a0": [
        "index-pairs-of-a-string",
        [],
        [
            "String",
            "Trie"
        ]
    ],
    "Given an array A of positive integers, let S be the sum of the digits of the minimal element of A.Return 0 if S is odd, otherwise return 1.\u00a0": [
        "sum-of-digits-in-the-minimum-number",
        [
            "add-digits"
        ],
        [
            "Array"
        ]
    ],
    "Given a list of scores of different students, return the average score of each student's top five scores in the order of each student's id.Each entry items[i]\u00a0has items[i][0] the student's id, and items[i][1] the student's score.\u00a0 The average score is calculated using integer division.\u00a0": [
        "high-five",
        [],
        [
            "Array",
            "Hash Table",
            "Sort"
        ]
    ],
    "Given an array A of integers and\u00a0integer K, return the maximum S such that there exists i < j with A[i] + A[j] = S and S < K. If no i, j exist satisfying this equation, return -1.\u00a0": [
        "two-sum-less-than-k",
        [
            "subarray-product-less-than-k",
            "3sum-smaller",
            "two-sum-ii-input-array-is-sorted",
            "two-sum"
        ],
        [
            "Array"
        ]
    ],
    "Given a year Y and a month M, return how many days there are in that month.\u00a0": [
        "number-of-days-in-a-month",
        [],
        []
    ],
    "Given a string S, remove the vowels 'a', 'e', 'i', 'o', and 'u' from it, and return the new string.\u00a0": [
        "remove-vowels-from-a-string",
        [
            "reverse-vowels-of-a-string"
        ],
        [
            "String"
        ]
    ],
    "Given an array of integers A, return the largest integer that only occurs once.If no integer occurs once, return -1.\u00a0": [
        "largest-unique-number",
        [],
        [
            "Hash Table"
        ]
    ],
    "The k-digit number N is an Armstrong number if and only if the k-th power of each digit sums to N.Given a positive integer N, return true if and only if it is an Armstrong number.\u00a0": [
        "armstrong-number",
        [],
        [
            "Math"
        ]
    ],
    "Given an array nums sorted in non-decreasing order, and a number target, return True if and only if target is a majority element.A majority element is an element that appears more than N/2 times in an array of length N.\u00a0": [
        "check-if-a-number-is-majority-element-in-a-sorted-array",
        [
            "majority-element-ii",
            "majority-element"
        ],
        [
            "Array",
            "Binary Search"
        ]
    ],
    "There is a special keyboard with all keys in a single row.Given a string keyboard of length 26 indicating the layout of the keyboard (indexed from 0 to\u00a025), initially your finger is at index 0. To type a character, you have to move your finger to the index of the desired character. The time taken to move your finger from index i to index j is |i - j|.You want to type a string word. Write a function to calculate how much time it takes to type it with one finger.\u00a0": [
        "single-row-keyboard",
        [],
        [
            "String"
        ]
    ],
    "A dieter consumes\u00a0calories[i]\u00a0calories on the i-th day.\u00a0Given an integer k, for every consecutive sequence of k days (calories[i], calories[i+1], ..., calories[i+k-1]\u00a0for all 0 <= i <= n-k), they look at T, the total calories consumed during that sequence of k days (calories[i] + calories[i+1] + ... + calories[i+k-1]):If T < lower, they performed poorly on their diet and lose 1 point;\u00a0If T > upper, they performed well on their diet and gain 1 point;Otherwise, they performed normally and there is no change in points.Initially, the dieter has zero points. Return the total number of points the dieter has after dieting for calories.length\u00a0days.": [
        "diet-plan-performance",
        [],
        [
            "Array",
            "Sliding Window"
        ]
    ],
    "Given a string S,\u00a0return the number of substrings that have\u00a0only one distinct letter.\u00a0": [
        "count-substrings-with-only-one-distinct-letter",
        [],
        [
            "Math",
            "String"
        ]
    ],
    "You have some apples, where arr[i] is the weight of the i-th apple.\u00a0 You also have a basket that can carry up to 5000 units of weight.Return the maximum number of apples you can put in the basket.\u00a0": [
        "how-many-apples-can-you-put-into-the-basket",
        [],
        [
            "Greedy"
        ]
    ],
    "Given three integer arrays arr1, arr2 and arr3\u00a0sorted in strictly increasing order, return a sorted array of only\u00a0the\u00a0integers that appeared in all three arrays.\u00a0": [
        "intersection-of-three-sorted-arrays",
        [
            "intersection-of-two-arrays"
        ],
        [
            "Hash Table",
            "Two Pointers"
        ]
    ],
    "In some array arr, the values were in arithmetic progression: the values\u00a0arr[i+1] - arr[i]\u00a0are all\u00a0equal for every\u00a00 <= i < arr.length - 1.Then, a value from arr\u00a0was removed that was\u00a0not the first or last value in the array.Return the removed value.\u00a0": [
        "missing-number-in-arithmetic-progression",
        [],
        [
            "Math"
        ]
    ],
    "Given an initial array arr, every day you produce a new array using the array of the previous day.On the i-th day, you do the following operations on the array of day\u00a0i-1\u00a0to produce the array of day i:If an element is smaller than both its left neighbor and its right neighbor, then this element is incremented.If an element is bigger than both its left neighbor and its right neighbor, then this element is decremented.The first\u00a0and last elements never change.After some days, the array does not change. Return that final array.\u00a0": [
        "array-transformation",
        [],
        [
            "Array"
        ]
    ],
    "A decimal number can be converted to its\u00a0Hexspeak representation\u00a0by first converting it to an uppercase hexadecimal string, then replacing all occurrences of the digit 0 with the letter O, and the digit 1 with the letter I.\u00a0 Such a representation\u00a0is valid\u00a0if and only if it consists only of the letters in the set {\"A\", \"B\", \"C\", \"D\", \"E\", \"F\", \"I\", \"O\"}.Given a string num\u00a0representing a decimal integer N, return the Hexspeak representation of N if it is valid, otherwise return \"ERROR\".\u00a0": [
        "hexspeak",
        [],
        [
            "Math",
            "String"
        ]
    ],
    "Given an integer array arr, count how many elements\u00a0x\u00a0there are, such that x + 1 is also in arr.If there're duplicates in\u00a0arr, count them seperately.\u00a0": [
        "counting-elements",
        [],
        [
            "Array"
        ]
    ],
    "You are given a string s\u00a0containing lowercase English letters, and a matrix\u00a0shift, where\u00a0shift[i] = [direction, amount]:direction\u00a0can be 0\u00a0(for left shift) or 1\u00a0(for right shift).\u00a0amount\u00a0is the amount by which string\u00a0s\u00a0is to be shifted.A left shift by 1 means remove the first character of s and append it to the end.Similarly, a right shift by 1 means remove the last character of s and add it to the beginning.Return the final string after all operations.\u00a0": [
        "perform-string-shifts",
        [],
        [
            "Array",
            "Math"
        ]
    ],
    "In a binary tree, a lonely node is a node that is the only child of its parent node. The root of the tree is not lonely because it does not have a parent node.Given the root of a binary tree, return an array containing the values of all lonely nodes in the tree. Return the list in any order.\u00a0": [
        "find-all-the-lonely-nodes",
        [
            "univalued-binary-tree",
            "binary-tree-tilt"
        ],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given the\u00a0head\u00a0of a linked list and two integers m and n. Traverse the linked list and remove some nodes\u00a0in the following way:Start with the head as the current node.Keep the first m nodes starting with the current node.Remove the next n nodesKeep repeating steps 2 and 3 until you reach the end of the list.Return the head of the modified list after removing the mentioned nodes.Follow up question: How can you solve this problem by modifying the list in-place?\u00a0": [
        "delete-n-nodes-after-m-nodes-of-a-linked-list",
        [],
        [
            "Linked List"
        ]
    ],
    "Given the root of a binary tree, turn the tree upside down and return the new root.You can turn a binary tree upside down with the following steps:The original left child becomes the new root.The original root becomes the new right child.The original right child\u00a0becomes the new left child.The mentioned steps are done level by level, it is guaranteed that for each node in the given tree if this node has a right child then it also has a left child.\u00a0": [
        "binary-tree-upside-down",
        [
            "reverse-linked-list"
        ],
        [
            "Tree"
        ]
    ],
    "Given a string s , find the length of the longest substring\u00a0t\u00a0\u00a0that contains at most 2 distinct characters.": [
        "longest-substring-with-at-most-two-distinct-characters",
        [
            "subarrays-with-k-different-integers",
            "longest-substring-with-at-most-k-distinct-characters",
            "sliding-window-maximum",
            "longest-substring-without-repeating-characters"
        ],
        [
            "Hash Table",
            "Two Pointers",
            "String",
            "Sliding Window"
        ]
    ],
    "Given two strings s\u00a0and t, return true if they are both one edit distance apart, otherwise return false.A string s is said to be one distance apart from a string t if you can:Insert exactly one character into s\u00a0to get\u00a0t.Delete exactly one character from\u00a0s\u00a0to get\u00a0t.Replace exactly one character of\u00a0s\u00a0with a different character to get\u00a0t.\u00a0": [
        "one-edit-distance",
        [
            "edit-distance"
        ],
        [
            "String"
        ]
    ],
    "Given a sorted integer array nums, where the range of elements are in the inclusive range [lower, upper], return its missing ranges.": [
        "missing-ranges",
        [
            "summary-ranges"
        ],
        [
            "Array"
        ]
    ],
    "Given an input string\u00a0, reverse the string word by word.\u00a0": [
        "reverse-words-in-a-string-ii",
        [
            "rotate-array",
            "reverse-words-in-a-string"
        ],
        [
            "String"
        ]
    ],
    "Design a class which receives a list of words in the constructor, and implements a method that takes two words word1 and word2 and return the shortest distance between these two words in the list. Your method will be called repeatedly many times with different parameters.\u00a0": [
        "shortest-word-distance-ii",
        [
            "shortest-word-distance-iii",
            "shortest-word-distance",
            "merge-two-sorted-lists"
        ],
        [
            "Hash Table",
            "Design"
        ]
    ],
    "Given a list of words and two words word1 and word2, return the shortest distance between these two words in the list.word1 and word2 may be the same and they represent two individual words in the list.": [
        "shortest-word-distance-iii",
        [
            "shortest-word-distance-ii",
            "shortest-word-distance"
        ],
        [
            "Array"
        ]
    ],
    "A strobogrammatic number is a number that looks the same when rotated 180 degrees (looked at upside down).Find all strobogrammatic numbers that are of length = n.": [
        "strobogrammatic-number-ii",
        [
            "strobogrammatic-number-iii",
            "strobogrammatic-number"
        ],
        [
            "Math",
            "Recursion"
        ]
    ],
    "Given a string, we can \"shift\" each of its letter to its successive letter, for example: \"abc\" -> \"bcd\". We can keep \"shifting\" which forms the sequence:\"abc\" -> \"bcd\" -> ... -> \"xyz\"Given a list of non-empty strings which contains only lowercase alphabets, group all strings that belong to the same shifting sequence.": [
        "group-shifted-strings",
        [
            "group-anagrams"
        ],
        [
            "Hash Table",
            "String"
        ]
    ],
    "Given the root of a binary tree, return the number of uni-value subtrees.A uni-value subtree means all nodes of the subtree have the same value.\u00a0": [
        "count-univalue-subtrees",
        [
            "longest-univalue-path",
            "subtree-of-another-tree"
        ],
        [
            "Tree"
        ]
    ],
    "Design and implement an iterator to flatten a 2d vector. It should support the following operations: next and hasNext.\u00a0": [
        "flatten-2d-vector",
        [
            "flatten-nested-list-iterator",
            "peeking-iterator",
            "zigzag-iterator",
            "binary-search-tree-iterator"
        ],
        [
            "Design"
        ]
    ],
    "Given an array of meeting time intervals consisting of start and end times [[s1,e1],[s2,e2],...] (si < ei), find the minimum number of conference rooms required.": [
        "meeting-rooms-ii",
        [
            "car-pooling",
            "minimum-number-of-arrows-to-burst-balloons",
            "meeting-rooms",
            "merge-intervals"
        ],
        [
            "Heap",
            "Greedy",
            "Sort"
        ]
    ],
    "Numbers can be regarded as product of its factors. ": [
        "factor-combinations",
        [
            "combination-sum"
        ],
        [
            "Backtracking"
        ]
    ],
    "Given an array of numbers, verify whether it is the correct preorder traversal sequence of a binary search tree.": [
        "verify-preorder-sequence-in-binary-search-tree",
        [
            "binary-tree-preorder-traversal"
        ],
        [
            "Stack",
            "Tree"
        ]
    ],
    "Given an array of n integers nums and an integer\u00a0target, find the number of index triplets i, j, k with 0 <= i < j < k < n that satisfy the condition nums[i] + nums[j] + nums[k] < target.": [
        "3sum-smaller",
        [
            "two-sum-less-than-k",
            "valid-triangle-number",
            "3sum-closest",
            "3sum"
        ],
        [
            "Array",
            "Two Pointers"
        ]
    ],
    "Given n nodes labeled from 0 to n-1 and a list of undirected edges (each edge is a pair of nodes), write a function to check whether these edges make up a valid tree.": [
        "graph-valid-tree",
        [
            "number-of-connected-components-in-an-undirected-graph",
            "course-schedule"
        ],
        [
            "Depth-first Search",
            "Breadth-first Search",
            "Union Find",
            "Graph"
        ]
    ],
    "Given a string s, return all the palindromic permutations (without duplicates) of it. Return an empty list if no palindromic permutation could be form.": [
        "palindrome-permutation-ii",
        [
            "palindrome-permutation",
            "permutations-ii",
            "next-permutation"
        ],
        [
            "Backtracking"
        ]
    ],
    "Design an algorithm to encode a list of strings to a string. The encoded string is then sent over the network and is decoded back to the original list of strings.Machine 1 (sender) has the function:string encode(vector<string> strs) {      // ... your code      return encoded_string;    }    Machine 2 (receiver) has the function:        vector<string> decode(string s) {      //... your code      return strs;    }    So Machine 1 does:string encoded_string = encode(strs);    and Machine 2 does:vector<string> strs2 = decode(encoded_string);    strs2 in Machine 2 should be the same as strs in Machine 1.Implement the encode and decode methods.\u00a0": [
        "encode-and-decode-strings",
        [
            "count-binary-substrings",
            "string-compression",
            "serialize-and-deserialize-binary-tree",
            "count-and-say"
        ],
        [
            "String"
        ]
    ],
    "": [
        "search-in-rotated-sorted-array-ii",
        [
            "search-in-rotated-sorted-array"
        ],
        [
            "Array",
            "Binary Search"
        ]
    ],
    "Given an unsorted array nums, reorder it in-place such that nums[0] <= nums[1] >= nums[2] <= nums[3]....": [
        "wiggle-sort",
        [
            "wiggle-sort-ii",
            "sort-colors"
        ],
        [
            "Array",
            "Sort"
        ]
    ],
    "Given two 1d vectors, implement an iterator to return their elements alternately.\u00a0": [
        "zigzag-iterator",
        [
            "flatten-nested-list-iterator",
            "peeking-iterator",
            "flatten-2d-vector",
            "binary-search-tree-iterator"
        ],
        [
            "Design"
        ]
    ],
    "Given a binary search tree and a node in it, find the in-order successor of that node in the BST.The successor of a node\u00a0p\u00a0is the node with the smallest key greater than\u00a0p.val.\u00a0": [
        "inorder-successor-in-bst",
        [
            "inorder-successor-in-bst-ii",
            "binary-search-tree-iterator",
            "binary-tree-inorder-traversal"
        ],
        [
            "Tree"
        ]
    ],
    "You are given a m x n 2D grid initialized with these three possible values.-1 - A wall or an obstacle.0 - A gate.INF - Infinity means an empty room. We use the value 231 - 1 = 2147483647 to represent INF as you may assume that the distance to a gate is less than 2147483647.Fill each empty room with the distance to its nearest gate. If it is impossible to reach a gate, it should be filled with INF.": [
        "walls-and-gates",
        [
            "rotting-oranges",
            "robot-room-cleaner",
            "shortest-distance-from-all-buildings",
            "number-of-islands",
            "surrounded-regions"
        ],
        [
            "Breadth-first Search"
        ]
    ],
    "An abbreviation of a word follows the form <first letter><number><last letter>. Below are some examples of word abbreviations:a) it                      --> it    (no abbreviation)             1         \u2193    b) d|o|g                   --> d1g                      1    1  1         1---5----0----5--8         \u2193   \u2193    \u2193    \u2193  \u2193        c) i|nternationalizatio|n  --> i18n                      1         1---5----0    \u00a0    \u2193   \u2193    \u2193    d) l|ocalizatio|n          --> l10n        Additionally for any string s of size less than or equal to 2 their abbreviation is the same string s.    Find whether its abbreviation is unique in the dictionary. A word's abbreviation is called unique if any of the following conditions is met:There is no word in dictionary\u00a0such that their abbreviation is equal to the abbreviation of word.Else, for all words in dictionary such that their abbreviation is equal to the abbreviation of word\u00a0those words are equal to word.\u00a0": [
        "unique-word-abbreviation",
        [
            "generalized-abbreviation",
            "two-sum-iii-data-structure-design"
        ],
        [
            "Hash Table",
            "Design"
        ]
    ],
    "You are playing the following Flip Game with your friend: Given a string that contains only these two characters: + and -, you and your friend take turns to flip two consecutive \"++\" into \"--\". The game ends when a person can no longer make a move and therefore the other person will be the winner.Write a function to determine if the starting player can guarantee a win.": [
        "flip-game-ii",
        [
            "can-i-win",
            "guess-number-higher-or-lower-ii",
            "flip-game",
            "nim-game"
        ],
        [
            "Backtracking",
            "Minimax"
        ]
    ],
    "Given a binary tree, find the length of the longest consecutive sequence path.The path refers to any sequence of nodes from some starting node to any node in the tree along the parent-child connections. The longest consecutive path need to be from parent to child (cannot be the reverse).": [
        "binary-tree-longest-consecutive-sequence",
        [
            "binary-tree-longest-consecutive-sequence-ii",
            "longest-consecutive-sequence"
        ],
        [
            "Tree"
        ]
    ],
    "Given two sparse matrices A and B, return the result of AB.": [
        "sparse-matrix-multiplication",
        [],
        [
            "Hash Table"
        ]
    ],
    "Given a binary tree, return the vertical order traversal of its nodes' values. (ie, from top to bottom, column by column).If two nodes are in the same row and column, the order should be from left to right.": [
        "binary-tree-vertical-order-traversal",
        [
            "binary-tree-level-order-traversal"
        ],
        [
            "Depth-first Search",
            "Breadth-first Search"
        ]
    ],
    "Write a function to generate the generalized abbreviations of a word.\u00a0": [
        "generalized-abbreviation",
        [
            "minimum-unique-word-abbreviation",
            "unique-word-abbreviation",
            "subsets"
        ],
        [
            "Backtracking",
            "Bit Manipulation"
        ]
    ],
    "Given n nodes labeled from 0 to n - 1 and a list of undirected edges (each edge is a pair of nodes), write a function to find the number of connected components in an undirected graph.": [
        "number-of-connected-components-in-an-undirected-graph",
        [
            "friend-circles",
            "graph-valid-tree",
            "number-of-islands"
        ],
        [
            "Depth-first Search",
            "Breadth-first Search",
            "Union Find",
            "Graph"
        ]
    ],
    "Given an array nums and a target value k, find the maximum length of a subarray that sums to k. If there isn't one, return 0 instead.": [
        "maximum-size-subarray-sum-equals-k",
        [
            "subarray-product-less-than-k",
            "contiguous-array",
            "range-sum-query-immutable",
            "minimum-size-subarray-sum"
        ],
        [
            "Hash Table"
        ]
    ],
    "Given a binary tree, find the largest subtree which is a Binary Search Tree (BST), where largest means subtree with largest number of nodes in it.": [
        "largest-bst-subtree",
        [],
        [
            "Tree"
        ]
    ],
    "Design a Tic-tac-toe game that is played between two players on a n x n grid.": [
        "design-tic-tac-toe",
        [
            "valid-tic-tac-toe-state"
        ],
        [
            "Design"
        ]
    ],
    "Given an Android 3x3 key lock screen and two integers m and n, where 1 \u2264 m \u2264 n \u2264 9, count the total number of unlock patterns of the Android lock screen, which consist of minimum of m keys and maximum n keys.\u00a0Rules for a valid pattern:Each pattern must connect at least m keys and at most n keys.All the keys must be distinct.If the line connecting two consecutive keys in the pattern passes through any other keys, the other keys must have previously selected in the pattern. No jumps through non selected key is allowed.The order of keys used matters.\u00a0\u00a0Explanation:| 1 | 2 | 3 |    | 4 | 5 | 6 |    | 7 | 8 | 9 |Invalid move: 4 - 1 - 3 - 6     Line 1 - 3 passes through key 2 which had not been selected in the pattern.Invalid move: 4 - 1 - 9 - 2    Line 1 - 9 passes through key 5 which had not been selected in the pattern.Valid move: 2 - 4 - 1 - 3 - 6    Line 1 - 3 is valid because it passes through key 2, which had been selected in the patternValid move: 6 - 5 - 4 - 1 - 9 - 2    Line 1 - 9 is valid because it passes through key 5, which had been selected in the pattern.\u00a0": [
        "android-unlock-patterns",
        [],
        [
            "Dynamic Programming",
            "Backtracking"
        ]
    ],
    "Design a Snake game that is played on a device with screen size = width x height. Play the game online if you are not familiar with the game.The snake is initially positioned at the top left corner (0,0) with length = 1 unit.You are given a list of food's positions in row-column order. When a snake eats the food, its length and the game's score both increase by 1.Each food appears one by one on the screen. ": [
        "design-snake-game",
        [],
        [
            "Design",
            "Queue"
        ]
    ],
    "Given n points on a 2D plane, find if there is such a line parallel to y-axis that reflect the given points symmetrically, in other words, answer whether or not if there exists a line that after reflecting all points over the given line the set of the original points is the same that the reflected ones.": [
        "line-reflection",
        [
            "number-of-boomerangs",
            "max-points-on-a-line"
        ],
        [
            "Hash Table",
            "Math"
        ]
    ],
    "Given a sorted array of integers nums and integer values a, b and c. Apply a quadratic function of the form f(x) = ax2 + bx + c to each element x in the array.The returned array must be in sorted order.Expected time complexity: O(n)": [
        "sort-transformed-array",
        [
            "squares-of-a-sorted-array"
        ],
        [
            "Math",
            "Two Pointers",
            "Sort"
        ]
    ],
    "Given a 2D grid, each cell is either a wall 'W', an enemy 'E' or empty '0' (the number zero), return the maximum enemies you can kill using one bomb.    The bomb kills all the enemies in the same row and column from the planted point until it hits the wall since the wall is too strong to be destroyed.": [
        "bomb-enemy",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Design a hit counter which counts the number of hits received in the past 5 minutes.Each function accepts a timestamp parameter (in seconds granularity) and you may assume that calls are being made to the system in chronological order (ie, the timestamp is monotonically increasing). ": [
        "design-hit-counter",
        [
            "logger-rate-limiter"
        ],
        [
            "Design"
        ]
    ],
    "Given a nested list of integers, return the sum of all integers in the list weighted by their depth.Each element is either an integer, or a list -- whose elements may also be integers or other lists.Different from the previous question where weight is increasing from root to leaf, now the weight is defined from bottom up. i.e., the leaf level integers have weight 1, and the root level integers have the largest weight.": [
        "nested-list-weight-sum-ii",
        [
            "array-nesting",
            "nested-list-weight-sum"
        ],
        [
            "Depth-first Search"
        ]
    ],
    "Given a binary tree, collect a tree's nodes as if you were doing this: Collect and remove all leaves, repeat until the tree is empty.\u00a0": [
        "find-leaves-of-binary-tree",
        [],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given a non-negative integer represented as non-empty a singly linked list of digits, plus one to the integer.": [
        "plus-one-linked-list",
        [
            "plus-one"
        ],
        [
            "Linked List"
        ]
    ],
    "Assume you have an array of length n initialized with all 0's and are given k update operations.Each operation is represented as a triplet: [startIndex, endIndex, inc] which increments each element of subarray A[startIndex ... endIndex] (startIndex and endIndex inclusive) with inc.Return the modified array after all k operations were executed.": [
        "range-addition",
        [
            "range-addition-ii"
        ],
        [
            "Array"
        ]
    ],
    "Design a Phone Directory which supports the following operations:\u00a0get: Provide a number which is not assigned to anyone.check: Check if a number is available or not.release: Recycle or release a number.\u00a0": [
        "design-phone-directory",
        [],
        [
            "Linked List",
            "Design"
        ]
    ],
    "Given a rows x cols screen and a sentence represented by a list of non-empty words, find how many times the given sentence can be fitted on the screen.": [
        "sentence-screen-fitting",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Convert a Binary Search Tree\u00a0to a sorted Circular Doubly-Linked List\u00a0in place.You can think of the left and right pointers as synonymous to the predecessor and successor pointers in a doubly-linked list. For a circular doubly linked list, the predecessor of the first element is the last element, and the successor of the last element is the first element.We want to do the transformation in place. After the transformation, the left pointer of the tree node should point to its predecessor, and the right pointer should point to its successor. You should return the pointer to the smallest element of the linked list.\u00a0": [
        "convert-binary-search-tree-to-sorted-doubly-linked-list",
        [
            "binary-tree-inorder-traversal"
        ],
        [
            "Linked List",
            "Divide and Conquer",
            "Tree"
        ]
    ],
    "Given a string representing arbitrarily nested ternary expressions, calculate the result of the expression. You can always assume that the given expression is valid and only consists of digits 0-9, ?, :, T and F (T and F represent True and False respectively).": [
        "ternary-expression-parser",
        [
            "parse-lisp-expression",
            "remove-comments",
            "mini-parser"
        ],
        [
            "Stack",
            "Depth-first Search"
        ]
    ],
    "Check whether the original sequence org can be uniquely reconstructed from the sequences in seqs. The org sequence is a permutation of the integers from 1 to n, with 1 \u2264 n \u2264 104. Reconstruction means building a shortest common supersequence of the sequences in seqs (i.e., a shortest sequence so that all sequences in seqs are subsequences of it). Determine whether there is only one sequence that can be reconstructed from seqs and it is the org sequence.\u00a0": [
        "sequence-reconstruction",
        [
            "course-schedule-ii"
        ],
        [
            "Graph",
            "Topological Sort"
        ]
    ],
    "Given a list of points that form a polygon when joined sequentially, find if this polygon is convex (Convex polygon definition).\u00a0": [
        "convex-polygon",
        [],
        [
            "Math"
        ]
    ],
    "    By now, you are given a secret signature consisting of character 'D' and 'I'. 'D' represents a decreasing relationship between two numbers, 'I' represents an increasing relationship between two numbers. And our secret signature was constructed by a special integer array, which contains uniquely all the different number from 1 to n (n is the length of the secret signature plus 1). ": [
        "find-permutation",
        [],
        [
            "Greedy"
        ]
    ],
    "    Given a binary array, find the maximum number of consecutive 1s in this array if you can flip at most one 0.    ": [
        "max-consecutive-ones-ii",
        [
            "max-consecutive-ones-iii",
            "max-consecutive-ones"
        ],
        [
            "Two Pointers"
        ]
    ],
    "There is a ball in a maze with empty spaces (represented as 0) and walls (represented as 1). The ball can go through the empty spaces by rolling up, down, left or right, but it won't stop rolling until hitting a wall. When the ball stops, it could choose the next direction.Given the maze, the ball's start position and\u00a0the destination, where start = [startrow, startcol] and destination\u00a0= [destinationrow, destinationcol], return true if the ball can stop at the destination, otherwise return false.": [
        "the-maze",
        [
            "the-maze-ii",
            "the-maze-iii"
        ],
        [
            "Depth-first Search",
            "Breadth-first Search"
        ]
    ],
    "There is a ball in a maze with empty spaces and walls. The ball can go through empty spaces by rolling up, down, left or right, but it won't stop rolling until hitting a wall. When the ball stops, it could choose the next direction.Given the ball's start position, the destination and the maze, find the shortest distance for the ball to stop at the destination. The distance is defined by the number of empty spaces traveled by the ball from the start position (excluded) to the destination (included). If the ball cannot stop at the destination, return -1.The maze is represented by a binary 2D array. 1 means the wall and 0 means the empty space. ": [
        "the-maze-ii",
        [
            "the-maze-iii",
            "the-maze"
        ],
        [
            "Depth-first Search",
            "Breadth-first Search"
        ]
    ],
    "Given a node in a binary search tree, find\u00a0the in-order successor of that node in the BST.If that node has no in-order successor, return\u00a0null.The successor of a node\u00a0is the node with the smallest key greater than node.val.You will have direct access to the node but not to the root of the tree. Each node will have a reference to its parent node.\u00a0Below is the definition for Node:class Node {        public int val;        public Node left;        public Node right;        public Node parent;    }    \u00a0": [
        "inorder-successor-in-bst-ii",
        [
            "inorder-successor-in-bst"
        ],
        [
            "Tree"
        ]
    ],
    "Given a picture consisting of black and white pixels, find the number of black lonely pixels.The picture is represented by a 2D char array consisting of 'B' and 'W', which means black and white pixels respectively. A black lonely pixel is character 'B' that located at a specific position where the same row and same column don't have any other black pixels.": [
        "lonely-pixel-i",
        [
            "lonely-pixel-ii"
        ],
        [
            "Array",
            "Depth-first Search"
        ]
    ],
    "Given a picture consisting of black and white pixels, and a positive integer N, find the number of black pixels located at some specific row R and column C that align with all the following rules: Row R and column C both contain exactly N black pixels. For all rows that have a black pixel at column C, they should be exactly the same as row RThe picture is represented by a 2D char array consisting of 'B' and 'W', which means black and white pixels respectively. ": [
        "lonely-pixel-ii",
        [
            "lonely-pixel-i"
        ],
        [
            "Array"
        ]
    ],
    "You need to construct a binary tree from a string consisting of parenthesis and integers.The whole input represents a binary tree. It contains an integer followed by zero, one or two pairs of parenthesis. The integer represents the root's value and a pair of parenthesis contains a child binary tree with the same structure.You always start to construct the left child node of the parent first if it exists.\u00a0": [
        "construct-binary-tree-from-string",
        [
            "construct-string-from-binary-tree"
        ],
        [
            "String",
            "Tree"
        ]
    ],
    "    During the NBA playoffs, we always arrange the rather strong team to play with the rather weak team, like make the rank 1 team play with the rank nth team, which is a good strategy to make the contest more interesting. Now, you're given n teams, you need to output their final contest matches in the form of a string.    The n teams are given in the form of positive integers from 1 to n, which represents their initial rank. (Rank 1 is the strongest team and Rank n is the weakest team.) We'll use parentheses('(', ')') and commas(',') to represent the contest team pairing - parentheses('(' , ')') for pairing and commas(',') for partition. During the pairing process in each round, you always need to follow the strategy of making the rather strong one pair with the rather weak one.": [
        "output-contest-matches",
        [],
        [
            "String",
            "Recursion"
        ]
    ],
    "Given a binary tree, return the values of its boundary in anti-clockwise direction starting from root. Boundary includes left boundary, leaves, and right boundary in order without duplicate nodes.\u00a0 (The values of the nodes may still be duplicates.)Left boundary is defined as the path from root to the left-most node. Right boundary is defined as the path from root to the right-most node. If the root doesn't have left subtree or right subtree, then the root itself is left boundary or right boundary. Note this definition only applies to the input binary tree, and not applies to any subtrees.The left-most node is defined as a leaf node you could reach when you always firstly travel to the left subtree if exists. If not, travel to the right subtree. Repeat until you reach a leaf node.The right-most node is also defined by the same way with left and right exchanged.": [
        "boundary-of-binary-tree",
        [
            "binary-tree-right-side-view"
        ],
        [
            "Tree"
        ]
    ],
    "    Given an array with n integers, you need to find if there are triplets  (i, j, k) which satisfies following conditions:     0 < i, i + 1 < j, j + 1 < k < n - 1  Sum of subarrays (0, i - 1), (i + 1, j - 1), (j + 1, k - 1) and (k + 1, n - 1) should be equal.     where we define that subarray (L, R) represents a slice of the original array starting from the element indexed L to the element indexed R.    ": [
        "split-array-with-equal-sum",
        [
            "number-of-ways-to-split-a-string"
        ],
        [
            "Array"
        ]
    ],
    "Given a binary tree, you need to find the length of Longest Consecutive Path in Binary Tree.Especially, this path can be either increasing or decreasing. ": [
        "binary-tree-longest-consecutive-sequence-ii",
        [
            "binary-tree-longest-consecutive-sequence"
        ],
        [
            "Tree"
        ]
    ],
    "Given a list of strings, you could concatenate these strings together into a loop, where for each string you could choose to reverse it or not. Among all the possible loops, you need to find the lexicographically biggest string after cutting the loop, which will make the looped string into a regular one.Specifically, to find the lexicographically biggest string, you need to experience two phases:     Concatenate all the strings into a loop, where you can reverse some strings or not and connect them in the same order as given.Cut and make one breakpoint in any place of the loop, which will make the looped string into a regular one starting from the character at the cutpoint. And your job is to find the lexicographically biggest one among all the possible regular strings.": [
        "split-concatenated-strings",
        [],
        [
            "String"
        ]
    ],
    "Given a 01 matrix M, find the longest line of consecutive one in the matrix. The line could be horizontal, vertical, diagonal or anti-diagonal.    ": [
        "longest-line-of-consecutive-one-in-matrix",
        [],
        [
            "Array"
        ]
    ],
    "There's a tree, a squirrel, and several nuts. Positions are represented by the cells in a 2D grid. Your goal is to find the minimal distance for the squirrel to collect all the nuts and put them under the tree one by one. The squirrel can only take at most one nut at one time and can move in four directions - up, down, left and right, to the adjacent cell. The distance is represented by the number of moves.    ": [
        "squirrel-simulation",
        [],
        [
            "Math"
        ]
    ],
    "Given n processes, each process has a unique PID (process id) and its PPID (parent process id). Each process only has one parent process, but may have one or more children processes. This is just like a tree structure.  Only one process has PPID that is 0, which means this process has no parent process. All the PIDs will be distinct positive integers.We use two list of integers to represent a list of processes, where the first list contains PID for each process and the second list contains the corresponding PPID. Now given the two lists, and a PID representing a process you want to kill, return a list of PIDs of processes that will be killed in the end. You should assume that when a process is killed, all its children processes will be killed. No order is required for the final answer.": [
        "kill-process",
        [],
        [
            "Tree",
            "Queue"
        ]
    ],
    "Given a string s and a list of strings dict, you need to add a closed pair of bold tag <b> and </b> to wrap the substrings in s that exist in dict. If two such substrings overlap, you need to wrap them together by only one pair of closed bold tag. Also, if two substrings wrapped by bold tags are consecutive, you need to combine them.    ": [
        "add-bold-tag-in-string",
        [
            "tag-validator",
            "merge-intervals"
        ],
        [
            "String"
        ]
    ],
    "Given a positive integer a, find the smallest positive integer b whose multiplication of each digit equals to a.     If there is no answer or the answer is not fit in 32-bit signed integer, then return 0.": [
        "minimum-factorization",
        [],
        [
            "Math",
            "Recursion"
        ]
    ],
    "    In combinatorial mathematics, a derangement is a permutation of the elements of a set, such that no element appears in its original position.        There's originally an array consisting of n integers from 1 to n in ascending order, you need to find the number of derangement it can generate.        Also, since the answer may be very large, you should return the output mod 109 + 7.    ": [
        "find-the-derangement-of-an-array",
        [],
        [
            "Math"
        ]
    ],
    "You are given several logs that each log contains a unique id and timestamp. Timestamp is a string that has the following format: Year:Month:Day:Hour:Minute:Second, for example, 2017:01:01:23:59:59. All domains are zero-padded decimal numbers. Design a log storage system to implement the following functions:void Put(int id, string timestamp): Given a log's unique id and timestamp, store the log in your storage system.int[] Retrieve(String start, String end, String granularity): Return the id of logs whose timestamps are within the range from start to end. Start and end all have the same format as timestamp. However, granularity means the time level for consideration. ": [
        "design-log-storage-system",
        [
            "design-in-memory-file-system"
        ],
        [
            "String",
            "Design"
        ]
    ],
    "Imagine you have a special keyboard with the following keys: Key 1: (A):  Print one 'A' on screen.Key 2: (Ctrl-A): Select the whole screen.Key 3: (Ctrl-C): Copy selection to buffer.Key 4: (Ctrl-V): Print buffer on screen appending it after what has already been printed. Now, you can only press the keyboard for N times (with the above four keys), find out the maximum numbers of 'A' you can print on screen.": [
        "4-keys-keyboard",
        [
            "2-keys-keyboard"
        ],
        [
            "Math",
            "Dynamic Programming",
            "Greedy"
        ]
    ],
    "    Given a binary tree with n nodes, your task is to check if it's possible to partition the tree to two trees which have the equal sum of values after removing exactly one edge on the original tree.    ": [
        "equal-tree-partition",
        [],
        [
            "Tree"
        ]
    ],
    "If the depth of a tree is smaller than 5, then this tree can be represented by a list of three-digits integers.For each integer in this list:The hundreds digit represents the depth D of this node, 1 <= D <= 4.The tens digit represents the position P of this node in the level it belongs to, 1 <= P <= 8. The position is the same as that in a full binary tree.The units digit represents the value V of this node, 0 <= V <= 9.Given a list of ascending three-digits integers representing a binary tree with the depth smaller than 5, you need to return the sum of all paths from the root towards the leaves.It's guaranteed that the given list represents a valid connected binary tree.": [
        "path-sum-iv",
        [
            "path-sum-iii",
            "binary-tree-maximum-path-sum",
            "path-sum-ii",
            "path-sum"
        ],
        [
            "Tree"
        ]
    ],
    "Given a time represented in the format \"HH:MM\", form the next closest time by reusing the current digits. There is no limit on how many times a digit can be reused.": [
        "next-closest-time",
        [],
        [
            "String"
        ]
    ],
    "Given a non-empty 2D array grid of 0's and 1's, an island is a group of 1's (representing land) connected 4-directionally (horizontal or vertical.)  ": [
        "number-of-distinct-islands-ii",
        [
            "number-of-distinct-islands"
        ],
        [
            "Hash Table",
            "Depth-first Search"
        ]
    ],
    "Given an\u00a0integer array sorted in ascending order, write a function to search target in nums.\u00a0 If target exists, then return its index, otherwise return -1. However, the array size is unknown to you. You may only access the array using an ArrayReader\u00a0interface, where\u00a0ArrayReader.get(k) returns the element of the array at index k\u00a0(0-indexed).": [
        "search-in-a-sorted-array-of-unknown-size",
        [
            "find-the-index-of-the-large-integer",
            "binary-search"
        ],
        [
            "Binary Search"
        ]
    ],
    "Given a node from a Circular Linked List which is sorted in ascending order,\u00a0write a function to insert a value\u00a0insertVal into the list such that it remains a\u00a0sorted circular list. The given node can be a reference to any single node in the list, and may not be necessarily the smallest value in the circular\u00a0list.If there are multiple suitable places for insertion, you may choose any place to insert the new value. After the insertion, the circular list should remain sorted.If the list is empty (i.e., given node is null), you should create a new single circular list and return the reference to that single node. Otherwise, you should return the original given node.\u00a0": [
        "insert-into-a-sorted-circular-linked-list",
        [
            "insertion-sort-list"
        ],
        [
            "Linked List"
        ]
    ],
    "This question is about implementing a basic elimination algorithm for Candy Crush.Given a 2D integer array board representing the grid of candy, different positive integers board[i][j] represent different types of candies. A value of board[i][j] = 0 represents that the cell at position (i, j) is empty. The given board represents the state of the game following the player's move. Now, you need to restore the board to a stable state by crushing candies according to the following rules:If three or more candies of the same type are adjacent vertically or horizontally, \"crush\" them all at the same time - these positions become empty.After crushing all candies simultaneously, if an empty space on the board has candies on top of itself, then these candies will drop until they hit a candy or bottom at the same time. (No new candies will drop outside the top boundary.)After the above steps, there may exist more candies that can be crushed. If so, you need to repeat the above steps.If there does not exist more candies that can be crushed (ie. the board is stable), then return the current board.You need to perform the above rules until the board becomes stable, then return the current board.\u00a0": [
        "candy-crush",
        [],
        [
            "Array",
            "Two Pointers"
        ]
    ],
    "Given two sentences words1, words2 (each represented as an array of strings), and a list of similar word pairs pairs, determine if two sentences are similar.": [
        "sentence-similarity-ii",
        [
            "sentence-similarity",
            "accounts-merge",
            "friend-circles"
        ],
        [
            "Depth-first Search"
        ]
    ],
    "Given a binary tree where every node has a unique value, and a target key k, find the value of the nearest leaf node to target k in the tree.Here, nearest to a leaf means the least number of edges travelled on the binary tree to reach any leaf of the tree.  Also, a node is called a leaf if it has no children.In the following examples, the input tree is represented in flattened form row by row.The actual root tree given will be a TreeNode object.": [
        "closest-leaf-in-a-binary-tree",
        [],
        [
            "Tree"
        ]
    ],
    "Given a grid where each entry is only 0 or 1, find the number of corner rectangles.A corner rectangle is 4 distinct 1s on the grid that form an axis-aligned rectangle. ": [
        "number-of-corner-rectangles",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "    Given a start IP address ip and a number of ips we need to cover n, return a representation of the range as a list (of smallest possible length) of CIDR blocks.        A CIDR block is a string consisting of an IP, followed by a slash, and then the prefix length.  ": [
        "ip-to-cidr",
        [
            "validate-ip-address",
            "restore-ip-addresses"
        ],
        [
            "Bit Manipulation"
        ]
    ],
    "    We are given an elevation map, heights[i] representing the height of the terrain at that index.  The width at each index is 1.  After V units of water fall at index K, how much water is at each index?        Water first drops at index K and rests on top of the highest terrain or water at that index.  Then, it flows according to the following rules:    If the droplet would eventually fall by moving left, then move left.Otherwise, if the droplet would eventually fall by moving right, then move right.Otherwise, rise at it's current position.    Here, \"eventually fall\" means that the droplet will eventually be at a lower level if it moves in that direction.    Also, \"level\" means the height of the terrain plus any water in that column.        We can assume there's infinitely high terrain on the two sides out of bounds of the array.  Also, there could not be partial water being spread out evenly on more than 1 grid block - each unit of water has to be in exactly one block.    ": [
        "pour-water",
        [
            "trapping-rain-water"
        ],
        [
            "Array"
        ]
    ],
    "Given a Binary Search Tree (BST) with root node root, and a target value V, split the tree into two subtrees\u00a0where one subtree has nodes that are all smaller or equal to the target value, while the other subtree has all nodes that are greater than the target value.\u00a0 It's not necessarily the case that the tree contains a node with value V.Additionally, most of the structure of the original tree should remain.\u00a0 ": [
        "split-bst",
        [
            "delete-node-in-a-bst"
        ],
        [
            "Tree",
            "Recursion"
        ]
    ],
    "From any string, we can form a subsequence of that string by deleting some number of characters (possibly no deletions).Given two strings source and target, return the minimum number of subsequences of source such that their concatenation equals target. If the task is impossible, return -1.\u00a0": [
        "shortest-way-to-form-string",
        [
            "number-of-matching-subsequences",
            "is-subsequence"
        ],
        [
            "Dynamic Programming",
            "Greedy"
        ]
    ],
    "On a campus represented as a 2D grid, there are N workers and M bikes, with N <= M. Each worker and bike is a 2D coordinate on this grid.Our goal is to assign a bike to each worker. Among the available bikes and workers, we choose the (worker, bike) pair with the shortest Manhattan distance between each other, and assign the bike to that worker. (If there are multiple (worker, bike) pairs with the same shortest Manhattan distance, we choose the pair with the smallest worker index; if there are multiple ways to do that, we choose the pair with the smallest bike index). We repeat this process until there are no available workers.The Manhattan distance between two points p1 and p2 is Manhattan(p1, p2) = |p1.x - p2.x| + |p1.y - p2.y|.Return a vector ans of length N, where ans[i] is the index (0-indexed) of the bike that the i-th worker is assigned to.\u00a0": [
        "campus-bikes",
        [
            "campus-bikes-ii"
        ],
        [
            "Greedy",
            "Sort"
        ]
    ],
    "Given an array of prices [p1,p2...,pn] and a target, round each price pi to Roundi(pi) so that the rounded array [Round1(p1),Round2(p2)...,Roundn(pn)] sums to the given target. Each operation Roundi(pi) could be either Floor(pi) or Ceil(pi).Return the string \"-1\" if the rounded array is impossible to sum to target. Otherwise, return the smallest rounding error, which is defined as \u03a3 |Roundi(pi) - (pi)| for i from 1 to n, as a string with three places after the decimal.\u00a0": [
        "minimize-rounding-error-to-meet-target",
        [],
        [
            "Math",
            "Dynamic Programming",
            "Greedy"
        ]
    ],
    "Given the edges of a directed graph where edges[i] = [ai, bi] indicates there is an edge between nodes ai and bi, and two nodes source and destination of this graph, determine whether or not all paths starting from source eventually, end at destination, that is:At least one path exists from the source node to the destination nodeIf a path exists from the source node to a node with no outgoing edges, then that node is equal to destination.The number of possible paths from source to destination is a finite number.Return true if and only if all roads from source lead to destination.\u00a0": [
        "all-paths-from-source-lead-to-destination",
        [],
        [
            "Depth-first Search",
            "Graph"
        ]
    ],
    "Given a sorted array A of unique numbers, find the K-th missing number starting from the leftmost number of the array.\u00a0": [
        "missing-element-in-sorted-array",
        [],
        [
            "Binary Search"
        ]
    ],
    "Given strings A and B of the same length, we say A[i] and B[i] are equivalent characters. ": [
        "lexicographically-smallest-equivalent-string",
        [],
        [
            "Depth-first Search",
            "Union Find"
        ]
    ],
    "Given a string S, find out the length of the longest repeating substring(s). Return 0 if no repeating substring exists.\u00a0": [
        "longest-repeating-substring",
        [],
        [
            "String"
        ]
    ],
    "On a campus represented as a 2D grid, there are N workers and M bikes, with N <= M. Each worker and bike is a 2D coordinate on this grid.We assign one unique bike to each worker so that the sum of the Manhattan distances between each worker and their assigned bike is minimized.The Manhattan distance between two points p1 and p2 is Manhattan(p1, p2) = |p1.x - p2.x| + |p1.y - p2.y|.Return the minimum possible sum of Manhattan distances between each worker and their assigned bike.\u00a0": [
        "campus-bikes-ii",
        [
            "campus-bikes"
        ],
        [
            "Dynamic Programming",
            "Backtracking"
        ]
    ],
    "A string S\u00a0represents a list of words.Each letter in the word has 1 or more options.\u00a0 If there is one option, the letter is represented as is.\u00a0 If there is more than one option, then curly braces delimit the options.\u00a0 ": [
        "brace-expansion",
        [
            "brace-expansion-ii",
            "letter-case-permutation",
            "decode-string"
        ],
        [
            "Backtracking"
        ]
    ],
    "Given a string S, return the number of substrings of length K with no repeated characters.\u00a0": [
        "find-k-length-substrings-with-no-repeated-characters",
        [],
        [
            "String",
            "Sliding Window"
        ]
    ],
    "In a social group, there are N people, with unique integer ids from 0 to N-1.We have a list of logs, where each logs[i] = [timestamp, id_A, id_B] contains a non-negative\u00a0integer timestamp, and the ids of two different people.Each log represents the time in which two different people became friends. \u00a0Friendship is symmetric: if A is friends with B, then B is friends with A.Let's say that person A is acquainted with person B if A is friends with B, or A is a friend of someone acquainted with B.Return the earliest time for which every person became acquainted with every other person. Return -1 if there is no\u00a0such\u00a0earliest time.\u00a0": [
        "the-earliest-moment-when-everyone-become-friends",
        [
            "friend-circles"
        ],
        [
            "Union Find"
        ]
    ],
    "Given a\u00a0matrix of integers A\u00a0with\u00a0R\u00a0rows and C\u00a0columns, find\u00a0the maximum\u00a0score\u00a0of a path starting at\u00a0[0,0]\u00a0and ending at [R-1,C-1].The score of a path is the minimum value in that path.\u00a0 ": [
        "path-with-maximum-minimum-value",
        [],
        [
            "Depth-first Search",
            "Union Find",
            "Graph"
        ]
    ],
    "Given the root of a binary tree, find the maximum average value of any subtree of that tree.(A subtree of a tree is any node of that tree plus all its descendants. The average value of a tree is the sum of its values, divided by the number of nodes.)\u00a0": [
        "maximum-average-subtree",
        [],
        [
            "Tree"
        ]
    ],
    "There are N cities numbered from 1 to N.You are given connections, where each connections[i] = [city1, city2, cost]\u00a0represents the cost to connect city1 and city2 together.\u00a0 (A connection is bidirectional: connecting city1 and city2 is the same as connecting city2 and city1.)Return the minimum cost so that for every pair of cities, there exists a path\u00a0of connections (possibly of length 1) that connects those two cities together.\u00a0 The cost is the sum of the connection costs used. If the task is impossible, return -1.\u00a0": [
        "connecting-cities-with-minimum-cost",
        [],
        [
            "Union Find",
            "Graph"
        ]
    ],
    "Given a\u00a0binary array data, return\u00a0the minimum number of swaps required to group all 1\u2019s present in the array together in any place in the array.\u00a0": [
        "minimum-swaps-to-group-all-1s-together",
        [],
        [
            "Array",
            "Sliding Window"
        ]
    ],
    "We are given some website visits: the user with name\u00a0username[i] visited the website\u00a0website[i] at time timestamp[i].A 3-sequence\u00a0is a list of\u00a0websites of length 3 sorted in ascending order\u00a0by the time of their visits.\u00a0 (The websites in a 3-sequence are not necessarily distinct.)Find the 3-sequence visited\u00a0by the largest number of users. If there is more than one solution, return the lexicographically smallest such 3-sequence.\u00a0": [
        "analyze-user-website-visit-pattern",
        [],
        [
            "Array",
            "Hash Table",
            "Sort"
        ]
    ],
    "You are asked to design a file system\u00a0which provides two functions:createPath(path, value):\u00a0Creates a new path and associates a value to it if possible and returns True.\u00a0Returns False\u00a0if the path already exists or its parent path doesn't exist.get(path):\u00a0Returns the value associated with a path or returns\u00a0-1\u00a0if the path doesn't exist.The format of a path is\u00a0one or more concatenated strings of the form:\u00a0/ followed by one or more lowercase English letters. ": [
        "design-file-system",
        [],
        [
            "Hash Table",
            "Design"
        ]
    ],
    "You have some\u00a0sticks\u00a0with\u00a0positive integer lengths.You can connect any two sticks of lengths X and Y into one stick\u00a0by paying a cost of X + Y.\u00a0 You perform this action until there is one stick remaining.Return\u00a0the minimum cost of connecting all the given sticks into one stick in this way.\u00a0": [
        "minimum-cost-to-connect-sticks",
        [
            "minimum-cost-to-merge-stones"
        ],
        [
            "Greedy"
        ]
    ],
    "Given a list of phrases, generate a list of\u00a0Before and After puzzles.A phrase is a string that consists of lowercase English letters and spaces only. No space appears in the start or the end of a phrase. There are\u00a0no consecutive spaces\u00a0in a phrase.Before and After\u00a0puzzles are phrases that are formed by merging\u00a0two phrases where the last\u00a0word of the first\u00a0phrase is the same as the first word of the second phrase.Return the\u00a0Before and After\u00a0puzzles that can be formed by every two phrases\u00a0phrases[i]\u00a0and\u00a0phrases[j]\u00a0where\u00a0i != j. ": [
        "before-and-after-puzzle",
        [],
        [
            "String"
        ]
    ],
    "You are given an array colors, in which there are three colors: 1, 2 and\u00a03.You are also given some queries. Each query consists of two integers i\u00a0and c, return\u00a0the shortest distance between the given index\u00a0i and the target color c. If there is no solution return -1.\u00a0": [
        "shortest-distance-to-target-color",
        [],
        [
            "Binary Search"
        ]
    ],
    "In an infinite chess board with coordinates from -infinity\u00a0to +infinity, you have a knight at square\u00a0[0, 0].A\u00a0knight has 8 possible moves it can make, as illustrated below. Each move is two squares in a cardinal direction, then one square in an orthogonal direction.Return the\u00a0minimum number of steps needed to move the knight to the square [x, y].\u00a0 It is guaranteed the answer exists.\u00a0": [
        "minimum-knight-moves",
        [],
        [
            "Breadth-first Search"
        ]
    ],
    "Given a matrix mat\u00a0where every row is sorted in strictly\u00a0increasing order, return\u00a0the smallest common element in all rows.If there is no common element, return\u00a0-1.\u00a0": [
        "find-smallest-common-element-in-all-rows",
        [],
        [
            "Hash Table",
            "Binary Search"
        ]
    ],
    "Given two binary search trees, return True\u00a0if and only if there is a node in the first tree and a node in the second tree whose values\u00a0sum up to a given integer\u00a0target.\u00a0": [
        "two-sum-bsts",
        [
            "two-sum-iv-input-is-a-bst"
        ],
        [
            "Binary Search Tree"
        ]
    ],
    "A Stepping Number is\u00a0an integer\u00a0such that\u00a0all of its adjacent digits have an absolute difference of exactly 1. ": [
        "stepping-numbers",
        [],
        [
            "Backtracking"
        ]
    ],
    "Given the availability time slots arrays\u00a0slots1 and slots2\u00a0of two people and a meeting duration duration, return the earliest time slot that works for both of them and is of duration duration.If there is no common time slot that satisfies the requirements, return an empty array.The format of a time slot is an array of two elements\u00a0[start, end]\u00a0representing an inclusive time range from start\u00a0to end.\u00a0\u00a0It is guaranteed that no two availability slots of the same person intersect with each other. That is, for any two time slots\u00a0[start1, end1]\u00a0and\u00a0[start2, end2]\u00a0of the same person, either\u00a0start1 > end2\u00a0or\u00a0start2 > end1.\u00a0": [
        "meeting-scheduler",
        [],
        [
            "Line Sweep"
        ]
    ],
    "You have some coins.\u00a0 The i-th\u00a0coin has a probability\u00a0prob[i] of facing heads when tossed.Return the probability that the number of coins facing heads equals target if you toss every coin exactly once.\u00a0": [
        "toss-strange-coins",
        [],
        [
            "Math",
            "Dynamic Programming"
        ]
    ],
    "Given a url startUrl and an interface HtmlParser, implement a web\u00a0crawler to crawl all links that are under the\u00a0same hostname as\u00a0startUrl.\u00a0Return\u00a0all urls obtained by your web crawler in any order.Your crawler should:Start from the page: startUrlCall HtmlParser.getUrls(url) to get all urls from a webpage of given url.Do not crawl the same link twice.Explore only the links that are under the same hostname as startUrl.As shown in the example url above, the hostname is example.org. For simplicity sake, you may assume all\u00a0urls use http protocol without any\u00a0port specified. ": [
        "web-crawler",
        [
            "Web Crawler Multithreaded"
        ],
        [
            "Depth-first Search",
            "Breadth-first Search"
        ]
    ],
    "Design a Leaderboard class, which has 3 functions:addScore(playerId, score): Update the leaderboard by adding score to the given player's score. If there is no player with such id in the leaderboard, add him to the leaderboard with the given score.top(K): Return the score sum of the top K players.reset(playerId): Reset the score of the player with the given id\u00a0to 0 (in other words erase it from the leaderboard). It is guaranteed that the player was added to the leaderboard before calling this function.Initially, the leaderboard is empty.\u00a0": [
        "design-a-leaderboard",
        [],
        [
            "Hash Table",
            "Sort",
            "Design"
        ]
    ],
    "Given an undirected tree, return\u00a0its diameter: the number of edges in a longest path in that tree.The tree is given as an array\u00a0of\u00a0edges\u00a0where edges[i] = [u, v] is a bidirectional edge between nodes\u00a0u and v.\u00a0 Each node has\u00a0labels in the set {0, 1, ..., edges.length}.\u00a0": [
        "tree-diameter",
        [],
        [
            "Tree",
            "Depth-first Search",
            "Breadth-first Search"
        ]
    ],
    "Given a non-negative integer num, Return its encoding string.The encoding is done by converting the integer to a string using a secret function that you should deduce from the following table:\u00a0": [
        "encode-number",
        [
            "convert-to-base-2"
        ],
        [
            "Math",
            "Bit Manipulation"
        ]
    ],
    "You are given some lists of regions\u00a0where the first region of each list includes all other regions in that list.Naturally, if a region X\u00a0contains another region Y\u00a0then X\u00a0is bigger than Y. Also by definition a region X contains itself.Given two regions region1, region2, find out the smallest region that contains both of them.If you are given regions r1, r2 and r3 such that r1 includes r3, it is guaranteed there is no r2 such that r2 includes r3.    It's guaranteed the smallest region exists.\u00a0": [
        "smallest-common-region",
        [
            "lowest-common-ancestor-of-a-binary-tree",
            "lowest-common-ancestor-of-a-binary-search-tree"
        ],
        [
            "Tree"
        ]
    ],
    "Given a list of pairs of equivalent words\u00a0synonyms and a sentence text,\u00a0Return all possible synonymous sentences sorted lexicographically.    \u00a0": [
        "synonymous-sentences",
        [],
        [
            "Backtracking"
        ]
    ],
    "You are given an immutable linked list, print out all values of each node in reverse with the help of the following\u00a0interface:ImmutableListNode:\u00a0An interface of immutable linked list, you are given the head of the list.You need to use the following functions to access the linked list (you can't access the ImmutableListNode directly):ImmutableListNode.printValue(): Print value of the current node.ImmutableListNode.getNext(): Return the next node.The input is only given to initialize the linked list internally.\u00a0You must solve this problem without modifying the linked list. In other words, you must operate\u00a0the linked list using only the mentioned\u00a0APIs.\u00a0": [
        "print-immutable-linked-list-in-reverse",
        [],
        []
    ],
    "Given a sorted list of disjoint intervals, each interval intervals[i] = [a, b] represents the set of real numbers\u00a0x such that\u00a0a <= x < b.We remove the intersections between any interval in intervals and the interval toBeRemoved.Return a sorted\u00a0list of intervals after all such removals.\u00a0": [
        "remove-interval",
        [],
        [
            "Math",
            "Line Sweep"
        ]
    ],
    "A tree rooted at node 0 is given as follows:The number of nodes is nodes;The value of the i-th node is value[i];The parent of the i-th node is parent[i].Remove every subtree whose sum of values of nodes is zero.After doing so, return the number of nodes remaining in the tree.\u00a0": [
        "delete-tree-nodes",
        [],
        [
            "Dynamic Programming",
            "Depth-first Search"
        ]
    ],
    "(This problem is an\u00a0interactive problem.)A binary matrix means that all elements are\u00a00\u00a0or\u00a01. For each\u00a0individual row of the matrix, this row\u00a0is sorted in non-decreasing order.Given a row-sorted binary matrix binaryMatrix, return leftmost column index(0-indexed) with at least a\u00a01\u00a0in it. If such\u00a0index\u00a0doesn't exist, return -1.You can't access the Binary Matrix directly.\u00a0 You may only access the matrix using a\u00a0BinaryMatrix\u00a0interface:BinaryMatrix.get(row, col) returns the element of the matrix\u00a0at index (row, col)\u00a0(0-indexed).BinaryMatrix.dimensions()\u00a0returns a list of 2 elements\u00a0[rows, cols], which means the matrix is rows * cols.Submissions making more than 1000\u00a0calls to\u00a0BinaryMatrix.get\u00a0will be judged Wrong Answer.\u00a0 Also, any solutions that attempt to circumvent the judge\u00a0will result in disqualification.For custom testing purposes you're given the binary matrix mat\u00a0as input\u00a0in the following four examples. You will not have\u00a0access the binary matrix directly.\u00a0\u00a0\u00a0": [
        "leftmost-column-with-at-least-a-one",
        [],
        [
            "Array"
        ]
    ],
    "You have a queue of integers, you need to retrieve the first unique integer in the queue.Implement the FirstUnique\u00a0class:FirstUnique(int[] nums) Initializes the object with the numbers in the queue.int showFirstUnique()\u00a0returns the value of the\u00a0first unique integer of the queue, and returns -1 if there is no such integer.void add(int value)\u00a0insert value\u00a0to\u00a0the queue.\u00a0": [
        "first-unique-number",
        [],
        [
            "Hash Table",
            "Design"
        ]
    ],
    "Given a binary tree where each path going from the root to any leaf form a valid sequence, check if a given string\u00a0is a valid sequence in such binary tree.\u00a0We get the given string from the concatenation of an array of integers arr and the concatenation of all\u00a0values of the nodes along a path results in a sequence in the given binary tree.\u00a0": [
        "check-if-a-string-is-a-valid-sequence-from-root-to-leaves-path-in-a-binary-tree",
        [],
        [
            "Tree"
        ]
    ],
    "A binary tree is given such that each node contains an additional random pointer which could point to any node in the tree or null.Return a\u00a0deep copy\u00a0of the tree.": [
        "clone-binary-tree-with-random-pointer",
        [
            "copy-list-with-random-pointer",
            "clone-graph"
        ],
        [
            "Hash Table",
            "Tree",
            "Depth-first Search",
            "Breadth-first Search"
        ]
    ],
    "Given a root\u00a0of an N-ary tree,\u00a0return a\u00a0deep copy\u00a0(clone) of the tree.Each node in the n-ary tree\u00a0contains a val (int) and a list (List[Node]) of its children.class Node {        public int val;        public List<Node> children;    }    Nary-Tree input serialization\u00a0is represented in their level order traversal, each group of children is separated by the null value (See examples).": [
        "clone-n-ary-tree",
        [
            "clone-binary-tree-with-random-pointer",
            "copy-list-with-random-pointer",
            "clone-graph"
        ],
        [
            "Hash Table",
            "Tree"
        ]
    ],
    "\u7ed9\u5b9aN\u5143\u6811\u7684\u6240\u6709\u8282\u70b9\u4e3a\u6570\u7ec4 \u00a0 Node[] tree\u00a0\uff0c\u5176\u4e2d\u6bcf\u4e2a\u8282\u70b9\u90fd\u6709\u4e00\u4e2a\u00a0 \u552f\u4e00\u503c\u3002\u67e5\u627e\u5e76\u8fd4\u56deN\u5143\u6811\u7684\u6839\u3002\u00a0\u8ddf\u8fdb\uff1a\u60a8\u53ef\u4ee5\u4f7f\u7528\u7ebf\u6027\u65f6\u95f4\u7b97\u6cd5\u4ee5\u6052\u5b9a\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u89e3\u51b3\u6b64\u95ee\u9898\u5417\uff1f\u00a0Nary-Tree\u8f93\u5165\u5e8f\u5217\u5316\u4ee5\u5176\u7ea7\u522b\u987a\u5e8f\u904d\u5386\u8868\u793a\uff0c\u6bcf\u7ec4\u5b50\u7ea7\u7531\u7a7a\u503c\u5206\u9694\uff08\u8bf7\u53c2\u89c1\u793a\u4f8b\uff09\u3002\u4f8b\u5982\uff0c\u4e0a\u8ff0\u6811\u88ab\u5e8f\u5217\u5316\u4e3a[1\uff0cnull\uff0c2,3,4,5\uff0cnull\uff0cnull\uff0c6,7\uff0cnull\uff0c8\uff0cnull\uff0c9,10\uff0cnull\uff0cnull\uff0c11\uff0cnull\uff0c12\uff0c null\uff0c13\uff0cnull\uff0cnull\uff0c14]\u3002Custom testing:    You should provide the serialization of the input tree.    The Driver code then extracts the nodes from the tree and shuffles them. You shouldn't\u00a0care how the extracted nodes are shuffled.    The driver code will provide you with an array of the extracted nodes in random order and you need to find the root of the tree out of these nodes.\u00a0": [
        "find-root-of-n-ary-tree",
        [
            "move-sub-tree-of-n-ary-tree"
        ],
        []
    ],
    "Given a\u00a0root\u00a0of an N-ary tree,\u00a0you need to compute the length of the diameter of the tree.The diameter of an N-ary tree is the length of the\u00a0longest\u00a0path between any two nodes in the\u00a0tree. This path may or may not pass through the root.(Nary-Tree input serialization\u00a0is represented in their level order traversal, each group of children is separated by the null value.)\u00a0": [
        "diameter-of-n-ary-tree",
        [
            "diameter-of-binary-tree"
        ],
        []
    ],
    "We have an integer array arr, where all the integers in arr are equal except for one integer which is larger than the rest of the integers. You will not be given direct access to the array, instead, you will have an API ArrayReader which have the following functions:int compareSub(int l, int r, int x, int y): where 0 <= l, r, x, y <\u00a0ArrayReader.length(), l <= r and\u00a0x <= y. The function compares the sum of sub-array arr[l..r] with the sum of the sub-array arr[x..y] and returns:            1 if arr[l]+arr[l+1]+...+arr[r] > arr[x]+arr[x+1]+...+arr[y].0 if arr[l]+arr[l+1]+...+arr[r] == arr[x]+arr[x+1]+...+arr[y].-1 if arr[l]+arr[l+1]+...+arr[r] < arr[x]+arr[x+1]+...+arr[y].int length(): Returns the size of the array.You are allowed to call\u00a0compareSub()\u00a020 times at most. You can assume both functions work in O(1) time.Return the index of the array arr which has the largest integer.Follow-up:What if there are two numbers in arr that are bigger than all other numbers?What if there is one number that is bigger than other numbers and one number that is smaller than other numbers?\u00a0": [
        "find-the-index-of-the-large-integer",
        [],
        [
            "Binary Search"
        ]
    ],
    "We have an integer array\u00a0nums, where all the integers in\u00a0nums\u00a0are 0 or 1. You will not be given direct access to the array, instead, you will have an\u00a0API\u00a0ArrayReader\u00a0which have the following functions:int query(int a, int b, int c, int d): where 0 <= a < b < c < d\u00a0<\u00a0ArrayReader.length().\u00a0The function returns the distribution of the value of the 4 elements and returns:            4 : if the values of the 4 elements are the same (0 or 1).2\u00a0: if three\u00a0elements have a value\u00a0equal to 0\u00a0and one\u00a0element has value equal to 1\u00a0or vice versa.0\u00a0:\u00a0if two element have a value equal to 0 and two elements have a value equal to 1.int length(): Returns the size of the array.You are allowed to call\u00a0query()\u00a02 * n\u00a0times at most where n is equal to ArrayReader.length().Return any index of the most frequent value in nums,\u00a0in case of tie, return -1.": [
        "guess-the-majority-in-a-hidden-array",
        [],
        []
    ],
    "Given a list\u00a0of strings dict where all the strings are of the same length.Return True if there are 2 strings that only differ by 1 character in the same index, otherwise\u00a0return False.": [
        "strings-differ-by-one-character",
        [],
        []
    ],
    "Given two arrays of positive integers\u00a0boxes\u00a0and\u00a0warehouse\u00a0representing the heights of some boxes\u00a0of unit width, and the heights of n\u00a0rooms in a warehouse, respectively.\u00a0The warehouse's\u00a0rooms are labeled from\u00a00\u00a0to\u00a0n - 1\u00a0from left to right where\u00a0warehouse[i]\u00a0(0-indexed) is the height of the\u00a0ith\u00a0room.Boxes are put into the warehouse by the following rules:Boxes can't be piled up.You can rearrange the order of the boxes.Boxes\u00a0can only be pushed into the warehouse from left to right only.If the height of some room\u00a0in the warehouse is less than the height of a box, then the box will be stopped before that room, so are the boxes\u00a0behind it.Return the maximum number of boxes you can put into the warehouse.\u00a0": [
        "put-boxes-into-the-warehouse-i",
        [],
        [
            "Greedy"
        ]
    ],
    "Given two sparse vectors, compute their dot product.Implement class SparseVector:SparseVector(nums)\u00a0Initializes the object with the vector numsdotProduct(vec)\u00a0Compute the dot product between the instance of SparseVector and vecA sparse vector is a vector that has mostly zero values, you should store the sparse vector\u00a0efficiently and compute the dot product between two SparseVector.": [
        "dot-product-of-two-sparse-vectors",
        [],
        [
            "Array",
            "Hash Table",
            "Two Pointers"
        ]
    ],
    "Given a file and assume that you can only read the file using a given method\u00a0read4, implement a method read to read n characters. Your method read may be called multiple times.\u00a0Method read4: The API\u00a0read4 reads 4 consecutive characters from the file, then writes those characters into the buffer array buf.The return value is the number of actual characters read.": [
        "read-n-characters-given-read4-ii-call-multiple-times",
        [
            "read-n-characters-given-read4"
        ],
        [
            "String"
        ]
    ],
    "A strobogrammatic number is a number that looks the same when rotated 180 degrees (looked at upside down).Write a function to count the total strobogrammatic numbers that exist in the range of low <= num <= high.": [
        "strobogrammatic-number-iii",
        [
            "strobogrammatic-number-ii",
            "strobogrammatic-number"
        ],
        [
            "Math",
            "Recursion"
        ]
    ],
    "There are a row of n houses, each house can be painted with one of the k colors. The cost of painting each house with a certain color is different. You have to paint all the houses such that no two adjacent houses have the same color.The cost of painting each house with a certain color is represented by a n x k cost matrix. ": [
        "paint-house-ii",
        [
            "paint-fence",
            "paint-house",
            "sliding-window-maximum",
            "product-of-array-except-self"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "There is a new alien language which uses the latin alphabet. However, the order among letters are unknown to you. You receive a list of non-empty words from the dictionary, where words are sorted lexicographically by the rules of this new language. Derive the order of letters in this language.": [
        "alien-dictionary",
        [
            "course-schedule-ii"
        ],
        [
            "Graph",
            "Topological Sort"
        ]
    ],
    "Given a non-empty binary search tree and a target value, find k values in the BST that are closest to the target.": [
        "closest-binary-search-tree-value-ii",
        [
            "closest-binary-search-tree-value",
            "binary-tree-inorder-traversal"
        ],
        [
            "Stack",
            "Tree"
        ]
    ],
    "Given a pattern and a string str, find if str follows the same pattern.Here follow means a full match, such that there is a bijection between a letter in pattern and a non-empty substring in str.\u00a0": [
        "word-pattern-ii",
        [
            "word-pattern"
        ],
        [
            "Backtracking"
        ]
    ],
    "A group of two or more people wants to meet and minimize the total travel distance. You are given a 2D grid of values 0 or 1, where each 1 marks the home of someone in the group. The distance is calculated using Manhattan Distance, where distance(p1, p2) = |p2.x - p1.x| + |p2.y - p1.y|.": [
        "best-meeting-point",
        [
            "minimum-moves-to-equal-array-elements-ii",
            "shortest-distance-from-all-buildings"
        ],
        [
            "Math",
            "Sort"
        ]
    ],
    "An image is represented by a binary matrix with 0 as a white pixel and 1 as a black pixel. The black pixels are connected, i.e., there is only one black region. Pixels are connected horizontally and vertically. Given the location (x, y) of one of the black pixels, return the area of the smallest (axis-aligned) rectangle that encloses all black pixels.": [
        "smallest-rectangle-enclosing-black-pixels",
        [],
        [
            "Binary Search"
        ]
    ],
    "A 2d grid map of m rows and n columns is initially filled with water. We may perform an addLand operation which turns the water at position (row, col) into a land. Given a list of positions to operate, count the number of islands after each addLand operation. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. ": [
        "number-of-islands-ii",
        [
            "number-of-islands"
        ],
        [
            "Union Find"
        ]
    ],
    "Given a 2D matrix matrix, find the sum of the elements inside the rectangle defined by its upper left corner (row1, col1) and lower right corner (row2, col2).The above rectangle (with the red border) is defined by (row1, col1) = (2, 1) and (row2, col2) = (4, 3), which contains sum = 8.": [
        "range-sum-query-2d-immutable",
        [
            "range-sum-query-2d-mutable",
            "range-sum-query-immutable"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "You want to build a house on an empty land which reaches all buildings in the shortest amount of distance. You can only move up, down, left and right. You are given a 2D grid of values 0, 1 or 2, where:Each 0 marks an empty land which you can pass by freely.Each 1 marks a building which you cannot pass through.Each 2 marks an obstacle which you cannot pass through.": [
        "shortest-distance-from-all-buildings",
        [
            "as-far-from-land-as-possible",
            "best-meeting-point",
            "walls-and-gates"
        ],
        [
            "Breadth-first Search"
        ]
    ],
    "Given a string, find the length of the longest substring T that contains at most k distinct characters.": [
        "longest-substring-with-at-most-k-distinct-characters",
        [
            "max-consecutive-ones-iii",
            "subarrays-with-k-different-integers",
            "longest-repeating-character-replacement",
            "longest-substring-with-at-most-two-distinct-characters",
            "longest-substring-without-repeating-characters"
        ],
        [
            "Hash Table",
            "String",
            "Sliding Window"
        ]
    ],
    "Given a non-empty string s and an integer k, rearrange the string such that the same characters are at least distance k from each other.All input strings are given in lowercase letters. If it is not possible to rearrange the string, return an empty string \"\".": [
        "rearrange-string-k-distance-apart",
        [
            "reorganize-string",
            "task-scheduler"
        ],
        [
            "Hash Table",
            "Heap",
            "Greedy"
        ]
    ],
    "A string such as \"word\" contains the following abbreviations:[\"word\", \"1ord\", \"w1rd\", \"wo1d\", \"wor1\", \"2rd\", \"w2d\", \"wo2\", \"1o1d\", \"1or1\", \"w1r1\", \"1o2\", \"2r1\", \"3d\", \"w3\", \"4\"]    Given a target string and a set of strings in a dictionary, find an abbreviation of this target string with the smallest possible length such that it does not conflict with abbreviations of the strings in the dictionary.Each number or letter in the abbreviation is considered length = 1. ": [
        "minimum-unique-word-abbreviation",
        [
            "word-abbreviation",
            "valid-word-abbreviation",
            "generalized-abbreviation"
        ],
        [
            "Backtracking",
            "Bit Manipulation"
        ]
    ],
    "Given a set of words (without duplicates), find all word squares you can build from them.A sequence of words forms a valid word square if the kth row and column read the exact same string, where 0 \u2264 k < max(numRows, numColumns).": [
        "word-squares",
        [
            "valid-word-square"
        ],
        [
            "Backtracking",
            "Trie"
        ]
    ],
    "Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.Design an algorithm to serialize and deserialize an N-ary tree. An N-ary tree is a rooted tree in which each node has no more than N children. There is no restriction on how your serialization/deserialization algorithm should work. You just need to ensure that an N-ary tree can be serialized to a string and this string can be deserialized to the original tree structure.": [
        "serialize-and-deserialize-n-ary-tree",
        [
            "encode-n-ary-tree-to-binary-tree",
            "serialize-and-deserialize-bst",
            "serialize-and-deserialize-binary-tree"
        ],
        [
            "Tree"
        ]
    ],
    "Design an algorithm to encode an N-ary tree into a binary tree and decode the binary tree to get the original N-ary tree. An N-ary tree is a rooted tree in which each node has no more than N children. Similarly, a binary tree is a rooted tree in which each node has no more than 2 children. There is no restriction on how your encode/decode algorithm should work. You just need to ensure that an N-ary tree can be encoded to a binary tree and this binary tree can be decoded to the original N-nary tree structure.Nary-Tree input serialization\u00a0is represented in their level order traversal, each group of children is separated by the null value (See following example).": [
        "encode-n-ary-tree-to-binary-tree",
        [
            "serialize-and-deserialize-n-ary-tree"
        ],
        [
            "Tree"
        ]
    ],
    "A group of friends went on holiday and sometimes lent each other money. ": [
        "optimal-account-balancing",
        [],
        []
    ],
    "Given a non-empty string, encode the string such that its encoded length is the shortest.The encoding rule is: k[encoded_string], where the encoded_string inside the square brackets is being repeated exactly k times.": [
        "encode-string-with-shortest-length",
        [
            "number-of-atoms",
            "decode-string"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Given a robot cleaner in a room modeled as a grid.Each cell in the grid can be empty or blocked.The robot cleaner with 4 given APIs can move forward, turn left or turn right. Each turn it made is 90 degrees.When it tries to move into a blocked cell, its bumper sensor detects the obstacle and it stays on the current cell.Design an algorithm to clean the entire room using only the 4 given APIs shown below.interface Robot {    \u00a0 // returns true if next cell is open and robot moves into the cell.    \u00a0 // returns false if next cell is obstacle and robot stays on the current cell.    \u00a0 boolean move();          // Robot will stay on the same cell after calling turnLeft/turnRight.    \u00a0 // Each turn will be 90 degrees.    \u00a0 void turnLeft();    \u00a0 void turnRight();          // Clean the current cell.      void clean();    }    ": [
        "robot-room-cleaner",
        [
            "rotting-oranges",
            "robot-room-cleaner",
            "shortest-distance-from-all-buildings",
            "number-of-islands",
            "surrounded-regions"
        ],
        [
            "Depth-first Search"
        ]
    ],
    "There is a ball in a maze with empty spaces and walls. The ball can go through empty spaces by rolling up (u), down (d), left (l) or right (r), but it won't stop rolling until hitting a wall. When the ball stops, it could choose the next direction. There is also a hole in this maze. The ball will drop into the hole if it rolls on to the hole.Given the ball position, the hole position and the maze, find out how the ball could drop into the hole by moving the shortest distance. The distance is defined by the number of empty spaces traveled by the ball from the start position (excluded) to the hole (included). Output the moving directions by using 'u', 'd', 'l' and 'r'. Since there could be several different shortest ways, you should output the lexicographically smallest way. If the ball cannot reach the hole, output \"impossible\".The maze is represented by a binary 2D array. 1 means the wall and 0 means the empty space. ": [
        "the-maze-iii",
        [
            "the-maze-ii",
            "the-maze"
        ],
        [
            "Depth-first Search",
            "Breadth-first Search"
        ]
    ],
    "Given an array of n distinct non-empty strings, you need to generate minimal possible abbreviations for every word following rules below.Begin with the first character and then the number of characters abbreviated, which followed by the last character.If there are any conflict, that is more than one words share the same abbreviation, a longer prefix is used instead of only the first character until making the map from word to abbreviation become unique. In other words, a final abbreviation cannot map to more than one original words. If the abbreviation doesn't make the word shorter, then keep it as original.": [
        "word-abbreviation",
        [
            "minimum-unique-word-abbreviation",
            "valid-word-abbreviation"
        ],
        [
            "String",
            "Sort"
        ]
    ],
    "    LeetCode wants to give one of its best employees the option to travel among N cities to collect algorithm problems. But all work and no play makes Jack a dull boy, you could take vacations in some particular cities and weeks. Your job is to schedule the traveling to maximize the number of vacation days you could take, but there are certain rules and restrictions you need to follow.    Rules and restrictions:You can only travel among N cities, represented by indexes from 0 to N-1. Initially, you are in the city indexed 0 on Monday.The cities are connected by flights. The flights are represented as a N*N matrix (not necessary symmetrical), called flights representing the airline status from the city i to the city j. If there is no flight from the city i to the city j, flights[i][j] = 0; Otherwise, flights[i][j] = 1. Also, flights[i][i] = 0 for all i.You totally have K weeks (each week has 7 days) to travel. You can only take flights at most once per day and can only take flights on each week's Monday morning. Since flight time is so short, we don't consider the impact of flight time.For each city, you can only have restricted vacation days in different weeks, given an N*K matrix called days representing this relationship. For the value of days[i][j], it represents the maximum days you could take vacation in the city i in the week j.You're given the flights matrix and days matrix, and you need to output the maximum vacation days you could take during K weeks.": [
        "maximum-vacation-days",
        [
            "cheapest-flights-within-k-stops"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Design an in-memory file system to simulate the following functions:ls: Given a path in string format. If it is a file path, return a list that only contains this file's name. If it is a directory path, return the list of file and directory names in this directory. Your output (file and directory names together) should in lexicographic order.mkdir: Given a directory path that does not exist, you should make a new directory according to the path. If the middle directories in the path don't exist either, you should create them as well. This function has void return type.addContentToFile: Given a file path and file content in string format. If the file doesn't exist, you need to create that file containing given content. If the file already exists, you need to append given content to original content. This function has void return type.readContentFromFile: Given a file path, return its content in string format.\u00a0": [
        "design-in-memory-file-system",
        [
            "design-log-storage-system",
            "lfu-cache",
            "lru-cache"
        ],
        [
            "Design"
        ]
    ],
    "Your task is to design the basic function of Excel and implement the function of sum formula.  Specifically, you need to implement the following functions:Excel(int H, char W): This is the constructor. The inputs represents the height and width of the Excel form. H is a positive integer, range from 1 to 26. It represents the height. W is a character range from 'A' to 'Z'. It represents that the width is the number of characters from 'A' to W. The Excel form content is represented by a height * width 2D integer array C, it should be initialized to zero. You should assume that the first row of C starts from 1, and the first column of C starts from 'A'.void Set(int row, char column, int val): Change the value at C(row, column) to be val.int Get(int row, char column): Return the value at C(row, column).int Sum(int row, char column, List of Strings : numbers): This function calculate and set the value at C(row, column), where the value should be the sum of cells represented by numbers. This function return the sum result at C(row, column). This sum formula should exist until this cell is overlapped by another value or another sum formula.numbers is a list of strings that each string represent a cell or a range of cells. If the string represent a single cell, then it has the following format : ColRow. ": [
        "design-excel-sum-formula",
        [],
        [
            "Design"
        ]
    ],
    "Design a search autocomplete system for a search engine. Users may input a sentence (at least one word and end with a special character '#'). For each character they type except '#', you need to return the top 3 historical hot sentences that have prefix the same as the part of sentence already typed. Here are the specific rules:The hot degree for a sentence is defined as the number of times a user typed the exactly same sentence before.The returned top 3 hot sentences should be sorted by hot degree (The first is the hottest one). If several sentences have the same degree of hot, you need to use ASCII-code order (smaller one appears first).If less than 3 hot sentences exist, then just return as many as you can.When the input is a special character, it means the sentence ends, and in this case, you need to return an empty list.Your job is to implement the following functions:The constructor function:AutocompleteSystem(String[] sentences, int[] times): This is the constructor. The input is historical data. Sentences is a string array consists of previously typed sentences. Times is the corresponding times a sentence has been typed. Your system should record these historical data.Now, the user wants to input a new sentence. The following function will provide the next character the user types:List<String> input(char c): The input c is the next character typed by the user. The character will only be lower-case letters ('a' to 'z'), blank space (' ') or a special character ('#'). Also, the previously typed sentence should be recorded in your system. The output will be the top 3 historical hot sentences that have prefix the same as the part of sentence already typed.    \u00a0        ": [
        "design-search-autocomplete-system",
        [
            "implement-trie-prefix-tree"
        ],
        [
            "Design",
            "Trie"
        ]
    ],
    "    Given an array consisting of n integers, find the contiguous subarray whose length is greater than or equal to k that has the maximum average value. And you need to output the maximum average value.    ": [
        "maximum-average-subarray-ii",
        [
            "maximum-average-subarray-i"
        ],
        [
            "Array",
            "Binary Search"
        ]
    ],
    "Given an array A (index starts at 1) consisting of N integers: A1, A2, ..., AN\u00a0and an integer B. The integer B denotes that from any place (suppose the index is i) in the array A, you can jump to any one of the place in the array A indexed i+1, i+2, \u2026, i+B if this place can be jumped to. Also, if you step on the index i, you have to pay Ai\u00a0coins. If Ai\u00a0is -1, it means you can\u2019t jump to the place indexed i in the array.Now, you start from the place indexed 1 in the array A, and your aim is to reach the place indexed N using the minimum coins. You need to return the path of indexes (starting from 1 to N) in the array you should take to get to the place indexed N using minimum coins.If there are multiple paths with the same cost, return the lexicographically smallest such path.If it's not possible to reach the place indexed N then you need to return an empty array.": [
        "coin-path",
        [
            "house-robber-ii",
            "house-robber"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Start from integer 1, remove any integer that contains 9 such as 9, 19, 29...So now, you will have a new integer sequence: 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, ...Given a positive integer n, you need to return the n-th integer after removing. ": [
        "remove-9",
        [],
        [
            "Math"
        ]
    ],
    "You have N bulbs in a row numbered from 1 to N. Initially, all the bulbs are turned off. We turn on exactly one bulb everyday until all bulbs are on after N days.You are given an array bulbs\u00a0of length N\u00a0where bulbs[i] = x means that on the (i+1)th day, we will turn on the bulb at position x\u00a0where\u00a0i\u00a0is\u00a00-indexed\u00a0and\u00a0x\u00a0is\u00a01-indexed.Given an integer K, find out the minimum day number such that there exists two turned on bulbs that have exactly\u00a0K bulbs between them that are all turned off.If there isn't such day, return -1.\u00a0": [
        "k-empty-slots",
        [],
        [
            "Ordered Map"
        ]
    ],
    "Given strings S and T, find the minimum (contiguous) substring W of S, so that T is a subsequence of W.If there is no such window in S that covers all characters in T, return the empty string \"\". If there are multiple such minimum-length windows, return the one with the left-most starting index.": [
        "minimum-window-subsequence",
        [
            "longest-continuous-increasing-subsequence",
            "minimum-window-substring"
        ],
        [
            "Dynamic Programming",
            "Sliding Window",
            "Dynamic Programming",
            "Sliding Window"
        ]
    ],
    "We are given a list schedule of employees, which represents the working time for each employee.Each employee has a list of non-overlapping Intervals, and these intervals are in sorted order.Return the list of finite intervals representing common, positive-length free time for all employees, also in sorted order.(Even though we are representing Intervals in the form [x, y], the objects inside are Intervals, not lists or arrays. ": [
        "employee-free-time",
        [
            "interval-list-intersections",
            "merge-intervals"
        ],
        [
            "Heap",
            "Greedy"
        ]
    ],
    "Implement a basic calculator to evaluate a simple expression string.The expression string may contain open ( and closing parentheses ), the plus + or minus sign -, non-negative integers and empty spaces  .The expression string contains only non-negative integers, +, -, *, / operators , open ( and closing parentheses ) and empty spaces  . The integer division should truncate toward zero.": [
        "basic-calculator-iii",
        [
            "basic-calculator-iv",
            "basic-calculator-ii",
            "basic-calculator"
        ],
        [
            "String",
            "Stack"
        ]
    ],
    "On a horizontal number line, we have gas stations at positions stations[0], stations[1], ..., stations[N-1], where N = stations.length.Now, we add K more gas stations so that D, the maximum distance between adjacent gas stations, is minimized.Return the smallest possible value of D.": [
        "minimize-max-distance-to-gas-station",
        [
            "koko-eating-bananas"
        ],
        [
            "Binary Search"
        ]
    ],
    "Given an array A of integers, return the number of non-empty continuous subarrays that satisfy the following condition:The leftmost element of the subarray is not larger than other elements in the subarray.\u00a0": [
        "number-of-valid-subarrays",
        [],
        [
            "Stack"
        ]
    ],
    "Given an integer d between 0 and 9, and two positive integers low and high as lower and upper bounds, respectively. Return the number of times that d occurs as a digit in all integers between low and high, including the bounds low and high.    \u00a0": [
        "digit-count-in-range",
        [
            "number-of-digit-one"
        ],
        [
            "Math",
            "Dynamic Programming"
        ]
    ],
    "We can rotate digits by 180 degrees to form new digits. When 0, 1, 6, 8, 9 are rotated 180 degrees, they become 0, 1, 9, 8, 6 respectively. When 2, 3, 4, 5 and 7 are rotated 180 degrees, they become invalid.A confusing number is a number that when rotated 180 degrees becomes a different number with each digit valid.(": [
        "confusing-number-ii",
        [
            "confusing-number"
        ],
        [
            "Math",
            "Backtracking"
        ]
    ],
    "Given a non-decreasing array of positive integers\u00a0nums\u00a0and an integer K, find out if this array can be divided into one or more disjoint increasing subsequences of length at least K.\u00a0": [
        "divide-array-into-increasing-sequences",
        [],
        [
            "Math"
        ]
    ],
    "There are N courses, labelled from 1 to N.We are given\u00a0relations[i] = [X, Y], representing a prerequisite relationship between course X and course Y:\u00a0course X\u00a0has to be studied before course Y.In one semester you can study any number of courses as long as you have studied all the prerequisites for the course you are studying.Return the minimum number of semesters needed to study all courses.\u00a0 If there is no way to study all the courses, return -1.\u00a0": [
        "parallel-courses",
        [],
        [
            "Dynamic Programming",
            "Depth-first Search",
            "Graph"
        ]
    ],
    "Given two strings str1 and str2\u00a0of the same length, determine whether you can transform str1\u00a0into str2 by doing zero or more\u00a0conversions.In one conversion you can convert\u00a0all occurrences of one character in str1 to\u00a0any other lowercase English character.Return true\u00a0if and only if you can transform str1 into str2.\u00a0": [
        "string-transforms-into-another-string",
        [],
        [
            "Graph"
        ]
    ],
    "There are n\u00a0houses in a village. We want to supply water for all the houses by building wells and laying pipes.For each house i, we can either build a well inside it directly with cost wells[i], or pipe in water from another well to it. The costs to lay pipes between houses are given by the array pipes, where each\u00a0pipes[i] = [house1, house2, cost]\u00a0represents the cost to connect\u00a0house1\u00a0and house2\u00a0together using a pipe.\u00a0Connections are bidirectional.Find the minimum total cost to supply water to all houses.\u00a0": [
        "optimize-water-distribution-in-a-village",
        [],
        [
            "Union Find",
            "Graph"
        ]
    ],
    "Consider a matrix M with dimensions width * height, such that every cell has value 0\u00a0or 1, and any square\u00a0sub-matrix of M of size sideLength * sideLength\u00a0has at most maxOnes\u00a0ones.Return the maximum possible number of ones that the matrix M can have.\u00a0": [
        "maximum-number-of-ones",
        [],
        [
            "Math",
            "Sort"
        ]
    ],
    "You are given a list of blocks, where blocks[i] = t means that the\u00a0i-th block needs\u00a0t\u00a0units of time to be built. A block can only be built by exactly one worker.A worker can either split into two workers (number of workers increases by one) or build a block then go home. Both decisions cost some time.The time cost of spliting one worker into two workers is\u00a0given as an integer split. ": [
        "minimum-time-to-build-blocks",
        [],
        [
            "Math",
            "Dynamic Programming"
        ]
    ],
    "Given a string s\u00a0and an integer\u00a0k, find out if the given string is\u00a0a\u00a0K-Palindrome or not.A string is K-Palindrome if it can be\u00a0transformed\u00a0into a palindrome by removing at most k characters from it.\u00a0": [
        "valid-palindrome-iii",
        [],
        [
            "String",
            "Dynamic Programming"
        ]
    ],
    "You have one chocolate bar that consists of some chunks. Each chunk has its own sweetness given by the array\u00a0sweetness.You want to share the chocolate with your K\u00a0friends so you start cutting the chocolate bar into K+1\u00a0pieces using\u00a0K\u00a0cuts, each piece consists of some consecutive chunks.Being generous, you will eat the piece with the minimum total sweetness and give the other pieces to your friends.Find the maximum total sweetness of the\u00a0piece you can get by cutting the chocolate bar optimally.\u00a0": [
        "divide-chocolate",
        [],
        [
            "Binary Search",
            "Greedy"
        ]
    ],
    "Given an integer array\u00a0arr, in one move you can select a palindromic\u00a0subarray arr[i], arr[i+1], ..., arr[j]\u00a0where i <= j, and remove that subarray from the given array. ": [
        "palindrome-removal",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "You are given an\u00a0even number of people num_people\u00a0that stand around a circle and each person shakes hands\u00a0with someone else, so that there are num_people / 2 handshakes total.Return the number of ways these handshakes could occur such that none of the handshakes cross.Since this number could be very big, return the answer mod\u00a010^9 + 7\u00a0": [
        "handshakes-that-dont-cross",
        [],
        [
            "Math",
            "Dynamic Programming"
        ]
    ],
    "(This problem is an\u00a0interactive problem.)On the sea represented by a cartesian plane, each ship is located at an integer point, and each integer point may contain at most 1 ship.You have a function Sea.hasShips(topRight, bottomLeft) which takes two points\u00a0as arguments and returns true\u00a0if and only if there is at least one ship in the rectangle represented by the two points, including on the boundary.Given two points, which are the top right and bottom left corners of a rectangle, return the number of ships present in that rectangle.\u00a0\u00a0It is guaranteed that there are at most 10 ships in that rectangle.Submissions making more than 400 calls to\u00a0hasShips\u00a0will be judged Wrong Answer.\u00a0 Also, any solutions that attempt to circumvent the judge\u00a0will result in disqualification.\u00a0": [
        "number-of-ships-in-a-rectangle",
        [],
        [
            "Divide and Conquer"
        ]
    ],
    "Given the root of an\u00a0N-ary tree\u00a0of unique values, and two nodes of the tree\u00a0p and q.You should move\u00a0the subtree of the node\u00a0p\u00a0to become a direct child of node q. If p\u00a0is already a direct child of q, don't change anything. Node p must be the last child in the children list of node q.Return the root of the tree after adjusting it.\u00a0There are 3 cases for nodes p and q:Node q is in the sub-tree of node p.Node p is in the sub-tree of node q.Neither node p is\u00a0in the sub-tree of node q nor node q is in the sub-tree of node p.In cases 2 and 3, you just need to move p\u00a0(with its sub-tree) to be a child of q, but in case 1 the tree may be disconnected, thus you need to reconnect the tree again. Please read the examples carefully before solving this problem.\u00a0Nary-Tree input serialization\u00a0is represented in their level order traversal, each group of children is separated by the null value (See examples).": [
        "move-sub-tree-of-n-ary-tree",
        [
            "find-root-of-n-ary-tree"
        ],
        [
            "Tree"
        ]
    ],
    "We have n cities and m bi-directional roads where roads[i] = [ai, bi] connects city ai with city bi. Each city has a\u00a0name consisting of exactly 3 upper-case English letters given in the string array names. Starting at any city x, you can reach any city y where y != x (i.e. the cities and the roads are forming an undirected connected graph).You will be given a string array targetPath. You should find a path in the graph of the same length and with the minimum edit distance to targetPath.You need to return the order of the nodes in the path with the minimum edit distance, The path should be\u00a0of the same length of targetPath\u00a0and should be valid (i.e. there should be a direct road between ans[i] and ans[i + 1]). If there are multiple answers return any one of them.The edit distance is defined as follows:Follow-up: If each node can be visited only once in the path, What should you change in your solution?\u00a0": [
        "the-most-similar-path-in-a-graph",
        [],
        [
            "Dynamic Programming",
            "Graph"
        ]
    ],
    "Given an array nums\u00a0that represents a permutation of integers from\u00a01\u00a0to\u00a0n. We are going to construct a binary search tree (BST) by inserting the elements of\u00a0nums\u00a0in\u00a0order into an initially empty BST. Find the number of different ways to reorder nums so that the constructed BST is identical to that formed from the original array\u00a0nums.": [
        "number-of-ways-to-reorder-array-to-get-same-bst",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Given a 2D\u00a0grid consisting\u00a0of 1s (land)\u00a0and 0s (water).\u00a0 An island is a maximal 4-directionally (horizontal or vertical) connected group of 1s.The grid is said to be connected if we have exactly one\u00a0island, otherwise is said disconnected.In one day, we are allowed to change any single land cell (1) into a water cell (0).Return the minimum number of days to disconnect the grid.\u00a0": [
        "minimum-number-of-days-to-disconnect-island",
        [],
        [
            "Greedy"
        ]
    ],
    "Given an array of integers\u00a0nums, find\u00a0the maximum length of a subarray where the product of all its elements is positive.A subarray of an array is a consecutive sequence of zero or more values taken out of that array.Return\u00a0the maximum length of a subarray with positive product.\u00a0": [
        "maximum-length-of-subarray-with-positive-product",
        [],
        [
            "Greedy"
        ]
    ],
    "Given an array of positive integers arr,\u00a0 find a pattern of length m that is repeated k or more times.A pattern is a subarray (consecutive sub-sequence) that consists of one or more values, repeated multiple times consecutively without overlapping. A pattern is defined by its length and the number of repetitions.Return\u00a0true\u00a0if there exists a pattern of length\u00a0m\u00a0that is repeated\u00a0k\u00a0or more times, otherwise return\u00a0false.\u00a0": [
        "detect-pattern-of-length-m-repeated-k-or-more-times",
        [],
        [
            "Array"
        ]
    ],
    "There are several stones\u00a0arranged in a row, and each stone has an associated\u00a0value which is an integer given in the array\u00a0stoneValue.In each round of the game, Alice divides the row into two non-empty rows (i.e. left row and right row), then Bob calculates the value of each row which is the sum of the values of all the stones in this row. Bob throws away the row which has the maximum value, and\u00a0Alice's score increases by the value of the remaining row. If the value of the two rows are equal, Bob lets Alice decide which row will be thrown away. The next round starts with the remaining row.The game ends when there is only one stone remaining. Alice's is initially zero.Return the maximum score that Alice can obtain.\u00a0": [
        "stone-game-v",
        [
            "stone-game-iv",
            "stone-game-iii",
            "stone-game-ii",
            "stone-game"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Given an array arr\u00a0that represents a permutation of numbers from 1\u00a0to n. You have a binary string of size\u00a0n\u00a0that initially has all its bits set to zero.At each step i\u00a0(assuming both the binary string and arr are 1-indexed) from 1 to\u00a0n, the bit at position\u00a0arr[i]\u00a0is set to\u00a01. You are given an integer\u00a0m\u00a0and you need to find the latest step at which there exists a group of ones of length\u00a0m. A group of ones is a contiguous substring of 1s such that it cannot be extended in either direction.Return the latest step at which there exists a group of ones of length exactly\u00a0m. If no such group exists, return\u00a0-1.\u00a0": [
        "find-latest-group-of-size-m",
        [],
        [
            "Binary Search"
        ]
    ],
    "There are 3n\u00a0piles of coins of\u00a0varying size, you and your friends will take piles of coins as follows:In each step, you will choose any\u00a03 piles of coins (not necessarily consecutive).Of your choice,\u00a0Alice\u00a0will pick\u00a0the pile with the maximum number of coins.You will pick the next pile with maximum number of coins.Your friend Bob will pick the last pile.Repeat\u00a0until\u00a0there are no more piles of coins.Given an array of integers piles\u00a0where piles[i] is the number of coins in the ith pile.Return the maximum number of coins which you can have.\u00a0": [
        "maximum-number-of-coins-you-can-get",
        [],
        [
            "Sort"
        ]
    ],
    "Given an integer n and an integer array rounds.\u00a0We\u00a0have a circular track which consists of n sectors labeled from 1 to n. A marathon will be held on this track, the marathon consists of m rounds. The ith\u00a0round starts at sector rounds[i - 1] and ends at sector rounds[i]. ": [
        "most-visited-sector-in-a-circular-track",
        [],
        [
            "Array"
        ]
    ],
    "There are n oranges in the kitchen and you decided to eat some of these oranges every day as follows:Eat one orange.If the number of remaining oranges (n) is divisible by 2 then you can eat\u00a0 n/2 oranges.If the number of remaining oranges (n) is divisible by 3\u00a0then you can eat\u00a0 2*(n/3)\u00a0oranges.You can only choose one of the actions per day.Return the minimum number of days to eat n oranges.\u00a0": [
        "minimum-number-of-days-to-eat-n-oranges",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "In universe Earth\u00a0C-137, Rick discovered a special form of magnetic force between\u00a0two balls if they are put in his new invented basket. Rick has\u00a0n empty baskets, the ith basket is at position[i], Morty has m balls and needs to distribute the balls into the baskets such that the minimum\u00a0magnetic force\u00a0between any two balls is maximum.Rick stated that\u00a0magnetic force between two different balls at positions x and y is |x - y|.Given the integer array position\u00a0and the integer m. Return the required force.\u00a0": [
        "magnetic-force-between-two-balls",
        [],
        [
            "Array",
            "Binary Search"
        ]
    ],
    "You have an array arr of length n where arr[i] = (2 * i) + 1 for all valid values of i (i.e. 0 <= i < n).In one operation, you can select two indices x\u00a0and y where 0 <= x, y < n and subtract 1 from arr[x] and add 1 to arr[y]\u00a0(i.e. perform arr[x] -=1\u00a0and arr[y] += 1).\u00a0The goal is to make all the elements of the array equal. It is guaranteed that all the elements of the array can be made equal using some operations.Given an integer n, the length of the array. Return the minimum number of operations needed to make\u00a0all the elements of arr equal.\u00a0": [
        "minimum-operations-to-make-array-equal",
        [],
        [
            "Math"
        ]
    ],
    "Given a wooden stick of length n units. The stick is labelled from 0 to n. ": [
        "minimum-cost-to-cut-a-stick",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Given a string s. An awesome substring is a non-empty substring of s such that we can make any number of swaps in order to make it palindrome.Return the length of the maximum length awesome substring of s.\u00a0": [
        "find-longest-awesome-substring",
        [],
        [
            "String",
            "Bit Manipulation"
        ]
    ],
    "Given two positive integers\u00a0n\u00a0and k,\u00a0the binary string\u00a0\u00a0Sn\u00a0is formed as follows:S1\u00a0= \"0\"Si\u00a0=\u00a0Si-1\u00a0+ \"1\" + reverse(invert(Si-1))\u00a0for\u00a0i > 1Where\u00a0+\u00a0denotes the concatenation operation,\u00a0reverse(x)\u00a0returns the reversed string x,\u00a0and\u00a0invert(x)\u00a0inverts all the bits in x (0 changes to 1 and 1 changes to 0).": [
        "find-kth-bit-in-nth-binary-string",
        [],
        [
            "String"
        ]
    ],
    "Given a string s of lower and upper case English letters.A good string is a string which doesn't have\u00a0two adjacent characters s[i] and s[i + 1] where:0 <= i <= s.length - 2s[i] is a lower-case letter and s[i + 1] is the same letter but in upper-case\u00a0or vice-versa.To make the string good, you can choose two adjacent characters that make the string bad and remove them. You can keep doing this until the string becomes good.Return the string after making it good. The answer is guaranteed to be unique under the given constraints.Notice that an empty string is also good.\u00a0": [
        "make-the-string-great",
        [],
        [
            "String",
            "Stack"
        ]
    ],
    "Given a 2D array of characters\u00a0grid\u00a0of size m x n, you need to find if there exists any cycle consisting of the same value\u00a0in\u00a0grid.A cycle is a path of length 4\u00a0or more\u00a0in the grid that starts and ends at the same cell. From a given cell, you can move to one of the cells adjacent to it - in one of the four directions (up, down, left, or right), if it has the same value of the current cell.Also, you cannot move to the cell that you visited in your last move. ": [
        "detect-cycles-in-2d-grid",
        [],
        [
            "Depth-first Search"
        ]
    ],
    "Your task is to form\u00a0an integer array nums from an initial array of zeros\u00a0arr that is the\u00a0same size\u00a0as nums.Return the minimum number of\u00a0function calls to make nums from arr.The answer is guaranteed to fit in a 32-bit signed integer.\u00a0": [
        "minimum-numbers-of-function-calls-to-make-target-array",
        [],
        [
            "Greedy"
        ]
    ],
    "Given a\u00a0directed acyclic graph,\u00a0with\u00a0n\u00a0vertices numbered from\u00a00\u00a0to\u00a0n-1,\u00a0and an array\u00a0edges\u00a0where\u00a0edges[i] = [fromi, toi]\u00a0represents a directed edge from node\u00a0fromi\u00a0to node\u00a0toi.Find the smallest set of vertices from which all nodes in the graph are reachable. It's guaranteed that a unique solution exists.Notice that you can return the vertices in any order.\u00a0": [
        "minimum-number-of-vertices-to-reach-all-nodes",
        [],
        [
            "Graph"
        ]
    ],
    "Given an\u00a0integer n, add a dot (\".\")\u00a0as the thousands separator and return it in\u00a0string format.\u00a0": [
        "thousand-separator",
        [],
        [
            "String"
        ]
    ],
    "You are given two sorted arrays of distinct integers nums1 and nums2.A valid path is defined as follows:Choose\u00a0array nums1 or nums2 to traverse (from index-0).Traverse the current array from left to right.If you are reading any value that is present in nums1 and nums2\u00a0you are allowed to change your path to the other array. (Only one repeated value is considered in the\u00a0valid path).Score is defined as the sum of uniques values in a valid path.Return the maximum score you can obtain of all possible\u00a0valid\u00a0paths.Since the answer\u00a0may be too large,\u00a0return it modulo\u00a010^9 + 7.\u00a0": [
        "get-the-maximum-score",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Given an n\u00a0x n\u00a0binary grid, in one step you can choose two adjacent rows of the grid and swap them.A grid is said to be valid if all the cells above the main diagonal are zeros.Return the minimum number of steps needed to make the grid valid, or -1 if the grid cannot be valid.The main diagonal of a grid is the diagonal that starts at cell (1, 1) and ends at cell (n, n).\u00a0": [
        "minimum-swaps-to-arrange-a-binary-grid",
        [],
        [
            "Greedy"
        ]
    ],
    "Given an integer array arr of distinct integers and an integer k.A game will be played between the first two elements of the array (i.e. arr[0] and arr[1]). In each round of the game, we compare arr[0] with arr[1], the larger integer\u00a0wins and remains at position 0 and the smaller integer moves to the end of the array. The game ends when an integer wins k consecutive rounds.Return the integer which will win the game.It is guaranteed that there will be a winner of the game.\u00a0": [
        "find-the-winner-of-an-array-game",
        [],
        [
            "Array"
        ]
    ],
    "Given an array of integers arr, and three integers\u00a0a,\u00a0b\u00a0and\u00a0c. You need to find the number of good triplets.A triplet (arr[i], arr[j], arr[k])\u00a0is good if the following conditions are true:0 <= i < j < k <\u00a0arr.length|arr[i] - arr[j]| <= a|arr[j] - arr[k]| <= b|arr[i] - arr[k]| <= cWhere |x| denotes the absolute value of x.Return the number of good triplets.\u00a0": [
        "count-good-triplets",
        [],
        [
            "Array"
        ]
    ],
    "Given the root of a binary tree and an integer distance. A pair of two different leaf nodes of a binary tree is said to be good if the length of the shortest path between them is less than or equal to distance.Return the number of good leaf node pairs in the tree.\u00a0": [
        "number-of-good-leaf-nodes-pairs",
        [],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "There is a room with n\u00a0bulbs, numbered from 0 to\u00a0n-1,\u00a0arranged in a row from left to right. Initially all the bulbs are turned off.Your task is to obtain the configuration represented by target where\u00a0target[i] is '1' if the i-th bulb is turned on and is '0' if it is turned off.You have a switch\u00a0to flip the state of the bulb,\u00a0a flip operation is defined as follows:Choose any bulb (index\u00a0i)\u00a0of your current configuration.Flip each bulb from index\u00a0i to\u00a0n-1.When any bulb is flipped it means that if it is 0 it changes to 1 and if it is 1 it changes to 0.Return the minimum number of flips required to form target.\u00a0": [
        "bulb-switcher-iv",
        [],
        [
            "String"
        ]
    ],
    "Given a string s\u00a0and an integer array indices of the same length.The string s will be shuffled such that the character at the ith position moves to\u00a0indices[i] in the shuffled string.Return the shuffled string.\u00a0": [
        "shuffle-string",
        [],
        [
            "Sort"
        ]
    ],
    "Given an array nums and an integer target.Return the maximum number of non-empty\u00a0non-overlapping subarrays such that the sum of values in each subarray is equal to target.\u00a0": [
        "maximum-number-of-non-overlapping-subarrays-with-sum-equals-target",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Given a parentheses string s containing only the characters '(' and ')'. A parentheses string is balanced if:Any left parenthesis\u00a0'('\u00a0must have a corresponding two consecutive right parenthesis\u00a0'))'.Left parenthesis\u00a0'('\u00a0must go before the corresponding two\u00a0consecutive right parenthesis\u00a0'))'.In other words, we treat '(' as openning parenthesis and '))' as closing parenthesis.": [
        "minimum-insertions-to-balance-a-parentheses-string",
        [],
        [
            "String",
            "Stack"
        ]
    ],
    "Given two strings\u00a0s\u00a0and\u00a0t, your goal is to convert\u00a0s\u00a0into\u00a0t\u00a0in\u00a0k\u00a0moves or less.During the\u00a0ith\u00a0(1 <= i <= k)\u00a0move you can:Choose any index\u00a0j\u00a0(1-indexed) from\u00a0s, such that\u00a01 <= j <= s.length\u00a0and j\u00a0has not been chosen in any previous move,\u00a0and shift the character at that index\u00a0i\u00a0times.Do nothing.Shifting a character means replacing it by the next letter in the alphabet\u00a0(wrapping around so that\u00a0'z'\u00a0becomes\u00a0'a'). Shifting a character by\u00a0i\u00a0means applying the shift operations\u00a0i\u00a0times.Remember that any index\u00a0j\u00a0can be picked at most once.Return\u00a0true\u00a0if it's possible to convert\u00a0s\u00a0into\u00a0t\u00a0in no more than\u00a0k\u00a0moves, otherwise return\u00a0false.\u00a0": [
        "can-convert-string-in-k-moves",
        [],
        [
            "String",
            "Greedy"
        ]
    ],
    "Given an array arr\u00a0of positive integers\u00a0sorted in a strictly increasing order, and an integer k.Find the kth\u00a0positive integer that is missing from this array.\u00a0": [
        "kth-missing-positive-number",
        [],
        [
            "Array",
            "Hash Table"
        ]
    ],
    "Winston was given the above mysterious function func. He has an integer array arr and an integer target and he wants to find the values\u00a0l and r\u00a0that make\u00a0the value |func(arr, l, r) - target| minimum possible.Return the minimum possible value of |func(arr, l, r) - target|.Notice that func should be called with the values\u00a0l and r where 0 <= l, r < arr.length.\u00a0": [
        "find-a-value-of-a-mysterious-function-closest-to-target",
        [],
        [
            "Binary Search",
            "Bit Manipulation",
            "Segment Tree"
        ]
    ],
    "Given a string s\u00a0of lowercase letters, you need to find the maximum number of non-empty substrings of\u00a0s\u00a0that meet the following conditions:The substrings do not overlap, that is for any two substrings s[i..j] and s[k..l], either j < k or i > l\u00a0is true.A substring that contains a certain character\u00a0c\u00a0must also contain all occurrences of c.Find the maximum number of substrings that meet the above conditions. If there are multiple solutions with the same number of substrings, return the one with minimum total length.\u00a0It can be shown that there exists a unique solution of minimum total length.Notice that you can return the substrings in any order.\u00a0": [
        "maximum-number-of-non-overlapping-substrings",
        [],
        [
            "Greedy"
        ]
    ],
    "Given a tree (i.e. a connected, undirected graph that has no cycles) consisting of n nodes numbered from 0 to n - 1 and exactly n - 1 edges. The root of the tree is the node 0, and each node of the tree has a label which is a lower-case character given in the string labels (i.e. The node with the number i has the label labels[i]).The edges array is given on the form edges[i] = [ai, bi], which means there is an edge between nodes ai and bi in the tree.Return an array of size n where ans[i] is the number of nodes in the subtree of the\u00a0ith\u00a0node which have the same label as node i.A\u00a0subtree\u00a0of a tree\u00a0T is the tree consisting of a node in T and all of its descendant\u00a0nodes.\u00a0": [
        "number-of-nodes-in-the-sub-tree-with-the-same-label",
        [],
        [
            "Depth-first Search",
            "Breadth-first Search"
        ]
    ],
    "Given numBottles\u00a0full water bottles, you can exchange numExchange empty water bottles for one full water bottle.The operation of drinking a full water bottle turns it into an empty bottle.Return the maximum number of water bottles you can\u00a0drink.\u00a0": [
        "water-bottles",
        [],
        [
            "Greedy"
        ]
    ],
    "A delivery company wants to build a new service centre in a new city. The company knows the positions of all the customers in this city on a 2D-Map and wants to build the new centre in a position such that the sum of the euclidean distances to all customers is minimum.Given an array positions where positions[i] = [xi, yi] is the position of the ith customer on the map, return the minimum sum of the euclidean distances to all customers.In other words, you need to choose the position of the service centre [xcentre, ycentre] such that the following formula is minimized:Answers within\u00a010^-5\u00a0of the actual value will be accepted.\u00a0": [
        "best-position-for-a-service-centre",
        [],
        [
            "Geometry"
        ]
    ],
    "Run-length encoding is a string compression method that works by\u00a0replacing consecutive identical characters (repeated 2 or more times) with the concatenation of the character and the number marking the count of the characters (length of the run). ": [
        "string-compression-ii",
        [],
        [
            "String",
            "Dynamic Programming"
        ]
    ],
    "Given a binary string\u00a0s\u00a0(a string consisting only of '0' and '1's).Return the number of substrings with all characters 1's.Since the answer\u00a0may be too large,\u00a0return it modulo\u00a010^9 + 7.\u00a0": [
        "number-of-substrings-with-only-1s",
        [],
        [
            "Math",
            "String"
        ]
    ],
    "Given an array of integers\u00a0nums.A pair\u00a0(i,j)\u00a0is called good if\u00a0nums[i] == nums[j] and i < j.Return the number of good pairs.\u00a0": [
        "number-of-good-pairs",
        [],
        [
            "Array",
            "Hash Table",
            "Math"
        ]
    ],
    "Given an array of positive integers target and an array initial of same size with all zeros.Return the minimum number of operations to form a target array from initial\u00a0if you are allowed to do the following operation:Choose any subarray from initial\u00a0and increment each value by one.The answer is guaranteed to fit within the range of a 32-bit signed integer.\u00a0": [
        "minimum-number-of-increments-on-subarrays-to-form-a-target-array",
        [],
        [
            "Segment Tree"
        ]
    ],
    "You are given a string s, a\u00a0split is called good\u00a0if you can split\u00a0s into 2\u00a0non-empty strings p and q where its concatenation is equal to s and the number of distinct letters in p and q are the same.Return the number of good splits you can make in s.\u00a0": [
        "number-of-good-ways-to-split-a-string",
        [],
        [
            "String",
            "Bit Manipulation"
        ]
    ],
    "Given an array of integers arr. Return the number of sub-arrays with odd sum.As the answer may grow large, the answer\u00a0must be\u00a0computed modulo\u00a010^9 + 7.\u00a0": [
        "number-of-sub-arrays-with-odd-sum",
        [],
        [
            "Array",
            "Math"
        ]
    ],
    "Given two non-negative integers low and high. Return the count of odd numbers between low and high\u00a0(inclusive).\u00a0": [
        "count-odd-numbers-in-an-interval-range",
        [],
        [
            "Math"
        ]
    ],
    "Given a string num representing the digits of\u00a0a very large integer and an integer k.You are allowed to swap any two adjacent digits of the integer at most k times.Return the minimum integer you can obtain also as a string.\u00a0": [
        "minimum-possible-integer-after-at-most-k-adjacent-swaps-on-digits",
        [],
        [
            "Greedy"
        ]
    ],
    "Given a\u00a0rows * columns\u00a0matrix mat of ones and zeros, return how many\u00a0submatrices have all ones.\u00a0": [
        "count-submatrices-with-all-ones",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "We have a wooden\u00a0plank of the length n units. Some ants are walking on the\u00a0plank, each ant moves with speed 1 unit per second. Some of the ants move to the left, the other move to the right.When two ants moving in two different directions meet at some point, they change their directions and continue moving again. Assume changing directions doesn't take any additional time.When an ant reaches one end of the plank at a time t, it falls out of the plank imediately.Given an integer n and two integer arrays left and right, the positions of the ants moving to the left and the right.\u00a0Return the\u00a0moment when the last ant(s) fall out of the plank.\u00a0": [
        "last-moment-before-all-ants-fall-out-of-a-plank",
        [],
        [
            "Array",
            "Brainteaser"
        ]
    ],
    "Given an array of numbers arr.\u00a0A sequence of numbers is called an arithmetic progression\u00a0if the difference between any two consecutive elements is the same.Return true\u00a0if the array can be rearranged to form an arithmetic progression, otherwise, return false.\u00a0": [
        "can-make-arithmetic-progression-from-sequence",
        [],
        [
            "Array",
            "Sort"
        ]
    ],
    "Given an\u00a0array points containing the coordinates of points on a 2D plane,\u00a0sorted by the x-values, where points[i] = [xi, yi]\u00a0such that\u00a0xi < xj for all 1 <= i < j <= points.length. You are also given an integer\u00a0k.Find the maximum value of the equation yi\u00a0+ yj\u00a0+ |xi\u00a0- xj|\u00a0where |xi\u00a0- xj|\u00a0<= k\u00a0and 1 <= i < j <= points.length. It is guaranteed that there exists at least one pair of points that satisfy the constraint |xi\u00a0- xj|\u00a0<= k.\u00a0": [
        "max-value-of-equation",
        [],
        [
            "Array",
            "Sliding Window"
        ]
    ],
    "Given an array of integers nums and an integer target.Return the number of non-empty subsequences of nums such that the sum of the minimum and maximum element on it is less or equal than target.Since the answer\u00a0may be too large,\u00a0return it modulo\u00a010^9 + 7.\u00a0": [
        "number-of-subsequences-that-satisfy-the-given-sum-condition",
        [],
        [
            "Sort",
            "Sliding Window"
        ]
    ],
    "Given an array of integers arr of even length n and an integer k.We want to divide the array into exactly n /\u00a02 pairs such that the sum of each pair is divisible by k.Return True If you can find a way to do that or False otherwise.\u00a0": [
        "check-if-array-pairs-are-divisible-by-k",
        [],
        [
            "Array",
            "Math",
            "Greedy"
        ]
    ],
    "Given a string\u00a0path, where path[i] =\u00a0'N', 'S', 'E'\u00a0or\u00a0'W', each representing moving one unit north, south, east, or west, respectively. You start at the origin (0, 0) on a 2D plane and walk on the path specified by path.Return True if the path crosses itself at any point, that is, if at any time you are on a location you've previously visited. Return False otherwise.\u00a0": [
        "path-crossing",
        [],
        [
            "String"
        ]
    ],
    "Alice and Bob take turns playing a game, with Alice starting first.Initially, there are n stones in a pile.\u00a0 On each player's turn, that player makes a\u00a0move\u00a0consisting of removing any non-zero square number of stones in the pile.Also, if a player cannot make a move, he/she loses the game.Given a positive\u00a0integer n.\u00a0Return\u00a0True\u00a0if and only if Alice wins the game otherwise return False, assuming both players play optimally.\u00a0": [
        "stone-game-iv",
        [
            "stone-game-v"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Given an array nums, you are allowed to choose one element of nums and change it by any\u00a0value in one move.Return the minimum difference between the largest and smallest value of nums\u00a0after perfoming at most 3 moves.\u00a0": [
        "minimum-difference-between-largest-and-smallest-value-in-three-moves",
        [],
        [
            "Array",
            "Sort"
        ]
    ],
    "Given the array nums consisting of n positive integers. You computed the sum of all non-empty continous subarrays from\u00a0the array and then sort them in non-decreasing order, creating a new array of n * (n + 1) / 2\u00a0numbers.Return the sum of the numbers from index left to index right (indexed from 1), inclusive, in the\u00a0new array.\u00a0Since the answer can be a huge number return it modulo 10^9 + 7.\u00a0": [
        "range-sum-of-sorted-subarray-sums",
        [],
        [
            "Array",
            "Sort"
        ]
    ],
    "Given a weighted undirected connected graph with n\u00a0vertices numbered from 0 to n-1,\u00a0and an array edges\u00a0where edges[i] = [fromi, toi, weighti] represents a bidirectional and weighted edge between nodes\u00a0fromi\u00a0and toi. A minimum spanning tree (MST) is a subset of the edges of the graph that connects all vertices without cycles\u00a0and with the minimum possible total edge weight.Find all the critical and pseudo-critical edges in the minimum spanning tree (MST) of the given graph. An MST edge whose deletion from the graph would cause the MST weight to increase is called a\u00a0critical edge. A pseudo-critical edge, on the other hand, is that which can appear in some MSTs but not all.": [
        "find-critical-and-pseudo-critical-edges-in-minimum-spanning-tree",
        [],
        [
            "Depth-first Search",
            "Union Find"
        ]
    ],
    "Your country has an infinite number of lakes. Initially, all the lakes are empty, but when it rains over the nth lake, the nth lake becomes full of water. If it rains over a lake which is full of water, there will be a flood. Your goal is to avoid the flood in any lake.Given an integer array rains where:rains[i] > 0 means there will be rains over the rains[i] lake.rains[i] == 0 means there are no rains this day and you can choose one lake this day and dry it.Return an array ans where:ans.length == rains.lengthans[i] == -1 if rains[i] > 0.ans[i] is the lake you choose to dry in the ith day\u00a0if rains[i] == 0.If there are multiple valid answers return any of them. If it is impossible to avoid flood return an empty array.Notice that if you chose to dry a full lake, it becomes empty, but if you chose to dry an empty lake, nothing changes. (see example 4)\u00a0": [
        "avoid-flood-in-the-city",
        [],
        [
            "Array",
            "Hash Table"
        ]
    ],
    "Given an array of strings names of size n. You will create n folders in your file system such that, at the ith minute, you will create a folder with the name names[i].Since two files cannot have the same name, if you enter a folder name which is previously used,\u00a0the system\u00a0will have a suffix\u00a0addition to its name in the form of (k),\u00a0where,\u00a0k is the smallest positive integer such that the obtained name remains unique.Return an array of strings of length n where ans[i] is the actual name the system will assign to the ith folder when you create it.\u00a0": [
        "making-file-names-unique",
        [],
        [
            "Hash Table",
            "String"
        ]
    ],
    "Given an integer n and an integer start.Define an array nums where nums[i] = start + 2*i (0-indexed) and n == nums.length.Return the bitwise\u00a0XOR\u00a0of all elements of nums.\u00a0": [
        "xor-operation-in-an-array",
        [],
        [
            "Array",
            "Bit Manipulation"
        ]
    ],
    "Given an integer array bloomDay, an integer m and an integer k.We need to make m\u00a0bouquets. To make a bouquet,\u00a0you need to use k adjacent flowers from the garden.The garden consists of n flowers, the ith flower will bloom in the bloomDay[i]\u00a0and then can be used in\u00a0exactly one bouquet.Return the minimum number of days you need to wait to be able to make m bouquets from the garden. If it is impossible to make m bouquets return -1.\u00a0": [
        "minimum-number-of-days-to-make-m-bouquets",
        [],
        [
            "Array",
            "Binary Search"
        ]
    ],
    "Given an array of integers\u00a0arr\u00a0and an integer k.\u00a0Find the least number of unique integers\u00a0after removing exactly k elements.\u00a0": [
        "least-number-of-unique-integers-after-k-removals",
        [],
        [
            "Array",
            "Sort"
        ]
    ],
    "Given an array nums. We define a running sum of an array as\u00a0runningSum[i] = sum(nums[0]\u2026nums[i]).Return the running sum of nums.\u00a0": [
        "running-sum-of-1d-array",
        [],
        [
            "Array"
        ]
    ],
    "Given the integer n representing the number of courses at some university labeled from 1 to n, and the array dependencies where dependencies[i] = [xi, yi] \u00a0represents a prerequisite relationship, that is, the course xi\u00a0must be taken before the course yi. \u00a0Also, you are given the\u00a0integer k.In one semester you can take at most k courses as long as you have taken all the prerequisites for the courses you are taking.Return the minimum number of semesters to take all courses.\u00a0It is guaranteed that you can take all courses in some way.\u00a0": [
        "parallel-courses-ii",
        [],
        [
            "Graph"
        ]
    ],
    "Given a binary array nums, you should delete one element from it.Return the size of the longest non-empty subarray containing only 1's\u00a0in the resulting array.Return 0 if there is no such subarray.\u00a0": [
        "longest-subarray-of-1s-after-deleting-one-element",
        [],
        [
            "Array"
        ]
    ],
    "Given two positive integers n and k.A factor of an integer n is defined as an integer i where n % i == 0.Consider a list of all factors of n\u00a0sorted in ascending order, return the kth factor in this list or return -1 if n has less than\u00a0k factors.\u00a0": [
        "the-kth-factor-of-n",
        [],
        [
            "Math"
        ]
    ],
    "Given an array of unique integers salary\u00a0where salary[i] is the salary of the employee i.Return the average salary of employees excluding the minimum and maximum salary.\u00a0": [
        "average-salary-excluding-the-minimum-and-maximum-salary",
        [],
        [
            "Array",
            "Sort"
        ]
    ],
    "There is\u00a0a row of\u00a0m\u00a0houses in a small city, each house must be painted with one of the\u00a0n\u00a0colors (labeled from 1 to n), some houses that has been painted last summer should not be painted again.A neighborhood is a maximal group of continuous houses that are painted with the same color. (": [
        "paint-house-iii",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "You have a browser of one tab where you start on the homepage and you can visit another url, get back in the history number of steps or move forward in the history number of steps.Implement the BrowserHistory class:BrowserHistory(string homepage) Initializes the object with the homepage\u00a0of the browser.void visit(string url)\u00a0Visits\u00a0url from the current page. It clears up all the forward history.string back(int steps)\u00a0Move steps back in history. If you can only return x steps in the history and steps > x, you will\u00a0return only x steps. Return the current url\u00a0after moving back in history at most steps.string forward(int steps)\u00a0Move steps forward in history. If you can only forward x steps in the history and steps > x, you will\u00a0forward only\u00a0x steps. Return the current url\u00a0after forwarding in history at most steps.\u00a0": [
        "design-browser-history",
        [],
        [
            "Design"
        ]
    ],
    "Given an array of integers arr\u00a0and an integer k.A value arr[i] is said to be stronger than a value arr[j] if |arr[i] - m| > |arr[j]\u00a0- m| where m is the median of the array.If |arr[i] - m| == |arr[j] - m|, then arr[i] is said to be stronger than arr[j] if arr[i] > arr[j].Return a list of the strongest k values in the array. return the answer in any arbitrary order.Median is the middle value in an ordered integer list. ": [
        "the-k-strongest-values-in-an-array",
        [],
        [
            "Array",
            "Sort"
        ]
    ],
    "Given the array nums consisting of 2n elements in the form [x1,x2,...,xn,y1,y2,...,yn].Return the array in the form [x1,y1,x2,y2,...,xn,yn].\u00a0": [
        "shuffle-the-array",
        [],
        [
            "Array"
        ]
    ],
    "Given 2n balls of k distinct colors. You will be given an integer array balls of size k where balls[i] is the number of balls of color i.\u00a0All the balls will be shuffled uniformly at random,\u00a0then we will distribute the first n balls to the first box and the remaining n balls to the other box (Please read the explanation of the second example carefully).Please note that the two boxes are considered different. ": [
        "probability-of-a-two-boxes-having-the-same-number-of-distinct-balls",
        [],
        [
            "Math",
            "Backtracking"
        ]
    ],
    "There are\u00a0n\u00a0cities numbered from\u00a00\u00a0to\u00a0n-1 and\u00a0n-1 roads such that\u00a0there is only one way to travel between two\u00a0different cities (this network form a tree).\u00a0Last year,\u00a0The ministry of transport\u00a0decided to orient the roads in one direction because they are too narrow.Roads are represented by\u00a0connections\u00a0where\u00a0connections[i] = [a, b]\u00a0represents a\u00a0road\u00a0from city\u00a0a\u00a0to\u00a0b.This year, there will be a big event in the capital (city 0), and many people want to travel to this city.Your task consists of reorienting\u00a0some roads such that each city can visit the city\u00a00. Return the minimum number of edges changed.It's guaranteed that each city can reach the city 0 after reorder.\u00a0": [
        "reorder-routes-to-make-all-paths-lead-to-the-city-zero",
        [],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given a rectangular cake with height h and width w, and two arrays of integers horizontalCuts and verticalCuts where horizontalCuts[i] is the distance from the top of the rectangular cake to the ith horizontal cut\u00a0and similarly, verticalCuts[j] is the distance from the\u00a0left of the rectangular cake to the jth\u00a0vertical cut.Return the maximum area of a piece of cake after you cut at each horizontal and vertical position provided in the arrays horizontalCuts and verticalCuts.\u00a0Since the answer can be a huge number, return this modulo 10^9 + 7.\u00a0": [
        "maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts",
        [],
        [
            "Array"
        ]
    ],
    "Given the array of integers nums, you will choose two different indices i and j of that array. Return the maximum value of (nums[i]-1)*(nums[j]-1).\u00a0": [
        "maximum-product-of-two-elements-in-an-array",
        [],
        [
            "Array"
        ]
    ],
    "Given an array of integers arr and an integer target.You have to find two non-overlapping sub-arrays of arr each with sum equal target. There can be multiple answers so you have to find an answer where the sum of the lengths of the two sub-arrays is minimum.Return the minimum sum of the lengths of the two required sub-arrays, or return -1 if you cannot\u00a0find such two sub-arrays.\u00a0": [
        "find-two-non-overlapping-sub-arrays-each-with-target-sum",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Implement the class SubrectangleQueries\u00a0which receives a rows x cols rectangle as a matrix of integers in the constructor and supports two methods:1.\u00a0updateSubrectangle(int row1, int col1, int row2, int col2, int newValue)Updates all values with newValue in the subrectangle whose upper left coordinate is (row1,col1) and bottom right coordinate is (row2,col2).2.\u00a0getValue(int row, int col)Returns the current value of the coordinate (row,col) from\u00a0the rectangle.\u00a0": [
        "subrectangle-queries",
        [],
        [
            "Array"
        ]
    ],
    "Given the array houses and an integer k. where houses[i] is the location of the ith house along a street, your task is to allocate k mailboxes in\u00a0the street.Return the minimum total distance between each house and its nearest mailbox.The answer is guaranteed to fit in a 32-bit signed integer.\u00a0": [
        "allocate-mailboxes",
        [],
        [
            "Math",
            "Dynamic Programming"
        ]
    ],
    "Given the array prices where prices[i] is the price of the ith item in a shop. There is a special discount for items in the shop, if you buy the ith item, then you will receive a discount equivalent to prices[j] where j is the minimum\u00a0index such that j > i and prices[j] <= prices[i], otherwise, you will not receive any discount at all.Return an array where the ith element is the final price you will pay for the ith item of the shop considering the special discount.\u00a0": [
        "final-prices-with-a-special-discount-in-a-shop",
        [],
        [
            "Array"
        ]
    ],
    "Given two arrays nums1\u00a0and nums2.Return the maximum dot product\u00a0between\u00a0non-empty subsequences of nums1 and nums2 with the same length.A subsequence of a array is a new array which is formed from the original array by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie,\u00a0[2,3,5]\u00a0is a subsequence of\u00a0[1,2,3,4,5]\u00a0while [1,5,3]\u00a0is not).\u00a0": [
        "max-dot-product-of-two-subsequences",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Given a binary tree where node values are digits from 1 to 9. A path in the binary tree is said to be pseudo-palindromic if at least one permutation of the node values in the path is a palindrome.Return the number of pseudo-palindromic paths going from the root node to leaf nodes.\u00a0": [
        "pseudo-palindromic-paths-in-a-binary-tree",
        [],
        [
            "Bit Manipulation",
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given a string s and an integer k.Return the maximum number of vowel letters in any substring of s\u00a0with\u00a0length k.Vowel letters in\u00a0English are\u00a0(a, e, i, o, u).\u00a0": [
        "maximum-number-of-vowels-in-a-substring-of-given-length",
        [],
        [
            "String",
            "Sliding Window"
        ]
    ],
    "Given a sentence\u00a0that consists of some words separated by a\u00a0single space, and a searchWord.You have to check if searchWord is a prefix of any word in sentence.Return the index of the word in sentence where searchWord is a prefix of this word (1-indexed).If searchWord is\u00a0a prefix of more than one word, return the index of the first word (minimum index). If there is no such word return -1.A prefix of a string\u00a0S is any leading contiguous substring of S.\u00a0": [
        "check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence",
        [],
        [
            "String"
        ]
    ],
    "You have a very large square wall and a circular dartboard placed on the wall.\u00a0You have been challenged to throw darts into the board blindfolded.\u00a0Darts thrown at the wall are represented as an array of\u00a0points on a 2D plane.\u00a0Return\u00a0the maximum number of points that are within or\u00a0lie\u00a0on\u00a0any circular dartboard of radius\u00a0r.\u00a0": [
        "maximum-number-of-darts-inside-of-a-circular-dartboard",
        [],
        [
            "Geometry"
        ]
    ],
    "Given the array favoriteCompanies where favoriteCompanies[i] is the list of favorites companies for the ith person (indexed from 0).Return the indices of people whose list of favorite companies is not a subset of any other list of favorites companies. You must return the indices\u00a0in increasing order.\u00a0": [
        "people-whose-list-of-favorite-companies-is-not-a-subset-of-another-list",
        [],
        [
            "String",
            "Sort"
        ]
    ],
    "Given a sentence\u00a0text (A\u00a0sentence\u00a0is a string of space-separated words) in the following format:First letter is in upper case.Each word in text are separated by a single space.Your task is to rearrange the words in text such that\u00a0all words are rearranged in an increasing order of their lengths. If two words have the same length, arrange them in their original order.Return the new text\u00a0following the format shown above.\u00a0": [
        "rearrange-words-in-a-sentence",
        [],
        [
            "String",
            "Sort"
        ]
    ],
    "Given two integer arrays startTime and endTime and given an integer queryTime.The ith student started doing their homework at the time startTime[i] and finished it at time endTime[i].Return the number of students doing their homework at time queryTime. ": [
        "number-of-students-doing-homework-at-a-given-time",
        [],
        [
            "Array"
        ]
    ],
    "Given a rows x cols matrix grid representing a field of cherries.\u00a0Each cell in\u00a0grid\u00a0represents the number of cherries that you can collect.You have two\u00a0robots that can collect cherries for you, Robot #1 is located at the top-left corner (0,0) , and Robot #2 is located at the top-right corner (0, cols-1) of the grid.Return the maximum number of cherries collection using both robots\u00a0 by following the rules below:From a cell (i,j), robots can move to cell (i+1, j-1) , (i+1, j) or (i+1, j+1).When any robot is passing through a cell, It picks it up all cherries, and the cell becomes an empty cell (0).When both robots stay on the same cell, only one of them takes the cherries.Both robots cannot move outside of the grid at\u00a0any moment.Both robots should reach the bottom row in the grid.\u00a0": [
        "cherry-pickup-ii",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "There are a total of n courses you have to take, labeled from 0 to n-1.Some courses may have direct prerequisites, for example, to take course 0 you have first to take course 1, which is expressed as a pair: [1,0]Given the total number of courses n,\u00a0a list of direct\u00a0prerequisite pairs and a list of queries pairs.You should answer for each queries[i] whether the course queries[i][0] is a\u00a0prerequisite of the course\u00a0queries[i][1] or not.Return a list of boolean, the answers to the given queries.Please note that if course a is a prerequisite of course b and course b is a prerequisite\u00a0of course c, then, course a is a\u00a0prerequisite of course c.\u00a0": [
        "course-schedule-iv",
        [],
        [
            "Graph"
        ]
    ],
    "Given a binary string s and an integer k.Return True if every\u00a0binary code\u00a0of length k is a substring of s. Otherwise, return False.\u00a0": [
        "check-if-a-string-contains-all-binary-codes-of-size-k",
        [],
        [
            "String",
            "Bit Manipulation"
        ]
    ],
    "Given two integer arrays of equal length target and arr.In one step, you can select any non-empty sub-array of arr and reverse it. You are allowed to make any number of steps.Return True if you can make arr equal to target, or False otherwise.\u00a0": [
        "make-two-arrays-equal-by-reversing-sub-arrays",
        [],
        [
            "Array"
        ]
    ],
    "Given a rectangular pizza represented as a rows x cols\u00a0matrix containing the following characters: 'A' (an apple) and '.' (empty cell) and given the integer k. You have to cut the pizza into k pieces using k-1 cuts.\u00a0For each cut you choose the direction: vertical or horizontal, then you choose a cut position at the cell boundary and cut the pizza into two pieces. If you cut the pizza vertically, give the left part of the pizza to a person. If you cut the pizza horizontally, give the upper part of the pizza to a person. Give the last piece of pizza to the last person.Return the number of ways of cutting the pizza such that each piece contains at least one apple.\u00a0Since the answer can be a huge number, return this modulo 10^9 + 7.\u00a0": [
        "number-of-ways-of-cutting-a-pizza",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Given an undirected tree consisting of n vertices numbered from 0 to n-1, which has some apples in their\u00a0vertices. You spend 1 second to walk over one\u00a0edge of the tree.\u00a0Return the minimum time in seconds\u00a0you have to spend\u00a0in order to collect all apples in the tree starting at vertex 0 and coming back to this vertex.The edges of the undirected tree are given in the array edges, where edges[i] = [fromi, toi] means that exists an edge connecting the vertices fromi and toi. Additionally, there is\u00a0a boolean array hasApple, where hasApple[i] = true\u00a0means that\u00a0vertex i has an apple, otherwise, it does not have any apple.\u00a0": [
        "minimum-time-to-collect-all-apples-in-a-tree",
        [],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given an array of\u00a0integers arr.We want to select three indices i, j and k where (0 <= i < j <= k < arr.length).Let's define a and b as follows:a = arr[i] ^ arr[i + 1] ^ ... ^ arr[j - 1]b = arr[j] ^ arr[j + 1] ^ ... ^ arr[k]": [
        "count-triplets-that-can-form-two-arrays-of-equal-xor",
        [],
        [
            "Array",
            "Math",
            "Bit Manipulation"
        ]
    ],
    "Given an array target and\u00a0an integer n. In each iteration, you will read a number from \u00a0list = {1,2,3..., n}.Build the target\u00a0array\u00a0using the following operations:Push: Read a new element from the beginning\u00a0list, and push it in the array.Pop: delete the last element of\u00a0the array.If the target array is already\u00a0built, stop reading more elements.You are guaranteed that the target array is strictly\u00a0increasing, only containing\u00a0numbers between 1 to n\u00a0inclusive.Return the operations to build the target array.You are guaranteed that the answer is unique.\u00a0": [
        "build-an-array-with-stack-operations",
        [],
        [
            "Stack"
        ]
    ],
    "You are given an\u00a0m\u00a0* n\u00a0matrix,\u00a0mat, and an integer k,\u00a0which\u00a0has its rows sorted in non-decreasing\u00a0order.You are allowed to choose exactly 1 element from each row to form an array.\u00a0Return the Kth smallest array sum among all possible arrays.\u00a0": [
        "find-the-kth-smallest-sum-of-a-matrix-with-sorted-rows",
        [],
        [
            "Heap"
        ]
    ],
    "Given an\u00a0array of integers nums and an\u00a0integer limit, return the size of the longest non-empty subarray such that the absolute difference between any two elements of this subarray is less than or equal to\u00a0limit.\u00a0": [
        "longest-continuous-subarray-with-absolute-diff-less-than-or-equal-to-limit",
        [],
        [
            "Array",
            "Sliding Window"
        ]
    ],
    "Given an array nums of 0s and 1s and an integer k, return True if all 1's are at least k places away from each other, otherwise return False.\u00a0": [
        "check-if-all-1s-are-at-least-length-k-places-away",
        [],
        [
            "Array"
        ]
    ],
    "You are given the array paths, where paths[i] = [cityAi, cityBi] means there\u00a0exists a direct path going from cityAi to cityBi. Return the destination city, that is, the city without any path outgoing to another city.It is guaranteed that the graph of paths forms a line without any loop, therefore, there will be exactly one destination city.\u00a0": [
        "destination-city",
        [],
        [
            "String"
        ]
    ],
    "Given an array of integers cost and an integer target. Return the maximum integer you can paint\u00a0under the following rules:The cost of painting a\u00a0digit (i+1) is given by\u00a0cost[i]\u00a0(0 indexed).The total cost used must\u00a0be equal to target.Integer does not have digits 0.Since the answer may be too large, return it as string.If there is no way to paint any integer given the condition, return \"0\".\u00a0": [
        "form-largest-integer-with-digits-that-add-up-to-target",
        [],
        [
            "String",
            "Dynamic Programming"
        ]
    ],
    "Given a binary tree root, a node X in the tree is named\u00a0good if in the path from root to X there are no nodes with a value greater than X.Return the number of good nodes in the binary tree.\u00a0": [
        "count-good-nodes-in-binary-tree",
        [],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given an integer n, return a list of all simplified fractions between 0 and 1 (exclusive) such that the denominator is less-than-or-equal-to n. The fractions can be in any order.\u00a0": [
        "simplified-fractions",
        [],
        [
            "Math"
        ]
    ],
    "Given a string s, the power of the string is the maximum length of a non-empty substring that\u00a0contains only one unique character.Return the power\u00a0of the string.\u00a0": [
        "consecutive-characters",
        [
            "max-consecutive-ones"
        ],
        [
            "String"
        ]
    ],
    "Given a list of lists of integers,\u00a0nums,\u00a0return all elements of nums in diagonal order as shown in the below images.\u00a0": [
        "diagonal-traverse-ii",
        [],
        [
            "Array",
            "Sort"
        ]
    ],
    "There are several cards\u00a0arranged in a row, and each card has an associated number of points\u00a0The points are given in the integer array\u00a0cardPoints.In one step, you can take one card from the beginning or from the end of the row. You have to take exactly k cards.Your score is the sum of the points of the cards you have taken.Given the integer array cardPoints and the integer k, return the maximum score you can obtain.\u00a0": [
        "maximum-points-you-can-obtain-from-cards",
        [],
        [
            "Array",
            "Dynamic Programming",
            "Sliding Window"
        ]
    ],
    "Given a\u00a0string s\u00a0of zeros and ones, return the maximum score after splitting the string into two non-empty substrings (i.e. left substring and right substring).The score after splitting a string is the number of zeros in the left substring plus the number of ones in the right substring.\u00a0": [
        "maximum-score-after-splitting-a-string",
        [],
        [
            "String"
        ]
    ],
    "Given three integers n, m and k. Consider the following algorithm to find the maximum element of an array of positive integers:You should build the array arr which has the following properties:arr has exactly n integers.1 <= arr[i] <= m where (0 <= i < n).After applying the mentioned algorithm to arr, the value search_cost is equal to k.Return the number of ways to build the array arr under the mentioned conditions.\u00a0As the answer may grow large, the answer\u00a0must be\u00a0computed modulo\u00a010^9 + 7.\u00a0": [
        "build-array-where-you-can-find-the-maximum-exactly-k-comparisons",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Given the string croakOfFrogs, which represents a combination of the string \"croak\" from different frogs, that is, multiple frogs can croak at the same time, so multiple \u201ccroak\u201d are mixed.\u00a0Return the minimum number of different frogs to finish all the croak in the given string.A valid \"croak\"\u00a0means a frog is printing 5 letters \u2018c\u2019, \u2019r\u2019, \u2019o\u2019, \u2019a\u2019, \u2019k\u2019\u00a0sequentially.\u00a0The frogs have to print all five letters to finish a croak.\u00a0If the given string is not a combination of valid\u00a0\"croak\"\u00a0return -1.\u00a0": [
        "minimum-number-of-frogs-croaking",
        [],
        [
            "String"
        ]
    ],
    "Given\u00a0the array orders, which represents the orders that customers have done in a restaurant. More specifically\u00a0orders[i]=[customerNamei,tableNumberi,foodItemi] where customerNamei is the name of the customer, tableNumberi\u00a0is the table customer sit at, and foodItemi\u00a0is the item customer orders.Return the restaurant's \u201cdisplay table\u201d. The \u201cdisplay table\u201d is a table whose row entries denote how many of each food item each table ordered. The first column is the table number and the remaining columns correspond to each food item in alphabetical order. The first row should be a header whose first column is \u201cTable\u201d, followed by the names of the food items. ": [
        "display-table-of-food-orders-in-a-restaurant",
        [],
        [
            "Hash Table"
        ]
    ],
    "Given alphanumeric string s. (Alphanumeric string is a string consisting of lowercase English letters and digits).You have to find a permutation of\u00a0the string where no letter is followed by another letter and no digit is followed by another digit. That is, no two adjacent characters have the same type.Return the reformatted string or return an empty string if it is impossible to reformat the string.\u00a0": [
        "reformat-the-string",
        [],
        [
            "String"
        ]
    ],
    "There are\u00a0n people\u00a0and 40 types of hats labeled from 1 to 40.Given a list of list of integers hats, where hats[i]\u00a0is a list of all hats preferred\u00a0by the i-th person.Return the number of ways that the n people wear different hats to each other.Since the answer\u00a0may be too large,\u00a0return it modulo\u00a010^9 + 7.\u00a0": [
        "number-of-ways-to-wear-different-hats-to-each-other",
        [],
        [
            "Dynamic Programming",
            "Bit Manipulation"
        ]
    ],
    "Given two strings: s1 and s2 with the same\u00a0size, check if some\u00a0permutation of string s1 can break\u00a0some\u00a0permutation of string s2 or vice-versa (in other words s2 can break s1).A string x\u00a0can break\u00a0string y\u00a0(both of size n) if x[i] >= y[i]\u00a0(in alphabetical order)\u00a0for all i\u00a0between 0 and n-1.\u00a0": [
        "check-if-a-string-can-break-another-string",
        [],
        [
            "String",
            "Greedy"
        ]
    ],
    "You are given an integer num. You will apply the following steps exactly two times:Pick a digit x (0\u00a0<= x <= 9).Pick another digit y (0\u00a0<= y <= 9). The digit y can be equal to x.Replace all the occurrences of x in the decimal representation of num by y.The new integer cannot have any leading zeros, also the new integer cannot be 0.Let a\u00a0and b\u00a0be the results of applying the operations to num the first and second times, respectively.Return the max difference between a and b.\u00a0": [
        "max-difference-you-can-get-from-changing-an-integer",
        [],
        [
            "String"
        ]
    ],
    "Given the array candies and the integer extraCandies, where candies[i] represents the number of candies that the ith kid has.For each kid check if there is a way to distribute extraCandies among the kids such that he or she can have the greatest number of candies among them.\u00a0Notice that multiple kids can have the greatest number of candies.\u00a0": [
        "kids-with-the-greatest-number-of-candies",
        [],
        [
            "Array"
        ]
    ],
    "You have a grid of size n x 3 and you want to paint each cell of the grid with exactly\u00a0one of the three colours: Red, Yellow or Green\u00a0while making sure that no two adjacent cells have\u00a0the same colour (i.e no two cells that share vertical or horizontal sides have the same colour).You are given n the number of rows of the grid.Return the number of ways you can paint this grid. As the answer may grow large, the answer must be computed modulo\u00a010^9 + 7.\u00a0": [
        "number-of-ways-to-paint-n-3-grid",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "HTML entity parser is the parser that takes HTML code as input and replace all the entities of the special characters by the characters itself.The special characters and their entities for HTML are:Quotation Mark:\u00a0the entity is &quot; and\u00a0symbol character is \".Single Quote\u00a0Mark:\u00a0the entity is &apos; and\u00a0symbol character is '.Ampersand:\u00a0the entity is &amp; and symbol character is &.Greater Than Sign:\u00a0the entity is &gt;\u00a0and symbol character is >.Less Than Sign:\u00a0the entity is &lt;\u00a0and symbol character is <.Slash:\u00a0the entity is &frasl; and\u00a0symbol character is /.Given the input text string to the HTML parser, you have to implement the entity parser.Return the text after replacing the entities by the special characters.\u00a0": [
        "html-entity-parser",
        [],
        [
            "String",
            "Stack"
        ]
    ],
    "Given the array queries of positive integers between 1 and m, you have to process all queries[i] (from i=0 to i=queries.length-1) according to the following rules:In the beginning, you have the permutation P=[1,2,3,...,m].For the current i, find the position of queries[i] in the permutation P (indexing from 0) and then move this at the beginning of the permutation P.\u00a0Notice that the position of queries[i] in P is the result for queries[i].Return an array containing the result for the given queries.\u00a0": [
        "queries-on-a-permutation-with-key",
        [],
        [
            "Array"
        ]
    ],
    "Given an array of string words. Return all strings in words which is substring of another word in any order.\u00a0String words[i] is substring of words[j],\u00a0if\u00a0can be obtained removing some characters to left and/or right side of words[j].\u00a0": [
        "string-matching-in-an-array",
        [],
        [
            "String"
        ]
    ],
    "Alice and Bob continue their\u00a0games with piles of stones. There are several stones\u00a0arranged in a row, and each stone has an associated\u00a0value which is an integer given in the array\u00a0stoneValue.Alice and Bob take turns, with Alice starting first. On each player's turn, that player\u00a0can take 1, 2 or 3 stones\u00a0from\u00a0the first remaining stones in the row.The score of each player is the sum of values of the stones taken. The score of each player is 0\u00a0initially.The objective of the game is to end with the highest score, and the winner is the player with the highest score and there could be a tie. The game continues until all the stones have been taken.Assume\u00a0Alice\u00a0and Bob\u00a0play optimally.Return \"Alice\" if\u00a0Alice will win, \"Bob\" if Bob will win or \"Tie\" if they end the game with the same score.\u00a0": [
        "stone-game-iii",
        [
            "stone-game-v"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Given a number\u00a0s in their binary representation. Return the number of steps to reduce it to 1 under the following rules:If the current number is even, you have to divide it by 2.If the current number is odd, you have to add 1 to it.It's guaranteed that you can always reach to one for all testcases.\u00a0": [
        "number-of-steps-to-reduce-a-number-in-binary-representation-to-one",
        [],
        [
            "String",
            "Bit Manipulation"
        ]
    ],
    "Given the array nums, obtain a subsequence of the array whose sum of elements is strictly greater than the sum of the non\u00a0included elements in such subsequence.\u00a0If there are multiple solutions, return the subsequence with minimum size and if there still exist multiple solutions, return the subsequence with the maximum total sum of all its elements. A subsequence of an array can be obtained by erasing some (possibly zero) elements from the array.\u00a0": [
        "minimum-subsequence-in-non-increasing-order",
        [],
        [
            "Greedy",
            "Sort"
        ]
    ],
    "A program was supposed to print an array of integers. The program forgot to print whitespaces and the array is printed as a string of digits and all we know is that all integers in the array were in the range\u00a0[1, k]\u00a0and there are no leading zeros in the array.Given the string s and the integer k. There can be multiple ways to restore the array.Return the number of possible array that can be printed as a string s\u00a0using the mentioned program.The number of ways could be very large so return it modulo 10^9 + 7\u00a0": [
        "restore-the-array",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "A happy string is a string that:consists only of letters of the set ['a', 'b', 'c'].s[i] != s[i + 1]\u00a0for all values of i from 1 to s.length - 1 (string is 1-indexed).": [
        "the-k-th-lexicographical-string-of-all-happy-strings-of-length-n",
        [],
        [
            "Backtracking"
        ]
    ],
    "Given the number k, return the minimum number of Fibonacci numbers whose sum is equal to k, whether a Fibonacci number could be used multiple times.The Fibonacci numbers are defined as:F1 = 1F2 = 1Fn = Fn-1 + Fn-2 , for n > 2.It is guaranteed that for the given constraints we can always find such fibonacci numbers that sum k.\u00a0": [
        "find-the-minimum-number-of-fibonacci-numbers-whose-sum-is-k",
        [],
        [
            "Array",
            "Greedy"
        ]
    ],
    "Given an array of integers\u00a0nums, you start with an initial positive value startValue.In each iteration, you calculate the step by step sum of startValue\u00a0plus\u00a0elements in nums\u00a0(from left to right).Return the minimum positive value of\u00a0startValue such that the step by step sum is never less than 1.\u00a0": [
        "minimum-value-to-get-positive-step-by-step-sum",
        [],
        [
            "Array"
        ]
    ],
    "Given the strings s1 and s2 of size n, and the string evil. Return the number of good strings.A good string has size n, it is alphabetically greater than or equal to s1, it is alphabetically smaller than or equal to s2, and it does not contain the string evil as a substring. Since the answer can be a huge number, return this modulo 10^9 + 7.\u00a0": [
        "find-all-good-strings",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Implement the class UndergroundSystem that supports three methods:1.\u00a0checkIn(int id, string stationName, int t)A customer with id card equal to id, gets in the station stationName at time t.A customer\u00a0can only be checked into one place at a time.2.\u00a0checkOut(int id, string stationName, int t)A customer with id card equal to id, gets out from the station stationName at time t.3.\u00a0getAverageTime(string startStation, string endStation)\u00a0Returns the average time to travel between the startStation and the endStation.The average time is computed from all the previous traveling from startStation to endStation that happened directly.Call to getAverageTime is always valid.You can assume all calls to checkIn and checkOut methods are consistent. That is, if a customer gets in at time t1 at some station, then it gets out at time t2 with t2 > t1.\u00a0All events happen in chronological order.\u00a0": [
        "design-underground-system",
        [],
        [
            "Design"
        ]
    ],
    "There are\u00a0n\u00a0soldiers standing in a line. Each soldier is assigned a unique rating value.You have to form a team of 3 soldiers\u00a0amongst them under the following rules:Choose 3 soldiers with index (i, j, k) with\u00a0rating (rating[i], rating[j], rating[k]).A team is valid if:\u00a0 (rating[i] < rating[j] < rating[k]) or (rating[i] > rating[j] > rating[k]) where (0\u00a0<= i <\u00a0j <\u00a0k <\u00a0n).Return the number of teams you can form given the conditions. (soldiers can be part of multiple teams).\u00a0": [
        "count-number-of-teams",
        [],
        [
            "Array"
        ]
    ],
    "Given an array of integers arr, a lucky integer is an integer which has a frequency in the array equal to its value.Return a lucky integer\u00a0in the array. If there are multiple lucky integers return the largest of them. If there is no lucky\u00a0integer return -1.\u00a0": [
        "find-lucky-integer-in-an-array",
        [],
        [
            "Array"
        ]
    ],
    "A string is called a\u00a0happy prefix\u00a0if is a non-empty prefix which is also a suffix (excluding itself).Given a string s. Return the longest happy prefix\u00a0of s\u00a0.Return an empty string if no such prefix exists.\u00a0": [
        "longest-happy-prefix",
        [],
        [
            "String"
        ]
    ],
    "Given a m x n grid. Each cell of the grid represents a street. The street of\u00a0grid[i][j] can be:1 which means a street connecting the left cell and the right cell.2 which means a street connecting the upper cell and the lower cell.3\u00a0which means a street connecting the left cell and the lower cell.4 which means a street connecting the right cell and the lower cell.5 which means a street connecting the left cell and the upper cell.6 which means a street connecting the right cell and the upper cell.You will initially start at the street of the\u00a0upper-left cell (0,0). A valid path in the grid is a path which starts from the upper left\u00a0cell (0,0) and ends at the bottom-right\u00a0cell (m - 1, n - 1). The path should only follow the streets.Notice that you are not allowed to change any street.Return true\u00a0if there is a valid path in the grid or false otherwise.\u00a0": [
        "check-if-there-is-a-valid-path-in-a-grid",
        [],
        [
            "Depth-first Search",
            "Breadth-first Search"
        ]
    ],
    "Given two arrays of integers\u00a0nums and index. Your task is to create target array under the following rules:Initially target array is empty.From left to right read nums[i] and index[i], insert at index index[i]\u00a0the value nums[i]\u00a0in\u00a0target array.Repeat the previous step until there are no elements to read in nums and index.Return the target array.It is guaranteed that the insertion operations will be valid.\u00a0": [
        "create-target-array-in-the-given-order",
        [],
        [
            "Array"
        ]
    ],
    "A chef\u00a0has collected data on the satisfaction level of his\u00a0n dishes.\u00a0Chef can cook any dish in 1 unit of time.Like-time coefficient\u00a0of a dish is defined as\u00a0the time taken to cook that dish including previous dishes multiplied by its satisfaction level \u00a0i.e.\u00a0 time[i]*satisfaction[i]Return\u00a0the maximum sum of\u00a0Like-time coefficient that the chef can obtain after dishes preparation.Dishes can be prepared in any order and the chef can discard some dishes to get this maximum value.\u00a0": [
        "reducing-dishes",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Given a string s and an integer k. You should construct k non-empty palindrome strings using all the characters in s.Return True if you can use all the characters in s to construct k palindrome strings or False otherwise.\u00a0": [
        "construct-k-palindrome-strings",
        [],
        [
            "Greedy"
        ]
    ],
    "Given a circle represented as (radius, x_center, y_center)\u00a0and an axis-aligned rectangle represented as (x1, y1, x2, y2),\u00a0where (x1, y1) are the coordinates of the bottom-left corner, and (x2, y2) are the coordinates of the top-right corner of the\u00a0rectangle.Return True if the circle and rectangle are overlapped otherwise return False.In other words, check if there are any point\u00a0(xi, yi) such that belongs to the circle and the rectangle at the same time.\u00a0": [
        "circle-and-rectangle-overlapping",
        [],
        [
            "Geometry"
        ]
    ],
    "Given an integer\u00a0n.\u00a0Each number from 1 to n is grouped according to the sum of its digits.\u00a0Return\u00a0how many groups have the largest size.\u00a0": [
        "count-largest-group",
        [],
        [
            "Array"
        ]
    ],
    "There are n engineers numbered from 1 to n\u00a0and\u00a0two arrays: speed\u00a0and efficiency, where speed[i] and efficiency[i] represent the speed and efficiency for the i-th engineer respectively. Return the maximum performance of a team composed of\u00a0at most\u00a0k\u00a0engineers, since the answer can be a huge number, return this modulo\u00a010^9 + 7.The performance of a team is the sum of their engineers' speeds multiplied by the minimum efficiency among\u00a0their engineers.\u00a0\u00a0": [
        "maximum-performance-of-a-team",
        [],
        [
            "Greedy",
            "Sort"
        ]
    ],
    "Given two binary trees original and cloned and given a reference to a node target in the original tree.The cloned tree is a copy of the original tree.Return a reference to the same node in the cloned tree.": [
        "find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree",
        [],
        [
            "Tree"
        ]
    ],
    "Design a stack which supports the following operations.Implement the CustomStack class:CustomStack(int maxSize) Initializes the object with maxSize which is the maximum number of elements in the stack or do nothing if the stack reached the maxSize.void push(int x)\u00a0Adds x to the top of the stack if the stack hasn't reached the maxSize.int pop()\u00a0Pops and returns the top of stack or -1 if the stack is empty.void inc(int k, int val) Increments the bottom k elements of the stack by val. If there are less than k elements in the stack, just increment all the elements in the stack.\u00a0": [
        "design-a-stack-with-increment-operation",
        [],
        [
            "Stack",
            "Design"
        ]
    ],
    "Given a m * n matrix of distinct numbers, return all lucky numbers in the\u00a0matrix in any order.A lucky number is an element of the matrix such that it is the minimum element in its row and maximum in its column.\u00a0": [
        "lucky-numbers-in-a-matrix",
        [],
        [
            "Array"
        ]
    ],
    "Given an undirected tree\u00a0consisting of n vertices numbered from 1 to n. A frog starts jumping\u00a0from the vertex 1. In one second, the frog\u00a0jumps from its\u00a0current\u00a0vertex to another unvisited vertex if they are directly connected. The frog can not jump back to a visited vertex.\u00a0In case the frog can jump to several vertices it jumps randomly to one of them with the same probability, otherwise, when the frog can not jump to any unvisited vertex it jumps forever on the same vertex.\u00a0The edges of the undirected tree\u00a0are given in the array edges, where edges[i] = [fromi, toi] means that exists an edge connecting directly the vertices fromi and toi.Return the probability that after t seconds the frog is on the vertex target.\u00a0": [
        "frog-position-after-t-seconds",
        [],
        [
            "Depth-first Search"
        ]
    ],
    "A company has n employees with a unique ID for each employee from 0 to n - 1. The head of the company has is the one with headID.Each employee has one\u00a0direct manager given in the manager array where manager[i] is the direct manager of the i-th employee,\u00a0manager[headID] = -1. Also it's guaranteed that the subordination relationships have a tree structure.The head of the company wants to inform all the employees of the company of an urgent piece of news. He will inform his direct subordinates and they will inform their subordinates and so on until all employees know about the urgent news.The i-th employee needs informTime[i] minutes to inform all of his direct subordinates (i.e After informTime[i] minutes, all his direct subordinates can start spreading the news).Return the number of minutes needed to inform all the employees about the urgent news.\u00a0": [
        "time-needed-to-inform-all-employees",
        [
            "binary-tree-maximum-path-sum",
            "maximum-depth-of-binary-tree"
        ],
        [
            "Depth-first Search"
        ]
    ],
    "There is a room with n bulbs, numbered from 1 to n, arranged in a row from left to right. Initially, all the bulbs are turned off.At moment k (for k from 0 to n - 1), we turn on the light[k] bulb. A bulb change\u00a0color to blue only if it is on and all the previous bulbs (to the left)\u00a0are turned on too.Return the number of moments in\u00a0which all\u00a0turned on bulbs\u00a0are blue.\u00a0": [
        "bulb-switcher-iii",
        [
            "bulb-switcher-ii",
            "bulb-switcher"
        ],
        [
            "Array"
        ]
    ],
    "Given an\u00a0integer n, return a string with n\u00a0characters such that each character in such string occurs an odd number of times.The returned string must contain only lowercase English letters. If there are multiples valid strings, return any of them. \u00a0\u00a0": [
        "generate-a-string-with-characters-that-have-odd-counts",
        [],
        [
            "String"
        ]
    ],
    "There is a pizza with 3n slices of varying size, you and your friends will take slices of pizza as follows:You will pick any pizza slice.Your friend Alice\u00a0will pick\u00a0next slice in anti clockwise direction of your pick.\u00a0Your friend Bob\u00a0will\u00a0pick\u00a0next slice in clockwise direction of your pick.Repeat\u00a0until\u00a0there are no more slices of pizzas.Sizes of Pizza slices is represented by circular array slices in clockwise direction.Return the maximum possible sum of slice sizes which you can have.\u00a0": [
        "pizza-with-3n-slices",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "The power of an integer x is defined as the number of steps needed to transform\u00a0x into 1 using the following steps:if x is even then x = x / 2if x is odd then x = 3 * x + 1": [
        "sort-integers-by-the-power-value",
        [],
        [
            "Sort",
            "Graph"
        ]
    ],
    "A cinema\u00a0has n\u00a0rows of seats, numbered from 1 to n\u00a0and there are ten\u00a0seats in each row, labelled from 1\u00a0to 10\u00a0as shown in the figure above.Given the array reservedSeats containing the numbers of seats already reserved, for example, reservedSeats[i] = [3,8]\u00a0means the seat located in row 3 and labelled with 8\u00a0is already reserved.Return the maximum number of four-person groups\u00a0you can assign on the cinema\u00a0seats. A four-person group\u00a0occupies four\u00a0adjacent seats in one single row. Seats across an aisle (such as [3,3]\u00a0and [3,4]) are not considered to be adjacent, but there is an exceptional case\u00a0on which an aisle split\u00a0a four-person group, in that case, the aisle split\u00a0a four-person group in the middle,\u00a0which means to have two people on each side.\u00a0": [
        "cinema-seat-allocation",
        [],
        [
            "Array",
            "Greedy"
        ]
    ],
    "Given two integer arrays arr1 and arr2, and the integer d, return the distance value between the two\u00a0arrays.The distance value is defined as the number of elements arr1[i] such that there is not any element arr2[j] where |arr1[i]-arr2[j]| <= d.\u00a0": [
        "find-the-distance-value-between-two-arrays",
        [],
        [
            "Array"
        ]
    ],
    "Given a m x n grid. Each cell of the grid has a sign pointing to the next cell you should visit if you are currently in this cell. The sign of grid[i][j] can be:1 which means go to the cell to the right. (i.e go from grid[i][j] to grid[i][j + 1])2 which means go to the cell to the left. (i.e go from grid[i][j] to grid[i][j - 1])3 which means go to the lower cell. (i.e go from grid[i][j] to grid[i + 1][j])4 which means go to the upper cell. (i.e go from grid[i][j] to grid[i - 1][j])Notice\u00a0that there could be some invalid signs on the cells of the grid which points outside the grid.You will initially start at the upper left cell (0,0). A valid path in the grid is a path which starts from the upper left\u00a0cell (0,0) and ends at the bottom-right\u00a0cell (m - 1, n - 1) following the signs on the grid. The valid path doesn't have to be the shortest.You can modify the sign on a cell with cost = 1. You can modify the sign on a cell one time only.Return the minimum cost to make the grid have at least one valid path.\u00a0": [
        "minimum-cost-to-make-at-least-one-valid-path-in-a-grid",
        [],
        [
            "Breadth-first Search"
        ]
    ],
    "Given a binary tree root and a\u00a0linked list with\u00a0head\u00a0as the first node.\u00a0Return True if all the elements in the linked list starting from the head correspond to some downward path connected in the binary tree\u00a0otherwise return False.In this context downward path means a path that starts at some node and goes downwards.\u00a0": [
        "linked-list-in-binary-tree",
        [],
        [
            "Linked List",
            "Dynamic Programming",
            "Tree"
        ]
    ],
    "In a special ranking system,\u00a0each voter gives a rank from highest to lowest to all teams participated in the competition.The ordering of teams is decided by who received the most position-one votes. If two or more teams tie in the first position, we consider the second position to resolve the conflict, if they tie again, we continue this process until the ties are resolved. If two or more teams are still tied after considering all positions, we rank them alphabetically based on their team letter.Given an array of strings votes which is the votes of all voters in the ranking systems. Sort all teams according to the ranking system described above.Return a string of all teams sorted by the ranking system.\u00a0": [
        "rank-teams-by-votes",
        [
            "online-election"
        ],
        [
            "Array",
            "Sort"
        ]
    ],
    "Given the array nums, for each nums[i] find out how many numbers in the array are smaller than it. That is, for each nums[i] you have to count the number of valid j's\u00a0such that\u00a0j != i and nums[j] < nums[i].Return the answer in an array.\u00a0": [
        "how-many-numbers-are-smaller-than-the-current-number",
        [
            "count-of-smaller-numbers-after-self"
        ],
        [
            "Array",
            "Hash Table"
        ]
    ],
    "Given an array of integers\u00a0target. From a starting array, A\u00a0consisting of all 1's, you may perform the following procedure :let x be the sum of all elements currently in your array.choose index i, such that\u00a00 <= i < target.size and set the value of A at index i to x.You may repeat this procedure\u00a0as many times as needed.Return True if it is possible to construct the target array from A otherwise\u00a0return False.\u00a0": [
        "construct-target-array-with-multiple-sums",
        [],
        [
            "Greedy"
        ]
    ],
    "Given an array of events where events[i] = [startDayi, endDayi]. Every event i starts at\u00a0startDayi\u00a0and ends at\u00a0endDayi.You can attend an event i\u00a0at any day\u00a0d where\u00a0startTimei\u00a0<= d <= endTimei. Notice that you can only attend one event at any time d.Return the maximum number of events\u00a0you can attend.\u00a0": [
        "maximum-number-of-events-that-can-be-attended",
        [],
        [
            "Greedy",
            "Sort",
            "Segment Tree"
        ]
    ],
    "Implement the class ProductOfNumbers\u00a0that supports two methods:1.\u00a0add(int num)Adds the number num to the back of the current list of numbers.2. getProduct(int k)Returns the product of the last k numbers in the current list.You can assume that always the current list has at least k numbers.At any time, the product of any contiguous sequence of numbers will fit into a single 32-bit integer without overflowing.\u00a0": [
        "product-of-the-last-k-numbers",
        [],
        [
            "Array",
            "Design"
        ]
    ],
    "Given a m\u00a0* n\u00a0matrix grid\u00a0which is sorted in non-increasing order both row-wise and column-wise.\u00a0Return the number of negative numbers in\u00a0grid.\u00a0": [
        "count-negative-numbers-in-a-sorted-matrix",
        [],
        [
            "Array",
            "Binary Search"
        ]
    ],
    "Given a binary tree root, the task is to return the maximum sum of all keys of any\u00a0sub-tree which is also a Binary Search Tree (BST).Assume a BST is defined as follows:The left subtree of a node contains only nodes with keys\u00a0less than\u00a0the node's key.The right subtree of a node contains only nodes with keys\u00a0greater than\u00a0the node's key.Both the left and right subtrees must also be binary search trees.\u00a0": [
        "maximum-sum-bst-in-binary-tree",
        [],
        [
            "Dynamic Programming",
            "Binary Search Tree"
        ]
    ],
    "Given a binary tree root, a\u00a0ZigZag path for a binary tree is defined as follow:Choose any node in the binary tree and a direction (right or left).If the current direction is right then move to the right child of the current node otherwise move to the left child.Change the direction from right to left or right to left.Repeat the second and third step until you can't move in the tree.Zigzag length is defined as the number of nodes visited - 1. (A single node has a length of 0).Return\u00a0the longest ZigZag path contained in that tree.\u00a0": [
        "longest-zigzag-path-in-a-binary-tree",
        [],
        [
            "Dynamic Programming",
            "Tree"
        ]
    ],
    "Given the string s, return the size of the longest substring containing each vowel an even number of times. That is, 'a', 'e', 'i', 'o', and 'u' must appear an even number of times.\u00a0": [
        "find-the-longest-substring-containing-vowels-in-even-counts",
        [],
        [
            "String"
        ]
    ],
    "Given a string s. You should re-order the string using the following algorithm:Pick the smallest character from s and append it to the result.Pick the smallest character from s which is greater than the last appended character to the result and append it.Repeat step 2 until you cannot pick more characters.Pick the largest\u00a0character from s and append it to the result.Pick the largest\u00a0character from s which is smaller than the last appended character to the result and append it.Repeat step 5 until you cannot pick more characters.Repeat the steps from 1 to 6 until you pick all characters from s.In each step, If the smallest or the largest character appears more than once you can choose any occurrence and append it to the result.Return the result string after sorting s\u00a0with this algorithm.\u00a0": [
        "increasing-decreasing-string",
        [],
        [
            "String",
            "Sort"
        ]
    ],
    "Given a m\u00a0* n\u00a0matrix seats\u00a0\u00a0that represent seats distributions\u00a0in a classroom.\u00a0If a seat\u00a0is\u00a0broken, it is denoted by '#' character otherwise it is denoted by a '.' character.Students can see the answers of those sitting next to the left, right, upper left and upper right, but he cannot see the answers of the student sitting\u00a0directly in front or behind him. Return the maximum number of students that can take the exam together\u00a0without any cheating being possible..Students must be placed in seats in good condition.\u00a0": [
        "maximum-students-taking-exam",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Implement the class TweetCounts that supports two methods:1. recordTweet(string tweetName, int time)Stores the tweetName at the recorded time (in seconds).2. getTweetCountsPerFrequency(string freq, string tweetName, int startTime, int endTime)Returns the total number of occurrences for the given tweetName per minute, hour, or day (depending on freq) starting from the startTime (in seconds) and ending at the endTime (in seconds).freq is always minute, hour\u00a0or day, representing the time interval to get the total number of occurrences for the given\u00a0tweetName.The first time interval always starts from the startTime, so the time intervals are [startTime, startTime + delta*1>, \u00a0[startTime + delta*1, startTime + delta*2>, [startTime + delta*2, startTime + delta*3>, ... , [startTime + delta*i, min(startTime + delta*(i+1), endTime + 1)> for some non-negative number i and delta (which depends on freq).\u00a0\u00a0\u00a0": [
        "tweet-counts-per-frequency",
        [],
        [
            "Design"
        ]
    ],
    "Given two equal-size strings s and t. In one step you can choose any character of t and replace it with another character.Return the minimum number of steps to make t\u00a0an anagram of s.An\u00a0Anagram\u00a0of a\u00a0string\u00a0is a string that contains the same characters with a different (or the same) ordering.\u00a0": [
        "minimum-number-of-steps-to-make-two-strings-anagram",
        [],
        [
            "String"
        ]
    ],
    "Given an array arr of integers, check if there exists two integers N and M such that N is the double of M ( i.e. N = 2 * M).More formally check if there exists\u00a0two indices i and j such that :i != j0 <= i, j < arr.lengtharr[i] == 2 * arr[j]\u00a0": [
        "check-if-n-and-its-double-exist",
        [],
        [
            "Array"
        ]
    ],
    "Given an array of\u00a0integers arr and an integer d. In one step you can jump from index i to index:i + x where:\u00a0i + x < arr.length and  0 <\u00a0x <= d.i - x where:\u00a0i - x >= 0 and  0 <\u00a0x <= d.In addition, you can only jump from index i to index j\u00a0if arr[i] > arr[j] and arr[i] > arr[k] for all indices k between i and j (More formally min(i,\u00a0j) < k < max(i, j)).You can choose any index of the array and start jumping. Return the maximum number of indices\u00a0you can visit.Notice that you can not jump outside of the array at any time.\u00a0": [
        "jump-game-v",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Given a binary tree root.\u00a0Split the binary tree into two subtrees by removing\u00a01 edge such that the product of the sums of the subtrees are maximized.Since the answer\u00a0may be too large,\u00a0return it modulo\u00a010^9 + 7.\u00a0": [
        "maximum-product-of-splitted-binary-tree",
        [],
        [
            "Dynamic Programming",
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given an array arr.\u00a0 You can choose a set of integers and remove all the occurrences of these integers in the array.Return the minimum size of the set so that at least half of the integers of the array are removed.\u00a0": [
        "reduce-array-size-to-the-half",
        [],
        [
            "Array",
            "Greedy"
        ]
    ],
    "Given a m\u00a0* n\u00a0matrix mat of ones\u00a0(representing soldiers) and zeros\u00a0(representing civilians), return the indexes of the k weakest rows in the matrix ordered from the weakest to the strongest.A row i is weaker than row j, if the number of soldiers in row i is less than the number of soldiers in row j, or they have the same number of soldiers but i is less than j. Soldiers are always stand in the frontier of a row, that is, always ones\u00a0may appear first and then zeros.\u00a0": [
        "the-k-weakest-rows-in-a-matrix",
        [],
        [
            "Array",
            "Binary Search"
        ]
    ],
    "Given n orders, each order consist in pickup and delivery services.\u00a0Count all valid pickup/delivery possible sequences such that delivery(i) is always after of\u00a0pickup(i).\u00a0Since the answer\u00a0may be too large,\u00a0return it modulo\u00a010^9 + 7.\u00a0": [
        "count-all-valid-pickup-and-delivery-options",
        [],
        [
            "Math",
            "Dynamic Programming"
        ]
    ],
    "Given a string s\u00a0consisting only of characters a, b and c.Return the number of substrings containing at least\u00a0one occurrence of all these characters a, b and c.\u00a0": [
        "number-of-substrings-containing-all-three-characters",
        [],
        [
            "String"
        ]
    ],
    "There is\u00a0a sale in a supermarket, there will be a discount every n customer.There are some products in the supermarket where the id of the i-th product is products[i] and the price per unit of this product is\u00a0prices[i].The system will count the number of customers and when the n-th customer arrive he/she will have a discount on the bill. (i.e if the cost is x the new cost is x - (discount * x) / 100). Then the system will start counting customers again.The customer orders a certain amount of each product where product[i] is the id of the i-th product the customer ordered and amount[i] is the number of units the customer ordered of that product.Implement the Cashier class:Cashier(int n, int discount, int[] products, int[] prices) Initializes the object with n, the discount, the products\u00a0and their prices.double\u00a0getBill(int[] product, int[] amount)\u00a0returns the value of the bill and apply the discount if needed. Answers within 10^-5 of the actual value will be accepted as correct.\u00a0": [
        "apply-discount-every-n-orders",
        [],
        [
            "Design"
        ]
    ],
    "Given an integer array arr. You have to sort the integers in the array\u00a0in ascending order by the number of 1's\u00a0in their binary representation and in case of two or more integers have the same number of 1's you have to sort them in ascending order.Return the sorted array.\u00a0": [
        "sort-integers-by-the-number-of-1-bits",
        [],
        [
            "Sort",
            "Bit Manipulation"
        ]
    ],
    "You want to schedule a list of jobs in d days. Jobs are dependent (i.e To work on the i-th job, you have to finish all the jobs j where 0 <= j < i).You have to finish at least one task every day. The difficulty of a job schedule is the sum of difficulties of each day of the d days. The difficulty of a day is the maximum difficulty of a job done in that day.Given an array of integers jobDifficulty and an integer d. The difficulty of the i-th\u00a0job is\u00a0jobDifficulty[i].Return the minimum difficulty of a job schedule. If you cannot find a schedule for the jobs return -1.\u00a0": [
        "minimum-difficulty-of-a-job-schedule",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "There are n cities numbered from 0 to n-1. Given the array edges\u00a0where edges[i] = [fromi, toi, weighti] represents a bidirectional and weighted edge between cities fromi\u00a0and toi, and given the integer distanceThreshold.Return the city with the smallest number of\u00a0cities that are reachable through some path and whose distance is at most distanceThreshold, If there are multiple such cities, return the city with the greatest number.Notice that the distance of a path connecting cities i and j is equal to the sum of the edges' weights along that path.\u00a0": [
        "find-the-city-with-the-smallest-number-of-neighbors-at-a-threshold-distance",
        [],
        [
            "Graph"
        ]
    ],
    "Given the array restaurants where \u00a0restaurants[i] = [idi, ratingi, veganFriendlyi, pricei, distancei]. You have to filter the restaurants using three filters.The veganFriendly filter will be either true (meaning you should only include restaurants with veganFriendlyi set to true)\u00a0or false\u00a0(meaning you can include any restaurant). In addition, you have the filters\u00a0maxPrice and maxDistance\u00a0which\u00a0are the maximum value for price and distance of restaurants you should consider respectively.Return the array of restaurant IDs after filtering, ordered by rating from highest to lowest. For restaurants with the same rating, order them by id from highest to lowest. For simplicity veganFriendlyi and veganFriendly take value 1 when it is true, and 0 when it is false.\u00a0": [
        "filter-restaurants-by-vegan-friendly-price-and-distance",
        [],
        [
            "Array",
            "Sort"
        ]
    ],
    "Given a string s consisting only of\u00a0letters\u00a0'a' and 'b'. In a single step you can remove one\u00a0palindromic subsequence\u00a0from s.Return the minimum number of steps to make the given string empty.A string is a subsequence of a given string, if it is generated by deleting some characters of a given string without changing its order.A string is called palindrome if is one that reads the same backward as well as forward.\u00a0": [
        "remove-palindromic-subsequences",
        [],
        [
            "String"
        ]
    ],
    "There is a one-dimensional garden on the x-axis. The garden starts at the point 0 and ends at the point n. (i.e The length of the garden is n).There are\u00a0n + 1 taps located\u00a0at points [0, 1, ..., n] in the garden.Given an integer n and an integer array ranges of length n + 1 where ranges[i] (0-indexed) means the i-th tap can water the area [i - ranges[i], i + ranges[i]] if it was open.Return the minimum number of taps that should be open to water the whole garden, If the garden cannot be watered return -1.\u00a0": [
        "minimum-number-of-taps-to-open-to-water-a-garden",
        [],
        [
            "Dynamic Programming",
            "Greedy"
        ]
    ],
    "Given a binary tree\u00a0root\u00a0and an integer\u00a0target, delete all the\u00a0leaf nodes\u00a0with value target.Note\u00a0that once you delete a leaf node with value target,\u00a0if it's parent node becomes a leaf node and has the value target, it should also be deleted (you need to continue doing that until you can't).\u00a0": [
        "delete-leaves-with-a-given-value",
        [],
        [
            "Tree"
        ]
    ],
    "Given a string s.\u00a0Return\u00a0all the words vertically in the same order in which they appear in s.Words are returned as a list of strings, complete with\u00a0spaces when is necessary. (Trailing spaces are not allowed).Each word would be put on only one column and that in one column there will be only one word.\u00a0": [
        "print-words-vertically",
        [],
        [
            "String"
        ]
    ],
    "Given a positive integer num consisting only of digits 6 and 9.Return the maximum number you can get by changing at most one digit (6 becomes 9, and 9 becomes 6).\u00a0": [
        "maximum-69-number",
        [],
        [
            "Math"
        ]
    ],
    "Given an array of\u00a0integers arr, you are initially positioned at the first index of the array.In one step you can jump from index i to index:i + 1 where:\u00a0i + 1 < arr.length.i - 1 where:\u00a0i - 1 >= 0.j where: arr[i] == arr[j] and i != j.Return the minimum number of steps to reach the last index of the array.Notice that you can not jump outside of the array at any time.\u00a0": [
        "jump-game-iv",
        [],
        [
            "Breadth-first Search"
        ]
    ],
    "Given two numbers, hour and minutes. Return the smaller angle (in degrees) formed between the hour and the minute hand.\u00a0": [
        "angle-between-hands-of-a-clock",
        [],
        [
            "Math"
        ]
    ],
    "Given an array of integers arr and two integers k and threshold.Return the number of sub-arrays of size k and average greater than or equal to threshold.\u00a0": [
        "number-of-sub-arrays-of-size-k-and-average-greater-than-or-equal-to-threshold",
        [],
        [
            "Array"
        ]
    ],
    "Given a non-negative integer num, return the number of steps to reduce it to zero. If the current number is even, you have to divide it by 2, otherwise, you have to subtract 1 from it.\u00a0": [
        "number-of-steps-to-reduce-a-number-to-zero",
        [],
        [
            "Bit Manipulation"
        ]
    ],
    "You have a keyboard layout as shown above in the XY plane, where each English uppercase letter is located at some coordinate, for example, the letter A is located at coordinate (0,0), the letter B is located at coordinate (0,1), the letter P is located at coordinate (2,3) and the letter Z is located at coordinate (4,1).Given the string word, return the minimum total distance to type such string using only two\u00a0fingers. The distance between coordinates (x1,y1) and (x2,y2) is |x1 - x2| + |y1 - y2|.\u00a0": [
        "minimum-distance-to-type-a-word-using-two-fingers",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "There are\u00a0n\u00a0computers numbered from\u00a00\u00a0to\u00a0n-1\u00a0connected by\u00a0ethernet cables\u00a0connections\u00a0forming a network where\u00a0connections[i] = [a, b]\u00a0represents a connection between computers\u00a0a\u00a0and\u00a0b. Any computer\u00a0can reach any other computer directly or indirectly through the network.Given an initial computer network connections. You can extract certain cables between two directly connected computers, and place them between any pair of disconnected computers to make them directly connected. Return the minimum number of times you need to do this in order to make all the computers connected. If it's not possible, return -1.\u00a0\u00a0": [
        "number-of-operations-to-make-network-connected",
        [],
        [
            "Depth-first Search",
            "Breadth-first Search",
            "Union Find"
        ]
    ],
    "Given 3 positives numbers a, b and c. Return the minimum flips required in some bits of a and b to make (\u00a0a OR b == c\u00a0). (bitwise OR operation).Flip operation\u00a0consists of change\u00a0any\u00a0single bit 1 to 0 or change the bit 0 to 1\u00a0in their binary representation.\u00a0": [
        "minimum-flips-to-make-a-or-b-equal-to-c",
        [],
        [
            "Bit Manipulation"
        ]
    ],
    "Given an integer n. No-Zero integer is a positive integer which doesn't contain any 0 in its decimal representation.Return a list of two integers [A, B] where:A and B are No-Zero integers.A + B = nIt's guarateed that there is at least one valid solution. If there are many valid solutions you can return any of them.\u00a0": [
        "convert-integer-to-the-sum-of-two-no-zero-integers",
        [],
        [
            "Math"
        ]
    ],
    "Given a string s. In one step you can insert any character at any index of the string.Return the minimum number of steps to make s\u00a0palindrome.A\u00a0Palindrome String\u00a0is one that reads the same backward as well as forward.\u00a0": [
        "minimum-insertion-steps-to-make-a-string-palindrome",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "There are n people, each person has a unique id between 0 and n-1. Given the arrays watchedVideos and friends, where watchedVideos[i] and friends[i] contain the list of watched videos and the list of friends respectively for the person with id = i.Level 1 of videos are all watched videos by your\u00a0friends, level 2 of videos are all watched videos by the friends of your\u00a0friends and so on. In general, the level k of videos are all\u00a0watched videos by people\u00a0with the shortest path exactly equal\u00a0to\u00a0k with you. Given your\u00a0id and the level of videos, return the list of videos ordered by their frequencies (increasing). For videos with the same frequency order them alphabetically from least to greatest.\u00a0\u00a0": [
        "get-watched-videos-by-your-friends",
        [],
        [
            "Hash Table",
            "String",
            "Breadth-first Search"
        ]
    ],
    "Given the array arr of positive integers and the array queries where queries[i] = [Li,\u00a0Ri],\u00a0for each query i compute the XOR of elements from Li to Ri (that is, arr[Li] xor arr[Li+1] xor ... xor arr[Ri] ). Return an array containing the result for the given queries.\u00a0": [
        "xor-queries-of-a-subarray",
        [],
        [
            "Bit Manipulation"
        ]
    ],
    "Given a string s formed by digits ('0' - '9')\u00a0and '#'\u00a0.\u00a0We want to map s to English lowercase characters as follows:Characters ('a' to 'i') are\u00a0represented by\u00a0('1' to\u00a0'9')\u00a0respectively.Characters ('j' to 'z') are represented by ('10#'\u00a0to\u00a0'26#')\u00a0respectively.\u00a0Return the string formed after mapping.It's guaranteed that a unique mapping will always exist.\u00a0": [
        "decrypt-string-from-alphabet-to-integer-mapping",
        [],
        [
            "String"
        ]
    ],
    "Given an equation, represented by words on left side and the result on right side.You need to check if the equation is solvable\u00a0under the following rules:Each character is decoded as one digit (0 - 9).Every pair of different characters they must map to different digits.Each words[i] and result\u00a0are decoded as one number without leading zeros.Sum of numbers on left side (words) will equal to the number on right side (result).\u00a0Return True\u00a0if the equation is solvable otherwise\u00a0return\u00a0False.\u00a0": [
        "verbal-arithmetic-puzzle",
        [],
        [
            "Math",
            "Backtracking"
        ]
    ],
    "Given an array of non-negative integers arr, you are initially positioned at start\u00a0index of the array. When you are at index i, you can jump\u00a0to i + arr[i] or i - arr[i], check if you can reach to any index with value 0.Notice that you can not jump outside of the array at any time.\u00a0": [
        "jump-game-iii",
        [
            "jump-game",
            "jump-game-ii"
        ],
        [
            "Breadth-first Search",
            "Graph"
        ]
    ],
    "Given two binary search trees root1 and root2.Return a list containing all the integers from both trees sorted in ascending order.\u00a0": [
        "all-elements-in-two-binary-search-trees",
        [],
        [
            "Sort",
            "Tree"
        ]
    ],
    "Given an integer n, return any array containing n unique\u00a0integers such that they add up to 0.\u00a0": [
        "find-n-unique-integers-sum-up-to-zero",
        [],
        [
            "Array"
        ]
    ],
    "Given n boxes, each box is given in the format [status, candies, keys, containedBoxes] where:status[i]: an integer which is 1 if\u00a0box[i] is open and 0 if\u00a0box[i] is closed.candies[i]:\u00a0an integer representing the number of candies in box[i].keys[i]: an array contains the indices of the boxes you can open with the key in box[i].containedBoxes[i]: an array contains the indices of the boxes found in box[i].You will start with some boxes given in initialBoxes array. You can take all the candies in any open\u00a0box and you can use the keys in it to open new boxes and you also can use the boxes you find in it.Return the maximum number of candies you can get following the rules above.\u00a0": [
        "maximum-candies-you-can-get-from-boxes",
        [],
        [
            "Breadth-first Search"
        ]
    ],
    "Given a string s, return the maximum number of ocurrences of any substring\u00a0under the following rules:The number of unique characters in the substring must be less than or equal to maxLetters.The substring size must be between minSize and maxSize\u00a0inclusive.\u00a0": [
        "maximum-number-of-occurrences-of-a-substring",
        [],
        [
            "String",
            "Bit Manipulation"
        ]
    ],
    "Given an array of integers\u00a0nums\u00a0and a positive integer\u00a0k, find whether it's possible to divide this array into\u00a0sets of k consecutive numbersReturn\u00a0True\u00a0if its possible\u00a0otherwise\u00a0return\u00a0False.\u00a0": [
        "divide-array-in-sets-of-k-consecutive-numbers",
        [
            "split-array-into-consecutive-subsequences"
        ],
        [
            "Array",
            "Greedy"
        ]
    ],
    "Given an array nums of integers, return how many of them contain an even number of digits.\u00a0": [
        "find-numbers-with-even-number-of-digits",
        [],
        [
            "Array"
        ]
    ],
    "Given a m * n grid, where each cell is either 0 (empty)\u00a0or 1 (obstacle).\u00a0In one step, you can move up, down, left or right from and to an empty cell.Return the minimum number of steps to walk from the upper left corner\u00a0(0, 0)\u00a0to the lower right corner\u00a0(m-1, n-1) given that you can eliminate\u00a0at most k obstacles. If it is not possible to find such\u00a0walk return -1.\u00a0": [
        "shortest-path-in-a-grid-with-obstacles-elimination",
        [],
        [
            "Breadth-first Search"
        ]
    ],
    "Given a m x n\u00a0matrix mat and an integer threshold. Return the maximum side-length of a square with a sum less than or equal to threshold or return 0 if there is no such square.\u00a0": [
        "maximum-side-length-of-a-square-with-sum-less-than-or-equal-to-threshold",
        [],
        [
            "Array",
            "Binary Search"
        ]
    ],
    "Given head which is a reference node to\u00a0a singly-linked list. The value of each node in the linked list is either 0 or 1. The linked list holds the binary representation of a number.Return the decimal value of the number in the linked list.\u00a0": [
        "convert-binary-number-in-a-linked-list-to-integer",
        [],
        [
            "Linked List",
            "Bit Manipulation"
        ]
    ],
    "Given a m x n binary matrix mat. In one step, you can choose one cell and flip it and all the four neighbours of it\u00a0if they exist (Flip is changing 1 to 0 and 0 to 1). A pair of cells are called neighboors if they share one edge.Return the minimum number of steps required to convert mat\u00a0to a zero matrix or -1 if you cannot.Binary matrix is a matrix with all cells equal to 0 or 1 only.Zero matrix is a matrix with all cells equal to 0.\u00a0": [
        "minimum-number-of-flips-to-convert-binary-matrix-to-zero-matrix",
        [],
        [
            "Breadth-first Search"
        ]
    ],
    "Given an array of integers nums and an integer threshold, we will choose a positive integer divisor and\u00a0divide\u00a0all the array by it and sum the result of the division. Find the smallest divisor such that the result mentioned above is less than\u00a0or equal to threshold.Each\u00a0result of\u00a0division is rounded\u00a0to the nearest integer greater than or equal to that element.\u00a0(": [
        "find-the-smallest-divisor-given-a-threshold",
        [],
        [
            "Binary Search"
        ]
    ],
    "There are n people\u00a0that are split into some unknown number of groups. Each person is labeled with a\u00a0unique ID\u00a0from\u00a00\u00a0to\u00a0n - 1.You are given an integer array\u00a0groupSizes, where groupSizes[i]\u00a0is the size of the group that person\u00a0i\u00a0is in. ": [
        "group-the-people-given-the-group-size-they-belong-to",
        [],
        [
            "Greedy"
        ]
    ],
    "Given an integer number n, return the difference between the product of its digits and the sum of its digits.\u00a0": [
        "subtract-the-product-and-sum-of-digits-of-an-integer",
        [],
        [
            "Math"
        ]
    ],
    "You are given a string\u00a0s containing lowercase letters and an integer k. You need to :First, change some characters of s\u00a0to other lowercase English letters.Then divide s\u00a0into k non-empty disjoint substrings such that each substring is palindrome.Return the minimal number of characters that you need to change\u00a0to divide the string.\u00a0": [
        "palindrome-partitioning-iii",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Given a m * n matrix of ones and zeros, return how many square submatrices have all ones.\u00a0": [
        "count-square-submatrices-with-all-ones",
        [],
        [
            "Array",
            "Dynamic Programming"
        ]
    ],
    "Given two integers tomatoSlices\u00a0and cheeseSlices. The ingredients of different burgers are as follows:Jumbo Burger: 4 tomato slices\u00a0and 1 cheese slice.Small Burger: 2 Tomato slices\u00a0and 1 cheese slice.Return [total_jumbo, total_small] so that the number of remaining tomatoSlices\u00a0equal to 0 and the number of remaining cheeseSlices equal to 0. If it is not possible to make the remaining tomatoSlices\u00a0and cheeseSlices equal to 0 return [].\u00a0": [
        "number-of-burgers-with-no-waste-of-ingredients",
        [],
        [
            "Math",
            "Greedy"
        ]
    ],
    "Tic-tac-toe is played\u00a0by\u00a0two players A and B on a\u00a03\u00a0x\u00a03\u00a0grid.Here are the rules of Tic-Tac-Toe:Players take turns placing characters into empty squares (\" \").The first player A always places \"X\" characters, while the second player B\u00a0always places \"O\" characters.\"X\" and \"O\" characters are always placed into empty squares, never on filled ones.The game ends when there are 3 of the same (non-empty) character filling any row, column, or diagonal.The game also ends if all squares are non-empty.No more moves can be played if the game is over.Given an array moves where each element\u00a0is another array of size 2 corresponding to the row and column of the grid where they mark their respective character in the order in which A and B play.Return the winner of the game if it exists (A or B), in case the game ends in a draw return \"Draw\", if there are still movements to play return \"Pending\".You can assume that\u00a0moves is\u00a0valid (It follows the rules of Tic-Tac-Toe),\u00a0the grid is initially empty and A will play first.\u00a0": [
        "find-winner-on-a-tic-tac-toe-game",
        [],
        [
            "Array"
        ]
    ],
    "You have a pointer at index 0 in an array of size arrLen. At each step, you can move 1 position to the left, 1 position to the right\u00a0in the array or stay in the same place\u00a0 (The pointer should not be placed outside the array at any time).Given two integers\u00a0steps and arrLen, return the number of\u00a0ways such that your pointer still at index 0 after exactly steps\u00a0steps.Since the answer\u00a0may be too large,\u00a0return it modulo\u00a010^9 + 7.\u00a0": [
        "number-of-ways-to-stay-in-the-same-place-after-some-steps",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Given an array of strings products and a string searchWord. We want to design a system that suggests at most three product names from products\u00a0after each character of\u00a0searchWord is typed. Suggested products should have common prefix with the searchWord. If there are\u00a0more than three products with a common prefix\u00a0return the three lexicographically minimums products.Return list of lists of the suggested products after each character of\u00a0searchWord is typed.\u00a0\u00a0": [
        "search-suggestions-system",
        [],
        [
            "String"
        ]
    ],
    "You are given a map of a server center, represented as a m * n integer matrix\u00a0grid, where 1 means that on that cell there is a server and 0 means that it is no server. Two servers are said to communicate if they are on the same row or on the same column.Return the number of servers\u00a0that communicate with any other server.\u00a0": [
        "count-servers-that-communicate",
        [],
        [
            "Array",
            "Graph"
        ]
    ],
    "On a plane there are n points with integer coordinates points[i] = [xi, yi]. Your task is to find the minimum time in seconds to visit all points.You can move according to the next rules:In one second always you can either move vertically, horizontally by one unit or diagonally (it means to move one unit vertically and one unit horizontally in one second).You have to visit the points in the same order as they appear in the array.\u00a0": [
        "minimum-time-visiting-all-points",
        [],
        [
            "Array",
            "Geometry"
        ]
    ],
    "Storekeeper is a\u00a0game\u00a0in which the player pushes boxes around in a warehouse\u00a0trying to get them to target locations.The game is represented by a grid of size\u00a0m x n, where each element is a wall, floor, or a box.Your task is move the box 'B' to the target position 'T' under the following rules:Player is represented by character 'S'\u00a0and\u00a0can move up, down, left, right in the grid if it is a floor (empy cell).Floor is represented by character '.' that means free cell to walk.Wall is represented by character '#' that means obstacle\u00a0\u00a0(impossible to walk there).\u00a0There is only one box 'B' and one\u00a0target cell 'T' in the grid.The box can be moved to an adjacent free cell by standing next to the box and then moving in the direction of the box. This is a push.The player cannot walk through the box.Return the minimum number of pushes to move the box to the target. If there is no way to reach the target, return\u00a0-1.\u00a0": [
        "minimum-moves-to-move-a-box-to-their-target-location",
        [],
        [
            "Breadth-first Search"
        ]
    ],
    "Given an array\u00a0nums\u00a0of integers, we need to find the maximum possible sum of elements of the array such that it is divisible by three.\u00a0": [
        "greatest-sum-divisible-by-three",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Given a\u00a0binary tree with the following rules:root.val == 0If treeNode.val == x and treeNode.left != null, then treeNode.left.val == 2 * x + 1If treeNode.val == x and treeNode.right != null, then treeNode.right.val == 2 * x + 2Now the binary tree is contaminated, which means all\u00a0treeNode.val\u00a0have\u00a0been changed to -1.You need to first recover the binary tree and then implement the FindElements class:FindElements(TreeNode* root)\u00a0Initializes the object with a\u00a0contamined binary tree, you need to recover it first.bool find(int target)\u00a0Return if the target value exists in the recovered binary tree.\u00a0": [
        "find-elements-in-a-contaminated-binary-tree",
        [],
        [
            "Hash Table",
            "Tree"
        ]
    ],
    "Given a 2D grid of size m x n\u00a0and an integer k. You need to shift the grid\u00a0k times.In one shift operation:Element at grid[i][j] moves to grid[i][j + 1].Element at grid[i][n - 1] moves to grid[i + 1][0].Element at grid[m\u00a0- 1][n - 1] moves to grid[0][0].Return the 2D grid after applying shift operation k times.\u00a0": [
        "shift-2d-grid",
        [],
        [
            "Array"
        ]
    ],
    "Given a list of words, list of\u00a0 single\u00a0letters (might be repeating)\u00a0and score\u00a0of every character.Return the maximum score of any valid set of words formed by using the given letters (words[i] cannot be used two\u00a0or more times).It is not necessary to use all characters in letters and each letter can only be used once. Score of letters\u00a0'a', 'b', 'c', ... ,'z' is given by\u00a0score[0], score[1], ... , score[25] respectively.\u00a0": [
        "maximum-score-words-formed-by-letters",
        [],
        [
            "Bit Manipulation"
        ]
    ],
    "Given a 2D\u00a0grid consists of 0s (land)\u00a0and 1s (water).\u00a0 An island is a maximal 4-directionally connected group of 0s and a closed island\u00a0is an island totally\u00a0(all left, top, right, bottom) surrounded by 1s.Return the number of closed islands.\u00a0": [
        "number-of-closed-islands",
        [],
        [
            "Depth-first Search"
        ]
    ],
    "Given the following details of a matrix with n columns and 2 rows :The matrix is a binary matrix, which means each element in the matrix can be 0 or 1.The sum of elements of the 0-th(upper) row is given as upper.The sum of elements of the 1-st(lower) row is given as lower.The sum of elements in the i-th column(0-indexed) is colsum[i], where colsum is given as an integer array with length n.Your task is to reconstruct the matrix with upper, lower and colsum.Return it as a 2-D integer array.If there are more than one valid solution, any of them will be accepted.If no valid solution exists, return an empty 2-D array.\u00a0": [
        "reconstruct-a-2-row-binary-matrix",
        [],
        [
            "Math",
            "Greedy"
        ]
    ],
    "Given\u00a0n\u00a0and\u00a0m\u00a0which are the dimensions of a matrix initialized by zeros and given an array indices\u00a0where indices[i] = [ri, ci]. For each pair of [ri, ci]\u00a0you have to increment all cells in row ri and column ci\u00a0by 1.Return the number of cells with odd values in the matrix after applying the increment to all indices.\u00a0": [
        "cells-with-odd-values-in-a-matrix",
        [],
        [
            "Array"
        ]
    ],
    "Given an array nums of\u00a0positive integers. Your task is to select some subset of nums, multiply each element by an integer and add all these numbers.\u00a0The array is said to be\u00a0good\u00a0if you can obtain a sum of\u00a01\u00a0from the array by any possible subset and multiplicand.Return\u00a0True\u00a0if the array is good\u00a0otherwise\u00a0return\u00a0False.\u00a0": [
        "check-if-it-is-a-good-array",
        [],
        [
            "Math"
        ]
    ],
    "Given a string s\u00a0of\u00a0'('\u00a0,\u00a0')'\u00a0and lowercase English characters.\u00a0Your task is to remove the minimum number of parentheses (\u00a0'('\u00a0or\u00a0')',\u00a0in any positions ) so that the resulting parentheses string is valid and return any valid string.": [
        "minimum-remove-to-make-valid-parentheses",
        [],
        [
            "String",
            "Stack"
        ]
    ],
    "Given an array of integers nums and an integer\u00a0k. A\u00a0subarray\u00a0is called nice\u00a0if there are\u00a0k odd numbers on it.Return the number of nice sub-arrays.\u00a0": [
        "count-number-of-nice-subarrays",
        [],
        [
            "Two Pointers"
        ]
    ],
    "You are given two strings\u00a0s1\u00a0and\u00a0s2\u00a0of equal length\u00a0consisting of letters \"x\" and \"y\" only. Your task is to\u00a0make these two strings equal to each other. You can swap any two characters that belong to different strings,\u00a0which means: swap s1[i] and s2[j].Return\u00a0the minimum number of swaps required\u00a0to make\u00a0s1\u00a0and s2 equal, or return\u00a0-1\u00a0if it is\u00a0impossible to do so.\u00a0": [
        "minimum-swaps-to-make-strings-equal",
        [],
        [
            "String",
            "Greedy"
        ]
    ],
    "n\u00a0passengers board an airplane with exactly\u00a0n\u00a0seats. The first passenger has lost the ticket and picks a seat randomly. But after that, the rest of passengers will:Take their own seat if it is still available,\u00a0Pick other seats randomly when they find their seat occupied\u00a0What is the probability that the n-th person can get his own seat?\u00a0": [
        "airplane-seat-assignment-probability",
        [],
        [
            "Math",
            "Dynamic Programming",
            "Brainteaser"
        ]
    ],
    "Given a rectangle of size\u00a0n\u00a0x m, find the minimum number of integer-sided squares that tile the rectangle.\u00a0": [
        "tiling-a-rectangle-with-the-fewest-squares",
        [],
        [
            "Dynamic Programming",
            "Backtracking"
        ]
    ],
    "Given an array of strings arr. String s is a concatenation of a sub-sequence of arr which have unique characters.Return the maximum possible length of s.\u00a0": [
        "maximum-length-of-a-concatenated-string-with-unique-characters",
        [],
        [
            "Backtracking",
            "Bit Manipulation"
        ]
    ],
    "Given 2 integers n and start. Your task is return any permutation p\u00a0of (0,1,2.....,2^n -1) such that :p[0] = startp[i] and p[i+1]\u00a0differ by only one bit in their binary representation.p[0] and p[2^n -1]\u00a0must also differ by only one bit in their binary representation.\u00a0": [
        "circular-permutation-in-binary-representation",
        [],
        [
            "Math"
        ]
    ],
    "Given a\u00a0function\u00a0 f(x, y)\u00a0and a value z, return all positive integer\u00a0pairs x and y where f(x,y) == z.The function is constantly increasing, i.e.:f(x, y) < f(x + 1, y)f(x, y) < f(x, y + 1)The function interface is defined like this:\u00a0interface CustomFunction {public:\u00a0 // Returns positive integer f(x, y) for any given positive integer x and y.\u00a0 int f(int x, int y);};For custom testing purposes you're given an integer function_id and a target z as input, where function_id represent one function from an secret internal list, on the examples you'll know only two functions from the list. \u00a0You may return the solutions in any order.\u00a0": [
        "find-positive-integer-solution-for-a-given-equation",
        [],
        [
            "Math",
            "Binary Search"
        ]
    ],
    "We have n jobs, where every job\u00a0is scheduled to be done from startTime[i] to endTime[i], obtaining a profit\u00a0of profit[i].You're given the\u00a0startTime\u00a0,\u00a0endTime\u00a0and profit\u00a0arrays,\u00a0you need to output the maximum profit you can take such that there are no 2 jobs in the subset\u00a0with overlapping time range.If you choose a job that ends at time X\u00a0you\u00a0will be able to start another job that starts at time X.\u00a0": [
        "maximum-profit-in-job-scheduling",
        [],
        [
            "Binary Search",
            "Dynamic Programming",
            "Sort"
        ]
    ],
    "You are given a string containing only 4\u00a0kinds of characters 'Q', 'W', 'E' and\u00a0'R'.A string is said to be\u00a0balanced\u00a0if each of its characters appears\u00a0n/4 times where n is the length of the string.Return the minimum length of the substring that can be replaced with any other string of the same length to make the original string s\u00a0balanced.Return 0 if the string is already balanced.\u00a0": [
        "replace-the-substring-for-balanced-string",
        [],
        [
            "Two Pointers",
            "String"
        ]
    ],
    "Given a list of folders, remove all sub-folders in those folders and return in any order the folders after removing.If a folder[i] is located within\u00a0another folder[j], it is called a\u00a0sub-folder\u00a0of it.The format of a path is\u00a0one or more concatenated strings of the form:\u00a0/\u00a0followed by one or more lowercase English letters. ": [
        "remove-sub-folders-from-the-filesystem",
        [],
        [
            "Array",
            "String"
        ]
    ],
    "You are given an array\u00a0coordinates, coordinates[i] = [x, y], where [x, y] represents the coordinate of a point. Check if these points\u00a0make a straight line in the XY plane.\u00a0\u00a0": [
        "check-if-it-is-a-straight-line",
        [],
        [
            "Array",
            "Math",
            "Geometry"
        ]
    ],
    "Given an array nums\u00a0of positive integers, return the longest possible length of an array prefix of nums, such that it is possible to remove exactly one element from this prefix so that every number that has appeared in it will have the same number of occurrences.If after removing one element there are no remaining elements, it's still considered that every appeared number has the same number of ocurrences (0).\u00a0": [
        "maximum-equal-frequency",
        [],
        [
            "Hash Table"
        ]
    ],
    "A die simulator generates a random number from 1 to 6 for each roll.\u00a0You introduced a constraint to the generator such that it cannot roll the number i more than rollMax[i] (1-indexed) consecutive times.\u00a0Given an array of integers\u00a0rollMax\u00a0and an integer\u00a0n, return the number of distinct sequences that can be obtained with exact n rolls.Two sequences are considered different if at least one element differs from each other. Since the answer\u00a0may be too large,\u00a0return it modulo 10^9 + 7.\u00a0": [
        "dice-roll-simulation",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "On an 8x8 chessboard, there can be multiple Black Queens and one White King.Given an array of integer coordinates queens that represents the positions of the Black Queens, and a pair of coordinates king that represent the position of the White King, return the coordinates of all the queens (in any order) that can attack the King.\u00a0": [
        "queens-that-can-attack-the-king",
        [],
        [
            "Array"
        ]
    ],
    "Balanced\u00a0strings are those who have equal quantity of 'L' and 'R' characters.Given a balanced string\u00a0s\u00a0split it in the maximum amount of balanced strings.Return the maximum amount of splitted balanced strings.\u00a0": [
        "split-a-string-in-balanced-strings",
        [],
        [
            "String",
            "Greedy"
        ]
    ],
    "Design a Skiplist without using any built-in libraries.A Skiplist is a data structure that takes\u00a0O(log(n)) time\u00a0to add, erase and search. Comparing with treap and red-black tree which has the same function and performance, the code length of Skiplist can be\u00a0comparatively short and the idea behind Skiplists are just simple linked lists.": [
        "design-skiplist",
        [
            "design-linked-list",
            "design-hashmap",
            "design-hashset"
        ],
        [
            "Design"
        ]
    ],
    "Given an integer n, your task is to count how many strings of length n can be formed under the following rules:Each character is a lower case vowel\u00a0('a', 'e', 'i', 'o', 'u')Each vowel\u00a0'a' may only be followed by an 'e'.Each vowel\u00a0'e' may only be followed by an 'a'\u00a0or an 'i'.Each vowel\u00a0'i' may not be followed by another 'i'.Each vowel\u00a0'o' may only be followed by an 'i' or a\u00a0'u'.Each vowel\u00a0'u' may only be followed by an 'a'.Since the answer\u00a0may be too large,\u00a0return it modulo 10^9 + 7.\u00a0": [
        "count-vowels-permutation",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "In a gold mine grid\u00a0of size m * n,\u00a0each cell in this mine has an integer representing the amount of gold\u00a0in that cell,\u00a00 if it is empty.Return the maximum amount of gold you\u00a0can collect under the conditions:Every time you are located in a cell you will collect all the gold in that cell.From your position you can walk one step to the left, right, up or down.You can't visit the same cell more than once.Never visit a cell with\u00a00 gold.You can start and stop collecting gold from\u00a0any position in the grid that has some gold.\u00a0": [
        "path-with-maximum-gold",
        [],
        [
            "Backtracking"
        ]
    ],
    "Given an integer array arr\u00a0and an integer difference, return the length of the longest subsequence in arr\u00a0which is an arithmetic sequence such that the difference between adjacent elements in the subsequence equals\u00a0difference.\u00a0": [
        "longest-arithmetic-subsequence-of-given-difference",
        [],
        [
            "Math",
            "Dynamic Programming"
        ]
    ],
    "We have n chips, where the position of the ith chip is position[i].We need to move all the chips to the same position. In one step, we can change the position of the ith chip from position[i] to:position[i] + 2 or position[i] - 2 with cost = 0.position[i] + 1 or position[i] - 1 with cost = 1.Return the minimum cost needed to move all the chips to the same position.\u00a0": [
        "minimum-cost-to-move-chips-to-the-same-position",
        [],
        [
            "Array",
            "Math",
            "Greedy"
        ]
    ],
    "You are given an undirected weighted graph of\u00a0n\u00a0nodes (0-indexed), represented by an edge list where\u00a0edges[i] = [a, b]\u00a0is an undirected edge connecting the nodes\u00a0a\u00a0and\u00a0b\u00a0with a probability of success of traversing that edge\u00a0succProb[i].Given two nodes\u00a0start\u00a0and\u00a0end, find the path with the maximum probability of success to go from\u00a0start\u00a0to\u00a0end\u00a0and return its success probability.If there is no path from\u00a0start\u00a0to\u00a0end, return\u00a00. Your answer will be accepted if it differs from the correct answer by at most 1e-5.\u00a0": [
        "path-with-maximum-probability",
        [],
        [
            "Graph"
        ]
    ],
    "In an\u00a0n*n\u00a0grid, there is a snake that spans 2 cells and starts moving from the top left corner at (0, 0) and (0, 1). The grid has empty cells represented by zeros and blocked cells represented by ones. The snake wants to reach the lower right corner at\u00a0(n-1, n-2)\u00a0and\u00a0(n-1, n-1).In one move the snake can:Move one cell to the right\u00a0if there are no blocked cells there. This move keeps the horizontal/vertical position of the snake as it is.Move down one cell\u00a0if there are no blocked cells there. This move keeps the horizontal/vertical position of the snake as it is.Rotate clockwise if it's in a horizontal position and the two cells under it are both empty. In that case the snake moves from\u00a0(r, c)\u00a0and\u00a0(r, c+1)\u00a0to\u00a0(r, c)\u00a0and\u00a0(r+1, c).Rotate counterclockwise\u00a0if it's in a vertical position and the two cells to its right are both empty. In that case the snake moves from\u00a0(r, c)\u00a0and\u00a0(r+1, c)\u00a0to\u00a0(r, c)\u00a0and\u00a0(r, c+1).Return the minimum number of moves to reach the target.If there is no way to reach the target, return\u00a0-1.\u00a0": [
        "minimum-moves-to-reach-target-with-rotations",
        [],
        [
            "Breadth-first Search"
        ]
    ],
    "You are given two strings s and t of the same length. You want to change s to t. Changing the i-th character of s to i-th character of t costs |s[i] - t[i]| that is, the absolute difference between the ASCII values of the characters.You are also given an integer maxCost.Return the maximum length of a substring of s that can be changed to be the same as the corresponding substring of twith a cost less than or equal to maxCost.If there is no substring from\u00a0s that can be changed to its corresponding substring from t, return 0.\u00a0": [
        "get-equal-substrings-within-budget",
        [],
        [
            "Array",
            "Sliding Window"
        ]
    ],
    "Given a string\u00a0s, a k\u00a0duplicate removal\u00a0consists of choosing k\u00a0adjacent and equal letters from\u00a0s and removing\u00a0them causing the left and the right side of the deleted substring to concatenate together.We repeatedly make k duplicate removals on s until we no longer can.Return the final string after all such duplicate removals have been made.It is guaranteed that the answer is unique.\u00a0": [
        "remove-all-adjacent-duplicates-in-string-ii",
        [
            "remove-all-adjacent-duplicates-in-string"
        ],
        [
            "Stack"
        ]
    ],
    "Given an array of integers arr,\u00a0write a function that returns true if and only if the number of occurrences of each value in the array is unique.\u00a0": [
        "unique-number-of-occurrences",
        [],
        [
            "Hash Table"
        ]
    ],
    "There are\u00a0n\u00a0items each\u00a0belonging to zero or one of\u00a0m\u00a0groups where group[i]\u00a0is the group that the i-th item belongs to and it's equal to -1\u00a0if the i-th item belongs to no group. The items and the groups are zero indexed. A group can have no item belonging to it.Return a sorted list of the items such that:The items that belong to the same group are next to each other in the sorted list.There are some\u00a0relations\u00a0between these items where\u00a0beforeItems[i]\u00a0is a list containing all the items that should come before the\u00a0i-th item in the sorted array (to the left of the\u00a0i-th item).Return any solution if there is more than one solution and return an empty list\u00a0if there is no solution.\u00a0": [
        "sort-items-by-groups-respecting-dependencies",
        [],
        [
            "Depth-first Search",
            "Graph",
            "Topological Sort"
        ]
    ],
    "You are given a string s, and an array of pairs of indices in the string\u00a0pairs\u00a0where\u00a0pairs[i] =\u00a0[a, b]\u00a0indicates 2 indices(0-indexed) of the string.You can\u00a0swap the characters at any pair of indices in the given\u00a0pairs\u00a0any number of times.Return the\u00a0lexicographically smallest string that s\u00a0can be changed to after using the swaps.\u00a0": [
        "smallest-string-with-swaps",
        [],
        [
            "Array",
            "Union Find"
        ]
    ],
    "Write a program to find the\u00a0n-th ugly number.Ugly numbers are\u00a0positive integers\u00a0which are divisible by\u00a0a\u00a0or\u00a0b\u00a0or c.\u00a0": [
        "ugly-number-iii",
        [
            "ugly-number-ii"
        ],
        [
            "Math",
            "Binary Search"
        ]
    ],
    "Given an\u00a0array\u00a0of distinct\u00a0integers arr, find all pairs of elements with the minimum absolute difference of any two elements.\u00a0Return a list of pairs in ascending order(with respect to pairs), each pair [a, b] followsa, b are from arra < bb - a\u00a0equals to the minimum absolute difference of any two elements in arr\u00a0": [
        "minimum-absolute-difference",
        [],
        [
            "Array"
        ]
    ],
    "A string is called happy if it does\u00a0not have any of the strings 'aaa', 'bbb'\u00a0or 'ccc'\u00a0as a substring.Given three integers a, b and c, return any string s,\u00a0which satisfies following conditions:s is happy\u00a0and longest possible.s contains at most a\u00a0occurrences of the letter\u00a0'a', at most b\u00a0occurrences of the letter 'b' and at most c occurrences of the letter 'c'.s\u00a0will only contain 'a', 'b' and 'c'\u00a0letters.If there is no such string s\u00a0return the empty string \"\".\u00a0": [
        "longest-happy-string",
        [],
        [
            "Dynamic Programming",
            "Greedy"
        ]
    ],
    "There are\u00a0n servers numbered from\u00a00\u00a0to\u00a0n-1 connected by\u00a0undirected server-to-server connections forming a network where connections[i] = [a, b]\u00a0represents a connection between servers a\u00a0and b. Any server can reach any other server directly or indirectly through the network.A critical connection\u00a0is a connection that, if removed, will make some server unable to reach some other server.Return all critical connections in the network in any order.\u00a0": [
        "critical-connections-in-a-network",
        [],
        [
            "Depth-first Search"
        ]
    ],
    "Given an integer array arr\u00a0and an integer k, modify the array by repeating it k times.": [
        "k-concatenation-maximum-sum",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "You are given a string s that consists of lower case English letters and brackets.\u00a0Reverse the strings\u00a0in each\u00a0pair of matching parentheses, starting\u00a0from the innermost one.Your result should not contain any brackets.\u00a0": [
        "reverse-substrings-between-each-pair-of-parentheses",
        [],
        [
            "Stack"
        ]
    ],
    "Given a string\u00a0text, you want to use the characters of\u00a0text\u00a0to form as many instances of the word \"balloon\" as possible.You can use each character in text at most once. Return the maximum number of instances that can be formed.\u00a0": [
        "maximum-number-of-balloons",
        [],
        [
            "Hash Table",
            "String"
        ]
    ],
    "You are given a tree with\u00a0n\u00a0nodes numbered from\u00a00\u00a0to\u00a0n-1\u00a0in the form of a parent array where parent[i]\u00a0is the parent of node i. The root of the tree is node 0.Implement the function\u00a0getKthAncestor(int node, int k)\u00a0to return the k-th ancestor of the given\u00a0node. If there is no such ancestor, return\u00a0-1.The\u00a0k-th\u00a0ancestor\u00a0of a tree node is the k-th node\u00a0in the path\u00a0from that node to the root.\u00a0": [
        "kth-ancestor-of-a-tree-node",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Given an integer array arr, return true\u00a0if there are three consecutive odd numbers in the array. Otherwise, return\u00a0false.\u00a0": [
        "three-consecutive-odds",
        [],
        [
            "Array"
        ]
    ],
    "Given two integer arrays\u00a0arr1 and arr2, return the minimum number of operations (possibly zero) needed\u00a0to make arr1 strictly increasing.In one operation, you can choose two indices\u00a00 <=\u00a0i < arr1.length\u00a0and\u00a00 <= j < arr2.length\u00a0and do the assignment\u00a0arr1[i] = arr2[j].If there is no way to make\u00a0arr1\u00a0strictly increasing,\u00a0return\u00a0-1.\u00a0": [
        "make-array-strictly-increasing",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Given a date, return the corresponding day of the week for that date.The input is given as three integers representing the day, month and year respectively.Return the answer as one of the following values\u00a0{\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"}.\u00a0": [
        "day-of-the-week",
        [],
        [
            "Array"
        ]
    ],
    "Given an array of integers, return the maximum sum for a non-empty\u00a0subarray (contiguous elements) with at most one element deletion.\u00a0In other words, you want to choose a subarray and optionally delete one element from it so that there is still at least one element left and the\u00a0sum of the remaining elements is maximum possible.": [
        "maximum-subarray-sum-with-one-deletion",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "A bus\u00a0has n stops numbered from 0 to n - 1 that form\u00a0a circle. We know the distance between all pairs of neighboring stops where distance[i] is the distance between the stops number\u00a0i and (i + 1) % n.The bus goes along both directions\u00a0i.e. clockwise and counterclockwise.Return the shortest distance between the given\u00a0start\u00a0and destination\u00a0stops.\u00a0": [
        "distance-between-bus-stops",
        [],
        [
            "Array"
        ]
    ],
    "Given an integer array\u00a0nums\u00a0and an integer k, return the maximum sum of a non-empty subsequence\u00a0of that array such that for every\u00a0two consecutive integers in the subsequence,\u00a0nums[i]\u00a0and\u00a0nums[j], where\u00a0i < j, the condition\u00a0j - i <= k\u00a0is satisfied.A\u00a0subsequence\u00a0of an array is\u00a0obtained by deleting some number of elements (can be\u00a0zero) from the array, leaving the remaining elements in their original order.\u00a0": [
        "constrained-subsequence-sum",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Given a binary search tree, return a balanced binary search tree with the same node values.A binary search tree is balanced if and only if\u00a0the depth of the two subtrees of\u00a0every\u00a0node never differ by more than 1.If there is more than one answer, return any of them.\u00a0": [
        "balance-a-binary-search-tree",
        [],
        [
            "Binary Search Tree"
        ]
    ],
    "Given an integer array nums, return the sum of divisors of the integers in that array that have exactly four divisors.If there is no such integer in the array, return 0.\u00a0": [
        "four-divisors",
        [],
        [
            "Math"
        ]
    ],
    "Given a date string in the form\u00a0Day Month Year, where:Day\u00a0is in the set {\"1st\", \"2nd\", \"3rd\", \"4th\", ..., \"30th\", \"31st\"}.Month\u00a0is in the set {\"Jan\", \"Feb\", \"Mar\", \"Apr\", \"May\", \"Jun\", \"Jul\", \"Aug\", \"Sep\", \"Oct\", \"Nov\", \"Dec\"}.Year\u00a0is in the range [1900, 2100].Convert the date string to the format YYYY-MM-DD, where:YYYY denotes the 4 digit year.MM denotes the 2 digit month.DD denotes the 2 digit day.\u00a0": [
        "reformat-date",
        [],
        [
            "String"
        ]
    ],
    "With respect to a given puzzle string, a word is valid\u00a0if both the following conditions are satisfied:word contains the first letter of puzzle.For each letter in word, that letter is in puzzle.\t": [
        "number-of-valid-words-for-each-puzzle",
        [],
        [
            "Hash Table",
            "Bit Manipulation"
        ]
    ],
    "Given a string s, we make queries on substrings of s.For each query queries[i] = [left, right, k], we may rearrange\u00a0the substring s[left], ..., s[right], and then choose up to k of them to replace with any lowercase English letter.\u00a0If the substring\u00a0is possible to be a\u00a0palindrome string after the operations above, the result of the query is true.\u00a0Otherwise, the result\u00a0is false.Return an array answer[], where answer[i] is the result of the i-th query queries[i].": [
        "can-make-palindrome-from-substring",
        [],
        [
            "Array",
            "String"
        ]
    ],
    "Return the number of permutations of 1 to n so that prime numbers are at prime indices (1-indexed.)(Recall that an integer\u00a0is prime if and only if it is greater than 1, and cannot be written as a product of two positive integers\u00a0both smaller than it.)Since the answer may be large, return the answer modulo 10^9 + 7.\u00a0": [
        "prime-arrangements",
        [],
        [
            "Math"
        ]
    ],
    "Given an integer array of digits,\u00a0return the largest multiple of three that can be formed by concatenating some of the given digits in any order.Since the answer may not fit in an integer data type, return the answer as a string.If there is no answer return an empty string.\u00a0": [
        "largest-multiple-of-three",
        [],
        [
            "Math",
            "Dynamic Programming"
        ]
    ],
    "Given an integer num, find the closest two integers in absolute difference whose product equals\u00a0num + 1\u00a0or num + 2.Return the two integers in any order.\u00a0": [
        "closest-divisors",
        [],
        [
            "Math"
        ]
    ],
    "You have\u00a0n binary tree nodes\u00a0numbered from 0\u00a0to n - 1 where node\u00a0i\u00a0has two children\u00a0leftChild[i]\u00a0and\u00a0rightChild[i], return\u00a0true\u00a0if and only if all the given nodes form exactly one valid binary tree.If node\u00a0i\u00a0has no left child then\u00a0leftChild[i]\u00a0will equal\u00a0-1, similarly for the right child.": [
        "validate-binary-tree-nodes",
        [],
        [
            "Graph"
        ]
    ],
    "Write a program to count the number of days between two dates.The two dates are given as strings, their format is YYYY-MM-DD\u00a0as shown in the examples.\u00a0": [
        "number-of-days-between-two-dates",
        [],
        []
    ],
    "Let's define a function f(s) over a non-empty string s, which calculates the frequency of the smallest character in s. ": [
        "compare-strings-by-frequency-of-the-smallest-character",
        [],
        [
            "Array",
            "String"
        ]
    ],
    "A transaction is possibly invalid if:the amount exceeds $1000, or;if it occurs within (and including) 60 minutes of another transaction with the same name in a different city.Each transaction string transactions[i]\u00a0consists of\u00a0comma separated values representing\u00a0the name, time (in minutes), amount, and city of the transaction.Given a list of transactions,\u00a0return a list of transactions that are possibly invalid.\u00a0 You may return the answer in any order.\u00a0": [
        "invalid-transactions",
        [],
        [
            "Array",
            "String"
        ]
    ],
    "You have an infinite number of stacks arranged in a row and numbered (left to right) from 0, each of the stacks has the same\u00a0maximum capacity.Implement the DinnerPlates class:DinnerPlates(int capacity) Initializes the object with the maximum capacity of the stacks.void push(int val)\u00a0Pushes the given positive integer val into the leftmost stack with size less than capacity.int pop()\u00a0Returns the value at the top of the rightmost non-empty stack and removes it from that stack, and returns -1 if all stacks are empty.int popAtStack(int index)\u00a0Returns the value at the top of the stack with the given index and removes it from that stack, and returns -1 if the stack with that\u00a0given index is empty.": [
        "dinner-plate-stacks",
        [],
        [
            "Design"
        ]
    ],
    "Given the head of a linked list, we repeatedly delete consecutive sequences of nodes that sum to 0 until there are no such sequences.After doing so, return the head of the final linked list.\u00a0 You may return any such answer.\u00a0(": [
        "remove-zero-sum-consecutive-nodes-from-linked-list",
        [
            "delete-n-nodes-after-m-nodes-of-a-linked-list"
        ],
        [
            "Linked List"
        ]
    ],
    "You have d dice, and each die has f faces numbered 1, 2, ..., f.Return the number of possible ways (out of fd\u00a0total ways) modulo 10^9 + 7 to roll the dice so the sum of the face up numbers equals target.\u00a0": [
        "number-of-dice-rolls-with-target-sum",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Implementing the class MajorityChecker, which has the following API:MajorityChecker(int[] arr) constructs an instance of MajorityChecker with the given array arr;int query(int left, int right, int threshold)\u00a0has arguments\u00a0such that:\t0 <= left\u00a0<= right\u00a0< arr.length representing a subarray of arr;2 * threshold > right - left + 1, ie. the threshold is always a strict majority of the length of\u00a0the subarrayEach\u00a0query(...) returns the element in arr[left], arr[left+1], ..., arr[right] that occurs at least threshold times, or -1 if no such element exists.\u00a0": [
        "online-majority-element-in-subarray",
        [],
        [
            "Array",
            "Binary Search",
            "Segment Tree"
        ]
    ],
    "Given a string text, we are allowed to swap two of the characters in the string. Find the length of the longest substring with repeated characters.\u00a0": [
        "swap-for-longest-repeated-character-substring",
        [],
        [
            "String"
        ]
    ],
    "Given a string date representing a Gregorian\u00a0calendar date formatted as YYYY-MM-DD, return the day number of the year.\u00a0": [
        "day-of-the-year",
        [],
        [
            "Math"
        ]
    ],
    "Given an array of integers\u00a0arr, replace each element with its rank.The rank represents how large the element is. The rank has the following rules:Rank is an integer starting from 1.The larger the element, the larger the rank. If two elements are equal, their rank must be the same.Rank should be as small as possible.\u00a0": [
        "rank-transform-of-an-array",
        [],
        [
            "Array"
        ]
    ],
    "You are given an integer array nums. The value of this array is defined as the sum of |nums[i]-nums[i+1]|\u00a0for all\u00a00 <= i < nums.length-1.You are allowed to select any subarray of the given array and reverse it. You can perform this operation only once.Find maximum possible value of the final array.\u00a0": [
        "reverse-subarray-to-maximize-array-value",
        [],
        [
            "Array",
            "Math"
        ]
    ],
    "Given a binary tree, return the sum of values of its deepest leaves.\u00a0": [
        "deepest-leaves-sum",
        [],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given a m * n matrix mat\u00a0of integers, sort it diagonally in ascending order from the top-left to the bottom-right then return the sorted array.\u00a0": [
        "sort-the-matrix-diagonally",
        [],
        [
            "Array",
            "Sort"
        ]
    ],
    "Given a palindromic string palindrome, replace exactly one character by any lowercase English letter so that the string becomes the lexicographically smallest possible string that isn't a palindrome.After doing so, return the final string.\u00a0 If there is no way to do so, return the empty string.\u00a0": [
        "break-a-palindrome",
        [],
        [
            "String"
        ]
    ],
    "Return the largest possible k\u00a0such that there exists\u00a0a_1, a_2, ..., a_k\u00a0such that:Each a_i is a non-empty string;Their concatenation a_1 + a_2 + ... + a_k is equal to text;For all 1 <= i <= k,\u00a0\u00a0a_i = a_{k+1 - i}.\u00a0": [
        "longest-chunked-palindrome-decomposition",
        [],
        [
            "Dynamic Programming",
            "Rolling Hash"
        ]
    ],
    "Given two strings text1 and text2, return the length of their longest common subsequence.A subsequence of a string is a new string generated from the original string with some characters(can be none) deleted without changing the relative order of the remaining characters. (eg, \"ace\" is a subsequence of \"abcde\" while \"aec\" is not).\u00a0A common subsequence\u00a0of two strings is a subsequence that is common to both strings.\u00a0If there is no common subsequence, return 0.\u00a0": [
        "longest-common-subsequence",
        [
            "delete-operation-for-two-strings",
            "longest-palindromic-subsequence",
            "shortest-common-supersequence"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Implement a SnapshotArray that supports the following interface:SnapshotArray(int length) initializes an array-like data structure with the given length.\u00a0 Initially, each element equals 0.void set(index, val) sets the element at the given index to be equal to val.int snap()\u00a0takes a snapshot of the array and returns the snap_id: the total number of times we called snap() minus 1.int get(index, snap_id)\u00a0returns the value at the given index, at the time we took the snapshot with the given snap_id\u00a0": [
        "snapshot-array",
        [],
        [
            "Array"
        ]
    ],
    "Two players play a turn based game on a binary tree.\u00a0 We are given\u00a0the root of this binary tree, and the number of nodes n\u00a0in the tree.\u00a0 n is odd, and\u00a0each node has a distinct value from 1 to n.Initially, the first player names a value x with 1 <= x <= n, and the second player names a value y with 1 <= y <= n and y != x.\u00a0 The first player colors the node with value x red, and the second player colors the node with value y blue.Then, the players take turns starting with the first player.\u00a0 In each turn, that player chooses a node of their color (red if player 1, blue if player 2) and colors an uncolored neighbor of the chosen node (either the left child, right child, or parent of the chosen node.)If (and only if)\u00a0a player cannot choose such a node in this way, they must pass their turn.\u00a0 If both players pass their turn, the game ends, and the winner is the player that colored more nodes.You are the second player.\u00a0 If it is possible to choose such a y\u00a0to ensure you win the game, return true.\u00a0 If it is not possible, return false.\u00a0": [
        "binary-tree-coloring-game",
        [],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given an array nums of integers, a move\u00a0consists of choosing any element and decreasing it by 1.An array A is a\u00a0zigzag array\u00a0if either:Every even-indexed element is greater than adjacent elements, ie.\u00a0A[0] > A[1] < A[2] > A[3] < A[4] > ...OR, every odd-indexed element is greater than adjacent elements, ie.\u00a0A[0] < A[1] > A[2] < A[3] > A[4] < ...Return the minimum number of moves to transform the given array nums into a zigzag array.\u00a0": [
        "decrease-elements-to-make-array-zigzag",
        [],
        [
            "Array"
        ]
    ],
    "Return the number of distinct non-empty substrings of text\u00a0that can be written as the concatenation of some string with itself (i.e. it can be written as a + a\u00a0where a is some string).\u00a0": [
        "distinct-echo-substrings",
        [],
        [
            "String",
            "Rolling Hash"
        ]
    ],
    "Given a binary tree, return the sum of values of nodes with even-valued grandparent.\u00a0 (A grandparent of a node is the parent of its parent, if it exists.)If there are no nodes with an even-valued grandparent, return\u00a00.\u00a0": [
        "sum-of-nodes-with-even-valued-grandparent",
        [],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given a m * n matrix\u00a0mat\u00a0and an integer K, return a matrix answer where each answer[i][j]\u00a0is the sum of all elements mat[r][c] for i - K <= r <= i + K, j - K <= c <= j + K, and (r, c) is a valid position in the matrix.\u00a0": [
        "matrix-block-sum",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "We are given a list nums of integers representing a list compressed with run-length encoding.Consider each adjacent pair\u00a0of elements [freq, val] = [nums[2*i], nums[2*i+1]]\u00a0(with i >= 0).\u00a0 For each such pair, there are freq elements with value val concatenated in a sublist. Concatenate all the sublists from left to right to generate the decompressed list.Return the decompressed list.\u00a0": [
        "decompress-run-length-encoded-list",
        [
            "string-compression"
        ],
        [
            "Array"
        ]
    ],
    "Alex\u00a0and Lee continue their\u00a0games with piles of stones.\u00a0 There are a number of\u00a0piles\u00a0arranged in a row, and each pile has a positive integer number of stones\u00a0piles[i].\u00a0 The objective of the game is to end with the most\u00a0stones.\u00a0Alex and Lee take turns, with Alex starting first.\u00a0 Initially, M = 1.On each player's turn, that player\u00a0can take all the stones in the first X remaining piles, where 1 <= X <= 2M.\u00a0 Then, we set\u00a0M = max(M, X).The game continues until all the stones have been taken.Assuming Alex and Lee play optimally, return the maximum number of stones Alex can get.\u00a0": [
        "stone-game-ii",
        [
            "stone-game-v"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Given a 2D grid of 0s and 1s, return the number of elements in\u00a0the largest square\u00a0subgrid that has all 1s on its border, or 0 if such a subgrid\u00a0doesn't exist in the grid.\u00a0": [
        "largest-1-bordered-square",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "On an alphabet board, we start at position (0, 0), corresponding to character\u00a0board[0][0].Here, board = [\"abcde\", \"fghij\", \"klmno\", \"pqrst\", \"uvwxy\", \"z\"], as shown in the diagram below.We may make the following moves:'U' moves our position up one row, if the position exists on the board;'D' moves our position down one row, if the position exists on the board;'L' moves our position left one column, if the position exists on the board;'R' moves our position right one column, if the position exists on the board;'!'\u00a0adds the character board[r][c] at our current position (r, c)\u00a0to the\u00a0answer.(Here, the only positions that exist on the board are positions with letters on them.)Return a sequence of moves that makes our answer equal to target\u00a0in the minimum number of moves.\u00a0 You may return any path that does so.\u00a0": [
        "alphabet-board-path",
        [],
        [
            "Hash Table",
            "String"
        ]
    ],
    "The Tribonacci sequence Tn is defined as follows:\u00a0T0 = 0, T1 = 1, T2 = 1, and Tn+3 = Tn + Tn+1 + Tn+2 for n >= 0.Given n, return the value of Tn.\u00a0": [
        "n-th-tribonacci-number",
        [
            "fibonacci-number",
            "climbing-stairs"
        ],
        [
            "Recursion"
        ]
    ],
    "You are given a square board\u00a0of characters. You can move on the board starting at the bottom right square marked with the character\u00a0'S'.You need\u00a0to reach the top left square marked with the character 'E'. The rest of the squares are labeled either with a numeric character\u00a01, 2, ..., 9 or with an obstacle 'X'. In one move you can go up, left or up-left (diagonally) only if there is no obstacle there.Return a list of two integers: the first integer is the maximum sum of numeric characters you can collect, and the second is the number of such paths that you can take to get that maximum sum, taken modulo 10^9 + 7.In case there is no path, return\u00a0[0, 0].\u00a0": [
        "number-of-paths-with-max-score",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Given an integer array\u00a0arr and a target value target, return\u00a0the integer\u00a0value\u00a0such that when we change all the integers\u00a0larger than value\u00a0in the given array to be equal to\u00a0value,\u00a0the sum of the array gets\u00a0as close as possible (in absolute difference) to\u00a0target.In case of a tie, return the minimum such integer.Notice that the answer is not neccesarilly a number from arr.\u00a0": [
        "sum-of-mutated-array-closest-to-target",
        [],
        [
            "Array",
            "Binary Search"
        ]
    ],
    "Given an array arr,\u00a0replace every element in that array with the greatest element among the elements to its\u00a0right, and replace the last element with -1.After doing so, return the array.\u00a0": [
        "replace-elements-with-greatest-element-on-right-side",
        [],
        [
            "Array"
        ]
    ],
    "Given two arrays of integers with equal lengths, return the maximum value of:|arr1[i] - arr1[j]| + |arr2[i] - arr2[j]| + |i - j|where the maximum is taken over all 0 <= i, j < arr1.length.\u00a0": [
        "maximum-of-absolute-value-expression",
        [],
        [
            "Math",
            "Bit Manipulation"
        ]
    ],
    "Consider a directed graph, with nodes labelled 0, 1, ..., n-1.\u00a0 In this graph, each edge is either red or blue, and there could\u00a0be self-edges or parallel edges.Each [i, j] in red_edges denotes a red directed edge from node i to node j.\u00a0 Similarly, each [i, j] in blue_edges denotes a blue directed edge from node i to node j.Return an array answer\u00a0of length n,\u00a0where each\u00a0answer[X]\u00a0is\u00a0the length of the shortest path from node 0\u00a0to node X\u00a0such that the edge colors alternate along the path (or -1 if such a path doesn't exist).\u00a0": [
        "shortest-path-with-alternating-colors",
        [],
        [
            "Breadth-first Search",
            "Graph"
        ]
    ],
    "Given an array arr of positive integers, consider all binary trees such that:Each node has either 0 or 2 children;The values of arr correspond to the values of each\u00a0leaf in an in-order traversal of the tree.\u00a0 (Recall that a node is a leaf if and only if it has 0 children.)The value\u00a0of each non-leaf node is equal to the product of the largest leaf value in its left and right subtree respectively.Among all possible binary trees considered,\u00a0return the smallest possible sum of the values of each non-leaf node.\u00a0 It is guaranteed this sum fits into a 32-bit integer.\u00a0": [
        "minimum-cost-tree-from-leaf-values",
        [],
        [
            "Dynamic Programming",
            "Stack",
            "Tree"
        ]
    ],
    "Given a list of dominoes,\u00a0dominoes[i] = [a, b]\u00a0is equivalent to dominoes[j] = [c, d]\u00a0if and only if either (a==c and b==d), or (a==d and b==c) - that is, one domino can be rotated to be equal to another domino.Return the number of pairs (i, j) for which 0 <= i < j < dominoes.length, and\u00a0dominoes[i] is equivalent to dominoes[j].\u00a0": [
        "number-of-equivalent-domino-pairs",
        [],
        [
            "Array"
        ]
    ],
    "Given a square grid\u00a0of integers\u00a0arr, a falling path with non-zero shifts\u00a0is a choice of\u00a0exactly one element from each row of arr, such that no two elements chosen in adjacent rows are in\u00a0the same column.Return the\u00a0minimum\u00a0sum of a falling path with non-zero shifts.\u00a0": [
        "minimum-falling-path-sum-ii",
        [
            "minimum-falling-path-sum"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Given a list of intervals, remove all intervals that are covered by another interval in the list.\u00a0Interval [a,b) is covered by\u00a0interval [c,d) if and only if c <= a and b <= d.After doing so, return the number of remaining intervals.\u00a0": [
        "remove-covered-intervals",
        [],
        [
            "Line Sweep"
        ]
    ],
    "Given an\u00a0integer array\u00a0sorted in non-decreasing order, there is exactly one integer in the array that occurs more than 25% of the time.Return that integer.\u00a0": [
        "element-appearing-more-than-25-in-sorted-array",
        [],
        [
            "Array"
        ]
    ],
    "In a project, you have a list of required skills req_skills,\u00a0and a list of people.\u00a0 The i-th person people[i]\u00a0contains a list of skills that person has.Consider a sufficient team: a set of people such that for every required skill in req_skills, there is at least one person in the team who has that skill.\u00a0 We can represent these teams by the index of each person: for example, team = [0, 1, 3] represents the people with skills people[0], people[1], and people[3].Return any\u00a0sufficient team of the smallest possible size, represented by the index of each person.You may return the answer in any order.\u00a0 It is guaranteed an answer exists.\u00a0": [
        "smallest-sufficient-team",
        [],
        [
            "Dynamic Programming",
            "Bit Manipulation"
        ]
    ],
    "We are given hours, a list of the number of hours\u00a0worked per day for a given employee.A day is considered to be a tiring day if and only if the number of hours worked is (strictly) greater than 8.A well-performing interval is an interval of days for which the number of tiring days is strictly larger than the number of non-tiring days.Return the length of the longest well-performing interval.\u00a0": [
        "longest-well-performing-interval",
        [],
        [
            "Stack"
        ]
    ],
    "Given a rooted binary tree, return the lowest common ancestor of its deepest leaves.Recall that:The node of a binary tree is a leaf if and only if it has no childrenThe depth of the root of the tree is 0, and if the depth of a node is d, the depth of each of its children\u00a0is\u00a0d+1.The lowest common ancestor of a set S of nodes is the node A with the largest depth such that every node in S is in the subtree with root A.\u00a0": [
        "lowest-common-ancestor-of-deepest-leaves",
        [],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given two arrays arr1 and arr2, the elements of arr2 are distinct, and all elements in arr2 are also in arr1.Sort the elements of arr1 such that the relative ordering of items in arr1 are the same as in arr2.\u00a0 Elements that don't appear in arr2 should be placed at the end of arr1 in ascending order.\u00a0": [
        "relative-sort-array",
        [],
        [
            "Array",
            "Sort"
        ]
    ],
    "An\u00a0integer has sequential digits if and only if each digit in the number is one more than the previous digit.Return a sorted list of all the integers\u00a0in the range [low, high]\u00a0inclusive that have sequential digits.\u00a0": [
        "sequential-digits",
        [],
        [
            "Backtracking"
        ]
    ],
    "Design an Iterator class, which has:A constructor that takes a string\u00a0characters\u00a0of sorted distinct lowercase English letters and a number\u00a0combinationLength as arguments.A function next()\u00a0that returns the next combination of length combinationLength\u00a0in lexicographical order.A function hasNext() that returns True\u00a0if and only if\u00a0there exists a next combination.\u00a0": [
        "iterator-for-combination",
        [],
        [
            "Backtracking",
            "Design"
        ]
    ],
    "A string is a valid parentheses string\u00a0(denoted VPS) if and only if it consists of \"(\" and \")\" characters only, and:It is the empty string, orIt can be written as\u00a0AB\u00a0(A\u00a0concatenated with\u00a0B), where\u00a0A\u00a0and\u00a0B\u00a0are VPS's, orIt can be written as\u00a0(A), where\u00a0A\u00a0is a VPS.We can\u00a0similarly define the nesting depth depth(S) of any VPS S as follows:depth(\"\") = 0depth(A + B) = max(depth(A), depth(B)), where A and B are VPS'sdepth(\"(\" + A + \")\") = 1 + depth(A), where A is a VPS.": [
        "maximum-nesting-depth-of-two-valid-parentheses-strings",
        [],
        [
            "Binary Search",
            "Greedy"
        ]
    ],
    "Given the root\u00a0of a binary tree, each node in the tree has a distinct value.After deleting\u00a0all nodes with a value in to_delete, we are left with a forest (a\u00a0disjoint union of trees).Return the roots of the trees in the remaining forest.\u00a0 You may return the result in any order.\u00a0": [
        "delete-nodes-and-return-forest",
        [],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "There are n flights, and they are labeled\u00a0from 1 to n.We have a list of flight bookings.\u00a0 The i-th booking\u00a0bookings[i] = [i, j, k]\u00a0means that we booked k seats from flights labeled i to j inclusive.Return an array answer of length n, representing the number of seats booked on each flight in order of their label.\u00a0": [
        "corporate-flight-bookings",
        [],
        [
            "Array",
            "Math"
        ]
    ],
    "Given a valid (IPv4) IP address, return a defanged version of that IP address.A defanged\u00a0IP address\u00a0replaces every period \".\" with \"[.]\".\u00a0": [
        "defanging-an-ip-address",
        [],
        [
            "String"
        ]
    ],
    "Return the result of evaluating a given boolean expression, represented as a string.An expression can either be:\"t\", evaluating to True;\"f\", evaluating to False;\"!(expr)\", evaluating to the logical NOT of the inner expression expr;\"&(expr1,expr2,...)\", evaluating to the logical AND of 2 or more inner expressions expr1, expr2, ...;\"|(expr1,expr2,...)\", evaluating to the logical OR of 2 or more inner expressions expr1, expr2, ...\u00a0": [
        "parsing-a-boolean-expression",
        [],
        [
            "String"
        ]
    ],
    "We have a sequence of books: the i-th book has thickness books[i][0] and height books[i][1].We want to place these books in order\u00a0onto bookcase shelves that have total width shelf_width.We choose\u00a0some of the books to place on this shelf (such that the sum of their thickness is <= shelf_width), then build another level of shelf of the bookcase so that the total height of the bookcase has increased by the maximum height of the books we just put down.\u00a0 We repeat this process until there are no more books to place.Note again that at each step of the above\u00a0process, the order of the books we place is the same order as the given sequence of books.\u00a0 ": [
        "filling-bookcase-shelves",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "We distribute some\u00a0number of candies, to a row of n =\u00a0num_people\u00a0people in the following way:We then give 1 candy to the first person, 2 candies to the second person, and so on until we give n\u00a0candies to the last person.Then, we go back to the start of the row, giving n\u00a0+ 1 candies to the first person, n\u00a0+ 2 candies to the second person, and so on until we give 2 * n\u00a0candies to the last person.This process repeats (with us giving one more candy each time, and moving to the start of the row after we reach the end) until we run out of candies.\u00a0 The last person will receive all of our remaining candies (not necessarily one more than the previous gift).Return an array (of length num_people\u00a0and sum candies) that represents the final distribution of candies.\u00a0": [
        "distribute-candies-to-people",
        [],
        [
            "Math"
        ]
    ],
    "In an infinite binary tree where every node has two children, the nodes are labelled in row order.In the odd numbered rows (ie., the first, third, fifth,...), the labelling is left to right, while in the even numbered rows (second, fourth, sixth,...), the labelling is right to left.Given the label of a node in this tree, return the labels in the path from the root of the tree to the\u00a0node with that label.\u00a0": [
        "path-in-zigzag-labelled-binary-tree",
        [],
        [
            "Math",
            "Tree"
        ]
    ],
    "Under a grammar given below, strings can represent a set of lowercase words.\u00a0 Let's\u00a0use R(expr)\u00a0to denote the set of words the expression represents.Grammar can best be understood through simple examples:Single letters represent a singleton set containing that word.\tR(\"a\") = {\"a\"}R(\"w\") = {\"w\"}When we take a comma delimited list of 2 or more expressions, we take the union of possibilities.\tR(\"{a,b,c}\") = {\"a\",\"b\",\"c\"}R(\"{{a,b},{b,c}}\") = {\"a\",\"b\",\"c\"}\u00a0(notice the final set only contains each word at most once)When we concatenate two expressions, we take the set of possible concatenations between two words where the first word comes from the first expression and the second word comes from the second expression.\tR(\"{a,b}{c,d}\") = {\"ac\",\"ad\",\"bc\",\"bd\"}R(\"a{b,c}{d,e}f{g,h}\")\u00a0= {\"abdfg\", \"abdfh\", \"abefg\", \"abefh\", \"acdfg\", \"acdfh\", \"acefg\", \"acefh\"}": [
        "brace-expansion-ii",
        [
            "brace-expansion"
        ],
        [
            "String"
        ]
    ],
    "(This problem is an\u00a0interactive problem.)You may recall that an array\u00a0A is a mountain array if and only if:A.length >= 3There exists some\u00a0i\u00a0with\u00a00 < i\u00a0< A.length - 1\u00a0such that:\tA[0] < A[1] < ... A[i-1] < A[i]A[i] > A[i+1] > ... > A[A.length - 1]Given a mountain\u00a0array mountainArr, return the minimum\u00a0index such that mountainArr.get(index) == target.\u00a0 If such an index\u00a0doesn't exist, return -1.You can't access the mountain array directly.\u00a0 You may only access the array using a\u00a0MountainArray\u00a0interface:MountainArray.get(k) returns the element of the array at index k\u00a0(0-indexed).MountainArray.length()\u00a0returns the length of the array.Submissions making more than 100 calls to\u00a0MountainArray.get\u00a0will be judged Wrong Answer.\u00a0 Also, any solutions that attempt to circumvent the judge\u00a0will result in disqualification.\u00a0": [
        "find-in-mountain-array",
        [
            "peak-index-in-a-mountain-array"
        ],
        [
            "Binary Search"
        ]
    ],
    "You are driving a vehicle that\u00a0has capacity empty seats initially available for passengers.\u00a0 The vehicle only drives east (ie. it cannot turn around and drive west.)Given a list of trips, trip[i] = [num_passengers, start_location, end_location]\u00a0contains information about the i-th trip: the number of passengers that must be picked up, and the locations to pick them up and drop them off.\u00a0 The locations are given as the number of kilometers\u00a0due east from your vehicle's initial location.Return true if and only if\u00a0it is possible to pick up and drop off all passengers for all the given trips.\u00a0\u00a0": [
        "car-pooling",
        [
            "meeting-rooms-ii"
        ],
        [
            "Greedy"
        ]
    ],
    "We sampled integers between 0 and 255, and stored the results in an array count:\u00a0 count[k] is the number of integers we sampled equal to k.Return the minimum, maximum, mean, median, and mode of the sample respectively, as an array of floating point numbers.\u00a0 The mode is guaranteed to be unique.(Recall that the median of a sample is:The middle element, if the elements of the sample were sorted and the number of elements is odd;The average of the middle two elements, if the elements of the sample were sorted and the number of elements is even.)\u00a0": [
        "statistics-from-a-large-sample",
        [],
        [
            "Math",
            "Two Pointers"
        ]
    ],
    "In an N by N square grid, each cell is either empty (0) or blocked (1).A\u00a0clear\u00a0path from top-left to bottom-right\u00a0has length k if and only if it is composed of cells C_1, C_2, ..., C_k\u00a0such that:Adjacent cells C_i and C_{i+1} are connected 8-directionally (ie., they are different and\u00a0share an edge or corner)C_1 is at location (0, 0) (ie. has value grid[0][0])C_k\u00a0is at location (N-1, N-1) (ie. has value grid[N-1][N-1])If C_i is located at\u00a0(r, c), then grid[r][c] is empty (ie.\u00a0grid[r][c] ==\u00a00).Return the length of the shortest such clear path from top-left to bottom-right.\u00a0 If such a path does not exist, return -1.\u00a0": [
        "shortest-path-in-binary-matrix",
        [],
        [
            "Breadth-first Search"
        ]
    ],
    "We have a set of items: the i-th item has value values[i] and label labels[i].Then, we choose\u00a0a subset S of these items, such that:|S| <= num_wantedFor every label L, the number of items in S with\u00a0label L is <= use_limit.Return the largest possible sum of the subset S.\u00a0": [
        "largest-values-from-labels",
        [],
        [
            "Hash Table",
            "Greedy"
        ]
    ],
    "Given a fixed length\u00a0array arr of integers, duplicate each occurrence of zero, shifting the remaining elements to the right.": [
        "duplicate-zeros",
        [],
        [
            "Array"
        ]
    ],
    "You have n\u00a0\u00a0tiles, where each tile has one letter tiles[i] printed on it.Return the number of possible non-empty sequences of letters you can make using the letters printed on those tiles.\u00a0": [
        "letter-tile-possibilities",
        [],
        [
            "Backtracking"
        ]
    ],
    "Return the lexicographically smallest subsequence of text that contains all the distinct characters of text exactly once.": [
        "smallest-subsequence-of-distinct-characters",
        [],
        [
            "String"
        ]
    ],
    "Given the root\u00a0of a binary tree, consider all root to leaf paths: paths from the root\u00a0to any leaf.\u00a0 (A leaf is a node with no children.)A node is insufficient if\u00a0every such root to leaf path intersecting this node has sum strictly less than\u00a0limit.Delete all insufficient nodes simultaneously, and return the root of the resulting\u00a0binary tree.\u00a0": [
        "insufficient-nodes-in-root-to-leaf-paths",
        [],
        [
            "Depth-first Search"
        ]
    ],
    "Given words first and second, consider occurrences in some\u00a0text of the form \"first second third\", where second comes immediately after first, and third comes immediately after second.For each such occurrence, add \"third\" to the answer, and return the answer.\u00a0": [
        "occurrences-after-bigram",
        [],
        [
            "Hash Table"
        ]
    ],
    "Given two numbers arr1 and arr2 in base -2, return the result of adding them together.Each number is given in array format:\u00a0 as an array of 0s and 1s, from most significant bit to least significant bit.\u00a0 ": [
        "adding-two-negabinary-numbers",
        [],
        [
            "Math"
        ]
    ],
    "Given a matrix consisting of 0s and 1s, we may choose any number of columns in the matrix and flip every\u00a0cell in that column.\u00a0 Flipping a cell changes the value of that cell from 0 to 1 or from 1 to 0.Return the maximum number of rows that have all values equal after some number of flips.\u00a0": [
        "flip-columns-for-maximum-number-of-equal-rows",
        [],
        [
            "Hash Table"
        ]
    ],
    "For two strings s and t, we say \"t divides s\" if and only if s = t + ... + t\u00a0 (t concatenated with itself 1 or more times)Given two strings str1 and str2, return the largest string x such that x divides both\u00a0str1\u00a0and str2.\u00a0": [
        "greatest-common-divisor-of-strings",
        [],
        [
            "String"
        ]
    ],
    "Given a matrix\u00a0and a target, return the number of non-empty submatrices that sum to target.A submatrix x1, y1, x2, y2 is the set of all cells matrix[x][y] with x1 <= x <= x2 and y1 <= y <= y2.Two submatrices (x1, y1, x2, y2) and (x1', y1', x2', y2') are different if they have some coordinate\u00a0that is different: for example, if x1 != x1'.\u00a0": [
        "number-of-submatrices-that-sum-to-target",
        [],
        [
            "Array",
            "Dynamic Programming",
            "Sliding Window"
        ]
    ],
    "In a warehouse, there is a row of barcodes, where the i-th barcode is\u00a0barcodes[i].Rearrange the barcodes so that no two adjacent barcodes are equal.\u00a0 You may return any answer, and it is guaranteed an answer exists.\u00a0": [
        "distant-barcodes",
        [],
        [
            "Heap",
            "Sort"
        ]
    ],
    "Given an array A of positive integers (not necessarily distinct), return the lexicographically largest permutation that is smaller than A, that can be made with one swap (A swap exchanges the positions of two numbers A[i] and A[j]).\u00a0 If it cannot be done, then return the same array.\u00a0": [
        "previous-permutation-with-one-swap",
        [],
        [
            "Array",
            "Greedy"
        ]
    ],
    "Today, the bookstore owner has a store open for customers.length minutes.\u00a0 Every minute, some number of customers (customers[i]) enter the store, and all those customers leave after the end of that minute.On some minutes, the bookstore owner is grumpy.\u00a0 If the bookstore owner is grumpy on the i-th minute, grumpy[i] = 1, otherwise grumpy[i] = 0.\u00a0 When the bookstore owner is grumpy, the customers of that minute are not satisfied, otherwise they are satisfied.The bookstore owner knows a secret technique to keep themselves\u00a0not grumpy for X\u00a0minutes straight, but can only use it once.Return the maximum number of customers that can be satisfied throughout the day.\u00a0": [
        "grumpy-bookstore-owner",
        [],
        [
            "Array",
            "Sliding Window"
        ]
    ],
    "Students are asked to stand in non-decreasing order of heights for an annual photo.Return the minimum number of students that must move in order for all students to be standing in non-decreasing order of height.Notice that when a group of students is selected they can reorder in any possible way between themselves and the non selected students\u00a0remain on their seats.\u00a0": [
        "height-checker",
        [],
        [
            "Array"
        ]
    ],
    "Given a string s, return the last substring of s in lexicographical order.\u00a0": [
        "last-substring-in-lexicographical-order",
        [],
        [
            "String",
            "Suffix Array"
        ]
    ],
    "We have a collection of rocks, each rock has a positive integer weight.Each turn, we choose any two rocks\u00a0and smash them together.\u00a0 ": [
        "last-stone-weight-ii",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Given a list of words, each word consists of English lowercase letters.Let's say word1 is a predecessor of word2\u00a0if and only if we can add exactly one letter anywhere in word1 to make it equal to word2.\u00a0 ": [
        "longest-string-chain",
        [],
        [
            "Hash Table",
            "Dynamic Programming"
        ]
    ],
    "Given a string S of lowercase letters, a duplicate removal consists of choosing two adjacent and equal letters, and removing\u00a0them.We repeatedly make duplicate removals on S until we no longer can.Return the final string after all such duplicate removals have been made.\u00a0 It is guaranteed the answer is unique.\u00a0": [
        "remove-all-adjacent-duplicates-in-string",
        [
            "remove-all-adjacent-duplicates-in-string-ii"
        ],
        [
            "Stack"
        ]
    ],
    "We have a collection of stones, each stone\u00a0has a positive integer weight.Each turn, we choose the two heaviest\u00a0stones\u00a0and smash them together.\u00a0 ": [
        "last-stone-weight",
        [],
        [
            "Heap",
            "Greedy"
        ]
    ],
    "Given a string S, consider all duplicated substrings: (contiguous) substrings of S that occur 2 or more times.\u00a0 (The occurrences\u00a0may overlap.)Return any duplicated\u00a0substring that has the longest possible length.\u00a0 (If S does not have a duplicated substring, the answer is \"\".)\u00a0": [
        "longest-duplicate-substring",
        [],
        [
            "Hash Table",
            "Binary Search"
        ]
    ],
    "Given an integer array arr, you should partition the array into (contiguous) subarrays of length at most k. After partitioning, each subarray has their values changed to become the maximum value of that subarray.Return the largest sum of the given array after partitioning.\u00a0": [
        "partition-array-for-maximum-sum",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "You have N gardens, labelled 1 to N.\u00a0 In each garden, you want to plant one of 4 types of flowers.paths[i] = [x, y] describes the existence of a bidirectional path from garden x to garden y.Also, there is no garden that has more than 3 paths coming into or leaving it.Your task is to choose a flower type for each garden such that,\u00a0for any two gardens connected by a path, they have different types of flowers.Return any such a choice as an array answer, where\u00a0answer[i] is the type of flower\u00a0planted in the (i+1)-th garden.\u00a0 The flower types are denoted\u00a01, 2, 3, or 4.\u00a0 It is guaranteed an answer exists.\u00a0": [
        "flower-planting-with-no-adjacent",
        [],
        [
            "Graph"
        ]
    ],
    "On an infinite plane, a\u00a0robot initially stands at (0, 0) and faces north.\u00a0\u00a0The robot can receive one of three instructions:\"G\": go straight 1 unit;\"L\": turn 90 degrees to the left;\"R\": turn 90 degress to the right.The robot performs the instructions given in order, and repeats them forever.Return true if and only if there exists a circle in the plane such that the robot never leaves the circle.\u00a0": [
        "robot-bounded-in-circle",
        [],
        [
            "Math"
        ]
    ],
    "Given an N x N grid\u00a0containing only values 0 and 1, where\u00a00 represents water\u00a0and 1 represents land, find a water cell such that its distance to the nearest land cell is maximized and return the distance.The distance used in this problem is the Manhattan distance:\u00a0the distance between two cells (x0, y0) and (x1, y1) is |x0 - x1| + |y0 - y1|.If no land or water exists in the grid, return -1.\u00a0": [
        "as-far-from-land-as-possible",
        [
            "shortest-distance-from-all-buildings"
        ],
        [
            "Breadth-first Search",
            "Graph"
        ]
    ],
    "Given the root of a binary tree, the level of its root is 1,\u00a0the level of its children is 2,\u00a0and so on.Return the smallest level X such that the sum of all the values of nodes at level X is maximal.\u00a0": [
        "maximum-level-sum-of-a-binary-tree",
        [],
        [
            "Graph"
        ]
    ],
    "A boomerang is a set of 3 points that are all distinct and not in a straight line.Given a list\u00a0of three points in the plane, return whether these points are a boomerang.\u00a0": [
        "valid-boomerang",
        [],
        [
            "Math"
        ]
    ],
    "Given the root of a binary search tree with distinct values, modify it so that every node\u00a0has a new value equal to the sum of the values of the original tree that are greater than or equal to node.val.As a reminder, a\u00a0binary search tree is a tree that satisfies these constraints:The left subtree of a node contains only nodes with keys\u00a0less than\u00a0the node's key.The right subtree of a node contains only nodes with keys\u00a0greater than\u00a0the node's key.Both the left and right subtrees must also be binary search trees.\u00a0": [
        "binary-search-tree-to-greater-sum-tree",
        [],
        [
            "Binary Search Tree"
        ]
    ],
    "On an infinite number line, the position of the i-th stone is given by\u00a0stones[i].\u00a0 Call a stone an endpoint stone if it has the smallest or largest position.Each turn, you pick up an endpoint stone and move it to an unoccupied position so that it is no longer an endpoint stone.In particular,\u00a0if the stones are at say, stones = [1,2,5], you cannot move the endpoint stone at position 5, since moving it to any position (such as 0, or 3) will still keep that stone as an endpoint stone.The game ends when you cannot make any more moves, ie. the stones are in consecutive positions.When the game ends, what is the minimum and maximum number of moves that you could have made?\u00a0 Return the answer as an length 2 array:\u00a0answer = [minimum_moves, maximum_moves]\u00a0": [
        "moving-stones-until-consecutive-ii",
        [],
        [
            "Array",
            "Sliding Window"
        ]
    ],
    "You are given an array of strings\u00a0words\u00a0and a string\u00a0chars.A string is good\u00a0if\u00a0it can be formed by\u00a0characters from chars\u00a0(each character\u00a0can only be used once).Return the sum of lengths of all good strings in words.\u00a0": [
        "find-words-that-can-be-formed-by-characters",
        [],
        [
            "Array",
            "Hash Table"
        ]
    ],
    "Given N, consider a convex N-sided polygon with vertices labelled A[0], A[i], ..., A[N-1]\u00a0in clockwise order.": [
        "minimum-score-triangulation-of-polygon",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "In a 1 million by 1 million grid, the coordinates of each grid square are (x, y) with 0 <= x, y < 10^6.We start at the source square and want to reach the target square.\u00a0 Each move, we can walk to a 4-directionally adjacent square in the grid that isn't in the given list of blocked squares.Return true if and only if it is possible to reach the target square through a sequence of moves.\u00a0": [
        "escape-a-large-maze",
        [],
        [
            "Breadth-first Search"
        ]
    ],
    "We write the integers of A and B\u00a0(in the order they are given) on two separate horizontal lines.Now, we may draw connecting lines: a straight line connecting two numbers A[i] and B[j]\u00a0such that:A[i] == B[j];The line we draw does not intersect any other connecting (non-horizontal) line.": [
        "uncrossed-lines",
        [
            "edit-distance"
        ],
        [
            "Array"
        ]
    ],
    "Given a 2-dimensional\u00a0grid of integers, each value in the grid represents the color of the grid square at that location.Two squares belong to the same connected component if and only if they have the same color and are next to each other in any of the 4 directions.The\u00a0border of a connected component is\u00a0all the squares in the connected component that are\u00a0either 4-directionally adjacent to\u00a0a square not in the component, or on the boundary of the grid (the first or last row or column).Given a square at location\u00a0(r0, c0)\u00a0in the grid and a color, color the\u00a0border of the connected component of that square with the given color, and return the final grid.\u00a0": [
        "coloring-a-border",
        [
            "island-perimeter"
        ],
        [
            "Depth-first Search"
        ]
    ],
    "Three stones are on a number line at positions a, b, and c.Each turn, you pick up a stone at an endpoint (ie., either the lowest or highest position stone), and move it to an unoccupied position between those\u00a0endpoints.\u00a0 ": [
        "moving-stones-until-consecutive",
        [],
        [
            "Brainteaser"
        ]
    ],
    "Implement the StreamChecker class as follows:StreamChecker(words): Constructor, init the data structure with the given words.query(letter): returns true if and only if for some k >= 1, the last k\u00a0characters queried (in order from oldest to newest, including this letter just queried) spell one of the words in the given list.\u00a0": [
        "stream-of-characters",
        [],
        [
            "Trie"
        ]
    ],
    "Given an array A of non-negative integers, return the maximum sum of elements in two non-overlapping (contiguous) subarrays, which have lengths\u00a0L and M.\u00a0 (For clarification, the L-length subarray could occur before or after the M-length subarray.)Formally,\u00a0return the largest V for which\u00a0V = (A[i] + A[i+1] + ... + A[i+L-1]) + (A[j] + A[j+1] + ... + A[j+M-1]) and either:0 <= i < i + L - 1 < j < j + M - 1 < A.length, or0 <= j < j + M - 1 < i < i + L - 1 < A.length.\u00a0": [
        "maximum-sum-of-two-non-overlapping-subarrays",
        [],
        [
            "Array"
        ]
    ],
    "A company is planning to interview 2n people. Given the array costs where costs[i] = [aCosti, bCosti],\u00a0the cost of flying the ith person to city a is aCosti, and the cost of flying the ith person to city b is bCosti.Return the minimum cost to fly every person to a city such that exactly n people arrive in each city.\u00a0": [
        "two-city-scheduling",
        [],
        [
            "Greedy"
        ]
    ],
    "We are given a matrix with R rows and C columns has cells with integer coordinates\u00a0(r, c), where 0 <= r < R and 0 <= c < C.Additionally, we are given a cell in that matrix with coordinates\u00a0(r0, c0).Return the coordinates of\u00a0all cells in the matrix, sorted by their distance from (r0, c0)\u00a0from smallest distance to largest distance.\u00a0 Here,\u00a0the distance between two cells (r1, c1) and (r2, c2) is the Manhattan distance,\u00a0|r1 - r2| + |c1 - c2|.\u00a0 (You may return the answer in any order that satisfies this condition.)\u00a0": [
        "matrix-cells-in-distance-order",
        [],
        [
            "Sort"
        ]
    ],
    "We run a\u00a0preorder\u00a0depth first search on the root of a binary tree.At each node in this traversal, we output D dashes (where D is the depth of this node), then we output the value of this node.\u00a0\u00a0(If the depth of a node is D, the depth of its immediate child is D+1.\u00a0 The depth of the root node is 0.)If a node has only one child, that child is guaranteed to be the left child.Given the output S of this traversal, recover the tree and return its root.\u00a0": [
        "recover-a-tree-from-preorder-traversal",
        [],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given the root of a binary tree, find the maximum value V for which there exists different nodes A and B where V = |A.val - B.val|\u00a0and A is an ancestor of B.(A node A is an ancestor of B if either: any child of A is equal to B, or any child of A is an ancestor of B.)\u00a0": [
        "maximum-difference-between-node-and-ancestor",
        [],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given an array A of integers, return the length of the longest arithmetic subsequence in A.Recall that a subsequence of A is a list A[i_1], A[i_2], ..., A[i_k] with 0 <= i_1 < i_2 < ... < i_k <= A.length - 1, and that a sequence B\u00a0is arithmetic if B[i+1] - B[i] are all the same value (for 0 <= i < B.length - 1).\u00a0": [
        "longest-arithmetic-subsequence",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Alice and Bob take turns playing a game, with Alice starting first.Initially, there is a number N\u00a0on the chalkboard.\u00a0 On each player's turn, that player makes a move\u00a0consisting of:Choosing\u00a0any x with 0 < x < N and N % x == 0.Replacing\u00a0the number\u00a0N\u00a0on the chalkboard with N - x.Also, if a player cannot make a move, they lose the game.Return True if and only if Alice wins the game, assuming both players play optimally.\u00a0": [
        "divisor-game",
        [],
        [
            "Math",
            "Dynamic Programming"
        ]
    ],
    "You are given a series of video clips from a sporting event that lasted T seconds.\u00a0\u00a0These video clips can be overlapping with each other and have varied lengths.Each video clip clips[i]\u00a0is an interval: it starts at time clips[i][0] and ends at time clips[i][1].\u00a0 We can cut these clips into segments freely: for example, a clip [0, 7] can be cut into segments\u00a0[0, 1] +\u00a0[1, 3] + [3, 7].Return the minimum number of clips needed so that we can cut the clips into segments that cover the entire sporting event ([0, T]).\u00a0 If the task is impossible, return -1.\u00a0": [
        "video-stitching",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "A query word matches a given pattern if we can insert lowercase letters to the pattern word so that it equals the query. (We may insert each character at any position, and may insert 0 characters.)Given a list of queries, and a pattern, return an answer list of booleans, where answer[i] is true if and only if queries[i] matches the pattern.\u00a0": [
        "camelcase-matching",
        [],
        [
            "String",
            "Trie"
        ]
    ],
    "Given a binary tree, each node has value 0\u00a0or 1.\u00a0 Each root-to-leaf path represents a binary number starting with the most significant bit.\u00a0 ": [
        "sum-of-root-to-leaf-binary-numbers",
        [],
        [
            "Tree"
        ]
    ],
    "A valid parentheses string is either empty (\"\"), \"(\" + A + \")\", or A + B, where A and B are valid parentheses strings, and + represents string concatenation.\u00a0 ": [
        "remove-outermost-parentheses",
        [],
        [
            "Stack"
        ]
    ],
    "Given a 2D array A, each cell is 0 (representing sea) or 1 (representing land)A move consists of walking from one land square 4-directionally to another land square, or off the boundary of the grid.Return the number of land squares in the grid for which we cannot walk off the boundary of the grid in any number of moves.\u00a0": [
        "number-of-enclaves",
        [],
        [
            "Depth-first Search"
        ]
    ],
    "We are given a linked list with\u00a0head\u00a0as the first node.\u00a0 Let's number the\u00a0nodes in the list: node_1, node_2, node_3, ... etc.Each node may have a next larger value: for node_i,\u00a0next_larger(node_i)\u00a0is the node_j.val such that j > i, node_j.val > node_i.val, and j is the smallest possible choice.\u00a0 If such a j\u00a0does not exist, the next larger value is 0.Return an array of integers\u00a0answer, where answer[i] = next_larger(node_{i+1}).": [
        "next-greater-node-in-linked-list",
        [],
        [
            "Linked List",
            "Stack"
        ]
    ],
    "Given an array A of 0s and 1s, consider N_i: the i-th subarray from A[0] to A[i]\u00a0interpreted\u00a0as a binary number (from most-significant-bit to least-significant-bit.)Return a list of booleans\u00a0answer, where answer[i] is true\u00a0if and only if N_i\u00a0is divisible by 5.": [
        "binary-prefix-divisible-by-5",
        [],
        [
            "Array"
        ]
    ],
    "Given a number N, return a string consisting of \"0\"s and \"1\"s\u00a0that represents its value in base -2\u00a0(negative two).The returned string must have no leading zeroes, unless the string is \"0\".\u00a0": [
        "convert-to-base-2",
        [
            "encode-number"
        ],
        [
            "Math"
        ]
    ],
    "Given a binary string S (a string consisting only of '0' and '1's) and a positive integer N, return true if and only if for every integer X from 1 to N, the binary representation of X is a substring of S.\u00a0": [
        "binary-string-with-substrings-representing-1-to-n",
        [],
        [
            "String"
        ]
    ],
    "Given a positive integer K, you need find the smallest\u00a0positive integer N such that N is divisible by K, and N only contains the digit 1.Return the\u00a0length of N.\u00a0 If there is no such N,\u00a0return -1.\u00a0": [
        "smallest-integer-divisible-by-k",
        [],
        [
            "Math"
        ]
    ],
    "Given an array A of positive integers, A[i] represents the value of the i-th sightseeing spot, and two\u00a0sightseeing spots i and j\u00a0have distance j - i\u00a0between them.The score\u00a0of a pair (i < j) of sightseeing spots is (A[i] + A[j] + i\u00a0- j) : the sum of the values of the sightseeing spots, minus the distance between them.Return the maximum score of a pair of sightseeing spots.\u00a0": [
        "best-sightseeing-pair",
        [],
        [
            "Array"
        ]
    ],
    "Given an array A of integers, return true if and only if we can partition the array into three non-empty parts with equal sums.": [
        "partition-array-into-three-parts-with-equal-sum",
        [],
        [
            "Array"
        ]
    ],
    "Given a positive integer N, return the number of positive integers less than or equal to N that have at least 1 repeated digit.\u00a0": [
        "numbers-with-repeated-digits",
        [],
        [
            "Math",
            "Dynamic Programming"
        ]
    ],
    "A conveyor belt has packages that must be shipped from one port to another within D days.The i-th package on the conveyor belt has a weight of weights[i].\u00a0 Each day, we load the ship with packages on the conveyor belt (in the order given by weights). We may not load more weight than the maximum weight capacity of the ship.Return the least weight capacity of the ship that will result in all the packages on the conveyor belt being shipped within D days.\u00a0": [
        "capacity-to-ship-packages-within-d-days",
        [],
        [
            "Array",
            "Binary Search"
        ]
    ],
    "In a list of songs, the i-th\u00a0song has a duration of\u00a0time[i] seconds.\u00a0Return the number of pairs of songs for which their total\u00a0duration in seconds is divisible by 60.\u00a0 ": [
        "pairs-of-songs-with-total-durations-divisible-by-60",
        [],
        [
            "Array"
        ]
    ],
    "Every non-negative integer N\u00a0has a binary representation.\u00a0 ": [
        "complement-of-base-10-integer",
        [],
        [
            "Math"
        ]
    ],
    "Return the root node of a binary search tree that matches the given preorder traversal.(Recall that a binary search tree\u00a0is a binary tree where for every node, any descendant of node.left has a value <\u00a0node.val, and any descendant of node.right has a value >\u00a0node.val.\u00a0 Also recall that a preorder traversal\u00a0displays the value of the\u00a0node first, then traverses node.left, then traverses node.right.)It's guaranteed that for the given test cases there is always possible to find a binary search tree with the given requirements.": [
        "construct-binary-search-tree-from-preorder-traversal",
        [],
        [
            "Tree"
        ]
    ],
    "In a row of dominoes, A[i] and B[i] represent the top and bottom halves of the i-th domino.\u00a0 (A domino is a tile with two numbers from 1 to 6 - one on each half of the tile.)We may rotate the i-th domino, so that A[i] and B[i] swap values.Return the minimum number of rotations so that all the values in A are the same, or all the values in B\u00a0are the same.If it cannot be done, return -1.\u00a0": [
        "minimum-domino-rotations-for-equal-row",
        [],
        [
            "Array",
            "Greedy"
        ]
    ],
    "Normally, the factorial of a positive integer n\u00a0is the product of all positive integers less than or equal to n.\u00a0 ": [
        "clumsy-factorial",
        [],
        [
            "Math"
        ]
    ],
    "Given an array A of integers, we must\u00a0modify the array in the following way: we choose an i\u00a0and replace\u00a0A[i] with -A[i], and we repeat this process K times in total.\u00a0 (We may choose the same index i multiple times.)Return the largest possible sum of the array after modifying it in this way.\u00a0": [
        "maximize-sum-of-array-after-k-negations",
        [],
        [
            "Greedy"
        ]
    ],
    "Given an array A\u00a0of 0s and 1s, we may change up to K\u00a0values from 0 to 1.Return the length of the longest (contiguous) subarray that contains only 1s.\u00a0\u00a0": [
        "max-consecutive-ones-iii",
        [
            "max-consecutive-ones-ii",
            "max-consecutive-ones",
            "longest-repeating-character-replacement",
            "longest-substring-with-at-most-k-distinct-characters"
        ],
        [
            "Two Pointers",
            "Sliding Window"
        ]
    ],
    "We can say that a string is valid if it follows one of the three following cases:An empty string \"\" is valid.The string \"abc\" is also valid.Any string in the form \"a\" + str + \"bc\", \"ab\" + str + \"c\", str + \"abc\" or \"abc\" + str where str is a valid string is also considered a valid string.": [
        "check-if-word-is-valid-after-substitutions",
        [
            "valid-parentheses"
        ],
        [
            "String",
            "Stack"
        ]
    ],
    "Given an array\u00a0A of strings made only from lowercase letters, return a list of all characters that show up in all strings within the list (including duplicates).\u00a0\u00a0": [
        "find-common-characters",
        [
            "intersection-of-two-arrays-ii"
        ],
        [
            "Array",
            "Hash Table"
        ]
    ],
    "Given a grid of size N x N, each cell of this grid has a lamp which is intially turned off.Given an array of lamp positions lamps, where lamps[i] = [xi, yi] indicates that the lamp at grid[xi][yi] will be turned on. When a lamp is turned on, it illiminates its cell and any cell in the same row, column or diagonal with this this cell.Then you will be given a query array queries, where\u00a0queries[i] = [xi, yi]. For the ith\u00a0query, you should answer whether grid[xi][yi] is illuminated or not. After answering the ith query, you should turn off the lamp at\u00a0grid[xi][yi] and all of its 8 adjacent lamps if they exist\u00a0(i,e, lamps at adjacent cell which share side or diagonal).Return an array of integers ans where each\u00a0value ans[i] should be equal to the answer of the ith query queries[i].\u00a0": [
        "grid-illumination",
        [
            "n-queens"
        ],
        [
            "Hash Table"
        ]
    ],
    "There are N piles of stones arranged in a row.\u00a0 The i-th pile has stones[i] stones.A move consists of merging exactly\u00a0K\u00a0consecutive piles into one pile, and the cost of this move is equal to the total number of stones in these K piles.Find the minimum cost to merge all piles of stones into one pile.\u00a0 If it is impossible, return -1.\u00a0": [
        "minimum-cost-to-merge-stones",
        [
            "minimum-cost-to-connect-sticks",
            "burst-balloons"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "On an 8 x 8 chessboard, there is one white rook.\u00a0 There also may be empty squares, white bishops, and black pawns.\u00a0 These are given as characters 'R', '.', 'B', and 'p' respectively. Uppercase characters represent white pieces, and lowercase characters represent black pieces.The rook moves as in the rules of Chess: it chooses one of four cardinal directions (north, east, west, and south), then moves in that direction until it chooses to stop, reaches the edge of the board, or captures an opposite colored pawn by moving to the same square it occupies.\u00a0 Also, rooks cannot move into the same square as other friendly bishops.Return the number of pawns the rook can capture in one move.\u00a0": [
        "available-captures-for-rook",
        [],
        [
            "Array"
        ]
    ],
    "We are given the root\u00a0node of a maximum tree: a tree where every node has a value greater than any other value in its subtree.Just as in the previous problem, the given tree\u00a0was constructed from an list\u00a0A\u00a0(root = Construct(A)) recursively with the following\u00a0Construct(A) routine:If A is empty, return null.Otherwise, let A[i] be the largest element of A.\u00a0 Create a root node with value A[i].The left child of root will be Construct([A[0], A[1], ..., A[i-1]])The right child of root\u00a0will be Construct([A[i+1], A[i+2], ..., A[A.length - 1]])Return root.": [
        "maximum-binary-tree-ii",
        [
            "maximum-binary-tree"
        ],
        [
            "Tree"
        ]
    ],
    "In a town, there are N people labelled from\u00a01 to N.\u00a0 There is a rumor that one of these people is secretly the town judge.If the\u00a0town judge exists, then:The town judge trusts nobody.Everybody (except for the town judge) trusts the town judge.There is exactly one person that satisfies properties 1 and 2.You are given trust, an array of pairs trust[i] = [a, b] representing that the person labelled a trusts the person labelled b.If the town judge exists and can be identified, return the label of the town judge.\u00a0 Otherwise, return -1.\u00a0": [
        "find-the-town-judge",
        [
            "find-the-celebrity"
        ],
        [
            "Graph"
        ]
    ],
    "Given an array A of non-negative integers, the array is squareful if for every pair of adjacent elements, their sum is a perfect square.Return the number of permutations of A that are squareful.\u00a0 Two permutations A1 and A2 differ if and only if there is some index i such that A1[i] != A2[i].\u00a0": [
        "number-of-squareful-arrays",
        [
            "permutations-ii"
        ],
        [
            "Math",
            "Backtracking",
            "Graph"
        ]
    ],
    "In an array A containing only 0s and 1s, a K-bit flip\u00a0consists of choosing a (contiguous) subarray of length K and simultaneously changing every 0 in the subarray to 1, and every 1 in the subarray to 0.Return the minimum number of K-bit flips required so that there is no 0 in the array.\u00a0 If it is not possible, return -1.\u00a0": [
        "minimum-number-of-k-consecutive-bit-flips",
        [
            "bulb-switcher"
        ],
        [
            "Greedy",
            "Sliding Window"
        ]
    ],
    "In a given grid, each cell can have one of three\u00a0values:the value 0 representing an empty cell;the value 1 representing a fresh orange;the value 2 representing a rotten orange.Every minute, any fresh orange that is adjacent (4-directionally) to a rotten orange becomes rotten.Return the minimum number of minutes that must elapse until no cell has a fresh orange.\u00a0 If this is impossible, return -1 instead.\u00a0": [
        "rotting-oranges",
        [
            "walls-and-gates"
        ],
        [
            "Breadth-first Search"
        ]
    ],
    "In a binary tree, the root node is at depth 0, and children of each depth k node are at depth k+1.Two nodes of a binary tree are cousins if they have the same depth, but have different parents.We are given the root of a binary tree with unique values, and the values x\u00a0and y\u00a0of two different nodes in the tree.Return\u00a0true\u00a0if and only if the nodes corresponding to the values x and y are cousins.\u00a0": [
        "cousins-in-binary-tree",
        [
            "binary-tree-level-order-traversal"
        ],
        [
            "Tree",
            "Breadth-first Search"
        ]
    ],
    "Given an array A of positive integers, call a (contiguous, not necessarily distinct) subarray of A good if the number of different integers in that subarray is exactly K.(": [
        "subarrays-with-k-different-integers",
        [
            "longest-substring-with-at-most-k-distinct-characters",
            "longest-substring-with-at-most-two-distinct-characters",
            "longest-substring-without-repeating-characters"
        ],
        [
            "Hash Table",
            "Two Pointers",
            "Sliding Window"
        ]
    ],
    "On a broken calculator that has a number showing on its display, we can perform two operations:Double: Multiply the number on the display by 2, or;Decrement: Subtract 1 from the number on the display.Initially, the calculator is displaying the number X.Return the minimum number of operations needed to display the number Y.\u00a0": [
        "broken-calculator",
        [
            "2-keys-keyboard"
        ],
        [
            "Math",
            "Greedy"
        ]
    ],
    "Given an array equations\u00a0of strings that represent relationships between variables, each string equations[i]\u00a0has length 4 and takes one of two different forms: \"a==b\" or \"a!=b\".\u00a0 Here, a and b are lowercase letters (not necessarily different) that represent one-letter variable names.Return true\u00a0if and only if it is possible to assign integers to variable names\u00a0so as to satisfy all the given equations.\u00a0": [
        "satisfiability-of-equality-equations",
        [],
        [
            "Union Find",
            "Graph"
        ]
    ],
    "For a non-negative integer X, the\u00a0array-form of X\u00a0is an array of its digits in left to right order.\u00a0 ": [
        "add-to-array-form-of-integer",
        [
            "add-strings",
            "add-binary",
            "plus-one",
            "add-two-numbers"
        ],
        [
            "Array"
        ]
    ],
    "Given the root of a binary tree, each node has a value from 0 to 25 representing the letters 'a' to 'z': a value of 0 represents 'a', a value of 1 represents 'b', and so on.Find the lexicographically smallest string that starts at a leaf of this tree and ends at the root.(As a reminder, any shorter prefix of a string is lexicographically smaller: for example, \"ab\" is lexicographically smaller than \"aba\".\u00a0 A leaf of a node is a node that has no children.)\u00a0": [
        "smallest-string-starting-from-leaf",
        [
            "binary-tree-paths",
            "sum-root-to-leaf-numbers"
        ],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given a binary tree, return the vertical order traversal of its nodes\u00a0values.For each node at position (X, Y), its left and right children respectively\u00a0will be at positions (X-1, Y-1) and (X+1, Y-1).Running a vertical line from X = -infinity to X = +infinity, whenever the vertical line touches some nodes, we report the values of the nodes in order from top to bottom (decreasing Y coordinates).If two nodes have the same position, then the value of the node that is reported first is the value that is smaller.Return an list\u00a0of non-empty reports in order of X coordinate.\u00a0 Every report will have a list of values of nodes.\u00a0": [
        "vertical-order-traversal-of-a-binary-tree",
        [],
        [
            "Hash Table",
            "Tree"
        ]
    ],
    "Given two lists\u00a0of closed intervals, each list of intervals is pairwise disjoint and in sorted order.Return the intersection of these two interval lists.(": [
        "interval-list-intersections",
        [
            "employee-free-time",
            "merge-sorted-array",
            "merge-intervals"
        ],
        [
            "Two Pointers"
        ]
    ],
    "We have an array A of integers, and an array queries\u00a0of queries.For the i-th\u00a0query val =\u00a0queries[i][0], index\u00a0= queries[i][1], we add val\u00a0to A[index].\u00a0 Then, the answer to the i-th query is the sum of the even values of A.(Here, the given index = queries[i][1] is a 0-based index, and each query permanently modifies the array A.)Return the answer to all queries.\u00a0 Your answer array should have\u00a0answer[i]\u00a0as\u00a0the answer to the i-th query.\u00a0": [
        "sum-of-even-numbers-after-queries",
        [],
        [
            "Array"
        ]
    ],
    "Given two integers A and B, return any string S such that:S has length A + B and contains exactly A 'a' letters, and exactly B 'b' letters;The substring\u00a0'aaa'\u00a0does not occur in S;The substring 'bbb' does not occur in S.\u00a0": [
        "string-without-aaa-or-bbb",
        [],
        [
            "Greedy"
        ]
    ],
    "In a country popular for train travel, you\u00a0have planned some train travelling one year in advance.\u00a0 The days of the year that you will travel is given as an array days.\u00a0 Each day is an integer from 1 to 365.Train tickets are sold in 3 different ways:a 1-day pass is sold for costs[0] dollars;a 7-day pass is sold for costs[1] dollars;a 30-day pass is sold for costs[2] dollars.The passes allow that many days of consecutive travel.\u00a0 ": [
        "minimum-cost-for-tickets",
        [
            "coin-change"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Given an array of integers A, find the number of\u00a0triples of indices (i, j, k)\u00a0such that:0 <= i < A.length0 <= j < A.length0 <= k < A.lengthA[i]\u00a0& A[j]\u00a0& A[k] == 0, where &\u00a0represents the bitwise-AND operator.\u00a0": [
        "triples-with-bitwise-and-equal-to-zero",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Create a timebased key-value store class\u00a0TimeMap, that supports two operations.1. set(string key, string value, int timestamp)Stores the key and value, along with the given timestamp.2. get(string key, int timestamp)Returns a value such that set(key, value, timestamp_prev) was called previously, with timestamp_prev <= timestamp.If there are multiple such values, it returns the one with the largest timestamp_prev.If there are no values, it returns the empty string (\"\").\u00a0": [
        "time-based-key-value-store",
        [],
        [
            "Hash Table",
            "Binary Search"
        ]
    ],
    "On a 2-dimensional\u00a0grid, there are 4 types of squares:1 represents the starting square.\u00a0 There is exactly one starting square.2 represents the ending square.\u00a0 There is exactly one ending square.0 represents empty squares we can walk over.-1 represents obstacles that we cannot walk over.Return the number of 4-directional walks\u00a0from the starting square to the ending square, that walk over every non-obstacle square\u00a0exactly once.\u00a0": [
        "unique-paths-iii",
        [
            "word-search-ii",
            "unique-paths-ii",
            "sudoku-solver"
        ],
        [
            "Backtracking",
            "Depth-first Search"
        ]
    ],
    "Given the root of a binary tree with N nodes, each node\u00a0in the tree has node.val coins, and there are N coins total.In one move, we may choose two adjacent nodes and move one coin from one node to another.\u00a0 (The move may be from parent to child, or from child to parent.)Return the number of moves required to make every node have exactly one coin.\u00a0": [
        "distribute-coins-in-binary-tree",
        [
            "binary-tree-cameras",
            "sum-of-distances-in-tree"
        ],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "A subarray A[i], A[i+1], ..., A[j]\u00a0of A is said to be turbulent if and only if:For i <= k < j, A[k] > A[k+1] when k is odd, and A[k] < A[k+1] when k is even;OR, for i <= k < j, A[k] > A[k+1] when k is even, and A[k] < A[k+1] when k is odd.That is, the subarray is turbulent if the comparison sign flips between each adjacent pair of elements in the subarray.Return the length of a\u00a0maximum size turbulent subarray of A.\u00a0": [
        "longest-turbulent-subarray",
        [
            "maximum-subarray"
        ],
        [
            "Array",
            "Dynamic Programming",
            "Sliding Window"
        ]
    ],
    "Given an array of integers A\u00a0sorted in non-decreasing order,\u00a0return an array of the squares of each number,\u00a0also in sorted non-decreasing order.\u00a0": [
        "squares-of-a-sorted-array",
        [
            "sort-transformed-array",
            "merge-sorted-array"
        ],
        [
            "Array",
            "Two Pointers"
        ]
    ],
    "Given an array A of positive lengths, return the largest perimeter of a triangle with non-zero area, formed from 3 of these lengths.If it is impossible to form any\u00a0triangle of non-zero area, return 0.\u00a0": [
        "largest-perimeter-triangle",
        [
            "largest-triangle-area"
        ],
        [
            "Math",
            "Sort"
        ]
    ],
    "You are given an integer array A.\u00a0 From\u00a0some starting index, you can make a series of jumps.\u00a0 The (1st, 3rd, 5th, ...)\u00a0jumps in the series are called odd numbered jumps, and the (2nd, 4th, 6th, ...) jumps in the series are called even numbered jumps.You may from index i\u00a0jump forward to index j\u00a0(with i\u00a0< j) in the following way:During odd numbered jumps (ie. jumps 1, 3, 5, ...), you jump to the index j\u00a0such that A[i] <= A[j] and A[j] is the smallest possible value.\u00a0 If there are multiple such indexes j, you can only jump to the smallest such index j.During even numbered jumps (ie. jumps 2, 4, 6, ...), you jump to the index j\u00a0such that A[i] >= A[j] and A[j] is the largest\u00a0possible value.\u00a0 If there are multiple such indexes j, you can only jump to the smallest such index j.(It may be the case that for some index i, there are no legal jumps.)A starting index is good if, starting from that index, you can reach the end of the array (index A.length - 1) by jumping some number of times (possibly 0 or more than once.)Return the number of good starting indexes.\u00a0": [
        "odd-even-jump",
        [],
        [
            "Dynamic Programming",
            "Stack",
            "Ordered Map"
        ]
    ],
    "Given an array A of integers, return the number of (contiguous, non-empty) subarrays that have a sum divisible by K.\u00a0": [
        "subarray-sums-divisible-by-k",
        [
            "subarray-sum-equals-k"
        ],
        [
            "Array",
            "Hash Table"
        ]
    ],
    "We have a list of points\u00a0on the plane.\u00a0 Find the K closest points to the origin (0, 0).(Here, the distance between two points on a plane is the Euclidean distance.)You may return the answer in any order.\u00a0 The\u00a0answer is guaranteed to be unique (except for the order that it is in.)\u00a0": [
        "k-closest-points-to-origin",
        [
            "top-k-frequent-words",
            "top-k-frequent-elements",
            "kth-largest-element-in-an-array"
        ],
        [
            "Divide and Conquer",
            "Heap",
            "Sort"
        ]
    ],
    "The\u00a0Fibonacci numbers, commonly denoted\u00a0F(n)\u00a0form a sequence, called the\u00a0Fibonacci sequence, such that each number is the sum of the two preceding ones, starting from 0 and 1. That is,F(0) = 0,\u00a0 \u00a0F(1)\u00a0= 1F(N) = F(N - 1) + F(N - 2), for N > 1.Given N, calculate F(N).\u00a0": [
        "fibonacci-number",
        [
            "n-th-tribonacci-number",
            "length-of-longest-fibonacci-subsequence",
            "split-array-into-fibonacci-sequence",
            "climbing-stairs"
        ],
        [
            "Array"
        ]
    ],
    "Given two strings S and T, each of which represents a non-negative rational number, return True if and only if they represent the same number. The strings may use parentheses to denote the repeating part of the rational number.In general a rational number can be represented using up to\u00a0three parts: an\u00a0integer part, a\u00a0non-repeating part, and a\u00a0repeating part. The number will be represented\u00a0in one of the following three ways:<IntegerPart> (e.g. 0, 12, 123)<IntegerPart><.><NonRepeatingPart> \u00a0(e.g. 0.5, 1., 2.12, 2.0001)<IntegerPart><.><NonRepeatingPart><(><RepeatingPart><)> (e.g. 0.1(6), 0.9(9), 0.00(1212))The repeating portion of a decimal expansion is conventionally denoted within a pair of round brackets.\u00a0 ": [
        "equal-rational-numbers",
        [],
        [
            "Math"
        ]
    ],
    "Given a binary tree with N nodes, each node has a different value from\u00a0{1, ..., N}.A node in this binary tree can be flipped\u00a0by swapping the left child and the right child of that node.Consider the sequence of\u00a0N values reported by a preorder traversal starting from the root.\u00a0 Call such a sequence of N values the\u00a0voyage\u00a0of the tree.(Recall that a preorder traversal\u00a0of a node means we report the current node's value, then preorder-traverse the left child, then preorder-traverse the right child.)Our goal is to flip the least number of nodes in the tree so that the voyage of the tree matches the voyage we are given.If we can do so, then return a\u00a0list\u00a0of the values of all nodes flipped.\u00a0 You may return the answer in any order.If we cannot do so, then return the list [-1].\u00a0": [
        "flip-binary-tree-to-match-preorder-traversal",
        [],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given two positive integers x and y, an integer is powerful\u00a0if it is equal to x^i + y^j\u00a0for\u00a0some integers i >= 0 and j >= 0.Return a list of all powerful integers that have value less than or equal to bound.You may return the answer in any order.\u00a0 In your answer, each value should occur at most once.\u00a0": [
        "powerful-integers",
        [],
        [
            "Hash Table",
            "Math"
        ]
    ],
    "Given an array of integers\u00a0arr, sort the array by performing a series of pancake flips.In one pancake flip we do the following steps:Choose an integer k where 1 <= k <= arr.length.Reverse the sub-array arr[1...k].": [
        "pancake-sorting",
        [],
        [
            "Array",
            "Sort"
        ]
    ],
    "Given a binary tree, we install cameras on the nodes of the tree.\u00a0Each camera at\u00a0a node can monitor its parent, itself, and its immediate children.Calculate the minimum number of cameras needed to monitor all nodes of the tree.\u00a0": [
        "binary-tree-cameras",
        [
            "distribute-coins-in-binary-tree"
        ],
        [
            "Dynamic Programming",
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Return all non-negative integers of length N such that the absolute difference between every two consecutive digits is K.": [
        "numbers-with-same-consecutive-differences",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Given a\u00a0wordlist, we want to implement a spellchecker that converts a query word into a correct word.For a given query word, the spell checker handles two categories of spelling mistakes:Capitalization: If the query matches a word in the wordlist (case-insensitive), then the query word is returned with the same case as the case in the wordlist.\t": [
        "vowel-spellchecker",
        [],
        [
            "Hash Table",
            "String"
        ]
    ],
    "A binary tree is univalued if every node in the tree has the same value.Return true\u00a0if and only if the given tree is univalued.\u00a0": [
        "univalued-binary-tree",
        [
            "find-all-the-lonely-nodes"
        ],
        [
            "Tree"
        ]
    ],
    "Given a single positive integer x, we will write an expression of the form x (op1) x (op2) x (op3) x ...\u00a0where each operator op1, op2, etc. is either addition, subtraction, multiplication, or division (+, -, *, or /).\u00a0 ": [
        "least-operators-to-express-number",
        [],
        [
            "Math",
            "Dynamic Programming"
        ]
    ],
    "Given a set of points in the xy-plane, determine the minimum area of any rectangle formed from these points, with sides not necessarily parallel to the x and y axes.If there isn't any rectangle, return 0.\u00a0": [
        "minimum-area-rectangle-ii",
        [],
        [
            "Math",
            "Geometry"
        ]
    ],
    "Given an array A of integers, a ramp\u00a0is a tuple (i, j) for which i < j\u00a0and\u00a0A[i] <= A[j].\u00a0 The width of such a\u00a0ramp is j - i.Find the maximum width of a ramp in A.\u00a0 If one doesn't exist, return 0.\u00a0": [
        "maximum-width-ramp",
        [],
        [
            "Array"
        ]
    ],
    "In a array A of size 2N, there are N+1 unique elements, and exactly one of these elements is repeated N times.Return the element repeated N times.\u00a0": [
        "n-repeated-element-in-size-2n-array",
        [],
        [
            "Hash Table"
        ]
    ],
    "We are given an array\u00a0A of N lowercase letter strings, all of the same length.Now, we may choose any set of deletion indices, and for each string, we delete all the characters in those indices.": [
        "delete-columns-to-make-sorted",
        [],
        [
            "Greedy"
        ]
    ],
    "In a N x N\u00a0grid composed of 1 x 1 squares, each 1 x 1 square consists of a /, \\, or blank space.\u00a0 These characters divide the square into contiguous regions.(": [
        "regions-cut-by-slashes",
        [],
        [
            "Depth-first Search",
            "Union Find",
            "Graph"
        ]
    ],
    "Given a binary tree, determine if it is a complete binary tree.Definition of a complete binary tree from Wikipedia:In a complete binary tree every level, except possibly the last, is completely filled, and all nodes in the last level are as far left as possible. It can have between 1 and 2h nodes inclusive at the last level h.\u00a0": [
        "check-completeness-of-a-binary-tree",
        [],
        [
            "Tree"
        ]
    ],
    "There are 8 prison cells in a row, and each cell is either occupied or vacant.Each day, whether the cell is occupied or vacant changes according to the following rules:If a cell has two adjacent neighbors that are both occupied or both vacant,\u00a0then the cell becomes occupied.Otherwise, it becomes vacant.(": [
        "prison-cells-after-n-days",
        [],
        [
            "Hash Table"
        ]
    ],
    "You are installing a billboard and want it to have the largest height.\u00a0 The billboard will have two steel supports, one on each side.\u00a0 Each steel support must be an equal height.You have a collection of rods which can be welded together.\u00a0 ": [
        "tallest-billboard",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Given an array of integers A\u00a0with even length, return true if and only if it is possible to reorder it such that A[2 * i + 1] = 2 * A[2 * i] for every 0 <=\u00a0i < len(A) / 2.\u00a0": [
        "array-of-doubled-pairs",
        [],
        [
            "Array",
            "Hash Table"
        ]
    ],
    "In an alien language, surprisingly they also use english lowercase letters, but possibly\u00a0in a different order. The\u00a0order of the alphabet\u00a0is some permutation\u00a0of lowercase letters.Given a sequence of words\u00a0written in the alien language,\u00a0and the order of the alphabet,\u00a0return true if and only if the given words\u00a0are sorted lexicographicaly in this alien language.\u00a0": [
        "verifying-an-alien-dictionary",
        [],
        [
            "Hash Table"
        ]
    ],
    "Given a non-empty\u00a0array of unique positive integers A, consider the following graph:There are A.length nodes, labelled A[0] to A[A.length - 1];There is an edge between A[i] and A[j]\u00a0if and only if\u00a0A[i] and A[j] share a common factor greater than 1.Return the size of the largest connected component in the graph.\u00a0": [
        "largest-component-size-by-common-factor",
        [],
        [
            "Math",
            "Union Find"
        ]
    ],
    "For a binary tree T, we can define a flip operation as follows: choose any node, and swap the left and right child subtrees.A binary tree X\u00a0is flip equivalent to a binary tree Y if and only if we can make X equal to Y after some number of flip operations.Given the roots of two binary trees root1 and root2, return true if the two trees are flip equivelent or false otherwise.\u00a0": [
        "flip-equivalent-binary-trees",
        [],
        [
            "Tree"
        ]
    ],
    "In a deck of cards, every card has a unique integer.\u00a0 You can order the deck in\u00a0any order you want.Initially, all the cards start face down (unrevealed) in one deck.Now, you do the following steps repeatedly, until all cards are revealed:Take the top card of the deck, reveal it, and take it out of the deck.If there are still cards in the deck, put the next top card of the deck at\u00a0the bottom of the deck.If there are still unrevealed cards, go back to step 1.\u00a0 Otherwise, stop.Return an ordering of the deck that would reveal the cards\u00a0in increasing order.The first entry in the answer is considered to be the top of the deck.\u00a0": [
        "reveal-cards-in-increasing-order",
        [],
        [
            "Array"
        ]
    ],
    "Given an array of 4 digits, return the largest 24 hour time that can be made.The smallest 24 hour time is 00:00, and the largest is 23:59.\u00a0 Starting from 00:00, a time is larger if more time has elapsed since midnight.Return the answer as a string of length 5.\u00a0 If no valid time can be made, return an empty string.\u00a0": [
        "largest-time-for-given-digits",
        [],
        [
            "Math"
        ]
    ],
    "You have an initial power P, an initial score of 0 points, and a bag of tokens.Each token can be used at most once, has a value token[i], and has potentially two ways to use it.If we have at least token[i] power, we may play the token face up, losing token[i] power, and gaining 1 point.If we have at least 1 point, we may play the token face down, gaining token[i] power, and losing 1 point.Return the largest number of points we can have after playing any number of tokens.\u00a0": [
        "bag-of-tokens",
        [],
        [
            "Greedy"
        ]
    ],
    "On a 2D plane, we place stones at some integer coordinate points.\u00a0 Each coordinate point may have at most one stone.Now, a move consists of removing a stone\u00a0that shares a column or row with another stone on the grid.What is the largest possible number of moves we can make?\u00a0": [
        "most-stones-removed-with-same-row-or-column",
        [],
        [
            "Depth-first Search",
            "Union Find"
        ]
    ],
    "Given two sequences pushed and popped\u00a0with distinct values,\u00a0return true if and only if this could have been the result of a sequence of push and pop operations on an initially empty stack.\u00a0": [
        "validate-stack-sequences",
        [],
        [
            "Stack"
        ]
    ],
    "Given an array of integers A, a move consists of choosing any A[i], and incrementing it by 1.Return the least number of moves to make every value in A unique.\u00a0": [
        "minimum-increment-to-make-array-unique",
        [],
        [
            "Array"
        ]
    ],
    "Given an array A of strings, find any\u00a0smallest string that contains each string in A as a\u00a0substring.We may assume that no string in A is substring of another string in A.\u00a0": [
        "find-the-shortest-superstring",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Given a string S that only contains \"I\" (increase) or \"D\" (decrease), let N = S.length.Return any permutation A of [0, 1, ..., N] such that for all i = 0,\u00a0..., N-1:If S[i] == \"I\", then A[i] < A[i+1]If S[i] == \"D\", then A[i] > A[i+1]\u00a0": [
        "di-string-match",
        [],
        [
            "Math"
        ]
    ],
    "Given an array A of integers, return true if and only if it is a valid mountain array.Recall that A is a mountain array if and only if:A.length >= 3There exists some i with\u00a00 < i\u00a0< A.length - 1\u00a0such that:\tA[0] < A[1] < ... A[i-1] < A[i] A[i] > A[i+1] > ... > A[A.length - 1]\u00a0": [
        "valid-mountain-array",
        [],
        [
            "Array"
        ]
    ],
    "Given a string S, count the number of distinct, non-empty subsequences of S .Since the result may be large, return the answer modulo 10^9 + 7.\u00a0": [
        "distinct-subsequences-ii",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Given a set of points in the xy-plane, determine the minimum area of a rectangle formed from these points, with sides parallel to the x and y axes.If there isn't any rectangle, return 0.\u00a0": [
        "minimum-area-rectangle",
        [],
        [
            "Hash Table"
        ]
    ],
    "Given the root node of a binary search tree, return the sum of values of all nodes with value between L and R (inclusive).The binary search tree is guaranteed to have unique values.\u00a0": [
        "range-sum-of-bst",
        [],
        [
            "Tree",
            "Recursion"
        ]
    ],
    "You have an array of logs.\u00a0 Each log is a space delimited string of words.For each log, the first word in each log is an alphanumeric identifier.\u00a0 Then, either:Each word after the identifier will consist only of lowercase letters, or;Each word after the identifier will consist only of digits.We will call these two varieties of logs letter-logs and digit-logs.\u00a0 It is guaranteed that each log has at least one word after its identifier.Reorder the logs so that all of the letter-logs come before any digit-log.\u00a0 The letter-logs are ordered lexicographically ignoring identifier, with the identifier used in case of ties.\u00a0 The digit-logs should be put in their original order.Return the final order of the logs.\u00a0": [
        "reorder-data-in-log-files",
        [],
        [
            "String"
        ]
    ],
    "You want to form a target\u00a0string of lowercase letters.At the beginning, your sequence is target.length\u00a0'?' marks.\u00a0 You also have a stamp\u00a0of lowercase letters.On each turn, you may place the stamp over the sequence, and replace every letter in the sequence with the corresponding letter from the stamp.\u00a0 You can make up to 10 * target.length turns.": [
        "stamping-the-sequence",
        [],
        [
            "String",
            "Greedy"
        ]
    ],
    "The chess knight has a unique movement,\u00a0it may move two squares vertically and one square horizontally, or two squares horizontally and one square vertically (with both forming the shape of an L). The possible movements of chess knight are shown in this diagaram:A chess knight can move as indicated in the chess diagram below:We have a chess knight and a phone pad as shown below, the knight can only stand on a numeric cell\u00a0(i.e. blue cell).Given an integer n, return how many distinct phone numbers of length n we can dial.You are allowed to place the knight on any numeric cell initially and then you should perform n - 1 jumps to dial a number of length n. All jumps should be valid knight jumps.As the answer may be very large, return the answer modulo 109 + 7.\u00a0": [
        "knight-dialer",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "In a given 2D binary array A, there are two islands.\u00a0 (An island is a 4-directionally connected group of\u00a01s not connected to any other 1s.)Now, we may change 0s to 1s so as to connect the two islands together to form 1 island.Return the smallest number of 0s that must be flipped.\u00a0 (It is guaranteed that the answer is at least 1.)\u00a0": [
        "shortest-bridge",
        [],
        [
            "Depth-first Search",
            "Breadth-first Search"
        ]
    ],
    "Write a class RecentCounter to count recent requests.It has only one method:\u00a0ping(int t), where t represents some time in milliseconds.Return the number of pings that have been made from 3000 milliseconds ago until now.Any ping with time in [t - 3000, t] will count, including the current ping.It is guaranteed that every call to ping uses a strictly larger value of\u00a0t than before.\u00a0": [
        "number-of-recent-calls",
        [],
        [
            "Queue"
        ]
    ],
    "For some fixed N, an array A is beautiful if it is a permutation of the integers 1, 2, ..., N, such that:For every i < j, there is no\u00a0k with i < k < j\u00a0such that A[k] * 2 = A[i] + A[j].Given N, return any beautiful array A.\u00a0 (It is guaranteed that one exists.)\u00a0": [
        "beautiful-array",
        [],
        [
            "Divide and Conquer"
        ]
    ],
    "Given a square array of integers A, we want the minimum sum of a falling path through A.A falling path starts at any element in the first row, and chooses one element from each row.\u00a0 The next row's choice must be in a column that is different from the previous row's column by at most one.\u00a0": [
        "minimum-falling-path-sum",
        [
            "minimum-falling-path-sum-ii"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "In an array A of 0s and 1s, how many non-empty subarrays have sum S?\u00a0": [
        "binary-subarrays-with-sum",
        [],
        [
            "Hash Table",
            "Two Pointers"
        ]
    ],
    "Every email consists of a local name and a domain name, separated by the @ sign.": [
        "unique-email-addresses",
        [],
        [
            "String"
        ]
    ],
    "(This problem is the same as Minimize Malware Spread, with the differences bolded.)In a network of nodes, each node i is directly connected to another node j if and only if\u00a0graph[i][j] = 1.Some nodes initial are initially infected by malware.\u00a0 Whenever two nodes are directly connected and at least one of those two nodes is infected by malware, both nodes will be infected by malware.\u00a0 This spread of malware will continue until no more nodes can be infected in this manner.": [
        "minimize-malware-spread-ii",
        [],
        [
            "Depth-first Search",
            "Union Find",
            "Graph"
        ]
    ],
    "Given an array A of 0s and 1s, divide the array into 3 non-empty parts such that all of these parts represent the same binary value.If it is possible, return any [i, j]\u00a0with i+1 < j, such that:A[0], A[1], ..., A[i] is the first part;A[i+1], A[i+2], ..., A[j-1] is the second part, andA[j], A[j+1], ..., A[A.length - 1] is the third part.All three parts have equal binary value.If it is not possible, return [-1, -1].": [
        "three-equal-parts",
        [],
        [
            "Math",
            "Binary Search",
            "Greedy"
        ]
    ],
    "A string of '0's and '1's is monotone increasing if it consists of some number of '0's (possibly 0), followed by some number of '1's (also possibly 0.)We are given a string S of '0's and '1's, and we may flip any '0' to a '1' or a '1' to a '0'.Return the minimum number of flips to make S\u00a0monotone increasing.\u00a0": [
        "flip-string-to-monotone-increasing",
        [],
        [
            "Array"
        ]
    ],
    "Your friend is typing his name\u00a0into a keyboard.\u00a0 Sometimes, when typing a character c, the key might get long pressed, and the character will be typed 1 or more times.You examine the typed\u00a0characters of the keyboard.\u00a0 Return True if it is possible that it was your friends name, with some characters (possibly none) being long pressed.\u00a0": [
        "long-pressed-name",
        [],
        [
            "Two Pointers",
            "String"
        ]
    ],
    "In a network of nodes, each node i is directly connected to another node j if and only if\u00a0graph[i][j] = 1.Some nodes initial are initially infected by malware.\u00a0 Whenever two nodes are directly connected and at least one of those two nodes is infected by malware, both nodes will be infected by malware.\u00a0 This spread of malware will continue until no more nodes can be infected in this manner.": [
        "minimize-malware-spread",
        [],
        [
            "Depth-first Search",
            "Union Find"
        ]
    ],
    "Given an integer array A, and an integer target, return the number of\u00a0tuples\u00a0i, j, k\u00a0 such that i < j < k and\u00a0A[i] + A[j] + A[k] == target.As the answer can be very large, return it modulo\u00a0109 + 7.\u00a0": [
        "3sum-with-multiplicity",
        [],
        [
            "Two Pointers"
        ]
    ],
    "Given an array A\u00a0of non-negative integers, half of the integers in A are odd, and half of the integers are even.Sort the array so that whenever A[i] is odd, i is odd; and whenever A[i] is even, i is even.You may return any answer array that satisfies this condition.\u00a0": [
        "sort-array-by-parity-ii",
        [],
        [
            "Array",
            "Sort"
        ]
    ],
    "Given a string\u00a0S of '(' and ')' parentheses, we add the minimum number of parentheses ( '(' or ')', and in any positions ) so that the resulting parentheses string is valid.": [
        "minimum-add-to-make-parentheses-valid",
        [],
        [
            "Stack",
            "Greedy"
        ]
    ],
    "Your music player contains N\u00a0different songs and she wants to listen to L (not necessarily different) songs during your trip. \u00a0You\u00a0create\u00a0a playlist so\u00a0that:Every song is played at least onceA song can only be played again only if\u00a0K\u00a0other songs have been playedReturn the number of possible playlists.\u00a0 As the answer can be very large, return it modulo 10^9 + 7.\u00a0": [
        "number-of-music-playlists",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "A complete binary tree is a binary tree in which every level, except possibly the last, is completely filled, and all nodes are as far left as possible.Write a data structure\u00a0CBTInserter\u00a0that is initialized with a complete binary tree and supports the following operations:CBTInserter(TreeNode root) initializes the data structure on a given tree\u00a0with head node root;CBTInserter.insert(int v) will insert a TreeNode\u00a0into the tree with value node.val =\u00a0v\u00a0so that the tree remains complete, and returns the value of the parent of the inserted TreeNode;CBTInserter.get_root() will return the head node of the tree.\u00a0": [
        "complete-binary-tree-inserter",
        [],
        [
            "Tree"
        ]
    ],
    "Given a circular\u00a0array\u00a0C of integers represented by\u00a0A, find the maximum possible sum of a non-empty subarray of C.Here, a\u00a0circular\u00a0array means the end of the array connects to the beginning of the array.\u00a0 (": [
        "maximum-sum-circular-subarray",
        [],
        [
            "Array"
        ]
    ],
    "Given a string S, return the \"reversed\" string where all characters that are not a letter\u00a0stay in the same place, and all letters reverse their positions.\u00a0": [
        "reverse-only-letters",
        [],
        [
            "String"
        ]
    ],
    "We are given two arrays A and B of words.\u00a0 Each word is a string of lowercase letters.Now, say that\u00a0word b is a subset of word a\u00a0if every letter in b occurs in a, including multiplicity.\u00a0 ": [
        "word-subsets",
        [],
        [
            "String"
        ]
    ],
    "Given an array A, partition it\u00a0into two (contiguous) subarrays\u00a0left\u00a0and right\u00a0so that:Every element in left\u00a0is less than or equal to every element in right.left and right are non-empty.left\u00a0has the smallest possible size.Return the length of left after such a partitioning.\u00a0 It is guaranteed that such a partitioning exists.\u00a0": [
        "partition-array-into-disjoint-intervals",
        [],
        [
            "Array"
        ]
    ],
    "In a deck of cards, each card has an integer written on it.Return true if and only if you can choose\u00a0X >= 2 such that\u00a0it is possible to split the entire deck\u00a0into 1 or more groups of cards, where:Each group has exactly X cards.All the cards in each group have the same integer.\u00a0": [
        "x-of-a-kind-in-a-deck-of-cards",
        [],
        [
            "Array",
            "Math"
        ]
    ],
    "A game on an undirected graph is played by two players, Mouse and Cat, who alternate turns.The graph is given as follows: graph[a] is a list of all nodes b such that ab is an edge of the graph.Mouse starts at node 1 and goes first, Cat starts at node 2 and goes second, and there is a Hole at node 0.During each player's turn, they must travel along one\u00a0edge of the graph that meets where they are.\u00a0 ": [
        "cat-and-mouse",
        [],
        [
            "Breadth-first Search",
            "Minimax"
        ]
    ],
    "Given an array of integers nums, sort the array in ascending order.\u00a0": [
        "sort-an-array",
        [],
        []
    ],
    "In an election, the i-th\u00a0vote was cast for persons[i] at time times[i].Now, we would like to implement the following query function: TopVotedCandidate.q(int t) will return the number of the person that was leading the election at time t.\u00a0\u00a0Votes cast at time t will count towards our query.\u00a0 In the case of a tie, the most recent vote (among tied candidates) wins.\u00a0": [
        "online-election",
        [
            "rank-teams-by-votes"
        ],
        [
            "Binary Search"
        ]
    ],
    "Given an array A of integers, for each integer A[i] we need to choose either\u00a0x = -K\u00a0or x = K, and add x to A[i] (only once).After this process, we have some array B.Return the smallest possible difference between the maximum value of B\u00a0and the minimum value of B.\u00a0": [
        "smallest-range-ii",
        [],
        [
            "Math",
            "Greedy"
        ]
    ],
    "On an N x N board, the numbers from 1 to N*N are written\u00a0boustrophedonically\u00a0starting from the bottom\u00a0left of the board, and alternating direction each row.\u00a0 ": [
        "snakes-and-ladders",
        [],
        [
            "Breadth-first Search"
        ]
    ],
    "Given an array A of integers, for each integer A[i] we may choose any x with -K <= x <= K, and add x to A[i].After this process, we have some array B.Return the smallest possible difference between the maximum value of B\u00a0and the minimum value of B.\u00a0": [
        "smallest-range-i",
        [],
        [
            "Math"
        ]
    ],
    "Given an array of integers A, find the sum of min(B), where B ranges over\u00a0every (contiguous) subarray of A.Since the answer may be large, return the answer modulo 10^9 + 7.\u00a0": [
        "sum-of-subarray-minimums",
        [],
        [
            "Array",
            "Stack"
        ]
    ],
    "Let's say a positive integer is a\u00a0superpalindrome\u00a0if it is a palindrome, and it is also the square of a palindrome.Now, given two positive\u00a0integers L and R (represented as strings), return the number of superpalindromes in the inclusive range [L, R].\u00a0": [
        "super-palindromes",
        [],
        [
            "Math"
        ]
    ],
    "Given an array A of non-negative integers, return an array consisting of all the even elements of A, followed by all the odd elements of A.You may return any answer array that satisfies this condition.\u00a0": [
        "sort-array-by-parity",
        [],
        [
            "Array"
        ]
    ],
    "In a row of trees, the i-th tree\u00a0produces\u00a0fruit with type\u00a0tree[i].You start at any tree\u00a0of your choice, then repeatedly perform the following steps:Add one piece of fruit from this tree to your baskets.\u00a0 If you cannot, stop.Move to the next tree to the right of the current tree.\u00a0 If there is no tree to the right, stop.": [
        "fruit-into-baskets",
        [],
        [
            "Two Pointers"
        ]
    ],
    "We are given S, a length n string of characters from the set {'D', 'I'}. (These letters stand for \"decreasing\" and \"increasing\".)A\u00a0valid permutation\u00a0is a permutation P[0], P[1], ..., P[n] of integers\u00a0{0, 1, ..., n}, such that for all i:If S[i] == 'D', then P[i] > P[i+1], and;If S[i] == 'I', then P[i] < P[i+1].How many valid permutations are there?\u00a0 Since the answer may be large, return your answer modulo 10^9 + 7.\u00a0": [
        "valid-permutations-for-di-sequence",
        [],
        [
            "Divide and Conquer",
            "Dynamic Programming"
        ]
    ],
    "Given an array of digits, you can\u00a0write numbers using each digits[i] as many times as we want.\u00a0 ": [
        "numbers-at-most-n-given-digit-set",
        [],
        [
            "Math",
            "Dynamic Programming"
        ]
    ],
    "Write a class StockSpanner which collects daily price quotes for some stock, and returns the span\u00a0of that stock's price for the current day.The span of the stock's price today\u00a0is defined as the maximum number of consecutive days (starting from today and going backwards)\u00a0for which the price of the stock was less than or equal to today's price.": [
        "online-stock-span",
        [],
        [
            "Stack"
        ]
    ],
    "Write an iterator that iterates through a run-length encoded sequence.The iterator is initialized by RLEIterator(int[] A), where A is a run-length encoding of some\u00a0sequence.\u00a0 More specifically,\u00a0for all even i,\u00a0A[i] tells us the number of times that the non-negative integer value A[i+1] is repeated in the sequence.The iterator supports one function:\u00a0next(int n), which exhausts the next n elements\u00a0(n >= 1) and returns the last element exhausted in this way.\u00a0 If there is no element left to exhaust, next\u00a0returns -1 instead.": [
        "rle-iterator",
        [],
        [
            "Array"
        ]
    ],
    "A string S of lowercase letters is given.\u00a0 Then, we may make any number of moves.In each move, we\u00a0choose one\u00a0of the first K letters (starting from the left), remove it,\u00a0and place it at the end of the string.Return the lexicographically smallest string we could have after any number of moves.\u00a0": [
        "orderly-queue",
        [],
        [
            "Math",
            "String"
        ]
    ],
    "We have an array A of non-negative integers.For every (contiguous) subarray B =\u00a0[A[i], A[i+1], ..., A[j]] (with i <= j), we take the bitwise OR of all the elements in B, obtaining a result A[i] | A[i+1] | ... | A[j].Return the number of possible\u00a0results.\u00a0 (Results that occur more than once are only counted once in the final answer.)\u00a0": [
        "bitwise-ors-of-subarrays",
        [],
        [
            "Dynamic Programming",
            "Bit Manipulation"
        ]
    ],
    "Given a binary search tree, rearrange the tree in in-order so that the leftmost node in the tree is now the root of the tree, and every node has no left child and only 1 right child.": [
        "increasing-order-search-tree",
        [],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "An array is monotonic if it is either monotone increasing or monotone decreasing.An array A is monotone increasing if for all i <= j, A[i] <= A[j].\u00a0 An array A is monotone decreasing if for all i <= j, A[i] >= A[j].Return true if and only if the given array A is monotonic.\u00a0": [
        "monotonic-array",
        [],
        [
            "Array"
        ]
    ],
    "Implement FreqStack, a class which simulates the operation of a stack-like data structure.FreqStack\u00a0has two functions:push(int x), which pushes an integer x onto the stack.pop(), which removes and returns the most frequent element in the stack.\tIf there is a tie for most frequent element, the element closest to the top of the stack is removed and returned.\u00a0": [
        "maximum-frequency-stack",
        [],
        [
            "Hash Table",
            "Stack"
        ]
    ],
    "A full binary tree\u00a0is a binary tree where each node has exactly 0 or 2\u00a0children.Return a list of all possible full binary trees with N nodes.\u00a0 Each element of the answer is the root node of one possible tree.Each node of each\u00a0tree in the answer must have node.val = 0.You may return the final list of trees in any order.\u00a0": [
        "all-possible-full-binary-trees",
        [],
        [
            "Tree",
            "Recursion"
        ]
    ],
    "You are given an array A of strings.A move\u00a0onto S consists of swapping any two even indexed characters of S, or any two odd indexed characters of S.Two strings S and T are\u00a0special-equivalent\u00a0if after any number of moves onto S, S == T.": [
        "groups-of-special-equivalent-strings",
        [],
        [
            "String"
        ]
    ],
    "On a\u00a0N\u00a0*\u00a0N\u00a0grid, we place some\u00a01 * 1 * 1\u00a0cubes.Each value\u00a0v = grid[i][j]\u00a0represents a tower of\u00a0v\u00a0cubes placed on top of grid cell\u00a0(i, j).Return the total surface area of the resulting shapes.\u00a0": [
        "surface-area-of-3d-shapes",
        [],
        [
            "Math",
            "Geometry"
        ]
    ],
    "Given an array of integers A, consider all non-empty subsequences of A.For any sequence S, let the\u00a0width\u00a0of S be the difference between the maximum and minimum element of S.Return the sum of the widths of all subsequences of A.\u00a0As the answer may be very large, return the answer modulo 10^9 + 7.\u00a0": [
        "sum-of-subsequence-widths",
        [],
        [
            "Array",
            "Math"
        ]
    ],
    "You have a list of\u00a0words and a pattern, and you want to know which words in words matches the pattern.A word matches the pattern if there exists a permutation of letters p so that after replacing every letter x in the pattern with p(x), we get the desired word.(Recall that a permutation of letters is a bijection from letters to letters: every letter maps to another letter, and no two letters map to the same letter.)Return a list of the words in words\u00a0that match the given pattern.\u00a0You may return the answer in any order.\u00a0": [
        "find-and-replace-pattern",
        [],
        [
            "String"
        ]
    ],
    "Return any binary tree that matches the given preorder and postorder traversals.Values in the traversals\u00a0pre and post\u00a0are distinct\u00a0positive integers.\u00a0": [
        "construct-binary-tree-from-preorder-and-postorder-traversal",
        [],
        [
            "Tree"
        ]
    ],
    "Alice and Bob have candy bars of different sizes: A[i] is the size of the i-th bar of candy that Alice has, and B[j] is the size of the j-th bar of candy that Bob has.Since they are friends, they would like to exchange one candy bar each so that after the exchange, they both have the same total\u00a0amount of candy.\u00a0 (The total amount of candy\u00a0a person has is the sum of the sizes of candy\u00a0bars they have.)Return an integer array ans\u00a0where ans[0] is the size of the candy bar that Alice must exchange, and ans[1] is the size of the candy bar that Bob must exchange.If there are multiple answers, you may return any one of them.\u00a0 It is guaranteed an answer exists.\u00a0": [
        "fair-candy-swap",
        [],
        [
            "Array"
        ]
    ],
    "You are given K eggs, and you have access to a building with N floors from 1 to N.\u00a0Each egg is identical in function, and if an egg breaks, you cannot drop it\u00a0again.You know that there exists a floor F with 0 <= F <= N such that any egg dropped at a floor higher than F will break, and any egg dropped at or below floor F will not break.Each move, you may take an egg (if you have an unbroken one) and drop it from any floor X (with\u00a01 <= X <= N).\u00a0Your goal is to know\u00a0with certainty\u00a0what the value of F is.What is the minimum number of moves that you need to know with certainty\u00a0what F is, regardless of the initial value of F?\u00a0": [
        "super-egg-drop",
        [],
        [
            "Math",
            "Binary Search",
            "Dynamic Programming"
        ]
    ],
    "Given a set of N\u00a0people (numbered 1, 2, ..., N), we would like to split everyone into two groups of any size.Each person may dislike some other people, and they should not go into the same group.\u00a0": [
        "possible-bipartition",
        [],
        [
            "Depth-first Search",
            "Graph"
        ]
    ],
    "On a 2 dimensional grid with R rows and C columns, we start at (r0, c0) facing east.Here, the north-west corner of the grid is at the\u00a0first row and column, and the south-east corner of the grid is at the last row and column.Now, we walk in a clockwise spiral shape to visit every position in this grid.\u00a0Whenever we would move outside the boundary of the grid, we continue our walk outside the grid (but may return to the grid boundary later.)\u00a0Eventually, we reach all R * C spaces of the grid.Return a list of coordinates representing the positions of the grid in the order they were visited.\u00a0": [
        "spiral-matrix-iii",
        [
            "spiral-matrix-ii",
            "spiral-matrix"
        ],
        [
            "Math"
        ]
    ],
    "We are given two sentences A and B.\u00a0 (A sentence\u00a0is a string of space separated words.\u00a0 Each word consists only of lowercase letters.)A word is uncommon\u00a0if it appears exactly once in one of the sentences, and does not appear in the other sentence.Return a list of all uncommon words.\u00a0You may return the list in any order.\u00a0": [
        "uncommon-words-from-two-sentences",
        [],
        [
            "Hash Table"
        ]
    ],
    "On a\u00a0N\u00a0*\u00a0N grid, we place some\u00a01 * 1 * 1\u00a0cubes that are axis-aligned with the x, y, and z axes.Each value\u00a0v = grid[i][j]\u00a0represents a tower of\u00a0v\u00a0cubes placed on top of grid cell (i, j).Now we view the\u00a0projection\u00a0of these cubes\u00a0onto the xy, yz, and zx planes.A projection is like a shadow, that\u00a0maps our 3 dimensional figure to a 2 dimensional plane.\u00a0Here, we are viewing the \"shadow\" when looking at the cubes from the top, the front, and the side.Return the total area of all three projections.\u00a0": [
        "projection-area-of-3d-shapes",
        [],
        [
            "Math"
        ]
    ],
    "Starting with an\u00a0undirected graph (the \"original graph\") with nodes from 0 to N-1, subdivisions are made to some of the edges.The graph is given as follows: edges[k] is a list of integer pairs (i, j, n) such that (i, j) is an edge of the original graph,and n is the total number of new nodes on that edge.\u00a0Then, the edge (i, j) is deleted from the original graph,\u00a0n\u00a0new nodes (x_1, x_2, ..., x_n) are added to the original graph,and n+1 new\u00a0edges (i, x_1), (x_1, x_2), (x_2, x_3), ..., (x_{n-1}, x_n), (x_n, j)\u00a0are added to the original\u00a0graph.Now, you start at node 0\u00a0from the original graph, and in each move, you travel along one\u00a0edge.\u00a0Return how many nodes you can reach in at most M moves.\u00a0": [
        "reachable-nodes-in-subdivided-graph",
        [],
        [
            "Heap"
        ]
    ],
    "The i-th person has weight people[i], and each boat can carry a maximum weight of limit.Each boat carries at most 2 people at the same time, provided the sum of the\u00a0weight of those people is at most limit.Return the minimum number of boats to carry every given person.\u00a0 (It is guaranteed each person can be carried by a boat.)\u00a0": [
        "boats-to-save-people",
        [],
        [
            "Two Pointers",
            "Greedy"
        ]
    ],
    "An encoded string S is given.\u00a0 To find and write the decoded string to a tape, the encoded string is read one character at a time\u00a0and the following steps are taken:If the character read is a letter, that letter is written onto the tape.If the character read is a digit (say d), the entire current tape is repeatedly written\u00a0d-1\u00a0more times in total.Now for some encoded string S, and an index K, find and return the K-th letter (1 indexed) in the decoded string.\u00a0": [
        "decoded-string-at-index",
        [],
        [
            "Stack"
        ]
    ],
    "Given the radius and x-y positions of the center of a circle, write a function randPoint\u00a0which\u00a0generates a uniform random\u00a0point in the circle.": [
        "generate-random-point-in-a-circle",
        [
            "random-point-in-non-overlapping-rectangles"
        ],
        [
            "Math",
            "Random",
            "Rejection Sampling"
        ]
    ],
    "Given a list of non-overlapping\u00a0axis-aligned rectangles rects, write a function pick which randomly and uniformily picks an integer point in the space\u00a0covered by the rectangles.": [
        "random-point-in-non-overlapping-rectangles",
        [
            "generate-random-point-in-a-circle",
            "random-pick-with-weight"
        ],
        [
            "Binary Search",
            "Random"
        ]
    ],
    "You are given the number of rows n_rows\u00a0and number of columns n_cols\u00a0of a\u00a02D\u00a0binary matrix\u00a0where all values are initially 0.\u00a0Write a function flip\u00a0which chooses\u00a0a 0 value\u00a0uniformly at random,\u00a0changes it to 1,\u00a0and then returns the position [row.id, col.id] of that value. Also, write a function reset which sets all values back to 0.\u00a0Try to minimize the number of calls to system's Math.random() and optimize the time and\u00a0space complexity.": [
        "random-flip-matrix",
        [],
        [
            "Random"
        ]
    ],
    "You are given an array of positive integers w where w[i] describes the weight of ith\u00a0index (0-indexed).We need to call the function\u00a0pickIndex() which randomly returns an integer in the range [0, w.length - 1].\u00a0pickIndex()\u00a0should return the integer\u00a0proportional to its weight in the w array. ": [
        "random-pick-with-weight",
        [
            "random-point-in-non-overlapping-rectangles",
            "random-pick-with-blacklist",
            "random-pick-index"
        ],
        [
            "Binary Search",
            "Random"
        ]
    ],
    "There is a group of\u00a0G members, and a list of various crimes they could commit.The ith\u00a0crime generates a profit[i] and requires group[i]\u00a0members to participate in it.If a\u00a0member participates in one crime, that member can't participate in another crime.Let's call a profitable\u00a0scheme\u00a0any subset of these crimes that generates at least P profit, and the total number of\u00a0members participating in that subset of crimes is at most G.How many schemes can be chosen?\u00a0 Since the answer may be very\u00a0large, return it modulo 10^9 + 7.\u00a0": [
        "profitable-schemes",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "A positive integer\u00a0is magical\u00a0if it is divisible by either A\u00a0or B.Return the N-th magical number.\u00a0 Since the answer may be very large, return it modulo 10^9 + 7.\u00a0": [
        "nth-magical-number",
        [],
        [
            "Math",
            "Binary Search"
        ]
    ],
    "Alex and Lee play a game with piles of stones.\u00a0 There are an even number of\u00a0piles arranged in a row, and each pile has a positive integer number of stones piles[i].The objective of the game is to end with the most\u00a0stones.\u00a0 The total number of stones is odd, so there are no ties.Alex and Lee take turns, with Alex starting first.\u00a0 Each turn, a player\u00a0takes the entire pile of stones from either the beginning or the end of the row.\u00a0 This continues until there are no more piles left, at which point the person with the most stones wins.Assuming Alex and Lee play optimally, return True\u00a0if and only if Alex wins the game.\u00a0": [
        "stone-game",
        [
            "stone-game-v"
        ],
        [
            "Math",
            "Dynamic Programming",
            "Minimax"
        ]
    ],
    "Given a non-empty, singly\u00a0linked list with head node head, return\u00a0a\u00a0middle node of linked list.If there are two middle nodes, return the second middle node.\u00a0": [
        "middle-of-the-linked-list",
        [],
        [
            "Linked List"
        ]
    ],
    "Koko loves to eat bananas.\u00a0 There are N\u00a0piles of bananas, the i-th\u00a0pile has piles[i] bananas.\u00a0 The guards have gone and will come back in H hours.Koko can decide her bananas-per-hour eating speed of K.\u00a0 Each hour, she chooses some pile of bananas, and eats K bananas from that pile.\u00a0 If the pile has less than K bananas, she eats all of them instead, and won't eat any more bananas during this hour.Koko likes to eat slowly, but still wants to finish eating all the bananas before the guards come back.Return the minimum integer K such that she can eat all the bananas within H hours.\u00a0": [
        "koko-eating-bananas",
        [
            "minimize-max-distance-to-gas-station"
        ],
        [
            "Binary Search"
        ]
    ],
    "A robot on an infinite grid starts at point (0, 0) and faces north.\u00a0 The robot can receive one of three possible types of commands:-2: turn left 90 degrees-1: turn right 90 degrees1 <= x <= 9: move forward x unitsSome of the grid squares are obstacles.\u00a0The i-th obstacle is at grid point (obstacles[i][0], obstacles[i][1])If the robot would try to move onto them, the robot stays on the previous grid square instead (but still continues following the rest of the route.)Return the square of the maximum Euclidean distance that the robot will be from the origin.\u00a0": [
        "walking-robot-simulation",
        [],
        [
            "Greedy"
        ]
    ],
    "A sequence X_1, X_2, ..., X_n\u00a0is fibonacci-like if:n >= 3X_i + X_{i+1} = X_{i+2}\u00a0for all\u00a0i + 2 <= nGiven a strictly increasing\u00a0array\u00a0A of positive integers forming a sequence, find the length of the longest fibonacci-like subsequence of A.\u00a0 If one does not exist, return 0.(Recall that a subsequence is derived from another sequence A by\u00a0deleting any number of\u00a0elements (including none)\u00a0from A, without changing the order of the remaining elements.\u00a0 ": [
        "length-of-longest-fibonacci-subsequence",
        [
            "fibonacci-number"
        ],
        [
            "Array",
            "Dynamic Programming"
        ]
    ],
    "Consider all the leaves of a binary tree, from\u00a0left to right order, the values of those\u00a0leaves form a leaf value sequence.": [
        "leaf-similar-trees",
        [],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given the API\u00a0rand7 which generates a uniform random integer in the range 1 to 7, write a function rand10\u00a0which generates a uniform random integer in the range 1 to 10. You can only call the API rand7\u00a0and you shouldn't call any other API. Please\u00a0don't use the system's Math.random().Notice that Each test case has one argument\u00a0n, the number of times that your implemented function\u00a0rand10 will be called while testing.\u00a0": [
        "implement-rand10-using-rand7",
        [],
        [
            "Random",
            "Rejection Sampling"
        ]
    ],
    "A car travels from a starting position to a destination which is target miles east of the starting position.Along the way, there are gas stations.\u00a0 Each station[i]\u00a0represents a gas station that is station[i][0] miles east of the starting position, and has station[i][1] liters of gas.The car starts with an infinite tank of gas, which initially has\u00a0startFuel\u00a0liters of fuel in it.\u00a0 It uses 1 liter of gas per 1 mile that it drives.When the car\u00a0reaches a gas station, it may stop and refuel, transferring all the gas from the station into the car.What is the least number of refueling stops the car must make in order to reach its destination?\u00a0 If it cannot reach the destination, return -1.": [
        "minimum-number-of-refueling-stops",
        [],
        [
            "Dynamic Programming",
            "Heap"
        ]
    ],
    "Given two arrays A and B of equal size, the advantage of A with respect to B is the number of indices i\u00a0for which A[i] > B[i].Return any permutation of A that maximizes its advantage with respect to B.\u00a0": [
        "advantage-shuffle",
        [],
        [
            "Array",
            "Greedy"
        ]
    ],
    "Starting with a positive integer N, we reorder the digits in any order (including the original order) such that the leading digit is not zero.Return true\u00a0if and only if we can do this in a way such that the resulting number is a power of 2.\u00a0": [
        "reordered-power-of-2",
        [],
        [
            "Math"
        ]
    ],
    "Given a positive\u00a0integer N, find and return the longest distance between two consecutive 1's in the binary representation of N.If there aren't two consecutive 1's, return 0.\u00a0": [
        "binary-gap",
        [],
        [
            "Math"
        ]
    ],
    "Given a\u00a0matrix A, return the transpose of A.The transpose of a matrix is the matrix flipped over it's main diagonal, switching the row and column indices of the matrix.\u00a0": [
        "transpose-matrix",
        [],
        [
            "Array"
        ]
    ],
    "Find the smallest prime palindrome greater than or equal to N.Recall that a\u00a0number is prime if it's only divisors are 1 and itself, and it is greater than 1.\u00a0": [
        "prime-palindrome",
        [],
        [
            "Math"
        ]
    ],
    "Given the root of a binary tree, the depth of each node is the shortest distance to the root.Return the smallest subtree such that it contains all the deepest nodes in the original tree.A node is called the\u00a0deepest if it has the largest depth possible among\u00a0any node in the entire tree.The subtree of a node is tree consisting of that node, plus the set of all descendants of that node.\u00a0": [
        "smallest-subtree-with-all-the-deepest-nodes",
        [],
        [
            "Tree"
        ]
    ],
    "We are given a 2-dimensional\u00a0grid.\u00a0\".\" is an empty cell, \"#\" is\u00a0a wall, \"@\" is the starting point, (\"a\", \"b\", ...) are keys, and (\"A\",\u00a0\"B\", ...) are locks.We start at the starting point, and one move consists of walking one space in one of the 4 cardinal directions.\u00a0 We cannot walk outside the grid, or walk into a wall.\u00a0 If we walk over a key, we pick it up.\u00a0 We can't walk over a lock unless we have the corresponding key.For some 1 <= K <= 6, there is exactly one lowercase and one uppercase letter of the first K letters of the English alphabet in the grid.\u00a0 This means that there is exactly one key for each lock, and one lock for each key; and also that the letters used to represent the keys and locks were\u00a0chosen in the same order as the English alphabet.Return the lowest number of moves to acquire all keys.\u00a0 If\u00a0it's impossible, return -1.\u00a0": [
        "shortest-path-to-get-all-keys",
        [],
        [
            "Heap",
            "Breadth-first Search"
        ]
    ],
    "Given a blacklist\u00a0B containing unique integers\u00a0from [0, N), write a function to return a uniform random integer from [0, N) which is NOT\u00a0in B.Optimize it such that it minimizes the call to system\u2019s Math.random().": [
        "random-pick-with-blacklist",
        [
            "random-pick-with-weight",
            "random-pick-index"
        ],
        [
            "Hash Table",
            "Binary Search",
            "Sort",
            "Random"
        ]
    ],
    "We are given a binary tree (with root node\u00a0root), a target node, and an integer value K.Return a list of the values of all\u00a0nodes that have a distance K from the target node.\u00a0 The answer can be returned in any order.\u00a0": [
        "all-nodes-distance-k-in-binary-tree",
        [],
        [
            "Tree",
            "Depth-first Search",
            "Breadth-first Search"
        ]
    ],
    "Return the length of the shortest, non-empty, contiguous\u00a0subarray of A with sum at least K.If there is no non-empty subarray with sum at least K, return -1.\u00a0": [
        "shortest-subarray-with-sum-at-least-k",
        [],
        [
            "Binary Search",
            "Queue"
        ]
    ],
    "We have a two dimensional matrix\u00a0A where each value is 0 or 1.A move consists of choosing any row or column, and toggling each value in that row or column: changing all 0s to 1s, and all 1s to 0s.After making any number of moves, every row of this matrix is interpreted as a binary number, and the score of the matrix is the sum of these numbers.Return the highest possible\u00a0score.\u00a0": [
        "score-after-flipping-matrix",
        [],
        [
            "Greedy"
        ]
    ],
    "At a lemonade stand, each lemonade costs $5.\u00a0Customers are standing in a queue to buy from you, and order one at a time (in the order specified by bills).Each customer will only buy one lemonade and\u00a0pay with either a $5, $10, or $20 bill.\u00a0 You must provide the correct change to each customer, so that the net transaction is that the customer pays $5.": [
        "lemonade-change",
        [],
        [
            "Greedy"
        ]
    ],
    "Given two strings A and B\u00a0of lowercase letters, return true if and only if we\u00a0can swap two letters in A so that the result equals B.\u00a0": [
        "buddy-strings",
        [],
        [
            "String"
        ]
    ],
    "There is\u00a0a special square room with mirrors on each of the four\u00a0walls.\u00a0 Except for the southwest\u00a0corner, there are receptors on each of the remaining corners, numbered 0, 1, and 2.The square room has walls of length p, and a laser ray from the southwest corner\u00a0first meets the east wall at a distance q\u00a0from the 0th receptor.Return the number of the receptor that the ray meets first.\u00a0 (It is guaranteed that the ray will meet\u00a0a receptor eventually.)\u00a0": [
        "mirror-reflection",
        [],
        [
            "Math"
        ]
    ],
    "There are N workers.\u00a0 The i-th worker has a quality[i] and a minimum wage expectation wage[i].Now we want to hire exactly K\u00a0workers to form a paid group.\u00a0 When hiring a group of K workers, we must pay them according to the following rules:Every worker in the paid group should be paid in the ratio of their quality compared to other workers in the paid group.Every worker in the paid group must be paid at least their minimum wage expectation.Return the least amount of money needed to form a paid group satisfying the above conditions.\u00a0": [
        "minimum-cost-to-hire-k-workers",
        [],
        [
            "Heap"
        ]
    ],
    "Given a balanced parentheses string S, compute the score of the string based on the following rule:() has score 1AB has score A + B, where A and B are balanced parentheses strings.(A) has score 2 * A, where A is a balanced parentheses string.\u00a0": [
        "score-of-parentheses",
        [],
        [
            "String",
            "Stack"
        ]
    ],
    "In an exam room, there are N seats in a single row, numbered 0, 1, 2, ..., N-1.When a student enters the room, they must sit in the seat that maximizes the distance to the closest person.\u00a0 If there are multiple such seats, they sit in the seat with the lowest number.\u00a0 (Also, if no one is in the room, then the student sits at seat number 0.)Return a class ExamRoom(int N)\u00a0that exposes two functions: ExamRoom.seat()\u00a0returning an int\u00a0representing what seat the student sat in, and ExamRoom.leave(int p)\u00a0representing that the student in seat number p\u00a0now leaves the room.\u00a0 It is guaranteed that any calls to ExamRoom.leave(p) have a student sitting in seat p.\u00a0": [
        "exam-room",
        [
            "maximize-distance-to-closest-person"
        ],
        [
            "Ordered Map"
        ]
    ],
    "Strings\u00a0A and B are K-similar (for some non-negative integer K) if we can swap the positions of two letters in A exactly K\u00a0times so that the resulting string equals B.Given two anagrams A and B, return the smallest K\u00a0for which A and B are K-similar.": [
        "k-similar-strings",
        [
            "couples-holding-hands"
        ],
        [
            "Breadth-first Search",
            "Graph"
        ]
    ],
    "N cars are going to the same destination along a one lane road.\u00a0 The destination is target\u00a0miles away.Each car i\u00a0has a constant speed speed[i]\u00a0(in miles per hour), and initial position position[i]\u00a0miles towards the target along the road.A car can never pass another car ahead of it, but it can catch up to it, and drive bumper to bumper at the same speed.The distance between these two cars is ignored - they are assumed to have the same position.A car fleet is some non-empty set of cars driving\u00a0at the same position and same speed.\u00a0 ": [
        "car-fleet",
        [],
        [
            "Sort"
        ]
    ],
    "Let's call an array arr a mountain\u00a0if the following properties hold:arr.length >= 3There exists some i with\u00a00 < i\u00a0< arr.length - 1\u00a0such that:\tarr[0] < arr[1] < ... arr[i-1] < arr[i] arr[i] > arr[i+1] > ... > arr[arr.length - 1]Given an integer array arr that is guaranteed to be\u00a0a mountain, return any\u00a0i\u00a0such that\u00a0arr[0] < arr[1] < ... arr[i - 1] < arr[i] > arr[i + 1] > ... > arr[arr.length - 1].\u00a0": [
        "peak-index-in-a-mountain-array",
        [
            "find-in-mountain-array",
            "find-peak-element"
        ],
        [
            "Binary Search"
        ]
    ],
    "In a group of N people (labelled 0, 1, 2, ..., N-1), each person has different amounts of money, and different levels of quietness.For convenience, we'll call the person with label x, simply \"person x\".We'll say that richer[i] = [x, y] if person x\u00a0definitely has more money than person\u00a0y.\u00a0 ": [
        "loud-and-rich",
        [],
        [
            "Depth-first Search"
        ]
    ],
    "We are given a list of (axis-aligned)\u00a0rectangles.\u00a0 Each\u00a0rectangle[i] = [x1, y1, x2, y2]\u00a0, where (x1, y1) are the coordinates of the bottom-left corner, and (x2, y2) are the coordinates of the top-right corner of the ith rectangle.Find the total area covered by all rectangles in the plane.\u00a0 Since the answer\u00a0may be too large, return it modulo 10^9 + 7.": [
        "rectangle-area-ii",
        [],
        [
            "Segment Tree",
            "Line Sweep"
        ]
    ],
    "In a row of seats, 1 represents a person sitting in that seat, and 0 represents that the seat is empty.\u00a0There is at least one empty seat, and at least one person sitting.Alex wants to sit in the seat such that the distance between him and the closest person to him is maximized.\u00a0Return that maximum distance to closest person.": [
        "maximize-distance-to-closest-person",
        [
            "exam-room"
        ],
        [
            "Array"
        ]
    ],
    "We have a string S of lowercase letters, and an integer array shifts.Call the shift of a letter, the next letter in the alphabet, (wrapping around so that 'z' becomes 'a').\u00a0": [
        "shifting-letters",
        [],
        [
            "String"
        ]
    ],
    "An undirected, connected graph of N nodes (labeled\u00a00, 1, 2, ..., N-1) is given as graph.graph.length = N, and j != i\u00a0is in the list\u00a0graph[i]\u00a0exactly once, if and only if nodes i and j are connected.Return the length of the shortest path that visits every node. You may start and stop at any node, you may revisit nodes multiple times, and you may reuse edges.\u00a0": [
        "shortest-path-visiting-all-nodes",
        [],
        [
            "Dynamic Programming",
            "Breadth-first Search"
        ]
    ],
    "Alice has a hand of cards, given as an array of integers.Now she wants to rearrange the cards into groups so that each group is size W, and consists of W consecutive cards.Return true if and only if she can.\u00a0": [
        "hand-of-straights",
        [],
        [
            "Ordered Map"
        ]
    ],
    "Let's call any (contiguous) subarray B (of A)\u00a0a mountain if the following properties hold:B.length >= 3There exists some 0 < i\u00a0< B.length - 1 such that B[0] < B[1] < ... B[i-1] < B[i] > B[i+1] > ... > B[B.length - 1](": [
        "longest-mountain-in-array",
        [],
        [
            "Two Pointers"
        ]
    ],
    "Given two\u00a0strings\u00a0S\u00a0and T,\u00a0return if they are equal when both are typed into empty text editors. # means a backspace character.": [
        "backspace-string-compare",
        [],
        [
            "Two Pointers",
            "Stack"
        ]
    ],
    "This problem is an\u00a0interactive problem\u00a0new to the LeetCode platform.We are given a word list of unique words, each word is 6 letters long, and one word in this list is chosen as secret.You may call master.guess(word)\u00a0to guess a word.\u00a0 The guessed word should have\u00a0type string\u00a0and must be from the original list\u00a0with 6 lowercase letters.This function returns an\u00a0integer\u00a0type, representing\u00a0the number of exact matches (value and position) of your guess to the secret word.\u00a0 Also, if your guess is not in the given wordlist, it will return -1 instead.For each test case, you have 10 guesses to guess the word. At the end of any number of calls, if you have made 10 or less calls to master.guess\u00a0and at least one of these guesses was the secret, you pass the testcase.Besides the example test case below, there will be 5\u00a0additional test cases, each with 100 words in the word list.\u00a0 The letters of each word in those testcases were chosen\u00a0independently at random from 'a' to 'z', such that every word in the given word lists is unique.": [
        "guess-the-word",
        [],
        [
            "Minimax"
        ]
    ],
    "Given a string S\u00a0of digits, such as S = \"123456579\", we can split it into a Fibonacci-like sequence\u00a0[123, 456, 579].": [
        "split-array-into-fibonacci-sequence",
        [
            "fibonacci-number",
            "additive-number"
        ],
        [
            "String",
            "Backtracking",
            "Greedy"
        ]
    ],
    "There are N rooms and you start in room 0.\u00a0 Each room has a distinct number in 0, 1, 2, ..., N-1, and each room may have\u00a0some keys to access the next room.\u00a0": [
        "keys-and-rooms",
        [],
        [
            "Depth-first Search",
            "Graph"
        ]
    ],
    "A 3 x 3 magic square is a 3 x 3 grid filled with distinct numbers from 1 to 9 such that each row, column, and both diagonals all have the same sum.Given an grid\u00a0of integers, how many 3 x 3 \"magic square\" subgrids are there?\u00a0 (Each subgrid is contiguous).\u00a0": [
        "magic-squares-in-grid",
        [],
        [
            "Array"
        ]
    ],
    "Two strings X\u00a0and Y\u00a0are similar if we can swap two letters (in different positions) of X, so that\u00a0it equals Y. Also two strings X and Y are similar if they are equal.": [
        "similar-string-groups",
        [],
        [
            "Depth-first Search",
            "Union Find",
            "Graph"
        ]
    ],
    "There are\u00a0N dominoes in a line, and we place each domino vertically upright.In the beginning, we simultaneously push\u00a0some of the dominoes either to the left or to the right.After each second, each domino that is falling to the left pushes the adjacent domino on the left.Similarly, the dominoes falling to the right push their adjacent dominoes standing on the right.When a vertical domino has dominoes falling on it from both sides, it stays still due to the balance of the forces.For the purposes of this question, we will consider that a falling domino\u00a0expends no additional force to a falling or already fallen domino.Given a string \"S\" representing the initial state.\u00a0S[i] = 'L', if the i-th domino has been pushed to the left; S[i] = 'R', if the i-th domino has been pushed to the right; S[i] = '.',\u00a0if the i-th domino has not been pushed.Return a string representing the final state.\u00a0": [
        "push-dominoes",
        [],
        [
            "Two Pointers",
            "Dynamic Programming"
        ]
    ],
    "Alice plays the following game, loosely based on the card game \"21\".Alice starts with 0 points, and draws numbers while she has less than K points.\u00a0 During each draw, she gains an integer number of points randomly from the range [1, W], where W is an integer.\u00a0 Each draw is independent and the outcomes have equal probabilities.Alice stops drawing numbers when she gets K or more points.\u00a0 What is the probability\u00a0that she has N or less points?": [
        "new-21-game",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "A rectangle is\u00a0represented as a\u00a0list [x1, y1, x2, y2], where\u00a0(x1, y1)\u00a0are the coordinates of its bottom-left corner, and (x2,\u00a0y2)\u00a0are the coordinates of its top-right corner.Two rectangles overlap if the area of their intersection is positive.\u00a0 To be clear, two rectangles that only touch at the corner or edges do not overlap.Given two (axis-aligned) rectangles, return whether\u00a0they overlap.": [
        "rectangle-overlap",
        [
            "rectangle-area"
        ],
        [
            "Math"
        ]
    ],
    "Two images A and B are given, represented as\u00a0binary, square matrices of the same size.\u00a0 (A binary matrix has only 0s and 1s as values.)We translate one image however we choose (sliding it left, right, up, or down any number of units), and place it on top of the other image.\u00a0 After, the overlap of this translation is the number of positions that have a 1 in both images.(Note also that a translation does not include any kind of rotation.)What is the largest possible overlap?": [
        "image-overlap",
        [],
        [
            "Array"
        ]
    ],
    "An undirected, connected\u00a0tree with N nodes labelled 0...N-1 and N-1 edges\u00a0are\u00a0given.The ith edge connects nodes\u00a0edges[i][0] and\u00a0edges[i][1]\u00a0together.Return a list ans, where ans[i] is the sum of the distances between node i and all other nodes.": [
        "sum-of-distances-in-tree",
        [
            "distribute-coins-in-binary-tree"
        ],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "To some string S, we will perform some\u00a0replacement\u00a0operations that replace groups of letters with new ones (not necessarily the same size).Each replacement operation has 3 parameters: a starting index i, a source word\u00a0x\u00a0and a target word\u00a0y.\u00a0 The rule is that if x\u00a0starts at position i\u00a0in the original string S, then we will replace that occurrence of\u00a0x\u00a0with\u00a0y.\u00a0 If not, we do nothing.": [
        "find-and-replace-in-string",
        [],
        [
            "String"
        ]
    ],
    "Given a binary matrix A, we want to flip the image horizontally, then invert it, and return the resulting image.To flip an image horizontally means that each row of the image is reversed.\u00a0 ": [
        "flipping-an-image",
        [],
        [
            "Array"
        ]
    ],
    "Design your implementation of the circular queue. The circular queue is a linear data structure in which the operations are performed based on FIFO (First In First Out) principle and the last position is connected back to the first position to make a circle. It is also called \"Ring Buffer\".One of the benefits of the circular queue is that we can make use of the spaces in front of the queue. In a normal queue, once the queue becomes full, we cannot insert the next element even if there is a space in front of the queue. But using the circular queue, we can use the space to store new values.Your implementation should support following operations:MyCircularQueue(k): Constructor, set the size of the queue to be k.Front: Get the front item from the queue. If the queue is empty, return -1.Rear: Get the last item from the queue. If the queue is empty, return -1.enQueue(value): Insert an element into the circular queue. Return true if the operation is successful.deQueue(): Delete an element from the circular queue. Return true if the operation is successful.isEmpty(): Checks whether the circular queue is empty or not.isFull(): Checks whether the circular queue is full or not.\u00a0": [
        "design-circular-queue",
        [
            "design-circular-deque"
        ],
        [
            "Design",
            "Queue"
        ]
    ],
    "Design your implementation of the circular double-ended queue (deque).Your implementation should support following operations:MyCircularDeque(k): Constructor, set the size of the deque to be k.insertFront(): Adds an item at the front of Deque. Return true if the operation is successful.insertLast(): Adds an item at the rear of Deque. Return true if the operation is successful.deleteFront(): Deletes an item from the front of Deque. Return true if the operation is successful.deleteLast(): Deletes an item from the rear of Deque. Return true if the operation is successful.getFront(): Gets the front item from the Deque. If the deque is empty, return -1.getRear(): Gets the last item from Deque. If the deque is empty, return -1.isEmpty(): Checks whether Deque is empty or not.\u00a0isFull(): Checks whether Deque is full or not.\u00a0": [
        "design-circular-deque",
        [
            "design-circular-queue"
        ],
        [
            "Design",
            "Queue"
        ]
    ],
    "We are given a\u00a0personal information string S, which may represent\u00a0either an email address or a phone number.We would like to mask this\u00a0personal information according to the\u00a0following rules:1. Email address:We define a\u00a0name to be a string of length \u2265 2 consisting\u00a0of only lowercase letters\u00a0a-z or uppercase\u00a0letters\u00a0A-Z.An email address starts with a name, followed by the\u00a0symbol '@', followed by a name, followed by the\u00a0dot\u00a0'.'\u00a0and\u00a0followed by a name.\u00a0All email addresses are\u00a0guaranteed to be valid and in the format of\u00a0\"name1@name2.name3\".To mask an email, all names must be converted to lowercase and all letters between the first and last letter of the first name must be replaced by 5 asterisks '*'.2. Phone number:A phone number is a string consisting of\u00a0only the digits 0-9 or the characters from the set {'+', '-', '(', ')', '\u00a0'}.\u00a0": [
        "masking-personal-information",
        [],
        [
            "String"
        ]
    ],
    "In a string\u00a0S\u00a0of lowercase letters, these letters form consecutive groups of the same character.": [
        "positions-of-large-groups",
        [],
        [
            "Array"
        ]
    ],
    "Given a positive integer\u00a0N, how many ways can we write it as a sum of\u00a0consecutive positive integers?": [
        "consecutive-numbers-sum",
        [],
        [
            "Math"
        ]
    ],
    "Let's define a function countUniqueChars(s)\u00a0that returns the number of unique characters on s, for example if s = \"LEETCODE\"\u00a0then \"L\", \"T\",\"C\",\"O\",\"D\" are the unique characters since they appear only once in s, therefore\u00a0countUniqueChars(s) = 5.On this problem given a string s we need to return the sum of\u00a0countUniqueChars(t)\u00a0where t is a substring of s. Notice that some substrings can be repeated so on this case you have to count the repeated ones too.Since the answer can be very large, return\u00a0the answer\u00a0modulo\u00a010 ^ 9 + 7.\u00a0": [
        "count-unique-characters-of-all-substrings-of-a-given-string",
        [],
        [
            "Two Pointers"
        ]
    ],
    "In a 2D grid of 0s and 1s, we change at most one 0 to a 1.After, what is the size of the largest island?\u00a0(An island is a 4-directionally connected group of 1s).": [
        "making-a-large-island",
        [],
        [
            "Depth-first Search"
        ]
    ],
    "We have jobs: difficulty[i]\u00a0is the difficulty of the\u00a0ith job, and\u00a0profit[i]\u00a0is the profit of the\u00a0ith job.\u00a0Now we have some workers.\u00a0worker[i]\u00a0is the ability of the\u00a0ith worker, which means that this worker can only complete a job with difficulty at most\u00a0worker[i].\u00a0Every worker can be assigned at most one job, but one job\u00a0can be completed multiple times.": [
        "most-profit-assigning-work",
        [],
        [
            "Two Pointers"
        ]
    ],
    "Some people will make friend requests. The\u00a0list of their ages is given and\u00a0ages[i]\u00a0is the age of the\u00a0ith person.\u00a0Person A will NOT friend request person B (B != A) if any of the following conditions are true:age[B]\u00a0<= 0.5 * age[A]\u00a0+ 7age[B]\u00a0> age[A]age[B]\u00a0> 100 &&\u00a0age[A]\u00a0< 100Otherwise, A will friend request B.": [
        "friends-of-appropriate-ages",
        [],
        [
            "Array"
        ]
    ],
    "A sentence S is given, composed of words separated by spaces. Each word consists of lowercase and uppercase letters only.We would like to convert the sentence to \"Goat Latin\"\u00a0(a made-up language similar to Pig Latin.)The rules of Goat Latin are as follows:If a word begins with a vowel (a, e, i, o, or u), append \"ma\"\u00a0to the end of the word.\t": [
        "goat-latin",
        [],
        [
            "String"
        ]
    ],
    "Given an array of unique integers, each integer is strictly greater than 1.We make a binary tree using these integers\u00a0and each number may be used for any number of times.Each non-leaf node's\u00a0value should be equal to the product of the values of it's children.How many binary trees can we make?\u00a0 Return the answer modulo 10 ** 9 + 7.": [
        "binary-trees-with-factors",
        [],
        []
    ],
    "On a table are N cards, with a positive integer printed on the front and back of each card (possibly different).We flip any number of cards, and after we choose one\u00a0card.\u00a0If the number X on the back of the chosen\u00a0card is not on the front of any card, then this number X is good.What is the smallest number that is good?\u00a0 If no number is good, output 0.Here, fronts[i] and backs[i] represent the number on the front and back of card i.\u00a0A\u00a0flip swaps the front and back numbers, so the value on the front is now on the back and vice versa.": [
        "card-flipping-game",
        [],
        []
    ],
    "Given a string S\u00a0and a character C, return an array of integers representing the shortest distance from the character C in the string.": [
        "shortest-distance-to-a-character",
        [],
        []
    ],
    "Given a list of words, we may encode it by writing a reference string S and a list of indexes A.": [
        "short-encoding-of-words",
        [],
        []
    ],
    "Design your\u00a0implementation of the linked list. You can choose to use the singly linked list or the doubly linked list. A node in a singly\u00a0linked list should have two attributes: val\u00a0and next. val is the value of the current node, and next\u00a0is\u00a0a\u00a0pointer/reference to the next node. If you want to use the doubly linked list,\u00a0you will need\u00a0one more attribute prev to indicate the previous node in the linked list. Assume all nodes in the linked list are 0-indexed.Implement these functions in your linked list class:get(index) : Get the value of\u00a0the index-th\u00a0node in the linked list. If the index is invalid, return -1.addAtHead(val) : Add a node of value val\u00a0before the first element of the linked list. After the insertion, the new node will be the first node of the linked list.addAtTail(val) : Append a node of value val\u00a0to the last element of the linked list.addAtIndex(index, val) : Add a node of value val\u00a0before the index-th\u00a0node in the linked list.\u00a0If index\u00a0equals\u00a0to the length of\u00a0linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted.deleteAtIndex(index) : Delete\u00a0the index-th\u00a0node in the linked list, if the index is valid.\u00a0": [
        "design-linked-list",
        [
            "design-skiplist"
        ],
        [
            "Linked List",
            "Design"
        ]
    ],
    "Given a paragraph\u00a0and a list of banned words, return the most frequent word that is not in the list of banned words.\u00a0 It is guaranteed there is at least one word that isn't banned, and that the answer is unique.Words in the list of banned words are given in lowercase, and free of punctuation.\u00a0 Words in the paragraph are not case sensitive.\u00a0 The answer is in lowercase.\u00a0": [
        "most-common-word",
        [],
        [
            "String"
        ]
    ],
    "Your car starts at position 0 and speed +1 on an infinite number line.\u00a0 (Your car can go into negative positions.)Your car drives automatically according to a sequence of instructions A (accelerate) and R (reverse).When you get an instruction \"A\", your car does the following:\u00a0position += speed, speed *= 2.When you get an instruction \"R\", your car does the following: if your speed is positive then\u00a0speed = -1\u00a0, otherwise\u00a0speed = 1.\u00a0 (Your position stays the same.)": [
        "race-car",
        [],
        [
            "Dynamic Programming",
            "Heap"
        ]
    ],
    "We are given\u00a0head,\u00a0the head node of a linked list containing\u00a0unique integer values.We are also given the list\u00a0G, a subset of the values in the linked list.Return the number of connected components in G, where two values are connected if they appear consecutively in the linked list.": [
        "linked-list-components",
        [],
        [
            "Linked List"
        ]
    ],
    "We had some 2-dimensional coordinates, like \"(1, 3)\" or \"(2, 0.5)\".\u00a0 Then, we removed\u00a0all commas, decimal points, and spaces, and ended up with the string\u00a0S.\u00a0 Return a list of strings representing\u00a0all possibilities for what our original coordinates could have been.Our original representation never had extraneous zeroes, so we never started with numbers like \"00\", \"0.0\", \"0.00\", \"1.0\", \"001\", \"00.01\", or any other number that can be represented with\u00a0less digits.\u00a0 Also, a decimal point within a number never occurs without at least one digit occuring before it, so we never started with numbers like \".1\".The final answer list can be returned in any order.\u00a0 Also note that all coordinates in the final answer\u00a0have exactly one space between them (occurring after the comma.)": [
        "ambiguous-coordinates",
        [],
        [
            "String"
        ]
    ],
    "We have a list of bus routes. Each routes[i] is a bus route that the i-th bus\u00a0repeats forever. ": [
        "bus-routes",
        [],
        [
            "Breadth-first Search"
        ]
    ],
    "We are given the head node root\u00a0of a binary tree, where additionally every node's value is either a 0 or a 1.Return the same tree where every subtree (of the given tree) not containing a 1 has been removed.(Recall that the subtree of a node X is X, plus every node that is a descendant of X.)": [
        "binary-tree-pruning",
        [],
        [
            "Tree"
        ]
    ],
    "We partition a row of numbers A\u00a0into at most K adjacent (non-empty) groups, then our score is the sum of the average of each group. What is the largest score we can achieve?": [
        "largest-sum-of-averages",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "You have a list of points in the plane. Return the area of the largest triangle that can be formed by any 3 of the points.": [
        "largest-triangle-area",
        [
            "largest-perimeter-triangle"
        ],
        [
            "Math"
        ]
    ],
    "A website domain like \"discuss.leetcode.com\" consists of various subdomains. At the top level, we have \"com\", at the next level, we have \"leetcode.com\", and at the lowest level, \"discuss.leetcode.com\". When we visit a domain like \"discuss.leetcode.com\", we will also visit the parent domains \"leetcode.com\" and \"com\" implicitly.Now, call a \"count-paired domain\" to be a count (representing the number of visits this domain received), followed by a space, followed by the address. An example of a count-paired domain might be \"9001 discuss.leetcode.com\".We are given a list cpdomains of count-paired domains. We would like a list of count-paired domains, (in the same format as the input, and in any order), that explicitly counts the number of visits to each subdomain.": [
        "subdomain-visit-count",
        [],
        [
            "Hash Table"
        ]
    ],
    "We are given non-negative integers nums[i] which are written on a chalkboard.\u00a0 Alice and Bob take turns erasing exactly one number from the chalkboard, with Alice starting first.\u00a0 If erasing a number causes\u00a0the bitwise XOR of all the elements of the chalkboard to become\u00a00, then that player loses.\u00a0 (Also, we'll say the bitwise XOR of one element is that element itself, and the bitwise XOR of no elements is 0.)Also, if any player starts their turn with the bitwise XOR of all the elements of the chalkboard equal to 0, then that player wins.Return True if and only if Alice wins the game, assuming both players play optimally.": [
        "chalkboard-xor-game",
        [],
        [
            "Math"
        ]
    ],
    "Sometimes people repeat letters to represent extra feeling, such as \"hello\" -> \"heeellooo\", \"hi\" -> \"hiiii\".\u00a0 In these strings like \"heeellooo\", we have groups of adjacent letters that are all the same:\u00a0 \"h\", \"eee\", \"ll\", \"ooo\".For some given string S, a query word is stretchy if it can be made to be equal to S by any\u00a0number of\u00a0applications of the following extension operation: choose a group consisting of\u00a0characters c, and add some number of characters c to the group so that the size of the group is 3 or more.": [
        "expressive-words",
        [],
        [
            "String"
        ]
    ],
    "There are two types of soup: type A and type B. Initially we have N ml of each type of soup. There are four kinds of operations:Serve\u00a0100 ml of soup A and 0 ml of soup BServe\u00a075 ml of soup A and 25\u00a0ml of soup BServe 50 ml of soup A and 50 ml of soup BServe 25\u00a0ml of soup A and 75\u00a0ml of soup BWhen we serve some soup, we give it to someone and we no longer have it.\u00a0 Each turn,\u00a0we will choose from the four operations with equal probability 0.25. If the remaining volume of soup is not enough to complete the operation, we will serve\u00a0as much as we can.\u00a0 We stop once we no longer have some quantity of both types of soup.": [
        "soup-servings",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "In a 2 dimensional array grid, each value grid[i][j] represents the height of a building located there. We are allowed to increase the height of any number of buildings, by any amount (the amounts\u00a0can be different for different buildings). Height\u00a00 is considered to be a\u00a0building\u00a0as well.\u00a0At the end, the \"skyline\" when viewed from all four directions\u00a0of the grid, i.e.\u00a0top, bottom, left, and right,\u00a0must be the same as the\u00a0skyline of the original grid. A city's skyline is the outer contour of the rectangles formed by all the buildings when viewed from a distance. See\u00a0the following example.What is the maximum total sum that the height of the buildings can be increased?": [
        "max-increase-to-keep-city-skyline",
        [],
        []
    ],
    "We are to write the letters of a given string S, from left to right into lines. Each line has maximum width 100 units, and if writing a letter would cause the width of the line to exceed 100 units, it is written on the next line. We are given an array\u00a0widths, an array where widths[0] is the width of 'a', widths[1] is the width of 'b', ..., and widths[25] is the width of 'z'.Now answer two questions: how many lines have at least one character from S, and what is the width used by the last such line? Return your answer as an integer list of length 2.\u00a0": [
        "number-of-lines-to-write-string",
        [],
        []
    ],
    "In a given integer array A, we must move every element of A to either list B or list C. (B and C initially start empty.)Return true if and only if after such a move, it is possible that the average value of B is equal to the average value of C, and B and C are both non-empty.": [
        "split-array-with-same-average",
        [],
        [
            "Math"
        ]
    ],
    "International Morse Code defines a standard encoding where each letter is mapped to a series of dots and dashes, as follows: \"a\" maps to \".-\", \"b\" maps to \"-...\", \"c\" maps to \"-.-.\", and so on.For convenience, the full table for the 26 letters of the English alphabet is given below:[\".-\",\"-...\",\"-.-.\",\"-..\",\".\",\"..-.\",\"--.\",\"....\",\"..\",\".---\",\"-.-\",\".-..\",\"--\",\"-.\",\"---\",\".--.\",\"--.-\",\".-.\",\"...\",\"-\",\"..-\",\"...-\",\".--\",\"-..-\",\"-.--\",\"--..\"]Now, given a list of words, each word can be written as a concatenation of the Morse code of each letter. ": [
        "unique-morse-code-words",
        [],
        [
            "String"
        ]
    ],
    "We have a grid of 1s and 0s; the 1s in a cell represent bricks.\u00a0 A brick will not drop if and only if it is directly connected to the top of the grid, or at least one of its (4-way) adjacent bricks will not drop.We will do some erasures\u00a0sequentially. Each time we want to do the erasure at the location (i, j), the brick (if it exists) on that location will disappear, and then some other bricks may\u00a0drop because of that\u00a0erasure.Return an array representing the number of bricks that will drop after each erasure in sequence.": [
        "bricks-falling-when-hit",
        [],
        [
            "Union Find"
        ]
    ],
    "In a directed graph, we start at some node and every turn, walk along a directed edge of the graph.\u00a0 If we reach a node that is terminal (that is, it has no outgoing directed edges), we stop.Now, say our starting node is eventually safe\u00a0if and only if we must eventually walk to a terminal node.\u00a0 More specifically, there exists a natural number K so that for any choice of where to walk, we must have stopped at a terminal node in less than K steps.Which nodes are eventually safe?\u00a0 Return them as an array in sorted order.The directed graph has N nodes with labels 0, 1, ..., N-1, where N is the length of graph.\u00a0 The\u00a0graph is given in the following form: graph[i] is a list of labels j such that (i, j) is a directed edge of the graph.": [
        "find-eventual-safe-states",
        [],
        [
            "Depth-first Search",
            "Graph"
        ]
    ],
    "We have two integer sequences A and B of the same non-zero length.We are allowed to swap elements A[i] and B[i].\u00a0 ": [
        "minimum-swaps-to-make-sequences-increasing",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Design a HashMap\u00a0without using any built-in hash table libraries.To be specific, your design should include these functions:put(key, value) :\u00a0Insert a (key, value) pair into the HashMap. If the value already exists in the HashMap, update the value.get(key): Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key.remove(key) :\u00a0Remove the mapping for the value key if this map contains the mapping for the key.": [
        "design-hashmap",
        [
            "design-skiplist",
            "design-hashset"
        ],
        [
            "Hash Table",
            "Design"
        ]
    ],
    "Design a HashSet\u00a0without using any built-in hash table libraries.To be specific, your design should include these functions:add(value):\u00a0Insert a value into the HashSet.\u00a0contains(value) : Return whether the value exists in the HashSet or not.remove(value): Remove a value in\u00a0the HashSet. If the value does not exist in the HashSet, do nothing.": [
        "design-hashset",
        [
            "design-skiplist",
            "design-hashmap"
        ],
        [
            "Hash Table",
            "Design"
        ]
    ],
    "We stack glasses in a pyramid, where the first row has 1 glass, the second row has 2 glasses, and so on until the 100th row.\u00a0 Each glass holds one cup (250ml) of champagne.Then, some champagne is poured in the first glass at the top.\u00a0 When the top most glass is full, any excess liquid poured will fall equally to the glass immediately to the left and right of it.\u00a0 When those glasses become full, any excess champagne will fall equally to the left and right of those glasses, and so on.\u00a0 (A glass at the bottom row has it's excess champagne fall on the floor.)": [
        "champagne-tower",
        [],
        []
    ],
    "\u00a0Given an array A, we may rotate it by a non-negative integer K so that the array becomes A[K], A[K+1], A{K+2], ... A[A.length - 1], A[0], A[1], ..., A[K-1].\u00a0 Afterward, any entries that are less than or equal to their index are worth 1 point.\u00a0": [
        "smallest-rotation-with-highest-score",
        [],
        []
    ],
    "Given a directed\u00a0acyclic graph of N nodes.\u00a0Find all possible paths from node 0 to node N-1, and return them in any order.The graph is given as follows:\u00a0 the nodes are 0, 1, ..., graph.length - 1.\u00a0 graph[i] is a list of all nodes j for which the edge (i, j) exists.": [
        "all-paths-from-source-to-target",
        [],
        []
    ],
    "We are given two strings, A and B.A shift on A consists of taking string A and moving the leftmost character to the rightmost position. ": [
        "rotate-string",
        [],
        []
    ],
    "We are given an array A of positive integers, and two positive integers L and R (L <= R).Return the number of (contiguous, non-empty) subarrays such that the value of the maximum array element in that subarray is at least L and at most R.": [
        "number-of-subarrays-with-bounded-maximum",
        [],
        [
            "Array"
        ]
    ],
    "A Tic-Tac-Toe board is given as a string array board. Return True if and only if it is possible to reach this board position during the course of a valid tic-tac-toe game.The board is a 3 x 3 array, and consists of characters \" \", \"X\", and \"O\".\u00a0 The \" \" character represents an empty square.Here are the rules of Tic-Tac-Toe:Players take turns placing characters into empty squares (\" \").The first player always places \"X\" characters, while the second player always places \"O\" characters.\"X\" and \"O\" characters are always placed into empty squares, never filled ones.The game ends when there are 3 of the same (non-empty) character filling any row, column, or diagonal.The game also ends if all squares are non-empty.No more moves can be played if the game is over.": [
        "valid-tic-tac-toe-state",
        [
            "design-tic-tac-toe"
        ],
        [
            "Math",
            "Recursion"
        ]
    ],
    "Let f(x) be the number of zeroes at the end of x!. (Recall that x! = 1 * 2 * 3 * ... * x, and by convention, 0! = 1.)": [
        "preimage-size-of-factorial-zeroes-function",
        [
            "factorial-trailing-zeroes"
        ],
        [
            "Binary Search"
        ]
    ],
    "Given string S and a\u00a0dictionary of words words, find the number of words[i] that is a subsequence of S.": [
        "number-of-matching-subsequences",
        [
            "shortest-way-to-form-string",
            "is-subsequence"
        ],
        [
            "Array"
        ]
    ],
    "S and T are strings composed of lowercase letters. In S, no letter occurs more than once.S was sorted in some custom order previously. We want to permute the characters of T so that they match the order that S was sorted. More specifically, if x occurs before y in S, then x should occur before y in the returned string.Return any permutation of T (as a string) that satisfies this property.": [
        "custom-sort-string",
        [],
        [
            "String"
        ]
    ],
    "We have two types of tiles: a 2x1 domino shape, and an \"L\" tromino shape. These shapes may be rotated.XX  <- dominoXX  <- \"L\" trominoXGiven N, how many ways are there to tile a 2 x N board? Return your answer modulo 10^9 + 7.(In a tiling, every square must be covered by a tile. Two tilings are different if and only if there are two 4-directionally adjacent cells on the board such that exactly one of the tilings has both squares occupied by a tile.)": [
        "domino-and-tromino-tiling",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "You are playing a simplified Pacman game. You\u00a0start at the point (0, 0), and your destination is (target[0], target[1]). There are several ghosts on the map, the i-th ghost starts at (ghosts[i][0], ghosts[i][1]).Each turn, you and all ghosts simultaneously *may* move in one of 4 cardinal directions: north, east, west, or south, going from the previous point to a new point 1 unit of distance away.You escape if and only if you can reach the target before any ghost reaches you (for any given moves the ghosts may take.)\u00a0 If you reach any square (including the target) at the same time as a ghost, it doesn't count as an escape.Return True if and only if it is possible to escape.": [
        "escape-the-ghosts",
        [],
        [
            "Math"
        ]
    ],
    "X is a good number if after rotating each digit individually by 180 degrees, we get a valid number that is different from X.\u00a0 Each digit must be rotated - we cannot choose to leave it alone.A number is valid if each digit remains a digit after rotation. 0, 1, and 8 rotate to themselves; 2 and 5 rotate to each other (on this case they are rotated in a different direction, in other words 2 or 5 gets mirrored); 6 and 9 rotate to each other, and the rest of the numbers do not rotate to any other number and become invalid.Now\u00a0given a positive number N, how many numbers X from 1 to N are good?": [
        "rotated-digits",
        [],
        [
            "String"
        ]
    ],
    "There are n cities connected by\u00a0m flights. Each flight starts from city\u00a0u and arrives at\u00a0v with a price w.Now given all the cities and flights, together with starting city src and the destination\u00a0dst, your task is to find the cheapest price from src to dst with up to k stops. If there is no such route, output -1.": [
        "cheapest-flights-within-k-stops",
        [
            "maximum-vacation-days"
        ],
        [
            "Dynamic Programming",
            "Heap",
            "Breadth-first Search"
        ]
    ],
    "A sorted list A contains 1, plus some number of primes.\u00a0 Then, for every p < q in the list, we consider the fraction p/q.What is the K-th smallest fraction considered?\u00a0 Return your answer as an array of ints, where answer[0] = p and answer[1] = q.": [
        "k-th-smallest-prime-fraction",
        [
            "find-k-th-smallest-pair-distance",
            "kth-smallest-number-in-multiplication-table",
            "kth-smallest-element-in-a-sorted-matrix"
        ],
        [
            "Binary Search",
            "Heap"
        ]
    ],
    "Given an undirected\u00a0graph, return true if and only if it is bipartite.Recall that a graph is bipartite if we can split it's set of nodes into two independent\u00a0subsets A and B such that every edge in the graph has one node in A and another node in B.The graph is given in the following form: graph[i] is a list of indexes j for which the edge between nodes i and j exists.\u00a0 Each node is an integer between 0 and graph.length - 1.\u00a0 There are no self edges or parallel edges: graph[i] does not contain i, and it doesn't contain any element twice.": [
        "is-graph-bipartite",
        [],
        [
            "Depth-first Search",
            "Breadth-first Search",
            "Graph"
        ]
    ],
    "Given a string S, we can transform every letter individually\u00a0to be lowercase or uppercase to create another string.Return a list of all possible strings we could create. You can return the output\u00a0in any order.\u00a0": [
        "letter-case-permutation",
        [
            "brace-expansion",
            "subsets"
        ],
        [
            "Backtracking",
            "Bit Manipulation"
        ]
    ],
    "Given a Binary Search Tree (BST) with the root node root, return\u00a0the minimum difference between the values of any two different nodes in the tree.": [
        "minimum-distance-between-bst-nodes",
        [
            "binary-tree-inorder-traversal"
        ],
        [
            "Tree",
            "Recursion"
        ]
    ],
    "An N x N board contains only 0s and 1s. In each move, you can swap any 2 rows with each other, or any 2 columns with each other.What is the minimum number of moves to transform the board into a \"chessboard\" - a board where no 0s and no 1s are 4-directionally adjacent? If the task is impossible, return -1.": [
        "transform-to-chessboard",
        [],
        [
            "Array",
            "Math"
        ]
    ],
    "In a forest, each rabbit has some color. Some subset of rabbits (possibly all of them) tell you how many other rabbits have the same color as them. Those answers are placed in an array.Return the minimum number of rabbits that could be in the forest.": [
        "rabbits-in-forest",
        [],
        [
            "Hash Table",
            "Math"
        ]
    ],
    "A move consists of taking a point (x, y) and transforming it to either (x, x+y) or (x+y, y).Given a starting point (sx, sy) and a target point (tx, ty), return True if and only if a sequence of moves exists to transform the point (sx, sy) to (tx, ty). Otherwise, return False.": [
        "reaching-points",
        [],
        [
            "Math"
        ]
    ],
    "On the first row, we write a 0. Now in every subsequent row, we look at the previous row and replace each occurrence of 0 with 01, and each occurrence of 1 with 10.Given row N and index K, return the K-th indexed symbol in row N. (The values of K are 1-indexed.) (1 indexed).": [
        "k-th-symbol-in-grammar",
        [],
        [
            "Recursion"
        ]
    ],
    "On an N x N grid, each square grid[i][j] represents the elevation at that point (i,j).Now rain starts to fall. At time t, the depth of the water everywhere is t. You can swim from a square to another 4-directionally adjacent square if and only if the elevation of both squares individually are\u00a0at most\u00a0t. You can swim infinite distance in zero time. Of course, you must stay within the boundaries of the grid during your swim.You start at the top left square (0, 0). What is the least time until you can reach the bottom right square (N-1, N-1)?": [
        "swim-in-rising-water",
        [],
        [
            "Binary Search",
            "Heap",
            "Depth-first Search",
            "Union Find"
        ]
    ],
    "In a string composed of 'L', 'R', and 'X' characters, like \"RXXLRXRXL\", a move consists of either replacing one occurrence of \"XL\" with \"LX\", or replacing one occurrence of \"RX\" with \"XR\". Given the starting string start and the ending string end, return True if and only if there exists a sequence of moves to transform one string to the other.\u00a0": [
        "swap-adjacent-in-lr-string",
        [],
        [
            "Brainteaser"
        ]
    ],
    "Given a sorted (in ascending order) integer array nums of n elements and a target value, write a function to search target in nums. If target exists, then return its index, otherwise return -1.": [
        "binary-search",
        [
            "search-in-a-sorted-array-of-unknown-size"
        ],
        [
            "Binary Search"
        ]
    ],
    "We have some permutation A of [0, 1, ..., N - 1], where N is the length of A.The number of (global) inversions is the number of i < j with 0 <= i < j < N and A[i] > A[j].The number of local inversions is the number of i with 0 <= i < N and A[i] > A[i+1].Return true\u00a0if and only if the number of global inversions is equal to the number of local inversions.": [
        "global-and-local-inversions",
        [],
        [
            "Array",
            "Math"
        ]
    ],
    "Design a class to find\u00a0the kth largest element in a stream. ": [
        "kth-largest-element-in-a-stream",
        [
            "kth-largest-element-in-an-array"
        ],
        [
            "Heap"
        ]
    ],
    "On a 2x3 board, there are 5 tiles represented by the integers 1 through 5, and an empty square represented by 0.A move consists of choosing 0\u00a0and a 4-directionally adjacent number and swapping it.The state of the board is solved if and only if the board is [[1,2,3],[4,5,0]].Given a puzzle board, return the least number of moves required so that the state of the board is solved. If it is impossible for the state of the board to be solved, return -1.": [
        "sliding-puzzle",
        [],
        [
            "Breadth-first Search"
        ]
    ],
    "Given the root node of a binary search tree (BST) and a value to be inserted into the tree,\u00a0insert the value into the BST. Return the root node of the BST after the insertion. It is guaranteed that the new value does not exist in the original BST.": [
        "insert-into-a-binary-search-tree",
        [
            "search-in-a-binary-search-tree"
        ],
        [
            "Tree"
        ]
    ],
    "Given the root node of a binary search tree (BST) and a value. You need to find the node in the BST that the node's value equals the given value. Return the subtree rooted with that node. If such node doesn't exist, you should return NULL.": [
        "search-in-a-binary-search-tree",
        [
            "insert-into-a-binary-search-tree",
            "closest-binary-search-tree-value"
        ],
        [
            "Tree"
        ]
    ],
    "You're given strings J representing the types of stones that are jewels, and S representing the stones you have.\u00a0 Each character in S is a type of stone you have.\u00a0 You want to know how many of the stones you have are also jewels.The letters in J are guaranteed distinct, and all characters in J and S are letters. Letters are case sensitive, so \"a\" is considered a different type of stone from \"A\".": [
        "jewels-and-stones",
        [],
        [
            "Hash Table"
        ]
    ],
    "Given an expression\u00a0such as expression = \"e + 8 - a + 5\" and an evaluation map such as {\"e\": 1} (given in terms of evalvars = [\"e\"] and evalints = [1]), return a list of tokens representing the simplified expression, such as [\"-1*a\",\"14\"]An expression alternates chunks and symbols, with a space separating each chunk and symbol.A chunk is either an expression in parentheses, a variable, or a non-negative integer.A variable is a string of lowercase letters (not including digits.) ": [
        "basic-calculator-iv",
        [
            "basic-calculator-iii",
            "parse-lisp-expression"
        ],
        [
            "Hash Table",
            "String",
            "Stack"
        ]
    ],
    "Given an array arr that is a permutation of [0, 1, ..., arr.length - 1], we split the array into some number of \"chunks\" (partitions), and individually sort each chunk.\u00a0 After concatenating them,\u00a0the result equals the sorted array.What is the most number of chunks we could have made?": [
        "max-chunks-to-make-sorted",
        [
            "max-chunks-to-make-sorted-ii"
        ],
        [
            "Array"
        ]
    ],
    "This question is the same as \"Max Chunks to Make Sorted\" except the integers of the given array are not necessarily distinct, the input array could be up to length 2000, and the elements could be up to 10**8.Given an array arr of integers (not necessarily distinct), we split the array into some number of \"chunks\" (partitions), and individually sort each chunk.\u00a0 After concatenating them,\u00a0the result equals the sorted array.What is the most number of chunks we could have made?": [
        "max-chunks-to-make-sorted-ii",
        [
            "max-chunks-to-make-sorted"
        ],
        [
            "Array"
        ]
    ],
    "Given a string S, check if the letters can be rearranged so that two characters that are adjacent to each other are not the same.If possible, output any possible result.\u00a0 If not possible, return the empty string.": [
        "reorganize-string",
        [
            "task-scheduler",
            "rearrange-string-k-distance-apart"
        ],
        [
            "String",
            "Heap",
            "Greedy",
            "Sort"
        ]
    ],
    "A matrix is Toeplitz if every diagonal from top-left to bottom-right has the same element.Now given an M x N matrix, return\u00a0True\u00a0if and only if the matrix is Toeplitz.\u00a0": [
        "toeplitz-matrix",
        [
            "valid-word-square"
        ],
        [
            "Array"
        ]
    ],
    "Given an n-ary tree, return the postorder traversal of its nodes' values.Nary-Tree input serialization\u00a0is represented in their level order traversal, each group of children is separated by the null value (See examples).\u00a0": [
        "n-ary-tree-postorder-traversal",
        [
            "n-ary-tree-preorder-traversal",
            "n-ary-tree-level-order-traversal",
            "binary-tree-postorder-traversal"
        ],
        [
            "Tree"
        ]
    ],
    "Given an n-ary tree, return the preorder traversal of its nodes' values.Nary-Tree input serialization\u00a0is represented in their level order traversal, each group of children is separated by the null value (See examples).\u00a0": [
        "n-ary-tree-preorder-traversal",
        [
            "n-ary-tree-postorder-traversal",
            "n-ary-tree-level-order-traversal",
            "binary-tree-preorder-traversal"
        ],
        [
            "Tree"
        ]
    ],
    "Given a n-ary tree, find its maximum depth.The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.Nary-Tree input serialization\u00a0is represented in their level order traversal, each group of children is separated by the null value (See examples).\u00a0": [
        "maximum-depth-of-n-ary-tree",
        [
            "maximum-depth-of-binary-tree"
        ],
        [
            "Tree",
            "Depth-first Search",
            "Breadth-first Search"
        ]
    ],
    "A Binary Matrix is a matrix in which all the elements are either 0 or 1.Given quadTree1 and quadTree2. quadTree1 represents a n * n binary matrix and quadTree2 represents another\u00a0n * n binary matrix.\u00a0Return a Quad-Tree representing the n * n binary matrix which is the result of logical bitwise OR of the two binary matrixes represented by quadTree1 and quadTree2.Notice that you can assign the value of a node to True or False when isLeaf is False, and both are accepted in the answer.A Quad-Tree is a tree data structure in which each internal node has exactly four children. Besides, each node has two attributes:val: True if the node represents a grid of 1's or False if the node represents a grid of 0's.\u00a0isLeaf: True if the node is leaf node on the tree or False if the node has the four children.class Node {    public boolean val;\u00a0 \u00a0 public boolean isLeaf;\u00a0 \u00a0 public Node topLeft;\u00a0 \u00a0 public Node topRight;\u00a0 \u00a0 public Node bottomLeft;\u00a0 \u00a0 public Node bottomRight;}We can construct a Quad-Tree from a two-dimensional area using the following steps:If the current grid has the same value (i.e all 1's or all 0's)\u00a0set isLeaf\u00a0True and set val to the value of the grid and set the four children to Null and stop.If the current grid has different values, set isLeaf to False and\u00a0set val to any value and divide the current grid into four sub-grids as shown in the photo.Recurse for each of the children with the proper sub-grid.If you want to know more about the Quad-Tree, you can refer to the\u00a0wiki.Quad-Tree\u00a0format:The input/output represents the serialized format of a Quad-Tree using level order traversal, where null signifies a path terminator where no node exists below.It is very similar to the serialization of the binary tree. The only difference is that the node is represented as a list [isLeaf, val].If the value of isLeaf or val is True we represent it as 1 in the list\u00a0[isLeaf, val] and if the value of isLeaf or val is False we represent it as 0.\u00a0": [
        "logical-or-of-two-binary-grids-represented-as-quad-trees",
        [],
        []
    ],
    "Given a n * n matrix grid of 0's and 1's only. We want to represent the grid with a Quad-Tree.Return the root of the Quad-Tree representing the grid.Notice that you can assign the value of a node to True or False when isLeaf is False, and both are accepted in the answer.A Quad-Tree is a tree data structure in which each internal node has exactly four children. Besides, each node has two attributes:val: True if the node represents a grid of 1's or False if the node represents a grid of 0's.\u00a0isLeaf: True if the node is leaf node on the tree or False if the node has the four children.class Node {    public boolean val;\u00a0 \u00a0 public boolean isLeaf;\u00a0 \u00a0 public Node topLeft;\u00a0 \u00a0 public Node topRight;\u00a0 \u00a0 public Node bottomLeft;\u00a0 \u00a0 public Node bottomRight;}We can construct a Quad-Tree from a two-dimensional area using the following steps:If the current grid has the same value (i.e all 1's or all 0's)\u00a0set isLeaf\u00a0True and set val to the value of the grid and set the four children to Null and stop.If the current grid has different values, set isLeaf to False and\u00a0set val to any value and divide the current grid into four sub-grids as shown in the photo.Recurse for each of the children with the proper sub-grid.If you want to know more about the Quad-Tree, you can refer to the\u00a0wiki.Quad-Tree\u00a0format:The output represents the serialized format of a Quad-Tree using level order traversal, where null signifies a path terminator where no node exists below.It is very similar to the serialization of the binary tree. The only difference is that the node is represented as a list [isLeaf, val].If the value of isLeaf or val is True we represent it as 1 in the list\u00a0[isLeaf, val] and if the value of isLeaf or val is False we represent it as 0.\u00a0": [
        "construct-quad-tree",
        [],
        []
    ],
    "N couples sit in 2N seats arranged in a row and want to hold hands.  We want to know the minimum number of swaps so that every couple is sitting side by side.  A swap consists of choosing any two people, then they stand up and switch seats. The people and seats are represented by an integer from 0 to 2N-1, the couples are numbered in order, the first couple being (0, 1), the second couple being (2, 3), and so on with the last couple being (2N-2, 2N-1).The couples' initial seating is given by row[i] being the value of the person who is initially sitting in the i-th seat.": [
        "couples-holding-hands",
        [
            "k-similar-strings",
            "missing-number",
            "first-missing-positive"
        ],
        [
            "Greedy",
            "Union Find",
            "Graph"
        ]
    ],
    "In a 2D grid from (0, 0) to (N-1, N-1), every cell contains a 1, except those cells in the given list mines which are 0.  What is the largest axis-aligned plus sign of 1s contained in the grid?  Return the order of the plus sign.  If there is none, return 0.An \"axis-aligned plus sign of 1s of order k\" has some center grid[x][y] = 1 along with 4 arms of length k-1 going up, down, left, and right, and made of 1s.  This is demonstrated in the diagrams below.  ": [
        "largest-plus-sign",
        [
            "maximal-square"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "A string S of lowercase English letters is given. We want to partition this string into as many parts as possible so that each letter appears in at most one part, and return a list of integers representing the size of these parts.\u00a0": [
        "partition-labels",
        [
            "merge-intervals"
        ],
        [
            "Two Pointers",
            "Greedy"
        ]
    ],
    "Given two integers L and R, find the count of numbers in the range [L, R] (inclusive) having a prime number of set bits in their binary representation.(Recall that the number of set bits an integer has is the number of 1s present when written in binary.  ": [
        "prime-number-of-set-bits-in-binary-representation",
        [
            "number-of-1-bits"
        ],
        [
            "Bit Manipulation"
        ]
    ],
    "You are given a doubly linked list which in addition to the next and previous pointers, it could have a child pointer, which may or may not point to a separate doubly linked list. These child lists may have one or more children of their own, and so on, to produce a multilevel data structure, as shown in the example below.Flatten the list so that all the nodes appear in a single-level, doubly linked list. You are given the head of the first level of the list.\u00a0": [
        "flatten-a-multilevel-doubly-linked-list",
        [
            "flatten-binary-tree-to-linked-list"
        ],
        [
            "Linked List",
            "Depth-first Search"
        ]
    ],
    "Given an n-ary tree, return the level order traversal of its nodes' values.Nary-Tree input serialization\u00a0is represented in their level order traversal, each group of children is separated by the null value (See examples).\u00a0": [
        "n-ary-tree-level-order-traversal",
        [
            "n-ary-tree-postorder-traversal",
            "n-ary-tree-preorder-traversal",
            "binary-tree-level-order-traversal"
        ],
        [
            "Tree",
            "Breadth-first Search"
        ]
    ],
    "Special binary strings are binary strings with the following two properties:The number of 0's is equal to the number of 1's.Every prefix of the binary string has at least as many 1's as 0's.Given a special string S, a move consists of choosing two consecutive, non-empty, special substrings of S, and swapping them.  (Two strings are consecutive if the last character of the first string is exactly one index before the first character of the second string.)At the end of any number of moves, what is the lexicographically largest resulting string possible?": [
        "special-binary-string",
        [
            "valid-parenthesis-string"
        ],
        [
            "String",
            "Recursion"
        ]
    ],
    "An integer interval [a, b] (for integers a < b) is a set of all consecutive integers from a to b, including a and b.Find the minimum size of a set S such that for every integer interval A in intervals, the intersection of S with A has size at least 2.": [
        "set-intersection-size-at-least-two",
        [],
        [
            "Greedy"
        ]
    ],
    "We are stacking blocks to form a pyramid. Each block has a color which is a one letter string.We are allowed to place any color block C on top of two adjacent blocks of colors A and B, if and only if ABC is an allowed triple.We start with a bottom row of bottom, represented as a single string. We also start with a list of allowed triples allowed. Each allowed triple is represented as a string of length 3.Return true if we can build the pyramid all the way to the top, otherwise false.": [
        "pyramid-transition-matrix",
        [],
        [
            "Bit Manipulation",
            "Depth-first Search"
        ]
    ],
    "You are standing at position 0 on an infinite number line.  There is a goal at position target.On each move, you can either go left or right.  During the n-th move (starting from 1), you take n steps.Return the minimum number of steps required to reach the destination.": [
        "reach-a-number",
        [],
        [
            "Math"
        ]
    ],
    "There is a box protected by a password. The password is a sequence of\u00a0n digits\u00a0where each digit can be one of the first k digits 0, 1, ..., k-1.While entering a password,\u00a0the last n digits entered will automatically be matched against the correct password.": [
        "cracking-the-safe",
        [],
        [
            "Math",
            "Depth-first Search"
        ]
    ],
    "You have a lock in front of you with 4 circular wheels. Each wheel has 10 slots: '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'. The wheels can rotate freely and wrap around: for example we can turn '9' to be '0', or '0' to be '9'. Each move consists of turning one wheel one slot.The lock initially starts at '0000', a string representing the state of the 4 wheels.You are given a list of deadends dead ends, meaning if the lock displays any of these codes, the wheels of the lock will stop turning and you will be unable to open it.Given a target representing the value of the wheels that will unlock the lock, return the minimum total number of turns required to open the lock, or -1 if it is impossible.\u00a0": [
        "open-the-lock",
        [],
        [
            "Breadth-first Search"
        ]
    ],
    "A virus is spreading rapidly, and your task is to quarantine the infected area by installing walls.The world is modeled as a 2-D array of cells, where 0 represents uninfected cells, and 1 represents cells contaminated with the virus.  A wall (and only one wall) can be installed between any two 4-directionally adjacent cells, on the shared boundary.Every night, the virus spreads to all neighboring cells in all four directions unless blocked by a wall.Resources are limited. Each day, you can install walls around only one region -- the affected area (continuous block of infected cells) that threatens the most uninfected cells the following night. There will never be a tie.Can you save the day? If so, what is the number of walls required? If not, and the world becomes fully infected, return the number of walls used.": [
        "contain-virus",
        [],
        [
            "Depth-first Search"
        ]
    ],
    "Find the minimum length word from a given dictionary words, which has all the letters from the string licensePlate.  Such a word is said to complete the given string licensePlateHere, for letters we ignore case.  ": [
        "shortest-completing-word",
        [],
        [
            "Hash Table"
        ]
    ],
    "In a given integer array nums, there is always exactly one largest element.Find whether the largest element in the array is at least twice as much as every other number in the array.If it is, return the index of the largest element, otherwise return -1.": [
        "largest-number-at-least-twice-of-others",
        [],
        [
            "Array"
        ]
    ],
    "On a staircase, the i-th step has some non-negative cost cost[i] assigned (0 indexed).Once you pay the cost, you can either climb one or two steps. You need to find minimum cost to reach the top of the floor, and you can either start from the step with index 0, or the step with index 1.": [
        "min-cost-climbing-stairs",
        [
            "climbing-stairs"
        ],
        [
            "Array",
            "Dynamic Programming"
        ]
    ],
    "Design a special dictionary which has some words and allows you to search the words in it by a prefix and a suffix.Implement the WordFilter class:WordFilter(string[] words) Initializes the object with the words in the dictionary.f(string prefix, string suffix) Returns the index of the word in the dictionary which has the prefix prefix and the suffix suffix. If there is\u00a0more than one valid index, return the largest of them. If there is no such word in the dictionary, return -1.\u00a0": [
        "prefix-and-suffix-search",
        [
            "design-add-and-search-words-data-structure"
        ],
        [
            "Trie"
        ]
    ],
    "Given a list of sorted characters letters containing only lowercase letters, and given a target letter target, find the smallest element in the list that is larger than the given target.Letters also wrap around.  ": [
        "find-smallest-letter-greater-than-target",
        [],
        [
            "Binary Search"
        ]
    ],
    "There are N network nodes, labelled 1 to N.Given times, a list of travel times as directed edges times[i] = (u, v, w), where u is the source node, v is the target node, and w is the time it takes for a signal to travel from source to target.Now, we send a signal from a certain node K. How long will it take for all nodes to receive the signal? If it is impossible, return -1.\u00a0": [
        "network-delay-time",
        [],
        [
            "Heap",
            "Depth-first Search",
            "Breadth-first Search",
            "Graph"
        ]
    ],
    "Implement function ToLowerCase() that has a string parameter str, and returns the same string in lowercase.\u00a0": [
        "to-lower-case",
        [],
        [
            "String"
        ]
    ],
    "In a N x N grid representing a field of cherries, each cell is one of three possible integers.\u00a00 means the cell is empty, so you can pass through;1 means the cell contains a cherry, that you can pick up and pass through;-1 means the cell contains a thorn that blocks your way.\u00a0Your task is to collect maximum number of cherries possible by following the rules below:\u00a0Starting at the position (0, 0) and reaching (N-1, N-1) by moving right or down through valid path cells (cells with value 0 or 1);After reaching (N-1, N-1), returning to (0, 0) by moving left or up through valid path cells;When passing through a path cell containing a cherry, you pick it up and the cell becomes an empty cell (0);If there is no valid path between (0, 0) and (N-1, N-1), then no cherries can be collected.\u00a0\u00a0": [
        "cherry-pickup",
        [
            "dungeon-game",
            "minimum-path-sum"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Given an array nums of integers, you can perform operations on the array.In each operation, you pick any nums[i] and delete it to earn nums[i] points. After, you must delete every element equal to nums[i] - 1 or nums[i] + 1.You start with 0 points. Return the maximum number of points you can earn by applying such operations.": [
        "delete-and-earn",
        [
            "house-robber"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Given a list of daily temperatures T, return a list such that, for each day in the input, tells you how many days you would have to wait until a warmer temperature.  If there is no future day for which this is possible, put 0 instead.": [
        "daily-temperatures",
        [
            "next-greater-element-i"
        ],
        [
            "Hash Table",
            "Stack"
        ]
    ],
    "Given a non-negative integer N, find the largest number that is less than or equal to N with monotone increasing digits.(Recall that an integer has monotone increasing digits if and only if each pair of adjacent digits x and y satisfy x <= y.)": [
        "monotone-increasing-digits",
        [
            "remove-k-digits"
        ],
        [
            "Greedy"
        ]
    ],
    "You are given a string expression representing a Lisp-like expression to return the integer value of.The syntax for these expressions is given as follows.An expression is either an integer, a let-expression, an add-expression, a mult-expression, or an assigned variable.  Expressions always evaluate to a single integer.(An integer could be positive or negative.)A let-expression takes the form (let v1 e1 v2 e2 ... vn en expr), where let is always the string \"let\", then there are 1 or more pairs of alternating variables and expressions, meaning that the first variable v1 is assigned the value of the expression e1, the second variable v2 is assigned the value of the expression e2, and so on sequentially; and then the value of this let-expression is the value of the expression expr.An add-expression takes the form (add e1 e2) where add is always the string \"add\", there are always two expressions e1, e2, and this expression evaluates to the addition of the evaluation of e1 and the evaluation of e2.A mult-expression takes the form (mult e1 e2) where mult is always the string \"mult\", there are always two expressions e1, e2, and this expression evaluates to the multiplication of the evaluation of e1 and the evaluation of e2.For the purposes of this question, we will use a smaller subset of variable names.  A variable starts with a lowercase letter, then zero or more lowercase letters or digits.  Additionally for your convenience, the names \"add\", \"let\", or \"mult\" are protected and will never be used as variable names.Finally, there is the concept of scope.  When an expression of a variable name is evaluated, within the context of that evaluation, the innermost scope (in terms of parentheses) is checked first for the value of that variable, and then outer scopes are checked sequentially.  It is guaranteed that every expression is legal.  Please see the examples for more details on scope.Evaluation ": [
        "parse-lisp-expression",
        [
            "basic-calculator-iv",
            "number-of-atoms",
            "ternary-expression-parser"
        ],
        [
            "String"
        ]
    ],
    "We are given an array asteroids of integers representing asteroids in a row.For each asteroid, the absolute value represents its size, and the sign represents its direction (positive meaning right, negative meaning left).  Each asteroid moves at the same speed.Find out the state of the asteroids after all collisions.  If two asteroids meet, the smaller one will explode.  If both are the same size, both will explode.  Two asteroids moving in the same direction will never meet.": [
        "asteroid-collision",
        [
            "can-place-flowers"
        ],
        [
            "Stack"
        ]
    ],
    "An image is represented by a 2-D array of integers, each integer representing the pixel value of the image (from 0 to 65535).Given a coordinate (sr, sc) representing the starting pixel (row and column) of the flood fill, and a pixel value newColor, \"flood fill\" the image.To perform a \"flood fill\", consider the starting pixel, plus any pixels connected 4-directionally to the starting pixel of the same color as the starting pixel, plus any pixels connected 4-directionally to those pixels (also with the same color as the starting pixel), and so on.  Replace the color of all of the aforementioned pixels with the newColor.At the end, return the modified image.": [
        "flood-fill",
        [
            "island-perimeter"
        ],
        [
            "Depth-first Search"
        ]
    ],
    "Implement a MyCalendarThree class to store your events. A new event can always be added.Your class will have one method, book(int start, int end). ": [
        "my-calendar-iii",
        [
            "my-calendar-ii",
            "my-calendar-i"
        ],
        [
            "Segment Tree",
            "Ordered Map"
        ]
    ],
    "Implement a MyCalendarTwo class to store your events. A new event can be added if adding the event will not cause a triple booking.Your class will have one method, book(int start, int end). ": [
        "my-calendar-ii",
        [
            "my-calendar-iii",
            "my-calendar-i"
        ],
        [
            "Ordered Map"
        ]
    ],
    "Given a string S, find the number of different non-empty palindromic subsequences in S, and return that number modulo 10^9 + 7.A subsequence of a string S is obtained by deleting 0 or more characters from S.A sequence is palindromic if it is equal to the sequence reversed.Two sequences A_1, A_2, ... and B_1, B_2, ... are different if there is some i for which A_i != B_i.": [
        "count-different-palindromic-subsequences",
        [
            "longest-palindromic-subsequence"
        ],
        [
            "String",
            "Dynamic Programming"
        ]
    ],
    "Implement a MyCalendar class to store your events. A new event can be added if adding the event will not cause a double booking.Your class will have the method, book(int start, int end). ": [
        "my-calendar-i",
        [
            "my-calendar-iii",
            "my-calendar-ii"
        ],
        [
            "Array"
        ]
    ],
    "A self-dividing number is a number that is divisible by every digit it contains.": [
        "self-dividing-numbers",
        [
            "perfect-number"
        ],
        [
            "Math"
        ]
    ],
    "Given a chemical formula (given as a string), return the count of each atom.An atomic element always starts with an uppercase character, then zero or more lowercase letters, representing the name.1 or more digits representing the count of that element may follow if the count is greater than 1.  If the count is 1, no digits will follow.  ": [
        "number-of-atoms",
        [
            "parse-lisp-expression",
            "encode-string-with-shortest-length",
            "decode-string"
        ],
        [
            "Hash Table",
            "Stack",
            "Recursion"
        ]
    ],
    "Given a (singly) linked list with head node root, write a function to split the linked list into k consecutive linked list \"parts\".The length of each part should be as equal as possible: no two parts should have a size differing by more than 1.  This may lead to some parts being null.The parts should be in order of occurrence in the input list, and parts occurring earlier should always have a size greater than or equal parts occurring later.Return a List of ListNode's representing the linked list parts that are formed.": [
        "split-linked-list-in-parts",
        [
            "odd-even-linked-list",
            "rotate-list"
        ],
        [
            "Linked List"
        ]
    ],
    "Given an array of integers nums, write a method that returns the \"pivot\" index of this array.We define the pivot index as the index where the sum of all the numbers to the left of the index is equal to the sum of all the numbers to the right of the index.If no such index exists, we should return -1. If there are multiple pivot indexes, you should return the left-most pivot index.\u00a0": [
        "find-pivot-index",
        [
            "subarray-sum-equals-k"
        ],
        [
            "Array"
        ]
    ],
    "Given a C++ program, remove comments from it. The program source is an array where source[i] is the i-th line of the source code.  This represents the result of splitting the original source code string by the newline character \\n.In C++, there are two types of comments, line comments, and block comments.The string // denotes a line comment, which represents that it and rest of the characters to the right of it in the same line should be ignored.The string /* denotes a block comment, which represents that all characters until the next (non-overlapping) occurrence of */ should be ignored.  (Here, occurrences happen in reading order: line by line from left to right.)  To be clear, the string /*/ does not yet end the block comment, as the ending would be overlapping the beginning.The first effective comment takes precedence over others: if the string // occurs in a block comment, it is ignored. Similarly, if the string /* occurs in a line or block comment, it is also ignored.If a certain line of code is empty after removing comments, you must not output that line: each string in the answer list will be non-empty.There will be no control characters, single quote, or double quote characters.  ": [
        "remove-comments",
        [
            "ternary-expression-parser",
            "mini-parser"
        ],
        [
            "String"
        ]
    ],
    "Given a list accounts, each element accounts[i] is a list of strings, where the first element accounts[i][0] is a name, and the rest of the elements are emails representing emails of the account.Now, we would like to merge these accounts.  Two accounts definitely belong to the same person if there is some email that is common to both accounts.  ": [
        "accounts-merge",
        [
            "sentence-similarity-ii",
            "sentence-similarity",
            "redundant-connection"
        ],
        [
            "Depth-first Search",
            "Union Find"
        ]
    ],
    "Given a list of strings words representing an English Dictionary, find the longest word in words that can be built one character at a time by other words in words.  If there is more than one possible answer, return the longest word with the smallest lexicographical order.  If there is no answer, return the empty string.": [
        "longest-word-in-dictionary",
        [
            "implement-magic-dictionary",
            "longest-word-in-dictionary-through-deleting"
        ],
        [
            "Hash Table",
            "Trie"
        ]
    ],
    "Given an integer array, return the k-th smallest distance among all the pairs. The distance of a pair (A, B) is defined as the absolute difference between A and B. ": [
        "find-k-th-smallest-pair-distance",
        [
            "k-th-smallest-prime-fraction",
            "kth-smallest-number-in-multiplication-table",
            "find-k-closest-elements",
            "kth-smallest-element-in-a-sorted-matrix",
            "find-k-pairs-with-smallest-sums"
        ],
        [
            "Array",
            "Binary Search",
            "Heap"
        ]
    ],
    "Given two integer arrays A and B, return the maximum length of an subarray that appears in both arrays.": [
        "maximum-length-of-repeated-subarray",
        [
            "minimum-size-subarray-sum"
        ],
        [
            "Array",
            "Hash Table",
            "Binary Search",
            "Dynamic Programming"
        ]
    ],
    "We have two special characters. The first character can be represented by one bit 0. The second character can be represented by two bits (10 or 11).  Now given a string represented by several bits. Return whether the last character must be a one-bit character or not. The given string will always end with a zero.": [
        "1-bit-and-2-bit-characters",
        [
            "gray-code"
        ],
        [
            "Array"
        ]
    ],
    "A Range Module is a module that tracks ranges of numbers. Your task is to design and implement the following interfaces in an efficient manner.addRange(int left, int right) Adds the half-open interval [left, right), tracking every real number in that interval.  Adding an interval that partially overlaps with currently tracked numbers should add any numbers in the interval [left, right) that are not already tracked.queryRange(int left, int right) Returns true if and only if every real number in the interval [left, right) is currently being tracked.removeRange(int left, int right) Stops tracking every real number currently being tracked in the interval [left, right).": [
        "range-module",
        [
            "data-stream-as-disjoint-intervals",
            "insert-interval",
            "merge-intervals"
        ],
        [
            "Segment Tree",
            "Ordered Map"
        ]
    ],
    "Your are given an array of integers prices, for which the i-th element is the price of a given stock on day i; and a non-negative integer fee representing a transaction fee.You may complete as many transactions as you like, but you need to pay the transaction fee for each transaction.  You may not buy more than 1 share of a stock at a time (ie. you must sell the stock share before you buy again.)Return the maximum profit you can make.": [
        "best-time-to-buy-and-sell-stock-with-transaction-fee",
        [
            "best-time-to-buy-and-sell-stock-ii"
        ],
        [
            "Array",
            "Dynamic Programming",
            "Greedy"
        ]
    ],
    "Your are given an array of positive integers nums.Count and print the number of (contiguous) subarrays where the product of all the elements in the subarray is less than k.": [
        "subarray-product-less-than-k",
        [
            "two-sum-less-than-k",
            "subarray-sum-equals-k",
            "maximum-size-subarray-sum-equals-k",
            "maximum-product-subarray"
        ],
        [
            "Array",
            "Two Pointers"
        ]
    ],
    "Given two strings s1, s2, find the lowest ASCII sum of deleted characters to make two strings equal.": [
        "minimum-ascii-delete-sum-for-two-strings",
        [
            "delete-operation-for-two-strings",
            "longest-increasing-subsequence",
            "edit-distance"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "On an infinite number line (x-axis), we drop given squares in the order they are given.The i-th square dropped (positions[i] = (left, side_length)) is a square with the left-most point being positions[i][0] and sidelength positions[i][1].The square is dropped with the bottom edge parallel to the number line, and from a higher height than all currently landed squares. We wait for each square to stick before dropping the next.The squares are infinitely sticky on their bottom edge, and will remain fixed to any positive length surface they touch (either the number line or another square). Squares dropped adjacent to each other will not stick together prematurely.\u00a0Return a list ans of heights. Each height ans[i] represents the current highest height of any square we have dropped, after dropping squares represented by positions[0], positions[1], ..., positions[i].": [
        "falling-squares",
        [
            "the-skyline-problem"
        ],
        [
            "Segment Tree",
            "Ordered Map"
        ]
    ],
    "Given an array of integers nums and a positive integer k, find whether it's possible to divide this array into k non-empty subsets whose sums are all equal.\u00a0": [
        "partition-to-k-equal-sum-subsets",
        [
            "partition-equal-subset-sum"
        ],
        [
            "Dynamic Programming",
            "Recursion"
        ]
    ],
    "Given a non-empty array of non-negative integers nums, the degree of this array is defined as the maximum frequency of any one of its elements.Your task is to find the smallest possible length of a (contiguous) subarray of nums, that has the same degree as nums.\u00a0": [
        "degree-of-an-array",
        [
            "maximum-subarray"
        ],
        [
            "Array"
        ]
    ],
    "Give a string s, count the number of non-empty (contiguous) substrings that have the same number of 0's and 1's, and all the 0's and all the 1's in these substrings are grouped consecutively. Substrings that occur multiple times are counted the number of times they occur.": [
        "count-binary-substrings",
        [
            "encode-and-decode-strings"
        ],
        [
            "String"
        ]
    ],
    "Given a non-empty 2D array grid of 0's and 1's, an island is a group of 1's (representing land) connected 4-directionally (horizontal or vertical.) ": [
        "max-area-of-island",
        [
            "island-perimeter",
            "number-of-islands"
        ],
        [
            "Array",
            "Depth-first Search"
        ]
    ],
    "Given a positive integer, check whether it has alternating bits: namely, if two adjacent bits will always have different values.": [
        "binary-number-with-alternating-bits",
        [
            "number-of-1-bits"
        ],
        [
            "Bit Manipulation"
        ]
    ],
    "Given a non-empty list of words, return the k most frequent elements.Your answer should be sorted by frequency from highest to lowest. If two words have the same frequency, then the word with the lower alphabetical order comes first.": [
        "top-k-frequent-words",
        [
            "k-closest-points-to-origin",
            "top-k-frequent-elements"
        ],
        [
            "Hash Table",
            "Heap",
            "Trie"
        ]
    ],
    "We are given N different types of stickers.  Each sticker has a lowercase English word on it.You would like to spell out the given target string by cutting individual letters from your collection of stickers and rearranging them.You can use each sticker more than once if you want, and you have infinite quantities of each sticker.What is the minimum number of stickers that you need to spell out the target?  If the task is impossible, return -1.": [
        "stickers-to-spell-word",
        [
            "ransom-note"
        ],
        [
            "Dynamic Programming",
            "Backtracking"
        ]
    ],
    "You are given a data structure of employee information, which includes the employee's unique id, their\u00a0importance value and their\u00a0direct subordinates' id.": [
        "employee-importance",
        [
            "nested-list-weight-sum"
        ],
        [
            "Hash Table",
            "Depth-first Search",
            "Breadth-first Search"
        ]
    ],
    "In a given array nums of positive integers, find three non-overlapping subarrays with maximum sum.Each subarray will be of size k, and we want to maximize the sum of all 3*k entries.Return the result as a list of indices representing the starting position of each interval (0-indexed). If there are multiple answers, return the lexicographically smallest one.": [
        "maximum-sum-of-3-non-overlapping-subarrays",
        [
            "best-time-to-buy-and-sell-stock-iii"
        ],
        [
            "Array",
            "Dynamic Programming"
        ]
    ],
    "On an NxN chessboard, a knight starts at the r-th row and c-th column and attempts to make exactly K moves. The rows and columns are 0 indexed, so the top-left square is (0, 0), and the bottom-right square is (N-1, N-1).A chess knight has 8 possible moves it can make, as illustrated below. Each move is two squares in a cardinal direction, then one square in an orthogonal direction.\u00a0\u00a0Each time the knight is to move, it chooses one of eight possible moves uniformly at random (even if the piece would go off the chessboard) and moves there.The knight continues moving until it has made exactly K moves or has moved off the chessboard. Return the probability that the knight remains on the board after it has stopped moving.\u00a0": [
        "knight-probability-in-chessboard",
        [
            "out-of-boundary-paths"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Given a binary tree, find the length of the longest path where each node in the path has the same value. This path may or may not pass through the root.The length of path between two nodes is represented by the number of edges between them.\u00a0": [
        "longest-univalue-path",
        [
            "path-sum-iii",
            "count-univalue-subtrees",
            "binary-tree-maximum-path-sum"
        ],
        [
            "Tree",
            "Recursion"
        ]
    ],
    "Given two strings\u00a0a and b, return the minimum number of times you should repeat string\u00a0a\u00a0so that string\u00a0b\u00a0is a substring of it. If it is\u00a0impossible for\u00a0b\u200b\u200b\u200b\u200b\u200b\u200b to be a substring of\u00a0a after repeating it, return\u00a0-1.Notice:\u00a0string\u00a0\"abc\"\u00a0repeated 0 times is\u00a0\"\",\u00a0 repeated 1 time is\u00a0\"abc\"\u00a0and repeated 2 times is\u00a0\"abcabc\".\u00a0": [
        "repeated-string-match",
        [
            "repeated-substring-pattern"
        ],
        [
            "String"
        ]
    ],
    "In this problem, a rooted tree is a directed graph such that, there is exactly one node (the root) for which all other nodes are descendants of this node, plus every node has exactly one parent, except for the root node which has no parents.The given input is a directed graph that started as a rooted tree with N nodes (with distinct values 1, 2, ..., N), with one additional directed edge added.  The added edge has two different vertices chosen from 1 to N, and was not an edge that already existed.The resulting graph is given as a 2D-array of edges.  Each element of edges is a pair [u, v] that represents a directed edge connecting nodes u and v, where u is a parent of child v.Return an edge that can be removed so that the resulting graph is a rooted tree of N nodes.  If there are multiple answers, return the answer that occurs last in the given 2D-array.": [
        "redundant-connection-ii",
        [
            "redundant-connection"
        ],
        [
            "Tree",
            "Depth-first Search",
            "Union Find",
            "Graph"
        ]
    ],
    "In this problem, a tree is an undirected graph that is connected and has no cycles.The given input is a graph that started as a tree with N nodes (with distinct values 1, 2, ..., N), with one additional edge added.  The added edge has two different vertices chosen from 1 to N, and was not an edge that already existed.The resulting graph is given as a 2D-array of edges.  Each element of edges is a pair [u, v] with u < v, that represents an undirected edge connecting nodes u and v.Return an edge that can be removed so that the resulting graph is a tree of N nodes.  If there are multiple answers, return the answer that occurs last in the given 2D-array.  The answer edge [u, v] should be in the same format, with u < v.": [
        "redundant-connection",
        [
            "accounts-merge",
            "redundant-connection-ii"
        ],
        [
            "Tree",
            "Union Find",
            "Graph"
        ]
    ],
    "You're now a baseball game point recorder.Given a list of strings, each string can be one of the 4 following types:Integer (one round's score): Directly represents the number of points you get in this round.\"+\" (one round's score): Represents that the points you get in this round are the sum of the last two valid round's points.\"D\" (one round's score): Represents that the points you get in this round are the doubled data of the last valid round's points.\"C\" (an operation, which isn't a round's score): Represents the last valid round's points you get were invalid and should be removed.Each round's operation is permanent and could have an impact on the round before and the round after.You need to return the sum of the points you could get in all the rounds.": [
        "baseball-game",
        [],
        [
            "Stack"
        ]
    ],
    "Given a non-empty string s, you may delete at most one character.  Judge whether you can make it a palindrome.": [
        "valid-palindrome-ii",
        [
            "valid-palindrome"
        ],
        [
            "String"
        ]
    ],
    "You have 4 cards each containing a number from 1 to 9.  You need to judge whether they could operated through *, /, +, -, (, ) to get the value of 24.": [
        "24-game",
        [],
        [
            "Depth-first Search"
        ]
    ],
    "Given a string containing only three types of characters: '(', ')' and '*', write a function to check whether this string is valid. We define the validity of a string by these rules:Any left parenthesis '(' must have a corresponding right parenthesis ')'.Any right parenthesis ')' must have a corresponding left parenthesis '('.Left parenthesis '(' must go before the corresponding right parenthesis ')'.'*' could be treated as a single right parenthesis ')' or a single left parenthesis '(' or an empty string.An empty string is also valid.": [
        "valid-parenthesis-string",
        [
            "special-binary-string"
        ],
        [
            "String"
        ]
    ],
    "Implement a MapSum class with insert, and sum methods.For the method insert, you'll be given a pair of (string, integer). The string represents the key and the integer represents the value. If the key already existed, then the original key-value pair will be overridden to the new one.For the method sum, you'll be given a string representing the prefix, and you need to return the sum of all the pairs' value whose key starts with the prefix.": [
        "map-sum-pairs",
        [],
        [
            "Trie"
        ]
    ],
    "Design a data structure that is initialized with a list of different words. Provided a string, you should determine if you can change exactly one character in this string to match any word in the data structure.Implement the\u00a0MagicDictionary\u00a0class:MagicDictionary()\u00a0Initializes the object.void buildDict(String[]\u00a0dictionary)\u00a0Sets the data structure\u00a0with an array of distinct strings dictionary.bool search(String searchWord) Returns true if you can change exactly one character in searchWord to match any string in the data structure, otherwise returns false.\u00a0": [
        "implement-magic-dictionary",
        [
            "longest-word-in-dictionary",
            "implement-trie-prefix-tree"
        ],
        [
            "Hash Table",
            "Trie"
        ]
    ],
    "You are asked to cut off trees in a forest for a golf event. The forest is represented as a non-negative 2D map, in this map:0 represents the obstacle can't be reached.1 represents the ground can be walked through.The place with number bigger than 1 represents a tree can be walked through, and this positive number represents the tree's height.In one step you can walk in any of the four directions top, bottom, left and right\u00a0also when standing in a point which is a tree you can decide whether or not to cut off the tree.You are asked to cut off all the trees in this forest in the order of tree's height - always cut off the tree with lowest height first. And after cutting, the original place has the tree will become a grass (value 1).You will start from the point (0, 0) and you should output the minimum steps you need to walk to cut off all the trees. If you can't cut off all the trees, output -1 in that situation.You are guaranteed that no two trees have the same height and there is at least one tree needs to be cut off.": [
        "cut-off-trees-for-golf-event",
        [],
        [
            "Breadth-first Search"
        ]
    ],
    "Given an unsorted array of integers, find the length of longest continuous increasing subsequence (subarray).": [
        "longest-continuous-increasing-subsequence",
        [
            "minimum-window-subsequence",
            "number-of-longest-increasing-subsequence"
        ],
        [
            "Array"
        ]
    ],
    "Given an unsorted array of integers, find the number of longest increasing subsequence.": [
        "number-of-longest-increasing-subsequence",
        [
            "longest-continuous-increasing-subsequence",
            "longest-increasing-subsequence"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "There is a room with n lights which are turned on initially and 4 buttons on the wall. After performing exactly m unknown operations towards buttons, you need to return how many different kinds of status of the n lights could be.": [
        "bulb-switcher-ii",
        [
            "bulb-switcher-iii",
            "bulb-switcher"
        ],
        [
            "Math"
        ]
    ],
    "Given a non-empty special binary tree consisting of nodes with the non-negative value, where each node in this tree has exactly two or zero sub-node. If the node has two sub-nodes, then this node's value is the smaller value among its two sub-nodes. ": [
        "second-minimum-node-in-a-binary-tree",
        [
            "kth-smallest-element-in-a-bst"
        ],
        [
            "Tree"
        ]
    ],
    "Given a non-negative integer, you could swap two digits at most once to get the maximum valued number. Return the maximum valued number you could get.": [
        "maximum-swap",
        [
            "create-maximum-number"
        ],
        [
            "Array",
            "Math"
        ]
    ],
    "Given a binary search tree and the lowest and highest boundaries as L and R, trim the tree so that all its elements lies in [L, R] (R >= L). You might need to change the root of the tree, so the result should return the new root of the trimmed binary search tree.": [
        "trim-a-binary-search-tree",
        [],
        [
            "Tree"
        ]
    ],
    "Nearly every one have used the Multiplication Table. But could you find out the k-th smallest number quickly from the multiplication table?Given the height m and the length n of a m * n Multiplication Table, and a positive integer k, you need to return the k-th smallest number in this table.": [
        "kth-smallest-number-in-multiplication-table",
        [
            "k-th-smallest-prime-fraction",
            "find-k-th-smallest-pair-distance",
            "kth-smallest-element-in-a-sorted-matrix"
        ],
        [
            "Binary Search"
        ]
    ],
    "Given two integers n and k, you need to construct a list which contains n different positive integers ranging from 1 to n and obeys the following requirement: ": [
        "beautiful-arrangement-ii",
        [
            "beautiful-arrangement"
        ],
        [
            "Array"
        ]
    ],
    "Given an array nums with n integers, your task is to check if it could become non-decreasing by modifying at most 1 element.We define an array is non-decreasing if nums[i] <= nums[i + 1] holds for every i\u00a0(0-based) such that (0\u00a0<= i <= n - 2).\u00a0": [
        "non-decreasing-array",
        [],
        [
            "Array"
        ]
    ],
    "There is a strange printer with the following two special requirements:The printer can only print a sequence of the same character each time.At each turn, the printer can print new characters starting from and ending at any places, and will cover the original existing characters.Given a string consists of lower English letters only, your job is to count the minimum number of turns the printer needed in order to print it.": [
        "strange-printer",
        [
            "remove-boxes"
        ],
        [
            "Dynamic Programming",
            "Depth-first Search"
        ]
    ],
    "Given a binary tree, write a function to get the maximum width of the given tree. The maximum width of a tree is the maximum width among all levels.The width of one level is defined as the length between the end-nodes (the leftmost and right most non-null nodes in the level, where the null nodes between the end-nodes are also counted into the length calculation.It is guaranteed that the answer will in the range of 32-bit signed integer.": [
        "maximum-width-of-binary-tree",
        [],
        [
            "Tree"
        ]
    ],
    "Given a 2D integer matrix M representing the gray scale of an image, you need to design a smoother to make the gray scale of each cell becomes the average gray scale (rounding down) of all the 8 surrounding cells and itself.  If a cell has less than 8 surrounding cells, then use as many as you can.": [
        "image-smoother",
        [],
        [
            "Array"
        ]
    ],
    "Given an array nums\u00a0sorted in ascending order, return true if and only if you can split it into 1 or more subsequences such that each subsequence consists of consecutive integers\u00a0and has length at least 3.\u00a0": [
        "split-array-into-consecutive-subsequences",
        [
            "divide-array-in-sets-of-k-consecutive-numbers",
            "top-k-frequent-elements"
        ],
        [
            "Heap",
            "Greedy"
        ]
    ],
    "Given a sorted array arr, two integers k and x, find the k closest elements to x in the array. The result should also be sorted in ascending order. If there is a tie, the smaller elements are always preferred.\u00a0": [
        "find-k-closest-elements",
        [
            "find-k-th-smallest-pair-distance",
            "guess-number-higher-or-lower-ii",
            "guess-number-higher-or-lower"
        ],
        [
            "Binary Search"
        ]
    ],
    "There is a robot starting at position (0, 0), the origin, on a 2D plane. Given a sequence of its moves, judge if this robot ends up at (0, 0) after it completes its moves.The move sequence is represented by a string, and the character moves[i] represents its ith move. Valid moves are R (right), L (left), U (up), and D (down). If the robot returns to the origin after it finishes all of its moves, return true. Otherwise, return false.": [
        "robot-return-to-origin",
        [
            "friend-circles"
        ],
        [
            "String"
        ]
    ],
    "Print a binary tree in an m*n 2D string array following these rules: The row number m should be equal to the height of the given binary tree.The column number n should always be an odd number.The root node's value (in string format) should be put in the exactly middle of the first row it can be put. The column and the row where the root node belongs will separate the rest space into two parts (left-bottom part and right-bottom part). You should print the left subtree in the left-bottom part and print the right subtree in the right-bottom part. The left-bottom part and the right-bottom part should have the same size. Even if one subtree is none while the other is not, you don't need to print anything for the none subtree but still need to leave the space as large as that for the other subtree. However, if two subtrees are none, then you don't need to leave space for both of them. Each unused space should contain an empty string \"\".Print the subtrees following the same rules.": [
        "print-binary-tree",
        [],
        [
            "Tree"
        ]
    ],
    "Given an integer array with no duplicates. A maximum tree building on this array is defined as follow:The root is the maximum number in the array. The left subtree is the maximum tree constructed from left part subarray divided by the maximum number.The right subtree is the maximum tree constructed from right part subarray divided by the maximum number.Construct the maximum tree by the given array and output the root node of this tree.": [
        "maximum-binary-tree",
        [
            "maximum-binary-tree-ii"
        ],
        [
            "Tree"
        ]
    ],
    "Given a Binary Search Tree and a target number, return true if there exist two elements in the BST such that their sum is equal to the given target.": [
        "two-sum-iv-input-is-a-bst",
        [
            "two-sum-bsts",
            "two-sum-iii-data-structure-design",
            "two-sum-ii-input-array-is-sorted",
            "two-sum"
        ],
        [
            "Tree"
        ]
    ],
    "Given the root\u00a0of a binary tree, return all duplicate subtrees.For each kind of duplicate subtrees, you only need to return the root node of any one of them.Two trees are duplicate if they have the same structure with the same node values.\u00a0": [
        "find-duplicate-subtrees",
        [
            "construct-string-from-binary-tree",
            "serialize-and-deserialize-bst",
            "serialize-and-deserialize-binary-tree"
        ],
        [
            "Tree"
        ]
    ],
    "Initially on a notepad only one character 'A' is present. You can perform two operations on this notepad for each step:Copy All: You can copy all the characters present on the notepad (partial copy is not allowed).Paste: You can paste the characters which are copied last time.\u00a0Given a number n. You have to get exactly n 'A' on the notepad by performing the minimum number of steps permitted. Output the minimum number of steps to get n 'A'.": [
        "2-keys-keyboard",
        [
            "broken-calculator",
            "4-keys-keyboard"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "In the world of Dota2, there are two parties: the Radiant and the Dire.The Dota2 senate consists of senators coming from two parties. Now the senate wants to make a decision about a change in the Dota2 game. The voting for this change is a round-based procedure. In each round, each senator can exercise one of the two rights:Ban one senator's right:\tA senator can make another senator lose all his rights in this and all the following rounds.Announce the victory:\tIf this senator found the senators who still have rights to vote are all from the same party, he can announce the victory and make the decision about the change in the game.\u00a0Given a string representing each senator's party belonging. The character 'R' and 'D' represent the Radiant party and the Dire party respectively. Then if there are n senators, the size of the given string will be n.The round-based procedure starts from the first senator to the last senator in the given order. This procedure will last until the end of voting. All the senators who have lost their rights will be skipped during the procedure.": [
        "dota2-senate",
        [
            "teemo-attacking"
        ],
        [
            "Greedy"
        ]
    ],
    "In English, we have a concept called root, which can be followed by some other word\u00a0to form another longer word - let's call this word successor. ": [
        "replace-words",
        [
            "implement-trie-prefix-tree"
        ],
        [
            "Hash Table",
            "Trie"
        ]
    ],
    "Given a string, your task is to count how many palindromic substrings in this string.The substrings with different start indexes or end indexes are counted as different substrings even they consist of same characters.": [
        "palindromic-substrings",
        [
            "longest-palindromic-subsequence",
            "longest-palindromic-substring"
        ],
        [
            "String",
            "Dynamic Programming"
        ]
    ],
    "You are given n pairs of numbers. In every pair, the first number is always smaller than the second number.Now, we define a pair (c, d) can follow another pair (a, b) if and only if b < c. Chain of pairs can be formed in this fashion. Given a set of pairs, find the length longest chain which can be formed. You needn't use up all the given pairs. You can select pairs in any order.": [
        "maximum-length-of-pair-chain",
        [
            "increasing-subsequences",
            "longest-increasing-subsequence"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "The set S originally contains numbers from 1 to n. But unfortunately, due to the data error, one of the numbers in the set got duplicated to another number in the set, which results in repetition of one number and loss of another number. Given an array nums representing the data status of this set after the error. Your task is to firstly find the number occurs twice and then find the number that is missing. Return them in the form of an array.": [
        "set-mismatch",
        [
            "find-the-duplicate-number"
        ],
        [
            "Hash Table",
            "Math"
        ]
    ],
    "Given an array consisting of n integers, find the contiguous subarray of given length k that has the maximum average value. And you need to output the maximum average value.": [
        "maximum-average-subarray-i",
        [
            "maximum-average-subarray-ii"
        ],
        [
            "Array"
        ]
    ],
    "Solve a given equation and return the value of x in the form of string \"x=#value\". The equation contains only '+', '-' operation, the variable x and its coefficient.If there is no solution for the equation, return \"No solution\".If there are infinite solutions for the equation, return \"Infinite solutions\".If there is exactly one solution for the equation, we ensure that the value of x is an integer.": [
        "solve-the-equation",
        [
            "fraction-addition-and-subtraction"
        ],
        [
            "Math"
        ]
    ],
    "A message containing letters from A-Z is being encoded to numbers using the following mapping way:'A' -> 1'B' -> 2...'Z' -> 26Beyond that, now the encoded string can also contain the character '*', which can be treated as one of the numbers from 1 to 9.Given the encoded message containing digits and the character '*', return the total number of ways to decode it.Also, since the answer may be very large, you should return the output mod 109 + 7.": [
        "decode-ways-ii",
        [
            "decode-ways"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "In LeetCode Store, there are some kinds of items to sell. Each item has a price.However, there are some special offers, and a special offer consists of one or more different kinds of items with a sale price.You are given the each item's price, a set of special offers, and the number we need to buy for each item.The job is to output the lowest price you have to pay for exactly certain items as given, where you could make optimal use of the special offers.Each special offer is represented in the form of an array, the last number represents the price you need to pay for this special offer, other numbers represents how many specific items you could get if you buy this offer.You could use any of special offers as many times as you want.": [
        "shopping-offers",
        [],
        [
            "Dynamic Programming",
            "Depth-first Search"
        ]
    ],
    "Given a non-empty binary tree, return the average value of the nodes on each level in the form of an array.": [
        "average-of-levels-in-binary-tree",
        [
            "binary-tree-level-order-traversal-ii",
            "binary-tree-level-order-traversal"
        ],
        [
            "Tree"
        ]
    ],
    "On a single threaded CPU, we execute some functions.\u00a0 Each function has a unique id between 0 and N-1.We store logs in timestamp order that describe when a function is entered or exited.Each log is a string with this format: \"{function_id}:{\"start\" | \"end\"}:{timestamp}\".\u00a0 ": [
        "exclusive-time-of-functions",
        [],
        [
            "Stack"
        ]
    ],
    "Given a non-negative integer c, your task is to decide whether there're two integers a and b such that a2 + b2 = c.": [
        "sum-of-square-numbers",
        [
            "valid-perfect-square"
        ],
        [
            "Math"
        ]
    ],
    "You have k lists of sorted integers in non-decreasing\u00a0order. Find the smallest range that includes at least one number from each of the k lists.We define the range [a, b] is smaller than range [c, d] if b - a < d - c or a < c if b - a == d - c.\u00a0": [
        "smallest-range-covering-elements-from-k-lists",
        [
            "minimum-window-substring"
        ],
        [
            "Hash Table",
            "Two Pointers",
            "String"
        ]
    ],
    "There are n different online courses numbered from 1 to n. Each course has some duration(course length) t and closed on dth day. A course should be taken continuously for t days and must be finished before or on the dth day. You will start at the 1st day.Given n online courses represented by pairs (t,d), your task is to find the maximal number of courses that can be taken.": [
        "course-schedule-iii",
        [
            "course-schedule-ii",
            "course-schedule"
        ],
        [
            "Greedy"
        ]
    ],
    "Given two integers n and k, find how many different arrays consist of numbers from 1 to n such that there are exactly k inverse pairs.We define an inverse pair as following: For ith and jth element in the array, if i < j and a[i] > a[j] then it's an inverse pair; Otherwise, it's not.Since the answer may be very large, the answer should be modulo 109 + 7.": [
        "k-inverse-pairs-array",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Given an integer array, find three numbers whose product is maximum and output the maximum product.": [
        "maximum-product-of-three-numbers",
        [
            "maximum-product-subarray"
        ],
        [
            "Array",
            "Math"
        ]
    ],
    "Given the root of a binary tree, then value v and depth d, you need to add a row of nodes with value v at the given depth d. The root node is at depth 1. The adding rule is: given a positive integer depth d, for each NOT null tree nodes N in depth d-1, create two tree nodes with value v as N's left subtree root and right subtree root. And N's original left subtree should be the left subtree of the new left subtree root, its original right subtree should be the right subtree of the new right subtree root. If depth d is 1 that means there is no depth d-1 at all, then create a tree node with value v as the new root of the whole original tree, and the original tree is the new root's left subtree.": [
        "add-one-row-to-tree",
        [],
        [
            "Tree"
        ]
    ],
    "Given a characters array tasks, representing the tasks a CPU needs to do, where each letter represents a different task. Tasks could be done in any order. Each task is done in one unit of time. For each unit of time, the CPU could complete either one task or just be idle.However, there is a non-negative integer\u00a0n that represents the cooldown period between\u00a0two same tasks\u00a0(the same letter in the array), that is that there must be at least n units of time between any two same tasks.Return the least number of units of times that the CPU will take to finish all the given tasks.\u00a0": [
        "task-scheduler",
        [
            "reorganize-string",
            "rearrange-string-k-distance-apart"
        ],
        [
            "Array",
            "Greedy",
            "Queue"
        ]
    ],
    "Given two binary trees and imagine that when you put one of them to cover the other, some nodes of the two trees are overlapped while the others are not.You need to merge them into a new binary tree. The merge rule is that if two nodes overlap, then sum node values up as the new value of the merged node. Otherwise, the NOT null node will be used as the node of new tree.": [
        "merge-two-binary-trees",
        [],
        [
            "Tree"
        ]
    ],
    "Given an array consists of non-negative integers,  your task is to count the number of triplets chosen from the array that can make triangles if we take them as side lengths of a triangle.": [
        "valid-triangle-number",
        [
            "3sum-smaller"
        ],
        [
            "Array"
        ]
    ],
    "Given a list of directory info including directory path, and all the files with contents in this directory, you need to find out all the groups of duplicate files in the file system in terms of their paths.A group of duplicate files consists of at least two files that have exactly the same content.A single directory info string in the input list has the following format:\"root/d1/d2/.../dm f1.txt(f1_content) f2.txt(f2_content) ... fn.txt(fn_content)\"It means there are n files (f1.txt, f2.txt ... fn.txt with content f1_content, f2_content ... fn_content, respectively) in directory root/d1/d2/.../dm. ": [
        "find-duplicate-file-in-system",
        [],
        [
            "Hash Table",
            "String"
        ]
    ],
    "You need to construct a string consists of parenthesis and integers from a binary tree with the preorder traversing way.The null node needs to be represented by empty parenthesis pair \"()\". And you need to omit all the empty parenthesis pairs that don't affect the one-to-one mapping relationship between the string and the original binary tree.": [
        "construct-string-from-binary-tree",
        [
            "find-duplicate-subtrees",
            "construct-binary-tree-from-string"
        ],
        [
            "String",
            "Tree"
        ]
    ],
    "Given a positive integer n, find the number of non-negative integers less than or equal to n, whose binary representations do NOT contain consecutive ones.": [
        "non-negative-integers-without-consecutive-ones",
        [
            "ones-and-zeroes",
            "house-robber-ii",
            "house-robber"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Given an m * n matrix M initialized with all 0's and several update operations.Operations are represented by a 2D array, and each operation is represented by an array with two positive integers a and b, which means M[i][j] should be added by one for all 0 <= i < a and 0 <= j < b. You need to count and return the number of maximum integers in the matrix after performing all the operations.": [
        "range-addition-ii",
        [
            "range-addition"
        ],
        [
            "Math"
        ]
    ],
    "We define a harmounious array as an array where the difference between its maximum value and its minimum value is exactly 1.Now, given an integer array, you need to find the length of its longest harmonious subsequence among all its possible subsequences.": [
        "longest-harmonious-subsequence",
        [],
        [
            "Hash Table"
        ]
    ],
    "Given the coordinates of four points in 2D space, return whether the four points could construct a square.The coordinate (x,y) of a point is represented by an integer array with two integers.": [
        "valid-square",
        [],
        [
            "Math"
        ]
    ],
    "Given a string representing an expression of fraction addition and subtraction, you need to return the calculation result in string format. The final result should be irreducible fraction. If your final result is an integer, say 2, you need to change it to the format of fraction that has denominator 1. So in this case, 2 should be converted to 2/1.": [
        "fraction-addition-and-subtraction",
        [
            "solve-the-equation"
        ],
        [
            "Math"
        ]
    ],
    "Given a string representing a code snippet, you need to implement a tag validator to parse the code and return whether it is valid. A code snippet is valid if all the following rules hold:The code must be wrapped in a valid closed tag. Otherwise, the code is invalid.A closed tag (not necessarily valid) has exactly the following format : <TAG_NAME>TAG_CONTENT</TAG_NAME>. Among them, <TAG_NAME> is the start tag, and </TAG_NAME> is the end tag. The TAG_NAME in start and end tags should be the same. A closed tag is valid if and only if the TAG_NAME and TAG_CONTENT are valid.A valid TAG_NAME only contain upper-case letters, and has length in range [1,9]. Otherwise, the TAG_NAME is invalid.A valid TAG_CONTENT may contain other valid closed tags, cdata and any characters (see note1) EXCEPT unmatched <, unmatched start and end tag, and unmatched or closed tags with invalid TAG_NAME. Otherwise, the TAG_CONTENT is invalid.A start tag is unmatched if no end tag exists with the same TAG_NAME, and vice versa. However, you also need to consider the issue of unbalanced when tags are nested.A < is unmatched if you cannot find a subsequent >. And when you find a < or </, all the subsequent characters until the next > should be parsed as TAG_NAME  (not necessarily valid).The cdata has the following format : <![CDATA[CDATA_CONTENT]]>. The range of CDATA_CONTENT is defined as the characters between <![CDATA[ and the first subsequent ]]>. CDATA_CONTENT may contain any characters. The function of cdata is to forbid the validator to parse CDATA_CONTENT, so even it has some characters that can be parsed as tag (no matter valid or invalid), you should treat it as regular characters. Valid Code ": [
        "tag-validator",
        [
            "add-bold-tag-in-string"
        ],
        [
            "String",
            "Stack"
        ]
    ],
    "There are some trees, where each tree is represented by (x,y) coordinate in a two-dimensional garden. Your job is to fence the entire garden using the minimum length of rope as it is expensive. The garden is well fenced only if all the trees are enclosed. Your task is to help find the coordinates of trees which are exactly located on the fence perimeter.\u00a0": [
        "erect-the-fence",
        [],
        [
            "Geometry"
        ]
    ],
    "Given two words word1 and word2, find the minimum number of steps required to make word1 and word2 the same, where in each step you can delete one character in either string.": [
        "delete-operation-for-two-strings",
        [
            "longest-common-subsequence",
            "minimum-ascii-delete-sum-for-two-strings",
            "edit-distance"
        ],
        [
            "String"
        ]
    ],
    "Given an integer array, you need to find one continuous subarray that if you only sort this subarray in ascending order, then the whole array will be sorted in ascending order, too. You need to find the shortest such subarray and output its length.": [
        "shortest-unsorted-continuous-subarray",
        [],
        [
            "Array"
        ]
    ],
    "There is an m by n grid with a ball. Given the start coordinate (i,j) of the ball, you can move the ball to adjacent cell or cross the grid boundary in four directions (up, down, left, right). However, you can at most move N times. Find out the number of paths to move the ball out of grid boundary. The answer may be very large, return it after mod 109 + 7.\u00a0": [
        "out-of-boundary-paths",
        [
            "knight-probability-in-chessboard"
        ],
        [
            "Dynamic Programming",
            "Depth-first Search"
        ]
    ],
    "You have n\u00a0candies, the ith candy is of type candies[i].You want to distribute the candies equally between a sister and a brother so that each of them gets n / 2\u00a0candies (n is even). The sister loves to collect different types of candies, so you want to give her the maximum number of different types of candies.Return the maximum number of different types of candies you can give to the sister.\u00a0": [
        "distribute-candies",
        [],
        [
            "Hash Table"
        ]
    ],
    "Given two non-empty binary trees s and t, check whether tree t has exactly the same structure and node values with a subtree of s. A subtree of s is a tree consists of a node in s and all of this node's descendants. The tree s could also be considered as a subtree of itself.": [
        "subtree-of-another-tree",
        [
            "most-frequent-subtree-sum",
            "count-univalue-subtrees"
        ],
        [
            "Tree"
        ]
    ],
    "Given two strings s1 and s2, write a function to return true if s2 contains the permutation of s1. In other words, one of the first string's permutations is the substring of the second string.\u00a0": [
        "permutation-in-string",
        [
            "find-all-anagrams-in-a-string",
            "minimum-window-substring"
        ],
        [
            "Two Pointers",
            "Sliding Window"
        ]
    ],
    "In MATLAB, there is a very useful function called 'reshape', which can reshape a matrix into a new one with different size but keep its original data.You're given a matrix represented by a two-dimensional array, and two positive integers r and c representing the row number and column number of the wanted reshaped matrix, respectively.The reshaped matrix need to be filled with all the elements of the original matrix in the same row-traversing order as they were.If the 'reshape' operation with given parameters is possible and legal, output the new reshaped matrix; Otherwise, output the original matrix.": [
        "reshape-the-matrix",
        [],
        [
            "Array"
        ]
    ],
    "A zero-indexed array A of length N contains all integers from 0 to N-1. Find and return the longest length of set S, where S[i] = {A[i], A[A[i]], A[A[A[i]]], ... } subjected to the rule below.": [
        "array-nesting",
        [
            "nested-list-weight-sum-ii",
            "flatten-nested-list-iterator",
            "nested-list-weight-sum"
        ],
        [
            "Array"
        ]
    ],
    "Given an integer n, find the closest integer (not including itself), which is a palindrome. The 'closest' is defined as absolute difference minimized between two integers.": [
        "find-the-closest-palindrome",
        [],
        [
            "String"
        ]
    ],
    "Given a binary tree, return the tilt of the whole tree.The tilt of a tree node is defined as the absolute difference between the sum of all left subtree node values and the sum of all right subtree node values. Null node has tilt 0.The tilt of the whole tree is defined as the sum of all nodes' tilt.": [
        "binary-tree-tilt",
        [
            "find-all-the-lonely-nodes"
        ],
        [
            "Tree"
        ]
    ],
    "Given an array of 2n integers, your task is to group these integers into n pairs of integer, say (a1, b1), (a2, b2), ..., (an, bn) which makes sum of min(ai, bi) for all i from 1 to n as large as possible.": [
        "array-partition-i",
        [],
        [
            "Array"
        ]
    ],
    "Given an array of integers and an integer k, you need to find the total number of continuous subarrays whose sum equals to k.": [
        "subarray-sum-equals-k",
        [
            "subarray-sums-divisible-by-k",
            "find-pivot-index",
            "subarray-product-less-than-k",
            "continuous-subarray-sum",
            "two-sum"
        ],
        [
            "Array",
            "Hash Table"
        ]
    ],
    "Given a string, you need to reverse the order of characters in each word within a sentence while still preserving whitespace and initial word order.": [
        "reverse-words-in-a-string-iii",
        [
            "reverse-string-ii"
        ],
        [
            "String"
        ]
    ],
    "Given a positive 32-bit integer n, you need to find the smallest 32-bit integer which has exactly the same digits existing in the integer n and is greater in value than n. If no such positive 32-bit integer exists, you need to return -1.": [
        "next-greater-element-iii",
        [
            "next-greater-element-ii",
            "next-greater-element-i"
        ],
        [
            "String"
        ]
    ],
    "There is a brick wall in front of you. The wall is rectangular and has several rows of bricks. The bricks have the same height but different width. You want to draw a vertical line from the top to the bottom and cross the least bricks.The brick wall is represented by a list of rows. Each row is a list of integers representing the width of each brick in this row from left to right.If your line go through the edge of a brick, then the brick is not considered as crossed. You need to find out how to draw the line to cross the least bricks and return the number of crossed bricks.You cannot draw a line just along one of the two vertical edges of the wall, in which case the line will obviously cross no bricks. \u00a0": [
        "brick-wall",
        [],
        [
            "Hash Table"
        ]
    ],
    "Given a list of positive integers, the adjacent integers will perform the float division. ": [
        "optimal-division",
        [],
        [
            "Math",
            "String"
        ]
    ],
    "Given a positive integer n, return the number of all possible attendance records with length n, which will be regarded as rewardable. The answer may be very large, return it after mod 109 + 7.A student attendance record is a string that only contains the following three characters:'A' : Absent. 'L' : Late. 'P' : Present. A record is regarded as rewardable if it doesn't contain more than one 'A' (absent) or more than two continuous 'L' (late).": [
        "student-attendance-record-ii",
        [
            "student-attendance-record-i"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "You are given a string representing an attendance record for a student. The record only contains the following three characters:'A' : Absent. 'L' : Late. 'P' : Present. A student could be rewarded if his attendance record doesn't contain more than one 'A' (absent) or more than two continuous 'L' (late).    You need to return whether the student could be rewarded according to his attendance record.": [
        "student-attendance-record-i",
        [
            "student-attendance-record-ii"
        ],
        [
            "String"
        ]
    ],
    "There are N students in a class. Some of them are friends, while some are not. Their friendship is transitive in nature. ": [
        "friend-circles",
        [
            "the-earliest-moment-when-everyone-become-friends",
            "sentence-similarity-ii",
            "sentence-similarity",
            "robot-return-to-origin",
            "number-of-connected-components-in-an-undirected-graph"
        ],
        [
            "Depth-first Search",
            "Union Find"
        ]
    ],
    "Given several boxes with different colors represented by different positive numbers.You may experience several rounds to remove boxes until there is no box left. Each time you can choose some continuous boxes with the same color (composed of k boxes, k >= 1), remove them and get k*k points.Find the maximum points you can get.\u00a0": [
        "remove-boxes",
        [
            "strange-printer"
        ],
        [
            "Dynamic Programming",
            "Depth-first Search"
        ]
    ],
    "Given a binary tree, you need to compute the length of the diameter of the tree. The diameter of a binary tree is the length of the longest path between any two nodes in a tree. This path may or may not pass through the root.": [
        "diameter-of-binary-tree",
        [
            "diameter-of-n-ary-tree"
        ],
        [
            "Tree"
        ]
    ],
    "Given a matrix consists of 0 and 1, find the distance of the nearest 0 for each cell.The distance between two adjacent cells is 1.\u00a0": [
        "01-matrix",
        [],
        [
            "Depth-first Search",
            "Breadth-first Search"
        ]
    ],
    "Given a string and an integer k, you need to reverse the first k characters for every 2k characters counting from the start of the string. If there are less than k characters left, reverse all of them. If there are less than 2k but greater than or equal to k characters, then reverse the first k characters and left the other as original.": [
        "reverse-string-ii",
        [
            "reverse-words-in-a-string-iii",
            "reverse-string"
        ],
        [
            "String"
        ]
    ],
    "You are given a sorted array consisting of only integers where every element appears exactly twice, except for one element which appears exactly\u00a0once. Find this single element that appears only once.": [
        "single-element-in-a-sorted-array",
        [],
        []
    ],
    "Given a list of 24-hour clock time points in \"Hour:Minutes\" format, find the minimum minutes difference between any two time points in the list. ": [
        "minimum-time-difference",
        [],
        [
            "String"
        ]
    ],
    "Given a Binary Search Tree (BST), convert it to a Greater Tree such that every key of the original BST is changed to the original key plus sum of all keys greater than the original key in BST.": [
        "convert-bst-to-greater-tree",
        [],
        [
            "Tree"
        ]
    ],
    "Given two strings representing two complex numbers.You need to return a string representing their multiplication. Note i2 = -1 according to the definition.": [
        "complex-number-multiplication",
        [],
        [
            "Math",
            "String"
        ]
    ],
    "Given an array of integers and an integer k, you need to find the number of unique k-diff pairs in the array. Here a k-diff pair is defined as an integer pair (i, j), where i and j are both numbers in the array and their absolute difference is k.": [
        "k-diff-pairs-in-an-array",
        [
            "minimum-absolute-difference-in-bst"
        ],
        [
            "Array",
            "Two Pointers"
        ]
    ],
    "Given a binary search tree with non-negative values, find the minimum absolute difference between values of any two nodes.": [
        "minimum-absolute-difference-in-bst",
        [
            "k-diff-pairs-in-an-array"
        ],
        [
            "Tree"
        ]
    ],
    "Let's play the minesweeper game (Wikipedia, online game)!You are given a 2D char matrix representing the game board. 'M' represents an unrevealed mine, 'E' represents an unrevealed empty square, 'B' represents a revealed blank square that has no adjacent (above, below, left, right, and all 4 diagonals) mines, digit ('1' to '8') represents how many mines are adjacent to this revealed square, and finally 'X' represents a revealed mine.Now given the next click position (row and column indices) among all the unrevealed squares ('M' or 'E'), return the board after revealing this position according to the following rules:If a mine ('M') is revealed, then the game is over - change it to 'X'.If an empty square ('E') with no adjacent mines is revealed, then change it to revealed blank ('B') and all of its adjacent unrevealed squares should be revealed recursively.If an empty square ('E') with at least one adjacent mine is revealed, then change it to a digit ('1' to '8') representing the number of adjacent mines.Return the board when no more squares will be revealed.\u00a0": [
        "minesweeper",
        [],
        [
            "Depth-first Search",
            "Breadth-first Search"
        ]
    ],
    "Given a binary array, find the maximum length of a contiguous subarray with equal number of 0 and 1. ": [
        "contiguous-array",
        [
            "maximum-size-subarray-sum-equals-k"
        ],
        [
            "Hash Table"
        ]
    ],
    "Given a string and a string dictionary, find the longest string in the dictionary that can be formed by deleting some characters of the given string. If there are more than one possible results, return the longest word with the smallest lexicographical order. If there is no possible result, return the empty string.": [
        "longest-word-in-dictionary-through-deleting",
        [
            "longest-word-in-dictionary"
        ],
        [
            "Two Pointers",
            "Sort"
        ]
    ],
    "Given a list of non-negative numbers and a target integer k, write a function to check if the array has a continuous subarray of size at least 2 that sums up to a multiple of k, that is, sums up to n*k where n is also an integer.\u00a0": [
        "continuous-subarray-sum",
        [
            "subarray-sum-equals-k"
        ],
        [
            "Math",
            "Dynamic Programming"
        ]
    ],
    "Given a list of strings, you need to find the longest uncommon subsequence among them. The longest uncommon subsequence is defined as the longest subsequence of one of these strings and this subsequence should not be any subsequence of the other strings.A subsequence is a sequence that can be derived from one sequence by deleting some characters without changing the order of the remaining elements. Trivially, any string is a subsequence of itself and an empty string is a subsequence of any string.The input will be a list of strings, and the output needs to be the length of the longest uncommon subsequence. If the longest uncommon subsequence doesn't exist, return -1.": [
        "longest-uncommon-subsequence-ii",
        [
            "longest-uncommon-subsequence-i"
        ],
        [
            "String"
        ]
    ],
    "Given two strings, you need to find the longest uncommon subsequence\u00a0of this two strings. The longest uncommon subsequence is defined as the longest subsequence of one of these strings and this subsequence should not be any subsequence of the other string.A subsequence is a sequence that can be derived from one sequence by deleting some characters without changing the order of the remaining elements. Trivially, any string is a subsequence of itself and an empty string is a subsequence of any string.The input will be two strings, and the output needs to be the length of the longest uncommon subsequence. If the longest uncommon subsequence doesn't exist, return -1.\u00a0": [
        "longest-uncommon-subsequence-i",
        [
            "longest-uncommon-subsequence-ii"
        ],
        [
            "String"
        ]
    ],
    "Given a word, you need to judge whether the usage of capitals in it is right or not.We define the usage of capitals in a word to be right when one of the following cases holds:All letters in this word are capitals, like \"USA\".All letters in this word are not capitals, like \"leetcode\".Only the first letter in this word is capital, like \"Google\".Otherwise, we define that this word doesn't use capitals in a right way.\u00a0": [
        "detect-capital",
        [],
        [
            "String"
        ]
    ],
    "You are given coins of different denominations and a total amount of money. Write a function to compute the number of combinations that make up that amount. ": [
        "coin-change-2",
        [],
        []
    ],
    "You have n super washing machines on a line. Initially, each washing machine has some dresses or is empty. For each move, you could choose any m (1 \u2264 m \u2264 n) washing machines, and pass one dress of each washing machine to one of its adjacent washing machines  at the same time .  Given an integer array representing the number of dresses in each washing machine from left to right on the line, you should find the minimum number of moves to make all the washing machines have the same number of dresses. If it is not possible to do it, return -1.": [
        "super-washing-machines",
        [],
        [
            "Math",
            "Dynamic Programming"
        ]
    ],
    "Given a string s, find the longest palindromic subsequence's length in s. ": [
        "longest-palindromic-subsequence",
        [
            "longest-common-subsequence",
            "count-different-palindromic-subsequences",
            "palindromic-substrings",
            "longest-palindromic-substring"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Given the root of a binary tree, return an array of the largest value in each row of the tree (0-indexed).\u00a0\u00a0": [
        "find-largest-value-in-each-tree-row",
        [],
        [
            "Tree",
            "Depth-first Search",
            "Breadth-first Search"
        ]
    ],
    "In the video game Fallout 4, the quest \"Road to Freedom\" requires players to reach a metal dial called the \"Freedom Trail Ring\", and use the dial to spell a specific keyword in order to open the door.Given a string ring, which represents the code engraved on the outer ring and another string key, which represents the keyword needs to be spelled. You need to find the minimum number of steps in order to spell all the characters in the keyword.Initially, the first character of the ring is aligned at 12:00 direction. You need to spell all the characters in the string key one by one by rotating the ring clockwise or anticlockwise to make each character of the string key aligned at 12:00 direction and then by pressing the center button.At the stage of rotating the ring to spell the key character key[i]:You can rotate the ring clockwise or anticlockwise one place, which counts as 1 step. The final purpose of the rotation is to align one of the string ring's characters at the 12:00 direction, where this character must equal to the character key[i].If the character key[i] has been aligned at the 12:00 direction, you need to press the center button to spell, which also counts as 1 step. After the pressing, you could begin to spell the next character in the key (next stage), otherwise, you've finished all the spelling.": [
        "freedom-trail",
        [],
        [
            "Divide and Conquer",
            "Dynamic Programming",
            "Depth-first Search"
        ]
    ],
    "Given a binary tree, find the leftmost value in the last row of the tree. ": [
        "find-bottom-left-tree-value",
        [],
        [
            "Tree",
            "Depth-first Search",
            "Breadth-first Search"
        ]
    ],
    "Given the root of a tree, you are asked to find the most frequent subtree sum. The subtree sum of a node is defined as the sum of all the node values formed by the subtree rooted at that node (including the node itself). So what is the most frequent subtree sum value? If there is a tie, return all the values with the highest frequency in any order.": [
        "most-frequent-subtree-sum",
        [
            "subtree-of-another-tree"
        ],
        [
            "Hash Table",
            "Tree"
        ]
    ],
    "We define the Perfect Number is a positive integer that is equal to the sum of all its positive divisors except itself. Now, given an integer n, write a function that returns true when it is a perfect number and false when it is not.": [
        "perfect-number",
        [
            "self-dividing-numbers"
        ],
        [
            "Math"
        ]
    ],
    "Given scores of N athletes, find their relative ranks and the people with the top three highest scores, who will be awarded medals: \"Gold Medal\", \"Silver Medal\" and \"Bronze Medal\".": [
        "relative-ranks",
        [],
        []
    ],
    "Given an integer, return its base 7 string representation.": [
        "base-7",
        [],
        []
    ],
    "Given a circular array (the next element of the last element is the first element of the array), print the Next Greater Number for every element. The Next Greater Number of a number x is the first greater number to its traversing-order next in the array, which means you could search circularly to find its next greater number. If it doesn't exist, output -1 for this number.": [
        "next-greater-element-ii",
        [
            "next-greater-element-iii",
            "next-greater-element-i"
        ],
        [
            "Stack"
        ]
    ],
    "Given a binary search tree (BST) with duplicates, find all the mode(s) (the most frequently occurred element) in the given BST.Assume a BST is defined as follows:The left subtree of a node contains only nodes with keys less than or equal to the node's key.The right subtree of a node contains only nodes with keys greater than or equal to the node's key.Both the left and right subtrees must also be binary search trees.\u00a0": [
        "find-mode-in-binary-search-tree",
        [
            "validate-binary-search-tree"
        ],
        [
            "Tree"
        ]
    ],
    "Given a List of words, return the words that can be typed using letters of alphabet on only one row's of American keyboard like the image below.\u00a0\u00a0": [
        "keyboard-row",
        [],
        [
            "Hash Table"
        ]
    ],
    "Given a matrix of M x N elements (M rows, N columns), return all elements of the matrix in diagonal order as shown in the below image.\u00a0": [
        "diagonal-traverse",
        [],
        []
    ],
    "You are given two arrays (without duplicates) nums1 and nums2 where nums1\u2019s elements are subset of nums2. Find all the next greater numbers for nums1's elements in the corresponding places of nums2. The Next Greater Number of a number x in nums1 is the first greater number to its right in nums2. If it does not exist, output -1 for this number.": [
        "next-greater-element-i",
        [
            "daily-temperatures",
            "next-greater-element-iii",
            "next-greater-element-ii"
        ],
        [
            "Stack"
        ]
    ],
    "In LOL world, there is a hero called Teemo and his attacking can make his enemy Ashe be in poisoned condition. Now, given the Teemo's attacking ascending time series towards Ashe and the poisoning time duration per Teemo's attacking, you need to output the total time that Ashe is in poisoned condition.": [
        "teemo-attacking",
        [
            "dota2-senate",
            "can-place-flowers",
            "merge-intervals"
        ],
        [
            "Array"
        ]
    ],
    "You are given a list of non-negative integers, a1, a2, ..., an, and a target, S. Now you have 2 symbols + and -. For each integer, you should choose one from + and - as its new symbol.Find out how many ways to assign symbols to make sum of integers equal to target S.": [
        "target-sum",
        [
            "expression-add-operators"
        ],
        [
            "Dynamic Programming",
            "Depth-first Search"
        ]
    ],
    "Given an array nums, we call (i, j) an important reverse pair if i < j and nums[i] > 2*nums[j].You need to return the number of important reverse pairs in the given array.": [
        "reverse-pairs",
        [
            "count-of-range-sum",
            "count-of-smaller-numbers-after-self"
        ],
        [
            "Binary Search",
            "Divide and Conquer",
            "Sort",
            "Binary Indexed Tree",
            "Segment Tree"
        ]
    ],
    "For a web developer, it is very important to know how to design a web page's size. So, given a specific rectangular web page\u2019s area, your job by now is to design a rectangular web page, whose length L and width W satisfy the following requirements:1. The area of the rectangular web page you designed must equal to the given target area.2. The width W should not be larger than the length L, which means L >= W.3. The difference between length L and width W should be as small as possible.You need to output the length L and the width W of the web page you designed in sequence.": [
        "construct-the-rectangle",
        [],
        []
    ],
    "Given an integer array, your task is to find all the different possible increasing subsequences of the given array, and the length of an increasing subsequence should be at least 2.\u00a0": [
        "increasing-subsequences",
        [
            "maximum-length-of-pair-chain"
        ],
        [
            "Depth-first Search"
        ]
    ],
    "Think about Zuma Game. You have a row of balls on the table, colored red(R), yellow(Y), blue(B), green(G), and white(W). You also have several balls in your hand.Each time, you may choose a ball in your hand, and insert it into the row (including the leftmost place and rightmost place). Then, if there is a group of 3 or more balls in the same color touching, remove these balls. Keep doing this until no more balls can be removed.Find the minimal balls you have to insert to remove all the balls on the table. If you cannot remove all the balls, output -1.\u00a0": [
        "zuma-game",
        [],
        [
            "Depth-first Search"
        ]
    ],
    "Given an array of scores that are non-negative integers. Player 1 picks one of the numbers from either end of the array followed by the player 2 and then player 1 and so on. Each time a player picks a number, that number will not be available for the next player. This continues until all the scores have been chosen. The player with the maximum score wins.Given an array of scores, predict whether player 1 is the winner. You can assume each player plays to maximize his score.": [
        "predict-the-winner",
        [
            "can-i-win"
        ],
        [
            "Dynamic Programming",
            "Minimax"
        ]
    ],
    "Given a binary array, find the maximum number of consecutive 1s in this array.": [
        "max-consecutive-ones",
        [
            "consecutive-characters",
            "max-consecutive-ones-iii",
            "max-consecutive-ones-ii"
        ],
        [
            "Array"
        ]
    ],
    "For an integer n, we call k>=2 a good base of n, if all digits of n base k are 1.Now given a string representing n, you should return the smallest good base of n in string format.": [
        "smallest-good-base",
        [],
        [
            "Math",
            "Binary Search"
        ]
    ],
    "You are given a license key represented as a string S which consists only alphanumeric character and dashes. The string is separated into N+1 groups by N dashes.Given a number K, we would want to reformat the strings such that each group contains exactly K characters, except for the first group which could be shorter than K, but still must contain at least one character. Furthermore, there must be a dash inserted between two groups and all lowercase letters should be converted to uppercase.Given a non-empty string S and a number K, format the string according to the rules described above.": [
        "license-key-formatting",
        [],
        []
    ],
    "A magical string S consists of only '1' and '2' and obeys the following rules:The string S is magical because concatenating the number of contiguous occurrences of characters '1' and '2' generates the string S itself.The first few elements of string S is the following:S = \"1221121221221121122\u2026\u2026\"If we group the consecutive '1's and '2's in S, it will be:1   22  11  2  1  22  1  22  11  2  11  22 ......and the occurrences of '1's or '2's in each group are:1   2\t   2    1   1    2     1    2     2    1    2    2 ......You can see that the occurrence sequence above is the S itself. Given an integer N as input, return the number of '1's in the first N number in the magical string S.": [
        "magical-string",
        [],
        []
    ],
    "Median is the middle value in an ordered integer list. If the size of the list is even, there is no middle value. So the median is the mean of the two middle value.": [
        "find-median-from-data-stream",
        [
            "sliding-window-median"
        ],
        [
            "Heap",
            "Design"
        ]
    ],
    "Find the largest palindrome made from the product of two n-digit numbers.Since the result could be very large, you should return the largest palindrome mod 1337.\u00a0": [
        "largest-palindrome-product",
        [],
        []
    ],
    "The Hamming distance between two integers is the number of positions at which the corresponding bits are different.Now your job is to find the total Hamming distance between all pairs of the given numbers.": [
        "total-hamming-distance",
        [
            "hamming-distance"
        ],
        [
            "Bit Manipulation"
        ]
    ],
    "Given a positive integer num, output its complement number. The complement strategy is to flip the bits of its binary representation.\u00a0": [
        "number-complement",
        [],
        [
            "Bit Manipulation"
        ]
    ],
    "Winter is coming! Your first job during the contest is to design a standard heater with fixed warm radius to warm all the houses.Now, you are given positions of houses and heaters on a horizontal line, find out minimum radius of heaters so that all houses could be covered by those heaters.So, your input will be the positions of houses and heaters seperately, and your expected output will be the minimum radius standard of heaters.": [
        "heaters",
        [],
        [
            "Binary Search"
        ]
    ],
    "Given an array, strs, with strings consisting of only 0s and 1s. Also two integers m and n.Now your task is to find the maximum number of strings that you can form with given m 0s and n 1s. Each 0 and 1 can be used at most once.\u00a0": [
        "ones-and-zeroes",
        [
            "non-negative-integers-without-consecutive-ones"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Remember the story of Little Match Girl? By now, you know exactly what matchsticks the little match girl has, please find out a way you can make one square by using up all those matchsticks. You should not break any stick, but you can link them up, and each matchstick must be used exactly one time. Your input will be several matchsticks the girl has, represented with their stick length. Your output will either be true or false, to represent whether you could make one square using all the matchsticks the little match girl has.": [
        "matchsticks-to-square",
        [],
        [
            "Depth-first Search"
        ]
    ],
    "Given a list of words (without duplicates), please write a program that returns all concatenated words in the given list of words.A concatenated word is defined as a string that is comprised entirely of at least two shorter words in the given array.": [
        "concatenated-words",
        [
            "word-break-ii"
        ],
        [
            "Dynamic Programming",
            "Depth-first Search",
            "Trie"
        ]
    ],
    "Given a string IP, return \"IPv4\" if IP is a valid IPv4 address,\u00a0\"IPv6\" if\u00a0IP is a valid IPv6 address or \"Neither\" if IP is not a correct IP of any type.A valid IPv4 address\u00a0is an IP in the form \"x1.x2.x3.x4\" where 0 <=\u00a0xi\u00a0<= 255 and xi cannot contain leading zeros. ": [
        "validate-ip-address",
        [
            "ip-to-cidr"
        ],
        [
            "String"
        ]
    ],
    "Consider the string s to be the infinite wraparound string of \"abcdefghijklmnopqrstuvwxyz\", so s will look like this: \"...zabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd....\".Now we have another string p. Your job is to find out how many unique non-empty substrings of p are present in s. In particular, your input is the string p and you need to output the number of different non-empty substrings of p in the string s.": [
        "unique-substrings-in-wraparound-string",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Define S = [s,n] as the string S which consists of n connected strings s. ": [
        "count-the-repetitions",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "In the \"100 game\" two players take turns adding, to a running total, any integer from 1 to 10. The player who first causes the running total to reach or exceed 100 wins.What if we change the game so that players cannot re-use integers?": [
        "can-i-win",
        [
            "predict-the-winner",
            "guess-number-higher-or-lower-ii",
            "flip-game-ii"
        ],
        [
            "Dynamic Programming",
            "Minimax"
        ]
    ],
    "You are given a map in form of a two-dimensional integer grid where 1 represents land and 0 represents water.Grid cells are connected horizontally/vertically (not diagonally). The grid is completely surrounded by water, and there is exactly one island (i.e., one or more connected land cells).The island doesn't have \"lakes\" (water inside that isn't connected to the water around the island). One cell is a square with side length 1. The grid is rectangular, width and height don't exceed 100. Determine the perimeter of the island.\u00a0": [
        "island-perimeter",
        [
            "coloring-a-border",
            "flood-fill",
            "max-area-of-island"
        ],
        [
            "Hash Table"
        ]
    ],
    "Given a non-empty integer array, find the minimum number of moves required to make all array elements equal, where a move is incrementing a selected element by 1 or decrementing a selected element by 1.": [
        "minimum-moves-to-equal-array-elements-ii",
        [
            "minimum-moves-to-equal-array-elements",
            "best-meeting-point"
        ],
        [
            "Math"
        ]
    ],
    "The Hamming distance between two integers is the number of positions at which the corresponding bits are different.Given two integers x and y, calculate the Hamming distance.": [
        "hamming-distance",
        [
            "total-hamming-distance",
            "number-of-1-bits"
        ],
        [
            "Bit Manipulation"
        ]
    ],
    "Design and implement a data structure for Least Frequently Used (LFU) cache. It should support the following operations: get and put.get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.put(key, value) - Set or insert the value if the key is not already present. When the cache reaches its capacity, it should invalidate the least frequently used item before inserting a new item. For the purpose of this problem, when there is a tie (i.e., two or more keys that have the same frequency), the least recently used key would be evicted.": [
        "lfu-cache",
        [
            "design-in-memory-file-system",
            "lru-cache"
        ],
        [
            "Design"
        ]
    ],
    "Given a non-empty string check if it can be constructed by taking a substring of it and appending multiple copies of the substring together. ": [
        "repeated-substring-pattern",
        [
            "repeated-string-match",
            "implement-strstr"
        ],
        [
            "String"
        ]
    ],
    "There are 1000 buckets, one and only one of them is poisonous, while the rest are filled with water. They all look identical. If a pig drinks the poison it will die within 15 minutes. What is the minimum amount of pigs you need to figure out which bucket is poisonous within one hour?": [
        "poor-pigs",
        [],
        [
            "Math"
        ]
    ],
    "You are given a circular array nums of positive and negative integers. If a number k at an index is positive, then move forward k steps. Conversely, if it's negative (-k), move backward k\u00a0steps. Since the array is circular, you may assume that the last element's next element is the first element, and the first element's previous element is the last element.Determine if there is a loop (or a cycle) in nums. A cycle must start and end at the same index and the cycle's length > 1. Furthermore, movements in a cycle must all follow a single direction. In other words, a cycle must not consist of both forward and backward movements.\u00a0": [
        "circular-array-loop",
        [],
        [
            "Array",
            "Two Pointers"
        ]
    ],
    "Given an array\u00a0of n integers nums, a 132 pattern is a subsequence of three integers nums[i], nums[j] and nums[k] such that i < j < k and nums[i] < nums[k] < nums[j].Return true if there is a 132 pattern in nums, otherwise return false.\u00a0": [
        "132-pattern",
        [],
        [
            "Stack"
        ]
    ],
    "Assume you are an awesome parent and want to give your children some cookies. But, you should give each child at most one cookie. Each child i has a greed factor gi, which is the minimum size of a cookie that the child will be content with; and each cookie j has a size sj. If sj >= gi, we can assign the cookie j to the child i, and the child i will be content. Your goal is to maximize the number of your content children and output the maximum number.": [
        "assign-cookies",
        [],
        [
            "Greedy"
        ]
    ],
    "Given four lists A, B, C, D of integer values, compute how many tuples (i, j, k, l) there are such that A[i] + B[j] + C[k] + D[l] is zero.To make problem a bit easier, all A, B, C, D have same length of N where 0 \u2264 N \u2264 500. All integers are in the range of -228 to 228 - 1 and the result is guaranteed to be at most 231 - 1.": [
        "4sum-ii",
        [
            "4sum"
        ],
        [
            "Hash Table",
            "Binary Search"
        ]
    ],
    "Given a non-empty integer array of size n, find the minimum number of moves required to make all array elements equal, where a move is incrementing n - 1 elements by 1.": [
        "minimum-moves-to-equal-array-elements",
        [
            "minimum-moves-to-equal-array-elements-ii"
        ],
        [
            "Math"
        ]
    ],
    "There are a number of spherical balloons spread in two-dimensional space. For each balloon, provided input is the start and end coordinates of the horizontal diameter. Since it's horizontal, y-coordinates don't matter and hence the x-coordinates of start and end of the diameter suffice. Start is always smaller than end. There will be at most 104 balloons.An arrow can be shot up exactly vertically from different points along the x-axis. A balloon with xstart and xend bursts by an arrow shot at x if xstart \u2264 x \u2264 xend. There is no limit to the number of arrows that can be shot. An arrow once shot keeps travelling up infinitely. The problem is to find the minimum number of arrows that must be shot to burst all balloons.": [
        "minimum-number-of-arrows-to-burst-balloons",
        [
            "non-overlapping-intervals",
            "meeting-rooms-ii"
        ],
        [
            "Greedy"
        ]
    ],
    "Given a string, sort it in decreasing order based on the frequency of characters.": [
        "sort-characters-by-frequency",
        [
            "first-unique-character-in-a-string",
            "top-k-frequent-elements"
        ],
        [
            "Hash Table",
            "Heap"
        ]
    ],
    "Given a root node reference of a BST and a key, delete the node with the given key in the BST. Return the root node reference (possibly updated) of the BST.Basically, the deletion can be divided into two stages:Search for a node to remove.If the node is found, delete the node.": [
        "delete-node-in-a-bst",
        [
            "split-bst"
        ],
        [
            "Tree"
        ]
    ],
    "Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.Design an algorithm to serialize and deserialize a binary search tree. There is no restriction on how your serialization/deserialization algorithm should work. You just need to ensure that a binary search tree can be serialized to a string and this string can be deserialized to the original tree structure.The encoded string should be as compact as possible.": [
        "serialize-and-deserialize-bst",
        [
            "serialize-and-deserialize-n-ary-tree",
            "find-duplicate-subtrees",
            "serialize-and-deserialize-binary-tree"
        ],
        [
            "Tree"
        ]
    ],
    "Given an array of integers where 1 \u2264 a[i] \u2264 n (n = size of array), some elements appear twice and others appear once.Find all the elements of [1, n] inclusive that do not appear in this array.Could you do it without extra space and in O(n) runtime? ": [
        "find-all-numbers-disappeared-in-an-array",
        [
            "find-all-duplicates-in-an-array",
            "first-missing-positive"
        ],
        [
            "Array"
        ]
    ],
    "Given n points in the plane that are all pairwise distinct, a \"boomerang\" is a tuple of points (i, j, k) such that the distance between i and j equals the distance between i and k (the order of the tuple matters).Find the number of boomerangs. ": [
        "number-of-boomerangs",
        [
            "line-reflection"
        ],
        [
            "Hash Table"
        ]
    ],
    "A sequence of numbers is called arithmetic if it consists of at least three elements and if the difference between any two consecutive elements is the same.": [
        "arithmetic-slices",
        [
            "arithmetic-slices-ii-subsequence"
        ],
        [
            "Math",
            "Dynamic Programming"
        ]
    ],
    "You are given two non-empty linked lists representing two non-negative integers. The most significant digit comes first and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.": [
        "add-two-numbers-ii",
        [
            "add-two-numbers"
        ],
        [
            "Linked List"
        ]
    ],
    "Given an array of characters, compress it in-place.The length after compression must always be smaller than or equal to the original array.Every element of the array should be a character (not int) of length 1.After you are done modifying the input array in-place, return the new length of the array.\u00a0": [
        "string-compression",
        [
            "decompress-run-length-encoded-list",
            "design-compressed-string-iterator",
            "encode-and-decode-strings",
            "count-and-say"
        ],
        [
            "String"
        ]
    ],
    "Given an array of integers, 1 \u2264 a[i] \u2264 n (n = size of array), some elements appear twice and others appear once.Find all the elements that appear twice in this array.Could you do it without extra space and in O(n) runtime?": [
        "find-all-duplicates-in-an-array",
        [
            "find-all-numbers-disappeared-in-an-array"
        ],
        [
            "Array"
        ]
    ],
    "You have a total of n coins that you want to form in a staircase shape, where every k-th row must have exactly k coins.Given n, find the total number of full staircase rows that can be formed.n is a non-negative integer and fits within the range of a 32-bit signed integer.": [
        "arranging-coins",
        [],
        [
            "Math",
            "Binary Search"
        ]
    ],
    "Given integers n and k, find the lexicographically k-th smallest integer in the range from 1 to n.": [
        "k-th-smallest-in-lexicographical-order",
        [],
        []
    ],
    "Given a string s and a non-empty string p, find all the start indices of p's anagrams in s.Strings consists of lowercase English letters only and the length of both strings s and p will not be larger than 20,100.The order of output does not matter.": [
        "find-all-anagrams-in-a-string",
        [
            "permutation-in-string",
            "valid-anagram"
        ],
        [
            "Hash Table"
        ]
    ],
    "You are given a binary tree in which each node contains an integer value.Find the number of paths that sum to a given value.The path does not need to start or end at the root or a leaf, but it must go downwards(traveling only from parent nodes to child nodes).The tree has no more than 1,000 nodes and the values are in the range -1,000,000 to 1,000,000.": [
        "path-sum-iii",
        [
            "longest-univalue-path",
            "path-sum-iv",
            "path-sum-ii",
            "path-sum"
        ],
        [
            "Tree"
        ]
    ],
    "You are given an array of\u00a0intervals, where intervals[i] = [starti, endi]\u00a0and each starti\u00a0is unique.The right\u00a0interval\u00a0for an interval i is an interval\u00a0j\u00a0such that startj\u00a0>= endi\u00a0and\u00a0startj\u00a0is\u00a0minimized.Return\u00a0an array of\u00a0right interval\u00a0indices for each interval\u00a0i. If no\u00a0right interval\u00a0exists for interval\u00a0i, then put\u00a0-1\u00a0at index i.\u00a0": [
        "find-right-interval",
        [
            "data-stream-as-disjoint-intervals"
        ],
        [
            "Binary Search"
        ]
    ],
    "Given a collection of intervals, find the minimum number of intervals you need to remove to make the rest of the intervals non-overlapping.\u00a0": [
        "non-overlapping-intervals",
        [
            "minimum-number-of-arrows-to-burst-balloons"
        ],
        [
            "Greedy"
        ]
    ],
    "You are given a string s, return the number of segments in the string.\u00a0A segment is defined to be a contiguous sequence of non-space characters.\u00a0": [
        "number-of-segments-in-a-string",
        [],
        [
            "String"
        ]
    ],
    "A gene string can be represented by an 8-character long string, with choices from \"A\", \"C\", \"G\", \"T\".": [
        "minimum-genetic-mutation",
        [
            "word-ladder"
        ],
        []
    ],
    "Implement a data structure supporting the following operations:Inc(Key) - Inserts a new key  with value 1. Or increments an existing key by 1. Key is guaranteed to be a non-empty string.Dec(Key) - If Key's value is 1, remove it from the data structure. Otherwise decrements an existing key by 1. If the key does not exist, this function does nothing. Key is guaranteed to be a non-empty string.GetMaxKey() - Returns one of the keys with maximal value. If no element exists, return an empty string \"\".GetMinKey() - Returns one of the keys with minimal value. If no element exists, return an empty string \"\".Challenge: Perform all these in O(1) time complexity.": [
        "all-oone-data-structure",
        [],
        [
            "Design"
        ]
    ],
    "Given a string s\u00a0that consists of only uppercase English letters, you can perform at most k operations on that string.In one operation, you can choose any character of the string and change it to any other uppercase English character.Find the length of the longest sub-string containing all repeating letters you can get after performing the above operations.": [
        "longest-repeating-character-replacement",
        [
            "max-consecutive-ones-iii",
            "longest-substring-with-at-most-k-distinct-characters"
        ],
        [
            "Two Pointers",
            "Sliding Window"
        ]
    ],
    "Given a non-empty string containing an out-of-order English representation of digits 0-9, output the digits in ascending order.": [
        "reconstruct-original-digits-from-english",
        [],
        [
            "Math"
        ]
    ],
    "Given a non-empty array of numbers, a0, a1, a2, \u2026 , an-1, where 0 \u2264 ai < 231.Find the maximum result of ai XOR aj, where 0 \u2264 i, j < n.Could you do this in O(n) runtime?": [
        "maximum-xor-of-two-numbers-in-an-array",
        [],
        [
            "Bit Manipulation",
            "Trie"
        ]
    ],
    "A password is considered strong if below conditions are all met: It has at least 6 characters and at most 20 characters.  It must contain at least one lowercase letter, at least one uppercase letter, and at least one digit.  It must NOT contain three repeating characters in a row (\"...aaa...\" is weak, but \"...aa...a...\" is strong, assuming other conditions are met). Write a function strongPasswordChecker(s), that takes a string s as input, and return the MINIMUM change required to make s a strong password. If s is already strong, return 0.Insertion, deletion or replace of any one character are all considered as one change.": [
        "strong-password-checker",
        [],
        []
    ],
    "Given an 2D board, count how many battleships are in it. The battleships are represented with 'X's, empty slots are represented with '.'s. ": [
        "battleships-in-a-board",
        [],
        []
    ],
    "Given an m x n matrix of non-negative integers representing the height of each unit cell in a continent, the \"Pacific ocean\" touches the left and top edges of the matrix and the \"Atlantic ocean\" touches the right and bottom edges.Water can only flow in four directions (up, down, left, or right) from a cell to another one with height equal or lower.Find the list of grid coordinates where water can flow to both the Pacific and Atlantic ocean.": [
        "pacific-atlantic-water-flow",
        [],
        [
            "Depth-first Search",
            "Breadth-first Search"
        ]
    ],
    "Given a non-empty array containing only positive integers, find if the array can be partitioned into two subsets such that the sum of elements in both subsets is equal.": [
        "partition-equal-subset-sum",
        [
            "partition-to-k-equal-sum-subsets"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Given two non-negative integers num1 and num2 represented as string, return the sum of num1 and num2.": [
        "add-strings",
        [
            "add-to-array-form-of-integer",
            "multiply-strings",
            "add-two-numbers"
        ],
        [
            "String"
        ]
    ],
    "Given a non-empty array of integers, return the third maximum number in this array. If it does not exist, return the maximum number. The time complexity must be in O(n).": [
        "third-maximum-number",
        [
            "kth-largest-element-in-an-array"
        ],
        [
            "Array"
        ]
    ],
    "Write a program that outputs the string representation of numbers from 1 to n.But for multiples of three it should output \u201cFizz\u201d instead of the number and for the multiples of five output \u201cBuzz\u201d. For numbers which are multiples of both three and five output \u201cFizzBuzz\u201d.": [
        "fizz-buzz",
        [
            "Fizz Buzz Multithreaded"
        ],
        []
    ],
    "Given an array nums which consists of non-negative integers and an integer m, you can split the array into m non-empty continuous subarrays.Write an algorithm to minimize the largest sum among these m subarrays.\u00a0": [
        "split-array-largest-sum",
        [],
        [
            "Binary Search",
            "Dynamic Programming"
        ]
    ],
    "Given a string s which consists of lowercase or uppercase letters, return the length of the longest palindrome\u00a0that can be built with those letters.Letters are case sensitive, for example,\u00a0\"Aa\" is not considered a palindrome here.\u00a0": [
        "longest-palindrome",
        [
            "palindrome-permutation"
        ],
        [
            "Hash Table"
        ]
    ],
    "Given an m x n matrix of positive integers representing the height of each unit cell in a 2D elevation map, compute the volume of water it is able to trap after raining.": [
        "trapping-rain-water-ii",
        [
            "trapping-rain-water"
        ],
        [
            "Heap",
            "Breadth-first Search"
        ]
    ],
    "Given an integer, write an algorithm to convert it to hexadecimal. For negative integer, two\u2019s complement method is used.": [
        "convert-a-number-to-hexadecimal",
        [],
        [
            "Bit Manipulation"
        ]
    ],
    "Find the sum of all left leaves in a given binary tree.": [
        "sum-of-left-leaves",
        [],
        [
            "Tree"
        ]
    ],
    "A frog is crossing a river. The river is divided into x units and at each unit there may or may not exist a stone. The frog can jump on a stone, but it must not jump into the water.Given a list of stones' positions (in units) in sorted ascending order, determine if the frog is able to cross the river by landing on the last stone. Initially, the frog is on the first stone and assume the first jump must be 1 unit.If the frog's last jump was k units, then its next jump must be either k - 1, k, or k + 1 units. ": [
        "frog-jump",
        [],
        [
            "Dynamic Programming"
        ]
    ],
    "Given a non-negative integer num represented as a string, remove k digits from the number so that the new number is the smallest possible.": [
        "remove-k-digits",
        [
            "monotone-increasing-digits",
            "create-maximum-number"
        ],
        [
            "Stack",
            "Greedy"
        ]
    ],
    "A binary watch has 4 LEDs on the top which represent the hours (0-11), and the 6 LEDs on the bottom represent the minutes (0-59).Each LED represents a zero or one, with the least significant bit on the right.": [
        "binary-watch",
        [
            "number-of-1-bits",
            "letter-combinations-of-a-phone-number"
        ],
        [
            "Backtracking",
            "Bit Manipulation"
        ]
    ],
    "Find the nth digit of the infinite integer sequence 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ... ": [
        "nth-digit",
        [],
        [
            "Math"
        ]
    ],
    "Equations are given in the format A / B = k, where A and B are variables represented as strings, and k is a real number (floating point number). Given some queries, return the answers. If the answer does not exist, return -1.0.": [
        "evaluate-division",
        [],
        [
            "Union Find",
            "Graph"
        ]
    ],
    "Given an array of integers with possible duplicates, randomly output the index of a given target number. You can assume that the given target number must exist in the array.": [
        "random-pick-index",
        [
            "random-pick-with-weight",
            "random-pick-with-blacklist",
            "linked-list-random-node"
        ],
        [
            "Reservoir Sampling"
        ]
    ],
    "Given a positive integer n and you can do operations as follow:If n is even, replace n with n/2.If n is odd, you can replace n with either n + 1 or n - 1.What is the minimum number of replacements needed for n to become 1?": [
        "integer-replacement",
        [],
        [
            "Math",
            "Bit Manipulation"
        ]
    ],
    "Given an array of integers A and let n to be its length.Assume Bk to be an array obtained by rotating the array A k positions clock-wise, we define a \"rotation function\" F on A as follow:F(k) = 0 * Bk[0] + 1 * Bk[1] + ... + (n-1) * Bk[n-1].Calculate the maximum value of F(0), F(1), ..., F(n-1). ": [
        "rotate-function",
        [],
        [
            "Math"
        ]
    ],
    "Find the length of the longest substring T of a given string (consists of lowercase letters only) such that every character in T appears no less than k times.": [
        "longest-substring-with-at-least-k-repeating-characters",
        [],
        []
    ],
    "Given an encoded string, return its decoded string.The encoding rule is: k[encoded_string], where the encoded_string inside the square brackets is being repeated exactly k times. ": [
        "decode-string",
        [
            "brace-expansion",
            "number-of-atoms",
            "encode-string-with-shortest-length"
        ],
        [
            "Stack",
            "Depth-first Search"
        ]
    ],
    "A character in UTF8 can be from 1 to 4 bytes long, subjected to the following rules:For 1-byte character, the first bit is a 0, followed by its unicode code.For n-bytes character, the first n-bits are all one's, the n+1 bit is 0, followed by n-1 bytes with most significant 2 bits being 10.This is how the UTF-8 encoding would work:   Char. number range  |        UTF-8 octet sequence      (hexadecimal)    |              (binary)   --------------------+---------------------------------------------   0000 0000-0000 007F | 0xxxxxxx   0000 0080-0000 07FF | 110xxxxx 10xxxxxx   0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx   0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxxGiven an array of integers representing the data, return whether it is a valid utf-8 encoding.": [
        "utf-8-validation",
        [],
        [
            "Bit Manipulation"
        ]
    ],
    "Given a string s and a string t, check if s is subsequence of t.A subsequence of a string is a new string which is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie, \"ace\" is a subsequence of \"abcde\" while \"aec\" is not).": [
        "is-subsequence",
        [
            "shortest-way-to-form-string",
            "number-of-matching-subsequences"
        ],
        [
            "Binary Search",
            "Dynamic Programming",
            "Greedy"
        ]
    ],
    "Given N axis-aligned rectangles where N > 0, determine if they all together form an exact cover of a rectangular region.Each rectangle is represented as a bottom-left point and a top-right point. ": [
        "perfect-rectangle",
        [],
        [
            "Line Sweep"
        ]
    ],
    "There is a list of sorted integers from 1 to n. Starting from left to right, remove the first number and every other number afterward until you reach the end of the list.Repeat the previous step again, but this time from right to left, remove the right most number and every other number from the remaining numbers.We keep repeating the steps again, alternating left to right and right to left, until a single number remains.Find the last number that remains starting with a list of length n.": [
        "elimination-game",
        [],
        []
    ],
    "Given two strings s and t which consist of only lowercase letters.String t is generated by random shuffling string s and then add one more letter at a random position.Find the letter that was added in t.": [
        "find-the-difference",
        [
            "single-number"
        ],
        [
            "Hash Table",
            "Bit Manipulation"
        ]
    ],
    "Given a string, find the first non-repeating character in it and return its index. If it doesn't exist, return -1.": [
        "first-unique-character-in-a-string",
        [
            "sort-characters-by-frequency"
        ],
        [
            "Hash Table",
            "String"
        ]
    ],
    "Given an integer n, return 1 - n in lexicographical order.": [
        "lexicographical-numbers",
        [],
        []
    ],
    "Given a nested list of integers represented as a string, implement a parser to deserialize it.Each element is either an integer, or a list -- whose elements may also be integers or other lists.": [
        "mini-parser",
        [
            "remove-comments",
            "ternary-expression-parser",
            "flatten-nested-list-iterator"
        ],
        [
            "String",
            "Stack"
        ]
    ],
    "Shuffle a set of numbers without duplicates.": [
        "shuffle-an-array",
        [],
        []
    ],
    "Given an arbitrary ransom note string and another string containing letters from all the magazines, write a function that will return true if the ransom note can be constructed from the magazines ; otherwise, it will return false.Each letter in the magazine string can only be used once in your ransom note.\u00a0": [
        "ransom-note",
        [
            "stickers-to-spell-word"
        ],
        [
            "String"
        ]
    ],
    "Given a singly linked list, return a random node's value from the linked list. Each node must have the same probability of being chosen.": [
        "linked-list-random-node",
        [
            "random-pick-index"
        ],
        [
            "Reservoir Sampling"
        ]
    ],
    "Design a data structure that supports all following operations in average O(1) time.": [
        "insert-delete-getrandom-o1-duplicates-allowed",
        [
            "insert-delete-getrandom-o1"
        ],
        [
            "Array",
            "Hash Table",
            "Design"
        ]
    ],
    "Design a data structure that supports all following operations in average O(1) time.\u00a0insert(val): Inserts an item val to the set if not already present.remove(val): Removes an item val from the set if present.getRandom: Returns a random element from current set of elements (it's guaranteed that at least one element exists when this method is called). Each element must have the same probability of being returned.\u00a0": [
        "insert-delete-getrandom-o1",
        [
            "insert-delete-getrandom-o1-duplicates-allowed"
        ],
        [
            "Array",
            "Hash Table",
            "Design"
        ]
    ],
    "Given a n x n matrix where each of the rows and columns are sorted in ascending order, find the kth smallest element in the matrix.": [
        "kth-smallest-element-in-a-sorted-matrix",
        [
            "k-th-smallest-prime-fraction",
            "find-k-th-smallest-pair-distance",
            "kth-smallest-number-in-multiplication-table",
            "find-k-pairs-with-smallest-sums"
        ],
        [
            "Binary Search",
            "Heap"
        ]
    ],
    "Given an integer array with all positive numbers and no duplicates, find the number of possible combinations that add up to a positive integer target.": [
        "combination-sum-iv",
        [
            "combination-sum"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "A sequence of numbers is called a wiggle sequence if the differences between successive numbers strictly alternate between positive and negative. The first difference (if one exists) may be either positive or negative. A sequence with fewer than two elements is trivially a wiggle sequence.": [
        "wiggle-subsequence",
        [],
        [
            "Dynamic Programming",
            "Greedy"
        ]
    ],
    "We are playing the Guess Game. The game is as follows:I pick a number from 1 to n. You have to guess which number I picked.Every time you guess wrong, I'll tell you whether the number I picked is higher or lower.However, when you guess a particular number x, and you guess wrong, you pay $x. You win the game when you guess the number I picked.": [
        "guess-number-higher-or-lower-ii",
        [
            "find-k-closest-elements",
            "can-i-win",
            "guess-number-higher-or-lower",
            "flip-game-ii"
        ],
        [
            "Dynamic Programming",
            "Minimax"
        ]
    ],
    "We are playing the Guess Game. The game is as follows:I pick a number from 1 to n. You have to guess which number I picked.Every time you guess wrong, I'll tell you whether the number is higher or lower.You call a pre-defined API guess(int num) which returns 3 possible results (-1, 1, or 0):-1 : My number is lower 1 : My number is higher 0 : Congrats! You got it!": [
        "guess-number-higher-or-lower",
        [
            "find-k-closest-elements",
            "guess-number-higher-or-lower-ii",
            "first-bad-version"
        ],
        [
            "Binary Search"
        ]
    ],
    "You are given two integer arrays nums1 and nums2 sorted in ascending order and an integer k.Define a pair (u,v) which consists of one element from the first array and one element from the second array.Find the k pairs (u1,v1),(u2,v2) ...(uk,vk) with the smallest sums.": [
        "find-k-pairs-with-smallest-sums",
        [
            "find-k-th-smallest-pair-distance",
            "kth-smallest-element-in-a-sorted-matrix"
        ],
        [
            "Heap"
        ]
    ],
    "Your task is to calculate ab mod 1337 where a is a positive integer and b is an extremely large positive integer given in the form of an array.": [
        "super-pow",
        [
            "powx-n"
        ],
        [
            "Math"
        ]
    ],
    "Calculate the sum of two integers a and b, but you are not allowed to use the operator + and -.": [
        "sum-of-two-integers",
        [
            "add-two-numbers"
        ],
        [
            "Bit Manipulation"
        ]
    ],
    "Given a set of distinct positive integers, find the largest subset such that every pair (Si, Sj) of elements in this subset satisfies:Si % Sj = 0 or Sj % Si = 0.If there are multiple solutions, return any subset is fine.": [
        "largest-divisible-subset",
        [],
        [
            "Math",
            "Dynamic Programming"
        ]
    ],
    "Given a positive integer num, write a function which returns True if num is a perfect square else False.": [
        "valid-perfect-square",
        [
            "sum-of-square-numbers",
            "sqrtx"
        ],
        [
            "Math",
            "Binary Search"
        ]
    ],
    "You are given two jugs with capacities x and y litres. There is an infinite amount of water supply available. You need to determine whether it is possible to measure exactly z litres using these two jugs.If z liters of water is measurable, you must have z liters of water contained within one or both buckets by the end.Operations allowed:Fill any of the jugs completely with water.Empty any of the jugs.Pour water from one jug into another till the other jug is completely full or the first jug itself is empty.": [
        "water-and-jug-problem",
        [],
        [
            "Math"
        ]
    ],
    "Given a non-empty 2D matrix matrix and an integer k, find the max sum of a rectangle in the matrix such that its sum is no larger than k.": [
        "max-sum-of-rectangle-no-larger-than-k",
        [],
        [
            "Binary Search",
            "Dynamic Programming",
            "Queue"
        ]
    ],
    "Given a non-negative integer n, count all numbers with unique digits, x, where 0 \u2264 x < 10n.": [
        "count-numbers-with-unique-digits",
        [],
        [
            "Math",
            "Dynamic Programming",
            "Backtracking"
        ]
    ],
    "Design a simplified version of Twitter where users can post tweets, follow/unfollow another user and is able to see the 10 most recent tweets in the user's news feed. Your design should support the following methods:postTweet(userId, tweetId): Compose a new tweet.getNewsFeed(userId): Retrieve the 10 most recent tweet ids in the user's news feed. Each item in the news feed must be posted by users who the user followed or by the user herself. Tweets must be ordered from most recent to least recent.follow(followerId, followeeId): Follower follows a followee.unfollow(followerId, followeeId): Follower unfollows a followee.": [
        "design-twitter",
        [
            "design-a-file-sharing-system"
        ],
        [
            "Hash Table",
            "Heap",
            "Design"
        ]
    ],
    "You have a number of envelopes with widths and heights given as a pair of integers (w, h). One envelope can fit into another if and only if both the width and height of one envelope is greater than the width and height of the other envelope.What is the maximum number of envelopes can you Russian doll? (put one inside other)": [
        "russian-doll-envelopes",
        [
            "longest-increasing-subsequence"
        ],
        [
            "Binary Search",
            "Dynamic Programming"
        ]
    ],
    "Given a data stream input of non-negative integers a1, a2, ..., an, ..., summarize the numbers seen so far as a list of disjoint intervals.": [
        "data-stream-as-disjoint-intervals",
        [
            "range-module",
            "find-right-interval",
            "summary-ranges"
        ],
        [
            "Binary Search",
            "Ordered Map"
        ]
    ],
    "Given two arrays, write a function to compute their intersection.": [
        "intersection-of-two-arrays",
        [
            "intersection-of-three-sorted-arrays",
            "intersection-of-two-arrays-ii"
        ],
        [
            "Hash Table",
            "Two Pointers",
            "Binary Search",
            "Sort"
        ]
    ],
    "Given a non-empty array of integers, return the k most frequent elements.": [
        "top-k-frequent-elements",
        [
            "Word Frequency",
            "k-closest-points-to-origin",
            "top-k-frequent-words",
            "split-array-into-consecutive-subsequences",
            "sort-characters-by-frequency",
            "kth-largest-element-in-an-array"
        ],
        [
            "Hash Table",
            "Heap"
        ]
    ],
    "Write a function that takes a string as input and reverse only the vowels of a string.": [
        "reverse-vowels-of-a-string",
        [
            "remove-vowels-from-a-string",
            "reverse-string"
        ],
        [
            "Two Pointers",
            "String"
        ]
    ],
    "Write a function that reverses a string. The input string is given as an array of characters char[].Do not allocate extra space for another array, you must do this by modifying the input array\u00a0in-place with O(1) extra memory.": [
        "reverse-string",
        [
            "reverse-string-ii",
            "reverse-vowels-of-a-string"
        ],
        [
            "Two Pointers",
            "String"
        ]
    ],
    "Given a positive integer n, break it into the sum of at least two positive integers and maximize the product of those integers. Return the maximum product you can get.": [
        "integer-break",
        [],
        [
            "Math",
            "Dynamic Programming"
        ]
    ],
    "Given an integer (signed 32 bits), write a function to check whether it is a power of 4.": [
        "power-of-four",
        [
            "power-of-three",
            "power-of-two"
        ],
        [
            "Bit Manipulation"
        ]
    ],
    "Given a nested list of integers, implement an iterator to flatten it.Each element is either an integer, or a list -- whose elements may also be integers or other lists.": [
        "flatten-nested-list-iterator",
        [
            "array-nesting",
            "mini-parser",
            "zigzag-iterator",
            "flatten-2d-vector"
        ],
        [
            "Stack",
            "Design"
        ]
    ],
    "Given a non negative integer number num. For every numbers i in the range 0 \u2264 i \u2264 num calculate the number of 1's in their binary representation and return them as an array.": [
        "counting-bits",
        [
            "number-of-1-bits"
        ],
        [
            "Dynamic Programming",
            "Bit Manipulation"
        ]
    ],
    "The thief has found himself a new place for his thievery again. There is only one entrance to this area, called the \"root.\" Besides the root, each house has one and only one parent house. After a tour, the smart thief realized that \"all houses in this place forms a binary tree\". It will automatically contact the police if two directly-linked houses were broken into on the same night.Determine the maximum amount of money the thief can rob tonight without alerting the police.": [
        "house-robber-iii",
        [
            "house-robber-ii",
            "house-robber"
        ],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given a list of unique words, return all the pairs of the\u00a0distinct indices (i, j) in the given list, so that the concatenation of the two words\u00a0words[i] + words[j] is a palindrome.\u00a0": [
        "palindrome-pairs",
        [
            "shortest-palindrome",
            "longest-palindromic-substring"
        ],
        [
            "Hash Table",
            "String",
            "Trie"
        ]
    ],
    "You are given an array x of n positive numbers. You start at point (0,0) and moves x[0] metres to the north, then x[1] metres to the west, x[2] metres to the south, x[3] metres to the east and so on. In other words, after each move your direction changes counter-clockwise.Write a one-pass algorithm with O(1) extra space to determine, if your path crosses itself, or not.\u00a0": [
        "self-crossing",
        [],
        [
            "Math"
        ]
    ],
    "Given an unsorted array return whether an increasing subsequence of length 3 exists or not in the array.Formally the function should:Return true if there exists i, j, k such that arr[i] < arr[j] < arr[k] given 0 \u2264 i < j < k \u2264 n-1 else return false.": [
        "increasing-triplet-subsequence",
        [
            "longest-increasing-subsequence"
        ],
        []
    ],
    "Given a list of airline tickets represented by pairs of departure and arrival airports [from, to], reconstruct the itinerary in order. All of the tickets belong to a man who departs from JFK. Thus, the itinerary must begin with JFK.": [
        "reconstruct-itinerary",
        [],
        [
            "Depth-first Search",
            "Graph"
        ]
    ],
    "One way to serialize a binary tree is to use pre-order traversal. When we encounter a non-null node, we record the node's value. If it is a null node, we record using a sentinel value such as #.     _9_    /   \\   3     2  / \\   / \\ 4   1  #  6/ \\ / \\   / \\# # # #   # #": [
        "verify-preorder-serialization-of-a-binary-tree",
        [],
        [
            "Stack"
        ]
    ],
    "Given a sorted positive integer array nums and an integer n, add/patch elements to the array such that any number in range [1, n] inclusive can be formed by the sum of some elements in the array. Return the minimum number of patches required.": [
        "patching-array",
        [],
        [
            "Greedy"
        ]
    ],
    "Given an integer matrix, find the length of the longest increasing path.From each cell, you can either move to four directions: left, right, up or down. You may NOT move diagonally or move outside of the boundary (i.e. wrap-around is not allowed).": [
        "longest-increasing-path-in-a-matrix",
        [],
        [
            "Depth-first Search",
            "Topological Sort",
            "Memoization"
        ]
    ],
    "Given a singly linked list, group all odd nodes together followed by the even nodes. Please note here we are talking about the node number and not the value in the nodes.You should try to do it in place. The program should run in O(1) space complexity and O(nodes) time complexity.": [
        "odd-even-linked-list",
        [
            "split-linked-list-in-parts"
        ],
        [
            "Linked List"
        ]
    ],
    "Given an integer array nums, return the number of range sums that lie in [lower, upper] inclusive.Range sum S(i, j) is defined as the sum of the elements in nums between indices i and j (i \u2264 j), inclusive.": [
        "count-of-range-sum",
        [
            "reverse-pairs",
            "count-of-smaller-numbers-after-self"
        ],
        [
            "Binary Search",
            "Divide and Conquer",
            "Sort",
            "Binary Indexed Tree",
            "Segment Tree"
        ]
    ],
    "Given an integer, write a function to determine if it is a power of three.": [
        "power-of-three",
        [
            "power-of-four",
            "power-of-two"
        ],
        [
            "Math"
        ]
    ],
    "Given an unsorted array nums, reorder it such that nums[0] < nums[1] > nums[2] < nums[3]....": [
        "wiggle-sort-ii",
        [
            "wiggle-sort",
            "kth-largest-element-in-an-array",
            "sort-colors"
        ],
        [
            "Sort"
        ]
    ],
    "You are given coins of different denominations and a total amount of money amount. Write a function to compute the fewest number of coins that you need to make up that amount. If that amount of money cannot be made up by any combination of the coins, return -1.": [
        "coin-change",
        [
            "minimum-cost-for-tickets"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Given two arrays of length m and n with digits 0-9 representing two numbers. Create the maximum number of length k <= m + n from digits of the two. The relative order of the digits from the same array must be preserved. Return an array of the k digits.": [
        "create-maximum-number",
        [
            "maximum-swap",
            "remove-k-digits"
        ],
        [
            "Dynamic Programming",
            "Greedy"
        ]
    ],
    "There are n bulbs that are initially off. You first turn on all the bulbs. Then, you turn off every second bulb. On the third round, you toggle every third bulb (turning on if it's off or turning off if it's on). For the i-th round, you toggle every i bulb. For the n-th round, you only toggle the last bulb. Find how many bulbs are on after n rounds.": [
        "bulb-switcher",
        [
            "bulb-switcher-iii",
            "minimum-number-of-k-consecutive-bit-flips",
            "bulb-switcher-ii"
        ],
        [
            "Math",
            "Brainteaser"
        ]
    ],
    "Given a string array words, find the maximum value of length(word[i]) * length(word[j]) where the two words do not share common letters. ": [
        "maximum-product-of-word-lengths",
        [],
        [
            "Bit Manipulation"
        ]
    ],
    "Given a string which contains only lowercase letters, remove duplicate letters so that every letter appears once and only once. You must make sure your result is the smallest in lexicographical order among all possible results.": [
        "remove-duplicate-letters",
        [],
        [
            "Stack",
            "Greedy"
        ]
    ],
    "You are given an integer array nums and you have to return a new counts array. The counts array has the property where counts[i] is the number of smaller elements to the right of nums[i].\u00a0": [
        "count-of-smaller-numbers-after-self",
        [
            "how-many-numbers-are-smaller-than-the-current-number",
            "reverse-pairs",
            "queue-reconstruction-by-height",
            "count-of-range-sum"
        ],
        [
            "Binary Search",
            "Divide and Conquer",
            "Sort",
            "Binary Indexed Tree",
            "Segment Tree"
        ]
    ],
    "Write a program to find the nth super ugly number.Super ugly numbers are positive numbers whose all prime factors are in the given prime list primes of size k.": [
        "super-ugly-number",
        [
            "ugly-number-ii"
        ],
        [
            "Math",
            "Heap"
        ]
    ],
    "Given n balloons, indexed from 0 to n-1. Each balloon is painted with a number on it represented by array nums. You are asked to burst all the balloons. If the you burst balloon i you will get nums[left] * nums[i] * nums[right] coins. Here left and right are adjacent indices of i. After the burst, the left and right then becomes adjacent.Find the maximum coins you can collect by bursting the balloons wisely.": [
        "burst-balloons",
        [
            "minimum-cost-to-merge-stones"
        ],
        [
            "Divide and Conquer",
            "Dynamic Programming"
        ]
    ],
    "A tree is an undirected graph in which any two vertices are connected by\u00a0exactly\u00a0one path. In other words, any connected graph without simple cycles is a tree.Given a tree of n nodes\u00a0labelled from 0 to n - 1, and an array of\u00a0n - 1\u00a0edges where edges[i] = [ai, bi] indicates that there is an undirected edge between the two nodes\u00a0ai and\u00a0bi in the tree,\u00a0you can choose any node of the tree as the root. When you select a node x as the root, the result tree has height h. Among all possible rooted trees, those with minimum height (i.e. min(h))\u00a0 are called minimum height trees (MHTs).Return a list of all MHTs' root labels.\u00a0You can return the answer in any order.The height of a rooted tree is the number of edges on the longest downward path between the root and a leaf.\u00a0": [
        "minimum-height-trees",
        [
            "course-schedule-ii",
            "course-schedule"
        ],
        [
            "Breadth-first Search",
            "Graph"
        ]
    ],
    "Say you have an array for which the ith element is the price of a given stock on day i.Design an algorithm to find the maximum profit. You may complete as many transactions as you like (ie, buy one and sell one share of the stock multiple times) with the following restrictions:You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).After you sell your stock, you cannot buy stock on next day. (ie, cooldown 1 day)": [
        "best-time-to-buy-and-sell-stock-with-cooldown",
        [
            "best-time-to-buy-and-sell-stock-ii",
            "best-time-to-buy-and-sell-stock"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Given an integer array nums, find the sum of the elements between indices i and j (i \u2264 j), inclusive.The update(i, val) function modifies nums by updating the element at index i to val.": [
        "range-sum-query-mutable",
        [
            "range-sum-query-2d-mutable",
            "range-sum-query-immutable"
        ],
        [
            "Binary Indexed Tree",
            "Segment Tree"
        ]
    ],
    "Additive number is a string whose digits can form additive sequence.A valid additive sequence should contain at least three numbers. Except for the first two numbers, each subsequent number in the sequence must be the sum of the preceding two.Given a string containing only digits '0'-'9', write a function to determine if it's an additive number.": [
        "additive-number",
        [
            "split-array-into-fibonacci-sequence"
        ],
        [
            "Backtracking"
        ]
    ],
    "Given an integer array nums, find the sum of the elements between indices i and j (i \u2264 j), inclusive.": [
        "range-sum-query-immutable",
        [
            "maximum-size-subarray-sum-equals-k",
            "range-sum-query-mutable",
            "range-sum-query-2d-immutable"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Remove the minimum number of invalid parentheses in order to make the input string valid. Return all possible results.": [
        "remove-invalid-parentheses",
        [
            "valid-parentheses"
        ],
        [
            "Depth-first Search",
            "Breadth-first Search"
        ]
    ],
    "Given an unsorted array of integers, find the length of longest increasing subsequence.": [
        "longest-increasing-subsequence",
        [
            "minimum-ascii-delete-sum-for-two-strings",
            "number-of-longest-increasing-subsequence",
            "maximum-length-of-pair-chain",
            "russian-doll-envelopes",
            "increasing-triplet-subsequence"
        ],
        [
            "Binary Search",
            "Dynamic Programming"
        ]
    ],
    "You are playing the following Bulls and Cows game with your friend: You write down a number and ask your friend to guess what the number is. Each time your friend makes a guess, you provide a hint that indicates how many digits in said guess match your secret number exactly in both digit and position (called \"bulls\") and how many digits match the secret number but locate in the wrong position (called \"cows\"). Your friend will use successive guesses and hints to eventually derive the secret number.Write a function to return a hint according to the secret number and friend's guess, use A to indicate the bulls and B to indicate the cows.\u00a0Please note that both secret number and friend's guess may contain duplicate digits.": [
        "bulls-and-cows",
        [],
        [
            "Hash Table"
        ]
    ],
    "Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.Design an algorithm to serialize and deserialize a binary tree. There is no restriction on how your serialization/deserialization algorithm should work. You just need to ensure that a binary tree can be serialized to a string and this string can be deserialized to the original tree structure.": [
        "serialize-and-deserialize-binary-tree",
        [
            "serialize-and-deserialize-n-ary-tree",
            "find-duplicate-subtrees",
            "serialize-and-deserialize-bst",
            "encode-and-decode-strings"
        ],
        [
            "Tree",
            "Design"
        ]
    ],
    "You are playing the following Nim Game with your friend: There is a heap of stones on the table, each time one of you take turns to remove 1 to 3 stones. The one who removes the last stone will be the winner. You will take the first turn to remove the stones.Both of you are very clever and have optimal strategies for the game. Write a function to determine whether you can win the game given the number of stones in the heap.": [
        "nim-game",
        [
            "flip-game-ii"
        ],
        [
            "Brainteaser",
            "Minimax"
        ]
    ],
    "Given a pattern and a string str, find if str follows the same pattern.Here follow means a full match, such that there is a bijection between a letter in pattern and a non-empty word in str.": [
        "word-pattern",
        [
            "word-pattern-ii",
            "isomorphic-strings"
        ],
        [
            "Hash Table"
        ]
    ],
    "According to the Wikipedia's article: \"The Game of Life, also known simply as Life, is a cellular automaton devised by the British mathematician John Horton Conway in 1970.\"Given a board with m by n cells, each cell has an initial state live (1) or dead (0). Each cell interacts with its eight neighbors (horizontal, vertical, diagonal) using the following four rules (taken from the above Wikipedia article):Any live cell with fewer than two live neighbors dies, as if caused by under-population.Any live cell with two or three live neighbors lives on to the next generation.Any live cell with more than three live neighbors dies, as if by over-population..Any dead cell with exactly three live neighbors becomes a live cell, as if by reproduction.Write a function to compute the next state (after one update) of the board given its current state.\u00a0The next state is created by applying the above rules simultaneously to every cell in the current state, where\u00a0births and deaths occur simultaneously.": [
        "game-of-life",
        [
            "set-matrix-zeroes"
        ],
        [
            "Array"
        ]
    ],
    "Given an array of integers nums containing\u00a0n + 1 integers where each integer is in the range [1, n] inclusive.There is only one duplicate number in nums, return this\u00a0duplicate number.Follow-ups:How can we prove that at least one duplicate number must exist in nums?\u00a0Can you solve the problem without\u00a0modifying\u00a0the array nums?Can you solve the problem using\u00a0only constant, O(1) extra space?Can you solve the problem with runtime complexity less than O(n2)?\u00a0": [
        "find-the-duplicate-number",
        [
            "set-mismatch",
            "missing-number",
            "linked-list-cycle-ii",
            "single-number",
            "first-missing-positive"
        ],
        [
            "Array",
            "Two Pointers",
            "Binary Search"
        ]
    ],
    "Given an Iterator class interface with methods: next() and hasNext(), design and implement a PeekingIterator that support the peek() operation -- it essentially peek() at the element that will be returned by the next call to next().": [
        "peeking-iterator",
        [
            "zigzag-iterator",
            "flatten-2d-vector",
            "binary-search-tree-iterator"
        ],
        [
            "Design"
        ]
    ],
    "Given an array nums, write a function to move all 0's to the end of it while maintaining the relative order of the non-zero elements.": [
        "move-zeroes",
        [
            "remove-element"
        ],
        [
            "Array",
            "Two Pointers"
        ]
    ],
    "Given a string that contains only digits 0-9 and a target value, return all possibilities to add binary operators (not unary) +, -, or * between the digits so they evaluate to the target value.": [
        "expression-add-operators",
        [
            "target-sum",
            "different-ways-to-add-parentheses",
            "basic-calculator-ii",
            "basic-calculator",
            "evaluate-reverse-polish-notation"
        ],
        [
            "Divide and Conquer"
        ]
    ],
    "Given a positive integer n, find the least number of perfect square numbers (for example, 1, 4, 9, 16, ...) which sum to n.": [
        "perfect-squares",
        [
            "ugly-number-ii",
            "count-primes"
        ],
        [
            "Math",
            "Dynamic Programming",
            "Breadth-first Search"
        ]
    ],
    "You are a product manager and currently leading a team to develop a new product. Unfortunately, the latest version of your product fails the quality check. Since each version is developed based on the previous version, all the versions after a bad version are also bad.": [
        "first-bad-version",
        [
            "guess-number-higher-or-lower",
            "search-insert-position",
            "find-first-and-last-position-of-element-in-sorted-array"
        ],
        [
            "Binary Search"
        ]
    ],
    "Given an array of citations sorted\u00a0in ascending order (each citation is a non-negative integer) of a researcher, write a function to compute the researcher's h-index.According to the\u00a0definition of h-index on Wikipedia: \"A scientist has index\u00a0h\u00a0if\u00a0h\u00a0of his/her\u00a0N\u00a0papers have\u00a0at least\u00a0h\u00a0citations each, and the other\u00a0N \u2212 h\u00a0papers have\u00a0no more than\u00a0h\u00a0citations each.\"": [
        "h-index-ii",
        [
            "h-index"
        ],
        [
            "Binary Search"
        ]
    ],
    "Given an array of citations (each citation is a non-negative integer) of a researcher, write a function to compute the researcher's h-index.According to the definition of h-index on Wikipedia: \"A scientist has index h if h of his/her N papers have at least h citations each, and the other N \u2212 h papers have no more than h citations each.\"": [
        "h-index",
        [
            "h-index-ii"
        ],
        [
            "Hash Table",
            "Sort"
        ]
    ],
    "Convert a non-negative integer to its english words representation. Given input is guaranteed to be less than 231 - 1.": [
        "integer-to-english-words",
        [
            "integer-to-roman"
        ],
        [
            "Math",
            "String"
        ]
    ],
    "Given an array containing n distinct numbers taken from 0, 1, 2, ..., n, find the one that is missing from the array.": [
        "missing-number",
        [
            "couples-holding-hands",
            "find-the-duplicate-number",
            "single-number",
            "first-missing-positive"
        ],
        [
            "Array",
            "Math",
            "Bit Manipulation"
        ]
    ],
    "Write a program to find the n-th ugly number.Ugly numbers are positive numbers whose prime factors only include 2, 3, 5.\u00a0": [
        "ugly-number-ii",
        [
            "ugly-number-iii",
            "super-ugly-number",
            "perfect-squares",
            "ugly-number",
            "count-primes",
            "merge-k-sorted-lists"
        ],
        [
            "Math",
            "Dynamic Programming",
            "Heap"
        ]
    ],
    "Write a program to check whether a given number is an ugly number.Ugly numbers are positive numbers whose prime factors only include 2, 3, 5.": [
        "ugly-number",
        [
            "ugly-number-ii",
            "count-primes",
            "happy-number"
        ],
        [
            "Math"
        ]
    ],
    "Given an integer array nums, in which exactly two elements appear only once and all the other elements appear exactly twice. Find the two elements that appear only once. You can return the answer in any order.": [
        "single-number-iii",
        [
            "single-number-ii",
            "single-number"
        ],
        [
            "Bit Manipulation"
        ]
    ],
    "Given a non-negative integer num, repeatedly add all its digits until the result has only one digit.": [
        "add-digits",
        [
            "sum-of-digits-in-the-minimum-number",
            "happy-number"
        ],
        [
            "Math"
        ]
    ],
    "Given a binary tree, return all root-to-leaf paths.": [
        "binary-tree-paths",
        [
            "smallest-string-starting-from-leaf",
            "path-sum-ii"
        ],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given two strings s and t\u00a0, write a function to determine if t is an anagram of s.": [
        "valid-anagram",
        [
            "find-all-anagrams-in-a-string",
            "palindrome-permutation",
            "group-anagrams"
        ],
        [
            "Hash Table",
            "Sort"
        ]
    ],
    "Given a string of numbers and operators, return all possible results from computing all the different possible ways to group numbers and operators. The valid operators are +, - and *.": [
        "different-ways-to-add-parentheses",
        [
            "expression-add-operators",
            "basic-calculator",
            "unique-binary-search-trees-ii"
        ],
        [
            "Divide and Conquer"
        ]
    ],
    "Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties:Integers in each row are sorted in ascending from left to right.Integers in each column are sorted in ascending from top to bottom.": [
        "search-a-2d-matrix-ii",
        [
            "search-a-2d-matrix"
        ],
        [
            "Binary Search",
            "Divide and Conquer"
        ]
    ],
    "Given an array nums, there is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves right by one position. Return the max sliding window.": [
        "sliding-window-maximum",
        [
            "paint-house-ii",
            "longest-substring-with-at-most-two-distinct-characters",
            "min-stack",
            "minimum-window-substring"
        ],
        [
            "Heap",
            "Sliding Window"
        ]
    ],
    "Given an array nums of n integers where n > 1, \u00a0return an array output such that output[i] is equal to the product of all the elements of nums except nums[i].": [
        "product-of-array-except-self",
        [
            "paint-house-ii",
            "maximum-product-subarray",
            "trapping-rain-water"
        ],
        [
            "Array"
        ]
    ],
    "Write a function to delete a node in a singly-linked list. You will not be given access to the head of the list, instead you will be given access to the node to be deleted directly.It is guaranteed that the node to be deleted is not a tail node in the list.\u00a0": [
        "delete-node-in-a-linked-list",
        [
            "remove-linked-list-elements"
        ],
        [
            "Linked List"
        ]
    ],
    "Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.According to the definition of LCA on Wikipedia: \u201cThe lowest common ancestor is defined between two nodes p\u00a0and q\u00a0as the lowest node in T that has both p\u00a0and q\u00a0as descendants (where we allow a node to be a descendant of itself).\u201dGiven the following binary tree:\u00a0 root =\u00a0[3,5,1,6,2,0,8,null,null,7,4]\u00a0": [
        "lowest-common-ancestor-of-a-binary-tree",
        [
            "smallest-common-region",
            "lowest-common-ancestor-of-a-binary-search-tree"
        ],
        [
            "Tree"
        ]
    ],
    "Given a binary search tree (BST), find the lowest common ancestor (LCA) of two given nodes in the BST.According to the definition of LCA on Wikipedia: \u201cThe lowest common ancestor is defined between two nodes p and q\u00a0as the lowest node in T that has both p and q\u00a0as descendants (where we allow a node to be a descendant of itself).\u201dGiven binary search tree:\u00a0 root =\u00a0[6,2,8,0,4,7,9,null,null,3,5]\u00a0": [
        "lowest-common-ancestor-of-a-binary-search-tree",
        [
            "smallest-common-region",
            "lowest-common-ancestor-of-a-binary-tree"
        ],
        [
            "Tree"
        ]
    ],
    "Given a singly linked list, determine if it is a palindrome.": [
        "palindrome-linked-list",
        [
            "reverse-linked-list",
            "valid-palindrome",
            "palindrome-number"
        ],
        [
            "Linked List",
            "Two Pointers"
        ]
    ],
    "Given an integer n, count the total number of digit 1 appearing in all non-negative integers less than or equal to n.": [
        "number-of-digit-one",
        [
            "digit-count-in-range",
            "factorial-trailing-zeroes"
        ],
        [
            "Math"
        ]
    ],
    "Implement the following operations of a queue using stacks.": [
        "implement-queue-using-stacks",
        [
            "implement-stack-using-queues"
        ],
        [
            "Stack",
            "Design"
        ]
    ],
    "Given an integer, write a function to determine if it is a power of two.": [
        "power-of-two",
        [
            "power-of-four",
            "power-of-three",
            "number-of-1-bits"
        ],
        [
            "Math",
            "Bit Manipulation"
        ]
    ],
    "Given a binary search tree, write a function kthSmallest to find the kth smallest element in it.\u00a0": [
        "kth-smallest-element-in-a-bst",
        [
            "second-minimum-node-in-a-binary-tree",
            "binary-tree-inorder-traversal"
        ],
        [
            "Binary Search",
            "Tree"
        ]
    ],
    "Given an integer array of size n, find all elements that appear more than \u230a n/3 \u230b times.": [
        "majority-element-ii",
        [
            "check-if-a-number-is-majority-element-in-a-sorted-array",
            "majority-element"
        ],
        [
            "Array"
        ]
    ],
    "Given a sorted integer array without duplicates, return the summary of its ranges.": [
        "summary-ranges",
        [
            "data-stream-as-disjoint-intervals",
            "missing-ranges"
        ],
        [
            "Array"
        ]
    ],
    "Implement a basic calculator to evaluate a simple expression string.The expression string contains only non-negative integers, +, -, *, / operators and empty spaces  . The integer division should truncate toward zero.": [
        "basic-calculator-ii",
        [
            "basic-calculator-iii",
            "expression-add-operators",
            "basic-calculator"
        ],
        [
            "String"
        ]
    ],
    "Invert a binary tree.": [
        "invert-binary-tree",
        [],
        [
            "Tree"
        ]
    ],
    "Implement the following operations of a stack using queues.": [
        "implement-stack-using-queues",
        [
            "implement-queue-using-stacks"
        ],
        [
            "Stack",
            "Design"
        ]
    ],
    "Implement a basic calculator to evaluate a simple expression string.The expression string may contain open ( and closing parentheses ), the plus + or minus sign -, non-negative integers and empty spaces  .": [
        "basic-calculator",
        [
            "basic-calculator-iii",
            "expression-add-operators",
            "different-ways-to-add-parentheses",
            "basic-calculator-ii",
            "evaluate-reverse-polish-notation"
        ],
        [
            "Math",
            "Stack"
        ]
    ],
    "Find the total area covered by two rectilinear rectangles in a 2D plane.Each rectangle is defined by its bottom left corner and top right corner as shown in the figure.": [
        "rectangle-area",
        [
            "rectangle-overlap"
        ],
        [
            "Math"
        ]
    ],
    "Given a complete binary tree, count the number of nodes.": [
        "count-complete-tree-nodes",
        [
            "closest-binary-search-tree-value"
        ],
        [
            "Binary Search",
            "Tree"
        ]
    ],
    "Given a 2D binary matrix filled with 0's and 1's, find the largest square containing only 1's and return its area.": [
        "maximal-square",
        [
            "largest-plus-sign",
            "maximal-rectangle"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Given an array of integers, find out whether there are two distinct indices i and j in the array such that the absolute difference between nums[i] and nums[j] is at most t and the absolute difference between i and j is at most k.\u00a0": [
        "contains-duplicate-iii",
        [
            "contains-duplicate-ii",
            "contains-duplicate"
        ],
        [
            "Sort",
            "Ordered Map"
        ]
    ],
    "Given an array of integers and an integer k, find out whether there are two distinct indices i and j in the array such that nums[i] = nums[j] and the absolute difference between i and j is at most k.": [
        "contains-duplicate-ii",
        [
            "contains-duplicate-iii",
            "contains-duplicate"
        ],
        [
            "Array",
            "Hash Table"
        ]
    ],
    "A city's skyline is the outer contour of the silhouette formed by all the buildings in that city when viewed from a distance. Now suppose you are given the locations and height of all the buildings as shown on a cityscape photo (Figure A), write a program to output the skyline formed by these buildings collectively (Figure B).    The geometric information of each building is represented by a triplet of integers [Li, Ri, Hi], where Li and Ri are the x coordinates of the left and right edge of the ith building, respectively, and Hi is its height. It is guaranteed that 0 \u2264 Li, Ri \u2264 INT_MAX, 0 < Hi \u2264 INT_MAX, and Ri - Li > 0. ": [
        "the-skyline-problem",
        [
            "falling-squares"
        ],
        [
            "Divide and Conquer",
            "Heap",
            "Binary Indexed Tree",
            "Segment Tree",
            "Line Sweep"
        ]
    ],
    "Given an array of integers, find if the array contains any duplicates.Your function should return true if any value appears at least twice in the array, and it should return false if every element is distinct.": [
        "contains-duplicate",
        [
            "contains-duplicate-iii",
            "contains-duplicate-ii"
        ],
        [
            "Array",
            "Hash Table"
        ]
    ],
    "Find all possible combinations of k numbers that add up to a number n, given that only numbers from 1 to 9 can be used and each combination should be a unique set of numbers.": [
        "combination-sum-iii",
        [
            "combination-sum"
        ],
        [
            "Array",
            "Backtracking"
        ]
    ],
    "Find the kth largest element in an unsorted array. ": [
        "kth-largest-element-in-an-array",
        [
            "k-closest-points-to-origin",
            "kth-largest-element-in-a-stream",
            "third-maximum-number",
            "top-k-frequent-elements",
            "wiggle-sort-ii"
        ],
        [
            "Divide and Conquer",
            "Heap"
        ]
    ],
    "Given a string s, you are allowed to convert it to a palindrome by adding characters in front of it. Find and return the shortest palindrome you can find by performing this transformation.": [
        "shortest-palindrome",
        [
            "palindrome-pairs",
            "implement-strstr",
            "longest-palindromic-substring"
        ],
        [
            "String"
        ]
    ],
    "You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed. All houses at this place are arranged in a circle. That means the first house is the neighbor of the last one. Meanwhile, adjacent houses have security system connected and\u00a0it will automatically contact the police if two adjacent houses were broken into on the same night.Given a list of non-negative integers representing the amount of money of each house, determine the maximum amount of money you can rob tonight without alerting the police.": [
        "house-robber-ii",
        [
            "coin-path",
            "non-negative-integers-without-consecutive-ones",
            "house-robber-iii",
            "paint-fence",
            "paint-house",
            "house-robber"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Given a 2D board and a list of words from the dictionary, find all words in the board.Each word must be constructed from letters of sequentially adjacent cell, where \"adjacent\" cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once in a word.\u00a0": [
        "word-search-ii",
        [
            "unique-paths-iii",
            "word-search"
        ],
        [
            "Backtracking",
            "Trie"
        ]
    ],
    "Design a data structure that supports adding new words and finding if a string matches any previously added string.Implement the WordDictionary class:WordDictionary()\u00a0Initializes the object.void addWord(word) Adds word to the data structure, it can be matched later.bool search(word)\u00a0Returns true if there is any string in the data structure that matches word\u00a0or false otherwise. word may contain dots '.' where dots can be matched with any letter.\u00a0": [
        "design-add-and-search-words-data-structure",
        [
            "prefix-and-suffix-search",
            "implement-trie-prefix-tree"
        ],
        [
            "Backtracking",
            "Design",
            "Trie"
        ]
    ],
    "There are a total of n courses you have to take labelled from 0 to n - 1.Some courses may have prerequisites, for example, if\u00a0prerequisites[i] = [ai, bi]\u00a0this means you must take the course bi before the course ai.Given the total number of courses\u00a0numCourses and a list of the prerequisite pairs, return the ordering of courses you should take to finish all courses.If there are many valid answers, return any of them.\u00a0If it is impossible to finish all courses, return an empty array.\u00a0": [
        "course-schedule-ii",
        [
            "course-schedule-iii",
            "sequence-reconstruction",
            "minimum-height-trees",
            "alien-dictionary",
            "course-schedule"
        ],
        [
            "Depth-first Search",
            "Breadth-first Search",
            "Graph",
            "Topological Sort"
        ]
    ],
    "Given an array of n positive integers and a positive integer s, find the minimal length of a contiguous subarray of which the sum \u2265 s. If there isn't one, return 0 instead.": [
        "minimum-size-subarray-sum",
        [
            "maximum-length-of-repeated-subarray",
            "maximum-size-subarray-sum-equals-k",
            "minimum-window-substring"
        ],
        [
            "Array",
            "Two Pointers",
            "Binary Search"
        ]
    ],
    "Implement a trie with insert, search, and startsWith methods.": [
        "implement-trie-prefix-tree",
        [
            "implement-magic-dictionary",
            "replace-words",
            "design-search-autocomplete-system",
            "design-add-and-search-words-data-structure"
        ],
        [
            "Design",
            "Trie"
        ]
    ],
    "There are a total of numCourses courses you have to take, labeled from 0 to numCourses-1.Some courses may have prerequisites, for example to take course 0 you have to first take course 1, which is expressed as a pair: [0,1]Given the total number of courses and a list of prerequisite pairs, is it possible for you to finish all courses?\u00a0": [
        "course-schedule",
        [
            "course-schedule-iii",
            "minimum-height-trees",
            "graph-valid-tree",
            "course-schedule-ii"
        ],
        [
            "Depth-first Search",
            "Breadth-first Search",
            "Graph",
            "Topological Sort"
        ]
    ],
    "Reverse a singly linked list.": [
        "reverse-linked-list",
        [
            "palindrome-linked-list",
            "binary-tree-upside-down",
            "reverse-linked-list-ii"
        ],
        [
            "Linked List"
        ]
    ],
    "Given two strings s and t, determine if they are isomorphic.Two strings are isomorphic if the characters in s can be replaced to get t.All occurrences of a character must be replaced with another character while preserving the order of characters. No two characters may map to the same character but a character may map to itself.": [
        "isomorphic-strings",
        [
            "word-pattern"
        ],
        [
            "Hash Table"
        ]
    ],
    "Count the number of prime numbers less than a non-negative number, n.": [
        "count-primes",
        [
            "perfect-squares",
            "ugly-number-ii",
            "ugly-number"
        ],
        [
            "Hash Table",
            "Math"
        ]
    ],
    "Remove all elements from a linked list of integers that have value val.": [
        "remove-linked-list-elements",
        [
            "delete-node-in-a-linked-list",
            "remove-element"
        ],
        [
            "Linked List"
        ]
    ],
    "Write an algorithm to determine if a number n is \"happy\".A happy number is a number defined by the following process: Starting with any positive integer, replace the number by the sum of the squares of its digits, and repeat the process until the number equals 1 (where it will stay), or it loops endlessly in a cycle which does not include 1. Those numbers for which this process ends in 1 are happy numbers.Return True if n is a happy number, and False if not.": [
        "happy-number",
        [
            "ugly-number",
            "add-digits",
            "linked-list-cycle"
        ],
        [
            "Hash Table",
            "Math"
        ]
    ],
    "Given a range [m, n] where 0 <= m <= n <= 2147483647, return the bitwise AND of all numbers in this range, inclusive.": [
        "bitwise-and-of-numbers-range",
        [],
        [
            "Bit Manipulation"
        ]
    ],
    "Given a 2d grid map of '1's (land) and '0's (water), count the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. ": [
        "number-of-islands",
        [
            "max-area-of-island",
            "number-of-distinct-islands",
            "number-of-connected-components-in-an-undirected-graph",
            "number-of-islands-ii",
            "walls-and-gates",
            "surrounded-regions"
        ],
        [
            "Depth-first Search",
            "Breadth-first Search",
            "Union Find"
        ]
    ],
    "Given a binary tree, imagine yourself standing on the right side of it, return the values of the nodes you can see ordered from top to bottom.": [
        "binary-tree-right-side-view",
        [
            "boundary-of-binary-tree",
            "populating-next-right-pointers-in-each-node"
        ],
        [
            "Tree",
            "Depth-first Search",
            "Breadth-first Search"
        ]
    ],
    "You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security system connected and it will automatically contact the police if two adjacent houses were broken into on the same night.Given a list of non-negative integers representing the amount of money of each house, determine the maximum amount of money you can rob tonight without alerting the police.\u00a0": [
        "house-robber",
        [
            "delete-and-earn",
            "coin-path",
            "non-negative-integers-without-consecutive-ones",
            "house-robber-iii",
            "paint-fence",
            "paint-house",
            "house-robber-ii",
            "maximum-product-subarray"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Write a function that takes an unsigned integer and return\u00a0the number of '1'\u00a0bits it has (also known as the Hamming weight).\u00a0": [
        "number-of-1-bits",
        [
            "prime-number-of-set-bits-in-binary-representation",
            "binary-number-with-alternating-bits",
            "hamming-distance",
            "binary-watch",
            "counting-bits",
            "power-of-two",
            "reverse-bits"
        ],
        [
            "Bit Manipulation"
        ]
    ],
    "Reverse bits of a given 32 bits unsigned integer.\u00a0": [
        "reverse-bits",
        [
            "number-of-1-bits",
            "reverse-integer"
        ],
        [
            "Bit Manipulation"
        ]
    ],
    "Given an array, rotate the array to the right by k steps, where\u00a0k\u00a0is non-negative.": [
        "rotate-array",
        [
            "reverse-words-in-a-string-ii",
            "rotate-list"
        ],
        [
            "Array"
        ]
    ],
    "Say you have an array for which the i-th\u00a0element is the price of a given stock on day i.Design an algorithm to find the maximum profit. You may complete at most k transactions.": [
        "best-time-to-buy-and-sell-stock-iv",
        [
            "best-time-to-buy-and-sell-stock-iii",
            "best-time-to-buy-and-sell-stock-ii",
            "best-time-to-buy-and-sell-stock"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "All DNA is composed of a series of nucleotides abbreviated as A, C, G, and T, for example: \"ACGAATTCCG\". When studying DNA, it is sometimes useful to identify repeated sequences within the DNA.Write a function to find all the 10-letter-long sequences (substrings) that occur more than once in a DNA molecule.": [
        "repeated-dna-sequences",
        [],
        [
            "Hash Table",
            "Bit Manipulation"
        ]
    ],
    "Given a list of non negative integers, arrange them such that they form the largest number.": [
        "largest-number",
        [],
        [
            "Sort"
        ]
    ],
    "table.dungeon, .dungeon th, .dungeon td {  border:3px solid black;} .dungeon th, .dungeon td {    text-align: center;    height: 70px;    width: 70px;}The demons had captured the princess (P) and imprisoned her in the bottom-right corner of a dungeon. The dungeon consists of M x N rooms laid out in a 2D grid. Our valiant knight (K) was initially positioned in the top-left room and must fight his way through the dungeon to rescue the princess.The knight has an initial health point represented by a positive integer. If at any point his health point drops to 0 or below, he dies immediately.Some of the rooms are guarded by demons, so the knight loses health (negative integers) upon entering these rooms; other rooms are either empty (0's) or contain magic orbs that increase the knight's health (positive integers).In order to reach the princess as quickly as possible, the knight decides to move only rightward or downward in each step.\u00a0Write a function to determine the knight's minimum initial health so that he is able to rescue the princess.": [
        "dungeon-game",
        [
            "cherry-pickup",
            "minimum-path-sum",
            "unique-paths"
        ],
        [
            "Binary Search",
            "Dynamic Programming"
        ]
    ],
    "Implement an iterator over a binary search tree (BST). Your iterator will be initialized with the root node of a BST.Calling next() will return the next smallest number in the BST.\u00a0": [
        "binary-search-tree-iterator",
        [
            "inorder-successor-in-bst",
            "peeking-iterator",
            "zigzag-iterator",
            "flatten-2d-vector",
            "binary-tree-inorder-traversal"
        ],
        [
            "Stack",
            "Tree",
            "Design"
        ]
    ],
    "Given an integer n, return the number of trailing zeroes in n!.": [
        "factorial-trailing-zeroes",
        [
            "preimage-size-of-factorial-zeroes-function",
            "number-of-digit-one"
        ],
        [
            "Math"
        ]
    ],
    "Given a column title as appear in an Excel sheet, return its corresponding column number.": [
        "excel-sheet-column-number",
        [
            "excel-sheet-column-title"
        ],
        [
            "Math"
        ]
    ],
    "Given an array of size n, find the majority element. The majority element is the element that appears more than \u230a n/2 \u230b times.": [
        "majority-element",
        [
            "check-if-a-number-is-majority-element-in-a-sorted-array",
            "majority-element-ii"
        ],
        [
            "Array",
            "Divide and Conquer",
            "Bit Manipulation"
        ]
    ],
    "Given a positive integer, return its corresponding column title as appear in an Excel sheet.": [
        "excel-sheet-column-title",
        [
            "excel-sheet-column-number"
        ],
        [
            "Math"
        ]
    ],
    "Given an array of integers that is already sorted in ascending order, find two numbers such that they add up to a specific target number.The function twoSum should return indices of the two numbers such that they add up to the target, where index1 must be less than index2.": [
        "two-sum-ii-input-array-is-sorted",
        [
            "two-sum-less-than-k",
            "two-sum-iv-input-is-a-bst",
            "two-sum"
        ],
        [
            "Array",
            "Two Pointers",
            "Binary Search"
        ]
    ],
    "Given two integers representing the numerator and denominator of a fraction, return the fraction in string format.If the fractional part is repeating, enclose the repeating part in parentheses.If multiple answers are possible, just return any of them.": [
        "fraction-to-recurring-decimal",
        [],
        [
            "Hash Table",
            "Math"
        ]
    ],
    "Compare two version numbers version1 and version2.If version1 > version2 return 1;\u00a0if version1 < version2 return -1;otherwise return 0.": [
        "compare-version-numbers",
        [],
        [
            "String"
        ]
    ],
    "Given an unsorted array, find the maximum difference between the successive elements in its sorted form.Return 0 if the array contains less than 2 elements.": [
        "maximum-gap",
        [],
        [
            "Sort"
        ]
    ],
    "A peak element is an element that is greater than its neighbors.Given an input array nums, where nums[i] \u2260 nums[i+1], find a peak element and return its index.The array may contain multiple peaks, in that case return the index to any one of the peaks is fine.You may imagine that nums[-1] = nums[n] = -\u221e.": [
        "find-peak-element",
        [
            "peak-index-in-a-mountain-array"
        ],
        [
            "Array",
            "Binary Search"
        ]
    ],
    "Write a program to find the node at which the intersection of two singly linked lists begins.": [
        "intersection-of-two-linked-lists",
        [
            "minimum-index-sum-of-two-lists"
        ],
        [
            "Linked List"
        ]
    ],
    "Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.": [
        "min-stack",
        [
            "max-stack",
            "sliding-window-maximum"
        ],
        [
            "Stack",
            "Design"
        ]
    ],
    "Given an integer array\u00a0nums, find the contiguous subarray within an array (containing at least one number) which has the largest product.": [
        "maximum-product-subarray",
        [
            "subarray-product-less-than-k",
            "maximum-product-of-three-numbers",
            "product-of-array-except-self",
            "house-robber",
            "maximum-subarray"
        ],
        [
            "Array",
            "Dynamic Programming"
        ]
    ],
    "Given an input string, reverse the string word by word.\u00a0": [
        "reverse-words-in-a-string",
        [
            "reverse-words-in-a-string-ii"
        ],
        [
            "String"
        ]
    ],
    "Evaluate the value of an arithmetic expression in Reverse Polish Notation.Valid operators are +, -, *, /. Each operand may be an integer or another expression.": [
        "evaluate-reverse-polish-notation",
        [
            "expression-add-operators",
            "basic-calculator"
        ],
        [
            "Stack"
        ]
    ],
    "Given n points on a 2D plane, find the maximum number of points that lie on the same straight line.": [
        "max-points-on-a-line",
        [
            "line-reflection"
        ],
        [
            "Hash Table",
            "Math"
        ]
    ],
    "Sort a linked list in O(n log n) time using constant space complexity.": [
        "sort-list",
        [
            "insertion-sort-list",
            "sort-colors",
            "merge-two-sorted-lists"
        ],
        [
            "Linked List",
            "Sort"
        ]
    ],
    "Sort a linked list using insertion sort.A graphical example of insertion sort. The partial sorted list (black) initially contains only the first element in the list.With each iteration one element (red) is removed from the input data and inserted in-place into the sorted list\u00a0Algorithm of Insertion Sort:Insertion sort iterates, consuming one input element each repetition, and growing a sorted output list.At each iteration, insertion sort removes one element from the input data, finds the location it belongs within the sorted list, and inserts it there.It repeats until no input elements remain.": [
        "insertion-sort-list",
        [
            "insert-into-a-sorted-circular-linked-list",
            "sort-list"
        ],
        [
            "Linked List",
            "Sort"
        ]
    ],
    "Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and put.get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.put(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.The cache is initialized with a positive capacity.": [
        "lru-cache",
        [
            "design-compressed-string-iterator",
            "design-in-memory-file-system",
            "lfu-cache"
        ],
        [
            "Design"
        ]
    ],
    "Given the root of a\u00a0binary tree, return the postorder traversal of its nodes' values.": [
        "binary-tree-postorder-traversal",
        [
            "n-ary-tree-postorder-traversal",
            "binary-tree-inorder-traversal"
        ],
        [
            "Stack",
            "Tree"
        ]
    ],
    "Given a binary tree, return the preorder traversal of its nodes' values.": [
        "binary-tree-preorder-traversal",
        [
            "n-ary-tree-preorder-traversal",
            "verify-preorder-sequence-in-binary-search-tree",
            "binary-tree-inorder-traversal"
        ],
        [
            "Stack",
            "Tree"
        ]
    ],
    "Given a singly linked list L: L0\u2192L1\u2192\u2026\u2192Ln-1\u2192Ln,reorder it to: L0\u2192Ln\u2192L1\u2192Ln-1\u2192L2\u2192Ln-2\u2192\u2026You may not modify the values in the list's nodes, only nodes itself may be changed.": [
        "reorder-list",
        [],
        [
            "Linked List"
        ]
    ],
    "Given a linked list, return the node where the cycle begins. If there is no cycle, return null.To represent a cycle in the given linked list, we use an integer pos which represents the position (0-indexed)\u00a0in the linked list where tail connects to. If pos is -1, then there is no cycle in the linked list.": [
        "linked-list-cycle-ii",
        [
            "find-the-duplicate-number",
            "linked-list-cycle"
        ],
        [
            "Linked List",
            "Two Pointers"
        ]
    ],
    "Given a linked list, determine if it has a cycle in it.To represent a cycle in the given linked list, we use an integer pos which represents the position (0-indexed)\u00a0in the linked list where the tail connects to. If pos\u00a0==\u00a0-1, then there is no cycle in the linked list.": [
        "linked-list-cycle",
        [
            "happy-number",
            "linked-list-cycle-ii"
        ],
        [
            "Linked List",
            "Two Pointers"
        ]
    ],
    "Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, add spaces in s to construct a sentence where each word is a valid dictionary word.\u00a0Return all such possible sentences.": [
        "word-break-ii",
        [
            "concatenated-words",
            "word-break"
        ],
        [
            "Dynamic Programming",
            "Backtracking"
        ]
    ],
    "Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, determine if s can be segmented into a space-separated sequence of one or more dictionary words.": [
        "word-break",
        [
            "word-break-ii"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "A linked list is given such that each node contains an additional random pointer which could point to any node in the list or null.Return a deep copy of the list.The Linked List is represented in the input/output as a list of n nodes. Each node is represented as a pair of [val, random_index] where:val: an integer representing Node.valrandom_index: the index of the node (range from 0 to n-1) where random pointer points to, or null if it does not point to any node.\u00a0": [
        "copy-list-with-random-pointer",
        [
            "clone-n-ary-tree",
            "clone-binary-tree-with-random-pointer",
            "clone-graph"
        ],
        [
            "Hash Table",
            "Linked List"
        ]
    ],
    "Given a non-empty\u00a0array of integers, every element appears three times except for one, which appears exactly once. Find that single one.": [
        "single-number-ii",
        [
            "single-number-iii",
            "single-number"
        ],
        [
            "Bit Manipulation"
        ]
    ],
    "Given a non-empty\u00a0array of integers, every element appears twice except for one. Find that single one.": [
        "single-number",
        [
            "find-the-difference",
            "find-the-duplicate-number",
            "missing-number",
            "single-number-iii",
            "single-number-ii"
        ],
        [
            "Hash Table",
            "Bit Manipulation"
        ]
    ],
    "There are N children standing in a line. Each child is assigned a rating value.You are giving candies to these children subjected to the following requirements:Each child must have at least one candy.Children with a higher rating get more candies than their neighbors.What is the minimum candies you must give?": [
        "candy",
        [],
        [
            "Greedy"
        ]
    ],
    "There are N gas stations along a circular route, where the amount of gas at station i is gas[i].You have a car with an unlimited gas tank and it costs cost[i] of gas to travel from station i to its next station (i+1). You begin the journey with an empty tank at one of the gas stations.Return the starting gas station's index if you can travel around the circuit once in the clockwise direction, otherwise return -1.": [
        "gas-station",
        [],
        [
            "Greedy"
        ]
    ],
    "Given a reference of a node in a\u00a0connected\u00a0undirected graph.Return a deep copy (clone) of the graph.Each node in the graph contains a val (int) and a list (List[Node]) of its neighbors.class Node {    public int val;    public List<Node> neighbors;}\u00a0Test case format:For simplicity sake, each\u00a0node's value is the same as the node's index (1-indexed). ": [
        "clone-graph",
        [
            "clone-n-ary-tree",
            "clone-binary-tree-with-random-pointer",
            "copy-list-with-random-pointer"
        ],
        [
            "Depth-first Search",
            "Breadth-first Search",
            "Graph"
        ]
    ],
    "Given a string s, partition s such that every substring of the partition is a palindrome.Return the minimum cuts needed for a palindrome partitioning of s.\u00a0": [
        "palindrome-partitioning-ii",
        [
            "palindrome-partitioning"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Given a string s, partition s such that every substring of the partition is a palindrome.Return all possible palindrome partitioning of s.": [
        "palindrome-partitioning",
        [
            "palindrome-partitioning-ii"
        ],
        [
            "Backtracking"
        ]
    ],
    "Given a 2D board containing 'X' and 'O' (the letter O), capture all regions surrounded by 'X'.A region is captured by flipping all 'O's into 'X's in that surrounded region.": [
        "surrounded-regions",
        [
            "walls-and-gates",
            "number-of-islands"
        ],
        [
            "Depth-first Search",
            "Breadth-first Search",
            "Union Find"
        ]
    ],
    "Given a binary tree containing digits from 0-9 only, each root-to-leaf path could represent a number.An example is the root-to-leaf path 1->2->3 which represents the number 123.Find the total sum of all root-to-leaf numbers.": [
        "sum-root-to-leaf-numbers",
        [
            "smallest-string-starting-from-leaf",
            "binary-tree-maximum-path-sum",
            "path-sum"
        ],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given an unsorted array of integers, find the length of the longest consecutive elements sequence.Your algorithm should run in O(n) complexity.": [
        "longest-consecutive-sequence",
        [
            "binary-tree-longest-consecutive-sequence"
        ],
        [
            "Array",
            "Union Find"
        ]
    ],
    "Given two words (beginWord and endWord), and a dictionary's word list, find the length of shortest transformation sequence from beginWord to endWord, such that:Only one letter can be changed at a time.Each transformed word must exist in the word list.": [
        "word-ladder",
        [
            "minimum-genetic-mutation",
            "word-ladder-ii"
        ],
        [
            "Breadth-first Search"
        ]
    ],
    "Given two words (beginWord and endWord), and a dictionary's word list, find all shortest transformation sequence(s) from beginWord to endWord, such that:Only one letter can be changed at a timeEach transformed word must exist in the word list. ": [
        "word-ladder-ii",
        [
            "word-ladder"
        ],
        [
            "Array",
            "String",
            "Backtracking",
            "Breadth-first Search"
        ]
    ],
    "Given a string, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases.": [
        "valid-palindrome",
        [
            "valid-palindrome-ii",
            "palindrome-linked-list"
        ],
        [
            "Two Pointers",
            "String"
        ]
    ],
    "Given a non-empty binary tree, find the maximum path sum.For this problem, a path is defined as any sequence of nodes from some starting node to any node in the tree along the parent-child connections. The path must contain at least one node and does not need to go through the root.": [
        "binary-tree-maximum-path-sum",
        [
            "time-needed-to-inform-all-employees",
            "longest-univalue-path",
            "path-sum-iv",
            "sum-root-to-leaf-numbers",
            "path-sum"
        ],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Say you have an array for which the ith element is the price of a given stock on day i.Design an algorithm to find the maximum profit. You may complete at most two transactions.": [
        "best-time-to-buy-and-sell-stock-iii",
        [
            "maximum-sum-of-3-non-overlapping-subarrays",
            "best-time-to-buy-and-sell-stock-iv",
            "best-time-to-buy-and-sell-stock-ii",
            "best-time-to-buy-and-sell-stock"
        ],
        [
            "Array",
            "Dynamic Programming"
        ]
    ],
    "Say you have an array prices for which the ith element is the price of a given stock on day i.Design an algorithm to find the maximum profit. You may complete as many transactions as you like (i.e., buy one and sell one share of the stock multiple times).": [
        "best-time-to-buy-and-sell-stock-ii",
        [
            "best-time-to-buy-and-sell-stock-with-transaction-fee",
            "best-time-to-buy-and-sell-stock-with-cooldown",
            "best-time-to-buy-and-sell-stock-iv",
            "best-time-to-buy-and-sell-stock-iii",
            "best-time-to-buy-and-sell-stock"
        ],
        [
            "Array",
            "Greedy"
        ]
    ],
    "Say you have an array for which the ith element is the price of a given stock on day i.If you were only permitted to complete at most one transaction (i.e., buy one and sell one share of the stock), design an algorithm to find the maximum profit.": [
        "best-time-to-buy-and-sell-stock",
        [
            "best-time-to-buy-and-sell-stock-with-cooldown",
            "best-time-to-buy-and-sell-stock-iv",
            "best-time-to-buy-and-sell-stock-iii",
            "best-time-to-buy-and-sell-stock-ii",
            "maximum-subarray"
        ],
        [
            "Array",
            "Dynamic Programming"
        ]
    ],
    "Given a triangle, find the minimum path sum from top to bottom. Each step you may move to adjacent numbers on the row below.": [
        "triangle",
        [],
        [
            "Array",
            "Dynamic Programming"
        ]
    ],
    "Given an integer rowIndex, return the rowIndexth\u00a0row of the Pascal's triangle.Notice\u00a0that the row index starts from\u00a00.In Pascal's triangle, each number is the sum of the two numbers directly above it.": [
        "pascals-triangle-ii",
        [
            "pascals-triangle"
        ],
        [
            "Array"
        ]
    ],
    "Given a non-negative integer\u00a0numRows, generate the first numRows of Pascal's triangle.In Pascal's triangle, each number is the sum of the two numbers directly above it.": [
        "pascals-triangle",
        [
            "pascals-triangle-ii"
        ],
        [
            "Array"
        ]
    ],
    "Given a binary treestruct Node {  int val;  Node *left;  Node *right;  Node *next;}Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to NULL.Initially, all next pointers are set to NULL.\u00a0": [
        "populating-next-right-pointers-in-each-node-ii",
        [
            "populating-next-right-pointers-in-each-node"
        ],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "You are given a perfect binary tree\u00a0where\u00a0all leaves are on the same level, and every parent has two children. The binary tree has the following definition:struct Node {  int val;  Node *left;  Node *right;  Node *next;}Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to NULL.Initially, all next pointers are set to NULL.\u00a0": [
        "populating-next-right-pointers-in-each-node",
        [
            "binary-tree-right-side-view",
            "populating-next-right-pointers-in-each-node-ii"
        ],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given a string S and a string T, count the number of distinct subsequences of S which equals T.A subsequence of a string is a new string which is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie, \"ACE\" is a subsequence of \"ABCDE\" while \"AEC\" is not).It's guaranteed the answer fits on a 32-bit signed integer.": [
        "distinct-subsequences",
        [],
        [
            "String",
            "Dynamic Programming"
        ]
    ],
    "Given a binary tree, flatten it to a linked list in-place.": [
        "flatten-binary-tree-to-linked-list",
        [
            "flatten-a-multilevel-doubly-linked-list"
        ],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given a binary tree and a sum, find all root-to-leaf paths where each path's sum equals the given sum.": [
        "path-sum-ii",
        [
            "path-sum-iv",
            "path-sum-iii",
            "binary-tree-paths",
            "path-sum"
        ],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum.": [
        "path-sum",
        [
            "path-sum-iv",
            "path-sum-iii",
            "sum-root-to-leaf-numbers",
            "binary-tree-maximum-path-sum",
            "path-sum-ii"
        ],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given a binary tree, find its minimum depth.The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.": [
        "minimum-depth-of-binary-tree",
        [
            "maximum-depth-of-binary-tree",
            "binary-tree-level-order-traversal"
        ],
        [
            "Tree",
            "Depth-first Search",
            "Breadth-first Search"
        ]
    ],
    "Given a binary tree, determine if it is height-balanced.For this problem, a height-balanced binary tree is defined as:a binary tree in which the left and right subtrees of every node differ in height by no more than 1.\u00a0": [
        "balanced-binary-tree",
        [
            "maximum-depth-of-binary-tree"
        ],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given the head of a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST.For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.\u00a0": [
        "convert-sorted-list-to-binary-search-tree",
        [
            "convert-sorted-array-to-binary-search-tree"
        ],
        [
            "Linked List",
            "Depth-first Search"
        ]
    ],
    "Given an array where elements are sorted in ascending order, convert it to a height balanced BST.For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.": [
        "convert-sorted-array-to-binary-search-tree",
        [
            "convert-sorted-list-to-binary-search-tree"
        ],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given a binary tree, return the bottom-up level order traversal of its nodes' values. (ie, from left to right, level by level from leaf to root).": [
        "binary-tree-level-order-traversal-ii",
        [
            "average-of-levels-in-binary-tree",
            "binary-tree-level-order-traversal"
        ],
        [
            "Tree",
            "Breadth-first Search"
        ]
    ],
    "Given inorder and postorder traversal of a tree, construct the binary tree.": [
        "construct-binary-tree-from-inorder-and-postorder-traversal",
        [
            "construct-binary-tree-from-preorder-and-inorder-traversal"
        ],
        [
            "Array",
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given preorder and inorder traversal of a tree, construct the binary tree.": [
        "construct-binary-tree-from-preorder-and-inorder-traversal",
        [
            "construct-binary-tree-from-inorder-and-postorder-traversal"
        ],
        [
            "Array",
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given a binary tree, find its maximum depth.The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.": [
        "maximum-depth-of-binary-tree",
        [
            "time-needed-to-inform-all-employees",
            "maximum-depth-of-n-ary-tree",
            "minimum-depth-of-binary-tree",
            "balanced-binary-tree"
        ],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given a binary tree, return the zigzag level order traversal of its nodes' values. (ie, from left to right, then right to left for the next level and alternate between).": [
        "binary-tree-zigzag-level-order-traversal",
        [
            "binary-tree-level-order-traversal"
        ],
        [
            "Stack",
            "Tree",
            "Breadth-first Search"
        ]
    ],
    "Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).": [
        "binary-tree-level-order-traversal",
        [
            "cousins-in-binary-tree",
            "n-ary-tree-level-order-traversal",
            "average-of-levels-in-binary-tree",
            "binary-tree-vertical-order-traversal",
            "minimum-depth-of-binary-tree",
            "binary-tree-level-order-traversal-ii",
            "binary-tree-zigzag-level-order-traversal"
        ],
        [
            "Tree",
            "Breadth-first Search"
        ]
    ],
    "Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).": [
        "symmetric-tree",
        [],
        [
            "Tree",
            "Depth-first Search",
            "Breadth-first Search"
        ]
    ],
    "Given two binary trees, write a function to check if they are the same or not.Two binary trees are considered the same if they are structurally identical and the nodes have the same value.": [
        "same-tree",
        [],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Two elements of a binary search tree (BST) are swapped by mistake.Recover the tree without changing its structure.": [
        "recover-binary-search-tree",
        [],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given a binary tree, determine if it is a valid binary search tree (BST).Assume a BST is defined as follows:The left subtree of a node contains only nodes with keys less than the node's key.The right subtree of a node contains only nodes with keys greater than the node's key.Both the left and right subtrees must also be binary search trees.\u00a0": [
        "validate-binary-search-tree",
        [
            "find-mode-in-binary-search-tree",
            "binary-tree-inorder-traversal"
        ],
        [
            "Tree",
            "Depth-first Search"
        ]
    ],
    "Given s1, s2, and s3, find whether s3 is formed by the interleaving of s1 and s2.\u00a0": [
        "interleaving-string",
        [],
        [
            "String",
            "Dynamic Programming"
        ]
    ],
    "Given n, how many structurally unique BST's (binary search trees) that store values 1 ...\u00a0n?": [
        "unique-binary-search-trees",
        [
            "unique-binary-search-trees-ii"
        ],
        [
            "Dynamic Programming",
            "Tree"
        ]
    ],
    "Given an integer n, generate all structurally unique BST's (binary search trees) that store values 1 ...\u00a0n.": [
        "unique-binary-search-trees-ii",
        [
            "different-ways-to-add-parentheses",
            "unique-binary-search-trees"
        ],
        [
            "Dynamic Programming",
            "Tree"
        ]
    ],
    "Given a binary tree, return the inorder traversal of its nodes' values.": [
        "binary-tree-inorder-traversal",
        [
            "minimum-distance-between-bst-nodes",
            "convert-binary-search-tree-to-sorted-doubly-linked-list",
            "inorder-successor-in-bst",
            "closest-binary-search-tree-value-ii",
            "kth-smallest-element-in-a-bst",
            "binary-search-tree-iterator",
            "binary-tree-postorder-traversal",
            "binary-tree-preorder-traversal",
            "validate-binary-search-tree"
        ],
        [
            "Hash Table",
            "Stack",
            "Tree"
        ]
    ],
    "Given a string s containing only digits, return all possible valid IP addresses that can be obtained from s. You can return them in any order.A valid IP address consists of exactly four integers, each integer is between 0 and 255, separated by single dots and cannot have leading zeros. ": [
        "restore-ip-addresses",
        [
            "ip-to-cidr"
        ],
        [
            "String",
            "Backtracking"
        ]
    ],
    "Reverse a linked list from position m to n. Do it in one-pass.": [
        "reverse-linked-list-ii",
        [
            "reverse-linked-list"
        ],
        [
            "Linked List"
        ]
    ],
    "A message containing letters from A-Z is being encoded to numbers using the following mapping:'A' -> 1'B' -> 2...'Z' -> 26Given a non-empty string containing only digits, determine the total number of ways to decode it.": [
        "decode-ways",
        [
            "decode-ways-ii"
        ],
        [
            "String",
            "Dynamic Programming"
        ]
    ],
    "Given a collection of integers that might contain duplicates, nums, return all possible subsets (the power set).": [
        "subsets-ii",
        [
            "subsets"
        ],
        [
            "Array",
            "Backtracking"
        ]
    ],
    "The gray code is a binary numeral system where two successive values differ in only one bit.Given a non-negative integer n representing the total number of bits in the code, print the sequence of gray code. A gray code sequence must begin with 0.": [
        "gray-code",
        [
            "1-bit-and-2-bit-characters"
        ],
        [
            "Backtracking"
        ]
    ],
    "Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array.": [
        "merge-sorted-array",
        [
            "interval-list-intersections",
            "squares-of-a-sorted-array",
            "merge-two-sorted-lists"
        ],
        [
            "Array",
            "Two Pointers"
        ]
    ],
    "We can scramble a string s to get a string t using the following algorithm:If the length of the string is 1, stop.If the length of the string is > 1, do the following:\tSplit the string into 2 non-empty substrings at a random index, i.e. if the string is s, divide it to x and y where s = x + y.Randomly, decide to swap the two substrings or to keep them in the same order. i.e. after this step, s may become s = x + y or s = y + x.Apply step 1 recursively on each of the two substrings x and y.Given two strings s1 and s2 of the same length, return true if s2 is a scrambled string of s1, otherwise, return false.\u00a0": [
        "scramble-string",
        [],
        [
            "String",
            "Dynamic Programming"
        ]
    ],
    "Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.You should preserve the original relative order of the nodes in each of the two partitions.": [
        "partition-list",
        [],
        [
            "Linked List",
            "Two Pointers"
        ]
    ],
    "Given a 2D binary matrix filled with 0's and 1's, find the largest rectangle containing only 1's and return its area.": [
        "maximal-rectangle",
        [
            "maximal-square",
            "largest-rectangle-in-histogram"
        ],
        [
            "Array",
            "Hash Table",
            "Dynamic Programming",
            "Stack"
        ]
    ],
    "Given n non-negative integers representing the histogram's bar height where the width of each bar is 1, find the area of largest rectangle in the histogram.\u00a0Above is a histogram where width of each bar is 1, given height = [2,1,5,6,2,3].\u00a0The largest rectangle is shown in the shaded area, which has area = 10 unit.\u00a0": [
        "largest-rectangle-in-histogram",
        [
            "maximal-rectangle"
        ],
        [
            "Array",
            "Stack"
        ]
    ],
    "Given a sorted linked list, delete all duplicates such that each element appear only once.": [
        "remove-duplicates-from-sorted-list",
        [
            "remove-duplicates-from-sorted-list-ii"
        ],
        [
            "Linked List"
        ]
    ],
    "Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list.Return the linked list sorted as well.": [
        "remove-duplicates-from-sorted-list-ii",
        [
            "remove-duplicates-from-sorted-list"
        ],
        [
            "Linked List"
        ]
    ],
    "Given a sorted array nums, remove the duplicates in-place such that duplicates appeared at most\u00a0twice and return the new length.Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.": [
        "remove-duplicates-from-sorted-array-ii",
        [
            "remove-duplicates-from-sorted-array"
        ],
        [
            "Array",
            "Two Pointers"
        ]
    ],
    "Given a 2D board and a word, find if the word exists in the grid.The word can be constructed from letters of sequentially adjacent cell, where \"adjacent\" cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once.": [
        "word-search",
        [
            "word-search-ii"
        ],
        [
            "Array",
            "Backtracking"
        ]
    ],
    "Given a set of distinct integers, nums, return all possible subsets (the power set).": [
        "subsets",
        [
            "letter-case-permutation",
            "generalized-abbreviation",
            "subsets-ii"
        ],
        [
            "Array",
            "Backtracking",
            "Bit Manipulation"
        ]
    ],
    "Given two integers n and k, return all possible combinations of k numbers out of 1 ... n.You may return the answer in any order.\u00a0": [
        "combinations",
        [
            "permutations",
            "combination-sum"
        ],
        [
            "Backtracking"
        ]
    ],
    "Given a string S and a string T, find the minimum window in S which will contain all the characters in T in complexity O(n).": [
        "minimum-window-substring",
        [
            "minimum-window-subsequence",
            "smallest-range-covering-elements-from-k-lists",
            "permutation-in-string",
            "sliding-window-maximum",
            "minimum-size-subarray-sum",
            "substring-with-concatenation-of-all-words"
        ],
        [
            "Hash Table",
            "Two Pointers",
            "String",
            "Sliding Window"
        ]
    ],
    "Given an array with n objects colored red, white or blue, sort them in-place\u00a0so that objects of the same color are adjacent, with the colors in the order red, white and blue.Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.": [
        "sort-colors",
        [
            "wiggle-sort-ii",
            "wiggle-sort",
            "sort-list"
        ],
        [
            "Array",
            "Two Pointers",
            "Sort"
        ]
    ],
    "Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties:Integers in each row are sorted from left to right.The first integer of each row is greater than the last integer of the previous row.": [
        "search-a-2d-matrix",
        [
            "search-a-2d-matrix-ii"
        ],
        [
            "Array",
            "Binary Search"
        ]
    ],
    "Given an\u00a0m x n matrix. If an element is 0, set its entire row and column to 0. Do it in-place.": [
        "set-matrix-zeroes",
        [
            "game-of-life"
        ],
        [
            "Array"
        ]
    ],
    "Given two words word1 and word2, find the minimum number of operations required to convert word1 to word2.You have the following 3 operations permitted on a word:Insert a characterDelete a characterReplace a character": [
        "edit-distance",
        [
            "uncrossed-lines",
            "minimum-ascii-delete-sum-for-two-strings",
            "delete-operation-for-two-strings",
            "one-edit-distance"
        ],
        [
            "String",
            "Dynamic Programming"
        ]
    ],
    "Given an absolute path for a file (Unix-style), simplify it. Or in other words, convert it to the canonical path.In a UNIX-style file system, a period .\u00a0refers to the current directory. Furthermore, a double period ..\u00a0moves the directory up a level.": [
        "simplify-path",
        [],
        [
            "String",
            "Stack"
        ]
    ],
    "You are climbing a stair case. It takes n steps to reach to the top.Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?": [
        "climbing-stairs",
        [
            "n-th-tribonacci-number",
            "fibonacci-number",
            "min-cost-climbing-stairs"
        ],
        [
            "Dynamic Programming"
        ]
    ],
    "Implement int sqrt(int x).Compute and return the square root of x, where\u00a0x\u00a0is guaranteed to be a non-negative integer.Since the return type\u00a0is an integer, the decimal digits are truncated and only the integer part of the result\u00a0is returned.": [
        "sqrtx",
        [
            "valid-perfect-square",
            "powx-n"
        ],
        [
            "Math",
            "Binary Search"
        ]
    ],
    "Given an array of words and a width\u00a0maxWidth, format the text such that each line has exactly maxWidth characters and is fully (left and right) justified.You should pack your words in a greedy approach; that is, pack as many words as you can in each line. Pad extra spaces ' ' when necessary so that each line has exactly maxWidth characters.Extra spaces between words should be distributed as evenly as possible. If the number of spaces on a line do not divide evenly between words, the empty slots on the left will be assigned more spaces than the slots on the right.For the last line of text, it should be left justified and no extra space is inserted between words.": [
        "text-justification",
        [],
        [
            "String"
        ]
    ],
    "Given two binary strings, return their sum (also a binary string).The input strings are both non-empty and contains only characters 1 or\u00a00.": [
        "add-binary",
        [
            "add-to-array-form-of-integer",
            "plus-one",
            "multiply-strings",
            "add-two-numbers"
        ],
        [
            "Math",
            "String"
        ]
    ],
    "Given a non-empty array of digits\u00a0representing a non-negative integer, increment\u00a0one to the integer.The digits are stored such that the most significant digit is at the head of the list, and each element in the array contains a single digit.": [
        "plus-one",
        [
            "add-to-array-form-of-integer",
            "plus-one-linked-list",
            "add-binary",
            "multiply-strings"
        ],
        [
            "Array"
        ]
    ],
    "Validate if a given string can be interpreted as\u00a0a decimal number.Some examples:\"0\" => true\" 0.1 \" => true\"abc\" => false\"1 a\" => false\"2e10\" => true\" -90e3\u00a0 \u00a0\" => true\" 1e\" => false\"e3\" => false\" 6e-1\" => true\" 99e2.5\u00a0\" => false\"53.5e93\" => true\" --6 \" => false\"-+3\" => false\"95a54e53\" => false": [
        "valid-number",
        [
            "string-to-integer-atoi"
        ],
        [
            "Math",
            "String"
        ]
    ],
    "Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum of all numbers along its path.": [
        "minimum-path-sum",
        [
            "cherry-pickup",
            "dungeon-game",
            "unique-paths"
        ],
        [
            "Array",
            "Dynamic Programming"
        ]
    ],
    "A robot is located at the top-left corner of a m x n grid (marked 'Start' in the diagram below).The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).Now consider if some obstacles are added to the grids. How many unique paths would there be?An obstacle and empty space is marked as 1 and 0 respectively in the grid.": [
        "unique-paths-ii",
        [
            "unique-paths-iii",
            "unique-paths"
        ],
        [
            "Array",
            "Dynamic Programming"
        ]
    ],
    "A robot is located at the top-left corner of a m x n grid (marked 'Start' in the diagram below).The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).How many possible unique paths are there?Above is a 7 x 3 grid. How many possible unique paths are there?\u00a0": [
        "unique-paths",
        [
            "dungeon-game",
            "minimum-path-sum",
            "unique-paths-ii"
        ],
        [
            "Array",
            "Dynamic Programming"
        ]
    ],
    "Given a linked\u00a0list, rotate the list to the right by k places, where k is non-negative.": [
        "rotate-list",
        [
            "split-linked-list-in-parts",
            "rotate-array"
        ],
        [
            "Linked List",
            "Two Pointers"
        ]
    ],
    "The set [1,2,3,...,n] contains a total of n! unique permutations.By listing and labeling all of the permutations in order, we get the following sequence for n = 3:\"123\"\"132\"\"213\"\"231\"\"312\"\"321\"Given n and k, return the kth permutation sequence.": [
        "permutation-sequence",
        [
            "permutations",
            "next-permutation"
        ],
        [
            "Math",
            "Backtracking"
        ]
    ],
    "Given a positive integer n, generate a square matrix filled with elements from 1 to n2 in spiral order.": [
        "spiral-matrix-ii",
        [
            "spiral-matrix-iii",
            "spiral-matrix"
        ],
        [
            "Array"
        ]
    ],
    "Given a string s consists of upper/lower-case alphabets and empty space characters ' ', return the length of last word (last word means the last appearing word if we loop from left to right) in the string.If the last word does not exist, return 0.": [
        "length-of-last-word",
        [],
        [
            "String"
        ]
    ],
    "Given a set of non-overlapping intervals, insert a new interval into the intervals (merge if necessary).": [
        "insert-interval",
        [
            "range-module",
            "merge-intervals"
        ],
        [
            "Array",
            "Sort"
        ]
    ],
    "Given a collection of intervals, merge all overlapping intervals.": [
        "merge-intervals",
        [
            "interval-list-intersections",
            "partition-labels",
            "employee-free-time",
            "range-module",
            "add-bold-tag-in-string",
            "teemo-attacking",
            "meeting-rooms-ii",
            "meeting-rooms",
            "insert-interval"
        ],
        [
            "Array",
            "Sort"
        ]
    ],
    "Given an array of non-negative integers, you are initially positioned at the first index of the array.Each element in the array represents your maximum jump length at that position.Determine if you are able to reach the last index.\u00a0": [
        "jump-game",
        [
            "jump-game-iii",
            "jump-game-ii"
        ],
        [
            "Array",
            "Greedy"
        ]
    ],
    "Given a matrix of m x n elements (m rows, n columns), return all elements of the matrix in spiral order.": [
        "spiral-matrix",
        [
            "spiral-matrix-iii",
            "spiral-matrix-ii"
        ],
        [
            "Array"
        ]
    ],
    "Given an integer array nums, find the contiguous subarray\u00a0(containing at least one number) which has the largest sum and return its sum.": [
        "maximum-subarray",
        [
            "longest-turbulent-subarray",
            "degree-of-an-array",
            "maximum-product-subarray",
            "best-time-to-buy-and-sell-stock"
        ],
        [
            "Array",
            "Divide and Conquer",
            "Dynamic Programming"
        ]
    ],
    "The n-queens puzzle is the problem of placing n queens on an n\u00d7n chessboard such that no two queens attack each other.Given an integer\u00a0n, return the number of\u00a0distinct solutions to the\u00a0n-queens puzzle.": [
        "n-queens-ii",
        [
            "n-queens"
        ],
        [
            "Backtracking"
        ]
    ],
    "The n-queens puzzle is the problem of placing n queens on an n\u00d7n chessboard such that no two queens attack each other.Given an integer n, return all distinct solutions to the n-queens puzzle.Each solution contains a distinct board configuration of the n-queens' placement, where 'Q' and '.' both indicate a queen and an empty space respectively.": [
        "n-queens",
        [
            "grid-illumination",
            "n-queens-ii"
        ],
        [
            "Backtracking"
        ]
    ],
    "Implement pow(x, n), which calculates\u00a0x raised to the power n (i.e. xn).\u00a0": [
        "powx-n",
        [
            "super-pow",
            "sqrtx"
        ],
        [
            "Math",
            "Binary Search"
        ]
    ],
    "Given an array of strings strs, group the anagrams together. You can return the answer in any order.An Anagram is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.\u00a0": [
        "group-anagrams",
        [
            "group-shifted-strings",
            "valid-anagram"
        ],
        [
            "Hash Table",
            "String"
        ]
    ],
    "You are given an n x n 2D matrix representing an image, rotate the image by 90 degrees (clockwise).You have to rotate the image in-place, which means you have to modify the input 2D matrix directly. DO NOT allocate another 2D matrix and do the rotation.\u00a0": [
        "rotate-image",
        [],
        [
            "Array"
        ]
    ],
    "Given a collection of numbers that might contain duplicates, return all possible unique permutations.": [
        "permutations-ii",
        [
            "number-of-squareful-arrays",
            "palindrome-permutation-ii",
            "permutations",
            "next-permutation"
        ],
        [
            "Backtracking"
        ]
    ],
    "Given a collection of distinct integers, return all possible permutations.": [
        "permutations",
        [
            "combinations",
            "permutation-sequence",
            "permutations-ii",
            "next-permutation"
        ],
        [
            "Backtracking"
        ]
    ],
    "Given an array of non-negative integers, you are initially positioned at the first index of the array.Each element in the array represents your maximum jump length at that position.Your goal is to reach the last index in the minimum number of jumps.": [
        "jump-game-ii",
        [
            "jump-game-iii",
            "jump-game"
        ],
        [
            "Array",
            "Greedy"
        ]
    ],
    "Given an input string (s) and a pattern (p), implement wildcard pattern matching with support for '?' and '*'.'?' Matches any single character.'*' Matches any sequence of characters (including the empty sequence).The matching should cover the entire input string (not partial).": [
        "wildcard-matching",
        [
            "regular-expression-matching"
        ],
        [
            "String",
            "Dynamic Programming",
            "Backtracking",
            "Greedy"
        ]
    ],
    "Given two non-negative integers num1 and num2 represented as strings, return the product of num1 and num2, also represented as a string.": [
        "multiply-strings",
        [
            "add-strings",
            "add-binary",
            "plus-one",
            "add-two-numbers"
        ],
        [
            "Math",
            "String"
        ]
    ],
    "Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it is able to trap after raining.The above elevation map is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped. Thanks Marcos for contributing this image!": [
        "trapping-rain-water",
        [
            "pour-water",
            "trapping-rain-water-ii",
            "product-of-array-except-self",
            "container-with-most-water"
        ],
        [
            "Array",
            "Two Pointers",
            "Stack"
        ]
    ],
    "Given an unsorted integer array, find the smallest missing\u00a0positive integer.": [
        "first-missing-positive",
        [
            "couples-holding-hands",
            "find-all-numbers-disappeared-in-an-array",
            "find-the-duplicate-number",
            "missing-number"
        ],
        [
            "Array"
        ]
    ],
    "Given a collection of candidate numbers (candidates) and a target number (target), find all unique combinations in candidates\u00a0where the candidate numbers sums to target.Each number in candidates\u00a0may only be used once in the combination.": [
        "combination-sum-ii",
        [
            "combination-sum"
        ],
        [
            "Array",
            "Backtracking"
        ]
    ],
    "Given a set of candidate numbers (candidates) (without duplicates) and a target number (target), find all unique combinations in candidates\u00a0where the candidate numbers sums to target.The same repeated number may be chosen from candidates\u00a0unlimited number of times.": [
        "combination-sum",
        [
            "combination-sum-iv",
            "factor-combinations",
            "combination-sum-iii",
            "combinations",
            "combination-sum-ii",
            "letter-combinations-of-a-phone-number"
        ],
        [
            "Array",
            "Backtracking"
        ]
    ],
    "The count-and-say sequence is the sequence of integers with the first five terms as following:1.     12.     113.     214.     12115.     1112211 is read off as \"one 1\" or 11.11 is read off as \"two 1s\" or 21.21 is read off as \"one 2, then one 1\" or 1211.Given an integer n\u00a0where 1 \u2264 n \u2264 30, generate the nth term of the count-and-say sequence. You can do so recursively, in other words from the previous member\u00a0read off the digits, counting the number of digits in groups of the same digit.": [
        "count-and-say",
        [
            "string-compression",
            "encode-and-decode-strings"
        ],
        [
            "String"
        ]
    ],
    "Write a program to solve a Sudoku puzzle by filling the empty cells.A\u00a0sudoku solution must satisfy all of\u00a0the following rules:Each of the digits\u00a01-9 must occur exactly\u00a0once in each row.Each of the digits\u00a01-9\u00a0must occur\u00a0exactly once in each column.Each of the the digits\u00a01-9 must occur exactly once in each of the 9 3x3 sub-boxes of the grid.Empty cells are indicated by the character '.'.A sudoku puzzle......and its solution numbers marked in red.": [
        "sudoku-solver",
        [
            "unique-paths-iii",
            "valid-sudoku"
        ],
        [
            "Hash Table",
            "Backtracking"
        ]
    ],
    "Determine if a\u00a09x9 Sudoku board\u00a0is valid.\u00a0Only the filled cells need to be validated\u00a0according to the following rules:Each row\u00a0must contain the\u00a0digits\u00a01-9 without repetition.Each column must contain the digits\u00a01-9\u00a0without repetition.Each of the 9 3x3 sub-boxes of the grid must contain the digits\u00a01-9\u00a0without repetition.A partially filled sudoku which is valid.The Sudoku board could be partially filled, where empty cells are filled with the character '.'.": [
        "valid-sudoku",
        [
            "sudoku-solver"
        ],
        [
            "Hash Table"
        ]
    ],
    "Given a sorted array and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.": [
        "search-insert-position",
        [
            "first-bad-version"
        ],
        [
            "Array",
            "Binary Search"
        ]
    ],
    "Given an array of integers nums sorted in ascending order, find the starting and ending position of a given target value.Your algorithm's runtime complexity must be in the order of O(log n).If the target is not found in the array, return [-1, -1].": [
        "find-first-and-last-position-of-element-in-sorted-array",
        [
            "first-bad-version"
        ],
        [
            "Array",
            "Binary Search"
        ]
    ],
    "You are given an integer array nums sorted in ascending order, and an integer target.": [
        "search-in-rotated-sorted-array",
        [
            "find-minimum-in-rotated-sorted-array",
            "search-in-rotated-sorted-array-ii"
        ],
        [
            "Array",
            "Binary Search"
        ]
    ],
    "Given a string containing just the characters '(' and ')', find the length of the longest valid (well-formed) parentheses substring.": [
        "longest-valid-parentheses",
        [
            "valid-parentheses"
        ],
        [
            "String",
            "Dynamic Programming"
        ]
    ],
    "Implement next permutation, which rearranges numbers into the lexicographically next greater permutation of numbers.If such arrangement is not possible, it must rearrange it as the lowest possible order (ie, sorted in ascending order).The replacement must be in-place and use only constant\u00a0extra memory.Here are some examples. Inputs are in the left-hand column and its corresponding outputs are in the right-hand column.1,2,3 \u2192 1,3,23,2,1 \u2192 1,2,31,1,5 \u2192 1,5,1": [
        "next-permutation",
        [
            "palindrome-permutation-ii",
            "permutation-sequence",
            "permutations-ii",
            "permutations"
        ],
        [
            "Array"
        ]
    ],
    "You are given a string s and an array of strings words of the same length. Return\u00a0all starting indices of substring(s) in s\u00a0that is a concatenation of each word in words exactly once, in any order,\u00a0and without any intervening characters.You can return the answer in any order.\u00a0": [
        "substring-with-concatenation-of-all-words",
        [
            "minimum-window-substring"
        ],
        [
            "Hash Table",
            "Two Pointers",
            "String"
        ]
    ],
    "Given two integers dividend and divisor, divide two integers without using multiplication, division and mod operator.Return the quotient after dividing dividend by divisor.The integer division should truncate toward zero, which means losing its fractional part. ": [
        "divide-two-integers",
        [],
        [
            "Math",
            "Binary Search"
        ]
    ],
    "Implement strStr().Return the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.": [
        "implement-strstr",
        [
            "repeated-substring-pattern",
            "shortest-palindrome"
        ],
        [
            "Two Pointers",
            "String"
        ]
    ],
    "Given an array nums and a value val, remove all instances of that value in-place and return the new length.Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.The order of elements can be changed. It doesn't matter what you leave beyond the new length.": [
        "remove-element",
        [
            "move-zeroes",
            "remove-linked-list-elements",
            "remove-duplicates-from-sorted-array"
        ],
        [
            "Array",
            "Two Pointers"
        ]
    ],
    "Given a sorted array nums, remove the duplicates in-place such that each element appear only once and return the new length.Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.": [
        "remove-duplicates-from-sorted-array",
        [
            "remove-duplicates-from-sorted-array-ii",
            "remove-element"
        ],
        [
            "Array",
            "Two Pointers"
        ]
    ],
    "Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.k is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.": [
        "reverse-nodes-in-k-group",
        [
            "swap-nodes-in-pairs"
        ],
        [
            "Linked List"
        ]
    ],
    "Given a\u00a0linked list, swap every two adjacent nodes and return its head.You may not modify the values in the list's nodes, only nodes itself may be changed.\u00a0": [
        "swap-nodes-in-pairs",
        [
            "reverse-nodes-in-k-group"
        ],
        [
            "Linked List"
        ]
    ],
    "You are given an array of k linked-lists lists, each linked-list is sorted in ascending order.Merge all the linked-lists into one sorted linked-list and return it.\u00a0": [
        "merge-k-sorted-lists",
        [
            "ugly-number-ii",
            "merge-two-sorted-lists"
        ],
        [
            "Linked List",
            "Divide and Conquer",
            "Heap"
        ]
    ],
    "Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.": [
        "generate-parentheses",
        [
            "valid-parentheses",
            "letter-combinations-of-a-phone-number"
        ],
        [
            "String",
            "Backtracking"
        ]
    ],
    "Merge two sorted linked lists and return it as a new sorted list. The new list should be made by splicing together the nodes of the first two lists.": [
        "merge-two-sorted-lists",
        [
            "shortest-word-distance-ii",
            "sort-list",
            "merge-sorted-array",
            "merge-k-sorted-lists"
        ],
        [
            "Linked List"
        ]
    ],
    "Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.An input string is valid if:Open brackets must be closed by the same type of brackets.Open brackets must be closed in the correct order.\u00a0": [
        "valid-parentheses",
        [
            "check-if-word-is-valid-after-substitutions",
            "remove-invalid-parentheses",
            "longest-valid-parentheses",
            "generate-parentheses"
        ],
        [
            "String",
            "Stack"
        ]
    ],
    "Given a linked list, remove the n-th node from the end of list and return its head.": [
        "remove-nth-node-from-end-of-list",
        [
            "delete-n-nodes-after-m-nodes-of-a-linked-list"
        ],
        [
            "Linked List",
            "Two Pointers"
        ]
    ],
    "Given an array nums of n integers and an integer target, are there elements a, b, c, and d in nums such that a + b + c + d = target? Find all unique quadruplets in the array which gives the sum of target.": [
        "4sum",
        [
            "4sum-ii",
            "3sum",
            "two-sum"
        ],
        [
            "Array",
            "Hash Table",
            "Two Pointers"
        ]
    ],
    "Given a string containing digits from 2-9 inclusive, return all possible letter combinations that the number could represent.A mapping of digit to letters (just like on the telephone buttons) is given below. ": [
        "letter-combinations-of-a-phone-number",
        [
            "binary-watch",
            "combination-sum",
            "generate-parentheses"
        ],
        [
            "String",
            "Backtracking"
        ]
    ],
    "Given an array nums of n integers and an integer target, find three integers in nums\u00a0such that the sum is closest to\u00a0target. Return the sum of the three integers. ": [
        "3sum-closest",
        [
            "3sum-smaller",
            "3sum"
        ],
        [
            "Array",
            "Two Pointers"
        ]
    ],
    "Given an array nums of n integers, are there elements a, b, c in nums such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.Notice that the solution set must not contain duplicate triplets.\u00a0": [
        "3sum",
        [
            "3sum-smaller",
            "4sum",
            "3sum-closest",
            "two-sum"
        ],
        [
            "Array",
            "Two Pointers"
        ]
    ],
    "Write a function to find the longest common prefix string amongst an array of strings.If there is no common prefix, return an empty string \"\".": [
        "longest-common-prefix",
        [],
        [
            "String"
        ]
    ],
    "Roman numerals are represented by seven different symbols:\u00a0I, V, X, L, C, D and M.Symbol       ValueI             1V             5X             10L             50C             100D             500M             1000": [
        "integer-to-roman",
        [
            "integer-to-english-words",
            "roman-to-integer"
        ],
        [
            "Math",
            "String"
        ]
    ],
    "Given n non-negative integers a1, a2, ..., an\u00a0, where each represents a point at coordinate (i, ai). n vertical lines are drawn such that the two endpoints of line i is at (i, ai) and (i, 0). Find two lines, which together with x-axis forms a container, such that the container contains the most water.": [
        "container-with-most-water",
        [
            "trapping-rain-water"
        ],
        [
            "Array",
            "Two Pointers"
        ]
    ],
    "Given an input string (s) and a pattern (p), implement regular expression matching with support for '.' and '*'.'.' Matches any single character.'*' Matches zero or more of the preceding element.The matching should cover the entire input string (not partial).": [
        "regular-expression-matching",
        [
            "wildcard-matching"
        ],
        [
            "String",
            "Dynamic Programming",
            "Backtracking"
        ]
    ],
    "Determine whether an integer is a palindrome. An integer\u00a0is\u00a0a\u00a0palindrome when it\u00a0reads the same backward as forward.": [
        "palindrome-number",
        [
            "palindrome-linked-list"
        ],
        [
            "Math"
        ]
    ],
    "Implement atoi which\u00a0converts a string to an integer.The function first discards as many whitespace characters as necessary until the first non-whitespace character is found. Then, starting from this character, takes an optional initial plus or minus sign followed by as many numerical digits as possible, and interprets them as a numerical value.The string can contain additional characters after those that form the integral number, which are ignored and have no effect on the behavior of this function.If the first sequence of non-whitespace characters in str is not a valid integral number, or if no such sequence exists because either str is empty or it contains only whitespace characters, no conversion is performed.If no valid conversion could be performed, a zero value is returned.": [
        "string-to-integer-atoi",
        [
            "valid-number",
            "reverse-integer"
        ],
        [
            "Math",
            "String"
        ]
    ],
    "Given a 32-bit signed integer, reverse digits of an integer.": [
        "reverse-integer",
        [
            "reverse-bits",
            "string-to-integer-atoi"
        ],
        [
            "Math"
        ]
    ],
    "The string \"PAYPALISHIRING\" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility)P   A   H   NA P L S I I GY   I   RAnd then read line by line: \"PAHNAPLSIIGYIR\"Write the code that will take a string and make this conversion given a number of rows:string convert(string s, int numRows);": [
        "zigzag-conversion",
        [],
        [
            "String"
        ]
    ],
    "Given a string s, find the longest palindromic substring in s. ": [
        "longest-palindromic-substring",
        [
            "palindromic-substrings",
            "longest-palindromic-subsequence",
            "palindrome-pairs",
            "palindrome-permutation",
            "shortest-palindrome"
        ],
        [
            "String",
            "Dynamic Programming"
        ]
    ],
    "Given two sorted arrays nums1 and nums2 of size m and n respectively, return the median of the two sorted arrays.": [
        "median-of-two-sorted-arrays",
        [],
        [
            "Array",
            "Binary Search",
            "Divide and Conquer"
        ]
    ],
    "Given a string s, find the length of the longest substring without repeating characters.\u00a0": [
        "longest-substring-without-repeating-characters",
        [
            "subarrays-with-k-different-integers",
            "longest-substring-with-at-most-k-distinct-characters",
            "longest-substring-with-at-most-two-distinct-characters"
        ],
        [
            "Hash Table",
            "Two Pointers",
            "String",
            "Sliding Window"
        ]
    ],
    "You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.": [
        "add-two-numbers",
        [
            "add-to-array-form-of-integer",
            "add-two-numbers-ii",
            "add-strings",
            "sum-of-two-integers",
            "add-binary",
            "multiply-strings"
        ],
        [
            "Linked List",
            "Math"
        ]
        
    ]
}