feat: cleaned AI wordings

Author: q1zhen

scripts/clean_text.py

@@ -0,0 +1,32 @@
+import os
+
+def clean_text(lines):
+	# `lines` is an iterator over the lines of a file (without "\n").
+	out = ""
+	for line in lines:
+		if line.startswith("---") \
+			or (line.startswith("#") and any([wd in line for wd in ["引言", "总结", "结语"]])): continue
+		if line.startswith("#") and any([(n + "、") in line for n in "一二三四五六七八九十"]):
+			mark, text = line.split(" ", 1)
+			text = text.split("、", 1)[1]
+			line_ = f"{mark} {text}"
+		else:
+			line_ = line
+		out += line_ + "\n"
+	return out
+
+if __name__ == "__main__":
+	src_dir = "./src/content/blog/"
+	for date in os.listdir(src_dir):
+		file = os.path.join(src_dir, date, "index.md")
+		with open(file, "r", encoding="utf-8") as f:
+			lines = iter(f.read().splitlines())
+		three_dashes_count = 0
+		metadata = ""
+		for line in lines:
+			if line.startswith("---"): three_dashes_count += 1
+			metadata += line + "\n"
+			if three_dashes_count == 2: break
+		cleaned = clean_text(lines)
+		with open(file, "w", encoding="utf-8") as f:
+			f.write(metadata + cleaned)

scripts/writer.py

@@ -7,6 +7,7 @@
 import os
 import glob
 import yaml
+import clean_text
 
 path_to = f'src/content/blog/{datetime.datetime.now().strftime("%Y-%m-%d")}'
 
@@ -129,7 +130,7 @@ def beautify_string(text):
 summary_result = beautify_string(summary(article))
 print(f"      Decided Summary: {summary_result}; time spent {time.time() - start:.1f} s")
 
-lines = iter(article.split("\n"))
+lines = iter(article.splitlines())
 markdown_file = ""
 author = random.choice(["杨其臻", "杨子凡", "叶家炜", "黄京"])
 print(f"        Rolled author: {author}")
@@ -152,10 +153,7 @@ def beautify_string(text):
         markdown_file += metadata
         break
 
-for line in lines:
-    if line.startswith("---") \
-        or (line.startswith("#") and any([wd in line for wd in ["引言", "总结", "结语"]])): continue
-    markdown_file += line + "\n"
+markdown_file += clean_text.clean_text(lines)
 
 with open(f"{path_to}/index.md", "w", encoding="utf-8") as f:
     f.write(markdown_file)

src/content/blog/2024-11-28/index.md

