├── 0 - 1 Knapsack Problem - GFG
├── 0-1-knapsack-problem.py
└── README.md
├── 1-two-sum
├── 1-two-sum.py
├── NOTES.md
└── README.md
├── 100-same-tree
├── 100-same-tree.py
├── NOTES.md
└── README.md
├── 101-symmetric-tree
├── 101-symmetric-tree.py
├── NOTES.md
└── README.md
├── 104-maximum-depth-of-binary-tree
├── 104-maximum-depth-of-binary-tree.py
├── NOTES.md
└── README.md
├── 1046-last-stone-weight
├── 1046-last-stone-weight.py
├── NOTES.md
└── README.md
├── 110-balanced-binary-tree
├── 110-balanced-binary-tree.py
├── NOTES.md
└── README.md
├── 1108-defanging-an-ip-address
├── 1108-defanging-an-ip-address.py
├── NOTES.md
└── README.md
├── 111-minimum-depth-of-binary-tree
├── 111-minimum-depth-of-binary-tree.py
├── NOTES.md
└── README.md
├── 1143-longest-common-subsequence
├── 1143-longest-common-subsequence.py
├── NOTES.md
└── README.md
├── 1150-check-if-a-number-is-majority-element-in-a-sorted-array
├── 1150-check-if-a-number-is-majority-element-in-a-sorted-array.py
├── NOTES.md
└── README.md
├── 118-pascals-triangle
├── 118-pascals-triangle.py
├── NOTES.md
└── README.md
├── 1200-minimum-absolute-difference
├── 1200-minimum-absolute-difference.py
├── NOTES.md
└── README.md
├── 1207-unique-number-of-occurrences
├── 1207-unique-number-of-occurrences.py
├── NOTES.md
└── README.md
├── 121-best-time-to-buy-and-sell-stock
├── 121-best-time-to-buy-and-sell-stock.py
├── NOTES.md
└── README.md
├── 1249-minimum-remove-to-make-valid-parentheses
├── 1249-minimum-remove-to-make-valid-parentheses.py
├── NOTES.md
└── README.md
├── 125-valid-palindrome
├── 125-valid-palindrome.py
├── NOTES.md
└── README.md
├── 128-longest-consecutive-sequence
├── 128-longest-consecutive-sequence.py
├── NOTES.md
└── README.md
├── 1295-find-numbers-with-even-number-of-digits
├── 1295-find-numbers-with-even-number-of-digits.py
├── NOTES.md
└── README.md
├── 136-single-number
├── 136-single-number.py
├── NOTES.md
└── README.md
├── 1365-how-many-numbers-are-smaller-than-the-current-number
├── 1365-how-many-numbers-are-smaller-than-the-current-number.py
├── NOTES.md
└── README.md
├── 1389-create-target-array-in-the-given-order
├── 1389-create-target-array-in-the-given-order.py
├── NOTES.md
└── README.md
├── 14-longest-common-prefix
├── 14-longest-common-prefix.py
├── NOTES.md
└── README.md
├── 141-linked-list-cycle
├── 141-linked-list-cycle.py
├── NOTES.md
└── README.md
├── 142-linked-list-cycle-ii
├── 142-linked-list-cycle-ii.py
├── NOTES.md
└── README.md
├── 144-binary-tree-preorder-traversal
├── 144-binary-tree-preorder-traversal.py
├── NOTES.md
└── README.md
├── 1470-shuffle-the-array
├── 1470-shuffle-the-array.py
├── NOTES.md
└── README.md
├── 1480-running-sum-of-1d-array
├── 1480-running-sum-of-1d-array.py
├── NOTES.md
└── README.md
├── 151-reverse-words-in-a-string
├── 151-reverse-words-in-a-string.py
├── NOTES.md
└── README.md
├── 1512-number-of-good-pairs
├── 1512-number-of-good-pairs.py
├── NOTES.md
└── README.md
├── 1539-kth-missing-positive-number
├── 1539-kth-missing-positive-number.py
├── NOTES.md
└── README.md
├── 155-min-stack
├── 155-min-stack.py
├── NOTES.md
└── README.md
├── 160-intersection-of-two-linked-lists
├── 160-intersection-of-two-linked-lists.py
├── NOTES.md
└── README.md
├── 1662-check-if-two-string-arrays-are-equivalent
├── 1662-check-if-two-string-arrays-are-equivalent.py
├── NOTES.md
└── README.md
├── 167-two-sum-ii-input-array-is-sorted
├── 167-two-sum-ii-input-array-is-sorted.py
├── NOTES.md
└── README.md
├── 169-majority-element
├── 169-majority-element.py
├── NOTES.md
└── README.md
├── 1748-sum-of-unique-elements
├── 1748-sum-of-unique-elements.py
├── NOTES.md
└── README.md
├── 1822-sign-of-the-product-of-an-array
├── 1822-sign-of-the-product-of-an-array.py
├── NOTES.md
└── README.md
├── 1859-sorting-the-sentence
├── 1859-sorting-the-sentence.py
├── NOTES.md
└── README.md
├── 19-remove-nth-node-from-end-of-list
├── 19-remove-nth-node-from-end-of-list.py
├── NOTES.md
└── README.md
├── 1920-build-array-from-permutation
├── 1920-build-array-from-permutation.py
├── NOTES.md
└── README.md
├── 1929-concatenation-of-array
├── 1929-concatenation-of-array.py
├── NOTES.md
└── README.md
├── 2-add-two-numbers
├── 2-add-two-numbers.py
├── NOTES.md
└── README.md
├── 20-valid-parentheses
├── 20-valid-parentheses.py
├── NOTES.md
└── README.md
├── 2006-count-number-of-pairs-with-absolute-difference-k
├── 2006-count-number-of-pairs-with-absolute-difference-k.py
├── NOTES.md
└── README.md
├── 2011-final-value-of-variable-after-performing-operations
├── 2011-final-value-of-variable-after-performing-operations.py
├── NOTES.md
└── README.md
├── 206-reverse-linked-list
├── 206-reverse-linked-list.py
├── NOTES.md
└── README.md
├── 2089-find-target-indices-after-sorting-array
├── 2089-find-target-indices-after-sorting-array.py
├── NOTES.md
└── README.md
├── 2103-rings-and-rods
├── 2103-rings-and-rods.py
├── NOTES.md
└── README.md
├── 215-kth-largest-element-in-an-array
├── 215-kth-largest-element-in-an-array.py
├── NOTES.md
└── README.md
├── 217-contains-duplicate
├── 217-contains-duplicate.py
├── NOTES.md
└── README.md
├── 2176-count-equal-and-divisible-pairs-in-an-array
├── 2176-count-equal-and-divisible-pairs-in-an-array.py
└── README.md
├── 2235-add-two-integers
├── 2235-add-two-integers.py
├── NOTES.md
└── README.md
├── 226-invert-binary-tree
├── 226-invert-binary-tree.py
├── NOTES.md
└── README.md
├── 229-majority-element-ii
├── 229-majority-element-ii.py
├── NOTES.md
└── README.md
├── 232-implement-queue-using-stacks
├── 232-implement-queue-using-stacks.py
├── NOTES.md
└── README.md
├── 234-palindrome-linked-list
├── 234-palindrome-linked-list.py
├── NOTES.md
└── README.md
├── 237-delete-node-in-a-linked-list
├── 237-delete-node-in-a-linked-list.py
├── NOTES.md
└── README.md
├── 242-valid-anagram
├── 242-valid-anagram.py
├── NOTES.md
└── README.md
├── 257-binary-tree-paths
├── 257-binary-tree-paths.py
├── NOTES.md
└── README.md
├── 268-missing-number
├── 268-missing-number.py
├── NOTES.md
└── README.md
├── 278-first-bad-version
├── 278-first-bad-version.py
├── NOTES.md
└── README.md
├── 287-find-the-duplicate-number
├── 287-find-the-duplicate-number.py
├── NOTES.md
└── README.md
├── 31-next-permutation
├── 31-next-permutation.py
├── NOTES.md
└── README.md
├── 322-coin-change
├── 322-coin-change.py
├── NOTES.md
└── README.md
├── 346-moving-average-from-data-stream
├── 346-moving-average-from-data-stream.py
├── NOTES.md
└── README.md
├── 347-top-k-frequent-elements
├── 347-top-k-frequent-elements.py
├── NOTES.md
└── README.md
├── 349-intersection-of-two-arrays
├── 349-intersection-of-two-arrays.py
├── NOTES.md
└── README.md
├── 35-search-insert-position
├── 35-search-insert-position.py
├── NOTES.md
└── README.md
├── 359-logger-rate-limiter
├── 359-logger-rate-limiter.py
├── NOTES.md
└── README.md
├── 367-valid-perfect-square
├── 367-valid-perfect-square.py
├── NOTES.md
└── README.md
├── 37-sudoku-solver
├── 37-sudoku-solver.py
├── NOTES.md
└── README.md
├── 389-find-the-difference
├── 389-find-the-difference.py
├── NOTES.md
└── README.md
├── 412-fizz-buzz
├── 412-fizz-buzz.py
├── NOTES.md
└── README.md
├── 415-add-strings
├── 415-add-strings.py
├── NOTES.md
└── README.md
├── 416-partition-equal-subset-sum
├── 416-partition-equal-subset-sum.py
├── NOTES.md
└── README.md
├── 451-sort-characters-by-frequency
├── 451-sort-characters-by-frequency.py
├── NOTES.md
└── README.md
├── 48-rotate-image
├── 48-rotate-image.py
├── NOTES.md
└── README.md
├── 485-max-consecutive-ones
├── 485-max-consecutive-ones.py
├── NOTES.md
└── README.md
├── 50-powx-n
├── 50-powx-n.py
├── NOTES.md
└── README.md
├── 509-fibonacci-number
├── 509-fibonacci-number.py
├── NOTES.md
└── README.md
├── 53-maximum-subarray
├── 53-maximum-subarray.py
├── NOTES.md
└── README.md
├── 540-single-element-in-a-sorted-array
├── 540-single-element-in-a-sorted-array.py
├── NOTES.md
└── README.md
├── 543-diameter-of-binary-tree
├── 543-diameter-of-binary-tree.py
├── NOTES.md
└── README.md
├── 56-merge-intervals
├── 56-merge-intervals.py
├── NOTES.md
└── README.md
├── 572-subtree-of-another-tree
├── 572-subtree-of-another-tree.py
├── NOTES.md
└── README.md
├── 58-length-of-last-word
├── 58-length-of-last-word.py
├── NOTES.md
└── README.md
├── 589-n-ary-tree-preorder-traversal
├── 589-n-ary-tree-preorder-traversal.py
├── NOTES.md
└── README.md
├── 66-plus-one
├── 66-plus-one.py
├── NOTES.md
└── README.md
├── 69-sqrtx
├── 69-sqrtx.py
├── NOTES.md
└── README.md
├── 692-top-k-frequent-words
├── 692-top-k-frequent-words.py
├── NOTES.md
└── README.md
├── 704-binary-search
├── 704-binary-search.py
├── NOTES.md
└── README.md
├── 73-set-matrix-zeroes
├── 73-set-matrix-zeroes.py
├── NOTES.md
└── README.md
├── 74-search-a-2d-matrix
├── 74-search-a-2d-matrix.py
├── NOTES.md
└── README.md
├── 75-sort-colors
├── 75-sort-colors.py
├── NOTES.md
└── README.md
├── 818-race-car
├── 818-race-car.py
├── NOTES.md
└── README.md
├── 832-flipping-an-image
├── 832-flipping-an-image.py
├── NOTES.md
└── README.md
├── 844-backspace-string-compare
├── 844-backspace-string-compare.py
├── NOTES.md
└── README.md
├── 852-peak-index-in-a-mountain-array
├── 852-peak-index-in-a-mountain-array.py
├── NOTES.md
└── README.md
├── 876-middle-of-the-linked-list
├── 876-middle-of-the-linked-list.py
├── NOTES.md
└── README.md
├── 88-merge-sorted-array
├── 88-merge-sorted-array.py
├── NOTES.md
└── README.md
├── 905-sort-array-by-parity
├── 905-sort-array-by-parity.py
├── NOTES.md
└── README.md
├── 912-sort-an-array
├── 912-sort-an-array.py
├── NOTES.md
└── README.md
├── Coin Change - GFG
├── README.md
└── coin-change.py
├── Find minimum and maximum element in an array - GFG
├── README.md
└── find-minimum-and-maximum-element-in-an-array.py
├── Height of Binary Tree - GFG
├── README.md
└── height-of-binary-tree.py
├── Knapsack with Duplicate Items - GFG
├── README.md
└── knapsack-with-duplicate-items.py
├── Longest Common Substring - GFG
├── README.md
└── longest-common-substring.py
├── Perfect Sum Problem - GFG
├── README.md
└── perfect-sum-problem.py
├── Print adjacency list - GFG
├── README.md
└── print-adjacency-list.py
├── README.md
├── Rod Cutting - GFG
├── README.md
└── rod-cutting.py
├── set-matrix-zeroes
├── README.md
└── set-matrix-zeroes.py
├── smallest-integer-divisible-by-k
├── README.md
└── smallest-integer-divisible-by-k.py
└── two-sum
├── README.md
└── two-sum.py
/0 - 1 Knapsack Problem - GFG/0-1-knapsack-problem.py:
--------------------------------------------------------------------------------
1 | #User function Template for python3
2 |
3 | class Solution:
4 |
5 | #Function to return max value that can be put in knapsack of capacity W.
6 | def knapSack(self,W, wt, val, n):
7 | #taking a matrix of W+1 columns and n+1 rows.
8 | DP = []
9 | for row in range(n+1):
10 | columns = [-1] * (W+1)
11 | DP.append(columns)
12 |
13 | #Initialization(equivalent to the recursive code )
14 | for i in range(n+1):
15 | for j in range(W+1):
16 | if i == 0 or j == 0:
17 | DP[i][j] = 0
18 | #filling the remaining ones.
19 | for i in range(1, n+1):
20 | for j in range(1, W+1):
21 | if wt[i-1] <= j:
22 | DP[i][j] = max(val[i-1]+DP[i-1][j-wt[i-1]], DP[i-1][j])
23 | else:
24 | DP[i][j] = DP[i-1][j]
25 | return DP[n][W]
26 |
27 |
28 | #{
29 | # Driver Code Starts
30 | #Initial Template for Python 3
31 | import atexit
32 | import io
33 | import sys
34 |
35 | # Contributed by : Nagendra Jha
36 |
37 | if __name__ == '__main__':
38 | test_cases = int(input())
39 | for cases in range(test_cases):
40 | n = int(input())
41 | W = int(input())
42 | val = list(map(int,input().strip().split()))
43 | wt = list(map(int,input().strip().split()))
44 | ob=Solution()
45 | print(ob.knapSack(W,wt,val,n))
46 | # } Driver Code Ends
--------------------------------------------------------------------------------
/1-two-sum/1-two-sum.py:
--------------------------------------------------------------------------------
1 | class Solution:
2 | def twoSum(self, nums: List[int], target: int) -> List[int]:
3 | D = {}
4 | D[nums[0]] = 0
5 | for n in range(1, len(nums)):
6 | diff = target - nums[n]
7 | if diff in D:
8 | return [D[diff], n]
9 | else:
10 | D[nums[n]] = n
11 |
12 |
--------------------------------------------------------------------------------
/1-two-sum/NOTES.md:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/1-two-sum/README.md:
--------------------------------------------------------------------------------
1 | Easy
Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.
2 |
3 |
You may assume that each input would have exactly one solution, and you may not use the same element twice.
4 |
5 |
You can return the answer in any order.
6 |
7 |
8 |
Example 1:
9 |
10 |
Input: nums = [2,7,11,15], target = 9
11 | Output: [0,1]
12 | Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].
13 |
14 |
15 |
Example 2:
16 |
17 |
Input: nums = [3,2,4], target = 6
18 | Output: [1,2]
19 |
20 |
21 |
Example 3:
22 |
23 |
Input: nums = [3,3], target = 6
24 | Output: [0,1]
25 |
26 |
27 |
28 |
Constraints:
29 |
30 |
31 | 2 <= nums.length <= 104-109 <= nums[i] <= 109-109 <= target <= 109- Only one valid answer exists.
35 |
36 |
37 |
38 |
Follow-up: Can you come up with an algorithm that is less than
O(n2) time complexity?
Easy
Given the roots of two binary trees p and q, write a function to check if they are the same or not.
2 |
3 |
Two binary trees are considered the same if they are structurally identical, and the nodes have the same value.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: p = [1,2,3], q = [1,2,3]
9 | Output: true
10 |
11 |
12 |
Example 2:
13 |
14 |
Input: p = [1,2], q = [1,null,2]
15 | Output: false
16 |
17 |
18 |
Example 3:
19 |
20 |
Input: p = [1,2,1], q = [1,1,2]
21 | Output: false
22 |
23 |
24 |
25 |
Constraints:
26 |
27 |
28 | - The number of nodes in both trees is in the range
[0, 100].
29 | -104 <= Node.val <= 104
31 |
Easy
Given the root of a binary tree, check whether it is a mirror of itself (i.e., symmetric around its center).
2 |
3 |
4 |
Example 1:
5 |
6 |
Input: root = [1,2,2,3,4,4,3]
7 | Output: true
8 |
9 |
10 |
Example 2:
11 |
12 |
Input: root = [1,2,2,null,3,null,3]
13 | Output: false
14 |
15 |
16 |
17 |
Constraints:
18 |
19 |
20 | - The number of nodes in the tree is in the range
[1, 1000].
21 | -100 <= Node.val <= 100
23 |
24 |
25 |
Follow up: Could you solve it both recursively and iteratively?
Easy
Given the root of a binary tree, return its maximum depth.
2 |
3 |
A binary tree's maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: root = [3,9,20,null,null,15,7]
9 | Output: 3
10 |
11 |
12 |
Example 2:
13 |
14 |
Input: root = [1,null,2]
15 | Output: 2
16 |
17 |
18 |
19 |
Constraints:
20 |
21 |
22 | - The number of nodes in the tree is in the range
[0, 104].
23 | -100 <= Node.val <= 100
25 |
Easy
Given a binary tree, determine if it is height-balanced.
2 |
3 |
For this problem, a height-balanced binary tree is defined as:
4 |
5 |
6 | a binary tree in which the left and right subtrees of every node differ in height by no more than 1.
7 |
8 |
9 |
10 |
Example 1:
11 |
12 |
Input: root = [3,9,20,null,null,15,7]
13 | Output: true
14 |
15 |
16 |
Example 2:
17 |
18 |
Input: root = [1,2,2,3,3,null,null,4,4]
19 | Output: false
20 |
21 |
22 |
Example 3:
23 |
24 |
Input: root = []
25 | Output: true
26 |
27 |
28 |
29 |
Constraints:
30 |
31 |
32 | - The number of nodes in the tree is in the range
[0, 5000].
33 | -104 <= Node.val <= 104
35 |
Easy
Given a valid (IPv4) IP address, return a defanged version of that IP address.
2 |
3 |
A defanged IP address replaces every period "." with "[.]".
4 |
5 |
6 |
Example 1:
7 |
Input: address = "1.1.1.1"
8 | Output: "1[.]1[.]1[.]1"
9 |
Example 2:
10 |
Input: address = "255.100.50.0"
11 | Output: "255[.]100[.]50[.]0"
12 |
13 |
14 |
Constraints:
15 |
16 |
17 | - The given
address is a valid IPv4 address.
18 |
Easy
Given a binary tree, find its minimum depth.
2 |
3 |
The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.
4 |
5 |
Note: A leaf is a node with no children.
6 |
7 |
8 |
Example 1:
9 |
10 |
Input: root = [3,9,20,null,null,15,7]
11 | Output: 2
12 |
13 |
14 |
Example 2:
15 |
16 |
Input: root = [2,null,3,null,4,null,5,null,6]
17 | Output: 5
18 |
19 |
20 |
21 |
Constraints:
22 |
23 |
24 | - The number of nodes in the tree is in the range
[0, 105].
25 | -1000 <= Node.val <= 1000
27 |
Easy
Given an integer array nums sorted in non-decreasing order and an integer target, return true if target is a majority element, or false otherwise.
2 |
3 |
A majority element in an array nums is an element that appears more than nums.length / 2 times in the array.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: nums = [2,4,5,5,5,5,5,6,6], target = 5
9 | Output: true
10 | Explanation: The value 5 appears 5 times and the length of the array is 9.
11 | Thus, 5 is a majority element because 5 > 9/2 is true.
12 |
13 |
14 |
Example 2:
15 |
16 |
Input: nums = [10,100,101,101], target = 101
17 | Output: false
18 | Explanation: The value 101 appears 2 times and the length of the array is 4.
19 | Thus, 101 is not a majority element because 2 > 4/2 is false.
20 |
21 |
22 |
23 |
Constraints:
24 |
25 |
26 | 1 <= nums.length <= 10001 <= nums[i], target <= 109nums is sorted in non-decreasing order.
30 |
Easy
Given an integer numRows, return the first numRows of Pascal's triangle.
2 |
3 |
In Pascal's triangle, each number is the sum of the two numbers directly above it as shown:
4 |
5 |
6 |
Example 1:
7 |
Input: numRows = 5
8 | Output: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]
9 |
Example 2:
10 |
Input: numRows = 1
11 | Output: [[1]]
12 |
13 |
14 |
Constraints:
15 |
16 |
17 | 1 <= numRows <= 30
19 |
Easy
Given an array of distinct integers arr, find all pairs of elements with the minimum absolute difference of any two elements.
2 |
3 |
Return a list of pairs in ascending order(with respect to pairs), each pair [a, b] follows
4 |
5 |
6 | a, b are from arra < bb - a equals to the minimum absolute difference of any two elements in arr
10 |
11 |
12 |
Example 1:
13 |
14 |
Input: arr = [4,2,1,3]
15 | Output: [[1,2],[2,3],[3,4]]
16 | Explanation: The minimum absolute difference is 1. List all pairs with difference equal to 1 in ascending order.
17 |
18 |
Example 2:
19 |
20 |
Input: arr = [1,3,6,10,15]
21 | Output: [[1,3]]
22 |
23 |
24 |
Example 3:
25 |
26 |
Input: arr = [3,8,-10,23,19,-4,-14,27]
27 | Output: [[-14,-10],[19,23],[23,27]]
28 |
29 |
30 |
31 |
Constraints:
32 |
33 |
34 | 2 <= arr.length <= 105-106 <= arr[i] <= 106
37 |
Easy
Given an array of integers arr, return true if the number of occurrences of each value in the array is unique, or false otherwise.
2 |
3 |
4 |
Example 1:
5 |
6 |
Input: arr = [1,2,2,1,1,3]
7 | Output: true
8 | Explanation: The value 1 has 3 occurrences, 2 has 2 and 3 has 1. No two values have the same number of occurrences.
9 |
10 |
Example 2:
11 |
12 |
Input: arr = [1,2]
13 | Output: false
14 |
15 |
16 |
Example 3:
17 |
18 |
Input: arr = [-3,0,1,-3,1,1,1,-3,10,0]
19 | Output: true
20 |
21 |
22 |
23 |
Constraints:
24 |
25 |
26 | 1 <= arr.length <= 1000-1000 <= arr[i] <= 1000
29 |
Easy
You are given an array prices where prices[i] is the price of a given stock on the ith day.
2 |
3 |
You want to maximize your profit by choosing a single day to buy one stock and choosing a different day in the future to sell that stock.
4 |
5 |
Return the maximum profit you can achieve from this transaction. If you cannot achieve any profit, return 0.
6 |
7 |
8 |
Example 1:
9 |
10 |
Input: prices = [7,1,5,3,6,4]
11 | Output: 5
12 | Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5.
13 | Note that buying on day 2 and selling on day 1 is not allowed because you must buy before you sell.
14 |
15 |
16 |
Example 2:
17 |
18 |
Input: prices = [7,6,4,3,1]
19 | Output: 0
20 | Explanation: In this case, no transactions are done and the max profit = 0.
21 |
22 |
23 |
24 |
Constraints:
25 |
26 |
27 | 1 <= prices.length <= 1050 <= prices[i] <= 104
30 |
Easy
A phrase is a palindrome if, after converting all uppercase letters into lowercase letters and removing all non-alphanumeric characters, it reads the same forward and backward. Alphanumeric characters include letters and numbers.
2 |
3 |
Given a string s, return true if it is a palindrome, or false otherwise.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: s = "A man, a plan, a canal: Panama"
9 | Output: true
10 | Explanation: "amanaplanacanalpanama" is a palindrome.
11 |
12 |
13 |
Example 2:
14 |
15 |
Input: s = "race a car"
16 | Output: false
17 | Explanation: "raceacar" is not a palindrome.
18 |
19 |
20 |
Example 3:
21 |
22 |
Input: s = " "
23 | Output: true
24 | Explanation: s is an empty string "" after removing non-alphanumeric characters.
25 | Since an empty string reads the same forward and backward, it is a palindrome.
26 |
27 |
28 |
29 |
Constraints:
30 |
31 |
32 | 1 <= s.length <= 2 * 105s consists only of printable ASCII characters.
35 |
Medium
Given an unsorted array of integers nums, return the length of the longest consecutive elements sequence.
2 |
3 |
You must write an algorithm that runs in O(n) time.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: nums = [100,4,200,1,3,2]
9 | Output: 4
10 | Explanation: The longest consecutive elements sequence is [1, 2, 3, 4]. Therefore its length is 4.
11 |
12 |
13 |
Example 2:
14 |
15 |
Input: nums = [0,3,7,2,5,8,4,6,0,1]
16 | Output: 9
17 |
18 |
19 |
20 |
Constraints:
21 |
22 |
23 | 0 <= nums.length <= 105-109 <= nums[i] <= 109
26 |
Easy
Given an array nums of integers, return how many of them contain an even number of digits.
2 |
3 |
4 |
Example 1:
5 |
6 |
Input: nums = [12,345,2,6,7896]
7 | Output: 2
8 | Explanation:
9 | 12 contains 2 digits (even number of digits).
10 | 345 contains 3 digits (odd number of digits).
11 | 2 contains 1 digit (odd number of digits).
12 | 6 contains 1 digit (odd number of digits).
13 | 7896 contains 4 digits (even number of digits).
14 | Therefore only 12 and 7896 contain an even number of digits.
15 |
16 |
17 |
Example 2:
18 |
19 |
Input: nums = [555,901,482,1771]
20 | Output: 1
21 | Explanation:
22 | Only 1771 contains an even number of digits.
23 |
24 |
25 |
26 |
Constraints:
27 |
28 |
29 | 1 <= nums.length <= 5001 <= nums[i] <= 105
32 |
Easy
Given a non-empty array of integers nums, every element appears twice except for one. Find that single one.
2 |
3 |
You must implement a solution with a linear runtime complexity and use only constant extra space.
4 |
5 |
6 |
Example 1:
7 |
Input: nums = [2,2,1]
8 | Output: 1
9 |
Example 2:
10 |
Input: nums = [4,1,2,1,2]
11 | Output: 4
12 |
Example 3:
13 |
Input: nums = [1]
14 | Output: 1
15 |
16 |
17 |
Constraints:
18 |
19 |
20 | 1 <= nums.length <= 3 * 104-3 * 104 <= nums[i] <= 3 * 104- Each element in the array appears twice except for one element which appears only once.
23 |
24 |
Easy
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 such that j != i and nums[j] < nums[i].
2 |
3 |
Return the answer in an array.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: nums = [8,1,2,2,3]
9 | Output: [4,0,1,1,3]
10 | Explanation:
11 | For nums[0]=8 there exist four smaller numbers than it (1, 2, 2 and 3).
12 | For nums[1]=1 does not exist any smaller number than it.
13 | For nums[2]=2 there exist one smaller number than it (1).
14 | For nums[3]=2 there exist one smaller number than it (1).
15 | For nums[4]=3 there exist three smaller numbers than it (1, 2 and 2).
16 |
17 |
18 |
Example 2:
19 |
20 |
Input: nums = [6,5,4,8]
21 | Output: [2,1,0,3]
22 |
23 |
24 |
Example 3:
25 |
26 |
Input: nums = [7,7,7,7]
27 | Output: [0,0,0,0]
28 |
29 |
30 |
31 |
Constraints:
32 |
33 |
34 | 2 <= nums.length <= 5000 <= nums[i] <= 100
37 |
Easy
Write a function to find the longest common prefix string amongst an array of strings.
2 |
3 |
If there is no common prefix, return an empty string "".
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: strs = ["flower","flow","flight"]
9 | Output: "fl"
10 |
11 |
12 |
Example 2:
13 |
14 |
Input: strs = ["dog","racecar","car"]
15 | Output: ""
16 | Explanation: There is no common prefix among the input strings.
17 |
18 |
19 |
20 |
Constraints:
21 |
22 |
23 | 1 <= strs.length <= 2000 <= strs[i].length <= 200strs[i] consists of only lower-case English letters.
27 |
Easy
Given the root of a binary tree, return the preorder traversal of its nodes' values.
2 |
3 |
4 |
Example 1:
5 |
6 |
Input: root = [1,null,2,3]
7 | Output: [1,2,3]
8 |
9 |
10 |
Example 2:
11 |
12 |
Input: root = []
13 | Output: []
14 |
15 |
16 |
Example 3:
17 |
18 |
Input: root = [1]
19 | Output: [1]
20 |
21 |
22 |
23 |
Constraints:
24 |
25 |
26 | - The number of nodes in the tree is in the range
[0, 100].
27 | -100 <= Node.val <= 100
29 |
30 |
31 |
Follow up: Recursive solution is trivial, could you do it iteratively?
32 |
Easy
Given the array nums consisting of 2n elements in the form [x1,x2,...,xn,y1,y2,...,yn].
2 |
3 |
Return the array in the form [x1,y1,x2,y2,...,xn,yn].
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: nums = [2,5,1,3,4,7], n = 3
9 | Output: [2,3,5,4,1,7]
10 | Explanation: Since x1=2, x2=5, x3=1, y1=3, y2=4, y3=7 then the answer is [2,3,5,4,1,7].
11 |
12 |
13 |
Example 2:
14 |
15 |
Input: nums = [1,2,3,4,4,3,2,1], n = 4
16 | Output: [1,4,2,3,3,2,4,1]
17 |
18 |
19 |
Example 3:
20 |
21 |
Input: nums = [1,1,2,2], n = 2
22 | Output: [1,2,1,2]
23 |
24 |
25 |
26 |
Constraints:
27 |
28 |
29 | 1 <= n <= 500nums.length == 2n1 <= nums[i] <= 10^3
Easy
Given an array nums. We define a running sum of an array as runningSum[i] = sum(nums[0]…nums[i]).
2 |
3 |
Return the running sum of nums.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: nums = [1,2,3,4]
9 | Output: [1,3,6,10]
10 | Explanation: Running sum is obtained as follows: [1, 1+2, 1+2+3, 1+2+3+4].
11 |
12 |
Example 2:
13 |
14 |
Input: nums = [1,1,1,1,1]
15 | Output: [1,2,3,4,5]
16 | Explanation: Running sum is obtained as follows: [1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1].
17 |
18 |
Example 3:
19 |
20 |
Input: nums = [3,1,2,10,1]
21 | Output: [3,4,6,16,17]
22 |
23 |
24 |
25 |
Constraints:
26 |
27 |
28 | 1 <= nums.length <= 1000-10^6 <= nums[i] <= 10^6
Easy
Given an array of integers nums, return the number of good pairs.
2 |
3 |
A pair (i, j) is called good if nums[i] == nums[j] and i < j.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: nums = [1,2,3,1,1,3]
9 | Output: 4
10 | Explanation: There are 4 good pairs (0,3), (0,4), (3,4), (2,5) 0-indexed.
11 |
12 |
13 |
Example 2:
14 |
15 |
Input: nums = [1,1,1,1]
16 | Output: 6
17 | Explanation: Each pair in the array are good.
18 |
19 |
20 |
Example 3:
21 |
22 |
Input: nums = [1,2,3]
23 | Output: 0
24 |
25 |
26 |
27 |
Constraints:
28 |
29 |
30 | 1 <= nums.length <= 1001 <= nums[i] <= 100
33 |
Easy
Given an array arr of positive integers sorted in a strictly increasing order, and an integer k.
2 |
3 |
Find the kth positive integer that is missing from this array.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: arr = [2,3,4,7,11], k = 5
9 | Output: 9
10 | Explanation: The missing positive integers are [1,5,6,8,9,10,12,13,...]. The 5th missing positive integer is 9.
11 |
12 |
13 |
Example 2:
14 |
15 |
Input: arr = [1,2,3,4], k = 2
16 | Output: 6
17 | Explanation: The missing positive integers are [5,6,7,...]. The 2nd missing positive integer is 6.
18 |
19 |
20 |
21 |
Constraints:
22 |
23 |
24 | 1 <= arr.length <= 10001 <= arr[i] <= 10001 <= k <= 1000arr[i] < arr[j] for 1 <= i < j <= arr.length
29 |
Easy
Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.
2 |
3 |
Implement the MinStack class:
4 |
5 |
6 | MinStack() initializes the stack object.void push(int val) pushes the element val onto the stack.void pop() removes the element on the top of the stack.int top() gets the top element of the stack.int getMin() retrieves the minimum element in the stack.
12 |
13 |
14 |
Example 1:
15 |
16 |
Input
17 | ["MinStack","push","push","push","getMin","pop","top","getMin"]
18 | [[],[-2],[0],[-3],[],[],[],[]]
19 |
20 | Output
21 | [null,null,null,null,-3,null,0,-2]
22 |
23 | Explanation
24 | MinStack minStack = new MinStack();
25 | minStack.push(-2);
26 | minStack.push(0);
27 | minStack.push(-3);
28 | minStack.getMin(); // return -3
29 | minStack.pop();
30 | minStack.top(); // return 0
31 | minStack.getMin(); // return -2
32 |
33 |
34 |
35 |
Constraints:
36 |
37 |
38 | -231 <= val <= 231 - 1- Methods
pop, top and getMin operations will always be called on non-empty stacks.
40 | - At most
3 * 104 calls will be made to push, pop, top, and getMin.
41 |
42 |
Easy
Given two string arrays word1 and word2, return true if the two arrays represent the same string, and false otherwise.
2 |
3 |
A string is represented by an array if the array elements concatenated in order forms the string.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: word1 = ["ab", "c"], word2 = ["a", "bc"]
9 | Output: true
10 | Explanation:
11 | word1 represents string "ab" + "c" -> "abc"
12 | word2 represents string "a" + "bc" -> "abc"
13 | The strings are the same, so return true.
14 |
15 |
Example 2:
16 |
17 |
Input: word1 = ["a", "cb"], word2 = ["ab", "c"]
18 | Output: false
19 |
20 |
21 |
Example 3:
22 |
23 |
Input: word1 = ["abc", "d", "defg"], word2 = ["abcddefg"]
24 | Output: true
25 |
26 |
27 |
28 |
Constraints:
29 |
30 |
31 | 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.
36 |
Easy
Given an array nums of size n, return the majority element.
2 |
3 |
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.
4 |
5 |
6 |
Example 1:
7 |
Input: nums = [3,2,3]
8 | Output: 3
9 |
Example 2:
10 |
Input: nums = [2,2,1,1,1,2,2]
11 | Output: 2
12 |
13 |
14 |
Constraints:
15 |
16 |
17 | n == nums.length1 <= n <= 5 * 104-109 <= nums[i] <= 109
21 |
22 |
23 |
Follow-up: Could you solve the problem in linear time and in
O(1) space?
Easy
You are given an integer array nums. The unique elements of an array are the elements that appear exactly once in the array.
2 |
3 |
Return the sum of all the unique elements of nums.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: nums = [1,2,3,2]
9 | Output: 4
10 | Explanation: The unique elements are [1,3], and the sum is 4.
11 |
12 |
13 |
Example 2:
14 |
15 |
Input: nums = [1,1,1,1,1]
16 | Output: 0
17 | Explanation: There are no unique elements, and the sum is 0.
18 |
19 |
20 |
Example 3:
21 |
22 |
Input: nums = [1,2,3,4,5]
23 | Output: 15
24 | Explanation: The unique elements are [1,2,3,4,5], and the sum is 15.
25 |
26 |
27 |
28 |
Constraints:
29 |
30 |
31 | 1 <= nums.length <= 1001 <= nums[i] <= 100
34 |
Easy
There is a function signFunc(x) that returns:
2 |
3 |
4 | 1 if x is positive.-1 if x is negative.0 if x is equal to 0.
8 |
9 |
You are given an integer array nums. Let product be the product of all values in the array nums.
10 |
11 |
Return signFunc(product).
12 |
13 |
14 |
Example 1:
15 |
16 |
Input: nums = [-1,-2,-3,-4,3,2,1]
17 | Output: 1
18 | Explanation: The product of all values in the array is 144, and signFunc(144) = 1
19 |
20 |
21 |
Example 2:
22 |
23 |
Input: nums = [1,5,0,2,-3]
24 | Output: 0
25 | Explanation: The product of all values in the array is 0, and signFunc(0) = 0
26 |
27 |
28 |
Example 3:
29 |
30 |
Input: nums = [-1,1,-1,1,-1]
31 | Output: -1
32 | Explanation: The product of all values in the array is -1, and signFunc(-1) = -1
33 |
34 |
35 |
36 |
Constraints:
37 |
38 |
39 | 1 <= nums.length <= 1000-100 <= nums[i] <= 100
42 |
Medium
Given the head of a linked list, remove the nth node from the end of the list and return its head.
2 |
3 |
4 |
Example 1:
5 |
6 |
Input: head = [1,2,3,4,5], n = 2
7 | Output: [1,2,3,5]
8 |
9 |
10 |
Example 2:
11 |
12 |
Input: head = [1], n = 1
13 | Output: []
14 |
15 |
16 |
Example 3:
17 |
18 |
Input: head = [1,2], n = 1
19 | Output: [1]
20 |
21 |
22 |
23 |
Constraints:
24 |
25 |
26 | - The number of nodes in the list is
sz.
27 | 1 <= sz <= 300 <= Node.val <= 1001 <= n <= sz
31 |
32 |
33 |
Follow up: Could you do this in one pass?
34 |
Easy
Given an integer array nums of length n, you want to create an array ans of length 2n where ans[i] == nums[i] and ans[i + n] == nums[i] for 0 <= i < n (0-indexed).
2 |
3 |
Specifically, ans is the concatenation of two nums arrays.
4 |
5 |
Return the array ans.
6 |
7 |
8 |
Example 1:
9 |
10 |
Input: nums = [1,2,1]
11 | Output: [1,2,1,1,2,1]
12 | Explanation: The array ans is formed as follows:
13 | - ans = [nums[0],nums[1],nums[2],nums[0],nums[1],nums[2]]
14 | - ans = [1,2,1,1,2,1]
15 |
16 |
Example 2:
17 |
18 |
Input: nums = [1,3,2,1]
19 | Output: [1,3,2,1,1,3,2,1]
20 | Explanation: The array ans is formed as follows:
21 | - ans = [nums[0],nums[1],nums[2],nums[3],nums[0],nums[1],nums[2],nums[3]]
22 | - ans = [1,3,2,1,1,3,2,1]
23 |
24 |
25 |
26 |
Constraints:
27 |
28 |
29 | n == nums.length1 <= n <= 10001 <= nums[i] <= 1000
33 |
Medium
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 contains a single digit. Add the two numbers and return the sum as a linked list.
2 |
3 |
You may assume the two numbers do not contain any leading zero, except the number 0 itself.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: l1 = [2,4,3], l2 = [5,6,4]
9 | Output: [7,0,8]
10 | Explanation: 342 + 465 = 807.
11 |
12 |
13 |
Example 2:
14 |
15 |
Input: l1 = [0], l2 = [0]
16 | Output: [0]
17 |
18 |
19 |
Example 3:
20 |
21 |
Input: l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
22 | Output: [8,9,9,9,0,0,0,1]
23 |
24 |
25 |
26 |
Constraints:
27 |
28 |
29 | - The number of nodes in each linked list is in the range
[1, 100].
30 | 0 <= Node.val <= 9- It is guaranteed that the list represents a number that does not have leading zeros.
32 |
33 |
Easy
Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.
2 |
3 |
An input string is valid if:
4 |
5 |
6 | - Open brackets must be closed by the same type of brackets.
7 | - Open brackets must be closed in the correct order.
8 |
9 |
10 |
11 |
Example 1:
12 |
13 |
Input: s = "()"
14 | Output: true
15 |
16 |
17 |
Example 2:
18 |
19 |
Input: s = "()[]{}"
20 | Output: true
21 |
22 |
23 |
Example 3:
24 |
25 |
Input: s = "(]"
26 | Output: false
27 |
28 |
29 |
30 |
Constraints:
31 |
32 |
33 | 1 <= s.length <= 104s consists of parentheses only '()[]{}'.
36 |
Easy
Given the head of a singly linked list, reverse the list, and return the reversed list.
2 |
3 |
4 |
Example 1:
5 |
6 |
Input: head = [1,2,3,4,5]
7 | Output: [5,4,3,2,1]
8 |
9 |
10 |
Example 2:
11 |
12 |
Input: head = [1,2]
13 | Output: [2,1]
14 |
15 |
16 |
Example 3:
17 |
18 |
Input: head = []
19 | Output: []
20 |
21 |
22 |
23 |
Constraints:
24 |
25 |
26 | - The number of nodes in the list is the range
[0, 5000].
27 | -5000 <= Node.val <= 5000
29 |
30 |
31 |
Follow up: A linked list can be reversed either iteratively or recursively. Could you implement both?
32 |
Medium
Given an integer array nums and an integer k, return the kth largest element in the array.
2 |
3 |
Note that it is the kth largest element in the sorted order, not the kth distinct element.
4 |
5 |
6 |
Example 1:
7 |
Input: nums = [3,2,1,5,6,4], k = 2
8 | Output: 5
9 |
Example 2:
10 |
Input: nums = [3,2,3,1,2,4,5,5,6], k = 4
11 | Output: 4
12 |
13 |
14 |
Constraints:
15 |
16 |
17 | 1 <= k <= nums.length <= 104-104 <= nums[i] <= 104
20 |
Easy
Given an integer array nums, return true if any value appears at least twice in the array, and return false if every element is distinct.
2 |
3 |
4 |
Example 1:
5 |
Input: nums = [1,2,3,1]
6 | Output: true
7 |
Example 2:
8 |
Input: nums = [1,2,3,4]
9 | Output: false
10 |
Example 3:
11 |
Input: nums = [1,1,1,3,3,4,3,2,4,2]
12 | Output: true
13 |
14 |
15 |
Constraints:
16 |
17 |
18 | 1 <= nums.length <= 105-109 <= nums[i] <= 109
21 |
Easy
Given a
0-indexed integer array
nums of length
n and an integer
k, return
the number of pairs (i, j) where 0 <= i < j < n,
such that nums[i] == nums[j] and (i * j) is divisible by k.
2 |
3 |
Example 1:
4 |
5 |
Input: nums = [3,1,2,2,2,1,3], k = 2
6 | Output: 4
7 | Explanation:
8 | There are 4 pairs that meet all the requirements:
9 | - nums[0] == nums[6], and 0 * 6 == 0, which is divisible by 2.
10 | - nums[2] == nums[3], and 2 * 3 == 6, which is divisible by 2.
11 | - nums[2] == nums[4], and 2 * 4 == 8, which is divisible by 2.
12 | - nums[3] == nums[4], and 3 * 4 == 12, which is divisible by 2.
13 |
14 |
15 |
Example 2:
16 |
17 |
Input: nums = [1,2,3,4], k = 1
18 | Output: 0
19 | Explanation: Since no value in nums is repeated, there are no pairs (i,j) that meet all the requirements.
20 |
21 |
22 |
23 |
Constraints:
24 |
25 |
26 | 1 <= nums.length <= 1001 <= nums[i], k <= 100
29 |
Easy
Given two integers
num1 and
num2, return
the sum of the two integers.
2 |
3 |
Example 1:
4 |
5 |
Input: num1 = 12, num2 = 5
6 | Output: 17
7 | Explanation: num1 is 12, num2 is 5, and their sum is 12 + 5 = 17, so 17 is returned.
8 |
9 |
10 |
Example 2:
11 |
12 |
Input: num1 = -10, num2 = 4
13 | Output: -6
14 | Explanation: num1 + num2 = -6, so -6 is returned.
15 |
16 |
17 |
18 |
Constraints:
19 |
20 |
21 | -100 <= num1, num2 <= 100
23 |
Easy
Given the root of a binary tree, invert the tree, and return its root.
2 |
3 |
4 |
Example 1:
5 |
6 |
Input: root = [4,2,7,1,3,6,9]
7 | Output: [4,7,2,9,6,3,1]
8 |
9 |
10 |
Example 2:
11 |
12 |
Input: root = [2,1,3]
13 | Output: [2,3,1]
14 |
15 |
16 |
Example 3:
17 |
18 |
Input: root = []
19 | Output: []
20 |
21 |
22 |
23 |
Constraints:
24 |
25 |
26 | - The number of nodes in the tree is in the range
[0, 100].
27 | -100 <= Node.val <= 100
29 |
Medium
Given an integer array of size n, find all elements that appear more than ⌊ n/3 ⌋ times.
2 |
3 |
4 |
Example 1:
5 |
6 |
Input: nums = [3,2,3]
7 | Output: [3]
8 |
9 |
10 |
Example 2:
11 |
12 |
Input: nums = [1]
13 | Output: [1]
14 |
15 |
16 |
Example 3:
17 |
18 |
Input: nums = [1,2]
19 | Output: [1,2]
20 |
21 |
22 |
23 |
Constraints:
24 |
25 |
26 | 1 <= nums.length <= 5 * 104-109 <= nums[i] <= 109
29 |
30 |
31 |
Follow up: Could you solve the problem in linear time and in O(1) space?
32 |
Easy
Given the head of a singly linked list, return true if it is a palindrome.
2 |
3 |
4 |
Example 1:
5 |
6 |
Input: head = [1,2,2,1]
7 | Output: true
8 |
9 |
10 |
Example 2:
11 |
12 |
Input: head = [1,2]
13 | Output: false
14 |
15 |
16 |
17 |
Constraints:
18 |
19 |
20 | - The number of nodes in the list is in the range
[1, 105].
21 | 0 <= Node.val <= 9
23 |
24 |
25 |
Follow up: Could you do it in
O(n) time and
O(1) space?
Easy
Given two strings s and t, return true if t is an anagram of s, and false otherwise.
2 |
3 |
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.
4 |
5 |
6 |
Example 1:
7 |
Input: s = "anagram", t = "nagaram"
8 | Output: true
9 |
Example 2:
10 |
Input: s = "rat", t = "car"
11 | Output: false
12 |
13 |
14 |
Constraints:
15 |
16 |
17 | 1 <= s.length, t.length <= 5 * 104s and t consist of lowercase English letters.
20 |
21 |
22 |
Follow up: What if the inputs contain Unicode characters? How would you adapt your solution to such a case?
23 |
Easy
Given the root of a binary tree, return all root-to-leaf paths in any order.
2 |
3 |
A leaf is a node with no children.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: root = [1,2,3,null,5]
9 | Output: ["1->2->5","1->3"]
10 |
11 |
12 |
Example 2:
13 |
14 |
Input: root = [1]
15 | Output: ["1"]
16 |
17 |
18 |
19 |
Constraints:
20 |
21 |
22 | - The number of nodes in the tree is in the range
[1, 100].
23 | -100 <= Node.val <= 100
25 |
Easy
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.
2 |
3 |
Suppose you have n versions [1, 2, ..., n] and you want to find out the first bad one, which causes all the following ones to be bad.
4 |
5 |
You are given an API bool isBadVersion(version) which returns whether version is bad. Implement a function to find the first bad version. You should minimize the number of calls to the API.
6 |
7 |
8 |
Example 1:
9 |
10 |
Input: n = 5, bad = 4
11 | Output: 4
12 | Explanation:
13 | call isBadVersion(3) -> false
14 | call isBadVersion(5) -> true
15 | call isBadVersion(4) -> true
16 | Then 4 is the first bad version.
17 |
18 |
19 |
Example 2:
20 |
21 |
Input: n = 1, bad = 1
22 | Output: 1
23 |
24 |
25 |
26 |
Constraints:
27 |
28 |
29 | 1 <= bad <= n <= 231 - 1
31 |
Medium
Given an array of integers nums containing n + 1 integers where each integer is in the range [1, n] inclusive.
2 |
3 |
There is only one repeated number in nums, return this repeated number.
4 |
5 |
You must solve the problem without modifying the array nums and uses only constant extra space.
6 |
7 |
8 |
Example 1:
9 |
10 |
Input: nums = [1,3,4,2,2]
11 | Output: 2
12 |
13 |
14 |
Example 2:
15 |
16 |
Input: nums = [3,1,3,4,2]
17 | Output: 3
18 |
19 |
20 |
21 |
Constraints:
22 |
23 |
24 | 1 <= n <= 105nums.length == n + 11 <= nums[i] <= n- All the integers in
nums appear only once except for precisely one integer which appears two or more times.
28 |
29 |
30 |
31 |
Follow up:
32 |
33 |
34 | - How can we prove that at least one duplicate number must exist in
nums?
35 | - Can you solve the problem in linear runtime complexity?
36 |
37 |
Medium
You are given an integer array coins representing coins of different denominations and an integer amount representing a total amount of money.
2 |
3 |
Return 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.
4 |
5 |
You may assume that you have an infinite number of each kind of coin.
6 |
7 |
8 |
Example 1:
9 |
10 |
Input: coins = [1,2,5], amount = 11
11 | Output: 3
12 | Explanation: 11 = 5 + 5 + 1
13 |
14 |
15 |
Example 2:
16 |
17 |
Input: coins = [2], amount = 3
18 | Output: -1
19 |
20 |
21 |
Example 3:
22 |
23 |
Input: coins = [1], amount = 0
24 | Output: 0
25 |
26 |
27 |
28 |
Constraints:
29 |
30 |
31 | 1 <= coins.length <= 121 <= coins[i] <= 231 - 10 <= amount <= 104
35 |
Easy
Given a stream of integers and a window size, calculate the moving average of all integers in the sliding window.
2 |
3 |
Implement the MovingAverage class:
4 |
5 |
6 | MovingAverage(int size) Initializes the object with the size of the window size.double next(int val) Returns the moving average of the last size values of the stream.
9 |
10 |
11 |
Example 1:
12 |
13 |
Input
14 | ["MovingAverage", "next", "next", "next", "next"]
15 | [[3], [1], [10], [3], [5]]
16 | Output
17 | [null, 1.0, 5.5, 4.66667, 6.0]
18 |
19 | Explanation
20 | MovingAverage movingAverage = new MovingAverage(3);
21 | movingAverage.next(1); // return 1.0 = 1 / 1
22 | movingAverage.next(10); // return 5.5 = (1 + 10) / 2
23 | movingAverage.next(3); // return 4.66667 = (1 + 10 + 3) / 3
24 | movingAverage.next(5); // return 6.0 = (10 + 3 + 5) / 3
25 |
26 |
27 |
28 |
Constraints:
29 |
30 |
31 | 1 <= size <= 1000-105 <= val <= 105- At most
104 calls will be made to next.
34 |
35 |
Medium
Given an integer array nums and an integer k, return the k most frequent elements. You may return the answer in any order.
2 |
3 |
4 |
Example 1:
5 |
Input: nums = [1,1,1,2,2,3], k = 2
6 | Output: [1,2]
7 |
Example 2:
8 |
Input: nums = [1], k = 1
9 | Output: [1]
10 |
11 |
12 |
Constraints:
13 |
14 |
15 | 1 <= nums.length <= 105-104 <= nums[i] <= 104k is in the range [1, the number of unique elements in the array].- It is guaranteed that the answer is unique.
19 |
20 |
21 |
22 |
Follow up: Your algorithm's time complexity must be better than O(n log n), where n is the array's size.
23 |
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.
2 |
3 |
4 |
Example 1:
5 |
6 |
Input: nums1 = [1,2,2,1], nums2 = [2,2]
7 | Output: [2]
8 |
9 |
10 |
Example 2:
11 |
12 |
Input: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
13 | Output: [9,4]
14 | Explanation: [4,9] is also accepted.
15 |
16 |
17 |
18 |
Constraints:
19 |
20 |
21 | 1 <= nums1.length, nums2.length <= 10000 <= nums1[i], nums2[i] <= 1000
24 |
Easy
Given a sorted array of distinct integers 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.
2 |
3 |
You must write an algorithm with O(log n) runtime complexity.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: nums = [1,3,5,6], target = 5
9 | Output: 2
10 |
11 |
12 |
Example 2:
13 |
14 |
Input: nums = [1,3,5,6], target = 2
15 | Output: 1
16 |
17 |
18 |
Example 3:
19 |
20 |
Input: nums = [1,3,5,6], target = 7
21 | Output: 4
22 |
23 |
24 |
25 |
Constraints:
26 |
27 |
28 | 1 <= nums.length <= 104-104 <= nums[i] <= 104nums contains distinct values sorted in ascending order.-104 <= target <= 104
33 |
Easy
Given a positive integer num, write a function which returns True if num is a perfect square else False.
2 |
3 |
Follow up: Do not use any built-in library function such as sqrt.
4 |
5 |
6 |
Example 1:
7 |
Input: num = 16
8 | Output: true
9 |
Example 2:
10 |
Input: num = 14
11 | Output: false
12 |
13 |
14 |
Constraints:
15 |
16 |
17 | 1 <= num <= 2^31 - 1
19 |
Easy
You are given two strings s and t.
2 |
3 |
String t is generated by random shuffling string s and then add one more letter at a random position.
4 |
5 |
Return the letter that was added to t.
6 |
7 |
8 |
Example 1:
9 |
10 |
Input: s = "abcd", t = "abcde"
11 | Output: "e"
12 | Explanation: 'e' is the letter that was added.
13 |
14 |
15 |
Example 2:
16 |
17 |
Input: s = "", t = "y"
18 | Output: "y"
19 |
20 |
21 |
22 |
Constraints:
23 |
24 |
25 | 0 <= s.length <= 1000t.length == s.length + 1s and t consist of lowercase English letters.
29 |
Easy
Given an integer n, return a string array answer (1-indexed) where:
2 |
3 |
4 | answer[i] == "FizzBuzz" if i is divisible by 3 and 5.answer[i] == "Fizz" if i is divisible by 3.answer[i] == "Buzz" if i is divisible by 5.answer[i] == i (as a string) if none of the above conditions are true.
9 |
10 |
11 |
Example 1:
12 |
Input: n = 3
13 | Output: ["1","2","Fizz"]
14 |
Example 2:
15 |
Input: n = 5
16 | Output: ["1","2","Fizz","4","Buzz"]
17 |
Example 3:
18 |
Input: n = 15
19 | Output: ["1","2","Fizz","4","Buzz","Fizz","7","8","Fizz","Buzz","11","Fizz","13","14","FizzBuzz"]
20 |
21 |
22 |
Constraints:
23 |
24 |
27 |
Easy
Given two non-negative integers, num1 and num2 represented as string, return the sum of num1 and num2 as a string.
2 |
3 |
You must solve the problem without using any built-in library for handling large integers (such as BigInteger). You must also not convert the inputs to integers directly.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: num1 = "11", num2 = "123"
9 | Output: "134"
10 |
11 |
12 |
Example 2:
13 |
14 |
Input: num1 = "456", num2 = "77"
15 | Output: "533"
16 |
17 |
18 |
Example 3:
19 |
20 |
Input: num1 = "0", num2 = "0"
21 | Output: "0"
22 |
23 |
24 |
25 |
Constraints:
26 |
27 |
28 | 1 <= num1.length, num2.length <= 104num1 and num2 consist of only digits.num1 and num2 don't have any leading zeros except for the zero itself.
32 |
Medium
Given a non-empty array nums 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.
2 |
3 |
4 |
Example 1:
5 |
6 |
Input: nums = [1,5,11,5]
7 | Output: true
8 | Explanation: The array can be partitioned as [1, 5, 5] and [11].
9 |
10 |
11 |
Example 2:
12 |
13 |
Input: nums = [1,2,3,5]
14 | Output: false
15 | Explanation: The array cannot be partitioned into equal sum subsets.
16 |
17 |
18 |
19 |
Constraints:
20 |
21 |
22 | 1 <= nums.length <= 2001 <= nums[i] <= 100
25 |
Medium
Given a string s, sort it in decreasing order based on the frequency of the characters. The frequency of a character is the number of times it appears in the string.
2 |
3 |
Return the sorted string. If there are multiple answers, return any of them.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: s = "tree"
9 | Output: "eert"
10 | Explanation: 'e' appears twice while 'r' and 't' both appear once.
11 | So 'e' must appear before both 'r' and 't'. Therefore "eetr" is also a valid answer.
12 |
13 |
14 |
Example 2:
15 |
16 |
Input: s = "cccaaa"
17 | Output: "aaaccc"
18 | Explanation: Both 'c' and 'a' appear three times, so both "cccaaa" and "aaaccc" are valid answers.
19 | Note that "cacaca" is incorrect, as the same characters must be together.
20 |
21 |
22 |
Example 3:
23 |
24 |
Input: s = "Aabb"
25 | Output: "bbAa"
26 | Explanation: "bbaA" is also a valid answer, but "Aabb" is incorrect.
27 | Note that 'A' and 'a' are treated as two different characters.
28 |
29 |
30 |
31 |
Constraints:
32 |
33 |
34 | 1 <= s.length <= 5 * 105s consists of uppercase and lowercase English letters and digits.
37 |
Medium
You are given an n x n 2D matrix representing an image, rotate the image by 90 degrees (clockwise).
2 |
3 |
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.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: matrix = [[1,2,3],[4,5,6],[7,8,9]]
9 | Output: [[7,4,1],[8,5,2],[9,6,3]]
10 |
11 |
12 |
Example 2:
13 |
14 |
Input: matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
15 | Output: [[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]
16 |
17 |
18 |
19 |
Constraints:
20 |
21 |
22 | n == matrix.length == matrix[i].length1 <= n <= 20-1000 <= matrix[i][j] <= 1000
26 |
Easy
Given a binary array nums, return the maximum number of consecutive 1's in the array.
2 |
3 |
4 |
Example 1:
5 |
6 |
Input: nums = [1,1,0,1,1,1]
7 | Output: 3
8 | Explanation: The first two digits or the last three digits are consecutive 1s. The maximum number of consecutive 1s is 3.
9 |
10 |
11 |
Example 2:
12 |
13 |
Input: nums = [1,0,1,1,0,1]
14 | Output: 2
15 |
16 |
17 |
18 |
Constraints:
19 |
20 |
21 | 1 <= nums.length <= 105nums[i] is either 0 or 1.
24 |
Medium
Implement pow(x, n), which calculates x raised to the power n (i.e., xn).
2 |
3 |
4 |
Example 1:
5 |
6 |
Input: x = 2.00000, n = 10
7 | Output: 1024.00000
8 |
9 |
10 |
Example 2:
11 |
12 |
Input: x = 2.10000, n = 3
13 | Output: 9.26100
14 |
15 |
16 |
Example 3:
17 |
18 |
Input: x = 2.00000, n = -2
19 | Output: 0.25000
20 | Explanation: 2-2 = 1/22 = 1/4 = 0.25
21 |
22 |
23 |
24 |
Constraints:
25 |
26 |
27 | -100.0 < x < 100.0-231 <= n <= 231-1-104 <= xn <= 104
31 |
Easy
The Fibonacci numbers, commonly denoted F(n) form a sequence, called the Fibonacci sequence, such that each number is the sum of the two preceding ones, starting from 0 and 1. That is,
2 |
3 |
F(0) = 0, F(1) = 1
4 | F(n) = F(n - 1) + F(n - 2), for n > 1.
5 |
6 |
7 |
Given n, calculate F(n).
8 |
9 |
10 |
Example 1:
11 |
12 |
Input: n = 2
13 | Output: 1
14 | Explanation: F(2) = F(1) + F(0) = 1 + 0 = 1.
15 |
16 |
17 |
Example 2:
18 |
19 |
Input: n = 3
20 | Output: 2
21 | Explanation: F(3) = F(2) + F(1) = 1 + 1 = 2.
22 |
23 |
24 |
Example 3:
25 |
26 |
Input: n = 4
27 | Output: 3
28 | Explanation: F(4) = F(3) + F(2) = 2 + 1 = 3.
29 |
30 |
31 |
32 |
Constraints:
33 |
34 |
37 |
Easy
Given an integer array nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.
2 |
3 |
A subarray is a contiguous part of an array.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: nums = [-2,1,-3,4,-1,2,1,-5,4]
9 | Output: 6
10 | Explanation: [4,-1,2,1] has the largest sum = 6.
11 |
12 |
13 |
Example 2:
14 |
15 |
Input: nums = [1]
16 | Output: 1
17 |
18 |
19 |
Example 3:
20 |
21 |
Input: nums = [5,4,-1,7,8]
22 | Output: 23
23 |
24 |
25 |
26 |
Constraints:
27 |
28 |
29 | 1 <= nums.length <= 105-104 <= nums[i] <= 104
32 |
33 |
34 |
Follow up: If you have figured out the O(n) solution, try coding another solution using the divide and conquer approach, which is more subtle.
35 |
Medium
You are given a sorted array consisting of only integers where every element appears exactly twice, except for one element which appears exactly once.
2 |
3 |
Return the single element that appears only once.
4 |
5 |
Your solution must run in O(log n) time and O(1) space.
6 |
7 |
8 |
Example 1:
9 |
Input: nums = [1,1,2,3,3,4,4,8,8]
10 | Output: 2
11 |
Example 2:
12 |
Input: nums = [3,3,7,7,10,11,11]
13 | Output: 10
14 |
15 |
16 |
Constraints:
17 |
18 |
19 | 1 <= nums.length <= 1050 <= nums[i] <= 105
22 |
Easy
Given the root of a binary tree, return the length of the diameter of the tree.
2 |
3 |
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.
4 |
5 |
The length of a path between two nodes is represented by the number of edges between them.
6 |
7 |
8 |
Example 1:
9 |
10 |
Input: root = [1,2,3,4,5]
11 | Output: 3
12 | Explanation: 3 is the length of the path [4,2,1,3] or [5,2,1,3].
13 |
14 |
15 |
Example 2:
16 |
17 |
Input: root = [1,2]
18 | Output: 1
19 |
20 |
21 |
22 |
Constraints:
23 |
24 |
25 | - The number of nodes in the tree is in the range
[1, 104].
26 | -100 <= Node.val <= 100
28 |
Medium
Given an array of intervals where intervals[i] = [starti, endi], merge all overlapping intervals, and return an array of the non-overlapping intervals that cover all the intervals in the input.
2 |
3 |
4 |
Example 1:
5 |
6 |
Input: intervals = [[1,3],[2,6],[8,10],[15,18]]
7 | Output: [[1,6],[8,10],[15,18]]
8 | Explanation: Since intervals [1,3] and [2,6] overlaps, merge them into [1,6].
9 |
10 |
11 |
Example 2:
12 |
13 |
Input: intervals = [[1,4],[4,5]]
14 | Output: [[1,5]]
15 | Explanation: Intervals [1,4] and [4,5] are considered overlapping.
16 |
17 |
18 |
19 |
Constraints:
20 |
21 |
22 | 1 <= intervals.length <= 104intervals[i].length == 20 <= starti <= endi <= 104
26 |
Easy
Given the roots of two binary trees root and subRoot, return true if there is a subtree of root with the same structure and node values of subRoot and false otherwise.
2 |
3 |
A subtree of a binary tree tree is a tree that consists of a node in tree and all of this node's descendants. The tree tree could also be considered as a subtree of itself.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: root = [3,4,5,1,2], subRoot = [4,1,2]
9 | Output: true
10 |
11 |
12 |
Example 2:
13 |
14 |
Input: root = [3,4,5,1,2,null,null,null,null,0], subRoot = [4,1,2]
15 | Output: false
16 |
17 |
18 |
19 |
Constraints:
20 |
21 |
22 | - The number of nodes in the
root tree is in the range [1, 2000].
23 | - The number of nodes in the
subRoot tree is in the range [1, 1000].
24 | -104 <= root.val <= 104-104 <= subRoot.val <= 104
27 |
Easy
Given a string s consisting of words and spaces, return the length of the last word in the string.
2 |
3 |
A word is a maximal substring consisting of non-space characters only.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: s = "Hello World"
9 | Output: 5
10 | Explanation: The last word is "World" with length 5.
11 |
12 |
13 |
Example 2:
14 |
15 |
Input: s = " fly me to the moon "
16 | Output: 4
17 | Explanation: The last word is "moon" with length 4.
18 |
19 |
20 |
Example 3:
21 |
22 |
Input: s = "luffy is still joyboy"
23 | Output: 6
24 | Explanation: The last word is "joyboy" with length 6.
25 |
26 |
27 |
28 |
Constraints:
29 |
30 |
31 | 1 <= s.length <= 104s consists of only English letters and spaces ' '.- There will be at least one word in
s.
34 |
35 |
Easy
Given the root of an n-ary tree, return the preorder traversal of its nodes' values.
2 |
3 |
Nary-Tree input serialization is represented in their level order traversal. Each group of children is separated by the null value (See examples)
4 |
5 |
6 |
Example 1:
7 |
8 |
9 |
10 |
Input: root = [1,null,3,2,4,null,5,6]
11 | Output: [1,3,5,6,2,4]
12 |
13 |
14 |
Example 2:
15 |
16 |
17 |
18 |
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]
19 | Output: [1,2,3,6,7,11,14,4,8,12,5,9,13,10]
20 |
21 |
22 |
23 |
Constraints:
24 |
25 |
26 | - The number of nodes in the tree is in the range
[0, 104].
27 | 0 <= Node.val <= 104- The height of the n-ary tree is less than or equal to
1000.
29 |
30 |
31 |
32 |
Follow up: Recursive solution is trivial, could you do it iteratively?
33 |
Easy
Given a non-negative integer x, compute and return the square root of x.
2 |
3 |
Since the return type is an integer, the decimal digits are truncated, and only the integer part of the result is returned.
4 |
5 |
Note: You are not allowed to use any built-in exponent function or operator, such as pow(x, 0.5) or x ** 0.5.
6 |
7 |
8 |
Example 1:
9 |
10 |
Input: x = 4
11 | Output: 2
12 |
13 |
14 |
Example 2:
15 |
16 |
Input: x = 8
17 | Output: 2
18 | Explanation: The square root of 8 is 2.82842..., and since the decimal part is truncated, 2 is returned.
19 |
20 |
21 |
Constraints:
22 |
23 |
24 | 0 <= x <= 231 - 1
26 |
Easy
Given an array of integers nums which is sorted in ascending order, and an integer target, write a function to search target in nums. If target exists, then return its index. Otherwise, return -1.
2 |
3 |
You must write an algorithm with O(log n) runtime complexity.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: nums = [-1,0,3,5,9,12], target = 9
9 | Output: 4
10 | Explanation: 9 exists in nums and its index is 4
11 |
12 |
13 |
Example 2:
14 |
15 |
Input: nums = [-1,0,3,5,9,12], target = 2
16 | Output: -1
17 | Explanation: 2 does not exist in nums so return -1
18 |
19 |
20 |
21 |
Constraints:
22 |
23 |
24 | 1 <= nums.length <= 104-104 < nums[i], target < 104- All the integers in
nums are unique.
27 | nums is sorted in ascending order.
29 |
Medium
Given an m x n integer matrix matrix, if an element is 0, set its entire row and column to 0's, and return the matrix.
2 |
3 |
You must do it in place.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: matrix = [[1,1,1],[1,0,1],[1,1,1]]
9 | Output: [[1,0,1],[0,0,0],[1,0,1]]
10 |
11 |
12 |
Example 2:
13 |
14 |
Input: matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]
15 | Output: [[0,0,0,0],[0,4,5,0],[0,3,1,0]]
16 |
17 |
18 |
19 |
Constraints:
20 |
21 |
22 | m == matrix.lengthn == matrix[0].length1 <= m, n <= 200-231 <= matrix[i][j] <= 231 - 1
27 |
28 |
29 |
Follow up:
30 |
31 |
32 | - A straightforward solution using
O(mn) space is probably a bad idea.
33 | - A simple improvement uses
O(m + n) space, but still not the best solution.
34 | - Could you devise a constant space solution?
35 |
36 |
Medium
Write an efficient algorithm that searches for a value target in an m x n integer matrix matrix. This matrix has the following properties:
2 |
3 |
4 | - Integers in each row are sorted from left to right.
5 | - The first integer of each row is greater than the last integer of the previous row.
6 |
7 |
8 |
9 |
Example 1:
10 |
11 |
Input: matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3
12 | Output: true
13 |
14 |
15 |
Example 2:
16 |
17 |
Input: matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13
18 | Output: false
19 |
20 |
21 |
22 |
Constraints:
23 |
24 |
25 | m == matrix.lengthn == matrix[i].length1 <= m, n <= 100-104 <= matrix[i][j], target <= 104
30 |
Medium
Given an array nums with n objects colored red, white, or blue, sort them in-place so that objects of the same color are adjacent, with the colors in the order red, white, and blue.
2 |
3 |
We will use the integers 0, 1, and 2 to represent the color red, white, and blue, respectively.
4 |
5 |
You must solve this problem without using the library's sort function.
6 |
7 |
8 |
Example 1:
9 |
10 |
Input: nums = [2,0,2,1,1,0]
11 | Output: [0,0,1,1,2,2]
12 |
13 |
14 |
Example 2:
15 |
16 |
Input: nums = [2,0,1]
17 | Output: [0,1,2]
18 |
19 |
20 |
21 |
Constraints:
22 |
23 |
24 | n == nums.length1 <= n <= 300nums[i] is either 0, 1, or 2.
28 |
29 |
30 |
Follow up: Could you come up with a one-pass algorithm using only constant extra space?
31 |
Easy
Given two strings s and t, return true if they are equal when both are typed into empty text editors. '#' means a backspace character.
2 |
3 |
Note that after backspacing an empty text, the text will continue empty.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: s = "ab#c", t = "ad#c"
9 | Output: true
10 | Explanation: Both s and t become "ac".
11 |
12 |
13 |
Example 2:
14 |
15 |
Input: s = "ab##", t = "c#d#"
16 | Output: true
17 | Explanation: Both s and t become "".
18 |
19 |
20 |
Example 3:
21 |
22 |
Input: s = "a#c", t = "b"
23 | Output: false
24 | Explanation: s becomes "c" while t becomes "b".
25 |
26 |
27 |
28 |
Constraints:
29 |
30 |
31 | 1 <= s.length, t.length <= 200s and t only contain lowercase letters and '#' characters.
34 |
35 |
36 |
Follow up: Can you solve it in O(n) time and O(1) space?
37 |
Easy
Given the head of a singly linked list, return the middle node of the linked list.
2 |
3 |
If there are two middle nodes, return the second middle node.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: head = [1,2,3,4,5]
9 | Output: [3,4,5]
10 | Explanation: The middle node of the list is node 3.
11 |
12 |
13 |
Example 2:
14 |
15 |
Input: head = [1,2,3,4,5,6]
16 | Output: [4,5,6]
17 | Explanation: Since the list has two middle nodes with values 3 and 4, we return the second one.
18 |
19 |
20 |
21 |
Constraints:
22 |
23 |
24 | - The number of nodes in the list is in the range
[1, 100].
25 | 1 <= Node.val <= 100
27 |
Easy
Given an integer array nums, move all the even integers at the beginning of the array followed by all the odd integers.
2 |
3 |
Return any array that satisfies this condition.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: nums = [3,1,2,4]
9 | Output: [2,4,3,1]
10 | Explanation: The outputs [4,2,3,1], [2,4,1,3], and [4,2,1,3] would also be accepted.
11 |
12 |
13 |
Example 2:
14 |
15 |
Input: nums = [0]
16 | Output: [0]
17 |
18 |
19 |
20 |
Constraints:
21 |
22 |
23 | 1 <= nums.length <= 50000 <= nums[i] <= 5000
26 |
Medium
Given an array of integers nums, sort the array in ascending order.
2 |
3 |
4 |
Example 1:
5 |
Input: nums = [5,2,3,1]
6 | Output: [1,2,3,5]
7 |
Example 2:
8 |
Input: nums = [5,1,1,2,0,0]
9 | Output: [0,0,1,1,2,5]
10 |
11 |
12 |
Constraints:
13 |
14 |
15 | 1 <= nums.length <= 5 * 104-5 * 104 <= nums[i] <= 5 * 104
18 |
4 |
Given a binary tree, find its height.
5 |
6 |
7 | Example 1:
8 |
9 |
Input:
10 | 1
11 | / \
12 | 2 3
13 | Output: 2
14 |
15 |
16 |
Example 2:
17 |
18 |
Input:
19 | 2
20 | \
21 | 1
22 | /
23 | 3
24 | Output: 3
25 |
26 |
27 | Your Task:
28 | You don't need to read input or print anything. Your task is to complete the function height() which takes root node of the tree as input parameter and returns an integer denoting the height of the tree. If the tree is empty, return 0.
29 |
30 |
31 | Expected Time Complexity: O(N)
32 | Expected Auxiliary Space: O(N)
33 |
34 |
35 | Constraints:
36 | 1 <= Number of nodes <= 105
37 | 1 <= Data of a node <= 105
38 |
39 |
4 |
Given two strings. The task is to find the length of the longest common substring.
5 |
6 |
7 | Example 1:
8 |
9 |
Input: S1 = "ABCDGH", S2 = "ACDGHR"
10 | Output: 4
11 | Explanation: The longest common substring
12 | is "CDGH" which has length 4.
13 |
14 |
15 |
Example 2:
16 |
17 |
Input: S1 = "ABC", S2 "ACB"
18 | Output: 1
19 | Explanation: The longest common substrings
20 | are "A", "B", "C" all having length 1.
21 |
22 |
23 |
24 | Your Task:
25 | You don't need to read input or print anything. Your task is to complete the function longestCommonSubstr() which takes the string S1, string S2 and their length n and m as inputs and returns the length of the longest common substring in S1 and S2.
26 |
27 |
28 | Expected Time Complexity: O(n*m).
29 | Expected Auxiliary Space: O(n*m).
30 |
31 |
32 | Constraints:
33 | 1<=n, m<=1000
34 |
35 |
73. Set Matrix Zeroes
Medium
Given an m x n integer matrix matrix, if an element is 0, set its entire row and column to 0's, and return the matrix.
2 |
3 |
You must do it in place.
4 |
5 |
6 |
Example 1:
7 |
8 |
Input: matrix = [[1,1,1],[1,0,1],[1,1,1]]
9 | Output: [[1,0,1],[0,0,0],[1,0,1]]
10 |
11 |
12 |
Example 2:
13 |
14 |
Input: matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]
15 | Output: [[0,0,0,0],[0,4,5,0],[0,3,1,0]]
16 |
17 |
18 |
19 |
Constraints:
20 |
21 |
22 | m == matrix.lengthn == matrix[0].length1 <= m, n <= 200-231 <= matrix[i][j] <= 231 - 1
27 |
28 |
29 |
Follow up:
30 |
31 |
32 | - A straightforward solution using
O(mn) space is probably a bad idea.
33 | - A simple improvement uses
O(m + n) space, but still not the best solution.
34 | - Could you devise a constant space solution?
35 |
36 |
1015. Smallest Integer Divisible by K
Medium
Given a positive integer k, you need to find the length of the smallest positive integer n such that n is divisible by k, and n only contains the digit 1.
2 |
3 |
Return the length of n. If there is no such n, return -1.
4 |
5 |
Note: n may not fit in a 64-bit signed integer.
6 |
7 |
8 |
Example 1:
9 |
10 |
Input: k = 1
11 | Output: 1
12 | Explanation: The smallest answer is n = 1, which has length 1.
13 |
14 |
15 |
Example 2:
16 |
17 |
Input: k = 2
18 | Output: -1
19 | Explanation: There is no such positive integer n divisible by 2.
20 |
21 |
22 |
Example 3:
23 |
24 |
Input: k = 3
25 | Output: 3
26 | Explanation: The smallest answer is n = 111, which has length 3.
27 |
28 |
29 |
30 |
Constraints:
31 |
32 |
35 |
1. Two Sum
Easy
Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.
2 |
3 |
You may assume that each input would have exactly one solution, and you may not use the same element twice.
4 |
5 |
You can return the answer in any order.
6 |
7 |
8 |
Example 1:
9 |
10 |
Input: nums = [2,7,11,15], target = 9
11 | Output: [0,1]
12 | Output: Because nums[0] + nums[1] == 9, we return [0, 1].
13 |
14 |
15 |
Example 2:
16 |
17 |
Input: nums = [3,2,4], target = 6
18 | Output: [1,2]
19 |
20 |
21 |
Example 3:
22 |
23 |
Input: nums = [3,3], target = 6
24 | Output: [0,1]
25 |
26 |
27 |
28 |
Constraints:
29 |
30 |
31 | 2 <= nums.length <= 104-109 <= nums[i] <= 109-109 <= target <= 109- Only one valid answer exists.
35 |
36 |
37 |
38 |
Follow-up: Can you come up with an algorithm that is less than
O(n2) time complexity?