Add solution 1662、1663、1664、1665

Author: halfrost

Diff for: leetcode/1662.Check-If-Two-String-Arrays-are-Equivalent/1662. Check If Two String Arrays are Equivalent.go

@@ -0,0 +1,12 @@
+package leetcode
+
+func arrayStringsAreEqual(word1 []string, word2 []string) bool {
+	str1, str2 := "", ""
+	for i := 0; i < len(word1); i++ {
+		str1 += word1[i]
+	}
+	for i := 0; i < len(word2); i++ {
+		str2 += word2[i]
+	}
+	return str1 == str2
+}

Diff for: leetcode/1662.Check-If-Two-String-Arrays-are-Equivalent/1662. Check If Two String Arrays are Equivalent_test.go

@@ -0,0 +1,53 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+type question1662 struct {
+	para1662
+	ans1662
+}
+
+// para 是参数
+// one 代表第一个参数
+type para1662 struct {
+	word1 []string
+	word2 []string
+}
+
+// ans 是答案
+// one 代表第一个答案
+type ans1662 struct {
+	one bool
+}
+
+func Test_Problem1662(t *testing.T) {
+
+	qs := []question1662{
+
+		{
+			para1662{[]string{"ab", "c"}, []string{"a", "bc"}},
+			ans1662{true},
+		},
+
+		{
+			para1662{[]string{"a", "cb"}, []string{"ab", "c"}},
+			ans1662{false},
+		},
+
+		{
+			para1662{[]string{"abc", "d", "defg"}, []string{"abcddefg"}},
+			ans1662{true},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 1662------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans1662, q.para1662
+		fmt.Printf("【input】:%v      【output】:%v      \n", p, arrayStringsAreEqual(p.word1, p.word2))
+	}
+	fmt.Printf("\n\n\n")
+}

Diff for: leetcode/1662.Check-If-Two-String-Arrays-are-Equivalent/README.md

@@ -0,0 +1,65 @@
+# [1662. Check If Two String Arrays are Equivalent](https://leetcode.com/problems/check-if-two-string-arrays-are-equivalent/)
+
+
+## 题目
+
+Given two string arrays `word1` and `word2`, return **`true` *if the two arrays **represent** the same string, and* `false` *otherwise.*
+
+A string is **represented** by an array if the array elements concatenated **in order** forms the string.
+
+**Example 1:**
+
+```
+Input: word1 = ["ab", "c"], word2 = ["a", "bc"]
+Output: true
+Explanation:
+word1 represents string "ab" + "c" -> "abc"
+word2 represents string "a" + "bc" -> "abc"
+The strings are the same, so return true.
+```
+
+**Example 2:**
+
+```
+Input: word1 = ["a", "cb"], word2 = ["ab", "c"]
+Output: false
+```
+
+**Example 3:**
+
+```
+Input: word1  = ["abc", "d", "defg"], word2 = ["abcddefg"]
+Output: true
+```
+
+**Constraints:**
+
+- `1 <= word1.length, word2.length <= 103`
+- `1 <= word1[i].length, word2[i].length <= 103`
+- `1 <= sum(word1[i].length), sum(word2[i].length) <= 103`
+- `word1[i]` and `word2[i]` consist of lowercase letters.
+
+## 题目大意
+
+给你两个字符串数组 word1 和 word2 。如果两个数组表示的字符串相同，返回 true ；否则，返回 false 。数组表示的字符串 是由数组中的所有元素 按顺序 连接形成的字符串。
+
+## 解题思路
+
+- 简单题，依次拼接 2 个数组内的字符串，然后比较 str1 和 str2 是否相同即可。
+
+## 代码
+
+```go
+package leetcode
+
+func arrayStringsAreEqual(word1 []string, word2 []string) bool {
+	str1, str2 := "", ""
+	for i := 0; i < len(word1); i++ {
+		str1 += word1[i]
+	}
+	for i := 0; i < len(word2); i++ {
+		str2 += word2[i]
+	}
+	return str1 == str2
+}
+```

Diff for: leetcode/1663.Smallest-String-With-A-Given-Numeric-Value/1663. Smallest String With A Given Numeric Value.go

@@ -0,0 +1,55 @@
+package leetcode
+
+// 解法一 贪心
+func getSmallestString(n int, k int) string {
+	res := make([]rune, n)
+	for i := n - 1; i >= 0; i-- {
+		diff := k - i
+		if diff >= 26 {
+			// Need to add z
+			res[i] = 'z'
+			k = k - 26
+		} else {
+			res[i] = rune('a' + diff - 1)
+			k = k - diff
+		}
+	}
+	return string(res)
+}
+
+// 解法二 DFS
+func getSmallestString1(n int, k int) string {
+	if n == 0 {
+		return ""
+	}
+	res, c := "", []byte{}
+	findSmallestString(0, n, k, 0, c, &res)
+	return res
+}
+
+func findSmallestString(value int, length, k, index int, str []byte, res *string) {
+	if len(str) == length && value == k {
+		tmp := string(str)
+		if (*res) == "" {
+			*res = tmp
+		}
+		if tmp < *res && *res != "" {
+			*res = tmp
+		}
+		return
+	}
+	if len(str) >= index && (*res) != "" && str[index-1] > (*res)[index-1] {
+		return
+	}
+	for j := 0; j < 26; j++ {
+		if k-value > (length-len(str))*26 || value > k {
+			return
+		}
+		str = append(str, byte(int('a')+j))
+		value += j + 1
+		findSmallestString(value, length, k, index+1, str, res)
+		str = str[:len(str)-1]
+		value -= j + 1
+
+	}
+}

Diff for: leetcode/1663.Smallest-String-With-A-Given-Numeric-Value/1663. Smallest String With A Given Numeric Value_test.go

@@ -0,0 +1,53 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+type question1663 struct {
+	para1663
+	ans1663
+}
+
+// para 是参数
+// one 代表第一个参数
+type para1663 struct {
+	n int
+	k int
+}
+
+// ans 是答案
+// one 代表第一个答案
+type ans1663 struct {
+	one string
+}
+
+func Test_Problem1663(t *testing.T) {
+
+	qs := []question1663{
+
+		{
+			para1663{3, 27},
+			ans1663{"aay"},
+		},
+
+		{
+			para1663{5, 73},
+			ans1663{"aaszz"},
+		},
+
+		{
+			para1663{24, 552},
+			ans1663{"aaszz"},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 1663------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans1663, q.para1663
+		fmt.Printf("【input】:%v      【output】:%v      \n", p, getSmallestString(p.n, p.k))
+	}
+	fmt.Printf("\n\n\n")
+}

Diff for: leetcode/1663.Smallest-String-With-A-Given-Numeric-Value/README.md

@@ -0,0 +1,104 @@
+# [1663. Smallest String With A Given Numeric Value](https://leetcode.com/problems/smallest-string-with-a-given-numeric-value/)
+
+## 题目
+
+The **numeric value** of a **lowercase character** is defined as its position `(1-indexed)` in the alphabet, so the numeric value of `a` is `1`, the numeric value of `b` is `2`, the numeric value of `c` is `3`, and so on.
+
+The **numeric value** of a **string** consisting of lowercase characters is defined as the sum of its characters' numeric values. For example, the numeric value of the string `"abe"` is equal to `1 + 2 + 5 = 8`.
+
+You are given two integers `n` and `k`. Return *the **lexicographically smallest string** with **length** equal to `n` and **numeric value** equal to `k`.*
+
+Note that a string `x` is lexicographically smaller than string `y` if `x` comes before `y` in dictionary order, that is, either `x` is a prefix of `y`, or if `i` is the first position such that `x[i] != y[i]`, then `x[i]` comes before `y[i]` in alphabetic order.
+
+**Example 1:**
+
+```
+Input: n = 3, k = 27
+Output: "aay"
+Explanation: The numeric value of the string is 1 + 1 + 25 = 27, and it is the smallest string with such a value and length equal to 3.
+```
+
+**Example 2:**
+
+```
+Input: n = 5, k = 73
+Output: "aaszz"
+```
+
+**Constraints:**
+
+- `1 <= n <= 105`
+- `n <= k <= 26 * n`
+
+## 题目大意
+
+小写字符 的 数值 是它在字母表中的位置（从 1 开始），因此 a 的数值为 1 ，b 的数值为 2 ，c 的数值为 3 ，以此类推。字符串由若干小写字符组成，字符串的数值 为各字符的数值之和。例如，字符串 "abe" 的数值等于 1 + 2 + 5 = 8 。给你两个整数 n 和 k 。返回 长度 等于 n 且 数值 等于 k 的 字典序最小 的字符串。注意，如果字符串 x 在字典排序中位于 y 之前，就认为 x 字典序比 y 小，有以下两种情况：
+
+- x 是 y 的一个前缀；
+- 如果 i 是 x[i] != y[i] 的第一个位置，且 x[i] 在字母表中的位置比 y[i] 靠前。
+
+## 解题思路
+
+- 给出 n 和 k，要求找到字符串长度为 n，字母在字母表内位置总和为 k 的最小字典序字符串。
+- 这一题笔者读完题，比赛的时候直接用 DFS 撸了一版。赛后看了时间复杂度马马虎虎，感觉还有优化的空间。DFS 会遍历出所有的解，实际上这一题只要求最小字典序，所以 DFS 剪枝的时候要加上判断字典序的判断，如果新添加进来的字母比已经保存的字符串的相应位置上的字母字典序大，那么就直接 return，这个答案一定不会是最小字典序。代码见解法二
+- 想到这里，其实 DFS 不必要，直接用 for 循环就可找到最小字典序的字符串。代码见解法一。
+
+## 代码
+
+```go
+package leetcode
+
+// 解法一 贪心
+func getSmallestString(n int, k int) string {
+	res := make([]rune, n)
+	for i := n - 1; i >= 0; i-- {
+		diff := k - i
+		if diff >= 26 {
+			// Need to add z
+			res[i] = 'z'
+			k = k - 26
+		} else {
+			res[i] = rune('a' + diff - 1)
+			k = k - diff
+		}
+	}
+	return string(res)
+}
+
+// 解法二 DFS
+func getSmallestString1(n int, k int) string {
+	if n == 0 {
+		return ""
+	}
+	res, c := "", []byte{}
+	findSmallestString(0, n, k, 0, c, &res)
+	return res
+}
+
+func findSmallestString(value int, length, k, index int, str []byte, res *string) {
+	if len(str) == length && value == k {
+		tmp := string(str)
+		if (*res) == "" {
+			*res = tmp
+		}
+		if tmp < *res && *res != "" {
+			*res = tmp
+		}
+		return
+	}
+	if len(str) >= index && (*res) != "" && str[index-1] > (*res)[index-1] {
+		return
+	}
+	for j := 0; j < 26; j++ {
+		if k-value > (length-len(str))*26 || value > k {
+			return
+		}
+		str = append(str, byte(int('a')+j))
+		value += j + 1
+		findSmallestString(value, length, k, index+1, str, res)
+		str = str[:len(str)-1]
+		value -= j + 1
+
+	}
+}
+```

Diff for: leetcode/1664.Ways-to-Make-a-Fair-Array/1664. Ways to Make a Fair Array.go

@@ -0,0 +1,45 @@
+package leetcode
+
+// 解法一 超简洁写法
+func waysToMakeFair(nums []int) int {
+	sum, res := [2]int{}, 0
+	for i := 0; i < len(nums); i++ {
+		sum[i%2] += nums[i]
+	}
+	for i := 0; i < len(nums); i++ {
+		sum[i%2] -= nums[i]
+		if sum[i%2] == sum[1-(i%2)] {
+			res++
+		}
+		sum[1-(i%2)] += nums[i]
+	}
+	return res
+}
+
+// 解法二 前缀和，后缀和
+func waysToMakeFair1(nums []int) int {
+	evenPrefix, oddPrefix, evenSuffix, oddSuffix, res := 0, 0, 0, 0, 0
+	for i := 0; i < len(nums); i++ {
+		if i%2 == 0 {
+			evenSuffix += nums[i]
+		} else {
+			oddSuffix += nums[i]
+		}
+	}
+	for i := 0; i < len(nums); i++ {
+		if i%2 == 0 {
+			evenSuffix -= nums[i]
+		} else {
+			oddSuffix -= nums[i]
+		}
+		if (evenPrefix + oddSuffix) == (oddPrefix + evenSuffix) {
+			res++
+		}
+		if i%2 == 0 {
+			evenPrefix += nums[i]
+		} else {
+			oddPrefix += nums[i]
+		}
+	}
+	return res
+}