[E:57/533, M:56/974, H:6/387] add No: 376 Wiggle Subsequence

Author: gladmo

questions/serial/中等/376/README.md

@@ -0,0 +1,29 @@
+## [摆动序列](https://leetcode-cn.com/problems/wiggle-subsequence/)
+
+如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为**摆动序列。**第一个差（如果存在的话）可能是正数或负数。少于两个元素的序列也是摆动序列。
+
+例如， `[1,7,4,9,2,5]` 是一个摆动序列，因为差值 `(6,-3,5,-7,3)` 是正负交替出现的。相反, `[1,4,7,2,5]` 和 `[1,7,4,5,5]` 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。
+
+给定一个整数序列，返回作为摆动序列的最长子序列的长度。 通过从原始序列中删除一些（也可以不删除）元素来获得子序列，剩下的元素保持其原始顺序。
+
+**示例 1:**
+
+`**输入:** [1,7,4,9,2,5]
+**输出:** 6 
+**解释:** 整个序列均为摆动序列。
+`
+
+**示例 2:**
+
+`**输入:** [1,17,5,10,13,15,10,5,16,8]
+**输出:** 7
+**解释:** 这个序列包含几个长度为 7 摆动序列，其中一个可为[1,17,10,13,10,16,8]。`
+
+**示例 3:**
+
+`**输入:** [1,2,3,4,5,6,7,8,9]
+**输出:** 2`
+
+**进阶:**  
+
+你能否用 O(_n_) 时间复杂度完成此题?

questions/serial/中等/376/golang/main.go

@@ -0,0 +1,82 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"reflect"
+	"time"
+
+	"github.com/gladmo/leetcode/leet"
+	"github.com/gladmo/leetcode/questions/serial/中等/376/golang/solution"
+)
+
+func main() {
+
+	tests := []struct {
+		name  string
+		input []int
+		want  int
+	}{
+		{
+			name:  "test-[1,7,4,9,2,5]",
+			input: []int{1, 7, 4, 9, 2, 5},
+			want:  6,
+		},
+		{
+			name:  "test-[1,7]",
+			input: []int{1, 7},
+			want:  2,
+		},
+		{
+			name:  "test-[1]",
+			input: []int{1},
+			want:  1,
+		},
+		{
+			name:  "test-[]",
+			input: []int{},
+			want:  0,
+		},
+		{
+			name:  "test-[1,17,5,10,13,15,10,5,16,8]",
+			input: []int{1, 17, 5, 10, 13, 15, 10, 5, 16, 8},
+			want:  7,
+		},
+		{
+			name:  "test-[1,2,3,4,5,6,7,8,9]",
+			input: []int{1, 2, 3, 4, 5, 6, 7, 8, 9},
+			want:  2,
+		},
+		{
+			name:  "test-[5,5,5,5,5,5]",
+			input: []int{5, 5, 5, 5, 5, 5},
+			want:  1,
+		},
+	}
+
+	testLog := leet.NewTestLog(len(tests))
+	defer testLog.Render()
+
+	timeoutDuration := time.Second * 2
+
+	for idx, test := range tests {
+		// 超时检测
+		got := test.want
+		timeout := leet.Timeout(timeoutDuration, func(ctx context.Context, cancel context.CancelFunc) {
+			got = solution.Export(test.input)
+			cancel()
+		})
+
+		if timeout {
+			testLog.Fail(idx+1, test.name, "timeout")
+			continue
+		}
+
+		if !reflect.DeepEqual(test.want, got) {
+			testLog.Fail(idx+1, test.name, fmt.Sprintf("want: %v, got %v.", test.want, got))
+			continue
+		}
+
+		testLog.Pass(idx+1, test.name)
+	}
+}

questions/serial/中等/376/golang/solution/wiggle-subsequence.go