@@ -1,82 +1,82 @@
----
-title: "前缀和引入"
-author: "杨子凡"
-date: "Nov 28, 2024"
-description: "前缀和系列第一篇"
-latex: true
-pdf: true
----
-
-## 引入
-
-> 荀子曰：不积跬步，无以至千里；不积小流，无以成江海。
-
-这句话揭示了世间万物整体和部分之间的关系——庞大的整体由若干个体组成；单个个体虽小，但经过一点一滴的累积，也能聚成一个庞大的整体。学习工作贵在不断积累，不断充实、丰富、完善自己，所有的努力都会有回报。
-
-在算法竞赛中，利用整体和部分的性质可以达成很多目的，例如利用前缀和可以在常数时间复杂度中查询区间和，利用差分在常数时间复杂度对序列进行区间操作，或者利用离散化去除无用数据区间，通过放缩保留有用的数据。这些操作使得我们不必每次都要重复处理个体的数据，而是直接对整体进行处理，从而降低时间复杂度，提升运算效率。
-
-本篇将介绍前缀和的基础算法与实现，帮助读者掌握这一重要的工具。
-
-## 前缀和的定义
-
-前缀和是一种简单而高效的算法思想。对于一个数组 `a`，它的前缀和数组 `prefix` 定义如下：
-
-$$
-\mathrm{prefix}_n = \sum _{i=1} ^{n} a_i
-$$
-
-通过前缀和，我们可以在 $\mathcal{O}(1)$ 的时间复杂度内快速计算任意区间 $[l, r]$ 的和，公式如下：
-
-$$
-\mathrm{sum}_{l,r} = \mathrm{prefix}_r - \mathrm{prefix}_{l-1}
-$$
-
-其中，当 $l = 1$ 时，$\mathrm{sum}_{l,r} = \mathrm{prefix}_r$。
-
-## 算法实现
-
-接下来我们讲上面的思想运用到一道具体的题目中来看一下前缀和的具体使用方法。
-
-~~由于笔者是洛谷忠实粉丝，这次包括之后的所有练习题可能大概率来自洛谷，建议各位今早注册账号跟着笔者一起练习。~~
-
-我们选用洛谷的 [B3612](https://www.luogu.com.cn/problem/B3612)，由于其实现思路与定义中所讲内容完全雷同，这里直接上代码：
-
-
-```cpp
-#include <bits/stdc++.h>
-
-using namespace std;
-
-int n, m, a[100050], s[100050];
-
-inline int read() {
-	int f = 1, x = 0; char ch = getchar();
-	while (ch < '0' or ch > '9') { if (ch == '-') f = -1; ch = getchar(); }
-	while (ch >= '0' and ch <= '9') { x = (x << 3) + (x << 1) + (ch ^ 48); ch = getchar(); }
-	return f*x;
-}
-
-int main() {
-	n = read();
-	for (int i = 1; i <= n; i ++)
-		s[i] = s[i - 1] + (a[i] = read());	//构造前缀和数组
-	m = read();
-	for (int i = 1; i <= m; i ++) {
-		int l = read(), r = read();
-		cout << s[r] - s[l - 1] << endl;	//根据上文公式得出
-	}
-	return 0;
-}
-```
-
-目前，如果你能完全理解以上代码，你已经掌握了前缀和的最基础运用。下一章将会介绍前缀和在差分中的运用。
-
-编者按：如果你喜欢比较更偏 C++ 的实现方法，你还可以这样实现前缀和：
-
-```cpp
-vector<int> values(n);			// 假设其中已有数据
-vector<int> prefixSums(1);
-for (auto i : values) prefixSums.push_back(prefixSums.back() + i);
-```
-
-其中 `vector<int> prefixSums(1)` 定义了一个长度为 1 且值为 0 的向量，随后的 `for` 循环中则每次把 `values` 中的一项与这个前缀和向量的最后一项相加，然后添加到后者中。
+---
+title: "前缀和引入"
+author: "杨子凡"
+date: "Nov 28, 2024"
+description: "前缀和系列第一篇"
+latex: true
+pdf: true
+---
+
+## 引入
+
+> 荀子曰：不积跬步，无以至千里；不积小流，无以成江海。
+
+这句话揭示了世间万物整体和部分之间的关系——庞大的整体由若干个体组成；单个个体虽小，但经过一点一滴的累积，也能聚成一个庞大的整体。学习工作贵在不断积累，不断充实、丰富、完善自己，所有的努力都会有回报。
+
+在算法竞赛中，利用整体和部分的性质可以达成很多目的，例如利用前缀和可以在常数时间复杂度中查询区间和，利用差分在常数时间复杂度对序列进行区间操作，或者利用离散化去除无用数据区间，通过放缩保留有用的数据。这些操作使得我们不必每次都要重复处理个体的数据，而是直接对整体进行处理，从而降低时间复杂度，提升运算效率。
+
+本篇将介绍前缀和的基础算法与实现，帮助读者掌握这一重要的工具。
+
+## 前缀和的定义
+
+前缀和是一种简单而高效的算法思想。对于一个数组 `a`，它的前缀和数组 `prefix` 定义如下：
+
+$$
+\mathrm{prefix}_n = \sum _{i=1} ^{n} a_i
+$$
+
+通过前缀和，我们可以在 $\mathcal{O}(1)$ 的时间复杂度内快速计算任意区间 $[l, r]$ 的和，公式如下：
+
+$$
+\mathrm{sum}_{l,r} = \mathrm{prefix}_r - \mathrm{prefix}_{l-1}
+$$
+
+其中，当 $l = 1$ 时，$\mathrm{sum}_{l,r} = \mathrm{prefix}_r$。
+
+## 算法实现
+
+接下来我们讲上面的思想运用到一道具体的题目中来看一下前缀和的具体使用方法。
+
+~~由于笔者是洛谷忠实粉丝，这次包括之后的所有练习题可能大概率来自洛谷，建议各位今早注册账号跟着笔者一起练习。~~
+
+我们选用洛谷的 [B3612](https://www.luogu.com.cn/problem/B3612)，由于其实现思路与定义中所讲内容完全雷同，这里直接上代码：
+
+
+```cpp
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int n, m, a[100050], s[100050];
+
+inline int read() {
+	int f = 1, x = 0; char ch = getchar();
+	while (ch < '0' or ch > '9') { if (ch == '-') f = -1; ch = getchar(); }
+	while (ch >= '0' and ch <= '9') { x = (x << 3) + (x << 1) + (ch ^ 48); ch = getchar(); }
+	return f*x;
+}
+
+int main() {
+	n = read();
+	for (int i = 1; i <= n; i ++)
+		s[i] = s[i - 1] + (a[i] = read());	//构造前缀和数组
+	m = read();
+	for (int i = 1; i <= m; i ++) {
+		int l = read(), r = read();
+		cout << s[r] - s[l - 1] << endl;	//根据上文公式得出
+	}
+	return 0;
+}
+```
+
+目前，如果你能完全理解以上代码，你已经掌握了前缀和的最基础运用。下一章将会介绍前缀和在差分中的运用。
+
+编者按：如果你喜欢比较更偏 C++ 的实现方法，你还可以这样实现前缀和：
+
+```cpp
+vector<int> values(n);			// 假设其中已有数据
+vector<int> prefixSums(1);
+for (auto i : values) prefixSums.push_back(prefixSums.back() + i);
+```
+
+其中 `vector<int> prefixSums(1)` 定义了一个长度为 1 且值为 0 的向量，随后的 `for` 循环中则每次把 `values` 中的一项与这个前缀和向量的最后一项相加，然后添加到后者中。

src/content/blog/2024-12-09/index.md

@@ -1,75 +1,75 @@
----
-title: "前缀和与差分"
-author: "杨子凡"
-date: "Dec 9, 2024"
-description: "前缀和系列第二篇"
-latex: true
-pdf: true
----
-
-## 引入
-
-> 画龙点睛，事半功倍。
-
-差分算法的思想就是通过巧妙的修改差值而不是直接修改原数组，从而优化时间复杂度。利用差分，我们可以在常数时间复杂度内对一个区间进行修改，而不需要遍历整个区间。结合前缀和进行求和，我们可以在 $\mathcal{O}(1)$ 的时间内完成区间修改操作。算法中的这些优化技巧在实际问题中非常高效，尤其是在面对大数据量时。
-
-本篇将介绍如何运用差分优化区间修改操作，并利用前缀和求解区间和。
-
-## 差分的思想
-
-差分是前缀和的逆过程，用于高效处理区间修改。给定一个数组 $a$，我们可以通过构造一个差分数组 $d$ 来记录数组相邻元素的差值。
-
-假设 $d_i$ 记录的是数组 $a_i$ 与 $a_{i-1}$ 之间的差异，即：
-
-$$d_i=a_i-a_{i-1}$$
-
-利用差分数组，我们可以在常数时间内对区间进行修改。
-
-## 区间修改
-
-给定一个区间 $[l, r]$，我们需要将区间内的每个元素都加上一个常数 $x$。直接修改原数组会导致 $\mathcal{O}(r-l+1)$ 的时间复杂度，而使用差分数组，我们可以通过如下操作：
-
-1. 对差分数组 $d_l$ 加上 $x$（表示区间开始处增加 $x$）。
-2. 对差分数组 $d_{r+1}$ 减去 $x$（表示区间结束后增加的部分被取消）。
-
-这样，区间修改的时间复杂度就变为 $\mathcal{O}(1)$。
-
-## 算法实现
-
-还是来看一道例题，是洛谷的[P2367](https://www.luogu.com.cn/problem/P2367)
-
-```cpp
-#include <bits/stdc++.h>
-#define F(_b, _e) for (int i = _b; i <= _e; i ++)
-using namespace std;
-
-const int MAXN = 5e6 + 5;
-int a[MAXN];
-int main() {
-	int n, p; n = read(); p = read();
-	int tmp = 0;
-	F (1, n) {
-		int k = read();
-		a[i] = k - tmp;
-		tmp = k;
-	}
-	F (1, p) {
-		int l, r, d;
-		l = read(); r = read(); d = read();
-		a[l] += d;
-		a[r + 1] -= d;
-	}
-	tmp = 0;
-	int ans = 5e5;
-	F (1, n) {
-		tmp += a[i];
-		ans = min(ans, tmp);
-	}
-	write(ans);
-	return 0;
-}
-```
-
-目前你已经掌握了前缀和的基本方法以及通过差分加前缀和的方法优化区间修改的时间复杂度。
-
-但是，这样对于区间修改的时间复杂度的优化会导致查询的时间复杂度急剧上升，没差一个都要从第一项求前缀和到该项，那么，有没有什么方法可以使得修改和查询时间复杂度都降低呢？这将会是我们前缀和这一期第三篇的内容，下一篇将会有很大难度，各位做好心理准备。
+---
+title: "前缀和与差分"
+author: "杨子凡"
+date: "Dec 9, 2024"
+description: "前缀和系列第二篇"
+latex: true
+pdf: true
+---
+
+## 引入
+
+> 画龙点睛，事半功倍。
+
+差分算法的思想就是通过巧妙的修改差值而不是直接修改原数组，从而优化时间复杂度。利用差分，我们可以在常数时间复杂度内对一个区间进行修改，而不需要遍历整个区间。结合前缀和进行求和，我们可以在 $\mathcal{O}(1)$ 的时间内完成区间修改操作。算法中的这些优化技巧在实际问题中非常高效，尤其是在面对大数据量时。
+
+本篇将介绍如何运用差分优化区间修改操作，并利用前缀和求解区间和。
+
+## 差分的思想
+
+差分是前缀和的逆过程，用于高效处理区间修改。给定一个数组 $a$，我们可以通过构造一个差分数组 $d$ 来记录数组相邻元素的差值。
+
+假设 $d_i$ 记录的是数组 $a_i$ 与 $a_{i-1}$ 之间的差异，即：
+
+$$d_i=a_i-a_{i-1}$$
+
+利用差分数组，我们可以在常数时间内对区间进行修改。
+
+## 区间修改
+
+给定一个区间 $[l, r]$，我们需要将区间内的每个元素都加上一个常数 $x$。直接修改原数组会导致 $\mathcal{O}(r-l+1)$ 的时间复杂度，而使用差分数组，我们可以通过如下操作：
+
+1. 对差分数组 $d_l$ 加上 $x$（表示区间开始处增加 $x$）。
+2. 对差分数组 $d_{r+1}$ 减去 $x$（表示区间结束后增加的部分被取消）。
+
+这样，区间修改的时间复杂度就变为 $\mathcal{O}(1)$。
+
+## 算法实现
+
+还是来看一道例题，是洛谷的[P2367](https://www.luogu.com.cn/problem/P2367)
+
+```cpp
+#include <bits/stdc++.h>
+#define F(_b, _e) for (int i = _b; i <= _e; i ++)
+using namespace std;
+
+const int MAXN = 5e6 + 5;
+int a[MAXN];
+int main() {
+	int n, p; n = read(); p = read();
+	int tmp = 0;
+	F (1, n) {
+		int k = read();
+		a[i] = k - tmp;
+		tmp = k;
+	}
+	F (1, p) {
+		int l, r, d;
+		l = read(); r = read(); d = read();
+		a[l] += d;
+		a[r + 1] -= d;
+	}
+	tmp = 0;
+	int ans = 5e5;
+	F (1, n) {
+		tmp += a[i];
+		ans = min(ans, tmp);
+	}
+	write(ans);
+	return 0;
+}
+```
+
+目前你已经掌握了前缀和的基本方法以及通过差分加前缀和的方法优化区间修改的时间复杂度。
+
+但是，这样对于区间修改的时间复杂度的优化会导致查询的时间复杂度急剧上升，没差一个都要从第一项求前缀和到该项，那么，有没有什么方法可以使得修改和查询时间复杂度都降低呢？这将会是我们前缀和这一期第三篇的内容，下一篇将会有很大难度，各位做好心理准备。