Merge branch 'master' of https://github.com/halfrost/LeetCode-Go

Author: novahe

README.md

@@ -0,0 +1,23 @@
+package leetcode
+
+import "sort"
+
+func longestCommonPrefix(strs []string) string {
+	sort.Slice(strs, func(i, j int) bool {
+		return len(strs[i]) <= len(strs[j])
+	})
+	minLen := len(strs[0])
+	if minLen == 0 {
+		return ""
+	}
+	var commonPrefix []byte
+	for i := 0; i < minLen; i++ {
+		for j := 1; j < len(strs); j++ {
+			if strs[j][i] != strs[0][i] {
+				return string(commonPrefix)
+			}
+		}
+		commonPrefix = append(commonPrefix, strs[0][i])
+	}
+	return string(commonPrefix)
+}

leetcode/0014.Longest-Common-Prefix/14.Longest Common Prefix.go

@@ -0,0 +1,45 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+type question14 struct {
+	para14
+	ans14
+}
+
+// para 是参数
+type para14 struct {
+	strs []string
+}
+
+// ans 是答案
+type ans14 struct {
+	ans string
+}
+
+func Test_Problem14(t *testing.T) {
+
+	qs := []question14{
+
+		{
+			para14{[]string{"flower", "flow", "flight"}},
+			ans14{"fl"},
+		},
+
+		{
+			para14{[]string{"dog", "racecar", "car"}},
+			ans14{""},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 14------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans14, q.para14
+		fmt.Printf("【input】:%v    【output】:%v\n", p.strs, longestCommonPrefix(p.strs))
+	}
+	fmt.Printf("\n\n\n")
+}

leetcode/0014.Longest-Common-Prefix/14.Longest Common Prefix_test.go

@@ -0,0 +1,64 @@
+# [14. Longest Common Prefix](https://leetcode.com/problems/longest-common-prefix/)
+
+## 题目
+
+Write a function to find the longest common prefix string amongst an array of strings.
+
+If there is no common prefix, return an empty string "".
+
+**Example 1**:
+
+    Input: strs = ["flower","flow","flight"]
+    Output: "fl"
+
+**Example 2**:
+
+    Input: strs = ["dog","racecar","car"]
+    Output: ""
+    Explanation: There is no common prefix among the input strings.
+
+**Constraints:**
+
+- 1 <= strs.length <= 200
+- 0 <= strs[i].length <= 200
+- strs[i] consists of only lower-case English letters.
+
+## 题目大意
+
+编写一个函数来查找字符串数组中的最长公共前缀。
+
+如果不存在公共前缀，返回空字符串 ""。
+
+## 解题思路
+
+- 对 strs 按照字符串长度进行升序排序，求出 strs 中长度最小字符串的长度 minLen
+- 逐个比较长度最小字符串与其它字符串中的字符，如果不相等就返回 commonPrefix,否则就把该字符加入 commonPrefix
+
+## 代码
+
+```go
+
+package leetcode
+
+import "sort"
+
+func longestCommonPrefix(strs []string) string {
+	sort.Slice(strs, func(i, j int) bool {
+		return len(strs[i]) <= len(strs[j])
+	})
+	minLen := len(strs[0])
+	if minLen == 0 {
+		return ""
+	}
+	var commonPrefix []byte
+	for i := 0; i < minLen; i++ {
+		for j := 1; j < len(strs); j++ {
+			if strs[j][i] != strs[0][i] {
+				return string(commonPrefix)
+			}
+		}
+		commonPrefix = append(commonPrefix, strs[0][i])
+	}
+	return string(commonPrefix)
+}
+```

leetcode/0014.Longest-Common-Prefix/README.md

@@ -1,5 +1,6 @@
 package leetcode
 
+// 解法一
 func nextPermutation(nums []int) {
 	i, j := 0, 0
 	for i = len(nums) - 2; i >= 0; i-- {
@@ -29,3 +30,43 @@ func reverse(nums *[]int, i, j int) {
 func swap(nums *[]int, i, j int) {
 	(*nums)[i], (*nums)[j] = (*nums)[j], (*nums)[i]
 }
+
+// 解法二
+// [2,(3),6,5,4,1] -> 2,(4),6,5,(3),1 -> 2,4, 1,3,5,6
+func nextPermutation1(nums []int) {
+	var n = len(nums)
+	var pIdx = checkPermutationPossibility(nums)
+	if pIdx == -1 {
+		reverse(&nums, 0, n-1)
+		return
+	}
+
+	var rp = len(nums) - 1
+	// start from right most to leftward,find the first number which is larger than PIVOT
+	for rp > 0 {
+		if nums[rp] > nums[pIdx] {
+			swap(&nums, pIdx, rp)
+			break
+		} else {
+			rp--
+		}
+	}
+	// Finally, Reverse all elements which are right from pivot
+	reverse(&nums, pIdx+1, n-1)
+}
+
+// checkPermutationPossibility returns 1st occurrence Index where
+// value is in decreasing order(from right to left)
+// returns -1 if not found(it's already in its last permutation)
+func checkPermutationPossibility(nums []int) (idx int) {
+	// search right to left for 1st number(from right) that is not in increasing order
+	var rp = len(nums) - 1
+	for rp > 0 {
+		if nums[rp-1] < nums[rp] {
+			idx = rp - 1
+			return idx
+		}
+		rp--
+	}
+	return -1
+}

leetcode/0031.Next-Permutation/31. Next Permutation.go

@@ -1,5 +1,6 @@
 package leetcode
 
+// 解法一
 func rotate(matrix [][]int) {
 	length := len(matrix)
 	// rotate by diagonal 对角线变换
@@ -15,3 +16,46 @@ func rotate(matrix [][]int) {
 		}
 	}
 }
+
+// 解法二
+func rotate1(matrix [][]int) {
+	n := len(matrix)
+	if n == 1 {
+		return
+	}
+	/* rotate clock-wise = 1. transpose matrix => 2. reverse(matrix[i])
+
+	1   2  3  4      1   5  9  13        13  9  5  1
+	5   6  7  8  =>  2   6  10 14  =>    14  10 6  2
+	9  10 11 12      3   7  11 15        15  11 7  3
+	13 14 15 16      4   8  12 16        16  12 8  4
+
+	*/
+
+	for i := 0; i < n; i++ {
+		// transpose, i=rows, j=columns
+		// j = i+1, coz diagonal elements didn't change in a square matrix
+		for j := i + 1; j < n; j++ {
+			swap(matrix, i, j)
+		}
+		// reverse each row of the image
+		matrix[i] = reverse(matrix[i])
+	}
+}
+
+// swap changes original slice's i,j position
+func swap(nums [][]int, i, j int) {
+	nums[i][j], nums[j][i] = nums[j][i], nums[i][j]
+}
+
+// reverses a row of image, matrix[i]
+func reverse(nums []int) []int {
+	var lp, rp = 0, len(nums) - 1
+
+	for lp < rp {
+		nums[lp], nums[rp] = nums[rp], nums[lp]
+		lp++
+		rp--
+	}
+	return nums
+}

leetcode/0048.Rotate-Image/48. Rotate Image.go

@@ -0,0 +1,16 @@
+package leetcode
+
+func lengthOfLastWord(s string) int {
+	last := len(s) - 1
+	for last >= 0 && s[last] == ' ' {
+		last--
+	}
+	if last < 0 {
+		return 0
+	}
+	first := last
+	for first >= 0 && s[first] != ' ' {
+		first--
+	}
+	return last - first
+}

leetcode/0058.Length-of-Last-Word/58.Length of Last Word.go

@@ -0,0 +1,50 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+type question58 struct {
+	para58
+	ans58
+}
+
+// para 是参数
+type para58 struct {
+	s string
+}
+
+// ans 是答案
+type ans58 struct {
+	ans int
+}
+
+func Test_Problem58(t *testing.T) {
+
+	qs := []question58{
+
+		{
+			para58{"Hello World"},
+			ans58{5},
+		},
+
+		{
+			para58{"   fly me   to   the moon  "},
+			ans58{4},
+		},
+
+		{
+			para58{"luffy is still joyboy"},
+			ans58{6},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 58------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans58, q.para58
+		fmt.Printf("【input】:%v       【output】:%v\n", p, lengthOfLastWord(p.s))
+	}
+	fmt.Printf("\n\n\n")
+}

leetcode/0058.Length-of-Last-Word/58.Length of Last Word_test.go

@@ -0,0 +1,70 @@
+# [58. Length of Last Word](https://leetcode.com/problems/length-of-last-word/)
+
+
+## 题目
+
+Given a string `s` consisting of some words separated by some number of spaces, return *the length of the **last** word in the string.*
+
+A **word** is a maximal substring consisting of non-space characters only.
+
+**Example 1:**
+
+```
+Input: s = "Hello World"
+Output: 5
+Explanation: The last word is "World" with length 5.
+
+```
+
+**Example 2:**
+
+```
+Input: s = "   fly me   to   the moon  "
+Output: 4
+Explanation: The last word is "moon" with length 4.
+
+```
+
+**Example 3:**
+
+```
+Input: s = "luffy is still joyboy"
+Output: 6
+Explanation: The last word is "joyboy" with length 6.
+
+```
+
+**Constraints:**
+
+- `1 <= s.length <= 104`
+- `s` consists of only English letters and spaces `' '`.
+- There will be at least one word in `s`.
+
+## 题目大意
+
+给你一个字符串 `s`，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中最后一个单词的长度。**单词** 是指仅由字母组成、不包含任何空格字符的最大子字符串。
+
+## 解题思路
+
+- 先从后过滤掉空格找到单词尾部，再从尾部向前遍历，找到单词头部，最后两者相减，即为单词的长度。
+
+## 代码
+
+```go
+package leetcode
+
+func lengthOfLastWord(s string) int {
+	last := len(s) - 1
+	for last >= 0 && s[last] == ' ' {
+		last--
+	}
+	if last < 0 {
+		return 0
+	}
+	first := last
+	for first >= 0 && s[first] != ' ' {
+		first--
+	}
+	return last - first
+}
+```

leetcode/0058.Length-of-Last-Word/README.md

@@ -26,4 +26,4 @@ Your algorithm should have a linear runtime complexity. Could you implement it w
 ## 解题思路
 
 - 题目要求不能使用辅助空间，并且时间复杂度只能是线性的。
-- 题目为什么要强调有一个数字出现一次，其他的出现两次？我们想到了异或运算的性质：任何一个数字异或它自己都等于0。也就是说，如果我们从头到尾依次异或数组中的每一个数字，那么最终的结果刚好是那个只出现依次的数字，因为那些出现两次的数字全部在异或中抵消掉了。于是最终做法是从头到尾依次异或数组中的每一个数字，那么最终得到的结果就是两个只出现一次的数字的异或结果。因为其他数字都出现了两次，在异或中全部抵消掉了。**利用的性质是 x^x = 0**。
+- 题目为什么要强调有一个数字出现一次，其他的出现两次？我们想到了异或运算的性质：任何一个数字异或它自己都等于0。也就是说，如果我们从头到尾依次异或数组中的每一个数字，那么最终的结果刚好是那个只出现一次的数字，因为那些出现两次的数字全部在异或中抵消掉了。于是最终做法是从头到尾依次异或数组中的每一个数字，那么最终得到的结果就是两个只出现一次的数字的异或结果。因为其他数字都出现了两次，在异或中全部抵消掉了。**利用的性质是 x^x = 0**。