@@ -0,0 +1,30 @@
+package solution
+
+import (
+	"fmt"
+	"os"
+	"runtime/debug"
+)
+
+func Export(nums []int) int {
+	defer func() {
+		if r := recover(); r != nil {
+			fmt.Println("Params: ", nums)
+			fmt.Println("Panic:", r)
+			fmt.Println()
+			debug.PrintStack()
+			os.Exit(0)
+		}
+	}()
+
+	return wiggleMaxLength(nums)
+}
+
+/****************************************************/
+/******** 以下为 Leetcode 示例部分（提交PR请还原） *******/
+/******** 使用 (./leetcode clear) 初始化所有问题 *******/
+/****************************************************/
+
+func wiggleMaxLength(nums []int) int {
+
+}

questions/serial/中等/376/golang/solution/wiggle-subsequence.go.clean

@@ -0,0 +1,30 @@
+package solution
+
+import (
+	"fmt"
+	"os"
+	"runtime/debug"
+)
+
+func Export(nums []int) int {
+	defer func() {
+		if r := recover(); r != nil {
+			fmt.Println("Params: ", nums)
+			fmt.Println("Panic:", r)
+			fmt.Println()
+			debug.PrintStack()
+			os.Exit(0)
+		}
+	}()
+
+	return wiggleMaxLength(nums)
+}
+
+/****************************************************/
+/******** 以下为 Leetcode 示例部分（提交PR请还原） *******/
+/******** 使用 (./leetcode clear) 初始化所有问题 *******/
+/****************************************************/
+
+func wiggleMaxLength(nums []int) int {
+
+}

questions/store.json

@@ -0,0 +1,29 @@
+## [摆动序列](https://leetcode-cn.com/problems/wiggle-subsequence/)
+
+如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为**摆动序列。**第一个差（如果存在的话）可能是正数或负数。少于两个元素的序列也是摆动序列。
+
+例如， `[1,7,4,9,2,5]` 是一个摆动序列，因为差值 `(6,-3,5,-7,3)` 是正负交替出现的。相反, `[1,4,7,2,5]` 和 `[1,7,4,5,5]` 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。
+
+给定一个整数序列，返回作为摆动序列的最长子序列的长度。 通过从原始序列中删除一些（也可以不删除）元素来获得子序列，剩下的元素保持其原始顺序。
+
+**示例 1:**
+
+`**输入:** [1,7,4,9,2,5]
+**输出:** 6 
+**解释:** 整个序列均为摆动序列。
+`
+
+**示例 2:**
+
+`**输入:** [1,17,5,10,13,15,10,5,16,8]
+**输出:** 7
+**解释:** 这个序列包含几个长度为 7 摆动序列，其中一个可为[1,17,10,13,10,16,8]。`
+
+**示例 3:**
+
+`**输入:** [1,2,3,4,5,6,7,8,9]
+**输出:** 2`
+
+**进阶:**  
+
+你能否用 O(_n_) 时间复杂度完成此题?

questions/tags/动态规划/中等/wiggle-subsequence/README.md

@@ -0,0 +1,82 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"reflect"
+	"time"
+
+	"github.com/gladmo/leetcode/leet"
+	"github.com/gladmo/leetcode/questions/serial/中等/376/golang/solution"
+)
+
+func main() {
+
+	tests := []struct {
+		name  string
+		input []int
+		want  int
+	}{
+		{
+			name:  "test-[1,7,4,9,2,5]",
+			input: []int{1, 7, 4, 9, 2, 5},
+			want:  6,
+		},
+		{
+			name:  "test-[1,7]",
+			input: []int{1, 7},
+			want:  2,
+		},
+		{
+			name:  "test-[1]",
+			input: []int{1},
+			want:  1,
+		},
+		{
+			name:  "test-[]",
+			input: []int{},
+			want:  0,
+		},
+		{
+			name:  "test-[1,17,5,10,13,15,10,5,16,8]",
+			input: []int{1, 17, 5, 10, 13, 15, 10, 5, 16, 8},
+			want:  7,
+		},
+		{
+			name:  "test-[1,2,3,4,5,6,7,8,9]",
+			input: []int{1, 2, 3, 4, 5, 6, 7, 8, 9},
+			want:  2,
+		},
+		{
+			name:  "test-[5,5,5,5,5,5]",
+			input: []int{5, 5, 5, 5, 5, 5},
+			want:  1,
+		},
+	}
+
+	testLog := leet.NewTestLog(len(tests))
+	defer testLog.Render()
+
+	timeoutDuration := time.Second * 2
+
+	for idx, test := range tests {
+		// 超时检测
+		got := test.want
+		timeout := leet.Timeout(timeoutDuration, func(ctx context.Context, cancel context.CancelFunc) {
+			got = solution.Export(test.input)
+			cancel()
+		})
+
+		if timeout {
+			testLog.Fail(idx+1, test.name, "timeout")
+			continue
+		}
+
+		if !reflect.DeepEqual(test.want, got) {
+			testLog.Fail(idx+1, test.name, fmt.Sprintf("want: %v, got %v.", test.want, got))
+			continue
+		}
+
+		testLog.Pass(idx+1, test.name)
+	}
+}

