1. Add solution 1091、1614、1619、1624、1629、1636、1704

2. ctl strings.TrimSpace question.Title

leetcode/1629.Slowest-Key/1629. Slowest Key.go

@@ -0,0 +1,15 @@
+package leetcode
+
+func slowestKey(releaseTimes []int, keysPressed string) byte {
+	longestDuration, key := releaseTimes[0], keysPressed[0]
+	for i := 1; i < len(releaseTimes); i++ {
+		duration := releaseTimes[i] - releaseTimes[i-1]
+		if duration > longestDuration {
+			longestDuration = duration
+			key = keysPressed[i]
+		} else if duration == longestDuration && keysPressed[i] > key {
+			key = keysPressed[i]
+		}
+	}
+	return key
+}

leetcode/1629.Slowest-Key/1629. Slowest Key_test.go

@@ -0,0 +1,48 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+type question1629 struct {
+	para1629
+	ans1629
+}
+
+// para 是参数
+// one 代表第一个参数
+type para1629 struct {
+	releaseTimes []int
+	keysPressed  string
+}
+
+// ans 是答案
+// one 代表第一个答案
+type ans1629 struct {
+	one byte
+}
+
+func Test_Problem1629(t *testing.T) {
+
+	qs := []question1629{
+
+		{
+			para1629{[]int{9, 29, 49, 50}, "cbcd"},
+			ans1629{'c'},
+		},
+
+		{
+			para1629{[]int{12, 23, 36, 46, 62}, "spuda"},
+			ans1629{'a'},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 1629------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans1629, q.para1629
+		fmt.Printf("【input】:%v      【output】:%c      \n", p, slowestKey(p.releaseTimes, p.keysPressed))
+	}
+	fmt.Printf("\n\n\n")
+}

leetcode/1629.Slowest-Key/README.md

@@ -0,0 +1,83 @@
+# [1629. Slowest Key](https://leetcode.com/problems/slowest-key/)
+
+
+## 题目
+
+A newly designed keypad was tested, where a tester pressed a sequence of `n` keys, one at a time.
+
+You are given a string `keysPressed` of length `n`, where `keysPressed[i]` was the `ith` key pressed in the testing sequence, and a sorted list `releaseTimes`, where `releaseTimes[i]` was the time the `ith` key was released. Both arrays are **0-indexed**. The `0th` key was pressed at the time `0`, and every subsequent key was pressed at the **exact** time the previous key was released.
+
+The tester wants to know the key of the keypress that had the **longest duration**. The `ith` keypress had a **duration** of `releaseTimes[i] - releaseTimes[i - 1]`, and the `0th` keypress had a duration of `releaseTimes[0]`.
+
+Note that the same key could have been pressed multiple times during the test, and these multiple presses of the same key **may not** have had the same **duration**.
+
+*Return the key of the keypress that had the **longest duration**. If there are multiple such keypresses, return the lexicographically largest key of the keypresses.*
+
+**Example 1:**
+
+```
+Input: releaseTimes = [9,29,49,50], keysPressed = "cbcd"
+Output: "c"
+Explanation: The keypresses were as follows:
+Keypress for 'c' had a duration of 9 (pressed at time 0 and released at time 9).
+Keypress for 'b' had a duration of 29 - 9 = 20 (pressed at time 9 right after the release of the previous character and released at time 29).
+Keypress for 'c' had a duration of 49 - 29 = 20 (pressed at time 29 right after the release of the previous character and released at time 49).
+Keypress for 'd' had a duration of 50 - 49 = 1 (pressed at time 49 right after the release of the previous character and released at time 50).
+The longest of these was the keypress for 'b' and the second keypress for 'c', both with duration 20.
+'c' is lexicographically larger than 'b', so the answer is 'c'.
+```
+
+**Example 2:**
+
+```
+Input: releaseTimes = [12,23,36,46,62], keysPressed = "spuda"
+Output: "a"
+Explanation: The keypresses were as follows:
+Keypress for 's' had a duration of 12.
+Keypress for 'p' had a duration of 23 - 12 = 11.
+Keypress for 'u' had a duration of 36 - 23 = 13.
+Keypress for 'd' had a duration of 46 - 36 = 10.
+Keypress for 'a' had a duration of 62 - 46 = 16.
+The longest of these was the keypress for 'a' with duration 16.
+```
+
+**Constraints:**
+
+- `releaseTimes.length == n`
+- `keysPressed.length == n`
+- `2 <= n <= 1000`
+- `1 <= releaseTimes[i] <= 109`
+- `releaseTimes[i] < releaseTimes[i+1]`
+- `keysPressed` contains only lowercase English letters.
+
+## 题目大意
+
+LeetCode 设计了一款新式键盘，正在测试其可用性。测试人员将会点击一系列键（总计 n 个），每次一个。
+
+给你一个长度为 n 的字符串 keysPressed ，其中 keysPressed[i] 表示测试序列中第 i 个被按下的键。releaseTimes 是一个升序排列的列表，其中 releaseTimes[i] 表示松开第 i 个键的时间。字符串和数组的 下标都从 0 开始 。第 0 个键在时间为 0 时被按下，接下来每个键都 恰好 在前一个键松开时被按下。测试人员想要找出按键 持续时间最长 的键。第 i 次按键的持续时间为 releaseTimes[i] - releaseTimes[i - 1] ，第 0 次按键的持续时间为 releaseTimes[0] 。
+
+注意，测试期间，同一个键可以在不同时刻被多次按下，而每次的持续时间都可能不同。请返回按键 持续时间最长 的键，如果有多个这样的键，则返回 按字母顺序排列最大 的那个键。
+
+## 解题思路
+
+- 题干很长，不过还是简单题。循环扫描一遍数组，计算出每个按键的持续时间。动态更新按键最长时间的键。如果持续时间最长的有多个键，需要返回字母序最大的那一个键。
+
+## 代码
+
+```go
+package leetcode
+
+func slowestKey(releaseTimes []int, keysPressed string) byte {
+	longestDuration, key := releaseTimes[0], keysPressed[0]
+	for i := 1; i < len(releaseTimes); i++ {
+		duration := releaseTimes[i] - releaseTimes[i-1]
+		if duration > longestDuration {
+			longestDuration = duration
+			key = keysPressed[i]
+		} else if duration == longestDuration && keysPressed[i] > key {
+			key = keysPressed[i]
+		}
+	}
+	return key
+}
+```