diff --git a/cmd/main.go b/cmd/main.go
index 4fbb86a96..7d5835f66 100644
--- a/cmd/main.go
+++ b/cmd/main.go
@@ -35,6 +35,7 @@ func main() {
 	//leetcode.MakeDirFromTo(problems, 2901, 3000)
 	//leetcode.MakeDirFromTo(problems, 3101, 3200)
 	//leetcode.MakeDirFromTo(problems, 3201, 3300)
+	leetcode.MakeDirFromTo(problems, 3301, 3400)
 
 	// leetcode.MakeDir(problems)
 
diff --git a/leetcode/3301-3400/3301.Maximize-the-Total-Height-of-Unique-Towers/README.md b/leetcode/3301-3400/3301.Maximize-the-Total-Height-of-Unique-Towers/README.md
new file mode 100755
index 000000000..08d28339b
--- /dev/null
+++ b/leetcode/3301-3400/3301.Maximize-the-Total-Height-of-Unique-Towers/README.md
@@ -0,0 +1,32 @@
+# [3301.Maximize the Total Height of Unique Towers][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Maximize the Total Height of Unique Towers
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/maximize-the-total-height-of-unique-towers/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3301.Maximize-the-Total-Height-of-Unique-Towers/Solution.go b/leetcode/3301-3400/3301.Maximize-the-Total-Height-of-Unique-Towers/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3301.Maximize-the-Total-Height-of-Unique-Towers/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3301.Maximize-the-Total-Height-of-Unique-Towers/Solution_test.go b/leetcode/3301-3400/3301.Maximize-the-Total-Height-of-Unique-Towers/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3301.Maximize-the-Total-Height-of-Unique-Towers/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3302.Find-the-Lexicographically-Smallest-Valid-Sequence/README.md b/leetcode/3301-3400/3302.Find-the-Lexicographically-Smallest-Valid-Sequence/README.md
new file mode 100755
index 000000000..f6e0cc32e
--- /dev/null
+++ b/leetcode/3301-3400/3302.Find-the-Lexicographically-Smallest-Valid-Sequence/README.md
@@ -0,0 +1,32 @@
+# [3302.Find the Lexicographically Smallest Valid Sequence][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Find the Lexicographically Smallest Valid Sequence
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/find-the-lexicographically-smallest-valid-sequence/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3302.Find-the-Lexicographically-Smallest-Valid-Sequence/Solution.go b/leetcode/3301-3400/3302.Find-the-Lexicographically-Smallest-Valid-Sequence/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3302.Find-the-Lexicographically-Smallest-Valid-Sequence/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3302.Find-the-Lexicographically-Smallest-Valid-Sequence/Solution_test.go b/leetcode/3301-3400/3302.Find-the-Lexicographically-Smallest-Valid-Sequence/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3302.Find-the-Lexicographically-Smallest-Valid-Sequence/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3303.Find-the-Occurrence-of-First-Almost-Equal-Substring/README.md b/leetcode/3301-3400/3303.Find-the-Occurrence-of-First-Almost-Equal-Substring/README.md
new file mode 100755
index 000000000..b2835a0a2
--- /dev/null
+++ b/leetcode/3301-3400/3303.Find-the-Occurrence-of-First-Almost-Equal-Substring/README.md
@@ -0,0 +1,32 @@
+# [3303.Find the Occurrence of First Almost Equal Substring][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Find the Occurrence of First Almost Equal Substring
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/find-the-occurrence-of-first-almost-equal-substring/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3303.Find-the-Occurrence-of-First-Almost-Equal-Substring/Solution.go b/leetcode/3301-3400/3303.Find-the-Occurrence-of-First-Almost-Equal-Substring/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3303.Find-the-Occurrence-of-First-Almost-Equal-Substring/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3303.Find-the-Occurrence-of-First-Almost-Equal-Substring/Solution_test.go b/leetcode/3301-3400/3303.Find-the-Occurrence-of-First-Almost-Equal-Substring/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3303.Find-the-Occurrence-of-First-Almost-Equal-Substring/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3304.Find-the-K-th-Character-in-String-Game-I/README.md b/leetcode/3301-3400/3304.Find-the-K-th-Character-in-String-Game-I/README.md
new file mode 100755
index 000000000..be2a86e6e
--- /dev/null
+++ b/leetcode/3301-3400/3304.Find-the-K-th-Character-in-String-Game-I/README.md
@@ -0,0 +1,32 @@
+# [3304.Find the K-th Character in String Game I][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Find the K-th Character in String Game I
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/find-the-k-th-character-in-string-game-i/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3304.Find-the-K-th-Character-in-String-Game-I/Solution.go b/leetcode/3301-3400/3304.Find-the-K-th-Character-in-String-Game-I/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3304.Find-the-K-th-Character-in-String-Game-I/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3304.Find-the-K-th-Character-in-String-Game-I/Solution_test.go b/leetcode/3301-3400/3304.Find-the-K-th-Character-in-String-Game-I/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3304.Find-the-K-th-Character-in-String-Game-I/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3305.Count-of-Substrings-Containing-Every-Vowel-and-K-Consonants-I/README.md b/leetcode/3301-3400/3305.Count-of-Substrings-Containing-Every-Vowel-and-K-Consonants-I/README.md
new file mode 100755
index 000000000..fb822fa47
--- /dev/null
+++ b/leetcode/3301-3400/3305.Count-of-Substrings-Containing-Every-Vowel-and-K-Consonants-I/README.md
@@ -0,0 +1,32 @@
+# [3305.Count of Substrings Containing Every Vowel and K Consonants I][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Count of Substrings Containing Every Vowel and K Consonants I
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/count-of-substrings-containing-every-vowel-and-k-consonants-i/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3305.Count-of-Substrings-Containing-Every-Vowel-and-K-Consonants-I/Solution.go b/leetcode/3301-3400/3305.Count-of-Substrings-Containing-Every-Vowel-and-K-Consonants-I/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3305.Count-of-Substrings-Containing-Every-Vowel-and-K-Consonants-I/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3305.Count-of-Substrings-Containing-Every-Vowel-and-K-Consonants-I/Solution_test.go b/leetcode/3301-3400/3305.Count-of-Substrings-Containing-Every-Vowel-and-K-Consonants-I/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3305.Count-of-Substrings-Containing-Every-Vowel-and-K-Consonants-I/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3306.Count-of-Substrings-Containing-Every-Vowel-and-K-Consonants-II/README.md b/leetcode/3301-3400/3306.Count-of-Substrings-Containing-Every-Vowel-and-K-Consonants-II/README.md
new file mode 100755
index 000000000..c7cf130b0
--- /dev/null
+++ b/leetcode/3301-3400/3306.Count-of-Substrings-Containing-Every-Vowel-and-K-Consonants-II/README.md
@@ -0,0 +1,32 @@
+# [3306.Count of Substrings Containing Every Vowel and K Consonants II][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Count of Substrings Containing Every Vowel and K Consonants II
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/count-of-substrings-containing-every-vowel-and-k-consonants-ii/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3306.Count-of-Substrings-Containing-Every-Vowel-and-K-Consonants-II/Solution.go b/leetcode/3301-3400/3306.Count-of-Substrings-Containing-Every-Vowel-and-K-Consonants-II/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3306.Count-of-Substrings-Containing-Every-Vowel-and-K-Consonants-II/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3306.Count-of-Substrings-Containing-Every-Vowel-and-K-Consonants-II/Solution_test.go b/leetcode/3301-3400/3306.Count-of-Substrings-Containing-Every-Vowel-and-K-Consonants-II/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3306.Count-of-Substrings-Containing-Every-Vowel-and-K-Consonants-II/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3307.Find-the-K-th-Character-in-String-Game-II/README.md b/leetcode/3301-3400/3307.Find-the-K-th-Character-in-String-Game-II/README.md
new file mode 100755
index 000000000..338708360
--- /dev/null
+++ b/leetcode/3301-3400/3307.Find-the-K-th-Character-in-String-Game-II/README.md
@@ -0,0 +1,32 @@
+# [3307.Find the K-th Character in String Game II][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Find the K-th Character in String Game II
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/find-the-k-th-character-in-string-game-ii/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3307.Find-the-K-th-Character-in-String-Game-II/Solution.go b/leetcode/3301-3400/3307.Find-the-K-th-Character-in-String-Game-II/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3307.Find-the-K-th-Character-in-String-Game-II/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3307.Find-the-K-th-Character-in-String-Game-II/Solution_test.go b/leetcode/3301-3400/3307.Find-the-K-th-Character-in-String-Game-II/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3307.Find-the-K-th-Character-in-String-Game-II/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3309.Maximum-Possible-Number-by-Binary-Concatenation/README.md b/leetcode/3301-3400/3309.Maximum-Possible-Number-by-Binary-Concatenation/README.md
new file mode 100755
index 000000000..6ebc10daa
--- /dev/null
+++ b/leetcode/3301-3400/3309.Maximum-Possible-Number-by-Binary-Concatenation/README.md
@@ -0,0 +1,32 @@
+# [3309.Maximum Possible Number by Binary Concatenation][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Maximum Possible Number by Binary Concatenation
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/maximum-possible-number-by-binary-concatenation/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3309.Maximum-Possible-Number-by-Binary-Concatenation/Solution.go b/leetcode/3301-3400/3309.Maximum-Possible-Number-by-Binary-Concatenation/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3309.Maximum-Possible-Number-by-Binary-Concatenation/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3309.Maximum-Possible-Number-by-Binary-Concatenation/Solution_test.go b/leetcode/3301-3400/3309.Maximum-Possible-Number-by-Binary-Concatenation/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3309.Maximum-Possible-Number-by-Binary-Concatenation/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3310.Remove-Methods-From-Project/README.md b/leetcode/3301-3400/3310.Remove-Methods-From-Project/README.md
new file mode 100755
index 000000000..4ae8edce8
--- /dev/null
+++ b/leetcode/3301-3400/3310.Remove-Methods-From-Project/README.md
@@ -0,0 +1,32 @@
+# [3310.Remove Methods From Project][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Remove Methods From Project
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/remove-methods-from-project/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3310.Remove-Methods-From-Project/Solution.go b/leetcode/3301-3400/3310.Remove-Methods-From-Project/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3310.Remove-Methods-From-Project/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3310.Remove-Methods-From-Project/Solution_test.go b/leetcode/3301-3400/3310.Remove-Methods-From-Project/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3310.Remove-Methods-From-Project/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3311.Construct-2D-Grid-Matching-Graph-Layout/README.md b/leetcode/3301-3400/3311.Construct-2D-Grid-Matching-Graph-Layout/README.md
new file mode 100755
index 000000000..4030a6d0f
--- /dev/null
+++ b/leetcode/3301-3400/3311.Construct-2D-Grid-Matching-Graph-Layout/README.md
@@ -0,0 +1,32 @@
+# [3311.Construct 2D Grid Matching Graph Layout][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Construct 2D Grid Matching Graph Layout
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/construct-2d-grid-matching-graph-layout/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3311.Construct-2D-Grid-Matching-Graph-Layout/Solution.go b/leetcode/3301-3400/3311.Construct-2D-Grid-Matching-Graph-Layout/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3311.Construct-2D-Grid-Matching-Graph-Layout/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3311.Construct-2D-Grid-Matching-Graph-Layout/Solution_test.go b/leetcode/3301-3400/3311.Construct-2D-Grid-Matching-Graph-Layout/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3311.Construct-2D-Grid-Matching-Graph-Layout/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3312.Sorted-GCD-Pair-Queries/README.md b/leetcode/3301-3400/3312.Sorted-GCD-Pair-Queries/README.md
new file mode 100755
index 000000000..3770b97e7
--- /dev/null
+++ b/leetcode/3301-3400/3312.Sorted-GCD-Pair-Queries/README.md
@@ -0,0 +1,32 @@
+# [3312.Sorted GCD Pair Queries][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Sorted GCD Pair Queries
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/sorted-gcd-pair-queries/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3312.Sorted-GCD-Pair-Queries/Solution.go b/leetcode/3301-3400/3312.Sorted-GCD-Pair-Queries/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3312.Sorted-GCD-Pair-Queries/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3312.Sorted-GCD-Pair-Queries/Solution_test.go b/leetcode/3301-3400/3312.Sorted-GCD-Pair-Queries/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3312.Sorted-GCD-Pair-Queries/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3314.Construct-the-Minimum-Bitwise-Array-I/README.md b/leetcode/3301-3400/3314.Construct-the-Minimum-Bitwise-Array-I/README.md
new file mode 100755
index 000000000..44f685f66
--- /dev/null
+++ b/leetcode/3301-3400/3314.Construct-the-Minimum-Bitwise-Array-I/README.md
@@ -0,0 +1,32 @@
+# [3314.Construct the Minimum Bitwise Array I][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Construct the Minimum Bitwise Array I
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/construct-the-minimum-bitwise-array-i/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3314.Construct-the-Minimum-Bitwise-Array-I/Solution.go b/leetcode/3301-3400/3314.Construct-the-Minimum-Bitwise-Array-I/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3314.Construct-the-Minimum-Bitwise-Array-I/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3314.Construct-the-Minimum-Bitwise-Array-I/Solution_test.go b/leetcode/3301-3400/3314.Construct-the-Minimum-Bitwise-Array-I/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3314.Construct-the-Minimum-Bitwise-Array-I/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3315.Construct-the-Minimum-Bitwise-Array-II/README.md b/leetcode/3301-3400/3315.Construct-the-Minimum-Bitwise-Array-II/README.md
new file mode 100755
index 000000000..3f9ee8f17
--- /dev/null
+++ b/leetcode/3301-3400/3315.Construct-the-Minimum-Bitwise-Array-II/README.md
@@ -0,0 +1,32 @@
+# [3315.Construct the Minimum Bitwise Array II][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Construct the Minimum Bitwise Array II
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/construct-the-minimum-bitwise-array-ii/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3315.Construct-the-Minimum-Bitwise-Array-II/Solution.go b/leetcode/3301-3400/3315.Construct-the-Minimum-Bitwise-Array-II/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3315.Construct-the-Minimum-Bitwise-Array-II/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3315.Construct-the-Minimum-Bitwise-Array-II/Solution_test.go b/leetcode/3301-3400/3315.Construct-the-Minimum-Bitwise-Array-II/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3315.Construct-the-Minimum-Bitwise-Array-II/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3316.Find-Maximum-Removals-From-Source-String/README.md b/leetcode/3301-3400/3316.Find-Maximum-Removals-From-Source-String/README.md
new file mode 100755
index 000000000..a948aad71
--- /dev/null
+++ b/leetcode/3301-3400/3316.Find-Maximum-Removals-From-Source-String/README.md
@@ -0,0 +1,32 @@
+# [3316.Find Maximum Removals From Source String][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Find Maximum Removals From Source String
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/find-maximum-removals-from-source-string/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3316.Find-Maximum-Removals-From-Source-String/Solution.go b/leetcode/3301-3400/3316.Find-Maximum-Removals-From-Source-String/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3316.Find-Maximum-Removals-From-Source-String/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3316.Find-Maximum-Removals-From-Source-String/Solution_test.go b/leetcode/3301-3400/3316.Find-Maximum-Removals-From-Source-String/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3316.Find-Maximum-Removals-From-Source-String/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3317.Find-the-Number-of-Possible-Ways-for-an-Event/README.md b/leetcode/3301-3400/3317.Find-the-Number-of-Possible-Ways-for-an-Event/README.md
new file mode 100755
index 000000000..4f07766e0
--- /dev/null
+++ b/leetcode/3301-3400/3317.Find-the-Number-of-Possible-Ways-for-an-Event/README.md
@@ -0,0 +1,32 @@
+# [3317.Find the Number of Possible Ways for an Event][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Find the Number of Possible Ways for an Event
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/find-the-number-of-possible-ways-for-an-event/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3317.Find-the-Number-of-Possible-Ways-for-an-Event/Solution.go b/leetcode/3301-3400/3317.Find-the-Number-of-Possible-Ways-for-an-Event/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3317.Find-the-Number-of-Possible-Ways-for-an-Event/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3317.Find-the-Number-of-Possible-Ways-for-an-Event/Solution_test.go b/leetcode/3301-3400/3317.Find-the-Number-of-Possible-Ways-for-an-Event/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3317.Find-the-Number-of-Possible-Ways-for-an-Event/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3318.Find-X-Sum-of-All-K-Long-Subarrays-I/README.md b/leetcode/3301-3400/3318.Find-X-Sum-of-All-K-Long-Subarrays-I/README.md
new file mode 100755
index 000000000..4e5204fb8
--- /dev/null
+++ b/leetcode/3301-3400/3318.Find-X-Sum-of-All-K-Long-Subarrays-I/README.md
@@ -0,0 +1,32 @@
+# [3318.Find X-Sum of All K-Long Subarrays I][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Find X-Sum of All K-Long Subarrays I
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/find-x-sum-of-all-k-long-subarrays-i/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3318.Find-X-Sum-of-All-K-Long-Subarrays-I/Solution.go b/leetcode/3301-3400/3318.Find-X-Sum-of-All-K-Long-Subarrays-I/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3318.Find-X-Sum-of-All-K-Long-Subarrays-I/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3318.Find-X-Sum-of-All-K-Long-Subarrays-I/Solution_test.go b/leetcode/3301-3400/3318.Find-X-Sum-of-All-K-Long-Subarrays-I/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3318.Find-X-Sum-of-All-K-Long-Subarrays-I/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3319.K-th-Largest-Perfect-Subtree-Size-in-Binary-Tree/README.md b/leetcode/3301-3400/3319.K-th-Largest-Perfect-Subtree-Size-in-Binary-Tree/README.md
new file mode 100755
index 000000000..9bbdbc933
--- /dev/null
+++ b/leetcode/3301-3400/3319.K-th-Largest-Perfect-Subtree-Size-in-Binary-Tree/README.md
@@ -0,0 +1,32 @@
+# [3319.K-th Largest Perfect Subtree Size in Binary Tree][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+K-th Largest Perfect Subtree Size in Binary Tree
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/k-th-largest-perfect-subtree-size-in-binary-tree/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3319.K-th-Largest-Perfect-Subtree-Size-in-Binary-Tree/Solution.go b/leetcode/3301-3400/3319.K-th-Largest-Perfect-Subtree-Size-in-Binary-Tree/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3319.K-th-Largest-Perfect-Subtree-Size-in-Binary-Tree/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3319.K-th-Largest-Perfect-Subtree-Size-in-Binary-Tree/Solution_test.go b/leetcode/3301-3400/3319.K-th-Largest-Perfect-Subtree-Size-in-Binary-Tree/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3319.K-th-Largest-Perfect-Subtree-Size-in-Binary-Tree/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3320.Count-The-Number-of-Winning-Sequences/README.md b/leetcode/3301-3400/3320.Count-The-Number-of-Winning-Sequences/README.md
new file mode 100755
index 000000000..11daa4b29
--- /dev/null
+++ b/leetcode/3301-3400/3320.Count-The-Number-of-Winning-Sequences/README.md
@@ -0,0 +1,32 @@
+# [3320.Count The Number of Winning Sequences][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Count The Number of Winning Sequences
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/count-the-number-of-winning-sequences/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3320.Count-The-Number-of-Winning-Sequences/Solution.go b/leetcode/3301-3400/3320.Count-The-Number-of-Winning-Sequences/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3320.Count-The-Number-of-Winning-Sequences/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3320.Count-The-Number-of-Winning-Sequences/Solution_test.go b/leetcode/3301-3400/3320.Count-The-Number-of-Winning-Sequences/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3320.Count-The-Number-of-Winning-Sequences/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3321.Find-X-Sum-of-All-K-Long-Subarrays-II/README.md b/leetcode/3301-3400/3321.Find-X-Sum-of-All-K-Long-Subarrays-II/README.md
new file mode 100755
index 000000000..a0d20fb01
--- /dev/null
+++ b/leetcode/3301-3400/3321.Find-X-Sum-of-All-K-Long-Subarrays-II/README.md
@@ -0,0 +1,32 @@
+# [3321.Find X-Sum of All K-Long Subarrays II][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Find X-Sum of All K-Long Subarrays II
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/find-x-sum-of-all-k-long-subarrays-ii/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3321.Find-X-Sum-of-All-K-Long-Subarrays-II/Solution.go b/leetcode/3301-3400/3321.Find-X-Sum-of-All-K-Long-Subarrays-II/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3321.Find-X-Sum-of-All-K-Long-Subarrays-II/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3321.Find-X-Sum-of-All-K-Long-Subarrays-II/Solution_test.go b/leetcode/3301-3400/3321.Find-X-Sum-of-All-K-Long-Subarrays-II/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3321.Find-X-Sum-of-All-K-Long-Subarrays-II/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3324.Find-the-Sequence-of-Strings-Appeared-on-the-Screen/README.md b/leetcode/3301-3400/3324.Find-the-Sequence-of-Strings-Appeared-on-the-Screen/README.md
new file mode 100755
index 000000000..1bd165161
--- /dev/null
+++ b/leetcode/3301-3400/3324.Find-the-Sequence-of-Strings-Appeared-on-the-Screen/README.md
@@ -0,0 +1,32 @@
+# [3324.Find the Sequence of Strings Appeared on the Screen][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Find the Sequence of Strings Appeared on the Screen
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/find-the-sequence-of-strings-appeared-on-the-screen/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3324.Find-the-Sequence-of-Strings-Appeared-on-the-Screen/Solution.go b/leetcode/3301-3400/3324.Find-the-Sequence-of-Strings-Appeared-on-the-Screen/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3324.Find-the-Sequence-of-Strings-Appeared-on-the-Screen/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3324.Find-the-Sequence-of-Strings-Appeared-on-the-Screen/Solution_test.go b/leetcode/3301-3400/3324.Find-the-Sequence-of-Strings-Appeared-on-the-Screen/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3324.Find-the-Sequence-of-Strings-Appeared-on-the-Screen/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3325.Count-Substrings-With-K-Frequency-Characters-I/README.md b/leetcode/3301-3400/3325.Count-Substrings-With-K-Frequency-Characters-I/README.md
new file mode 100755
index 000000000..0493cb391
--- /dev/null
+++ b/leetcode/3301-3400/3325.Count-Substrings-With-K-Frequency-Characters-I/README.md
@@ -0,0 +1,32 @@
+# [3325.Count Substrings With K-Frequency Characters I][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Count Substrings With K-Frequency Characters I
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/count-substrings-with-k-frequency-characters-i/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3325.Count-Substrings-With-K-Frequency-Characters-I/Solution.go b/leetcode/3301-3400/3325.Count-Substrings-With-K-Frequency-Characters-I/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3325.Count-Substrings-With-K-Frequency-Characters-I/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3325.Count-Substrings-With-K-Frequency-Characters-I/Solution_test.go b/leetcode/3301-3400/3325.Count-Substrings-With-K-Frequency-Characters-I/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3325.Count-Substrings-With-K-Frequency-Characters-I/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3326.Minimum-Division-Operations-to-Make-Array-Non-Decreasing/README.md b/leetcode/3301-3400/3326.Minimum-Division-Operations-to-Make-Array-Non-Decreasing/README.md
new file mode 100755
index 000000000..b6e3115d8
--- /dev/null
+++ b/leetcode/3301-3400/3326.Minimum-Division-Operations-to-Make-Array-Non-Decreasing/README.md
@@ -0,0 +1,32 @@
+# [3326.Minimum Division Operations to Make Array Non Decreasing][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Minimum Division Operations to Make Array Non Decreasing
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/minimum-division-operations-to-make-array-non-decreasing/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3326.Minimum-Division-Operations-to-Make-Array-Non-Decreasing/Solution.go b/leetcode/3301-3400/3326.Minimum-Division-Operations-to-Make-Array-Non-Decreasing/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3326.Minimum-Division-Operations-to-Make-Array-Non-Decreasing/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3326.Minimum-Division-Operations-to-Make-Array-Non-Decreasing/Solution_test.go b/leetcode/3301-3400/3326.Minimum-Division-Operations-to-Make-Array-Non-Decreasing/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3326.Minimum-Division-Operations-to-Make-Array-Non-Decreasing/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3327.Check-if-DFS-Strings-Are-Palindromes/README.md b/leetcode/3301-3400/3327.Check-if-DFS-Strings-Are-Palindromes/README.md
new file mode 100755
index 000000000..e243b1df9
--- /dev/null
+++ b/leetcode/3301-3400/3327.Check-if-DFS-Strings-Are-Palindromes/README.md
@@ -0,0 +1,32 @@
+# [3327.Check if DFS Strings Are Palindromes][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Check if DFS Strings Are Palindromes
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/check-if-dfs-strings-are-palindromes/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3327.Check-if-DFS-Strings-Are-Palindromes/Solution.go b/leetcode/3301-3400/3327.Check-if-DFS-Strings-Are-Palindromes/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3327.Check-if-DFS-Strings-Are-Palindromes/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3327.Check-if-DFS-Strings-Are-Palindromes/Solution_test.go b/leetcode/3301-3400/3327.Check-if-DFS-Strings-Are-Palindromes/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3327.Check-if-DFS-Strings-Are-Palindromes/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3330.Find-the-Original-Typed-String-I/README.md b/leetcode/3301-3400/3330.Find-the-Original-Typed-String-I/README.md
new file mode 100755
index 000000000..21f9634dc
--- /dev/null
+++ b/leetcode/3301-3400/3330.Find-the-Original-Typed-String-I/README.md
@@ -0,0 +1,32 @@
+# [3330.Find the Original Typed String I][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Find the Original Typed String I
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/find-the-original-typed-string-i/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3330.Find-the-Original-Typed-String-I/Solution.go b/leetcode/3301-3400/3330.Find-the-Original-Typed-String-I/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3330.Find-the-Original-Typed-String-I/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3330.Find-the-Original-Typed-String-I/Solution_test.go b/leetcode/3301-3400/3330.Find-the-Original-Typed-String-I/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3330.Find-the-Original-Typed-String-I/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3331.Find-Subtree-Sizes-After-Changes/README.md b/leetcode/3301-3400/3331.Find-Subtree-Sizes-After-Changes/README.md
new file mode 100755
index 000000000..34151aa22
--- /dev/null
+++ b/leetcode/3301-3400/3331.Find-Subtree-Sizes-After-Changes/README.md
@@ -0,0 +1,32 @@
+# [3331.Find Subtree Sizes After Changes][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Find Subtree Sizes After Changes
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/find-subtree-sizes-after-changes/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3331.Find-Subtree-Sizes-After-Changes/Solution.go b/leetcode/3301-3400/3331.Find-Subtree-Sizes-After-Changes/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3331.Find-Subtree-Sizes-After-Changes/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3331.Find-Subtree-Sizes-After-Changes/Solution_test.go b/leetcode/3301-3400/3331.Find-Subtree-Sizes-After-Changes/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3331.Find-Subtree-Sizes-After-Changes/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3332.Maximum-Points-Tourist-Can-Earn/README.md b/leetcode/3301-3400/3332.Maximum-Points-Tourist-Can-Earn/README.md
new file mode 100755
index 000000000..d9d4bec31
--- /dev/null
+++ b/leetcode/3301-3400/3332.Maximum-Points-Tourist-Can-Earn/README.md
@@ -0,0 +1,32 @@
+# [3332.Maximum Points Tourist Can Earn][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Maximum Points Tourist Can Earn
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/maximum-points-tourist-can-earn/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3332.Maximum-Points-Tourist-Can-Earn/Solution.go b/leetcode/3301-3400/3332.Maximum-Points-Tourist-Can-Earn/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3332.Maximum-Points-Tourist-Can-Earn/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3332.Maximum-Points-Tourist-Can-Earn/Solution_test.go b/leetcode/3301-3400/3332.Maximum-Points-Tourist-Can-Earn/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3332.Maximum-Points-Tourist-Can-Earn/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3333.Find-the-Original-Typed-String-II/README.md b/leetcode/3301-3400/3333.Find-the-Original-Typed-String-II/README.md
new file mode 100755
index 000000000..bf77b439d
--- /dev/null
+++ b/leetcode/3301-3400/3333.Find-the-Original-Typed-String-II/README.md
@@ -0,0 +1,32 @@
+# [3333.Find the Original Typed String II][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Find the Original Typed String II
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/find-the-original-typed-string-ii/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3333.Find-the-Original-Typed-String-II/Solution.go b/leetcode/3301-3400/3333.Find-the-Original-Typed-String-II/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3333.Find-the-Original-Typed-String-II/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3333.Find-the-Original-Typed-String-II/Solution_test.go b/leetcode/3301-3400/3333.Find-the-Original-Typed-String-II/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3333.Find-the-Original-Typed-String-II/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3334.Find-the-Maximum-Factor-Score-of-Array/README.md b/leetcode/3301-3400/3334.Find-the-Maximum-Factor-Score-of-Array/README.md
new file mode 100755
index 000000000..07d053129
--- /dev/null
+++ b/leetcode/3301-3400/3334.Find-the-Maximum-Factor-Score-of-Array/README.md
@@ -0,0 +1,32 @@
+# [3334.Find the Maximum Factor Score of Array][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Find the Maximum Factor Score of Array
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/find-the-maximum-factor-score-of-array/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3334.Find-the-Maximum-Factor-Score-of-Array/Solution.go b/leetcode/3301-3400/3334.Find-the-Maximum-Factor-Score-of-Array/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3334.Find-the-Maximum-Factor-Score-of-Array/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3334.Find-the-Maximum-Factor-Score-of-Array/Solution_test.go b/leetcode/3301-3400/3334.Find-the-Maximum-Factor-Score-of-Array/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3334.Find-the-Maximum-Factor-Score-of-Array/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3335.Total-Characters-in-String-After-Transformations-I/README.md b/leetcode/3301-3400/3335.Total-Characters-in-String-After-Transformations-I/README.md
new file mode 100755
index 000000000..9f43350bb
--- /dev/null
+++ b/leetcode/3301-3400/3335.Total-Characters-in-String-After-Transformations-I/README.md
@@ -0,0 +1,32 @@
+# [3335.Total Characters in String After Transformations I][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Total Characters in String After Transformations I
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/total-characters-in-string-after-transformations-i/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3335.Total-Characters-in-String-After-Transformations-I/Solution.go b/leetcode/3301-3400/3335.Total-Characters-in-String-After-Transformations-I/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3335.Total-Characters-in-String-After-Transformations-I/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3335.Total-Characters-in-String-After-Transformations-I/Solution_test.go b/leetcode/3301-3400/3335.Total-Characters-in-String-After-Transformations-I/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3335.Total-Characters-in-String-After-Transformations-I/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3336.Find-the-Number-of-Subsequences-With-Equal-GCD/README.md b/leetcode/3301-3400/3336.Find-the-Number-of-Subsequences-With-Equal-GCD/README.md
new file mode 100755
index 000000000..e66525e6b
--- /dev/null
+++ b/leetcode/3301-3400/3336.Find-the-Number-of-Subsequences-With-Equal-GCD/README.md
@@ -0,0 +1,32 @@
+# [3336.Find the Number of Subsequences With Equal GCD][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Find the Number of Subsequences With Equal GCD
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/find-the-number-of-subsequences-with-equal-gcd/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3336.Find-the-Number-of-Subsequences-With-Equal-GCD/Solution.go b/leetcode/3301-3400/3336.Find-the-Number-of-Subsequences-With-Equal-GCD/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3336.Find-the-Number-of-Subsequences-With-Equal-GCD/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3336.Find-the-Number-of-Subsequences-With-Equal-GCD/Solution_test.go b/leetcode/3301-3400/3336.Find-the-Number-of-Subsequences-With-Equal-GCD/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3336.Find-the-Number-of-Subsequences-With-Equal-GCD/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3337.Total-Characters-in-String-After-Transformations-II/README.md b/leetcode/3301-3400/3337.Total-Characters-in-String-After-Transformations-II/README.md
new file mode 100755
index 000000000..56158ae48
--- /dev/null
+++ b/leetcode/3301-3400/3337.Total-Characters-in-String-After-Transformations-II/README.md
@@ -0,0 +1,32 @@
+# [3337.Total Characters in String After Transformations II][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Total Characters in String After Transformations II
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/total-characters-in-string-after-transformations-ii/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3337.Total-Characters-in-String-After-Transformations-II/Solution.go b/leetcode/3301-3400/3337.Total-Characters-in-String-After-Transformations-II/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3337.Total-Characters-in-String-After-Transformations-II/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3337.Total-Characters-in-String-After-Transformations-II/Solution_test.go b/leetcode/3301-3400/3337.Total-Characters-in-String-After-Transformations-II/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3337.Total-Characters-in-String-After-Transformations-II/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3340.Check-Balanced-String/README.md b/leetcode/3301-3400/3340.Check-Balanced-String/README.md
new file mode 100755
index 000000000..f4245fa69
--- /dev/null
+++ b/leetcode/3301-3400/3340.Check-Balanced-String/README.md
@@ -0,0 +1,32 @@
+# [3340.Check Balanced String][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Check Balanced String
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/check-balanced-string/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3340.Check-Balanced-String/Solution.go b/leetcode/3301-3400/3340.Check-Balanced-String/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3340.Check-Balanced-String/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3340.Check-Balanced-String/Solution_test.go b/leetcode/3301-3400/3340.Check-Balanced-String/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3340.Check-Balanced-String/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3341.Find-Minimum-Time-to-Reach-Last-Room-I/README.md b/leetcode/3301-3400/3341.Find-Minimum-Time-to-Reach-Last-Room-I/README.md
new file mode 100755
index 000000000..29935036c
--- /dev/null
+++ b/leetcode/3301-3400/3341.Find-Minimum-Time-to-Reach-Last-Room-I/README.md
@@ -0,0 +1,32 @@
+# [3341.Find Minimum Time to Reach Last Room I][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Find Minimum Time to Reach Last Room I
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/find-minimum-time-to-reach-last-room-i/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3341.Find-Minimum-Time-to-Reach-Last-Room-I/Solution.go b/leetcode/3301-3400/3341.Find-Minimum-Time-to-Reach-Last-Room-I/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3341.Find-Minimum-Time-to-Reach-Last-Room-I/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3341.Find-Minimum-Time-to-Reach-Last-Room-I/Solution_test.go b/leetcode/3301-3400/3341.Find-Minimum-Time-to-Reach-Last-Room-I/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3341.Find-Minimum-Time-to-Reach-Last-Room-I/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3342.Find-Minimum-Time-to-Reach-Last-Room-II/README.md b/leetcode/3301-3400/3342.Find-Minimum-Time-to-Reach-Last-Room-II/README.md
new file mode 100755
index 000000000..c2bf27985
--- /dev/null
+++ b/leetcode/3301-3400/3342.Find-Minimum-Time-to-Reach-Last-Room-II/README.md
@@ -0,0 +1,32 @@
+# [3342.Find Minimum Time to Reach Last Room II][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Find Minimum Time to Reach Last Room II
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/find-minimum-time-to-reach-last-room-ii/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3342.Find-Minimum-Time-to-Reach-Last-Room-II/Solution.go b/leetcode/3301-3400/3342.Find-Minimum-Time-to-Reach-Last-Room-II/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3342.Find-Minimum-Time-to-Reach-Last-Room-II/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3342.Find-Minimum-Time-to-Reach-Last-Room-II/Solution_test.go b/leetcode/3301-3400/3342.Find-Minimum-Time-to-Reach-Last-Room-II/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3342.Find-Minimum-Time-to-Reach-Last-Room-II/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3343.Count-Number-of-Balanced-Permutations/README.md b/leetcode/3301-3400/3343.Count-Number-of-Balanced-Permutations/README.md
new file mode 100755
index 000000000..5758e85b3
--- /dev/null
+++ b/leetcode/3301-3400/3343.Count-Number-of-Balanced-Permutations/README.md
@@ -0,0 +1,32 @@
+# [3343.Count Number of Balanced Permutations][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Count Number of Balanced Permutations
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/count-number-of-balanced-permutations/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3343.Count-Number-of-Balanced-Permutations/Solution.go b/leetcode/3301-3400/3343.Count-Number-of-Balanced-Permutations/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3343.Count-Number-of-Balanced-Permutations/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3343.Count-Number-of-Balanced-Permutations/Solution_test.go b/leetcode/3301-3400/3343.Count-Number-of-Balanced-Permutations/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3343.Count-Number-of-Balanced-Permutations/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3345.Smallest-Divisible-Digit-Product-I/README.md b/leetcode/3301-3400/3345.Smallest-Divisible-Digit-Product-I/README.md
new file mode 100755
index 000000000..0e0efdf49
--- /dev/null
+++ b/leetcode/3301-3400/3345.Smallest-Divisible-Digit-Product-I/README.md
@@ -0,0 +1,32 @@
+# [3345.Smallest Divisible Digit Product I][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Smallest Divisible Digit Product I
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/smallest-divisible-digit-product-i/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3345.Smallest-Divisible-Digit-Product-I/Solution.go b/leetcode/3301-3400/3345.Smallest-Divisible-Digit-Product-I/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3345.Smallest-Divisible-Digit-Product-I/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3345.Smallest-Divisible-Digit-Product-I/Solution_test.go b/leetcode/3301-3400/3345.Smallest-Divisible-Digit-Product-I/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3345.Smallest-Divisible-Digit-Product-I/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3346.Maximum-Frequency-of-an-Element-After-Performing-Operations-I/README.md b/leetcode/3301-3400/3346.Maximum-Frequency-of-an-Element-After-Performing-Operations-I/README.md
new file mode 100755
index 000000000..7ac632cae
--- /dev/null
+++ b/leetcode/3301-3400/3346.Maximum-Frequency-of-an-Element-After-Performing-Operations-I/README.md
@@ -0,0 +1,32 @@
+# [3346.Maximum Frequency of an Element After Performing Operations I][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Maximum Frequency of an Element After Performing Operations I
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/maximum-frequency-of-an-element-after-performing-operations-i/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3346.Maximum-Frequency-of-an-Element-After-Performing-Operations-I/Solution.go b/leetcode/3301-3400/3346.Maximum-Frequency-of-an-Element-After-Performing-Operations-I/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3346.Maximum-Frequency-of-an-Element-After-Performing-Operations-I/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3346.Maximum-Frequency-of-an-Element-After-Performing-Operations-I/Solution_test.go b/leetcode/3301-3400/3346.Maximum-Frequency-of-an-Element-After-Performing-Operations-I/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3346.Maximum-Frequency-of-an-Element-After-Performing-Operations-I/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3347.Maximum-Frequency-of-an-Element-After-Performing-Operations-II/README.md b/leetcode/3301-3400/3347.Maximum-Frequency-of-an-Element-After-Performing-Operations-II/README.md
new file mode 100755
index 000000000..b5e3be604
--- /dev/null
+++ b/leetcode/3301-3400/3347.Maximum-Frequency-of-an-Element-After-Performing-Operations-II/README.md
@@ -0,0 +1,32 @@
+# [3347.Maximum Frequency of an Element After Performing Operations II][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Maximum Frequency of an Element After Performing Operations II
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/maximum-frequency-of-an-element-after-performing-operations-ii/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3347.Maximum-Frequency-of-an-Element-After-Performing-Operations-II/Solution.go b/leetcode/3301-3400/3347.Maximum-Frequency-of-an-Element-After-Performing-Operations-II/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3347.Maximum-Frequency-of-an-Element-After-Performing-Operations-II/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3347.Maximum-Frequency-of-an-Element-After-Performing-Operations-II/Solution_test.go b/leetcode/3301-3400/3347.Maximum-Frequency-of-an-Element-After-Performing-Operations-II/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3347.Maximum-Frequency-of-an-Element-After-Performing-Operations-II/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3348.Smallest-Divisible-Digit-Product-II/README.md b/leetcode/3301-3400/3348.Smallest-Divisible-Digit-Product-II/README.md
new file mode 100755
index 000000000..a53812126
--- /dev/null
+++ b/leetcode/3301-3400/3348.Smallest-Divisible-Digit-Product-II/README.md
@@ -0,0 +1,32 @@
+# [3348.Smallest Divisible Digit Product II][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Smallest Divisible Digit Product II
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/smallest-divisible-digit-product-ii/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3348.Smallest-Divisible-Digit-Product-II/Solution.go b/leetcode/3301-3400/3348.Smallest-Divisible-Digit-Product-II/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3348.Smallest-Divisible-Digit-Product-II/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3348.Smallest-Divisible-Digit-Product-II/Solution_test.go b/leetcode/3301-3400/3348.Smallest-Divisible-Digit-Product-II/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3348.Smallest-Divisible-Digit-Product-II/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3349.Adjacent-Increasing-Subarrays-Detection-I/README.md b/leetcode/3301-3400/3349.Adjacent-Increasing-Subarrays-Detection-I/README.md
new file mode 100755
index 000000000..28390af4c
--- /dev/null
+++ b/leetcode/3301-3400/3349.Adjacent-Increasing-Subarrays-Detection-I/README.md
@@ -0,0 +1,32 @@
+# [3349.Adjacent Increasing Subarrays Detection I][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Adjacent Increasing Subarrays Detection I
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/adjacent-increasing-subarrays-detection-i/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3349.Adjacent-Increasing-Subarrays-Detection-I/Solution.go b/leetcode/3301-3400/3349.Adjacent-Increasing-Subarrays-Detection-I/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3349.Adjacent-Increasing-Subarrays-Detection-I/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3349.Adjacent-Increasing-Subarrays-Detection-I/Solution_test.go b/leetcode/3301-3400/3349.Adjacent-Increasing-Subarrays-Detection-I/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3349.Adjacent-Increasing-Subarrays-Detection-I/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3350.Adjacent-Increasing-Subarrays-Detection-II/README.md b/leetcode/3301-3400/3350.Adjacent-Increasing-Subarrays-Detection-II/README.md
new file mode 100755
index 000000000..8c92bb31e
--- /dev/null
+++ b/leetcode/3301-3400/3350.Adjacent-Increasing-Subarrays-Detection-II/README.md
@@ -0,0 +1,32 @@
+# [3350.Adjacent Increasing Subarrays Detection II][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Adjacent Increasing Subarrays Detection II
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/adjacent-increasing-subarrays-detection-ii/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3350.Adjacent-Increasing-Subarrays-Detection-II/Solution.go b/leetcode/3301-3400/3350.Adjacent-Increasing-Subarrays-Detection-II/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3350.Adjacent-Increasing-Subarrays-Detection-II/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3350.Adjacent-Increasing-Subarrays-Detection-II/Solution_test.go b/leetcode/3301-3400/3350.Adjacent-Increasing-Subarrays-Detection-II/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3350.Adjacent-Increasing-Subarrays-Detection-II/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3351.Sum-of-Good-Subsequences/README.md b/leetcode/3301-3400/3351.Sum-of-Good-Subsequences/README.md
new file mode 100755
index 000000000..f634995b9
--- /dev/null
+++ b/leetcode/3301-3400/3351.Sum-of-Good-Subsequences/README.md
@@ -0,0 +1,32 @@
+# [3351.Sum of Good Subsequences][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Sum of Good Subsequences
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/sum-of-good-subsequences/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3351.Sum-of-Good-Subsequences/Solution.go b/leetcode/3301-3400/3351.Sum-of-Good-Subsequences/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3351.Sum-of-Good-Subsequences/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3351.Sum-of-Good-Subsequences/Solution_test.go b/leetcode/3301-3400/3351.Sum-of-Good-Subsequences/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3351.Sum-of-Good-Subsequences/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3352.Count-K-Reducible-Numbers-Less-Than-N/README.md b/leetcode/3301-3400/3352.Count-K-Reducible-Numbers-Less-Than-N/README.md
new file mode 100755
index 000000000..601abbe60
--- /dev/null
+++ b/leetcode/3301-3400/3352.Count-K-Reducible-Numbers-Less-Than-N/README.md
@@ -0,0 +1,32 @@
+# [3352.Count K-Reducible Numbers Less Than N][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Count K-Reducible Numbers Less Than N
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/count-k-reducible-numbers-less-than-n/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3352.Count-K-Reducible-Numbers-Less-Than-N/Solution.go b/leetcode/3301-3400/3352.Count-K-Reducible-Numbers-Less-Than-N/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3352.Count-K-Reducible-Numbers-Less-Than-N/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3352.Count-K-Reducible-Numbers-Less-Than-N/Solution_test.go b/leetcode/3301-3400/3352.Count-K-Reducible-Numbers-Less-Than-N/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3352.Count-K-Reducible-Numbers-Less-Than-N/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3354.Make-Array-Elements-Equal-to-Zero/README.md b/leetcode/3301-3400/3354.Make-Array-Elements-Equal-to-Zero/README.md
new file mode 100755
index 000000000..c47f9d4f9
--- /dev/null
+++ b/leetcode/3301-3400/3354.Make-Array-Elements-Equal-to-Zero/README.md
@@ -0,0 +1,32 @@
+# [3354.Make Array Elements Equal to Zero][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Make Array Elements Equal to Zero
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/make-array-elements-equal-to-zero/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3354.Make-Array-Elements-Equal-to-Zero/Solution.go b/leetcode/3301-3400/3354.Make-Array-Elements-Equal-to-Zero/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3354.Make-Array-Elements-Equal-to-Zero/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3354.Make-Array-Elements-Equal-to-Zero/Solution_test.go b/leetcode/3301-3400/3354.Make-Array-Elements-Equal-to-Zero/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3354.Make-Array-Elements-Equal-to-Zero/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3355.Zero-Array-Transformation-I/README.md b/leetcode/3301-3400/3355.Zero-Array-Transformation-I/README.md
new file mode 100755
index 000000000..ed9347afb
--- /dev/null
+++ b/leetcode/3301-3400/3355.Zero-Array-Transformation-I/README.md
@@ -0,0 +1,32 @@
+# [3355.Zero Array Transformation I][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Zero Array Transformation I
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/zero-array-transformation-i/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3355.Zero-Array-Transformation-I/Solution.go b/leetcode/3301-3400/3355.Zero-Array-Transformation-I/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3355.Zero-Array-Transformation-I/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3355.Zero-Array-Transformation-I/Solution_test.go b/leetcode/3301-3400/3355.Zero-Array-Transformation-I/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3355.Zero-Array-Transformation-I/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3356.Zero-Array-Transformation-II/README.md b/leetcode/3301-3400/3356.Zero-Array-Transformation-II/README.md
new file mode 100755
index 000000000..9f60d7b59
--- /dev/null
+++ b/leetcode/3301-3400/3356.Zero-Array-Transformation-II/README.md
@@ -0,0 +1,32 @@
+# [3356.Zero Array Transformation II][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Zero Array Transformation II
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/zero-array-transformation-ii/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3356.Zero-Array-Transformation-II/Solution.go b/leetcode/3301-3400/3356.Zero-Array-Transformation-II/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3356.Zero-Array-Transformation-II/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3356.Zero-Array-Transformation-II/Solution_test.go b/leetcode/3301-3400/3356.Zero-Array-Transformation-II/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3356.Zero-Array-Transformation-II/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3357.Minimize-the-Maximum-Adjacent-Element-Difference/README.md b/leetcode/3301-3400/3357.Minimize-the-Maximum-Adjacent-Element-Difference/README.md
new file mode 100755
index 000000000..e0dadf435
--- /dev/null
+++ b/leetcode/3301-3400/3357.Minimize-the-Maximum-Adjacent-Element-Difference/README.md
@@ -0,0 +1,32 @@
+# [3357.Minimize the Maximum Adjacent Element Difference][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Minimize the Maximum Adjacent Element Difference
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/minimize-the-maximum-adjacent-element-difference/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3357.Minimize-the-Maximum-Adjacent-Element-Difference/Solution.go b/leetcode/3301-3400/3357.Minimize-the-Maximum-Adjacent-Element-Difference/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3357.Minimize-the-Maximum-Adjacent-Element-Difference/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3357.Minimize-the-Maximum-Adjacent-Element-Difference/Solution_test.go b/leetcode/3301-3400/3357.Minimize-the-Maximum-Adjacent-Element-Difference/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3357.Minimize-the-Maximum-Adjacent-Element-Difference/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3360.Stone-Removal-Game/README.md b/leetcode/3301-3400/3360.Stone-Removal-Game/README.md
new file mode 100755
index 000000000..4fd99960d
--- /dev/null
+++ b/leetcode/3301-3400/3360.Stone-Removal-Game/README.md
@@ -0,0 +1,32 @@
+# [3360.Stone Removal Game][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Stone Removal Game
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/stone-removal-game/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3360.Stone-Removal-Game/Solution.go b/leetcode/3301-3400/3360.Stone-Removal-Game/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3360.Stone-Removal-Game/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3360.Stone-Removal-Game/Solution_test.go b/leetcode/3301-3400/3360.Stone-Removal-Game/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3360.Stone-Removal-Game/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3361.Shift-Distance-Between-Two-Strings/README.md b/leetcode/3301-3400/3361.Shift-Distance-Between-Two-Strings/README.md
new file mode 100755
index 000000000..ceb97f376
--- /dev/null
+++ b/leetcode/3301-3400/3361.Shift-Distance-Between-Two-Strings/README.md
@@ -0,0 +1,32 @@
+# [3361.Shift Distance Between Two Strings][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Shift Distance Between Two Strings
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/shift-distance-between-two-strings/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3361.Shift-Distance-Between-Two-Strings/Solution.go b/leetcode/3301-3400/3361.Shift-Distance-Between-Two-Strings/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3361.Shift-Distance-Between-Two-Strings/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3361.Shift-Distance-Between-Two-Strings/Solution_test.go b/leetcode/3301-3400/3361.Shift-Distance-Between-Two-Strings/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3361.Shift-Distance-Between-Two-Strings/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3362.Zero-Array-Transformation-III/README.md b/leetcode/3301-3400/3362.Zero-Array-Transformation-III/README.md
new file mode 100755
index 000000000..fb5595409
--- /dev/null
+++ b/leetcode/3301-3400/3362.Zero-Array-Transformation-III/README.md
@@ -0,0 +1,32 @@
+# [3362.Zero Array Transformation III][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Zero Array Transformation III
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/zero-array-transformation-iii/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3362.Zero-Array-Transformation-III/Solution.go b/leetcode/3301-3400/3362.Zero-Array-Transformation-III/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3362.Zero-Array-Transformation-III/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3362.Zero-Array-Transformation-III/Solution_test.go b/leetcode/3301-3400/3362.Zero-Array-Transformation-III/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3362.Zero-Array-Transformation-III/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3363.Find-the-Maximum-Number-of-Fruits-Collected/README.md b/leetcode/3301-3400/3363.Find-the-Maximum-Number-of-Fruits-Collected/README.md
new file mode 100755
index 000000000..ecf357498
--- /dev/null
+++ b/leetcode/3301-3400/3363.Find-the-Maximum-Number-of-Fruits-Collected/README.md
@@ -0,0 +1,32 @@
+# [3363.Find the Maximum Number of Fruits Collected][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Find the Maximum Number of Fruits Collected
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/find-the-maximum-number-of-fruits-collected/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3363.Find-the-Maximum-Number-of-Fruits-Collected/Solution.go b/leetcode/3301-3400/3363.Find-the-Maximum-Number-of-Fruits-Collected/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3363.Find-the-Maximum-Number-of-Fruits-Collected/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3363.Find-the-Maximum-Number-of-Fruits-Collected/Solution_test.go b/leetcode/3301-3400/3363.Find-the-Maximum-Number-of-Fruits-Collected/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3363.Find-the-Maximum-Number-of-Fruits-Collected/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3364.Minimum-Positive-Sum-Subarray-/README.md b/leetcode/3301-3400/3364.Minimum-Positive-Sum-Subarray-/README.md
new file mode 100755
index 000000000..e999a834f
--- /dev/null
+++ b/leetcode/3301-3400/3364.Minimum-Positive-Sum-Subarray-/README.md
@@ -0,0 +1,32 @@
+# [3364.Minimum Positive Sum Subarray ][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Minimum Positive Sum Subarray 
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/minimum-positive-sum-subarray/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3364.Minimum-Positive-Sum-Subarray-/Solution.go b/leetcode/3301-3400/3364.Minimum-Positive-Sum-Subarray-/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3364.Minimum-Positive-Sum-Subarray-/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3364.Minimum-Positive-Sum-Subarray-/Solution_test.go b/leetcode/3301-3400/3364.Minimum-Positive-Sum-Subarray-/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3364.Minimum-Positive-Sum-Subarray-/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3365.Rearrange-K-Substrings-to-Form-Target-String/README.md b/leetcode/3301-3400/3365.Rearrange-K-Substrings-to-Form-Target-String/README.md
new file mode 100755
index 000000000..a42008c38
--- /dev/null
+++ b/leetcode/3301-3400/3365.Rearrange-K-Substrings-to-Form-Target-String/README.md
@@ -0,0 +1,32 @@
+# [3365.Rearrange K Substrings to Form Target String][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Rearrange K Substrings to Form Target String
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/rearrange-k-substrings-to-form-target-string/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3365.Rearrange-K-Substrings-to-Form-Target-String/Solution.go b/leetcode/3301-3400/3365.Rearrange-K-Substrings-to-Form-Target-String/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3365.Rearrange-K-Substrings-to-Form-Target-String/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3365.Rearrange-K-Substrings-to-Form-Target-String/Solution_test.go b/leetcode/3301-3400/3365.Rearrange-K-Substrings-to-Form-Target-String/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3365.Rearrange-K-Substrings-to-Form-Target-String/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3366.Minimum-Array-Sum/README.md b/leetcode/3301-3400/3366.Minimum-Array-Sum/README.md
new file mode 100755
index 000000000..eb086fea5
--- /dev/null
+++ b/leetcode/3301-3400/3366.Minimum-Array-Sum/README.md
@@ -0,0 +1,32 @@
+# [3366.Minimum Array Sum][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Minimum Array Sum
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/minimum-array-sum/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3366.Minimum-Array-Sum/Solution.go b/leetcode/3301-3400/3366.Minimum-Array-Sum/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3366.Minimum-Array-Sum/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3366.Minimum-Array-Sum/Solution_test.go b/leetcode/3301-3400/3366.Minimum-Array-Sum/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3366.Minimum-Array-Sum/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3367.Maximize-Sum-of-Weights-after-Edge-Removals/README.md b/leetcode/3301-3400/3367.Maximize-Sum-of-Weights-after-Edge-Removals/README.md
new file mode 100755
index 000000000..bf1248f1f
--- /dev/null
+++ b/leetcode/3301-3400/3367.Maximize-Sum-of-Weights-after-Edge-Removals/README.md
@@ -0,0 +1,32 @@
+# [3367.Maximize Sum of Weights after Edge Removals][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Maximize Sum of Weights after Edge Removals
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/maximize-sum-of-weights-after-edge-removals/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3367.Maximize-Sum-of-Weights-after-Edge-Removals/Solution.go b/leetcode/3301-3400/3367.Maximize-Sum-of-Weights-after-Edge-Removals/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3367.Maximize-Sum-of-Weights-after-Edge-Removals/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3367.Maximize-Sum-of-Weights-after-Edge-Removals/Solution_test.go b/leetcode/3301-3400/3367.Maximize-Sum-of-Weights-after-Edge-Removals/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3367.Maximize-Sum-of-Weights-after-Edge-Removals/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3370.Smallest-Number-With-All-Set-Bits/README.md b/leetcode/3301-3400/3370.Smallest-Number-With-All-Set-Bits/README.md
new file mode 100755
index 000000000..5035313d8
--- /dev/null
+++ b/leetcode/3301-3400/3370.Smallest-Number-With-All-Set-Bits/README.md
@@ -0,0 +1,32 @@
+# [3370.Smallest Number With All Set Bits][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Smallest Number With All Set Bits
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/smallest-number-with-all-set-bits/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3370.Smallest-Number-With-All-Set-Bits/Solution.go b/leetcode/3301-3400/3370.Smallest-Number-With-All-Set-Bits/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3370.Smallest-Number-With-All-Set-Bits/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3370.Smallest-Number-With-All-Set-Bits/Solution_test.go b/leetcode/3301-3400/3370.Smallest-Number-With-All-Set-Bits/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3370.Smallest-Number-With-All-Set-Bits/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3371.Identify-the-Largest-Outlier-in-an-Array/README.md b/leetcode/3301-3400/3371.Identify-the-Largest-Outlier-in-an-Array/README.md
new file mode 100755
index 000000000..c4712022a
--- /dev/null
+++ b/leetcode/3301-3400/3371.Identify-the-Largest-Outlier-in-an-Array/README.md
@@ -0,0 +1,32 @@
+# [3371.Identify the Largest Outlier in an Array][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Identify the Largest Outlier in an Array
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/identify-the-largest-outlier-in-an-array/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3371.Identify-the-Largest-Outlier-in-an-Array/Solution.go b/leetcode/3301-3400/3371.Identify-the-Largest-Outlier-in-an-Array/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3371.Identify-the-Largest-Outlier-in-an-Array/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3371.Identify-the-Largest-Outlier-in-an-Array/Solution_test.go b/leetcode/3301-3400/3371.Identify-the-Largest-Outlier-in-an-Array/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3371.Identify-the-Largest-Outlier-in-an-Array/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3372.Maximize-the-Number-of-Target-Nodes-After-Connecting-Trees-I/README.md b/leetcode/3301-3400/3372.Maximize-the-Number-of-Target-Nodes-After-Connecting-Trees-I/README.md
new file mode 100755
index 000000000..ec9b58f67
--- /dev/null
+++ b/leetcode/3301-3400/3372.Maximize-the-Number-of-Target-Nodes-After-Connecting-Trees-I/README.md
@@ -0,0 +1,32 @@
+# [3372.Maximize the Number of Target Nodes After Connecting Trees I][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Maximize the Number of Target Nodes After Connecting Trees I
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/maximize-the-number-of-target-nodes-after-connecting-trees-i/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3372.Maximize-the-Number-of-Target-Nodes-After-Connecting-Trees-I/Solution.go b/leetcode/3301-3400/3372.Maximize-the-Number-of-Target-Nodes-After-Connecting-Trees-I/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3372.Maximize-the-Number-of-Target-Nodes-After-Connecting-Trees-I/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3372.Maximize-the-Number-of-Target-Nodes-After-Connecting-Trees-I/Solution_test.go b/leetcode/3301-3400/3372.Maximize-the-Number-of-Target-Nodes-After-Connecting-Trees-I/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3372.Maximize-the-Number-of-Target-Nodes-After-Connecting-Trees-I/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3373.Maximize-the-Number-of-Target-Nodes-After-Connecting-Trees-II/README.md b/leetcode/3301-3400/3373.Maximize-the-Number-of-Target-Nodes-After-Connecting-Trees-II/README.md
new file mode 100755
index 000000000..0a59acd4c
--- /dev/null
+++ b/leetcode/3301-3400/3373.Maximize-the-Number-of-Target-Nodes-After-Connecting-Trees-II/README.md
@@ -0,0 +1,32 @@
+# [3373.Maximize the Number of Target Nodes After Connecting Trees II][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Maximize the Number of Target Nodes After Connecting Trees II
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/maximize-the-number-of-target-nodes-after-connecting-trees-ii/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3373.Maximize-the-Number-of-Target-Nodes-After-Connecting-Trees-II/Solution.go b/leetcode/3301-3400/3373.Maximize-the-Number-of-Target-Nodes-After-Connecting-Trees-II/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3373.Maximize-the-Number-of-Target-Nodes-After-Connecting-Trees-II/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3373.Maximize-the-Number-of-Target-Nodes-After-Connecting-Trees-II/Solution_test.go b/leetcode/3301-3400/3373.Maximize-the-Number-of-Target-Nodes-After-Connecting-Trees-II/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3373.Maximize-the-Number-of-Target-Nodes-After-Connecting-Trees-II/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3375.Minimum-Operations-to-Make-Array-Values-Equal-to-K/README.md b/leetcode/3301-3400/3375.Minimum-Operations-to-Make-Array-Values-Equal-to-K/README.md
new file mode 100755
index 000000000..4e08aefda
--- /dev/null
+++ b/leetcode/3301-3400/3375.Minimum-Operations-to-Make-Array-Values-Equal-to-K/README.md
@@ -0,0 +1,32 @@
+# [3375.Minimum Operations to Make Array Values Equal to K][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Minimum Operations to Make Array Values Equal to K
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/minimum-operations-to-make-array-values-equal-to-k/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3375.Minimum-Operations-to-Make-Array-Values-Equal-to-K/Solution.go b/leetcode/3301-3400/3375.Minimum-Operations-to-Make-Array-Values-Equal-to-K/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3375.Minimum-Operations-to-Make-Array-Values-Equal-to-K/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3375.Minimum-Operations-to-Make-Array-Values-Equal-to-K/Solution_test.go b/leetcode/3301-3400/3375.Minimum-Operations-to-Make-Array-Values-Equal-to-K/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3375.Minimum-Operations-to-Make-Array-Values-Equal-to-K/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3376.Minimum-Time-to-Break-Locks-I/README.md b/leetcode/3301-3400/3376.Minimum-Time-to-Break-Locks-I/README.md
new file mode 100755
index 000000000..8ebae9b00
--- /dev/null
+++ b/leetcode/3301-3400/3376.Minimum-Time-to-Break-Locks-I/README.md
@@ -0,0 +1,32 @@
+# [3376.Minimum Time to Break Locks I][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Minimum Time to Break Locks I
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/minimum-time-to-break-locks-i/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3376.Minimum-Time-to-Break-Locks-I/Solution.go b/leetcode/3301-3400/3376.Minimum-Time-to-Break-Locks-I/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3376.Minimum-Time-to-Break-Locks-I/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3376.Minimum-Time-to-Break-Locks-I/Solution_test.go b/leetcode/3301-3400/3376.Minimum-Time-to-Break-Locks-I/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3376.Minimum-Time-to-Break-Locks-I/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3377.Digit-Operations-to-Make-Two-Integers-Equal/README.md b/leetcode/3301-3400/3377.Digit-Operations-to-Make-Two-Integers-Equal/README.md
new file mode 100755
index 000000000..28c017d8d
--- /dev/null
+++ b/leetcode/3301-3400/3377.Digit-Operations-to-Make-Two-Integers-Equal/README.md
@@ -0,0 +1,32 @@
+# [3377.Digit Operations to Make Two Integers Equal][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Digit Operations to Make Two Integers Equal
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/digit-operations-to-make-two-integers-equal/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3377.Digit-Operations-to-Make-Two-Integers-Equal/Solution.go b/leetcode/3301-3400/3377.Digit-Operations-to-Make-Two-Integers-Equal/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3377.Digit-Operations-to-Make-Two-Integers-Equal/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3377.Digit-Operations-to-Make-Two-Integers-Equal/Solution_test.go b/leetcode/3301-3400/3377.Digit-Operations-to-Make-Two-Integers-Equal/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3377.Digit-Operations-to-Make-Two-Integers-Equal/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3378.Count-Connected-Components-in-LCM-Graph/README.md b/leetcode/3301-3400/3378.Count-Connected-Components-in-LCM-Graph/README.md
new file mode 100755
index 000000000..90b43eb73
--- /dev/null
+++ b/leetcode/3301-3400/3378.Count-Connected-Components-in-LCM-Graph/README.md
@@ -0,0 +1,32 @@
+# [3378.Count Connected Components in LCM Graph][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Count Connected Components in LCM Graph
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/count-connected-components-in-lcm-graph/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3378.Count-Connected-Components-in-LCM-Graph/Solution.go b/leetcode/3301-3400/3378.Count-Connected-Components-in-LCM-Graph/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3378.Count-Connected-Components-in-LCM-Graph/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3378.Count-Connected-Components-in-LCM-Graph/Solution_test.go b/leetcode/3301-3400/3378.Count-Connected-Components-in-LCM-Graph/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3378.Count-Connected-Components-in-LCM-Graph/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3379.Transformed-Array/README.md b/leetcode/3301-3400/3379.Transformed-Array/README.md
new file mode 100755
index 000000000..11095a992
--- /dev/null
+++ b/leetcode/3301-3400/3379.Transformed-Array/README.md
@@ -0,0 +1,32 @@
+# [3379.Transformed Array][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Transformed Array
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/transformed-array/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3379.Transformed-Array/Solution.go b/leetcode/3301-3400/3379.Transformed-Array/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3379.Transformed-Array/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3379.Transformed-Array/Solution_test.go b/leetcode/3301-3400/3379.Transformed-Array/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3379.Transformed-Array/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3380.Maximum-Area-Rectangle-With-Point-Constraints-I/README.md b/leetcode/3301-3400/3380.Maximum-Area-Rectangle-With-Point-Constraints-I/README.md
new file mode 100755
index 000000000..6fc6b26e2
--- /dev/null
+++ b/leetcode/3301-3400/3380.Maximum-Area-Rectangle-With-Point-Constraints-I/README.md
@@ -0,0 +1,32 @@
+# [3380.Maximum Area Rectangle With Point Constraints I][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Maximum Area Rectangle With Point Constraints I
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/maximum-area-rectangle-with-point-constraints-i/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3380.Maximum-Area-Rectangle-With-Point-Constraints-I/Solution.go b/leetcode/3301-3400/3380.Maximum-Area-Rectangle-With-Point-Constraints-I/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3380.Maximum-Area-Rectangle-With-Point-Constraints-I/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3380.Maximum-Area-Rectangle-With-Point-Constraints-I/Solution_test.go b/leetcode/3301-3400/3380.Maximum-Area-Rectangle-With-Point-Constraints-I/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3380.Maximum-Area-Rectangle-With-Point-Constraints-I/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3381.Maximum-Subarray-Sum-With-Length-Divisible-by-K/README.md b/leetcode/3301-3400/3381.Maximum-Subarray-Sum-With-Length-Divisible-by-K/README.md
new file mode 100755
index 000000000..65f0edc1e
--- /dev/null
+++ b/leetcode/3301-3400/3381.Maximum-Subarray-Sum-With-Length-Divisible-by-K/README.md
@@ -0,0 +1,32 @@
+# [3381.Maximum Subarray Sum With Length Divisible by K][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Maximum Subarray Sum With Length Divisible by K
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/maximum-subarray-sum-with-length-divisible-by-k/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3381.Maximum-Subarray-Sum-With-Length-Divisible-by-K/Solution.go b/leetcode/3301-3400/3381.Maximum-Subarray-Sum-With-Length-Divisible-by-K/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3381.Maximum-Subarray-Sum-With-Length-Divisible-by-K/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3381.Maximum-Subarray-Sum-With-Length-Divisible-by-K/Solution_test.go b/leetcode/3301-3400/3381.Maximum-Subarray-Sum-With-Length-Divisible-by-K/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3381.Maximum-Subarray-Sum-With-Length-Divisible-by-K/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3382.Maximum-Area-Rectangle-With-Point-Constraints-II/README.md b/leetcode/3301-3400/3382.Maximum-Area-Rectangle-With-Point-Constraints-II/README.md
new file mode 100755
index 000000000..da4eae100
--- /dev/null
+++ b/leetcode/3301-3400/3382.Maximum-Area-Rectangle-With-Point-Constraints-II/README.md
@@ -0,0 +1,32 @@
+# [3382.Maximum Area Rectangle With Point Constraints II][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Maximum Area Rectangle With Point Constraints II
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/maximum-area-rectangle-with-point-constraints-ii/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3382.Maximum-Area-Rectangle-With-Point-Constraints-II/Solution.go b/leetcode/3301-3400/3382.Maximum-Area-Rectangle-With-Point-Constraints-II/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3382.Maximum-Area-Rectangle-With-Point-Constraints-II/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3382.Maximum-Area-Rectangle-With-Point-Constraints-II/Solution_test.go b/leetcode/3301-3400/3382.Maximum-Area-Rectangle-With-Point-Constraints-II/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3382.Maximum-Area-Rectangle-With-Point-Constraints-II/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3386.Button-with-Longest-Push-Time/README.md b/leetcode/3301-3400/3386.Button-with-Longest-Push-Time/README.md
new file mode 100755
index 000000000..0a4a748a3
--- /dev/null
+++ b/leetcode/3301-3400/3386.Button-with-Longest-Push-Time/README.md
@@ -0,0 +1,32 @@
+# [3386.Button with Longest Push Time][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Button with Longest Push Time
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/button-with-longest-push-time/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3386.Button-with-Longest-Push-Time/Solution.go b/leetcode/3301-3400/3386.Button-with-Longest-Push-Time/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3386.Button-with-Longest-Push-Time/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3386.Button-with-Longest-Push-Time/Solution_test.go b/leetcode/3301-3400/3386.Button-with-Longest-Push-Time/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3386.Button-with-Longest-Push-Time/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3387.Maximize-Amount-After-Two-Days-of-Conversions/README.md b/leetcode/3301-3400/3387.Maximize-Amount-After-Two-Days-of-Conversions/README.md
new file mode 100755
index 000000000..536cb7d77
--- /dev/null
+++ b/leetcode/3301-3400/3387.Maximize-Amount-After-Two-Days-of-Conversions/README.md
@@ -0,0 +1,32 @@
+# [3387.Maximize Amount After Two Days of Conversions][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Maximize Amount After Two Days of Conversions
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/maximize-amount-after-two-days-of-conversions/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3387.Maximize-Amount-After-Two-Days-of-Conversions/Solution.go b/leetcode/3301-3400/3387.Maximize-Amount-After-Two-Days-of-Conversions/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3387.Maximize-Amount-After-Two-Days-of-Conversions/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3387.Maximize-Amount-After-Two-Days-of-Conversions/Solution_test.go b/leetcode/3301-3400/3387.Maximize-Amount-After-Two-Days-of-Conversions/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3387.Maximize-Amount-After-Two-Days-of-Conversions/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3388.Count-Beautiful-Splits-in-an-Array/README.md b/leetcode/3301-3400/3388.Count-Beautiful-Splits-in-an-Array/README.md
new file mode 100755
index 000000000..b6d3b8508
--- /dev/null
+++ b/leetcode/3301-3400/3388.Count-Beautiful-Splits-in-an-Array/README.md
@@ -0,0 +1,32 @@
+# [3388.Count Beautiful Splits in an Array][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Count Beautiful Splits in an Array
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/count-beautiful-splits-in-an-array/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3388.Count-Beautiful-Splits-in-an-Array/Solution.go b/leetcode/3301-3400/3388.Count-Beautiful-Splits-in-an-Array/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3388.Count-Beautiful-Splits-in-an-Array/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3388.Count-Beautiful-Splits-in-an-Array/Solution_test.go b/leetcode/3301-3400/3388.Count-Beautiful-Splits-in-an-Array/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3388.Count-Beautiful-Splits-in-an-Array/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3389.Minimum-Operations-to-Make-Character-Frequencies-Equal/README.md b/leetcode/3301-3400/3389.Minimum-Operations-to-Make-Character-Frequencies-Equal/README.md
new file mode 100755
index 000000000..8817d6601
--- /dev/null
+++ b/leetcode/3301-3400/3389.Minimum-Operations-to-Make-Character-Frequencies-Equal/README.md
@@ -0,0 +1,32 @@
+# [3389.Minimum Operations to Make Character Frequencies Equal][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Minimum Operations to Make Character Frequencies Equal
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/minimum-operations-to-make-character-frequencies-equal/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3389.Minimum-Operations-to-Make-Character-Frequencies-Equal/Solution.go b/leetcode/3301-3400/3389.Minimum-Operations-to-Make-Character-Frequencies-Equal/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3389.Minimum-Operations-to-Make-Character-Frequencies-Equal/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3389.Minimum-Operations-to-Make-Character-Frequencies-Equal/Solution_test.go b/leetcode/3301-3400/3389.Minimum-Operations-to-Make-Character-Frequencies-Equal/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3389.Minimum-Operations-to-Make-Character-Frequencies-Equal/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3392.Count-Subarrays-of-Length-Three-With-a-Condition/README.md b/leetcode/3301-3400/3392.Count-Subarrays-of-Length-Three-With-a-Condition/README.md
new file mode 100755
index 000000000..c4ee87319
--- /dev/null
+++ b/leetcode/3301-3400/3392.Count-Subarrays-of-Length-Three-With-a-Condition/README.md
@@ -0,0 +1,32 @@
+# [3392.Count Subarrays of Length Three With a Condition][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Count Subarrays of Length Three With a Condition
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/count-subarrays-of-length-three-with-a-condition/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3392.Count-Subarrays-of-Length-Three-With-a-Condition/Solution.go b/leetcode/3301-3400/3392.Count-Subarrays-of-Length-Three-With-a-Condition/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3392.Count-Subarrays-of-Length-Three-With-a-Condition/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3392.Count-Subarrays-of-Length-Three-With-a-Condition/Solution_test.go b/leetcode/3301-3400/3392.Count-Subarrays-of-Length-Three-With-a-Condition/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3392.Count-Subarrays-of-Length-Three-With-a-Condition/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3393.Count-Paths-With-the-Given-XOR-Value/README.md b/leetcode/3301-3400/3393.Count-Paths-With-the-Given-XOR-Value/README.md
new file mode 100755
index 000000000..ee6e0e6c2
--- /dev/null
+++ b/leetcode/3301-3400/3393.Count-Paths-With-the-Given-XOR-Value/README.md
@@ -0,0 +1,32 @@
+# [3393.Count Paths With the Given XOR Value][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Count Paths With the Given XOR Value
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/count-paths-with-the-given-xor-value/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3393.Count-Paths-With-the-Given-XOR-Value/Solution.go b/leetcode/3301-3400/3393.Count-Paths-With-the-Given-XOR-Value/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3393.Count-Paths-With-the-Given-XOR-Value/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3393.Count-Paths-With-the-Given-XOR-Value/Solution_test.go b/leetcode/3301-3400/3393.Count-Paths-With-the-Given-XOR-Value/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3393.Count-Paths-With-the-Given-XOR-Value/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3394.Check-if-Grid-can-be-Cut-into-Sections/README.md b/leetcode/3301-3400/3394.Check-if-Grid-can-be-Cut-into-Sections/README.md
new file mode 100755
index 000000000..4e2deeff2
--- /dev/null
+++ b/leetcode/3301-3400/3394.Check-if-Grid-can-be-Cut-into-Sections/README.md
@@ -0,0 +1,32 @@
+# [3394.Check if Grid can be Cut into Sections][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Check if Grid can be Cut into Sections
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/check-if-grid-can-be-cut-into-sections/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3394.Check-if-Grid-can-be-Cut-into-Sections/Solution.go b/leetcode/3301-3400/3394.Check-if-Grid-can-be-Cut-into-Sections/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3394.Check-if-Grid-can-be-Cut-into-Sections/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3394.Check-if-Grid-can-be-Cut-into-Sections/Solution_test.go b/leetcode/3301-3400/3394.Check-if-Grid-can-be-Cut-into-Sections/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3394.Check-if-Grid-can-be-Cut-into-Sections/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3395.Subsequences-with-a-Unique-Middle-Mode-I/README.md b/leetcode/3301-3400/3395.Subsequences-with-a-Unique-Middle-Mode-I/README.md
new file mode 100755
index 000000000..5b7a9ee14
--- /dev/null
+++ b/leetcode/3301-3400/3395.Subsequences-with-a-Unique-Middle-Mode-I/README.md
@@ -0,0 +1,32 @@
+# [3395.Subsequences with a Unique Middle Mode I][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Subsequences with a Unique Middle Mode I
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/subsequences-with-a-unique-middle-mode-i/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3395.Subsequences-with-a-Unique-Middle-Mode-I/Solution.go b/leetcode/3301-3400/3395.Subsequences-with-a-Unique-Middle-Mode-I/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3395.Subsequences-with-a-Unique-Middle-Mode-I/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3395.Subsequences-with-a-Unique-Middle-Mode-I/Solution_test.go b/leetcode/3301-3400/3395.Subsequences-with-a-Unique-Middle-Mode-I/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3395.Subsequences-with-a-Unique-Middle-Mode-I/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3396.Minimum-Number-of-Operations-to-Make-Elements-in-Array-Distinct/README.md b/leetcode/3301-3400/3396.Minimum-Number-of-Operations-to-Make-Elements-in-Array-Distinct/README.md
new file mode 100755
index 000000000..9a137df67
--- /dev/null
+++ b/leetcode/3301-3400/3396.Minimum-Number-of-Operations-to-Make-Elements-in-Array-Distinct/README.md
@@ -0,0 +1,32 @@
+# [3396.Minimum Number of Operations to Make Elements in Array Distinct][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Minimum Number of Operations to Make Elements in Array Distinct
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/minimum-number-of-operations-to-make-elements-in-array-distinct/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3396.Minimum-Number-of-Operations-to-Make-Elements-in-Array-Distinct/Solution.go b/leetcode/3301-3400/3396.Minimum-Number-of-Operations-to-Make-Elements-in-Array-Distinct/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3396.Minimum-Number-of-Operations-to-Make-Elements-in-Array-Distinct/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3396.Minimum-Number-of-Operations-to-Make-Elements-in-Array-Distinct/Solution_test.go b/leetcode/3301-3400/3396.Minimum-Number-of-Operations-to-Make-Elements-in-Array-Distinct/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3396.Minimum-Number-of-Operations-to-Make-Elements-in-Array-Distinct/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3397.Maximum-Number-of-Distinct-Elements-After-Operations/README.md b/leetcode/3301-3400/3397.Maximum-Number-of-Distinct-Elements-After-Operations/README.md
new file mode 100755
index 000000000..2f32e8de5
--- /dev/null
+++ b/leetcode/3301-3400/3397.Maximum-Number-of-Distinct-Elements-After-Operations/README.md
@@ -0,0 +1,32 @@
+# [3397.Maximum Number of Distinct Elements After Operations][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Maximum Number of Distinct Elements After Operations
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/maximum-number-of-distinct-elements-after-operations/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3397.Maximum-Number-of-Distinct-Elements-After-Operations/Solution.go b/leetcode/3301-3400/3397.Maximum-Number-of-Distinct-Elements-After-Operations/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3397.Maximum-Number-of-Distinct-Elements-After-Operations/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3397.Maximum-Number-of-Distinct-Elements-After-Operations/Solution_test.go b/leetcode/3301-3400/3397.Maximum-Number-of-Distinct-Elements-After-Operations/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3397.Maximum-Number-of-Distinct-Elements-After-Operations/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3398.Smallest-Substring-With-Identical-Characters-I/README.md b/leetcode/3301-3400/3398.Smallest-Substring-With-Identical-Characters-I/README.md
new file mode 100755
index 000000000..d0c06b2dd
--- /dev/null
+++ b/leetcode/3301-3400/3398.Smallest-Substring-With-Identical-Characters-I/README.md
@@ -0,0 +1,32 @@
+# [3398.Smallest Substring With Identical Characters I][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Smallest Substring With Identical Characters I
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/smallest-substring-with-identical-characters-i/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3398.Smallest-Substring-With-Identical-Characters-I/Solution.go b/leetcode/3301-3400/3398.Smallest-Substring-With-Identical-Characters-I/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3398.Smallest-Substring-With-Identical-Characters-I/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3398.Smallest-Substring-With-Identical-Characters-I/Solution_test.go b/leetcode/3301-3400/3398.Smallest-Substring-With-Identical-Characters-I/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3398.Smallest-Substring-With-Identical-Characters-I/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}
diff --git a/leetcode/3301-3400/3399.Smallest-Substring-With-Identical-Characters-II/README.md b/leetcode/3301-3400/3399.Smallest-Substring-With-Identical-Characters-II/README.md
new file mode 100755
index 000000000..28bcae4f7
--- /dev/null
+++ b/leetcode/3301-3400/3399.Smallest-Substring-With-Identical-Characters-II/README.md
@@ -0,0 +1,32 @@
+# [3399.Smallest Substring With Identical Characters II][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
+
+## Description
+
+**Example 1:**
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+## 题意
+> ...
+
+## 题解
+
+### 思路1
+> ...
+Smallest Substring With Identical Characters II
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/smallest-substring-with-identical-characters-ii/
+[me]: https://github.com/kylesliu/awesome-golang-algorithm
diff --git a/leetcode/3301-3400/3399.Smallest-Substring-With-Identical-Characters-II/Solution.go b/leetcode/3301-3400/3399.Smallest-Substring-With-Identical-Characters-II/Solution.go
new file mode 100644
index 000000000..d115ccf5e
--- /dev/null
+++ b/leetcode/3301-3400/3399.Smallest-Substring-With-Identical-Characters-II/Solution.go
@@ -0,0 +1,5 @@
+package Solution
+
+func Solution(x bool) bool {
+	return x
+}
diff --git a/leetcode/3301-3400/3399.Smallest-Substring-With-Identical-Characters-II/Solution_test.go b/leetcode/3301-3400/3399.Smallest-Substring-With-Identical-Characters-II/Solution_test.go
new file mode 100644
index 000000000..14ff50eb4
--- /dev/null
+++ b/leetcode/3301-3400/3399.Smallest-Substring-With-Identical-Characters-II/Solution_test.go
@@ -0,0 +1,39 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs bool
+		expect bool
+	}{
+		{"TestCase", true, true},
+		{"TestCase", true, true},
+		{"TestCase", false, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+}
+
+//	使用案列
+func ExampleSolution() {
+}