Given an integer rowIndex, return the rowIndexth (0-indexed) row of the Pascal's triangle.
+
+
In Pascal's triangle, each number is the sum of the two numbers directly above it as shown:
+
+
+
Example 1:
+
Input: rowIndex = 3
+Output: [1,3,3,1]
+
Example 2:
+
Input: rowIndex = 0
+Output: [1]
+
Example 3:
+
Input: rowIndex = 1
+Output: [1,1]
+
+
+
Constraints:
+
+
+
+
+
Follow up: Could you optimize your algorithm to use only O(rowIndex) extra space?
+
You are given the head of a singly linked-list. The list can be represented as:
+
+
L0 → L1 → … → Ln - 1 → Ln
+
+
+
Reorder the list to be on the following form:
+
+
L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …
+
+
+
You may not modify the values in the list's nodes. Only nodes themselves may be changed.
+
+
+
Example 1:
+
+
Input: head = [1,2,3,4]
+Output: [1,4,2,3]
+
+
+
Example 2:
+
+
Input: head = [1,2,3,4,5]
+Output: [1,5,2,4,3]
+
+
+
+
Constraints:
+
+
+ - The number of nodes in the list is in the range
[1, 5 * 104].
+ 1 <= Node.val <= 1000
+
Given the head of a linked list, return the list after sorting it in ascending order.
+
+
+
Example 1:
+
+
Input: head = [4,2,1,3]
+Output: [1,2,3,4]
+
+
+
Example 2:
+
+
Input: head = [-1,5,3,4,0]
+Output: [-1,0,3,4,5]
+
+
+
Example 3:
+
+
Input: head = []
+Output: []
+
+
+
+
Constraints:
+
+
+ - The number of nodes in the list is in the range
[0, 5 * 104].
+ -105 <= Node.val <= 105
+
+
+
Follow up: Can you sort the linked list in O(n logn) time and O(1) memory (i.e. constant space)?
+
Given the heads of two singly linked-lists headA and headB, return the node at which the two lists intersect. If the two linked lists have no intersection at all, return null.
+
+
For example, the following two linked lists begin to intersect at node c1:
+
+
The test cases are generated such that there are no cycles anywhere in the entire linked structure.
+
+
Note that the linked lists must retain their original structure after the function returns.
+
+
Custom Judge:
+
+
The inputs to the judge are given as follows (your program is not given these inputs):
+
+
+ intersectVal - The value of the node where the intersection occurs. This is 0 if there is no intersected node.listA - The first linked list.listB - The second linked list.skipA - The number of nodes to skip ahead in listA (starting from the head) to get to the intersected node.skipB - The number of nodes to skip ahead in listB (starting from the head) to get to the intersected node.
+
+
The judge will then create the linked structure based on these inputs and pass the two heads, headA and headB to your program. If you correctly return the intersected node, then your solution will be accepted.
+
+
+
Example 1:
+
+
Input: intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
+Output: Intersected at '8'
+Explanation: The intersected node's value is 8 (note that this must not be 0 if the two lists intersect).
+From the head of A, it reads as [4,1,8,4,5]. From the head of B, it reads as [5,6,1,8,4,5]. There are 2 nodes before the intersected node in A; There are 3 nodes before the intersected node in B.
+- Note that the intersected node's value is not 1 because the nodes with value 1 in A and B (2nd node in A and 3rd node in B) are different node references. In other words, they point to two different locations in memory, while the nodes with value 8 in A and B (3rd node in A and 4th node in B) point to the same location in memory.
+
+
+
Example 2:
+
+
Input: intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
+Output: Intersected at '2'
+Explanation: The intersected node's value is 2 (note that this must not be 0 if the two lists intersect).
+From the head of A, it reads as [1,9,1,2,4]. From the head of B, it reads as [3,2,4]. There are 3 nodes before the intersected node in A; There are 1 node before the intersected node in B.
+
+
+
Example 3:
+
+
Input: intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
+Output: No intersection
+Explanation: From the head of A, it reads as [2,6,4]. From the head of B, it reads as [1,5]. Since the two lists do not intersect, intersectVal must be 0, while skipA and skipB can be arbitrary values.
+Explanation: The two lists do not intersect, so return null.
+
+
+
+
Constraints:
+
+
+ - The number of nodes of
listA is in the m.
+ - The number of nodes of
listB is in the n.
+ 1 <= m, n <= 3 * 1041 <= Node.val <= 1050 <= skipA < m0 <= skipB < nintersectVal is 0 if listA and listB do not intersect.intersectVal == listA[skipA] == listB[skipB] if listA and listB intersect.
+
+
+
Follow up: Could you write a solution that runs in
O(m + n) time and use only
O(1) memory?
Medium
A peak element is an element that is strictly greater than its neighbors.
+
+
Given a 0-indexed integer array nums, find a peak element, and return its index. If the array contains multiple peaks, return the index to any of the peaks.
+
+
You may imagine that nums[-1] = nums[n] = -∞. In other words, an element is always considered to be strictly greater than a neighbor that is outside the array.
+
+
You must write an algorithm that runs in O(log n) time.
+
+
+
Example 1:
+
+
Input: nums = [1,2,3,1]
+Output: 2
+Explanation: 3 is a peak element and your function should return the index number 2.
+
+
Example 2:
+
+
Input: nums = [1,2,1,3,5,6,4]
+Output: 5
+Explanation: Your function can return either index number 1 where the peak element is 2, or index number 5 where the peak element is 6.
+
+
+
Constraints:
+
+
+ 1 <= nums.length <= 1000-231 <= nums[i] <= 231 - 1nums[i] != nums[i + 1] for all valid i.
+
Medium
Given two version numbers, version1 and version2, compare them.
+
+
+
+
Version numbers consist of one or more revisions joined by a dot '.'. Each revision consists of digits and may contain leading zeros. Every revision contains at least one character. Revisions are 0-indexed from left to right, with the leftmost revision being revision 0, the next revision being revision 1, and so on. For example 2.5.33 and 0.1 are valid version numbers.
+
+
To compare version numbers, compare their revisions in left-to-right order. Revisions are compared using their integer value ignoring any leading zeros. This means that revisions 1 and 001 are considered equal. If a version number does not specify a revision at an index, then treat the revision as 0. For example, version 1.0 is less than version 1.1 because their revision 0s are the same, but their revision 1s are 0 and 1 respectively, and 0 < 1.
+
+
Return the following:
+
+
+ - If
version1 < version2, return -1.
+ - If
version1 > version2, return 1.
+ - Otherwise, return
0.
+
+
+
+
Example 1:
+
+
Input: version1 = "1.01", version2 = "1.001"
+Output: 0
+Explanation: Ignoring leading zeroes, both "01" and "001" represent the same integer "1".
+
+
+
Example 2:
+
+
Input: version1 = "1.0", version2 = "1.0.0"
+Output: 0
+Explanation: version1 does not specify revision 2, which means it is treated as "0".
+
+
+
Example 3:
+
+
Input: version1 = "0.1", version2 = "1.1"
+Output: -1
+Explanation: version1's revision 0 is "0", while version2's revision 0 is "1". 0 < 1, so version1 < version2.
+
+
+
+
Constraints:
+
+
+ 1 <= version1.length, version2.length <= 500version1 and version2 only contain digits and '.'.version1 and version2 are valid version numbers.- All the given revisions in
version1 and version2 can be stored in a 32-bit integer.
+
+
Easy
Given an array nums of size n, return the majority element.
+
+
The majority element is the element that appears more than ⌊n / 2⌋ times. You may assume that the majority element always exists in the array.
+
+
+
Example 1:
+
Input: nums = [3,2,3]
+Output: 3
+
Example 2:
+
Input: nums = [2,2,1,1,1,2,2]
+Output: 2
+
+
+
Constraints:
+
+
+ n == nums.length1 <= n <= 5 * 104-109 <= nums[i] <= 109
+
+
+
Follow-up: Could you solve the problem in linear time and in
O(1) space?
Medium
Given an m x n 2D binary grid grid which represents a map of '1's (land) and '0's (water), return the number of islands.
+
+
An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.
+
+
+
Example 1:
+
+
Input: grid = [
+ ["1","1","1","1","0"],
+ ["1","1","0","1","0"],
+ ["1","1","0","0","0"],
+ ["0","0","0","0","0"]
+]
+Output: 1
+
+
+
Example 2:
+
+
Input: grid = [
+ ["1","1","0","0","0"],
+ ["1","1","0","0","0"],
+ ["0","0","1","0","0"],
+ ["0","0","0","1","1"]
+]
+Output: 3
+
+
+
+
Constraints:
+
+
+ m == grid.lengthn == grid[i].length1 <= m, n <= 300grid[i][j] is '0' or '1'.
+
Medium
Given two integers left and right that represent the range [left, right], return the bitwise AND of all numbers in this range, inclusive.
+
+
+
Example 1:
+
+
Input: left = 5, right = 7
+Output: 4
+
+
+
Example 2:
+
+
Input: left = 0, right = 0
+Output: 0
+
+
+
Example 3:
+
+
Input: left = 1, right = 2147483647
+Output: 0
+
+
+
+
Constraints:
+
+
+ 0 <= left <= right <= 231 - 1
+
Easy
Given two strings s and t, determine if they are isomorphic.
+
+
Two strings s and t 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.
+
+
+
Example 1:
+
Input: s = "egg", t = "add"
+Output: true
+
Example 2:
+
Input: s = "foo", t = "bar"
+Output: false
+
Example 3:
+
Input: s = "paper", t = "title"
+Output: true
+
+
+
Constraints:
+
+
+ 1 <= s.length <= 5 * 104t.length == s.lengths and t consist of any valid ascii character.
+
Easy
Given an integer n, return true if it is a power of two. Otherwise, return false.
+
+
An integer n is a power of two, if there exists an integer x such that n == 2x.
+
+
+
Example 1:
+
+
Input: n = 1
+Output: true
+Explanation: 20 = 1
+
+
+
Example 2:
+
+
Input: n = 16
+Output: true
+Explanation: 24 = 16
+
+
+
Example 3:
+
+
Input: n = 3
+Output: false
+
+
+
+
Constraints:
+
+
+
+
+
Follow up: Could you solve it without loops/recursion?
Easy
Given the head of a singly linked list, return true if it is a palindrome or false otherwise.
+
+
+
Example 1:
+
+
Input: head = [1,2,2,1]
+Output: true
+
+
+
Example 2:
+
+
Input: head = [1,2]
+Output: false
+
+
+
+
Constraints:
+
+
+ - The number of nodes in the list is in the range
[1, 105].
+ 0 <= Node.val <= 9
+
+
+
Follow up: Could you do it in
O(n) time and
O(1) space?
Medium
There is a singly-linked list head and we want to delete a node node in it.
+
+
You are given the node to be deleted node. You will not be given access to the first node of head.
+
+
All the values of the linked list are unique, and it is guaranteed that the given node node is not the last node in the linked list.
+
+
Delete the given node. Note that by deleting the node, we do not mean removing it from memory. We mean:
+
+
+ - The value of the given node should not exist in the linked list.
+ - The number of nodes in the linked list should decrease by one.
+ - All the values before
node should be in the same order.
+ - All the values after
node should be in the same order.
+
+
+
Custom testing:
+
+
+ - For the input, you should provide the entire linked list
head and the node to be given node. node should not be the last node of the list and should be an actual node in the list.
+ - We will build the linked list and pass the node to your function.
+ - The output will be the entire list after calling your function.
+
+
+
+
Example 1:
+
+
Input: head = [4,5,1,9], node = 5
+Output: [4,1,9]
+Explanation: You are given the second node with value 5, the linked list should become 4 -> 1 -> 9 after calling your function.
+
+
+
Example 2:
+
+
Input: head = [4,5,1,9], node = 1
+Output: [4,5,9]
+Explanation: You are given the third node with value 1, the linked list should become 4 -> 5 -> 9 after calling your function.
+
+
+
+
Constraints:
+
+
+ - The number of the nodes in the given list is in the range
[2, 1000].
+ -1000 <= Node.val <= 1000- The value of each node in the list is unique.
+ - The
node to be deleted is in the list and is not a tail node.
+
+
Medium
Given an integer array nums, return an array answer such that answer[i] is equal to the product of all the elements of nums except nums[i].
+
+
The product of any prefix or suffix of nums is guaranteed to fit in a 32-bit integer.
+
+
You must write an algorithm that runs in O(n) time and without using the division operation.
+
+
+
Example 1:
+
Input: nums = [1,2,3,4]
+Output: [24,12,8,6]
+
Example 2:
+
Input: nums = [-1,1,0,-3,3]
+Output: [0,0,9,0,0]
+
+
+
Constraints:
+
+
+ 2 <= nums.length <= 105-30 <= nums[i] <= 30- The product of any prefix or suffix of
nums is guaranteed to fit in a 32-bit integer.
+
+
+
+
Follow up: Can you solve the problem in O(1) extra space complexity? (The output array does not count as extra space for space complexity analysis.)
+
Easy
Given two strings s and t, return true if t is an anagram of s, and false otherwise.
+
+
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.
+
+
+
Example 1:
+
Input: s = "anagram", t = "nagaram"
+Output: true
+
Example 2:
+
Input: s = "rat", t = "car"
+Output: false
+
+
+
Constraints:
+
+
+ 1 <= s.length, t.length <= 5 * 104s and t consist of lowercase English letters.
+
+
+
Follow up: What if the inputs contain Unicode characters? How would you adapt your solution to such a case?
+
Medium
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.
+
+
You must write an algorithm that runs in linear runtime complexity and uses only constant extra space.
+
+
+
Example 1:
+
+
Input: nums = [1,2,1,3,2,5]
+Output: [3,5]
+Explanation: [5, 3] is also a valid answer.
+
+
+
Example 2:
+
+
Input: nums = [-1,0]
+Output: [-1,0]
+
+
+
Example 3:
+
+
Input: nums = [0,1]
+Output: [1,0]
+
+
+
+
Constraints:
+
+
+ 2 <= nums.length <= 3 * 104-231 <= nums[i] <= 231 - 1- Each integer in
nums will appear twice, only two integers will appear once.
+
+
Medium
An ugly number is a positive integer whose prime factors are limited to 2, 3, and 5.
+
+
Given an integer n, return the nth ugly number.
+
+
+
Example 1:
+
+
Input: n = 10
+Output: 12
+Explanation: [1, 2, 3, 4, 5, 6, 8, 9, 10, 12] is the sequence of the first 10 ugly numbers.
+
+
+
Example 2:
+
+
Input: n = 1
+Output: 1
+Explanation: 1 has no prime factors, therefore all of its prime factors are limited to 2, 3, and 5.
+
+
+
+
Constraints:
+
+
+
Easy
Given an array nums containing n distinct numbers in the range [0, n], return the only number in the range that is missing from the array.
+
+
+
Example 1:
+
+
Input: nums = [3,0,1]
+Output: 2
+Explanation: n = 3 since there are 3 numbers, so all numbers are in the range [0,3]. 2 is the missing number in the range since it does not appear in nums.
+
+
+
Example 2:
+
+
Input: nums = [0,1]
+Output: 2
+Explanation: n = 2 since there are 2 numbers, so all numbers are in the range [0,2]. 2 is the missing number in the range since it does not appear in nums.
+
+
+
Example 3:
+
+
Input: nums = [9,6,4,2,3,5,7,0,1]
+Output: 8
+Explanation: n = 9 since there are 9 numbers, so all numbers are in the range [0,9]. 8 is the missing number in the range since it does not appear in nums.
+
+
+
+
Constraints:
+
+
+ n == nums.length1 <= n <= 1040 <= nums[i] <= n- All the numbers of
nums are unique.
+
+
+
+
Follow up: Could you implement a solution using only O(1) extra space complexity and O(n) runtime complexity?
+
Hard
Convert a non-negative integer num to its English words representation.
+
+
+
Example 1:
+
+
Input: num = 123
+Output: "One Hundred Twenty Three"
+
+
+
Example 2:
+
+
Input: num = 12345
+Output: "Twelve Thousand Three Hundred Forty Five"
+
+
+
Example 3:
+
+
Input: num = 1234567
+Output: "One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven"
+
+
+
+
Constraints:
+
+
+
Medium
Given an integer n, return the least number of perfect square numbers that sum to n.
+
+
A perfect square is an integer that is the square of an integer; in other words, it is the product of some integer with itself. For example, 1, 4, 9, and 16 are perfect squares while 3 and 11 are not.
+
+
+
Example 1:
+
+
Input: n = 12
+Output: 3
+Explanation: 12 = 4 + 4 + 4.
+
+
+
Example 2:
+
+
Input: n = 13
+Output: 2
+Explanation: 13 = 4 + 9.
+
+
+
+
Constraints:
+
+
+
Medium
According to 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."
+
+
The board is made up of an m x n grid of cells, where each cell has an initial state: live (represented by a 1) or dead (represented by a 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.
+
+
+
The next state is created by applying the above rules simultaneously to every cell in the current state, where births and deaths occur simultaneously. Given the current state of the m x n grid board, return the next state.
+
+
+
Example 1:
+
+
Input: board = [[0,1,0],[0,0,1],[1,1,1],[0,0,0]]
+Output: [[0,0,0],[1,0,1],[0,1,1],[0,1,0]]
+
+
+
Example 2:
+
+
Input: board = [[1,1],[1,0]]
+Output: [[1,1],[1,1]]
+
+
+
+
Constraints:
+
+
+ m == board.lengthn == board[i].length1 <= m, n <= 25board[i][j] is 0 or 1.
+
+
+
Follow up:
+
+
+ - Could you solve it in-place? Remember that the board needs to be updated simultaneously: You cannot update some cells first and then use their updated values to update other cells.
+ - In this question, we represent the board using a 2D array. In principle, the board is infinite, which would cause problems when the active area encroaches upon the border of the array (i.e., live cells reach the border). How would you address these problems?
+
+
Hard
The median is the middle value in an ordered integer list. If the size of the list is even, there is no middle value, and the median is the mean of the two middle values.
+
+
+ - For example, for
arr = [2,3,4], the median is 3.
+ - For example, for
arr = [2,3], the median is (2 + 3) / 2 = 2.5.
+
+
+
Implement the MedianFinder class:
+
+
+ MedianFinder() initializes the MedianFinder object.void addNum(int num) adds the integer num from the data stream to the data structure.double findMedian() returns the median of all elements so far. Answers within 10-5 of the actual answer will be accepted.
+
+
+
Example 1:
+
+
Input
+["MedianFinder", "addNum", "addNum", "findMedian", "addNum", "findMedian"]
+[[], [1], [2], [], [3], []]
+Output
+[null, null, null, 1.5, null, 2.0]
+
+Explanation
+MedianFinder medianFinder = new MedianFinder();
+medianFinder.addNum(1); // arr = [1]
+medianFinder.addNum(2); // arr = [1, 2]
+medianFinder.findMedian(); // return 1.5 (i.e., (1 + 2) / 2)
+medianFinder.addNum(3); // arr[1, 2, 3]
+medianFinder.findMedian(); // return 2.0
+
+
+
+
Constraints:
+
+
+ -105 <= num <= 105- There will be at least one element in the data structure before calling
findMedian.
+ - At most
5 * 104 calls will be made to addNum and findMedian.
+
+
+
+
Follow up:
+
+
+ - If all integer numbers from the stream are in the range
[0, 100], how would you optimize your solution?
+ - If
99% of all integer numbers from the stream are in the range [0, 100], how would you optimize your solution?
+
+
Medium
A tree is an undirected graph in which any two vertices are connected by exactly one path. In other words, any connected graph without simple cycles is a tree.
+
+
Given a tree of n nodes labelled from 0 to n - 1, and an array of n - 1 edges where edges[i] = [ai, bi] indicates that there is an undirected edge between the two nodes ai and bi in the tree, you 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)) are called minimum height trees (MHTs).
+
+
Return a list of all MHTs' root labels. You 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.
+
+
+
Example 1:
+
+
Input: n = 4, edges = [[1,0],[1,2],[1,3]]
+Output: [1]
+Explanation: As shown, the height of the tree is 1 when the root is the node with label 1 which is the only MHT.
+
+
+
Example 2:
+
+
Input: n = 6, edges = [[3,0],[3,1],[3,2],[3,4],[5,4]]
+Output: [3,4]
+
+
+
+
Constraints:
+
+
+ 1 <= n <= 2 * 104edges.length == n - 10 <= ai, bi < nai != bi- All the pairs
(ai, bi) are distinct.
+ - The given input is guaranteed to be a tree and there will be no repeated edges.
+
+
Medium
Given an integer array nums, reorder it such that nums[0] < nums[1] > nums[2] < nums[3]....
+
+
You may assume the input array always has a valid answer.
+
+
+
Example 1:
+
+
Input: nums = [1,5,1,1,6,4]
+Output: [1,6,1,5,1,4]
+Explanation: [1,4,1,5,1,6] is also accepted.
+
+
+
Example 2:
+
+
Input: nums = [1,3,2,2,3,1]
+Output: [2,3,1,3,1,2]
+
+
+
+
Constraints:
+
+
+ 1 <= nums.length <= 5 * 1040 <= nums[i] <= 5000- It is guaranteed that there will be an answer for the given input
nums.
+
+
+
+
Follow Up: Can you do it in
O(n) time and/or
in-place with
O(1) extra space?
Hard
Given a sorted integer array nums and an integer n, add/patch elements to the array such that any number in the range [1, n] inclusive can be formed by the sum of some elements in the array.
+
+
Return the minimum number of patches required.
+
+
+
Example 1:
+
+
Input: nums = [1,3], n = 6
+Output: 1
+Explanation:
+Combinations of nums are [1], [3], [1,3], which form possible sums of: 1, 3, 4.
+Now if we add/patch 2 to nums, the combinations are: [1], [2], [3], [1,3], [2,3], [1,2,3].
+Possible sums are 1, 2, 3, 4, 5, 6, which now covers the range [1, 6].
+So we only need 1 patch.
+
+
+
Example 2:
+
+
Input: nums = [1,5,10], n = 20
+Output: 2
+Explanation: The two patches can be [2, 4].
+
+
+
Example 3:
+
+
Input: nums = [1,2,2], n = 5
+Output: 0
+
+
+
+
Constraints:
+
+
+ 1 <= nums.length <= 10001 <= nums[i] <= 104nums is sorted in ascending order.1 <= n <= 231 - 1
+
Medium
You are given a nested list of integers nestedList. Each element is either an integer or a list whose elements may also be integers or other lists. Implement an iterator to flatten it.
+
+
Implement the NestedIterator class:
+
+
+ NestedIterator(List<NestedInteger> nestedList) Initializes the iterator with the nested list nestedList.int next() Returns the next integer in the nested list.boolean hasNext() Returns true if there are still some integers in the nested list and false otherwise.
+
+
Your code will be tested with the following pseudocode:
+
+
initialize iterator with nestedList
+res = []
+while iterator.hasNext()
+ append iterator.next() to the end of res
+return res
+
+
+
If res matches the expected flattened list, then your code will be judged as correct.
+
+
+
Example 1:
+
+
Input: nestedList = [[1,1],2,[1,1]]
+Output: [1,1,2,1,1]
+Explanation: By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,1,2,1,1].
+
+
+
Example 2:
+
+
Input: nestedList = [1,[4,[6]]]
+Output: [1,4,6]
+Explanation: By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,4,6].
+
+
+
+
Constraints:
+
+
+ 1 <= nestedList.length <= 500- The values of the integers in the nested list is in the range
[-106, 106].
+
+
Easy
Given an integer n, return true if it is a power of four. Otherwise, return false.
+
+
An integer n is a power of four, if there exists an integer x such that n == 4x.
+
+
+
Example 1:
+
Input: n = 16
+Output: true
+
Example 2:
+
Input: n = 5
+Output: false
+
Example 3:
+
Input: n = 1
+Output: true
+
+
+
Constraints:
+
+
+
+
+
Follow up: Could you solve it without loops/recursion?
Medium
Given an integer n, break it into the sum of k positive integers, where k >= 2, and maximize the product of those integers.
+
+
Return the maximum product you can get.
+
+
+
Example 1:
+
+
Input: n = 2
+Output: 1
+Explanation: 2 = 1 + 1, 1 × 1 = 1.
+
+
+
Example 2:
+
+
Input: n = 10
+Output: 36
+Explanation: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36.
+
+
+
+
Constraints:
+
+
+
Easy
Write a function that reverses a string. The input string is given as an array of characters s.
+
+
You must do this by modifying the input array in-place with O(1) extra memory.
+
+
+
Example 1:
+
Input: s = ["h","e","l","l","o"]
+Output: ["o","l","l","e","h"]
+
Example 2:
+
Input: s = ["H","a","n","n","a","h"]
+Output: ["h","a","n","n","a","H"]
+
+
+
Constraints:
+
+
+
Easy
Given two integer arrays nums1 and nums2, return an array of their intersection. Each element in the result must be unique and you may return the result in any order.
+
+
+
Example 1:
+
+
Input: nums1 = [1,2,2,1], nums2 = [2,2]
+Output: [2]
+
+
+
Example 2:
+
+
Input: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
+Output: [9,4]
+Explanation: [4,9] is also accepted.
+
+
+
+
Constraints:
+
+
+ 1 <= nums1.length, nums2.length <= 10000 <= nums1[i], nums2[i] <= 1000
+
Easy
Given two integer arrays nums1 and nums2, return an array of their intersection. Each element in the result must appear as many times as it shows in both arrays and you may return the result in any order.
+
+
+
Example 1:
+
+
Input: nums1 = [1,2,2,1], nums2 = [2,2]
+Output: [2,2]
+
+
+
Example 2:
+
+
Input: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
+Output: [4,9]
+Explanation: [9,4] is also accepted.
+
+
+
+
Constraints:
+
+
+ 1 <= nums1.length, nums2.length <= 10000 <= nums1[i], nums2[i] <= 1000
+
+
+
Follow up:
+
+
+ - What if the given array is already sorted? How would you optimize your algorithm?
+ - What if
nums1's size is small compared to nums2's size? Which algorithm is better?
+ - What if elements of
nums2 are stored on disk, and the memory is limited such that you cannot load all elements into the memory at once?
+
+
Hard
You are given a 2D array of integers envelopes where envelopes[i] = [wi, hi] represents the width and the height of an envelope.
+
+
One envelope can fit into another if and only if both the width and height of one envelope are greater than the other envelope's width and height.
+
+
Return the maximum number of envelopes you can Russian doll (i.e., put one inside the other).
+
+
Note: You cannot rotate an envelope.
+
+
+
Example 1:
+
+
Input: envelopes = [[5,4],[6,4],[6,7],[2,3]]
+Output: 3
+Explanation: The maximum number of envelopes you can Russian doll is 3 ([2,3] => [5,4] => [6,7]).
+
+
+
Example 2:
+
+
Input: envelopes = [[1,1],[1,1],[1,1]]
+Output: 1
+
+
+
+
Constraints:
+
+
+ 1 <= envelopes.length <= 105envelopes[i].length == 21 <= wi, hi <= 105
+
Medium
Given a set of distinct positive integers nums, return the largest subset answer such that every pair (answer[i], answer[j]) of elements in this subset satisfies:
+
+
+ answer[i] % answer[j] == 0, oranswer[j] % answer[i] == 0
+
+
If there are multiple solutions, return any of them.
+
+
+
Example 1:
+
+
Input: nums = [1,2,3]
+Output: [1,2]
+Explanation: [1,3] is also accepted.
+
+
+
Example 2:
+
+
Input: nums = [1,2,4,8]
+Output: [1,2,4,8]
+
+
+
+
Constraints:
+
+
+ 1 <= nums.length <= 10001 <= nums[i] <= 2 * 109- All the integers in
nums are unique.
+
+
Easy
Given a string s, find the first non-repeating character in it and return its index. If it does not exist, return -1.
+
+
+
Example 1:
+
Input: s = "leetcode"
+Output: 0
+
Example 2:
+
Input: s = "loveleetcode"
+Output: 2
+
Example 3:
+
Input: s = "aabb"
+Output: -1
+
+
+
Constraints:
+
+
+ 1 <= s.length <= 105s consists of only lowercase English letters.
+
Easy
You are given two strings s and t.
+
+
String t is generated by random shuffling string s and then add one more letter at a random position.
+
+
Return the letter that was added to t.
+
+
+
Example 1:
+
+
Input: s = "abcd", t = "abcde"
+Output: "e"
+Explanation: 'e' is the letter that was added.
+
+
+
Example 2:
+
+
Input: s = "", t = "y"
+Output: "y"
+
+
+
+
Constraints:
+
+
+ 0 <= s.length <= 1000t.length == s.length + 1s and t consist of lowercase English letters.
+
Medium
Given string num representing a non-negative integer num, and an integer k, return the smallest possible integer after removing k digits from num.
+
+
+
Example 1:
+
+
Input: num = "1432219", k = 3
+Output: "1219"
+Explanation: Remove the three digits 4, 3, and 2 to form the new number 1219 which is the smallest.
+
+
+
Example 2:
+
+
Input: num = "10200", k = 1
+Output: "200"
+Explanation: Remove the leading 1 and the number is 200. Note that the output must not contain leading zeroes.
+
+
+
Example 3:
+
+
Input: num = "10", k = 2
+Output: "0"
+Explanation: Remove all the digits from the number and it is left with nothing which is 0.
+
+
+
+
Constraints:
+
+
+ 1 <= k <= num.length <= 105num consists of only digits.num does not have any leading zeros except for the zero itself.
+
Easy
Given the root of a binary tree, return the sum of all left leaves.
+
+
A leaf is a node with no children. A left leaf is a leaf that is the left child of another node.
+
+
+
Example 1:
+
+
Input: root = [3,9,20,null,null,15,7]
+Output: 24
+Explanation: There are two left leaves in the binary tree, with values 9 and 15 respectively.
+
+
+
Example 2:
+
+
Input: root = [1]
+Output: 0
+
+
+
+
Constraints:
+
+
+ - The number of nodes in the tree is in the range
[1, 1000].
+ -1000 <= Node.val <= 1000
+
Easy
Given a string s which consists of lowercase or uppercase letters, return the length of the longest palindrome that can be built with those letters.
+
+
Letters are case sensitive, for example, "Aa" is not considered a palindrome.
+
+
+
Example 1:
+
+
Input: s = "abccccdd"
+Output: 7
+Explanation: One longest palindrome that can be built is "dccaccd", whose length is 7.
+
+
+
Example 2:
+
+
Input: s = "a"
+Output: 1
+Explanation: The longest palindrome that can be built is "a", whose length is 1.
+
+
+
+
Constraints:
+
+
+ 1 <= s.length <= 2000s consists of lowercase and/or uppercase English letters only.
+
Easy
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 g[i], which is the minimum size of a cookie that the child will be content with; and each cookie j has a size s[j]. If s[j] >= g[i], 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.
+
+
+
Example 1:
+
+
Input: g = [1,2,3], s = [1,1]
+Output: 1
+Explanation: You have 3 children and 2 cookies. The greed factors of 3 children are 1, 2, 3.
+And even though you have 2 cookies, since their size is both 1, you could only make the child whose greed factor is 1 content.
+You need to output 1.
+
+
+
Example 2:
+
+
Input: g = [1,2], s = [1,2,3]
+Output: 2
+Explanation: You have 2 children and 3 cookies. The greed factors of 2 children are 1, 2.
+You have 3 cookies and their sizes are big enough to gratify all of the children,
+You need to output 2.
+
+
+
+
Constraints:
+
+
+ 1 <= g.length <= 3 * 1040 <= s.length <= 3 * 1041 <= g[i], s[j] <= 231 - 1
+
Medium
Given an array of 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.
+
+
+
Example 1:
+
+
Input: nums = [1,2,3,4]
+Output: false
+Explanation: There is no 132 pattern in the sequence.
+
+
+
Example 2:
+
+
Input: nums = [3,1,4,2]
+Output: true
+Explanation: There is a 132 pattern in the sequence: [1, 4, 2].
+
+
+
Example 3:
+
+
Input: nums = [-1,3,2,0]
+Output: true
+Explanation: There are three 132 patterns in the sequence: [-1, 3, 2], [-1, 3, 0] and [-1, 2, 0].
+
+
+
+
Constraints:
+
+
+ n == nums.length1 <= n <= 2 * 105-109 <= nums[i] <= 109
+
Medium
Given an integer array nums of size n, return the minimum number of moves required to make all array elements equal.
+
+
In one move, you can increment or decrement an element of the array by 1.
+
+
Test cases are designed so that the answer will fit in a 32-bit integer.
+
+
+
Example 1:
+
+
Input: nums = [1,2,3]
+Output: 2
+Explanation:
+Only two moves are needed (remember each move increments or decrements one element):
+[1,2,3] => [2,2,3] => [2,2,2]
+
+
+
Example 2:
+
+
Input: nums = [1,10,2,9]
+Output: 16
+
+
+
+
Constraints:
+
+
+ n == nums.length1 <= nums.length <= 105-109 <= nums[i] <= 109
+
Easy
The complement of an integer is the integer you get when you flip all the 0's to 1's and all the 1's to 0's in its binary representation.
+
+
+ - For example, The integer
5 is "101" in binary and its complement is "010" which is the integer 2.
+
+
+
Given an integer num, return its complement.
+
+
+
Example 1:
+
+
Input: num = 5
+Output: 2
+Explanation: The binary representation of 5 is 101 (no leading zero bits), and its complement is 010. So you need to output 2.
+
+
+
Example 2:
+
+
Input: num = 1
+Output: 0
+Explanation: The binary representation of 1 is 1 (no leading zero bits), and its complement is 0. So you need to output 0.
+
+
+
+
Constraints:
+
+
+
+
+
Note: This question is the same as 1009: https://leetcode.com/problems/complement-of-base-10-integer/
+
Easy
Given the root of a binary search tree (BST) with duplicates, return all the mode(s) (i.e., the most frequently occurred element) in it.
+
+
If the tree has more than one mode, return them in any order.
+
+
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.
+
+
+
+
Example 1:
+
+
Input: root = [1,null,2,2]
+Output: [2]
+
+
+
Example 2:
+
+
Input: root = [0]
+Output: [0]
+
+
+
+
Constraints:
+
+
+ - The number of nodes in the tree is in the range
[1, 104].
+ -105 <= Node.val <= 105
+
+
+
Follow up: Could you do that without using any extra space? (Assume that the implicit stack space incurred due to recursion does not count).
Medium
Given the root of a binary tree, return the leftmost value in the last row of the tree.
+
+
+
Example 1:
+
+
Input: root = [2,1,3]
+Output: 1
+
+
+
Example 2:
+
+
Input: root = [1,2,3,4,null,5,6,null,null,7]
+Output: 7
+
+
+
+
Constraints:
+
+
+ - The number of nodes in the tree is in the range
[1, 104].
+ -231 <= Node.val <= 231 - 1
+
Hard
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 to open the door.
+
+
Given a string ring that represents the code engraved on the outer ring and another string key that represents the keyword that needs to be spelled, return the minimum number of steps to spell all the characters in the keyword.
+
+
Initially, the first character of the ring is aligned at the "12:00" direction. You should spell all the characters in key one by one by rotating ring clockwise or anticlockwise to make each character of the string key aligned at the "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 by one place, which counts as one step. The final purpose of the rotation is to align one of
ring's characters at the "12:00" direction, where this character must equal key[i].
+ - If the character
key[i] has been aligned at the "12:00" direction, press the center button to spell, which also counts as one step. After the pressing, you could begin to spell the next character in the key (next stage). Otherwise, you have finished all the spelling.
+
+
+
+
Example 1:
+
+
Input: ring = "godding", key = "gd"
+Output: 4
+Explanation:
+For the first key character 'g', since it is already in place, we just need 1 step to spell this character.
+For the second key character 'd', we need to rotate the ring "godding" anticlockwise by two steps to make it become "ddinggo".
+Also, we need 1 more step for spelling.
+So the final output is 4.
+
+
+
Example 2:
+
+
Input: ring = "godding", key = "godding"
+Output: 13
+
+
+
+
Constraints:
+
+
+ 1 <= ring.length, key.length <= 100ring and key consist of only lower case English letters.- It is guaranteed that
key could always be spelled by rotating ring.
+
+
Medium
Given the root of a binary tree, return an array of the largest value in each row of the tree (0-indexed).
+
+
+
Example 1:
+
+
Input: root = [1,3,2,5,3,null,9]
+Output: [1,3,9]
+
+
+
Example 2:
+
+
Input: root = [1,2,3]
+Output: [1,3]
+
+
+
+
Constraints:
+
+
+ - The number of nodes in the tree will be in the range
[0, 104].
+ -231 <= Node.val <= 231 - 1
+
Medium
Given an integer array nums and an integer k, return true if nums has a good subarray or false otherwise.
+
+
A good subarray is a subarray where:
+
+
+ - its length is at least two, and
+ - the sum of the elements of the subarray is a multiple of
k.
+
+
+
Note that:
+
+
+ - A subarray is a contiguous part of the array.
+ - An integer
x is a multiple of k if there exists an integer n such that x = n * k. 0 is always a multiple of k.
+
+
+
+
Example 1:
+
+
Input: nums = [23,2,4,6,7], k = 6
+Output: true
+Explanation: [2, 4] is a continuous subarray of size 2 whose elements sum up to 6.
+
+
+
Example 2:
+
+
Input: nums = [23,2,6,4,7], k = 6
+Output: true
+Explanation: [23, 2, 6, 4, 7] is an continuous subarray of size 5 whose elements sum up to 42.
+42 is a multiple of 6 because 42 = 7 * 6 and 7 is an integer.
+
+
+
Example 3:
+
+
Input: nums = [23,2,6,4,7], k = 13
+Output: false
+
+
+
+
Constraints:
+
+
+ 1 <= nums.length <= 1050 <= nums[i] <= 1090 <= sum(nums[i]) <= 231 - 11 <= k <= 231 - 1
+
Easy
Given the root of a binary tree, return 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.
+
+
The length of a path between two nodes is represented by the number of edges between them.
+
+
+
Example 1:
+
+
Input: root = [1,2,3,4,5]
+Output: 3
+Explanation: 3 is the length of the path [4,2,1,3] or [5,2,1,3].
+
+
+
Example 2:
+
+
Input: root = [1,2]
+Output: 1
+
+
+
+
Constraints:
+
+
+ - The number of nodes in the tree is in the range
[1, 104].
+ -100 <= Node.val <= 100
+
Medium
Given a positive integer n, find the smallest integer which has exactly the same digits existing in the integer n and is greater in value than n. If no such positive integer exists, return -1.
+
+
Note that the returned integer should fit in 32-bit integer, if there is a valid answer but it does not fit in 32-bit integer, return -1.
+
+
+
Example 1:
+
Input: n = 12
+Output: 21
+
Example 2:
+
Input: n = 21
+Output: -1
+
+
+
Constraints:
+
+
+
Easy
Given a string s, reverse the order of characters in each word within a sentence while still preserving whitespace and initial word order.
+
+
+
Example 1:
+
Input: s = "Let's take LeetCode contest"
+Output: "s'teL ekat edoCteeL tsetnoc"
+
Example 2:
+
Input: s = "God Ding"
+Output: "doG gniD"
+
+
+
Constraints:
+
+
+ 1 <= s.length <= 5 * 104s contains printable ASCII characters.s does not contain any leading or trailing spaces.- There is at least one word in
s.
+ - All the words in
s are separated by a single space.
+
+
Hard
Given a string n representing an integer, return the closest integer (not including itself), which is a palindrome. If there is a tie, return the smaller one.
+
+
The closest is defined as the absolute difference minimized between two integers.
+
+
+
Example 1:
+
+
Input: n = "123"
+Output: "121"
+
+
+
Example 2:
+
+
Input: n = "1"
+Output: "0"
+Explanation: 0 and 2 are the closest palindromes but we return the smallest which is 0.
+
+
+
+
Constraints:
+
+
+ 1 <= n.length <= 18n consists of only digits.n does not have leading zeros.n is representing an integer in the range [1, 1018 - 1].
+
Medium
There is an m x n grid with a ball. The ball is initially at the position [startRow, startColumn]. You are allowed to move the ball to one of the four adjacent cells in the grid (possibly out of the grid crossing the grid boundary). You can apply at most maxMove moves to the ball.
+
+
Given the five integers m, n, maxMove, startRow, startColumn, return the number of paths to move the ball out of the grid boundary. Since the answer can be very large, return it modulo 109 + 7.
+
+
+
Example 1:
+
+
Input: m = 2, n = 2, maxMove = 2, startRow = 0, startColumn = 0
+Output: 6
+
+
+
Example 2:
+
+
Input: m = 1, n = 3, maxMove = 3, startRow = 0, startColumn = 1
+Output: 12
+
+
+
+
Constraints:
+
+
+ 1 <= m, n <= 500 <= maxMove <= 500 <= startRow < m0 <= startColumn < n
+
Easy
Table: Customer
+
+
+-------------+---------+
+| Column Name | Type |
++-------------+---------+
+| id | int |
+| name | varchar |
+| referee_id | int |
++-------------+---------+
+In SQL, id is the primary key column for this table.
+Each row of this table indicates the id of a customer, their name, and the id of the customer who referred them.
+
+
+
+
+
Find the names of the customer that are not referred by the customer with id = 2.
+
+
Return the result table in any order.
+
+
The result format is in the following example.
+
+
+
Example 1:
+
+
Input:
+Customer table:
++----+------+------------+
+| id | name | referee_id |
++----+------+------------+
+| 1 | Will | null |
+| 2 | Jane | null |
+| 3 | Alex | 2 |
+| 4 | Bill | null |
+| 5 | Zack | 1 |
+| 6 | Mark | 2 |
++----+------+------------+
+Output:
++------+
+| name |
++------+
+| Will |
+| Jane |
+| Bill |
+| Zack |
++------+
+
+
Easy
Given the root of an n-ary tree, return the postorder traversal of its nodes' values.
+
+
Nary-Tree input serialization is represented in their level order traversal. Each group of children is separated by the null value (See examples)
+
+
+
Example 1:
+
+
Input: root = [1,null,3,2,4,null,5,6]
+Output: [5,6,3,2,4,1]
+
+
+
Example 2:
+
+
Input: root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
+Output: [2,6,14,11,7,3,12,8,4,13,9,10,5,1]
+
+
+
+
Constraints:
+
+
+ - The number of nodes in the tree is in the range
[0, 104].
+ 0 <= Node.val <= 104- The height of the n-ary tree is less than or equal to
1000.
+
+
+
+
Follow up: Recursive solution is trivial, could you do it iteratively?
+
Medium
Given a string expression representing an expression of fraction addition and subtraction, return the calculation result in string format.
+
+
The final result should be an irreducible fraction. If your final result is an integer, change it to the format of a fraction that has a denominator 1. So in this case, 2 should be converted to 2/1.
+
+
+
Example 1:
+
+
Input: expression = "-1/2+1/2"
+Output: "0/1"
+
+
+
Example 2:
+
+
Input: expression = "-1/2+1/2+1/3"
+Output: "1/3"
+
+
+
Example 3:
+
+
Input: expression = "1/3-1/2"
+Output: "-1/6"
+
+
+
+
Constraints:
+
+
+ - The input string only contains
'0' to '9', '/', '+' and '-'. So does the output.
+ - Each fraction (input and output) has the format
±numerator/denominator. If the first input fraction or the output is positive, then '+' will be omitted.
+ - The input only contains valid irreducible fractions, where the numerator and denominator of each fraction will always be in the range
[1, 10]. If the denominator is 1, it means this fraction is actually an integer in a fraction format defined above.
+ - The number of given fractions will be in the range
[1, 10].
+ - The numerator and denominator of the final result are guaranteed to be valid and in the range of 32-bit int.
+
+
Easy
Given the root of a binary tree, construct a string consisting of parenthesis and integers from a binary tree with the preorder traversal way, and return it.
+
+
Omit all the empty parenthesis pairs that do not affect the one-to-one mapping relationship between the string and the original binary tree.
+
+
+
Example 1:
+
+
Input: root = [1,2,3,4]
+Output: "1(2(4))(3)"
+Explanation: Originally, it needs to be "1(2(4)())(3()())", but you need to omit all the unnecessary empty parenthesis pairs. And it will be "1(2(4))(3)"
+
+
+
Example 2:
+
+
Input: root = [1,2,3,null,4]
+Output: "1(2()(4))(3)"
+Explanation: Almost the same as the first example, except we cannot omit the first parenthesis pair to break the one-to-one mapping relationship between the input and the output.
+
+
+
+
Constraints:
+
+
+ - The number of nodes in the tree is in the range
[1, 104].
+ -1000 <= Node.val <= 1000
+
Medium
You are given an array of CPU tasks, each represented by letters A to Z, and a cooling time, n. Each cycle or interval allows the completion of one task. Tasks can be completed in any order, but there's a constraint: identical tasks must be separated by at least n intervals due to cooling time.
+
+
Return the minimum number of intervals required to complete all tasks.
+
+
+
Example 1:
+
+
+
Input: tasks = ["A","A","A","B","B","B"], n = 2
+
+
Output: 8
+
+
Explanation: A possible sequence is: A -> B -> idle -> A -> B -> idle -> A -> B.
+
+
After completing task A, you must wait two cycles before doing A again. The same applies to task B. In the 3rd interval, neither A nor B can be done, so you idle. By the 4th cycle, you can do A again as 2 intervals have passed.
+
+
+
Example 2:
+
+
+
Input: tasks = ["A","C","A","B","D","B"], n = 1
+
+
Output: 6
+
+
Explanation: A possible sequence is: A -> B -> C -> D -> A -> B.
+
+
With a cooling interval of 1, you can repeat a task after just one other task.
+
+
+
Example 3:
+
+
+
Input: tasks = ["A","A","A", "B","B","B"], n = 3
+
+
Output: 10
+
+
Explanation: A possible sequence is: A -> B -> idle -> idle -> A -> B -> idle -> idle -> A -> B.
+
+
There are only two types of tasks, A and B, which need to be separated by 3 intervals. This leads to idling twice between repetitions of these tasks.
+
+
+
+
Constraints:
+
+
+ 1 <= tasks.length <= 104tasks[i] is an uppercase English letter.0 <= n <= 100
+
Medium
Given the root of a binary tree and two integers val and depth, add a row of nodes with value val at the given depth depth.
+
+
Note that the root node is at depth 1.
+
+
The adding rule is:
+
+
+ - Given the integer
depth, for each not null tree node cur at the depth depth - 1, create two tree nodes with value val as cur's left subtree root and right subtree root.
+ cur's original left subtree should be the left subtree of the new left subtree root.cur's original right subtree should be the right subtree of the new right subtree root.- If
depth == 1 that means there is no depth depth - 1 at all, then create a tree node with value val as the new root of the whole original tree, and the original tree is the new root's left subtree.
+
+
+
+
Example 1:
+
+
Input: root = [4,2,6,3,1,5], val = 1, depth = 2
+Output: [4,1,1,2,null,null,6,3,1,5]
+
+
+
Example 2:
+
+
Input: root = [4,2,null,3,1], val = 1, depth = 3
+Output: [4,2,null,1,1,3,null,null,1]
+
+
+
+
Constraints:
+
+
+ - The number of nodes in the tree is in the range
[1, 104].
+ - The depth of the tree is in the range
[1, 104].
+ -100 <= Node.val <= 100-105 <= val <= 1051 <= depth <= the depth of tree + 1
+
Medium
You are given m arrays, where each array is sorted in ascending order.
+
+
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|.
+
+
Return the maximum distance.
+
+
+
Example 1:
+
+
Input: arrays = [[1,2,3],[4,5],[1,2,3]]
+Output: 4
+Explanation: One way to reach the maximum distance 4 is to pick 1 in the first or third array and pick 5 in the second array.
+
+
+
Example 2:
+
+
Input: arrays = [[1],[1]]
+Output: 0
+
+
+
+
Constraints:
+
+
+ m == arrays.length2 <= m <= 1051 <= arrays[i].length <= 500-104 <= arrays[i][j] <= 104arrays[i] is sorted in ascending order.- There will be at most
105 integers in all the arrays.
+
+
Easy
Given an integer array nums, find three numbers whose product is maximum and return the maximum product.
+
+
+
Example 1:
+
Input: nums = [1,2,3]
+Output: 6
+
Example 2:
+
Input: nums = [1,2,3,4]
+Output: 24
+
Example 3:
+
Input: nums = [-1,-2,-3]
+Output: -6
+
+
+
Constraints:
+
+
+ 3 <= nums.length <= 104-1000 <= nums[i] <= 1000
+
Hard
For an integer array nums, an inverse pair is a pair of integers [i, j] where 0 <= i < j < nums.length and nums[i] > nums[j].
+
+
Given two integers n and k, return the number of different arrays consist of numbers from 1 to n such that there are exactly k inverse pairs. Since the answer can be huge, return it modulo 109 + 7.
+
+
+
Example 1:
+
+
Input: n = 3, k = 0
+Output: 1
+Explanation: Only the array [1,2,3] which consists of numbers from 1 to 3 has exactly 0 inverse pairs.
+
+
+
Example 2:
+
+
Input: n = 3, k = 1
+Output: 2
+Explanation: The array [1,3,2] and [2,1,3] have exactly 1 inverse pair.
+
+
+
+
Constraints:
+
+
+ 1 <= n <= 10000 <= k <= 1000
+
Medium
Given a non-negative integer c, decide whether there're two integers a and b such that a2 + b2 = c.
+
+
+
Example 1:
+
+
Input: c = 5
+Output: true
+Explanation: 1 * 1 + 2 * 2 = 5
+
+
+
Example 2:
+
+
Input: c = 3
+Output: false
+
+
+
+
Constraints:
+
+
+
Easy
You have a set of integers s, which originally contains all the numbers from 1 to n. Unfortunately, due to some error, one of the numbers in s got duplicated to another number in the set, which results in repetition of one number and loss of another number.
+
+
You are given an integer array nums representing the data status of this set after the error.
+
+
Find the number that occurs twice and the number that is missing and return them in the form of an array.
+
+
+
Example 1:
+
Input: nums = [1,2,2,4]
+Output: [2,3]
+
Example 2:
+
Input: nums = [1,1]
+Output: [1,2]
+
+
+
Constraints:
+
+
+ 2 <= nums.length <= 1041 <= nums[i] <= 104
+
Medium
Given a string s, return the number of palindromic substrings in it.
+
+
A string is a palindrome when it reads the same backward as forward.
+
+
A substring is a contiguous sequence of characters within the string.
+
+
+
Example 1:
+
+
Input: s = "abc"
+Output: 3
+Explanation: Three palindromic strings: "a", "b", "c".
+
+
+
Example 2:
+
+
Input: s = "aaa"
+Output: 6
+Explanation: Six palindromic strings: "a", "a", "a", "aa", "aa", "aaa".
+
+
+
+
Constraints:
+
+
+ 1 <= s.length <= 1000s consists of lowercase English letters.
+
Medium
In English, we have a concept called root, which can be followed by some other word to form another longer word - let's call this word derivative. For example, when the root "help" is followed by the word "ful", we can form a derivative "helpful".
+
+
Given a dictionary consisting of many roots and a sentence consisting of words separated by spaces, replace all the derivatives in the sentence with the root forming it. If a derivative can be replaced by more than one root, replace it with the root that has the shortest length.
+
+
Return the sentence after the replacement.
+
+
+
Example 1:
+
+
Input: dictionary = ["cat","bat","rat"], sentence = "the cattle was rattled by the battery"
+Output: "the cat was rat by the bat"
+
+
+
Example 2:
+
+
Input: dictionary = ["a","b","c"], sentence = "aadsfasf absbs bbab cadsfafs"
+Output: "a a b c"
+
+
+
+
Constraints:
+
+
+ 1 <= dictionary.length <= 10001 <= dictionary[i].length <= 100dictionary[i] consists of only lower-case letters.1 <= sentence.length <= 106sentence consists of only lower-case letters and spaces.- The number of words in
sentence is in the range [1, 1000]
+ - The length of each word in
sentence is in the range [1, 1000]
+ - Every two consecutive words in
sentence will be separated by exactly one space.
+ sentence does not have leading or trailing spaces.
+
Medium
There is only one character 'A' on the screen of a notepad. You can perform one of two operations on this notepad for each step:
+
+
+ - Copy All: You can copy all the characters present on the screen (a partial copy is not allowed).
+ - Paste: You can paste the characters which are copied last time.
+
+
+
Given an integer n, return the minimum number of operations to get the character 'A' exactly n times on the screen.
+
+
+
Example 1:
+
+
Input: n = 3
+Output: 3
+Explanation: Initially, we have one character 'A'.
+In step 1, we use Copy All operation.
+In step 2, we use Paste operation to get 'AA'.
+In step 3, we use Paste operation to get 'AAA'.
+
+
+
Example 2:
+
+
Input: n = 1
+Output: 0
+
+
+
+
Constraints:
+
+
+
Easy
An image smoother is a filter of the size 3 x 3 that can be applied to each cell of an image by rounding down the average of the cell and the eight surrounding cells (i.e., the average of the nine cells in the blue smoother). If one or more of the surrounding cells of a cell is not present, we do not consider it in the average (i.e., the average of the four cells in the red smoother).
+
+
Given an m x n integer matrix img representing the grayscale of an image, return the image after applying the smoother on each cell of it.
+
+
+
Example 1:
+
+
Input: img = [[1,1,1],[1,0,1],[1,1,1]]
+Output: [[0,0,0],[0,0,0],[0,0,0]]
+Explanation:
+For the points (0,0), (0,2), (2,0), (2,2): floor(3/4) = floor(0.75) = 0
+For the points (0,1), (1,0), (1,2), (2,1): floor(5/6) = floor(0.83333333) = 0
+For the point (1,1): floor(8/9) = floor(0.88888889) = 0
+
+
+
Example 2:
+
+
Input: img = [[100,200,100],[200,50,200],[100,200,100]]
+Output: [[137,141,137],[141,138,141],[137,141,137]]
+Explanation:
+For the points (0,0), (0,2), (2,0), (2,2): floor((100+200+200+50)/4) = floor(137.5) = 137
+For the points (0,1), (1,0), (1,2), (2,1): floor((200+200+50+200+100+100)/6) = floor(141.666667) = 141
+For the point (1,1): floor((50+200+200+200+200+100+100+100+100)/9) = floor(138.888889) = 138
+
+
+
+
Constraints:
+
+
+ m == img.lengthn == img[i].length1 <= m, n <= 2000 <= img[i][j] <= 255
+
Medium
Given a string s containing only three types of characters: '(', ')' and '*', return true if s is valid.
+
+
The following rules define a valid string:
+
+
+ - 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 "".
+
+
+
Example 1:
+
Input: s = "()"
+Output: true
+
Example 2:
+
Input: s = "(*)"
+Output: true
+
Example 3:
+
Input: s = "(*))"
+Output: true
+
+
+
Constraints:
+
+
+ 1 <= s.length <= 100s[i] is '(', ')' or '*'.
+
Easy
Design a HashMap without using any built-in hash table libraries.
+
+
Implement the MyHashMap class:
+
+
+ MyHashMap() initializes the object with an empty map.void put(int key, int value) inserts a (key, value) pair into the HashMap. If the key already exists in the map, update the corresponding value.int get(int key) returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key.void remove(key) removes the key and its corresponding value if the map contains the mapping for the key.
+
+
+
Example 1:
+
+
Input
+["MyHashMap", "put", "put", "get", "get", "put", "get", "remove", "get"]
+[[], [1, 1], [2, 2], [1], [3], [2, 1], [2], [2], [2]]
+Output
+[null, null, null, 1, -1, null, 1, null, -1]
+
+Explanation
+MyHashMap myHashMap = new MyHashMap();
+myHashMap.put(1, 1); // The map is now [[1,1]]
+myHashMap.put(2, 2); // The map is now [[1,1], [2,2]]
+myHashMap.get(1); // return 1, The map is now [[1,1], [2,2]]
+myHashMap.get(3); // return -1 (i.e., not found), The map is now [[1,1], [2,2]]
+myHashMap.put(2, 1); // The map is now [[1,1], [2,1]] (i.e., update the existing value)
+myHashMap.get(2); // return 1, The map is now [[1,1], [2,1]]
+myHashMap.remove(2); // remove the mapping for 2, The map is now [[1,1]]
+myHashMap.get(2); // return -1 (i.e., not found), The map is now [[1,1]]
+
+
+
+
Constraints:
+
+
+ 0 <= key, value <= 106- At most
104 calls will be made to put, get, and remove.
+
+
Hard
The distance of a pair of integers a and b is defined as the absolute difference between a and b.
+
+
Given an integer array nums and an integer k, return the kth smallest distance among all the pairs nums[i] and nums[j] where 0 <= i < j < nums.length.
+
+
+
Example 1:
+
+
Input: nums = [1,3,1], k = 1
+Output: 0
+Explanation: Here are all the pairs:
+(1,3) -> 2
+(1,1) -> 0
+(3,1) -> 2
+Then the 1st smallest distance pair is (1,1), and its distance is 0.
+
+
+
Example 2:
+
+
Input: nums = [1,1,1], k = 2
+Output: 0
+
+
+
Example 3:
+
+
Input: nums = [1,6,1], k = 3
+Output: 5
+
+
+
+
Constraints:
+
+
+ n == nums.length2 <= n <= 1040 <= nums[i] <= 1061 <= k <= n * (n - 1) / 2
+
Easy
You are given an integer array cost where cost[i] is the cost of ith step on a staircase. Once you pay the cost, you can either climb one or two steps.
+
+
You can either start from the step with index 0, or the step with index 1.
+
+
Return the minimum cost to reach the top of the floor.
+
+
+
Example 1:
+
+
Input: cost = [10,15,20]
+Output: 15
+Explanation: You will start at index 1.
+- Pay 15 and climb two steps to reach the top.
+The total cost is 15.
+
+
+
Example 2:
+
+
Input: cost = [1,100,1,1,1,100,1,1,100,1]
+Output: 6
+Explanation: You will start at index 0.
+- Pay 1 and climb two steps to reach index 2.
+- Pay 1 and climb two steps to reach index 4.
+- Pay 1 and climb two steps to reach index 6.
+- Pay 1 and climb one step to reach index 7.
+- Pay 1 and climb two steps to reach index 9.
+- Pay 1 and climb one step to reach the top.
+The total cost is 6.
+
+
+
+
Constraints:
+
+
+ 2 <= cost.length <= 10000 <= cost[i] <= 999
+
Medium
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.
+
+
+
Example 1:
+
+
Input: deadends = ["0201","0101","0102","1212","2002"], target = "0202"
+Output: 6
+Explanation:
+A sequence of valid moves would be "0000" -> "1000" -> "1100" -> "1200" -> "1201" -> "1202" -> "0202".
+Note that a sequence like "0000" -> "0001" -> "0002" -> "0102" -> "0202" would be invalid,
+because the wheels of the lock become stuck after the display becomes the dead end "0102".
+
+
+
Example 2:
+
+
Input: deadends = ["8888"], target = "0009"
+Output: 1
+Explanation: We can turn the last wheel in reverse to move from "0000" -> "0009".
+
+
+
Example 3:
+
+
Input: deadends = ["8887","8889","8878","8898","8788","8988","7888","9888"], target = "8888"
+Output: -1
+Explanation: We cannot reach the target without getting stuck.
+
+
+
+
Constraints:
+
+
+ 1 <= deadends.length <= 500deadends[i].length == 4target.length == 4- target will not be in the list
deadends.
+ target and deadends[i] consist of digits only.
+
Medium
You are given two strings order and s. All the characters of order are unique and were sorted in some custom order previously.
+
+
Permute the characters of s so that they match the order that order was sorted. More specifically, if a character x occurs before a character y in order, then x should occur before y in the permuted string.
+
+
Return any permutation of s that satisfies this property.
+
+
+
Example 1:
+
+
+
Input: order = "cba", s = "abcd"
+
+
Output: "cbad"
+
+
Explanation: "a", "b", "c" appear in order, so the order of "a", "b", "c" should be "c", "b", and "a".
+
+
Since "d" does not appear in order, it can be at any position in the returned string. "dcba", "cdba", "cbda" are also valid outputs.
+
+
+
Example 2:
+
+
+
Input: order = "bcafg", s = "abcd"
+
+
Output: "bcad"
+
+
Explanation: The characters "b", "c", and "a" from order dictate the order for the characters in s. The character "d" in s does not appear in order, so its position is flexible.
+
+
Following the order of appearance in order, "b", "c", and "a" from s should be arranged as "b", "c", "a". "d" can be placed at any position since it's not in order. The output "bcad" correctly follows this rule. Other arrangements like "bacd" or "bcda" would also be valid, as long as "b", "c", "a" maintain their order.
+
+
+
+
Constraints:
+
+
+ 1 <= order.length <= 261 <= s.length <= 200order and s consist of lowercase English letters.- All the characters of
order are unique.
+
+
Medium
Given an array of unique integers, arr, where each integer arr[i] is strictly greater than 1.
+
+
We make a binary tree using these integers, and each number may be used for any number of times. Each non-leaf node's value should be equal to the product of the values of its children.
+
+
Return the number of binary trees we can make. The answer may be too large so return the answer modulo 109 + 7.
+
+
+
Example 1:
+
+
Input: arr = [2,4]
+Output: 3
+Explanation: We can make these trees: [2], [4], [4, 2, 2]
+
+
Example 2:
+
+
Input: arr = [2,4,5,10]
+Output: 7
+Explanation: We can make these trees: [2], [4], [5], [10], [4, 2, 2], [10, 2, 5], [10, 5, 2].
+
+
+
Constraints:
+
+
+ 1 <= arr.length <= 10002 <= arr[i] <= 109- All the values of
arr are unique.
+
+
Hard
You are given an n x n binary matrix grid. You are allowed to change at most one 0 to be 1.
+
+
Return the size of the largest island in grid after applying this operation.
+
+
An island is a 4-directionally connected group of 1s.
+
+
+
Example 1:
+
+
Input: grid = [[1,0],[0,1]]
+Output: 3
+Explanation: Change one 0 to 1 and connect two 1s, then we get an island with area = 3.
+
+
+
Example 2:
+
+
Input: grid = [[1,1],[1,0]]
+Output: 4
+Explanation: Change the 0 to 1 and make the island bigger, only one island with area = 4.
+
+
Example 3:
+
+
Input: grid = [[1,1],[1,1]]
+Output: 4
+Explanation: Can't change any 0 to 1, only one island with area = 4.
+
+
+
+
Constraints:
+
+
+ n == grid.lengthn == grid[i].length1 <= n <= 500grid[i][j] is either 0 or 1.
Medium
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 a row x col grid of integers, how many 3 x 3 contiguous magic square subgrids are there?
+
+
Note: while a magic square can only contain numbers from 1 to 9, grid may contain numbers up to 15.
+
+
+
Example 1:
+
+
Input: grid = [[4,3,8,4],[9,5,1,9],[2,7,6,2]]
+Output: 1
+Explanation:
+The following subgrid is a 3 x 3 magic square:
+
+while this one is not:
+
+In total, there is only one magic square inside the given grid.
+
+
+
Example 2:
+
+
Input: grid = [[8]]
+Output: 0
+
+
+
+
Constraints:
+
+
+ row == grid.lengthcol == grid[i].length1 <= row, col <= 100 <= grid[i][j] <= 15
+
Medium
Alice has some number of cards and she wants to rearrange the cards into groups so that each group is of size groupSize, and consists of groupSize consecutive cards.
+
+
Given an integer array hand where hand[i] is the value written on the ith card and an integer groupSize, return true if she can rearrange the cards, or false otherwise.
+
+
+
Example 1:
+
+
Input: hand = [1,2,3,6,2,3,4,7,8], groupSize = 3
+Output: true
+Explanation: Alice's hand can be rearranged as [1,2,3],[2,3,4],[6,7,8]
+
+
+
Example 2:
+
+
Input: hand = [1,2,3,4,5], groupSize = 4
+Output: false
+Explanation: Alice's hand can not be rearranged into groups of 4.
+
+
+
+
+
Constraints:
+
+
+ 1 <= hand.length <= 1040 <= hand[i] <= 1091 <= groupSize <= hand.length
+
+
+
Note: This question is the same as 1296: https://leetcode.com/problems/divide-array-in-sets-of-k-consecutive-numbers/
+
Hard
There are n workers. You are given two integer arrays quality and wage where quality[i] is the quality of the ith worker and wage[i] is the minimum wage expectation for the ith worker.
+
+
We want to hire exactly k workers to form a paid group. To hire a group of k workers, we must pay them according to the following rules:
+
+
+ - Every worker in the paid group must be paid at least their minimum wage expectation.
+ - In the group, each worker's pay must be directly proportional to their quality. This means if a worker’s quality is double that of another worker in the group, then they must be paid twice as much as the other worker.
+
+
+
Given the integer k, return the least amount of money needed to form a paid group satisfying the above conditions. Answers within 10-5 of the actual answer will be accepted.
+
+
+
Example 1:
+
+
Input: quality = [10,20,5], wage = [70,50,30], k = 2
+Output: 105.00000
+Explanation: We pay 70 to 0th worker and 35 to 2nd worker.
+
+
+
Example 2:
+
+
Input: quality = [3,1,10,10,1], wage = [4,8,2,2,7], k = 3
+Output: 30.66667
+Explanation: We pay 4 to 0th worker, 13.33333 to 2nd and 3rd workers separately.
+
+
+
+
Constraints:
+
+
+ n == quality.length == wage.length1 <= k <= n <= 1041 <= quality[i], wage[i] <= 104
+
Easy
At a lemonade stand, each lemonade costs $5. Customers 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 pay with either a $5, $10, or $20 bill. You must provide the correct change to each customer so that the net transaction is that the customer pays $5.
+
+
Note that you do not have any change in hand at first.
+
+
Given an integer array bills where bills[i] is the bill the ith customer pays, return true if you can provide every customer with the correct change, or false otherwise.
+
+
+
Example 1:
+
+
Input: bills = [5,5,5,10,20]
+Output: true
+Explanation:
+From the first 3 customers, we collect three $5 bills in order.
+From the fourth customer, we collect a $10 bill and give back a $5.
+From the fifth customer, we give a $10 bill and a $5 bill.
+Since all customers got correct change, we output true.
+
+
+
Example 2:
+
+
Input: bills = [5,5,10,10,20]
+Output: false
+Explanation:
+From the first two customers in order, we collect two $5 bills.
+For the next two customers in order, we collect a $10 bill and give back a $5 bill.
+For the last customer, we can not give the change of $15 back because we only have two $10 bills.
+Since not every customer received the correct change, the answer is false.
+
+
+
+
Constraints:
+
+
+ 1 <= bills.length <= 105bills[i] is either 5, 10, or 20.
+
Easy
Given a 2D integer array matrix, return the transpose of matrix.
+
+
The transpose of a matrix is the matrix flipped over its main diagonal, switching the matrix's row and column indices.
+
+
+
+
+
Example 1:
+
+
Input: matrix = [[1,2,3],[4,5,6],[7,8,9]]
+Output: [[1,4,7],[2,5,8],[3,6,9]]
+
+
+
Example 2:
+
+
Input: matrix = [[1,2,3],[4,5,6]]
+Output: [[1,4],[2,5],[3,6]]
+
+
+
+
Constraints:
+
+
+ m == matrix.lengthn == matrix[i].length1 <= m, n <= 10001 <= m * n <= 105-109 <= matrix[i][j] <= 109
+
Easy
Consider all the leaves of a binary tree, from left to right order, the values of those leaves form a leaf value sequence.
+
+
+
+
For example, in the given tree above, the leaf value sequence is (6, 7, 4, 9, 8).
+
+
Two binary trees are considered leaf-similar if their leaf value sequence is the same.
+
+
Return true if and only if the two given trees with head nodes root1 and root2 are leaf-similar.
+
+
+
Example 1:
+
+
Input: root1 = [3,5,1,6,2,9,8,null,null,7,4], root2 = [3,5,1,6,7,4,2,null,null,null,null,null,null,9,8]
+Output: true
+
+
+
Example 2:
+
+
Input: root1 = [1,2,3], root2 = [1,3,2]
+Output: false
+
+
+
+
Constraints:
+
+
+ - The number of nodes in each tree will be in the range
[1, 200].
+ - Both of the given trees will have values in the range
[0, 200].
+
+
Easy
Given the head of a singly linked list, return the middle node of the linked list.
+
+
If there are two middle nodes, return the second middle node.
+
+
+
Example 1:
+
+
Input: head = [1,2,3,4,5]
+Output: [3,4,5]
+Explanation: The middle node of the list is node 3.
+
+
+
Example 2:
+
+
Input: head = [1,2,3,4,5,6]
+Output: [4,5,6]
+Explanation: Since the list has two middle nodes with values 3 and 4, we return the second one.
+
+
+
+
Constraints:
+
+
+ - The number of nodes in the list is in the range
[1, 100].
+ 1 <= Node.val <= 100
+
Medium
You are given an encoded string s. To decode the string to a tape, the encoded string is read one character at a time and 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
d, the entire current tape is repeatedly written d - 1 more times in total.
+
+
+
Given an integer k, return the kth letter (1-indexed) in the decoded string.
+
+
+
Example 1:
+
+
Input: s = "leet2code3", k = 10
+Output: "o"
+Explanation: The decoded string is "leetleetcodeleetleetcodeleetleetcode".
+The 10th letter in the string is "o".
+
+
+
Example 2:
+
+
Input: s = "ha22", k = 5
+Output: "h"
+Explanation: The decoded string is "hahahaha".
+The 5th letter is "h".
+
+
+
Example 3:
+
+
Input: s = "a2345678999999999999999", k = 1
+Output: "a"
+Explanation: The decoded string is "a" repeated 8301530446056247680 times.
+The 1st letter is "a".
+
+
+
+
Constraints:
+
+
+ 2 <= s.length <= 100s consists of lowercase English letters and digits 2 through 9.s starts with a letter.1 <= k <= 109- It is guaranteed that
k is less than or equal to the length of the decoded string.
+ - The decoded string is guaranteed to have less than
263 letters.
+
+
Medium
You start at the cell (rStart, cStart) of an rows x cols grid facing east. The northwest corner is at the first row and column in the grid, and the southeast corner is at the last row and column.
+
+
You will walk in a clockwise spiral shape to visit every position in this grid. Whenever you move outside the grid's boundary, we continue our walk outside the grid (but may return to the grid boundary later.). Eventually, we reach all rows * cols spaces of the grid.
+
+
Return an array of coordinates representing the positions of the grid in the order you visited them.
+
+
+
Example 1:
+
+
Input: rows = 1, cols = 4, rStart = 0, cStart = 0
+Output: [[0,0],[0,1],[0,2],[0,3]]
+
+
+
Example 2:
+
+
Input: rows = 5, cols = 6, rStart = 1, cStart = 4
+Output: [[1,4],[1,5],[2,5],[2,4],[2,3],[1,3],[0,3],[0,4],[0,5],[3,5],[3,4],[3,3],[3,2],[2,2],[1,2],[0,2],[4,5],[4,4],[4,3],[4,2],[4,1],[3,1],[2,1],[1,1],[0,1],[4,0],[3,0],[2,0],[1,0],[0,0]]
+
+
+
+
Constraints:
+
+
+ 1 <= rows, cols <= 1000 <= rStart < rows0 <= cStart < cols
+
Medium
Given an array of integers nums, sort the array in ascending order and return it.
+
+
You must solve the problem without using any built-in functions in O(nlog(n)) time complexity and with the smallest space complexity possible.
+
+
+
Example 1:
+
+
Input: nums = [5,2,3,1]
+Output: [1,2,3,5]
+Explanation: After sorting the array, the positions of some numbers are not changed (for example, 2 and 3), while the positions of other numbers are changed (for example, 1 and 5).
+
+
+
Example 2:
+
+
Input: nums = [5,1,1,2,0,0]
+Output: [0,0,1,1,2,5]
+Explanation: Note that the values of nums are not necessairly unique.
+
+
+
+
Constraints:
+
+
+ 1 <= nums.length <= 5 * 104-5 * 104 <= nums[i] <= 5 * 104
+
Medium
Given a binary array nums and an integer goal, return the number of non-empty subarrays with a sum goal.
+
+
A subarray is a contiguous part of the array.
+
+
+
Example 1:
+
+
Input: nums = [1,0,1,0,1], goal = 2
+Output: 4
+Explanation: The 4 subarrays are bolded and underlined below:
+[1,0,1,0,1]
+[1,0,1,0,1]
+[1,0,1,0,1]
+[1,0,1,0,1]
+
+
+
Example 2:
+
+
Input: nums = [0,0,0,0,0], goal = 0
+Output: 15
+
+
+
+
Constraints:
+
+
+ 1 <= nums.length <= 3 * 104nums[i] is either 0 or 1.0 <= goal <= nums.length
Medium
Given an n x n array of integers matrix, return the minimum sum of any falling path through matrix.
+
+
A falling path starts at any element in the first row and chooses the element in the next row that is either directly below or diagonally left/right. Specifically, the next element from position (row, col) will be (row + 1, col - 1), (row + 1, col), or (row + 1, col + 1).
+
+
+
Example 1:
+
+
Input: matrix = [[2,1,3],[6,5,4],[7,8,9]]
+Output: 13
+Explanation: There are two falling paths with a minimum sum as shown.
+
+
+
Example 2:
+
+
Input: matrix = [[-19,57],[-40,-5]]
+Output: -59
+Explanation: The falling path with a minimum sum is shown.
+
+
+
+
Constraints:
+
+
+ n == matrix.length == matrix[i].length1 <= n <= 100-100 <= matrix[i][j] <= 100
+
Easy
Given the root node of a binary search tree and two integers low and high, return the sum of values of all nodes with a value in the inclusive range [low, high].
+
+
+
Example 1:
+
+
Input: root = [10,5,15,3,7,null,18], low = 7, high = 15
+Output: 32
+Explanation: Nodes 7, 10, and 15 are in the range [7, 15]. 7 + 10 + 15 = 32.
+
+
+
Example 2:
+
+
Input: root = [10,5,15,3,7,13,18,1,null,6], low = 6, high = 10
+Output: 23
+Explanation: Nodes 6, 7, and 10 are in the range [6, 10]. 6 + 7 + 10 = 23.
+
+
+
+
Constraints:
+
+
+ - The number of nodes in the tree is in the range
[1, 2 * 104].
+ 1 <= Node.val <= 1051 <= low <= high <= 105- All
Node.val are unique.
+
+
Medium
You are given an integer array nums. In one move, you can pick an index i where 0 <= i < nums.length and increment nums[i] by 1.
+
+
Return the minimum number of moves to make every value in nums unique.
+
+
The test cases are generated so that the answer fits in a 32-bit integer.
+
+
+
Example 1:
+
+
Input: nums = [1,2,2]
+Output: 1
+Explanation: After 1 move, the array could be [1, 2, 3].
+
+
+
Example 2:
+
+
Input: nums = [3,2,1,2,1,7]
+Output: 6
+Explanation: After 6 moves, the array could be [3, 4, 1, 2, 5, 7].
+It can be shown with 5 or less moves that it is impossible for the array to have all unique values.
+
+
+
+
Constraints:
+
+
+ 1 <= nums.length <= 1050 <= nums[i] <= 105
+
Medium
You start with an initial power of power, an initial score of 0, and a bag of tokens given as an integer array tokens, where each tokens[i] donates the value of tokeni.
+
+
Your goal is to maximize the total score by strategically playing these tokens. In one move, you can play an unplayed token in one of the two ways (but not both for the same token):
+
+
+ - Face-up: If your current power is at least
tokens[i], you may play tokeni, losing tokens[i] power and gaining 1 score.
+ - Face-down: If your current score is at least
1, you may play tokeni, gaining tokens[i] power and losing 1 score.
+
+
+
Return the maximum possible score you can achieve after playing any number of tokens.
+
+
+
Example 1:
+
+
+
Input: tokens = [100], power = 50
+
+
Output: 0
+
+
Explanation: Since your score is 0 initially, you cannot play the token face-down. You also cannot play it face-up since your power (50) is less than tokens[0] (100).
+
+
+
Example 2:
+
+
+
Input: tokens = [200,100], power = 150
+
+
Output: 1
+
+
Explanation: Play token1 (100) face-up, reducing your power to 50 and increasing your score to 1.
+
+
There is no need to play token0, since you cannot play it face-up to add to your score. The maximum score achievable is 1.
+
+
+
Example 3:
+
+
+
Input: tokens = [100,200,300,400], power = 200
+
+
Output: 2
+
+
Explanation: Play the tokens in this order to get a score of 2:
+
+
+ - Play token0 (
100) face-up, reducing power to 100 and increasing score to 1.
+ - Play token3 (
400) face-down, increasing power to 500 and reducing score to 0.
+ - Play token1 (
200) face-up, reducing power to 300 and increasing score to 1.
+ - Play token2 (
300) face-up, reducing power to 0 and increasing score to 2.
+
+
+
The maximum score achievable is 2.
+
+
+
+
Constraints:
+
+
+ 0 <= tokens.length <= 10000 <= tokens[i], power < 104
+
Medium
You are given an integer array deck. There is a deck of cards where every card has a unique integer. The integer on the ith card is deck[i].
+
+
You can order the deck in any order you want. Initially, all the cards start face down (unrevealed) in one deck.
+
+
You will 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 then put the next top card of the deck at the bottom of the deck.
+ - If there are still unrevealed cards, go back to step 1. Otherwise, stop.
+
+
+
Return an ordering of the deck that would reveal the cards in increasing order.
+
+
Note that the first entry in the answer is considered to be the top of the deck.
+
+
+
Example 1:
+
+
Input: deck = [17,13,11,2,3,5,7]
+Output: [2,13,3,11,5,17,7]
+Explanation:
+We get the deck in the order [17,13,11,2,3,5,7] (this order does not matter), and reorder it.
+After reordering, the deck starts as [2,13,3,11,5,17,7], where 2 is the top of the deck.
+We reveal 2, and move 13 to the bottom. The deck is now [3,11,5,17,7,13].
+We reveal 3, and move 11 to the bottom. The deck is now [5,17,7,13,11].
+We reveal 5, and move 17 to the bottom. The deck is now [7,13,11,17].
+We reveal 7, and move 13 to the bottom. The deck is now [11,17,13].
+We reveal 11, and move 17 to the bottom. The deck is now [13,17].
+We reveal 13, and move 17 to the bottom. The deck is now [17].
+We reveal 17.
+Since all the cards revealed are in increasing order, the answer is correct.
+
+
+
Example 2:
+
+
Input: deck = [1,1000]
+Output: [1,1000]
+
+
+
+
Constraints:
+
+
+ 1 <= deck.length <= 10001 <= deck[i] <= 106- All the values of
deck are unique.
+
+
Medium
An n x n grid is composed of 1 x 1 squares where each 1 x 1 square consists of a '/', '\', or blank space ' '. These characters divide the square into contiguous regions.
+
+
Given the grid grid represented as a string array, return the number of regions.
+
+
Note that backslash characters are escaped, so a '\' is represented as '\\'.
+
+
+
Example 1:
+
+
Input: grid = [" /","/ "]
+Output: 2
+
+
+
Example 2:
+
+
Input: grid = [" /"," "]
+Output: 1
+
+
+
Example 3:
+
+
Input: grid = ["/\\","\\/"]
+Output: 5
+Explanation: Recall that because \ characters are escaped, "\\/" refers to \/, and "/\\" refers to /\.
+
+
+
+
Constraints:
+
+
+ n == grid.length == grid[i].length1 <= n <= 30grid[i][j] is either '/', '\', or ' '.
+
Easy
Given an integer array nums sorted in non-decreasing order, return an array of the squares of each number sorted in non-decreasing order.
+
+
+
Example 1:
+
+
Input: nums = [-4,-1,0,3,10]
+Output: [0,1,9,16,100]
+Explanation: After squaring, the array becomes [16,1,0,9,100].
+After sorting, it becomes [0,1,9,16,100].
+
+
+
Example 2:
+
+
Input: nums = [-7,-3,2,3,11]
+Output: [4,9,9,49,121]
+
+
+
+
Constraints:
+
+
+ 1 <= nums.length <= 104-104 <= nums[i] <= 104nums is sorted in non-decreasing order.
+
+
+
Follow up: Squaring each element and sorting the new array is very trivial, could you find an
O(n) solution using a different approach?
Medium
You are given the root of a binary tree with n nodes where each node in the tree has node.val coins. There are n coins in total throughout the whole tree.
+
+
In one move, we may choose two adjacent nodes and move one coin from one node to another. A move may be from parent to child, or from child to parent.
+
+
Return the minimum number of moves required to make every node have exactly one coin.
+
+
+
Example 1:
+
+
Input: root = [3,0,0]
+Output: 2
+Explanation: From the root of the tree, we move one coin to its left child, and one coin to its right child.
+
+
+
Example 2:
+
+
Input: root = [0,3,0]
+Output: 3
+Explanation: From the left child of the root, we move two coins to the root [taking two moves]. Then, we move one coin from the root of the tree to the right child.
+
+
+
+
Constraints:
+
+
+ - The number of nodes in the tree is
n.
+ 1 <= n <= 1000 <= Node.val <= n- The sum of all
Node.val is n.
+
+
Hard
Given the root of a binary tree, calculate the vertical order traversal of the binary tree.
+
+
For each node at position (row, col), its left and right children will be at positions (row + 1, col - 1) and (row + 1, col + 1) respectively. The root of the tree is at (0, 0).
+
+
The vertical order traversal of a binary tree is a list of top-to-bottom orderings for each column index starting from the leftmost column and ending on the rightmost column. There may be multiple nodes in the same row and same column. In such a case, sort these nodes by their values.
+
+
Return the vertical order traversal of the binary tree.
+
+
+
Example 1:
+
+
Input: root = [3,9,20,null,null,15,7]
+Output: [[9],[3,15],[20],[7]]
+Explanation:
+Column -1: Only node 9 is in this column.
+Column 0: Nodes 3 and 15 are in this column in that order from top to bottom.
+Column 1: Only node 20 is in this column.
+Column 2: Only node 7 is in this column.
+
+
Example 2:
+
+
Input: root = [1,2,3,4,5,6,7]
+Output: [[4],[2],[1,5,6],[3],[7]]
+Explanation:
+Column -2: Only node 4 is in this column.
+Column -1: Only node 2 is in this column.
+Column 0: Nodes 1, 5, and 6 are in this column.
+ 1 is at the top, so it comes first.
+ 5 and 6 are at the same position (2, 0), so we order them by their value, 5 before 6.
+Column 1: Only node 3 is in this column.
+Column 2: Only node 7 is in this column.
+
+
+
Example 3:
+
+
Input: root = [1,2,3,4,6,5,7]
+Output: [[4],[2],[1,5,6],[3],[7]]
+Explanation:
+This case is the exact same as example 2, but with nodes 5 and 6 swapped.
+Note that the solution remains the same since 5 and 6 are in the same location and should be ordered by their values.
+
+
+
+
Constraints:
+
+
+ - The number of nodes in the tree is in the range
[1, 1000].
+ 0 <= Node.val <= 1000
+
Medium
You are given the root of a binary tree where each node has a value in the range [0, 25] representing the letters 'a' to 'z'.
+
+
Return 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".
+
+
+
A leaf of a node is a node that has no children.
+
+
+
Example 1:
+
+
Input: root = [0,1,2,3,4,3,4]
+Output: "dba"
+
+
+
Example 2:
+
+
Input: root = [25,1,3,1,3,0,2]
+Output: "adz"
+
+
+
Example 3:
+
+
Input: root = [2,2,1,null,1,0,null,0]
+Output: "abc"
+
+
+
+
Constraints:
+
+
+ - The number of nodes in the tree is in the range
[1, 8500].
+ 0 <= Node.val <= 25
+
Hard
Given an integer array nums and an integer k, return the number of good subarrays of nums.
+
+
A good array is an array where the number of different integers in that array is exactly k.
+
+
+ - For example,
[1,2,3,1,2] has 3 different integers: 1, 2, and 3.
+
+
+
A subarray is a contiguous part of an array.
+
+
+
Example 1:
+
+
Input: nums = [1,2,1,2,3], k = 2
+Output: 7
+Explanation: Subarrays formed with exactly 2 different integers: [1,2], [2,1], [1,2], [2,3], [1,2,1], [2,1,2], [1,2,1,2]
+
+
+
Example 2:
+
+
Input: nums = [1,2,1,3,4], k = 3
+Output: 3
+Explanation: Subarrays formed with exactly 3 different integers: [1,2,1,3], [2,1,3], [1,3,4].
+
+
+
+
Constraints:
+
+
+ 1 <= nums.length <= 2 * 1041 <= nums[i], k <= nums.length
+
Hard
You are given a binary array nums and an integer k.
+
+
A k-bit flip is choosing a subarray of length k from nums 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. If it is not possible, return -1.
+
+
A subarray is a contiguous part of an array.
+
+
+
Example 1:
+
+
Input: nums = [0,1,0], k = 1
+Output: 2
+Explanation: Flip nums[0], then flip nums[2].
+
+
+
Example 2:
+
+
Input: nums = [1,1,0], k = 2
+Output: -1
+Explanation: No matter how we flip subarrays of size 2, we cannot make the array become [1,1,1].
+
+
+
Example 3:
+
+
Input: nums = [0,0,0,1,0,1,1,0], k = 3
+Output: 3
+Explanation:
+Flip nums[0],nums[1],nums[2]: nums becomes [1,1,1,1,0,1,1,0]
+Flip nums[4],nums[5],nums[6]: nums becomes [1,1,1,1,1,0,0,0]
+Flip nums[5],nums[6],nums[7]: nums becomes [1,1,1,1,1,1,1,1]
+
+
+
+
Constraints:
+
+
+ 1 <= nums.length <= 1051 <= k <= nums.length
+
Easy
Design a HashMap without using any built-in hash table libraries.
+
+
Implement the MyHashMap class:
+
+
+ MyHashMap() initializes the object with an empty map.void put(int key, int value) inserts a (key, value) pair into the HashMap. If the key already exists in the map, update the corresponding value.int get(int key) returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key.void remove(key) removes the key and its corresponding value if the map contains the mapping for the key.
+
+
+
Example 1:
+
+
Input
+["MyHashMap", "put", "put", "get", "get", "put", "get", "remove", "get"]
+[[], [1, 1], [2, 2], [1], [3], [2, 1], [2], [2], [2]]
+Output
+[null, null, null, 1, -1, null, 1, null, -1]
+
+Explanation
+MyHashMap myHashMap = new MyHashMap();
+myHashMap.put(1, 1); // The map is now [[1,1]]
+myHashMap.put(2, 2); // The map is now [[1,1], [2,2]]
+myHashMap.get(1); // return 1, The map is now [[1,1], [2,2]]
+myHashMap.get(3); // return -1 (i.e., not found), The map is now [[1,1], [2,2]]
+myHashMap.put(2, 1); // The map is now [[1,1], [2,1]] (i.e., update the existing value)
+myHashMap.get(2); // return 1, The map is now [[1,1], [2,1]]
+myHashMap.remove(2); // remove the mapping for 2, The map is now [[1,1]]
+myHashMap.get(2); // return -1 (i.e., not found), The map is now [[1,1]]
+
+
+
+
Constraints:
+
+
+ 0 <= key, value <= 106- At most
104 calls will be made to put, get, and remove.
+
+
Medium
Given an array of unique integers, arr, where each integer arr[i] is strictly greater than 1.
+
+
We make a binary tree using these integers, and each number may be used for any number of times. Each non-leaf node's value should be equal to the product of the values of its children.
+
+
Return the number of binary trees we can make. The answer may be too large so return the answer modulo 109 + 7.
+
+
+
Example 1:
+
+
Input: arr = [2,4]
+Output: 3
+Explanation: We can make these trees: [2], [4], [4, 2, 2]
+
+
Example 2:
+
+
Input: arr = [2,4,5,10]
+Output: 7
+Explanation: We can make these trees: [2], [4], [5], [10], [4, 2, 2], [10, 2, 5], [10, 5, 2].
+
+
+
Constraints:
+
+
+ 1 <= arr.length <= 10002 <= arr[i] <= 109- All the values of
arr are unique.
+
+
Hard
You are given an array of integers 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.
+
+
+
Example 1:
+
+
Input: nums = [1,3,-1,-3,5,3,6,7], k = 3
+Output: [3,3,5,5,6,7]
+Explanation:
+Window position Max
+--------------- -----
+[1 3 -1] -3 5 3 6 7 3
+ 1 [3 -1 -3] 5 3 6 7 3
+ 1 3 [-1 -3 5] 3 6 7 5
+ 1 3 -1 [-3 5 3] 6 7 5
+ 1 3 -1 -3 [5 3 6] 7 6
+ 1 3 -1 -3 5 [3 6 7] 7
+
+
+
Example 2:
+
+
Input: nums = [1], k = 1
+Output: [1]
+
+
+
+
Constraints:
+
+
+ 1 <= nums.length <= 105-104 <= nums[i] <= 1041 <= k <= nums.length
+
Medium
Given a string s, return the longest palindromic substring in s.
+
+
+
Example 1:
+
+
Input: s = "babad"
+Output: "bab"
+Explanation: "aba" is also a valid answer.
+
+
+
Example 2:
+
+
Input: s = "cbbd"
+Output: "bb"
+
+
+
+
Constraints:
+
+
+ 1 <= s.length <= 1000s consist of only digits and English letters.
+
Medium
Given an array of 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.
+
+
+
Example 1:
+
+
Input: nums = [1,2,3,4]
+Output: false
+Explanation: There is no 132 pattern in the sequence.
+
+
+
Example 2:
+
+
Input: nums = [3,1,4,2]
+Output: true
+Explanation: There is a 132 pattern in the sequence: [1, 4, 2].
+
+
+
Example 3:
+
+
Input: nums = [-1,3,2,0]
+Output: true
+Explanation: There are three 132 patterns in the sequence: [-1, 3, 2], [-1, 3, 0] and [-1, 2, 0].
+
+
+
+
Constraints:
+
+
+ n == nums.length1 <= n <= 2 * 105-109 <= nums[i] <= 109
+
Easy
You are given an integer array cost where cost[i] is the cost of ith step on a staircase. Once you pay the cost, you can either climb one or two steps.
+
+
You can either start from the step with index 0, or the step with index 1.
+
+
Return the minimum cost to reach the top of the floor.
+
+
+
Example 1:
+
+
Input: cost = [10,15,20]
+Output: 15
+Explanation: You will start at index 1.
+- Pay 15 and climb two steps to reach the top.
+The total cost is 15.
+
+
+
Example 2:
+
+
Input: cost = [1,100,1,1,1,100,1,1,100,1]
+Output: 6
+Explanation: You will start at index 0.
+- Pay 1 and climb two steps to reach index 2.
+- Pay 1 and climb two steps to reach index 4.
+- Pay 1 and climb two steps to reach index 6.
+- Pay 1 and climb one step to reach index 7.
+- Pay 1 and climb two steps to reach index 9.
+- Pay 1 and climb one step to reach the top.
+The total cost is 6.
+
+
+
+
Constraints:
+
+
+ 2 <= cost.length <= 10000 <= cost[i] <= 999
+
Easy
Given two string arrays word1 and word2, return true if the two arrays represent the same string, and false otherwise.
+
+
A string is represented by an array if the array elements concatenated in order forms the string.
+
+
+
Example 1:
+
+
Input: word1 = ["ab", "c"], word2 = ["a", "bc"]
+Output: true
+Explanation:
+word1 represents string "ab" + "c" -> "abc"
+word2 represents string "a" + "bc" -> "abc"
+The strings are the same, so return true.
+
+
Example 2:
+
+
Input: word1 = ["a", "cb"], word2 = ["ab", "c"]
+Output: false
+
+
+
Example 3:
+
+
Input: word1 = ["abc", "d", "defg"], word2 = ["abcddefg"]
+Output: true
+
+
+
+
Constraints:
+
+
+ 1 <= word1.length, word2.length <= 1031 <= word1[i].length, word2[i].length <= 1031 <= sum(word1[i].length), sum(word2[i].length) <= 103word1[i] and word2[i] consist of lowercase letters.
+
Easy
On a 2D plane, there are n points with integer coordinates points[i] = [xi, yi]. Return the minimum time in seconds to visit all the points in the order given by points.
+
+
You can move according to these rules:
+
+
+ - In
1 second, you can either:
+
+
+ - move vertically by one unit,
+ - move horizontally by one unit, or
+ - move diagonally
sqrt(2) units (in other words, move one unit vertically then one unit horizontally in 1 second).
+
+
+ - You have to visit the points in the same order as they appear in the array.
+ - You are allowed to pass through points that appear later in the order, but these do not count as visits.
+
+
+
+
Example 1:
+
+
Input: points = [[1,1],[3,4],[-1,0]]
+Output: 7
+Explanation: One optimal path is [1,1] -> [2,2] -> [3,3] -> [3,4] -> [2,3] -> [1,2] -> [0,1] -> [-1,0]
+Time from [1,1] to [3,4] = 3 seconds
+Time from [3,4] to [-1,0] = 4 seconds
+Total time = 7 seconds
+
+
Example 2:
+
+
Input: points = [[3,2],[-2,2]]
+Output: 5
+
+
+
+
Constraints:
+
+
+ points.length == n1 <= n <= 100points[i].length == 2-1000 <= points[i][0], points[i][1] <= 1000
+
+
+
+
+
+
+
+
+
+
+
+
+
+