添加内容

Author: halfrost

.github/workflows/deploy.yml

@@ -4,6 +4,7 @@ on:
   push:
     branches:
       - master  # 只在master上push触发部署
+      - add_hugo
     paths-ignore:   # 下列文件的变更不触发部署，可以自行添加
       - README.md
       - LICENSE

Algorithms/1093.Statistics-from-a-Large-Sample/README.md

@@ -45,7 +45,7 @@ Return the minimum, maximum, mean, median, and mode of the sample respectively,
 
 
 - 这个问题的关键需要理解题目的意思，什么是采样？`count[k]` 就是整数 `k` 的采样个数。
-- 题目要求返回样本的最小值、最大值、平均值、中位数和众数。最大值和最小值就很好处理，只需要遍历 count 判断最小的非 0 的 index 就是最小值，最大的非 0 的 index 就是最大值。平均值也非常好处理，对于所有非 0 的 count，我们通过累加 count[k] * index 得到所有数的和，然后除上所有非 0 的 count 的和。![](https://latex.codecogs.com/gif.latex?%24%24%5Csum_%7Bn%3D0%7D%5E%7B256%7Dcount%5Bn%5D%28while%5C%20%5C%20count%5Bn%5D%21%3D0%29%24%24)
+- 题目要求返回样本的最小值、最大值、平均值、中位数和众数。最大值和最小值就很好处理，只需要遍历 count 判断最小的非 0 的 index 就是最小值，最大的非 0 的 index 就是最大值。平均值也非常好处理，对于所有非 0 的 count，我们通过累加 count[k] * index 得到所有数的和，然后除上所有非 0 的 count 的和。![](https://latex.codecogs.com/svg.latex?\sum_{n=0}^{256}count[n](while\%20\%20count[n]!=0))
 
 - 众数也非常容易，只需统计 count 值最大时的 index 即可。
 - 中位数的处理相对麻烦一些，因为需要分非 0 的 count 之和是奇数还是偶数两种情况。先假设非 0 的 count 和为 cnt，那么如果 cnt 是奇数的话，只需要找到 cnt/2 的位置即可，通过不断累加 count 的值，直到累加和超过 ≥ cnt/2。如果 cnt 是偶数的话，需要找到 cnt/2 + 1 和 cnt/2 的位置，找法和奇数情况相同，不过需要找两次(可以放到一个循环中做两次判断)。

Algorithms/1221. Split a String in Balanced Strings/1221. Split a String in Balanced Strings.go

@@ -0,0 +1,16 @@
+package leetcode
+
+func balancedStringSplit(s string) int {
+	count, res := 0, 0
+	for _, r := range s {
+		if r == 'R' {
+			count++
+		} else {
+			count--
+		}
+		if count == 0 {
+			res++
+		}
+	}
+	return res
+}

Algorithms/1221. Split a String in Balanced Strings/1221. Split a String in Balanced Strings_test.go

@@ -0,0 +1,52 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+type question1221 struct {
+	para1221
+	ans1221
+}
+
+// para 是参数
+// one 代表第一个参数
+type para1221 struct {
+	s string
+}
+
+// ans 是答案
+// one 代表第一个答案
+type ans1221 struct {
+	one int
+}
+
+func Test_Problem1221(t *testing.T) {
+
+	qs := []question1221{
+
+		question1221{
+			para1221{"RLRRLLRLRL"},
+			ans1221{4},
+		},
+
+		question1221{
+			para1221{"RLLLLRRRLR"},
+			ans1221{3},
+		},
+
+		question1221{
+			para1221{"LLLLRRRR"},
+			ans1221{1},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 1221------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans1221, q.para1221
+		fmt.Printf("【input】:%v       【output】:%v\n", p, balancedStringSplit(p.s))
+	}
+	fmt.Printf("\n\n\n")
+}

Algorithms/1221. Split a String in Balanced Strings/README.md

@@ -0,0 +1,72 @@
+# [1221. Split a String in Balanced Strings](https://leetcode.com/problems/split-a-string-in-balanced-strings/)
+
+
+## 题目:
+
+Balanced strings are those who have equal quantity of 'L' and 'R' characters.
+
+Given a balanced string `s` split it in the maximum amount of balanced strings.
+
+Return the maximum amount of splitted balanced strings.
+
+**Example 1**:
+
+    Input: s = "RLRRLLRLRL"
+    Output: 4
+    Explanation: s can be split into "RL", "RRLL", "RL", "RL", each substring contains same number of 'L' and 'R'.
+
+**Example 2**:
+
+    Input: s = "RLLLLRRRLR"
+    Output: 3
+    Explanation: s can be split into "RL", "LLLRRR", "LR", each substring contains same number of 'L' and 'R'.
+
+**Example 3**:
+
+    Input: s = "LLLLRRRR"
+    Output: 1
+    Explanation: s can be split into "LLLLRRRR".
+
+**Constraints**:
+
+- `1 <= s.length <= 1000`
+- `s[i] = 'L' or 'R'`
+
+## 题目大意
+
+
+在一个「平衡字符串」中，'L' 和 'R' 字符的数量是相同的。给出一个平衡字符串 s，请你将它分割成尽可能多的平衡字符串。返回可以通过分割得到的平衡字符串的最大数量。
+
+提示：
+
+- 1 <= s.length <= 1000
+- s[i] = 'L' 或 'R'
+
+
+## 解题思路
+
+- 给出一个字符串，要求把这个字符串切成一些子串，这些子串中 R 和 L 的字符数是相等的。问能切成多少个满足条件的子串。
+- 这道题是简单题，按照题意模拟即可。从左往右扫，遇到 `R` 就加一，遇到 `L` 就减一，当计数是 `0` 的时候就是平衡的时候，就切割。
+
+## 代码
+
+```go
+
+package leetcode
+
+func balancedStringSplit(s string) int {
+	count, res := 0, 0
+	for _, r := range s {
+		if r == 'R' {
+			count++
+		} else {
+			count--
+		}
+		if count == 0 {
+			res++
+		}
+	}
+	return res
+}
+
+```

Algorithms/1232. Check If It Is a Straight Line/1232. Check If It Is a Straight Line.go

@@ -0,0 +1,14 @@
+package leetcode
+
+func checkStraightLine(coordinates [][]int) bool {
+	dx0 := coordinates[1][0] - coordinates[0][0]
+	dy0 := coordinates[1][1] - coordinates[0][1]
+	for i := 1; i < len(coordinates)-1; i++ {
+		dx := coordinates[i+1][0] - coordinates[i][0]
+		dy := coordinates[i+1][1] - coordinates[i][1]
+		if dy*dx0 != dy0*dx { // check cross product
+			return false
+		}
+	}
+	return true
+}

Algorithms/1232. Check If It Is a Straight Line/1232. Check If It Is a Straight Line_test.go

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

Algorithms/1232. Check If It Is a Straight Line/README.md

@@ -0,0 +1,72 @@
+# [1232. Check If It Is a Straight Line](https://leetcode.com/problems/check-if-it-is-a-straight-line/)
+
+
+## 题目:
+
+You are given an array `coordinates`, `coordinates[i] = [x, y]`, where `[x, y]` represents the coordinate of a point. Check if these points make a straight line in the XY plane.
+
+**Example 1**:
+
+![](https://img.halfrost.com/Leetcode/leetcode_1232_1.png)
+
+    Input: coordinates = [[1,2],[2,3],[3,4],[4,5],[5,6],[6,7]]
+    Output: true
+
+**Example 2**:
+
+
+![](https://img.halfrost.com/Leetcode/leetcode_1232_2.png)
+
+    Input: coordinates = [[1,1],[2,2],[3,4],[4,5],[5,6],[7,7]]
+    Output: false
+
+**Constraints**:
+
+- `2 <= coordinates.length <= 1000`
+- `coordinates[i].length == 2`
+- `-10^4 <= coordinates[i][0], coordinates[i][1] <= 10^4`
+- `coordinates` contains no duplicate point.
+
+## 题目大意
+
+
+在一个 XY 坐标系中有一些点，我们用数组 coordinates 来分别记录它们的坐标，其中 coordinates[i] = [x, y] 表示横坐标为 x、纵坐标为 y 的点。
+
+请你来判断，这些点是否在该坐标系中属于同一条直线上，是则返回 true，否则请返回 false。
+
+提示：
+
+- 2 <= coordinates.length <= 1000
+- coordinates[i].length == 2
+- -10^4 <= coordinates[i][0], coordinates[i][1] <= 10^4
+- coordinates 中不含重复的点
+
+
+
+## 解题思路
+
+- 给出一组坐标点，要求判断这些点是否在同一直线上。
+- 按照几何原理，依次计算这些点的斜率是否相等即可。斜率需要做除法，这里采用一个技巧是换成乘法。例如 `a/b = c/d` 换成乘法是 `a*d  = c*d`  。
+
+
+## 代码
+
+```go
+
+package leetcode
+
+func checkStraightLine(coordinates [][]int) bool {
+	dx0 := coordinates[1][0] - coordinates[0][0]
+	dy0 := coordinates[1][1] - coordinates[0][1]
+	for i := 1; i < len(coordinates)-1; i++ {
+		dx := coordinates[i+1][0] - coordinates[i][0]
+		dy := coordinates[i+1][1] - coordinates[i][1]
+		if dy*dx0 != dy0*dx { // check cross product
+			return false
+		}
+	}
+	return true
+}
+
+
+```

Algorithms/1234. Replace the Substring for Balanced String/1234. Replace the Substring for Balanced String.go

@@ -0,0 +1,24 @@
+package leetcode
+
+func balancedString(s string) int {
+	count, k := make([]int, 128), len(s)/4
+	for _, v := range s {
+		count[int(v)]++
+	}
+	left, right, res := 0, -1, len(s)
+	for left < len(s) {
+		if count['Q'] > k || count['W'] > k || count['E'] > k || count['R'] > k {
+			if right+1 < len(s) {
+				right++
+				count[s[right]]--
+			} else {
+				break
+			}
+		} else {
+			res = min(res, right-left+1)
+			count[s[left]]++
+			left++
+		}
+	}
+	return res
+}

Algorithms/1234. Replace the Substring for Balanced String/1234. Replace the Substring for Balanced String_test.go

@@ -0,0 +1,62 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+type question1234 struct {
+	para1234
+	ans1234
+}
+
+// para 是参数
+// one 代表第一个参数
+type para1234 struct {
+	s string
+}
+
+// ans 是答案
+// one 代表第一个答案
+type ans1234 struct {
+	one int
+}
+
+func Test_Problem1234(t *testing.T) {
+
+	qs := []question1234{
+
+		question1234{
+			para1234{"QWER"},
+			ans1234{0},
+		},
+
+		question1234{
+			para1234{"QQWE"},
+			ans1234{1},
+		},
+
+		question1234{
+			para1234{"QQQW"},
+			ans1234{2},
+		},
+
+		question1234{
+			para1234{"QQQQ"},
+			ans1234{3},
+		},
+
+		question1234{
+			para1234{"WQWRQQQW"},
+			ans1234{3},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 1234------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans1234, q.para1234
+		fmt.Printf("【input】:%v       【output】:%v\n", p, balancedString(p.s))
+	}
+	fmt.Printf("\n\n\n")
+}