algorithm/LeetCode-Go
1
0
Fork 0
mirror of https://github.com/halfrost/LeetCode-Go.git synced 2026-03-13 10:02:05 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add solution 0473

Browse Source
This commit is contained in:
halfrost
2021-06-16 18:16:04 +08:00
parent 5cf1b806b1
commit 555737bcff
12 changed files with 311 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
README.md
View File

@@ -126,16 +126,16 @@
| | Easy | Medium | Hard | Total |
|:--------:|:--------:|:--------:|:--------:|:--------:|
|Optimizing|33|33|23|89|
|Optimizing|33|32|23|88|
|Accepted|**285**|**386**|**114**|**785**|
|Total|499|1003|399|1901|
|Perfection Rate|88.4%|91.5%|79.8%|88.7%|
|Perfection Rate|88.4%|91.7%|79.8%|88.8%|
|Completion Rate|57.1%|38.5%|28.6%|41.3%|
|------------|----------------------------|----------------------------|----------------------------|----------------------------|
## 二. 目录
以下已经收录了 696 道题的题解，还有 11 道题在尝试优化到 beats 100%
以下已经收录了 697 道题的题解，还有 11 道题在尝试优化到 beats 100%
| No. | Title | Solution | Acceptance | Difficulty | Frequency |
|:--------:|:--------------------------------------------------------------|:--------:|:--------:|:--------:|:--------:|
@@ -611,7 +611,7 @@
|0470|Implement Rand10() Using Rand7()|[Go](https://github.com/halfrost/LeetCode-Go/tree/master/leetcode/0470.Implement-Rand10()-Using-Rand7())|46.1%|Medium||
|0471|Encode String with Shortest Length||50.0%|Hard||
|0472|Concatenated Words||44.0%|Hard||
|0473|Matchsticks to Square||40.0%|Medium||
|0473|Matchsticks to Square|[Go](https://github.com/halfrost/LeetCode-Go/tree/master/leetcode/0473.Matchsticks-to-Square)|40.0%|Medium||
|0474|Ones and Zeroes|[Go](https://github.com/halfrost/LeetCode-Go/tree/master/leetcode/0474.Ones-and-Zeroes)|43.5%|Medium||
|0475|Heaters|[Go](https://github.com/halfrost/LeetCode-Go/tree/master/leetcode/0475.Heaters)|33.9%|Medium||
|0476|Number Complement|[Go](https://github.com/halfrost/LeetCode-Go/tree/master/leetcode/0476.Number-Complement)|65.2%|Easy||
@@ -664,7 +664,7 @@
|0523|Continuous Subarray Sum|[Go](https://github.com/halfrost/LeetCode-Go/tree/master/leetcode/0523.Continuous-Subarray-Sum)|25.2%|Medium||
|0524|Longest Word in Dictionary through Deleting|[Go](https://github.com/halfrost/LeetCode-Go/tree/master/leetcode/0524.Longest-Word-in-Dictionary-through-Deleting)|50.3%|Medium||
|0525|Contiguous Array|[Go](https://github.com/halfrost/LeetCode-Go/tree/master/leetcode/0525.Contiguous-Array)|43.9%|Medium||
|0526|Beautiful Arrangement|[Go](https://github.com/halfrost/LeetCode-Go/tree/master/leetcode/0526.Beautiful-Arrangement)|62.4%|Medium||
|0526|Beautiful Arrangement|[Go](https://github.com/halfrost/LeetCode-Go/tree/master/leetcode/0526.Beautiful-Arrangement)|62.3%|Medium||
|0527|Word Abbreviation||56.8%|Hard||
|0528|Random Pick with Weight|[Go](https://github.com/halfrost/LeetCode-Go/tree/master/leetcode/0528.Random-Pick-with-Weight)|45.0%|Medium||
|0529|Minesweeper|[Go](https://github.com/halfrost/LeetCode-Go/tree/master/leetcode/0529.Minesweeper)|62.1%|Medium||
@@ -1745,7 +1745,7 @@
|1604|Alert Using Same Key-Card Three or More Times in a One Hour Period||43.5%|Medium||
|1605|Find Valid Matrix Given Row and Column Sums||77.6%|Medium||
|1606|Find Servers That Handled Most Number of Requests||38.1%|Hard||
|1607|Sellers With No Sales||55.1%|Easy||
|1607|Sellers With No Sales||55.2%|Easy||
|1608|Special Array With X Elements Greater Than or Equal X|[Go](https://github.com/halfrost/LeetCode-Go/tree/master/leetcode/1608.Special-Array-With-X-Elements-Greater-Than-or-Equal-X)|61.4%|Easy||
|1609|Even Odd Tree||52.3%|Medium||
|1610|Maximum Number of Visible Points||32.5%|Hard||
@@ -1778,9 +1778,9 @@
|1637|Widest Vertical Area Between Two Points Containing No Points||83.8%|Medium||
|1638|Count Substrings That Differ by One Character||71.2%|Medium||
|1639|Number of Ways to Form a Target String Given a Dictionary||40.3%|Hard||
|1640|Check Array Formation Through Concatenation|[Go](https://github.com/halfrost/LeetCode-Go/tree/master/leetcode/1640.Check-Array-Formation-Through-Concatenation)|55.6%|Easy||
|1640|Check Array Formation Through Concatenation|[Go](https://github.com/halfrost/LeetCode-Go/tree/master/leetcode/1640.Check-Array-Formation-Through-Concatenation)|55.5%|Easy||
|1641|Count Sorted Vowel Strings|[Go](https://github.com/halfrost/LeetCode-Go/tree/master/leetcode/1641.Count-Sorted-Vowel-Strings)|75.0%|Medium||
|1642|Furthest Building You Can Reach|[Go](https://github.com/halfrost/LeetCode-Go/tree/master/leetcode/1642.Furthest-Building-You-Can-Reach)|43.3%|Medium||
|1642|Furthest Building You Can Reach|[Go](https://github.com/halfrost/LeetCode-Go/tree/master/leetcode/1642.Furthest-Building-You-Can-Reach)|43.4%|Medium||
|1643|Kth Smallest Instructions||45.4%|Hard||
|1644|Lowest Common Ancestor of a Binary Tree II||56.9%|Medium||
|1645|Hopper Company Queries II||38.9%|Hard||
@@ -1857,7 +1857,7 @@
|1716|Calculate Money in Leetcode Bank|[Go](https://github.com/halfrost/LeetCode-Go/tree/master/leetcode/1716.Calculate-Money-in-Leetcode-Bank)|64.1%|Easy||
|1717|Maximum Score From Removing Substrings||41.6%|Medium||
|1718|Construct the Lexicographically Largest Valid Sequence||48.4%|Medium||
|1719|Number Of Ways To Reconstruct A Tree||39.7%|Hard||
|1719|Number Of Ways To Reconstruct A Tree||39.8%|Hard||
|1720|Decode XORed Array|[Go](https://github.com/halfrost/LeetCode-Go/tree/master/leetcode/1720.Decode-XORed-Array)|85.4%|Easy||
|1721|Swapping Nodes in a Linked List|[Go](https://github.com/halfrost/LeetCode-Go/tree/master/leetcode/1721.Swapping-Nodes-in-a-Linked-List)|66.6%|Medium||
|1722|Minimize Hamming Distance After Swap Operations||46.0%|Medium||
@@ -1917,7 +1917,7 @@
|1776|Car Fleet II||49.7%|Hard||
|1777|Product's Price for Each Store||86.4%|Easy||
|1778|Shortest Path in a Hidden Grid||45.0%|Medium||
|1779|Find Nearest Point That Has the Same X or Y Coordinate||66.7%|Easy||
|1779|Find Nearest Point That Has the Same X or Y Coordinate||66.6%|Easy||
|1780|Check if Number is a Sum of Powers of Three||63.2%|Medium||
|1781|Sum of Beauty of All Substrings||58.3%|Medium||
|1782|Count Pairs Of Nodes||34.4%|Hard||
@@ -1981,7 +1981,7 @@
|1840|Maximum Building Height||34.3%|Hard||
|1841|League Statistics||61.7%|Medium||
|1842|Next Palindrome Using Same Digits||63.8%|Hard||
|1843|Suspicious Bank Accounts||52.2%|Medium||
|1843|Suspicious Bank Accounts||52.1%|Medium||
|1844|Replace All Digits with Characters||80.1%|Easy||
|1845|Seat Reservation Manager||55.1%|Medium||
|1846|Maximum Element After Decreasing and Rearranging||54.6%|Medium||
@@ -2023,7 +2023,7 @@
|1882|Process Tasks Using Servers||30.4%|Medium||
|1883|Minimum Skips to Arrive at Meeting On Time||38.0%|Hard||
|1884|Egg Drop With 2 Eggs and N Floors||70.6%|Medium||
|1885|Count Pairs in Two Arrays||56.2%|Medium||
|1885|Count Pairs in Two Arrays||56.3%|Medium||
|1886|Determine Whether Matrix Can Be Obtained By Rotation||53.6%|Easy||
|1887|Reduction Operations to Make the Array Elements Equal||59.5%|Medium||
|1888|Minimum Number of Flips to Make the Binary String Alternating||33.6%|Medium||
@@ -2032,7 +2032,7 @@
|1891|Cutting Ribbons||55.8%|Medium||
|1892|Page Recommendations II||40.6%|Hard||
|1893|Check if All the Integers in a Range Are Covered||48.8%|Easy||
|1894|Find the Student that Will Replace the Chalk||37.9%|Medium||
|1894|Find the Student that Will Replace the Chalk||37.8%|Medium||
|1895|Largest Magic Square||48.4%|Medium||
|1896|Minimum Cost to Change the Final Value of Expression||49.4%|Hard||
|1897|Redistribute Characters to Make All Strings Equal||58.1%|Easy||

49
leetcode/0473.Matchsticks-to-Square/473. Matchsticks to Square.go Normal file
View File

@@ -0,0 +1,49 @@
package leetcode
import "sort"
func makesquare(matchsticks []int) bool {
if len(matchsticks) < 4 {
return false
}
total := 0
for _, v := range matchsticks {
total += v
}
if total%4 != 0 {
return false
}
sort.Slice(matchsticks, func(i, j int) bool {
return matchsticks[i] > matchsticks[j]
})
visited := make([]bool, 16)
return dfs(matchsticks, 0, 0, 0, total, &visited)
}
func dfs(matchsticks []int, cur, group, sum, total int, visited *[]bool) bool {
if group == 4 {
return true
}
if sum > total/4 {
return false
}
if sum == total/4 {
return dfs(matchsticks, 0, group+1, 0, total, visited)
}
last := -1
for i := cur; i < len(matchsticks); i++ {
if (*visited)[i] {
continue
}
if last == matchsticks[i] {
continue
}
(*visited)[i] = true
last = matchsticks[i]
if dfs(matchsticks, i+1, group, sum+matchsticks[i], total, visited) {
return true
}
(*visited)[i] = false
}
return false
}

47
leetcode/0473.Matchsticks-to-Square/473. Matchsticks to Square_test.go Normal file
View File

@@ -0,0 +1,47 @@
package leetcode
import (
"fmt"
"testing"
)
type question473 struct {
para473
ans473
}
// para 是参数
// one 代表第一个参数
type para473 struct {
arr []int
}
// ans 是答案
// one 代表第一个答案
type ans473 struct {
one bool
}
func Test_Problem473(t *testing.T) {
qs := []question473{
{
para473{[]int{1, 1, 2, 2, 2}},
ans473{true},
},
{
para473{[]int{3, 3, 3, 3, 4}},
ans473{false},
},
}
fmt.Printf("------------------------Leetcode Problem 473------------------------\n")
for _, q := range qs {
_, p := q.ans473, q.para473
fmt.Printf("【input】:%v 【output】:%v\n", p, makesquare(p.arr))
}
fmt.Printf("\n\n\n")
}

94
leetcode/0473.Matchsticks-to-Square/README.md Normal file
View File

@@ -0,0 +1,94 @@
# [473. Matchsticks to Square](https://leetcode.com/problems/matchsticks-to-square/)
## 题目
You are given an integer array `matchsticks` where `matchsticks[i]` is the length of the `ith` matchstick. You want to use **all the matchsticks** to make one square. You **should not break** any stick, but you can link them up, and each matchstick must be used **exactly one time**.
Return `true` if you can make this square and `false` otherwise.
**Example 1:**
![https://assets.leetcode.com/uploads/2021/04/09/matchsticks1-grid.jpg](https://assets.leetcode.com/uploads/2021/04/09/matchsticks1-grid.jpg)
```
Input: matchsticks = [1,1,2,2,2]
Output: true
Explanation: You can form a square with length 2, one side of the square came two sticks with length 1.
```
**Example 2:**
```
Input: matchsticks = [3,3,3,3,4]
Output: false
Explanation: You cannot find a way to form a square with all the matchsticks.
```
**Constraints:**
- `1 <= matchsticks.length <= 15`
- `0 <= matchsticks[i] <= 109`
## 题目大意
现在已知小女孩有多少根火柴，请找出一种能使用所有火柴拼成一个正方形的方法。不能折断火柴，可以把火柴连接起来，并且每根火柴都要用到。输入为小女孩拥有火柴的数目，每根火柴用其长度表示。输出即为是否能用所有的火柴拼成正方形。
## 解题思路
- 将火柴拼成一个正方形，可以将它们分成四组，每一根火柴恰好属于其中的一组；并且每一组火柴的长度之和都相同，等于所有火柴长度之和的四分之一。
- 考虑暴力解法，使用深度优先搜索枚举出所有的分组情况，并对于每一种情况，判断是否满足上述的两个条件(每根火柴属于其中一组，每组火柴长度之和相同)。依次对每一根火柴进行搜索，当搜索到第 i 根火柴时，可以考虑把它放到四组中的任意一种。对于每一种放置方法，继续对第 i + 1 根火柴进行深搜。当我们搜索完全部的 N 根火柴后，再判断每一组火柴的长度之和是否都相同。
## 代码
```go
package leetcode
import "sort"
func makesquare(matchsticks []int) bool {
if len(matchsticks) < 4 {
return false
}
total := 0
for _, v := range matchsticks {
total += v
}
if total%4 != 0 {
return false
}
sort.Slice(matchsticks, func(i, j int) bool {
return matchsticks[i] > matchsticks[j]
})
visited := make([]bool, 16)
return dfs(matchsticks, 0, 0, 0, total, &visited)
}
func dfs(matchsticks []int, cur, group, sum, total int, visited *[]bool) bool {
if group == 4 {
return true
}
if sum > total/4 {
return false
}
if sum == total/4 {
return dfs(matchsticks, 0, group+1, 0, total, visited)
}
last := -1
for i := cur; i < len(matchsticks); i++ {
if (*visited)[i] {
continue
}
if last == matchsticks[i] {
continue
}
(*visited)[i] = true
last = matchsticks[i]
if dfs(matchsticks, i+1, group, sum+matchsticks[i], total, visited) {
return true
}
(*visited)[i] = false
}
return false
}
```

2
website/content/ChapterFour/0400~0499/0470.Implement-Rand10-Using-Rand7.md
View File

@@ -103,5 +103,5 @@ func rand101() int {
----------------------------------------------
<div style="display: flex;justify-content: space-between;align-items: center;">
<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0400~0499/0463.Island-Perimeter/">⬅️上一页</a></p>
<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0400~0499/0474.Ones-and-Zeroes/">下一页➡️</a></p>
<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0400~0499/0473.Matchsticks-to-Square/">下一页➡️</a></p>
</div>

101
website/content/ChapterFour/0400~0499/0473.Matchsticks-to-Square.md Normal file
View File

@@ -0,0 +1,101 @@
# [473. Matchsticks to Square](https://leetcode.com/problems/matchsticks-to-square/)
## 题目
You are given an integer array `matchsticks` where `matchsticks[i]` is the length of the `ith` matchstick. You want to use **all the matchsticks** to make one square. You **should not break** any stick, but you can link them up, and each matchstick must be used **exactly one time**.
Return `true` if you can make this square and `false` otherwise.
**Example 1:**
![https://assets.leetcode.com/uploads/2021/04/09/matchsticks1-grid.jpg](https://assets.leetcode.com/uploads/2021/04/09/matchsticks1-grid.jpg)
```
Input: matchsticks = [1,1,2,2,2]
Output: true
Explanation: You can form a square with length 2, one side of the square came two sticks with length 1.
```
**Example 2:**
```
Input: matchsticks = [3,3,3,3,4]
Output: false
Explanation: You cannot find a way to form a square with all the matchsticks.
```
**Constraints:**
- `1 <= matchsticks.length <= 15`
- `0 <= matchsticks[i] <= 109`
## 题目大意
现在已知小女孩有多少根火柴，请找出一种能使用所有火柴拼成一个正方形的方法。不能折断火柴，可以把火柴连接起来，并且每根火柴都要用到。输入为小女孩拥有火柴的数目，每根火柴用其长度表示。输出即为是否能用所有的火柴拼成正方形。
## 解题思路
- 将火柴拼成一个正方形，可以将它们分成四组，每一根火柴恰好属于其中的一组；并且每一组火柴的长度之和都相同，等于所有火柴长度之和的四分之一。
- 考虑暴力解法，使用深度优先搜索枚举出所有的分组情况，并对于每一种情况，判断是否满足上述的两个条件(每根火柴属于其中一组，每组火柴长度之和相同)。依次对每一根火柴进行搜索，当搜索到第 i 根火柴时，可以考虑把它放到四组中的任意一种。对于每一种放置方法，继续对第 i + 1 根火柴进行深搜。当我们搜索完全部的 N 根火柴后，再判断每一组火柴的长度之和是否都相同。
## 代码
```go
package leetcode
import "sort"
func makesquare(matchsticks []int) bool {
if len(matchsticks) < 4 {
return false
}
total := 0
for _, v := range matchsticks {
total += v
}
if total%4 != 0 {
return false
}
sort.Slice(matchsticks, func(i, j int) bool {
return matchsticks[i] > matchsticks[j]
})
visited := make([]bool, 16)
return dfs(matchsticks, 0, 0, 0, total, &visited)
}
func dfs(matchsticks []int, cur, group, sum, total int, visited *[]bool) bool {
if group == 4 {
return true
}
if sum > total/4 {
return false
}
if sum == total/4 {
return dfs(matchsticks, 0, group+1, 0, total, visited)
}
last := -1
for i := cur; i < len(matchsticks); i++ {
if (*visited)[i] {
continue
}
if last == matchsticks[i] {
continue
}
(*visited)[i] = true
last = matchsticks[i]
if dfs(matchsticks, i+1, group, sum+matchsticks[i], total, visited) {
return true
}
(*visited)[i] = false
}
return false
}
```
----------------------------------------------
<div style="display: flex;justify-content: space-between;align-items: center;">
<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0400~0499/0470.Implement-Rand10-Using-Rand7/">⬅️上一页</a></p>
<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0400~0499/0474.Ones-and-Zeroes/">下一页➡️</a></p>
</div>

2
website/content/ChapterFour/0400~0499/0474.Ones-and-Zeroes.md
View File

@@ -80,6 +80,6 @@ func findMaxForm(strs []string, m int, n int) int {
----------------------------------------------
<div style="display: flex;justify-content: space-between;align-items: center;">
<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0400~0499/0470.Implement-Rand10-Using-Rand7/">⬅️上一页</a></p>
<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0400~0499/0473.Matchsticks-to-Square/">⬅️上一页</a></p>
<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0400~0499/0475.Heaters/">下一页➡️</a></p>
</div>

2
website/content/ChapterTwo/Array.md
View File

@@ -168,7 +168,7 @@ weight: 1
|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%|
|1629|Slowest Key|[Go]({{< relref "/ChapterFour/1600~1699/1629.Slowest-Key.md" >}})|Easy||||59.1%|
|1636|Sort Array by Increasing Frequency|[Go]({{< relref "/ChapterFour/1600~1699/1636.Sort-Array-by-Increasing-Frequency.md" >}})|Easy||||67.2%|
|1640|Check Array Formation Through Concatenation|[Go]({{< relref "/ChapterFour/1600~1699/1640.Check-Array-Formation-Through-Concatenation.md" >}})|Easy||||55.6%|
|1640|Check Array Formation Through Concatenation|[Go]({{< relref "/ChapterFour/1600~1699/1640.Check-Array-Formation-Through-Concatenation.md" >}})|Easy||||55.5%|
|1646|Get Maximum in Generated Array|[Go]({{< relref "/ChapterFour/1600~1699/1646.Get-Maximum-in-Generated-Array.md" >}})|Easy||||52.8%|
|1652|Defuse the Bomb|[Go]({{< relref "/ChapterFour/1600~1699/1652.Defuse-the-Bomb.md" >}})|Easy||||60.5%|
|1656|Design an Ordered Stream|[Go]({{< relref "/ChapterFour/1600~1699/1656.Design-an-Ordered-Stream.md" >}})|Easy||||82.2%|

2
website/content/ChapterTwo/Binary_Search.md
View File

@@ -200,7 +200,7 @@ func peakIndexInMountainArray(A []int) int {
|1337|The K Weakest Rows in a Matrix|[Go]({{< relref "/ChapterFour/1300~1399/1337.The-K-Weakest-Rows-in-a-Matrix.md" >}})|Easy||||72.0%|
|1482|Minimum Number of Days to Make m Bouquets|[Go]({{< relref "/ChapterFour/1400~1499/1482.Minimum-Number-of-Days-to-Make-m-Bouquets.md" >}})|Medium||||52.0%|
|1631|Path With Minimum Effort|[Go]({{< relref "/ChapterFour/1600~1699/1631.Path-With-Minimum-Effort.md" >}})|Medium||||50.2%|
|1642|Furthest Building You Can Reach|[Go]({{< relref "/ChapterFour/1600~1699/1642.Furthest-Building-You-Can-Reach.md" >}})|Medium||||43.3%|
|1642|Furthest Building You Can Reach|[Go]({{< relref "/ChapterFour/1600~1699/1642.Furthest-Building-You-Can-Reach.md" >}})|Medium||||43.4%|
|1649|Create Sorted Array through Instructions|[Go]({{< relref "/ChapterFour/1600~1699/1649.Create-Sorted-Array-through-Instructions.md" >}})|Hard||||36.8%|
|1658|Minimum Operations to Reduce X to Zero|[Go]({{< relref "/ChapterFour/1600~1699/1658.Minimum-Operations-to-Reduce-X-to-Zero.md" >}})|Medium||||33.4%|
|------------|-------------------------------------------------------|-------| ----------------| ---------------|-------------|-------------|-------------|

1
website/content/ChapterTwo/Depth_First_Search.md
View File

@@ -38,6 +38,7 @@ weight: 9
|0337|House Robber III|[Go]({{< relref "/ChapterFour/0300~0399/0337.House-Robber-III.md" >}})|Medium||||52.1%|
|0394|Decode String|[Go]({{< relref "/ChapterFour/0300~0399/0394.Decode-String.md" >}})|Medium| O(n)| O(n)||53.5%|
|0417|Pacific Atlantic Water Flow|[Go]({{< relref "/ChapterFour/0400~0499/0417.Pacific-Atlantic-Water-Flow.md" >}})|Medium||||44.8%|
|0473|Matchsticks to Square|[Go]({{< relref "/ChapterFour/0400~0499/0473.Matchsticks-to-Square.md" >}})|Medium||||40.0%|
|0491|Increasing Subsequences|[Go]({{< relref "/ChapterFour/0400~0499/0491.Increasing-Subsequences.md" >}})|Medium||||48.3%|
|0494|Target Sum|[Go]({{< relref "/ChapterFour/0400~0499/0494.Target-Sum.md" >}})|Medium||||45.6%|
|0513|Find Bottom Left Tree Value|[Go]({{< relref "/ChapterFour/0500~0599/0513.Find-Bottom-Left-Tree-Value.md" >}})|Medium||||63.2%|

2
website/content/ChapterTwo/Hash_Table.md
View File

@@ -85,7 +85,7 @@ weight: 13
|1207|Unique Number of Occurrences|[Go]({{< relref "/ChapterFour/1200~1299/1207.Unique-Number-of-Occurrences.md" >}})|Easy||||72.2%|
|1512|Number of Good Pairs|[Go]({{< relref "/ChapterFour/1500~1599/1512.Number-of-Good-Pairs.md" >}})|Easy||||87.6%|
|1539|Kth Missing Positive Number|[Go]({{< relref "/ChapterFour/1500~1599/1539.Kth-Missing-Positive-Number.md" >}})|Easy||||54.7%|
|1640|Check Array Formation Through Concatenation|[Go]({{< relref "/ChapterFour/1600~1699/1640.Check-Array-Formation-Through-Concatenation.md" >}})|Easy||||55.6%|
|1640|Check Array Formation Through Concatenation|[Go]({{< relref "/ChapterFour/1600~1699/1640.Check-Array-Formation-Through-Concatenation.md" >}})|Easy||||55.5%|
|1679|Max Number of K-Sum Pairs|[Go]({{< relref "/ChapterFour/1600~1699/1679.Max-Number-of-K-Sum-Pairs.md" >}})|Medium||||53.6%|
|1748|Sum of Unique Elements|[Go]({{< relref "/ChapterFour/1700~1799/1748.Sum-of-Unique-Elements.md" >}})|Easy||||74.7%|
|------------|-------------------------------------------------------|-------| ----------------| ---------------|-------------|-------------|-------------|

2
website/content/ChapterTwo/Sort.md
View File

@@ -51,7 +51,7 @@ weight: 14
|1353|Maximum Number of Events That Can Be Attended|[Go]({{< relref "/ChapterFour/1300~1399/1353.Maximum-Number-of-Events-That-Can-Be-Attended.md" >}})|Medium||||30.7%|
|1383|Maximum Performance of a Team|[Go]({{< relref "/ChapterFour/1300~1399/1383.Maximum-Performance-of-a-Team.md" >}})|Hard||||41.2%|
|1636|Sort Array by Increasing Frequency|[Go]({{< relref "/ChapterFour/1600~1699/1636.Sort-Array-by-Increasing-Frequency.md" >}})|Easy||||67.2%|
|1640|Check Array Formation Through Concatenation|[Go]({{< relref "/ChapterFour/1600~1699/1640.Check-Array-Formation-Through-Concatenation.md" >}})|Easy||||55.6%|
|1640|Check Array Formation Through Concatenation|[Go]({{< relref "/ChapterFour/1600~1699/1640.Check-Array-Formation-Through-Concatenation.md" >}})|Easy||||55.5%|
|1647|Minimum Deletions to Make Character Frequencies Unique|[Go]({{< relref "/ChapterFour/1600~1699/1647.Minimum-Deletions-to-Make-Character-Frequencies-Unique.md" >}})|Medium||||55.7%|
|1648|Sell Diminishing-Valued Colored Balls|[Go]({{< relref "/ChapterFour/1600~1699/1648.Sell-Diminishing-Valued-Colored-Balls.md" >}})|Medium||||31.1%|
|1691|Maximum Height by Stacking Cuboids|[Go]({{< relref "/ChapterFour/1600~1699/1691.Maximum-Height-by-Stacking-Cuboids.md" >}})|Hard||||51.0%|