Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 47847a3

Browse files
authored
Added descriptions 20-30.
1 parent fb8b236 commit 47847a3

File tree

11 files changed

+406
-0
lines changed

11 files changed

+406
-0
lines changed
Lines changed: 45 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,45 @@
1+
20\. Valid Parentheses
2+
3+
Easy
4+
5+
Given a string `s` containing just the characters `'('`, `')'`, `'{'`, `'}'`, `'['` and `']'`, determine if the input string is valid.
6+
7+
An input string is valid if:
8+
9+
1. Open brackets must be closed by the same type of brackets.
10+
2. Open brackets must be closed in the correct order.
11+
12+
**Example 1:**
13+
14+
**Input:** s = "()"
15+
16+
**Output:** true
17+
18+
**Example 2:**
19+
20+
**Input:** s = "()\[\]{}"
21+
22+
**Output:** true
23+
24+
**Example 3:**
25+
26+
**Input:** s = "(\]"
27+
28+
**Output:** false
29+
30+
**Example 4:**
31+
32+
**Input:** s = "(\[)\]"
33+
34+
**Output:** false
35+
36+
**Example 5:**
37+
38+
**Input:** s = "{\[\]}"
39+
40+
**Output:** true
41+
42+
**Constraints:**
43+
44+
* `1 <= s.length <= 104`
45+
* `s` consists of parentheses only `'()[]{}'`.
Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
21\. Merge Two Sorted Lists
2+
3+
Easy
4+
5+
Merge two sorted linked lists and return it as a **sorted** list. The list should be made by splicing together the nodes of the first two lists.
6+
7+
**Example 1:**
8+
9+
![](https://assets.leetcode.com/uploads/2020/10/03/merge_ex1.jpg)
10+
11+
**Input:** l1 = \[1,2,4\], l2 = \[1,3,4\]
12+
13+
**Output:** \[1,1,2,3,4,4\]
14+
15+
**Example 2:**
16+
17+
**Input:** l1 = \[\], l2 = \[\]
18+
19+
**Output:** \[\]
20+
21+
**Example 3:**
22+
23+
**Input:** l1 = \[\], l2 = \[0\]
24+
25+
**Output:** \[0\]
26+
27+
**Constraints:**
28+
29+
* The number of nodes in both lists is in the range `[0, 50]`.
30+
* `-100 <= Node.val <= 100`
31+
* Both `l1` and `l2` are sorted in **non-decreasing** order.
Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
22\. Generate Parentheses
2+
3+
Medium
4+
5+
Given `n` pairs of parentheses, write a function to _generate all combinations of well-formed parentheses_.
6+
7+
**Example 1:**
8+
9+
**Input:** n = 3
10+
11+
**Output:** \["((()))","(()())","(())()","()(())","()()()"\]
12+
13+
**Example 2:**
14+
15+
**Input:** n = 1
16+
17+
**Output:** \["()"\]
18+
19+
**Constraints:**
20+
21+
* `1 <= n <= 8`
Lines changed: 36 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,36 @@
1+
23\. Merge k Sorted Lists
2+
3+
Hard
4+
5+
You are given an array of `k` linked-lists `lists`, each linked-list is sorted in ascending order.
6+
7+
_Merge all the linked-lists into one sorted linked-list and return it._
8+
9+
**Example 1:**
10+
11+
**Input:** lists = \[\[1,4,5\],\[1,3,4\],\[2,6\]\]
12+
13+
**Output:** \[1,1,2,3,4,4,5,6\]
14+
15+
**Explanation:** The linked-lists are: \[ 1->4->5, 1->3->4, 2->6 \] merging them into one sorted list: 1->1->2->3->4->4->5->6
16+
17+
**Example 2:**
18+
19+
**Input:** lists = \[\]
20+
21+
**Output:** \[\]
22+
23+
**Example 3:**
24+
25+
**Input:** lists = \[\[\]\]
26+
27+
**Output:** \[\]
28+
29+
**Constraints:**
30+
31+
* `k == lists.length`
32+
* `0 <= k <= 10^4`
33+
* `0 <= lists[i].length <= 500`
34+
* `-10^4 <= lists[i][j] <= 10^4`
35+
* `lists[i]` is sorted in **ascending order**.
36+
* The sum of `lists[i].length` won't exceed `10^4`.
Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
24\. Swap Nodes in Pairs
2+
3+
Medium
4+
5+
Given a linked list, swap every two adjacent nodes and return its head. You must solve the problem without modifying the values in the list's nodes (i.e., only nodes themselves may be changed.)
6+
7+
**Example 1:**
8+
9+
![](https://assets.leetcode.com/uploads/2020/10/03/swap_ex1.jpg)
10+
11+
**Input:** head = \[1,2,3,4\]
12+
13+
**Output:** \[2,1,4,3\]
14+
15+
**Example 2:**
16+
17+
**Input:** head = \[\]
18+
19+
**Output:** \[\]
20+
21+
**Example 3:**
22+
23+
**Input:** head = \[1\]
24+
25+
**Output:** \[1\]
26+
27+
**Constraints:**
28+
29+
* The number of nodes in the list is in the range `[0, 100]`.
30+
* `0 <= Node.val <= 100`
Lines changed: 46 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,46 @@
1+
25\. Reverse Nodes in k-Group
2+
3+
Hard
4+
5+
Given a linked list, reverse the nodes of a linked list _k_ at a time and return its modified list.
6+
7+
_k_ is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of _k_ then left-out nodes, in the end, should remain as it is.
8+
9+
You may not alter the values in the list's nodes, only nodes themselves may be changed.
10+
11+
**Example 1:**
12+
13+
![](https://assets.leetcode.com/uploads/2020/10/03/reverse_ex1.jpg)
14+
15+
**Input:** head = \[1,2,3,4,5\], k = 2
16+
17+
**Output:** \[2,1,4,3,5\]
18+
19+
**Example 2:**
20+
21+
![](https://assets.leetcode.com/uploads/2020/10/03/reverse_ex2.jpg)
22+
23+
**Input:** head = \[1,2,3,4,5\], k = 3
24+
25+
**Output:** \[3,2,1,4,5\]
26+
27+
**Example 3:**
28+
29+
**Input:** head = \[1,2,3,4,5\], k = 1
30+
31+
**Output:** \[1,2,3,4,5\]
32+
33+
**Example 4:**
34+
35+
**Input:** head = \[1\], k = 1
36+
37+
**Output:** \[1\]
38+
39+
**Constraints:**
40+
41+
* The number of nodes in the list is in the range `sz`.
42+
* `1 <= sz <= 5000`
43+
* `0 <= Node.val <= 1000`
44+
* `1 <= k <= sz`
45+
46+
**Follow-up:** Can you solve the problem in O(1) extra memory space?
Lines changed: 41 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,41 @@
1+
26\. Remove Duplicates from Sorted Array
2+
3+
Easy
4+
5+
Given an integer array `nums` sorted in **non-decreasing order**, remove the duplicates [**in-place**](https://en.wikipedia.org/wiki/In-place_algorithm) such that each unique element appears only **once**. The **relative order** of the elements should be kept the **same**.
6+
7+
Since it is impossible to change the length of the array in some languages, you must instead have the result be placed in the **first part** of the array `nums`. More formally, if there are `k` elements after removing the duplicates, then the first `k` elements of `nums` should hold the final result. It does not matter what you leave beyond the first `k` elements.
8+
9+
Return `k` _after placing the final result in the first_ `k` _slots of_ `nums`.
10+
11+
Do **not** allocate extra space for another array. You must do this by **modifying the input array [in-place](https://en.wikipedia.org/wiki/In-place_algorithm)** with O(1) extra memory.
12+
13+
**Custom Judge:**
14+
15+
The judge will test your solution with the following code:
16+
17+
int\[\] nums = \[...\]; // Input array int\[\] expectedNums = \[...\]; // The expected answer with correct length int k = removeDuplicates(nums); // Calls your implementation assert k == expectedNums.length; for (int i = 0; i < k; i++) { assert nums\[i\] == expectedNums\[i\]; }
18+
19+
If all assertions pass, then your solution will be **accepted**.
20+
21+
**Example 1:**
22+
23+
**Input:** nums = \[1,1,2\]
24+
25+
**Output:** 2, nums = \[1,2,\_\]
26+
27+
**Explanation:** Your function should return k = 2, with the first two elements of nums being 1 and 2 respectively. It does not matter what you leave beyond the returned k (hence they are underscores).
28+
29+
**Example 2:**
30+
31+
**Input:** nums = \[0,0,1,1,1,2,2,3,3,4\]
32+
33+
**Output:** 5, nums = \[0,1,2,3,4,\_,\_,\_,\_,\_\]
34+
35+
**Explanation:** Your function should return k = 5, with the first five elements of nums being 0, 1, 2, 3, and 4 respectively. It does not matter what you leave beyond the returned k (hence they are underscores).
36+
37+
**Constraints:**
38+
39+
* `0 <= nums.length <= 3 * 104`
40+
* `-100 <= nums[i] <= 100`
41+
* `nums` is sorted in **non-decreasing** order.
Lines changed: 41 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,41 @@
1+
27\. Remove Element
2+
3+
Easy
4+
5+
Given an integer array `nums` and an integer `val`, remove all occurrences of `val` in `nums` [**in-place**](https://en.wikipedia.org/wiki/In-place_algorithm). The relative order of the elements may be changed.
6+
7+
Since it is impossible to change the length of the array in some languages, you must instead have the result be placed in the **first part** of the array `nums`. More formally, if there are `k` elements after removing the duplicates, then the first `k` elements of `nums` should hold the final result. It does not matter what you leave beyond the first `k` elements.
8+
9+
Return `k` _after placing the final result in the first_ `k` _slots of_ `nums`.
10+
11+
Do **not** allocate extra space for another array. You must do this by **modifying the input array [in-place](https://en.wikipedia.org/wiki/In-place_algorithm)** with O(1) extra memory.
12+
13+
**Custom Judge:**
14+
15+
The judge will test your solution with the following code:
16+
17+
int\[\] nums = \[...\]; // Input array int val = ...; // Value to remove int\[\] expectedNums = \[...\]; // The expected answer with correct length. // It is sorted with no values equaling val. int k = removeElement(nums, val); // Calls your implementation assert k == expectedNums.length; sort(nums, 0, k); // Sort the first k elements of nums for (int i = 0; i < actualLength; i++) { assert nums\[i\] == expectedNums\[i\]; }
18+
19+
If all assertions pass, then your solution will be **accepted**.
20+
21+
**Example 1:**
22+
23+
**Input:** nums = \[3,2,2,3\], val = 3
24+
25+
**Output:** 2, nums = \[2,2,\_,\_\]
26+
27+
**Explanation:** Your function should return k = 2, with the first two elements of nums being 2. It does not matter what you leave beyond the returned k (hence they are underscores).
28+
29+
**Example 2:**
30+
31+
**Input:** nums = \[0,1,2,2,3,0,4,2\], val = 2
32+
33+
**Output:** 5, nums = \[0,1,4,0,3,\_,\_,\_\]
34+
35+
**Explanation:** Your function should return k = 5, with the first five elements of nums containing 0, 0, 1, 3, and 4. Note that the five elements can be returned in any order. It does not matter what you leave beyond the returned k (hence they are underscores).
36+
37+
**Constraints:**
38+
39+
* `0 <= nums.length <= 100`
40+
* `0 <= nums[i] <= 50`
41+
* `0 <= val <= 100`
Lines changed: 36 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,36 @@
1+
28\. Implement strStr()
2+
3+
Easy
4+
5+
Implement [strStr()](http://www.cplusplus.com/reference/cstring/strstr/).
6+
7+
Return the index of the first occurrence of needle in haystack, or `-1` if `needle` is not part of `haystack`.
8+
9+
**Clarification:**
10+
11+
What should we return when `needle` is an empty string? This is a great question to ask during an interview.
12+
13+
For the purpose of this problem, we will return 0 when `needle` is an empty string. This is consistent to C's [strstr()](http://www.cplusplus.com/reference/cstring/strstr/) and Java's [indexOf()](https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#indexOf(java.lang.String)).
14+
15+
**Example 1:**
16+
17+
**Input:** haystack = "hello", needle = "ll"
18+
19+
**Output:** 2
20+
21+
**Example 2:**
22+
23+
**Input:** haystack = "aaaaa", needle = "bba"
24+
25+
**Output:** -1
26+
27+
**Example 3:**
28+
29+
**Input:** haystack = "", needle = ""
30+
31+
**Output:** 0
32+
33+
**Constraints:**
34+
35+
* `0 <= haystack.length, needle.length <= 5 * 104`
36+
* `haystack` and `needle` consist of only lower-case English characters.
Lines changed: 44 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,44 @@
1+
29\. Divide Two Integers
2+
3+
Medium
4+
5+
Given two integers `dividend` and `divisor`, divide two integers **without** using multiplication, division, and mod operator.
6+
7+
The integer division should truncate toward zero, which means losing its fractional part. For example, `8.345` would be truncated to `8`, and `-2.7335` would be truncated to `-2`.
8+
9+
Return _the **quotient** after dividing_ `dividend` _by_ `divisor`.
10+
11+
**Note:** Assume we are dealing with an environment that could only store integers within the **32-bit** signed integer range: `[−231, 231 − 1]`. For this problem, if the quotient is **strictly greater than** `231 - 1`, then return `231 - 1`, and if the quotient is **strictly less than** `-231`, then return `-231`.
12+
13+
**Example 1:**
14+
15+
**Input:** dividend = 10, divisor = 3
16+
17+
**Output:** 3
18+
19+
**Explanation:** 10/3 = 3.33333.. which is truncated to 3.
20+
21+
**Example 2:**
22+
23+
**Input:** dividend = 7, divisor = -3
24+
25+
**Output:** -2
26+
27+
**Explanation:** 7/-3 = -2.33333.. which is truncated to -2.
28+
29+
**Example 3:**
30+
31+
**Input:** dividend = 0, divisor = 1
32+
33+
**Output:** 0
34+
35+
**Example 4:**
36+
37+
**Input:** dividend = 1, divisor = 1
38+
39+
**Output:** 1
40+
41+
**Constraints:**
42+
43+
* `-231 <= dividend, divisor <= 231 - 1`
44+
* `divisor != 0`

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /