Skip to content

Commit 40201dc

Browse files
halfrosthalfrost
committed
Add solution 0816
1 parent e3304f5 commit 40201dc

22 files changed

+546
-270
lines changed

‎README.md

Lines changed: 208 additions & 208 deletions
Large diffs are not rendered by default.

‎leetcode/0816.Ambiguous-Coordinates/816. Ambiguous Coordinates.go

Lines changed: 36 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,36 @@
1+
package leetcode
2+
3+
func ambiguousCoordinates(s string) []string {
4+
res := []string{}
5+
s = s[1 : len(s)-1]
6+
for i := range s[:len(s)-1] {
7+
a := build(s[:i+1])
8+
b := build(s[i+1:])
9+
for _, ta := range a {
10+
for _, tb := range b {
11+
res = append(res, "("+ta+", "+tb+")")
12+
}
13+
}
14+
}
15+
return res
16+
}
17+
18+
func build(s string) []string {
19+
res := []string{}
20+
if len(s) == 1 || s[0] != '0' {
21+
res = append(res, s)
22+
}
23+
// 结尾带 0 的情况
24+
if s[len(s)-1] == '0' {
25+
return res
26+
}
27+
// 切分长度大于一位且带前导 0 的情况
28+
if s[0] == '0' {
29+
res = append(res, "0."+s[1:])
30+
return res
31+
}
32+
for i := range s[:len(s)-1] {
33+
res = append(res, s[:i+1]+"."+s[i+1:])
34+
}
35+
return res
36+
}

‎leetcode/0816.Ambiguous-Coordinates/816. Ambiguous Coordinates_test.go

Lines changed: 42 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,42 @@
1+
package leetcode
2+
3+
import (
4+
"fmt"
5+
"testing"
6+
)
7+
8+
type question816 struct {
9+
para816
10+
ans816
11+
}
12+
13+
// para 是参数
14+
// one 代表第一个参数
15+
type para816 struct {
16+
one string
17+
}
18+
19+
// ans 是答案
20+
// one 代表第一个答案
21+
type ans816 struct {
22+
one []string
23+
}
24+
25+
func Test_Problem816(t *testing.T) {
26+
27+
qs := []question816{
28+
29+
{
30+
para816{"(120123)"},
31+
ans816{[]string{"(1, 20123)", " (1, 2.0123)", " (1, 20.123)", " (1, 201.23)", " (1, 2012.3)", " (12, 0.123)", " (1.2, 0.123)", " (120, 123)", " (120, 1.23)", " (120, 12.3)", " (1201, 23) ", "(1201, 2.3)", " (1.201, 23)", " (1.201, 2.3) ", "(12.01, 23)", " (12.01, 2.3) ", "(120.1, 23)", " (120.1, 2.3) ", "(12012, 3)", " (1.2012, 3)", " (12.012, 3)", " (120.12, 3)", " (1201.2, 3)"}},
32+
},
33+
}
34+
35+
fmt.Printf("------------------------Leetcode Problem 816------------------------\n")
36+
37+
for _, q := range qs {
38+
_, p := q.ans816, q.para816
39+
fmt.Printf("【input】:%v 【output】:%v\n", p, ambiguousCoordinates(p.one))
40+
}
41+
fmt.Printf("\n\n\n")
42+
}

‎leetcode/0816.Ambiguous-Coordinates/README.md

