添加 problem 978

Algorithms/0498. Diagonal Traverse/498. Diagonal Traverse.go

@@ -5,15 +5,12 @@ func findDiagonalOrder1(matrix [][]int) []int {
 	if matrix == nil || len(matrix) == 0 || len(matrix[0]) == 0 {
 		return nil
 	}
-	row := len(matrix)
-	col := len(matrix[0])
-	dir := [2][2]int{
+	row, col, dir, i, x, y, d := len(matrix), len(matrix[0]), [2][2]int{
 		{-1, 1},
 		{1, -1},
-	}
+	}, 0, 0, 0, 0
 	total := row * col
 	res := make([]int, total)
-	var i, x, y, d int
 	for i < total {
 		for x >= 0 && x < row && y >= 0 && y < col {
 			res[i] = matrix[x][y]

Algorithms/0509. Fibonacci Number/README.md

@@ -1,9 +1,5 @@
-# 509. Fibonacci Number
+# [509. Fibonacci Number](https://leetcode.com/problems/fibonacci-number/)
 
-Created Time: Aug 24, 2019 2:52 PM
-Difficulty: Easy
-Link: https://leetcode.com/problems/fibonacci-number/
-Tags: Array,Dynamic Programming,Math,Recursive
 
 ## 题目:
 

Algorithms/0978. Longest Turbulent Subarray/978. Longest Turbulent Subarray.go

@@ -0,0 +1,43 @@
+package leetcode
+
+// 解法一 模拟法
+func maxTurbulenceSize(A []int) int {
+	inc, dec := 1, 1
+	maxLen := min(1, len(A))
+	for i := 1; i < len(A); i++ {
+		if A[i-1] < A[i] {
+			inc = dec + 1
+			dec = 1
+		} else if A[i-1] > A[i] {
+			dec = inc + 1
+			inc = 1
+		} else {
+			inc = 1
+			dec = 1
+		}
+		maxLen = max(maxLen, max(inc, dec))
+	}
+	return maxLen
+}
+
+// 解法二 滑动窗口
+func maxTurbulenceSize1(A []int) int {
+	if len(A) == 1 {
+		return 1
+	}
+	// flag > 0 代表下一个数要大于前一个数，flag < 0 代表下一个数要小于前一个数
+	res, left, right, flag, lastNum := 0, 0, 0, A[1]-A[0], A[0]
+	for left < len(A) {
+		if right < len(A)-1 && ((A[right+1] > lastNum && flag > 0) || (A[right+1] < lastNum && flag < 0) || (right == left)) {
+			right++
+			flag = lastNum - A[right]
+			lastNum = A[right]
+		} else {
+			if right != left && flag != 0 {
+				res = max(res, right-left+1)
+			}
+			left++
+		}
+	}
+	return max(res, 1)
+}

Algorithms/0978. Longest Turbulent Subarray/978. Longest Turbulent Subarray_test.go

@@ -0,0 +1,62 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+type question978 struct {
+	para978
+	ans978
+}
+
+// para 是参数
+// one 代表第一个参数
+type para978 struct {
+	one []int
+}
+
+// ans 是答案
+// one 代表第一个答案
+type ans978 struct {
+	one int
+}
+
+func Test_Problem978(t *testing.T) {
+
+	qs := []question978{
+
+		question978{
+			para978{[]int{0, 1, 1, 0, 1, 0, 1, 1, 0, 0}},
+			ans978{5},
+		},
+
+		question978{
+			para978{[]int{9, 9}},
+			ans978{1},
+		},
+
+		question978{
+			para978{[]int{9, 4, 2, 10, 7, 8, 8, 1, 9}},
+			ans978{5},
+		},
+
+		question978{
+			para978{[]int{4, 8, 12, 16}},
+			ans978{2},
+		},
+
+		question978{
+			para978{[]int{100}},
+			ans978{1},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 978------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans978, q.para978
+		fmt.Printf("【input】:%v       【output】:%v\n", p, maxTurbulenceSize(p.one))
+	}
+	fmt.Printf("\n\n\n")
+}

Algorithms/0978. Longest Turbulent Subarray/README.md

@@ -0,0 +1,58 @@
+# [978. Longest Turbulent Subarray](https://leetcode.com/problems/longest-turbulent-subarray/)
+
+## 题目:
+
+A subarray `A[i], A[i+1], ..., A[j]` of `A` is said to be *turbulent* if and only if:
+
+- For `i <= k < j`, `A[k] > A[k+1]` when `k` is odd, and `A[k] < A[k+1]` when `k` is even;
+- **OR**, for `i <= k < j`, `A[k] > A[k+1]` when `k` is even, and `A[k] < A[k+1]` when `k` is odd.
+
+That is, the subarray is turbulent if the comparison sign flips between each adjacent pair of elements in the subarray.
+
+Return the **length** of a maximum size turbulent subarray of A.
+
+**Example 1:**
+
+    Input: [9,4,2,10,7,8,8,1,9]
+    Output: 5
+    Explanation: (A[1] > A[2] < A[3] > A[4] < A[5])
+
+**Example 2:**
+
+    Input: [4,8,12,16]
+    Output: 2
+
+**Example 3:**
+
+    Input: [100]
+    Output: 1
+
+**Note:**
+
+1. `1 <= A.length <= 40000`
+2. `0 <= A[i] <= 10^9`
+
+
+## 题目大意
+
+
+当 A 的子数组 A[i], A[i+1], ..., A[j] 满足下列条件时，我们称其为湍流子数组：
+
+若 i <= k < j，当 k 为奇数时， A[k] > A[k+1]，且当 k 为偶数时，A[k] < A[k+1]；
+或 若 i <= k < j，当 k 为偶数时，A[k] > A[k+1] ，且当 k 为奇数时， A[k] < A[k+1]。
+也就是说，如果比较符号在子数组中的每个相邻元素对之间翻转，则该子数组是湍流子数组。
+
+返回 A 的最大湍流子数组的长度。
+
+提示：
+
+- 1 <= A.length <= 40000
+- 0 <= A[i] <= 10^9
+
+
+
+## 解题思路
+
+
+- 给出一个数组，要求找出“摆动数组”的最大长度。所谓“摆动数组”的意思是，元素一大一小间隔的。
+- 这一题可以用滑动窗口来解答。用一个变量记住下次出现的元素需要大于还是需要小于前一个元素。也可以用模拟的方法，用两个变量分别记录上升和下降数字的长度。一旦元素相等了，上升和下降数字长度都置为 1，其他时候按照上升和下降的关系增加队列长度即可，最后输出动态维护的最长长度。