Add solution 413、1249

leetcode/0413.Arithmetic-Slices/413. Arithmetic Slices.go

@@ -0,0 +1,17 @@
+package leetcode
+
+func numberOfArithmeticSlices(A []int) int {
+	if len(A) < 3 {
+		return 0
+	}
+	res, dp := 0, 0
+	for i := 1; i < len(A)-1; i++ {
+		if A[i+1]-A[i] == A[i]-A[i-1] {
+			dp++
+			res += dp
+		} else {
+			dp = 0
+		}
+	}
+	return res
+}

leetcode/0413.Arithmetic-Slices/413. Arithmetic Slices_test.go

@@ -0,0 +1,52 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+type question413 struct {
+	para413
+	ans413
+}
+
+// para 是参数
+// one 代表第一个参数
+type para413 struct {
+	A []int
+}
+
+// ans 是答案
+// one 代表第一个答案
+type ans413 struct {
+	one int
+}
+
+func Test_Problem413(t *testing.T) {
+
+	qs := []question413{
+
+		{
+			para413{[]int{1, 2, 3, 4}},
+			ans413{3},
+		},
+
+		{
+			para413{[]int{1, 2, 3, 4, 9}},
+			ans413{3},
+		},
+
+		{
+			para413{[]int{1, 2, 3, 4, 5, 6, 7}},
+			ans413{3},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 413------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans413, q.para413
+		fmt.Printf("【input】:%v       【output】:%v\n", p, numberOfArithmeticSlices(p.A))
+	}
+	fmt.Printf("\n\n\n")
+}

leetcode/0413.Arithmetic-Slices/README.md

@@ -0,0 +1,64 @@
+# [413. Arithmetic Slices](https://leetcode.com/problems/arithmetic-slices/)
+
+
+## 题目
+
+A sequence of numbers is called arithmetic if it consists of at least three elements and if the difference between any two consecutive elements is the same.
+
+For example, these are arithmetic sequences:
+
+```
+1, 3, 5, 7, 9
+7, 7, 7, 7
+3, -1, -5, -9
+```
+
+The following sequence is not arithmetic.
+
+```
+1, 1, 2, 5, 7
+```
+
+A zero-indexed array A consisting of N numbers is given. A slice of that array is any pair of integers (P, Q) such that 0 <= P < Q < N.
+
+A slice (P, Q) of the array A is called arithmetic if the sequence:A[P], A[P + 1], ..., A[Q - 1], A[Q] is arithmetic. In particular, this means that P + 1 < Q.
+
+The function should return the number of arithmetic slices in the array A.
+
+**Example:**
+
+```
+A = [1, 2, 3, 4]
+
+return: 3, for 3 arithmetic slices in A: [1, 2, 3], [2, 3, 4] and [1, 2, 3, 4] itself.
+```
+
+## 题目大意
+
+数组 A 包含 N 个数，且索引从0开始。数组 A 的一个子数组划分为数组 (P, Q)，P 与 Q 是整数且满足 0<=P<Q<N 。如果满足以下条件，则称子数组(P, Q)为等差数组：元素 A[P], A[p + 1], ..., A[Q - 1], A[Q] 是等差的。并且 P + 1 < Q 。函数要返回数组 A 中所有为等差数组的子数组个数。
+
+## 解题思路
+
+- 由题目给出的定义，至少 3 个数字以上的等差数列才满足题意。连续 k 个连续等差的元素，包含的子等差数列是底层的，1，2，3…… k。所以每判断一组 3 个连续的数列，只需要用一个变量累加前面已经有多少个满足题意的连续元素，只要满足题意的等差数列就加上这个累加值。一旦不满足等差的条件，累加值置 0。如此循环一次即可找到题目要求的答案。
+
+## 代码
+
+```go
+package leetcode
+
+func numberOfArithmeticSlices(A []int) int {
+	if len(A) < 3 {
+		return 0
+	}
+	res, dp := 0, 0
+	for i := 1; i < len(A)-1; i++ {
+		if A[i+1]-A[i] == A[i]-A[i-1] {
+			dp++
+			res += dp
+		} else {
+			dp = 0
+		}
+	}
+	return res
+}
+```

leetcode/1249.Minimum-Remove-to-Make-Valid-Parentheses/1249. Minimum Remove to Make Valid Parentheses.go

@@ -0,0 +1,23 @@
+package leetcode
+
+func minRemoveToMakeValid(s string) string {
+	res, opens := []byte{}, 0
+	for i := 0; i < len(s); i++ {
+		if s[i] == '(' {
+			opens++
+		} else if s[i] == ')' {
+			if opens == 0 {
+				continue
+			}
+			opens--
+		}
+		res = append(res, s[i])
+	}
+	for i := len(res) - 1; i >= 0; i-- {
+		if res[i] == '(' && opens > 0 {
+			opens--
+			res = append(res[:i], res[i+1:]...)
+		}
+	}
+	return string(res)
+}

leetcode/1249.Minimum-Remove-to-Make-Valid-Parentheses/1249. Minimum Remove to Make Valid Parentheses_test.go

@@ -0,0 +1,57 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+type question1249 struct {
+	para1249
+	ans1249
+}
+
+// para 是参数
+// one 代表第一个参数
+type para1249 struct {
+	s string
+}
+
+// ans 是答案
+// one 代表第一个答案
+type ans1249 struct {
+	one string
+}
+
+func Test_Problem1249(t *testing.T) {
+
+	qs := []question1249{
+
+		{
+			para1249{"lee(t(c)o)de)"},
+			ans1249{"lee(t(c)o)de"},
+		},
+
+		{
+			para1249{"a)b(c)d"},
+			ans1249{"ab(c)d"},
+		},
+
+		{
+			para1249{"))(("},
+			ans1249{""},
+		},
+
+		{
+			para1249{"(a(b(c)d)"},
+			ans1249{"a(b(c)d)"},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 1249------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans1249, q.para1249
+		fmt.Printf("【input】:%v       【output】:%v\n", p, minRemoveToMakeValid(p.s))
+	}
+	fmt.Printf("\n\n\n")
+}

leetcode/1249.Minimum-Remove-to-Make-Valid-Parentheses/README.md

@@ -0,0 +1,95 @@
+# [1249. Minimum Remove to Make Valid Parentheses](https://leetcode.com/problems/minimum-remove-to-make-valid-parentheses/)
+
+
+## 题目
+
+Given a string s of `'('` , `')'` and lowercase English characters.
+
+Your task is to remove the minimum number of parentheses ( `'('` or `')'`, in any positions ) so that the resulting *parentheses string* is valid and return **any** valid string.
+
+Formally, a *parentheses string* is valid if and only if:
+
+- It is the empty string, contains only lowercase characters, or
+- It can be written as `AB` (`A` concatenated with `B`), where `A` and `B` are valid strings, or
+- It can be written as `(A)`, where `A` is a valid string.
+
+**Example 1:**
+
+```
+Input: s = "lee(t(c)o)de)"
+Output: "lee(t(c)o)de"
+Explanation: "lee(t(co)de)" , "lee(t(c)ode)" would also be accepted.
+
+```
+
+**Example 2:**
+
+```
+Input: s = "a)b(c)d"
+Output: "ab(c)d"
+
+```
+
+**Example 3:**
+
+```
+Input: s = "))(("
+Output: ""
+Explanation: An empty string is also valid.
+
+```
+
+**Example 4:**
+
+```
+Input: s = "(a(b(c)d)"
+Output: "a(b(c)d)"
+
+```
+
+**Constraints:**
+
+- `1 <= s.length <= 10^5`
+- `s[i]` is one of `'('` , `')'` and lowercase English letters`.`
+
+## 题目大意
+
+给你一个由 '('、')' 和小写字母组成的字符串 s。你需要从字符串中删除最少数目的 '(' 或者 ')' （可以删除任意位置的括号)，使得剩下的「括号字符串」有效。请返回任意一个合法字符串。有效「括号字符串」应当符合以下 任意一条 要求：
+
+- 空字符串或只包含小写字母的字符串
+- 可以被写作 AB（A 连接 B）的字符串，其中 A 和 B 都是有效「括号字符串」
+- 可以被写作 (A) 的字符串，其中 A 是一个有效的「括号字符串」
+
+## 解题思路
+
+- 最容易想到的思路是利用栈判断括号匹配是否有效。这个思路可行，时间复杂度也只是 O(n)。
+- 不用栈，可以 2 次循环遍历，正向遍历一次，标记出多余的 `'('` ，逆向遍历一次，再标记出多余的 `')'`，最后将所有这些标记多余的字符删掉即可。这种解法写出来的代码也很简洁，时间复杂度也是 O(n)。
+- 针对上面的解法再改进一点。正向遍历的时候不仅标记出多余的 `'('`，还可以顺手把多余的 `')'` 删除。这样只用循环一次。最后再删除掉多余的 `'('` 即可。时间复杂度还是 O(n)。
+
+## 代码
+
+```go
+package leetcode
+
+func minRemoveToMakeValid(s string) string {
+	res, opens := []byte{}, 0
+	for i := 0; i < len(s); i++ {
+		if s[i] == '(' {
+			opens++
+		} else if s[i] == ')' {
+			if opens == 0 {
+				continue
+			}
+			opens--
+		}
+		res = append(res, s[i])
+	}
+	for i := len(res) - 1; i >= 0; i-- {
+		if res[i] == '(' && opens > 0 {
+			opens--
+			res = append(res[:i], res[i+1:]...)
+		}
+	}
+	return string(res)
+}
+```