Lines changed: 95 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,95 @@
1+
# [816. Ambiguous Coordinates](https://leetcode.com/problems/ambiguous-coordinates/)
2+
3+
4+
## 题目
5+
6+
We had some 2-dimensional coordinates, like `"(1, 3)"` or `"(2, 0.5)"`.  Then, we removed all commas, decimal points, and spaces, and ended up with the string `s`.  Return a list of strings representing all possibilities for what our original coordinates could have been.
7+
8+
Our original representation never had extraneous zeroes, so we never started with numbers like "00", "0.0", "0.00", "1.0", "001", "00.01", or any other number that can be represented with less digits.  Also, a decimal point within a number never occurs without at least one digit occuring before it, so we never started with numbers like ".1".
9+
10+
The final answer list can be returned in any order.  Also note that all coordinates in the final answer have exactly one space between them (occurring after the comma.)
11+
12+
```
13+
Example 1:Input: s = "(123)"
14+
Output: ["(1, 23)", "(12, 3)", "(1.2, 3)", "(1, 2.3)"]
15+
16+
```
17+
18+
```
19+
Example 2:Input: s = "(00011)"
20+
Output:  ["(0.001, 1)", "(0, 0.011)"]
21+
Explanation:
22+
0.0, 00, 0001 or 00.01 are not allowed.
23+
24+
```
25+
26+
```
27+
Example 3:Input: s = "(0123)"
28+
Output: ["(0, 123)", "(0, 12.3)", "(0, 1.23)", "(0.1, 23)", "(0.1, 2.3)", "(0.12, 3)"]
29+
30+
```
31+
32+
```
33+
Example 4:Input: s = "(100)"
34+
Output: [(10, 0)]
35+
Explanation:
36+
1.0 is not allowed.
37+
38+
```
39+
40+
**Note:**
41+
42+
- `4 <= s.length <= 12`.
43+
- `s[0]` = "(", `s[s.length - 1]` = ")", and the other elements in `s` are digits.
44+
45+
## 题目大意
46+
47+
我们有一些二维坐标，如 "(1, 3)" 或 "(2, 0.5)"，然后我们移除所有逗号，小数点和空格，得到一个字符串S。返回所有可能的原始字符串到一个列表中。原始的坐标表示法不会存在多余的零，所以不会出现类似于"00", "0.0", "0.00", "1.0", "001", "00.01"或一些其他更小的数来表示坐标。此外，一个小数点前至少存在一个数，所以也不会出现“.1”形式的数字。
48+
49+
最后返回的列表可以是任意顺序的。而且注意返回的两个数字中间（逗号之后）都有一个空格。
50+
51+
## 解题思路
52+
53+
- 本题没有什么算法思想，纯暴力题。先将原始字符串一分为二，分为的两个子字符串再移动坐标点，最后将每种情况组合再一次，这算完成了一次切分。将原始字符串每一位都按此规律完成切分，此题便得解。
54+
- 这道题有 2 处需要注意的。第一处是最终输出的字符串，请注意，**两个数字中间（逗号之后）都有一个空格**。不遵守输出格式的要求也会导致 `Wrong Answer`。另外一处是切分数字时，有 2 种违法情况，一种是带前导 0 的，另外一种是末尾带 0 的。带前导 0 的也分为 2 种情况，一种是只有一位，即只有一个 0，这种情况直接返回，因为这一个 0 怎么切分也只有一种切分方法。另外一种是长度大于 1，即 `0xxx` 这种情况。`0xxx` 这种情况只有一种切分方法，即 `0.xxx`。末尾带 0 的只有一种切分方法，即 `xxx0`，不可切分，因为 `xxx.0`，`xx.x0`，`x.xx0` 这些都是违法情况，所以末尾带 0 的也可以直接返回。具体的实现见代码和注释。
55+
56+
## 代码
57+
58+
```go
59+
package leetcode
60+
61+
func ambiguousCoordinates(s string) []string {
62+
res := []string{}
63+
s = s[1 : len(s)-1]
64+
for i := range s[:len(s)-1] {
65+
a := build(s[:i+1])
66+
b := build(s[i+1:])
67+
for _, ta := range a {
68+
for _, tb := range b {
69+
res = append(res, "("+ta+", "+tb+")")
70+
}
71+
}
72+
}
73+
return res
74+
}
75+
76+
func build(s string) []string {
77+
res := []string{}
78+
if len(s) == 1 || s[0] != '0' {
79+
res = append(res, s)
80+
}
81+
// 结尾带 0 的情况
82+
if s[len(s)-1] == '0' {
83+
return res
84+
}
85+
// 切分长度大于一位且带前导 0 的情况
86+
if s[0] == '0' {
87+
res = append(res, "0."+s[1:])
88+
return res
89+
}
90+
for i := range s[:len(s)-1] {
91+
res = append(res, s[:i+1]+"."+s[i+1:])
92+
}
93+
return res
94+
}
95+
```