questions/tags/动态规划/中等/wiggle-subsequence/golang/main.go

@@ -0,0 +1,30 @@
+package solution
+
+import (
+	"fmt"
+	"os"
+	"runtime/debug"
+)
+
+func Export(nums []int) int {
+	defer func() {
+		if r := recover(); r != nil {
+			fmt.Println("Params: ", nums)
+			fmt.Println("Panic:", r)
+			fmt.Println()
+			debug.PrintStack()
+			os.Exit(0)
+		}
+	}()
+
+	return wiggleMaxLength(nums)
+}
+
+/****************************************************/
+/******** 以下为 Leetcode 示例部分（提交PR请还原） *******/
+/******** 使用 (./leetcode clear) 初始化所有问题 *******/
+/****************************************************/
+
+func wiggleMaxLength(nums []int) int {
+
+}

questions/tags/动态规划/中等/wiggle-subsequence/golang/solution/wiggle-subsequence.go

@@ -0,0 +1,30 @@
+package solution
+
+import (
+	"fmt"
+	"os"
+	"runtime/debug"
+)
+
+func Export(nums []int) int {
+	defer func() {
+		if r := recover(); r != nil {
+			fmt.Println("Params: ", nums)
+			fmt.Println("Panic:", r)
+			fmt.Println()
+			debug.PrintStack()
+			os.Exit(0)
+		}
+	}()
+
+	return wiggleMaxLength(nums)
+}
+
+/****************************************************/
+/******** 以下为 Leetcode 示例部分（提交PR请还原） *******/
+/******** 使用 (./leetcode clear) 初始化所有问题 *******/
+/****************************************************/
+
+func wiggleMaxLength(nums []int) int {
+
+}

questions/tags/动态规划/中等/wiggle-subsequence/golang/solution/wiggle-subsequence.go.clean

@@ -0,0 +1,29 @@
+## [摆动序列](https://leetcode-cn.com/problems/wiggle-subsequence/)
+
+如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为**摆动序列。**第一个差（如果存在的话）可能是正数或负数。少于两个元素的序列也是摆动序列。
+
+例如， `[1,7,4,9,2,5]` 是一个摆动序列，因为差值 `(6,-3,5,-7,3)` 是正负交替出现的。相反, `[1,4,7,2,5]` 和 `[1,7,4,5,5]` 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。
+
+给定一个整数序列，返回作为摆动序列的最长子序列的长度。 通过从原始序列中删除一些（也可以不删除）元素来获得子序列，剩下的元素保持其原始顺序。
+
+**示例 1:**
+
+`**输入:** [1,7,4,9,2,5]
+**输出:** 6 
+**解释:** 整个序列均为摆动序列。
+`
+
+**示例 2:**
+
+`**输入:** [1,17,5,10,13,15,10,5,16,8]
+**输出:** 7
+**解释:** 这个序列包含几个长度为 7 摆动序列，其中一个可为[1,17,10,13,10,16,8]。`
+
+**示例 3:**
+
+`**输入:** [1,2,3,4,5,6,7,8,9]
+**输出:** 2`
+
+**进阶:**  
+
+你能否用 O(_n_) 时间复杂度完成此题?