‎website/content/ChapterFour/0800~0899/0815.Bus-Routes.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -91,5 +91,5 @@ func numBusesToDestination(routes [][]int, S int, T int) int {
9191
----------------------------------------------
9292
<div style="display: flex;justify-content: space-between;align-items: center;">
9393
<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0800~0899/0812.Largest-Triangle-Area/">⬅️上一页</a></p>
94-
<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0800~0899/0817.Linked-List-Components/">下一页➡️</a></p>
94+
<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0800~0899/0816.Ambiguous-Coordinates/">下一页➡️</a></p>
9595
</div>

‎website/content/ChapterFour/0800~0899/0816.Ambiguous-Coordinates.md

Lines changed: 102 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,102 @@
1+
# [816. Ambiguous Coordinates](https://leetcode.com/problems/ambiguous-coordinates/)
2+
3+
4+
## 题目
5+
6+
We had some 2-dimensional coordinates, like `"(1, 3)"` or `"(2, 0.5)"`.  Then, we removed all commas, decimal points, and spaces, and ended up with the string `s`.  Return a list of strings representing all possibilities for what our original coordinates could have been.
7+
8+
Our original representation never had extraneous zeroes, so we never started with numbers like "00", "0.0", "0.00", "1.0", "001", "00.01", or any other number that can be represented with less digits.  Also, a decimal point within a number never occurs without at least one digit occuring before it, so we never started with numbers like ".1".
9+
10+
The final answer list can be returned in any order.  Also note that all coordinates in the final answer have exactly one space between them (occurring after the comma.)
11+
12+
```
13+
Example 1:Input: s = "(123)"
14+
Output: ["(1, 23)", "(12, 3)", "(1.2, 3)", "(1, 2.3)"]
15+
16+
```
17+
18+
```
19+
Example 2:Input: s = "(00011)"
20+
Output:  ["(0.001, 1)", "(0, 0.011)"]
21+
Explanation:
22+
0.0, 00, 0001 or 00.01 are not allowed.
23+
24+
```
25+
26+
```
27+
Example 3:Input: s = "(0123)"
28+
Output: ["(0, 123)", "(0, 12.3)", "(0, 1.23)", "(0.1, 23)", "(0.1, 2.3)", "(0.12, 3)"]
29+
30+
```
31+
32+
```
33+
Example 4:Input: s = "(100)"
34+
Output: [(10, 0)]
35+
Explanation:
36+
1.0 is not allowed.
37+
38+
```
39+
40+
**Note:**
41+
42+
- `4 <= s.length <= 12`.
43+
- `s[0]` = "(", `s[s.length - 1]` = ")", and the other elements in `s` are digits.
44+
45+
## 题目大意
46+
47+
我们有一些二维坐标，如 "(1, 3)" 或 "(2, 0.5)"，然后我们移除所有逗号，小数点和空格，得到一个字符串S。返回所有可能的原始字符串到一个列表中。原始的坐标表示法不会存在多余的零，所以不会出现类似于"00", "0.0", "0.00", "1.0", "001", "00.01"或一些其他更小的数来表示坐标。此外，一个小数点前至少存在一个数，所以也不会出现“.1”形式的数字。
48+
49+
最后返回的列表可以是任意顺序的。而且注意返回的两个数字中间（逗号之后）都有一个空格。
50+
51+
## 解题思路
52+
53+
- 本题没有什么算法思想，纯暴力题。先将原始字符串一分为二，分为的两个子字符串再移动坐标点，最后将每种情况组合再一次，这算完成了一次切分。将原始字符串每一位都按此规律完成切分，此题便得解。
54+
- 这道题有 2 处需要注意的。第一处是最终输出的字符串，请注意，**两个数字中间（逗号之后）都有一个空格**。不遵守输出格式的要求也会导致 `Wrong Answer`。另外一处是切分数字时，有 2 种违法情况，一种是带前导 0 的，另外一种是末尾带 0 的。带前导 0 的也分为 2 种情况，一种是只有一位，即只有一个 0，这种情况直接返回，因为这一个 0 怎么切分也只有一种切分方法。另外一种是长度大于 1，即 `0xxx` 这种情况。`0xxx` 这种情况只有一种切分方法，即 `0.xxx`。末尾带 0 的只有一种切分方法，即 `xxx0`，不可切分，因为 `xxx.0`，`xx.x0`，`x.xx0` 这些都是违法情况，所以末尾带 0 的也可以直接返回。具体的实现见代码和注释。
55+
56+
## 代码
57+
58+
```go
59+
package leetcode
60+
61+
func ambiguousCoordinates(s string) []string {
62+
res := []string{}
63+
s = s[1 : len(s)-1]
64+
for i := range s[:len(s)-1] {
65+
a := build(s[:i+1])
66+
b := build(s[i+1:])
67+
for _, ta := range a {
68+
for _, tb := range b {
69+
res = append(res, "("+ta+", "+tb+")")
70+
}
71+
}
72+
}
73+
return res
74+
}
75+
76+
func build(s string) []string {
77+
res := []string{}
78+
if len(s) == 1 || s[0] != '0' {
79+
res = append(res, s)
80+
}
81+
// 结尾带 0 的情况
82+
if s[len(s)-1] == '0' {
83+
return res
84+
}
85+
// 切分长度大于一位且带前导 0 的情况
86+
if s[0] == '0' {
87+
res = append(res, "0."+s[1:])
88+
return res
89+
}
90+
for i := range s[:len(s)-1] {
91+
res = append(res, s[:i+1]+"."+s[i+1:])
92+
}
93+
return res
94+
}
95+
```
96+
97+
98+
----------------------------------------------
99+
<div style="display: flex;justify-content: space-between;align-items: center;">
100+
<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0800~0899/0815.Bus-Routes/">⬅️上一页</a></p>
101+
<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0800~0899/0817.Linked-List-Components/">下一页➡️</a></p>
102+
</div>

‎website/content/ChapterFour/0800~0899/0817.Linked-List-Components.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -111,6 +111,6 @@ func toMap(G []int) map[int]int {
111111

112112
----------------------------------------------
113113
<div style="display: flex;justify-content: space-between;align-items: center;">
114-
<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0800~0899/0815.Bus-Routes/">⬅️上一页</a></p>
114+
<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0800~0899/0816.Ambiguous-Coordinates/">⬅️上一页</a></p>
115115
<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0800~0899/0819.Most-Common-Word/">下一页➡️</a></p>
116116
</div>

‎website/content/ChapterTwo/Array.md

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -29,7 +29,7 @@ weight: 1
2929
|0053|Maximum Subarray|[Go]({{< relref "/ChapterFour/0001~0099/0053.Maximum-Subarray.md" >}})|Easy| O(n)| O(n)||48.0%|
3030
|0054|Spiral Matrix|[Go]({{< relref "/ChapterFour/0001~0099/0054.Spiral-Matrix.md" >}})|Medium| O(n)| O(n^2)||36.8%|
3131
|0055|Jump Game|[Go]({{< relref "/ChapterFour/0001~0099/0055.Jump-Game.md" >}})|Medium||||35.4%|
32-
|0056|Merge Intervals|[Go]({{< relref "/ChapterFour/0001~0099/0056.Merge-Intervals.md" >}})|Medium| O(n log n)| O(1)||41.6%|
32+
|0056|Merge Intervals|[Go]({{< relref "/ChapterFour/0001~0099/0056.Merge-Intervals.md" >}})|Medium| O(n log n)| O(1)||41.7%|
3333
|0057|Insert Interval|[Go]({{< relref "/ChapterFour/0001~0099/0057.Insert-Interval.md" >}})|Medium| O(n)| O(1)||35.5%|
3434
|0059|Spiral Matrix II|[Go]({{< relref "/ChapterFour/0001~0099/0059.Spiral-Matrix-II.md" >}})|Medium| O(n)| O(n^2)||58.5%|
3535
|0062|Unique Paths|[Go]({{< relref "/ChapterFour/0001~0099/0062.Unique-Paths.md" >}})|Medium| O(n^2)| O(n^2)||56.6%|
@@ -41,7 +41,7 @@ weight: 1
4141
|0075|Sort Colors|[Go]({{< relref "/ChapterFour/0001~0099/0075.Sort-Colors.md" >}})|Medium| O(n)| O(1)|❤️|50.2%|
4242
|0078|Subsets|[Go]({{< relref "/ChapterFour/0001~0099/0078.Subsets.md" >}})|Medium| O(n^2)| O(n)|❤️|66.0%|
4343
|0079|Word Search|[Go]({{< relref "/ChapterFour/0001~0099/0079.Word-Search.md" >}})|Medium| O(n^2)| O(n^2)|❤️|37.4%|
44-
|0080|Remove Duplicates from Sorted Array II|[Go]({{< relref "/ChapterFour/0001~0099/0080.Remove-Duplicates-from-Sorted-Array-II.md" >}})|Medium| O(n)| O(1||46.5%|
44+
|0080|Remove Duplicates from Sorted Array II|[Go]({{< relref "/ChapterFour/0001~0099/0080.Remove-Duplicates-from-Sorted-Array-II.md" >}})|Medium| O(n)| O(1||46.6%|
4545
|0081|Search in Rotated Sorted Array II|[Go]({{< relref "/ChapterFour/0001~0099/0081.Search-in-Rotated-Sorted-Array-II.md" >}})|Medium||||33.8%|
4646
|0084|Largest Rectangle in Histogram|[Go]({{< relref "/ChapterFour/0001~0099/0084.Largest-Rectangle-in-Histogram.md" >}})|Hard| O(n)| O(n)|❤️|37.6%|
4747
|0088|Merge Sorted Array|[Go]({{< relref "/ChapterFour/0001~0099/0088.Merge-Sorted-Array.md" >}})|Easy| O(n)| O(1)|❤️|41.0%|
@@ -113,15 +113,15 @@ weight: 1
113113
|0969|Pancake Sorting|[Go]({{< relref "/ChapterFour/0900~0999/0969.Pancake-Sorting.md" >}})|Medium| O(n)| O(1)|❤️|68.8%|
114114
|0977|Squares of a Sorted Array|[Go]({{< relref "/ChapterFour/0900~0999/0977.Squares-of-a-Sorted-Array.md" >}})|Easy| O(n)| O(1)||71.7%|
115115
|0978|Longest Turbulent Subarray|[Go]({{< relref "/ChapterFour/0900~0999/0978.Longest-Turbulent-Subarray.md" >}})|Medium||||46.7%|
116-
|0985|Sum of Even Numbers After Queries|[Go]({{< relref "/ChapterFour/0900~0999/0985.Sum-of-Even-Numbers-After-Queries.md" >}})|Easy||||60.6%|
116+
|0985|Sum of Even Numbers After Queries|[Go]({{< relref "/ChapterFour/0900~0999/0985.Sum-of-Even-Numbers-After-Queries.md" >}})|Easy||||60.5%|
117117
|0989|Add to Array-Form of Integer|[Go]({{< relref "/ChapterFour/0900~0999/0989.Add-to-Array-Form-of-Integer.md" >}})|Easy||||44.9%|
118118
|0999|Available Captures for Rook|[Go]({{< relref "/ChapterFour/0900~0999/0999.Available-Captures-for-Rook.md" >}})|Easy||||67.8%|
119119
|1002|Find Common Characters|[Go]({{< relref "/ChapterFour/1000~1099/1002.Find-Common-Characters.md" >}})|Easy||||68.7%|
120120
|1011|Capacity To Ship Packages Within D Days|[Go]({{< relref "/ChapterFour/1000~1099/1011.Capacity-To-Ship-Packages-Within-D-Days.md" >}})|Medium||||60.1%|
121121
|1018|Binary Prefix Divisible By 5|[Go]({{< relref "/ChapterFour/1000~1099/1018.Binary-Prefix-Divisible-By-5.md" >}})|Easy||||47.6%|
122122
|1040|Moving Stones Until Consecutive II|[Go]({{< relref "/ChapterFour/1000~1099/1040.Moving-Stones-Until-Consecutive-II.md" >}})|Medium||||54.5%|
123123
|1051|Height Checker|[Go]({{< relref "/ChapterFour/1000~1099/1051.Height-Checker.md" >}})|Easy||||72.6%|
124-
|1052|Grumpy Bookstore Owner|[Go]({{< relref "/ChapterFour/1000~1099/1052.Grumpy-Bookstore-Owner.md" >}})|Medium||||56.0%|
124+
|1052|Grumpy Bookstore Owner|[Go]({{< relref "/ChapterFour/1000~1099/1052.Grumpy-Bookstore-Owner.md" >}})|Medium||||56.1%|
125125
|1074|Number of Submatrices That Sum to Target|[Go]({{< relref "/ChapterFour/1000~1099/1074.Number-of-Submatrices-That-Sum-to-Target.md" >}})|Hard||||65.0%|
126126
|1089|Duplicate Zeros|[Go]({{< relref "/ChapterFour/1000~1099/1089.Duplicate-Zeros.md" >}})|Easy||||51.5%|
127127
|1122|Relative Sort Array|[Go]({{< relref "/ChapterFour/1100~1199/1122.Relative-Sort-Array.md" >}})|Easy||||68.1%|
@@ -137,9 +137,9 @@ weight: 1
137137
|1217|Minimum Cost to Move Chips to The Same Position|[Go]({{< relref "/ChapterFour/1200~1299/1217.Minimum-Cost-to-Move-Chips-to-The-Same-Position.md" >}})|Easy||||70.8%|
138138
|1232|Check If It Is a Straight Line|[Go]({{< relref "/ChapterFour/1200~1299/1232.Check-If-It-Is-a-Straight-Line.md" >}})|Easy||||43.0%|
139139
|1252|Cells with Odd Values in a Matrix|[Go]({{< relref "/ChapterFour/1200~1299/1252.Cells-with-Odd-Values-in-a-Matrix.md" >}})|Easy||||78.6%|
140-
|1260|Shift 2D Grid|[Go]({{< relref "/ChapterFour/1200~1299/1260.Shift-2D-Grid.md" >}})|Easy||||61.8%|
140+
|1260|Shift 2D Grid|[Go]({{< relref "/ChapterFour/1200~1299/1260.Shift-2D-Grid.md" >}})|Easy||||61.7%|
141141
|1266|Minimum Time Visiting All Points|[Go]({{< relref "/ChapterFour/1200~1299/1266.Minimum-Time-Visiting-All-Points.md" >}})|Easy||||79.2%|
142-
|1275|Find Winner on a Tic Tac Toe Game|[Go]({{< relref "/ChapterFour/1200~1299/1275.Find-Winner-on-a-Tic-Tac-Toe-Game.md" >}})|Easy||||52.8%|
142+
|1275|Find Winner on a Tic Tac Toe Game|[Go]({{< relref "/ChapterFour/1200~1299/1275.Find-Winner-on-a-Tic-Tac-Toe-Game.md" >}})|Easy||||52.9%|
143143
|1287|Element Appearing More Than 25% In Sorted Array|[Go]({{< relref "/ChapterFour/1200~1299/1287.Element-Appearing-More-Than-25-In-Sorted-Array.md" >}})|Easy||||60.2%|
144144
|1295|Find Numbers with Even Number of Digits|[Go]({{< relref "/ChapterFour/1200~1299/1295.Find-Numbers-with-Even-Number-of-Digits.md" >}})|Easy||||78.6%|
145145
|1299|Replace Elements with Greatest Element on Right Side|[Go]({{< relref "/ChapterFour/1200~1299/1299.Replace-Elements-with-Greatest-Element-on-Right-Side.md" >}})|Easy||||74.5%|
@@ -162,11 +162,11 @@ weight: 1
162162
|1512|Number of Good Pairs|[Go]({{< relref "/ChapterFour/1500~1599/1512.Number-of-Good-Pairs.md" >}})|Easy||||87.6%|
163163
|1539|Kth Missing Positive Number|[Go]({{< relref "/ChapterFour/1500~1599/1539.Kth-Missing-Positive-Number.md" >}})|Easy||||54.8%|
164164
|1608|Special Array With X Elements Greater Than or Equal X|[Go]({{< relref "/ChapterFour/1600~1699/1608.Special-Array-With-X-Elements-Greater-Than-or-Equal-X.md" >}})|Easy||||61.4%|
165-
|1619|Mean of Array After Removing Some Elements|[Go]({{< relref "/ChapterFour/1600~1699/1619.Mean-of-Array-After-Removing-Some-Elements.md" >}})|Easy||||64.5%|
165+
|1619|Mean of Array After Removing Some Elements|[Go]({{< relref "/ChapterFour/1600~1699/1619.Mean-of-Array-After-Removing-Some-Elements.md" >}})|Easy||||64.4%|
166166
|1629|Slowest Key|[Go]({{< relref "/ChapterFour/1600~1699/1629.Slowest-Key.md" >}})|Easy||||59.0%|
167-
|1636|Sort Array by Increasing Frequency|[Go]({{< relref "/ChapterFour/1600~1699/1636.Sort-Array-by-Increasing-Frequency.md" >}})|Easy||||67.1%|
167+
|1636|Sort Array by Increasing Frequency|[Go]({{< relref "/ChapterFour/1600~1699/1636.Sort-Array-by-Increasing-Frequency.md" >}})|Easy||||67.0%|
168168
|1640|Check Array Formation Through Concatenation|[Go]({{< relref "/ChapterFour/1600~1699/1640.Check-Array-Formation-Through-Concatenation.md" >}})|Easy||||59.6%|
169-
|1646|Get Maximum in Generated Array|[Go]({{< relref "/ChapterFour/1600~1699/1646.Get-Maximum-in-Generated-Array.md" >}})|Easy||||53.1%|
169+
|1646|Get Maximum in Generated Array|[Go]({{< relref "/ChapterFour/1600~1699/1646.Get-Maximum-in-Generated-Array.md" >}})|Easy||||53.0%|
170170
|1652|Defuse the Bomb|[Go]({{< relref "/ChapterFour/1600~1699/1652.Defuse-the-Bomb.md" >}})|Easy||||61.1%|
171171
|1656|Design an Ordered Stream|[Go]({{< relref "/ChapterFour/1600~1699/1656.Design-an-Ordered-Stream.md" >}})|Easy||||82.1%|
172172
|1672|Richest Customer Wealth|[Go]({{< relref "/ChapterFour/1600~1699/1672.Richest-Customer-Wealth.md" >}})|Easy||||88.1%|

‎website/content/ChapterTwo/Binary_Indexed_Tree.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,7 @@ weight: 19
1010

1111
| No. | Title | Solution | Difficulty | TimeComplexity | SpaceComplexity |Favorite| Acceptance |
1212
|:--------:|:------- | :--------: | :----------: | :----: | :-----: | :-----: |:-----: |
13-
|0218|The Skyline Problem|[Go]({{< relref "/ChapterFour/0200~0299/0218.The-Skyline-Problem.md" >}})|Hard||||36.8%|
13+
|0218|The Skyline Problem|[Go]({{< relref "/ChapterFour/0200~0299/0218.The-Skyline-Problem.md" >}})|Hard||||36.9%|
1414
|0307|Range Sum Query - Mutable|[Go]({{< relref "/ChapterFour/0300~0399/0307.Range-Sum-Query-Mutable.md" >}})|Medium||||37.2%|
1515
|0315|Count of Smaller Numbers After Self|[Go]({{< relref "/ChapterFour/0300~0399/0315.Count-of-Smaller-Numbers-After-Self.md" >}})|Hard||||42.3%|
1616
|0327|Count of Range Sum|[Go]({{< relref "/ChapterFour/0300~0399/0327.Count-of-Range-Sum.md" >}})|Hard||||36.3%|

0 commit comments

Comments
 (0)