添加 problem 7、136、137、169、187、190、201、229、260

Author: halfrost

Algorithms/0007. Reverse Integer/7. Reverse Integer.go

@@ -0,0 +1,13 @@
+package leetcode
+
+func reverse_7(x int) int {
+	tmp := 0
+	for x != 0 {
+		tmp = tmp*10 + x%10
+		x = x / 10
+	}
+	if tmp > 1<<31-1 || tmp < -(1<<31) {
+		return 0
+	}
+	return tmp
+}

Algorithms/0007. Reverse Integer/7. Reverse Integer_test.go

@@ -0,0 +1,57 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+type question7 struct {
+	para7
+	ans7
+}
+
+// para 是参数
+// one 代表第一个参数
+type para7 struct {
+	one int
+}
+
+// ans 是答案
+// one 代表第一个答案
+type ans7 struct {
+	one int
+}
+
+func Test_Problem7(t *testing.T) {
+
+	qs := []question7{
+
+		question7{
+			para7{321},
+			ans7{123},
+		},
+
+		question7{
+			para7{-123},
+			ans7{-321},
+		},
+
+		question7{
+			para7{120},
+			ans7{21},
+		},
+
+		question7{
+			para7{1534236469},
+			ans7{0},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 7------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans7, q.para7
+		fmt.Printf("【input】:%v    【output】:%v\n", p.one, reverse_7(p.one))
+	}
+	fmt.Printf("\n\n\n")
+}

Algorithms/0007. Reverse Integer/README.md

@@ -0,0 +1,35 @@
+# [7. Reverse Integer](https://leetcode.com/problems/reverse-integer/)
+
+
+## 题目:
+
+Given a 32-bit signed integer, reverse digits of an integer.
+
+**Example 1:**
+
+    Input: 123
+    Output: 321
+
+**Example 2:**
+
+    Input: -123
+    Output: -321
+
+**Example 3:**
+
+    Input: 120
+    Output: 21
+
+**Note:**Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−2^31, 2^31 − 1]. For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows.
+
+## 题目大意
+
+给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。注意:假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−2^31,  2^31 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。
+
+
+
+## 解题思路
+
+
+- 这一题是简单题，要求反转 10 进制数。类似的题目有第 190 题。
+- 这一题只需要注意一点，反转以后的数字要求在 [−2^31, 2^31 − 1]范围内，超过这个范围的数字都要输出 0 。

Algorithms/0136. Single Number/136. Single Number.go

@@ -0,0 +1,9 @@
+package leetcode
+
+func singleNumber(nums []int) int {
+	result := 0
+	for i := 0; i < len(nums); i++ {
+		result ^= nums[i]
+	}
+	return result
+}

Algorithms/0136. Single Number/136. Single Number_test.go

@@ -0,0 +1,47 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+type question136 struct {
+	para136
+	ans136
+}
+
+// para 是参数
+// one 代表第一个参数
+type para136 struct {
+	s []int
+}
+
+// ans 是答案
+// one 代表第一个答案
+type ans136 struct {
+	one int
+}
+
+func Test_Problem136(t *testing.T) {
+
+	qs := []question136{
+
+		question136{
+			para136{[]int{2, 2, 1}},
+			ans136{1},
+		},
+
+		question136{
+			para136{[]int{4, 1, 2, 1, 2}},
+			ans136{4},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 136------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans136, q.para136
+		fmt.Printf("【input】:%v       【output】:%v\n", p, singleNumber(p.s))
+	}
+	fmt.Printf("\n\n\n")
+}

Algorithms/0136. Single Number/README.md

@@ -0,0 +1,29 @@
+# [136. Single Number](https://leetcode.com/problems/single-number/)
+
+## 题目:
+
+Given a **non-empty** array of integers, every element appears *twice* except for one. Find that single one.
+
+**Note:**
+
+Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?
+
+**Example 1:**
+
+    Input: [2,2,1]
+    Output: 1
+
+**Example 2:**
+
+    Input: [4,1,2,1,2]
+    Output: 4
+
+## 题目大意
+
+给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。要求算法时间复杂度是线性的，并且不使用额外的辅助空间。
+
+
+## 解题思路
+
+- 题目要求不能使用辅助空间，并且时间复杂度只能是线性的。
+- 题目为什么要强调有一个数字出现一次，其他的出现两次？我们想到了异或运算的性质：任何一个数字异或它自己都等于0。也就是说，如果我们从头到尾依次异或数组中的每一个数字，那么最终的结果刚好是那个只出现依次的数字，因为那些出现两次的数字全部在异或中抵消掉了。于是最终做法是从头到尾依次异或数组中的每一个数字，那么最终得到的结果就是两个只出现一次的数字的异或结果。因为其他数字都出现了两次，在异或中全部抵消掉了。**利用的性质是 x^x = 0**。

Algorithms/0137. Single Number II/137. Single Number II.go

@@ -0,0 +1,35 @@
+package leetcode
+
+func singleNumberII(nums []int) int {
+	ones, twos := 0, 0
+	for i := 0; i < len(nums); i++ {
+		ones = (ones ^ nums[i]) & ^twos
+		twos = (twos ^ nums[i]) & ^ones
+	}
+	return ones
+}
+
+// 以下是拓展题
+// 在数组中每个元素都出现 5 次，找出只出现 1 次的数。
+
+// 解法一
+func singleNumberIIIII(nums []int) int {
+	na, nb, nc := 0, 0, 0
+	for i := 0; i < len(nums); i++ {
+		nb = nb ^ (nums[i] & na)
+		na = (na ^ nums[i]) & ^nc
+		nc = nc ^ (nums[i] & ^na & ^nb)
+	}
+	return na & ^nb & ^nc
+}
+
+// 解法二
+func singleNumberIIIII_(nums []int) int {
+	twos, threes, ones := 0xffffffff, 0xffffffff, 0
+	for i := 0; i < len(nums); i++ {
+		threes = threes ^ (nums[i] & twos)
+		twos = (twos ^ nums[i]) & ^ones
+		ones = ones ^ (nums[i] & ^twos & ^threes)
+	}
+	return ones
+}

Algorithms/0137. Single Number II/137. Single Number II_test.go

@@ -0,0 +1,47 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+type question137 struct {
+	para137
+	ans137
+}
+
+// para 是参数
+// one 代表第一个参数
+type para137 struct {
+	s []int
+}
+
+// ans 是答案
+// one 代表第一个答案
+type ans137 struct {
+	one int
+}
+
+func Test_Problem137(t *testing.T) {
+
+	qs := []question137{
+
+		question137{
+			para137{[]int{2, 2, 3, 2}},
+			ans137{3},
+		},
+
+		question137{
+			para137{[]int{0, 1, 0, 1, 0, 1, 99}},
+			ans137{99},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 137------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans137, q.para137
+		fmt.Printf("【input】:%v       【output】:%v\n", p, singleNumberII(p.s))
+	}
+	fmt.Printf("\n\n\n")
+}

Algorithms/0137. Single Number II/README.md

@@ -0,0 +1,66 @@
+# [137. Single Number II](https://leetcode.com/problems/single-number-ii/)
+
+
+## 题目:
+
+Given a **non-empty** array of integers, every element appears *three* times except for one, which appears exactly once. Find that single one.
+
+**Note:**
+
+Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?
+
+**Example 1:**
+
+    Input: [2,2,3,2]
+    Output: 3
+
+**Example 2:**
+
+    Input: [0,1,0,1,0,1,99]
+    Output: 99
+
+
+## 题目大意
+
+给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现了三次。找出那个只出现了一次的元素。要求算法时间复杂度是线性的，并且不使用额外的辅助空间。
+
+
+
+
+## 解题思路
+
+- 这一题是第 136 题的加强版。这类题也可以扩展，在数组中每个元素都出现 5 次，找出只出现 1 次的数。
+- 本题中要求找出只出现 1 次的数，出现 3 次的数都要被消除。第 136 题是消除出现 2 次的数。这一题也会相当相同的解法，出现 3 次的数也要被消除。定义状态，00、10、01，这 3 个状态。当一个数出现 3 次，那么它每个位置上的 1 出现的次数肯定是 3 的倍数，所以当 1 出现 3 次以后，就归零清除。如何能做到这点呢？仿造`三进制(00，10，01)` 就可以做到。
+- 变量  ones 中记录遍历中每个位上出现 1 的个数。将它与 A[i] 进行异或，目的是：
+    - 每位上两者都是 1 的，表示历史统计结果 ones 出现1次、A[i]中又出现1次，则是出现 2 次，需要进位到 twos 变量中。
+    - 每位上两者分别为 0、1 的，加入到 ones 统计结果中。
+    - 最后还要 & ^twos ，是为了能做到三进制，出现 3 次就清零。例如 ones = x，那么 twos = 0，当 twos = x，那么 ones = 0；
+- 变量 twos 中记录遍历中每个位上出现 1 ，2次 的个数。与 A[i] 进行异或的目的和上述描述相同，不再赘述。
+
+> 在 golang 中，&^ 表示 AND NOT 的意思。这里的 ^ 作为一元操作符，表示按位取反 (^0001 0100 = 1110 1011)，X &^ Y 的意思是将 X 中与 Y 相异的位保留，相同的位清零。
+
+> 在 golang 中没有 Java 中的 ~ 位操作运算符，Java 中的 ~ 运算符代表按位取反。这个操作就想当于 golang 中的 ^ 运算符当做一元运算符使用的效果。
+
+这一题还可以继续扩展，在数组中每个元素都出现 5 次，找出只出现 1 次的数。那该怎么做呢？思路还是一样的，模拟一个五进制，5 次就会消除。代码如下：
+
+    // 解法一
+    func singleNumberIII(nums []int) int {
+    	na, nb, nc := 0, 0, 0
+    	for i := 0; i < len(nums); i++ {
+    		nb = nb ^ (nums[i] & na)
+    		na = (na ^ nums[i]) & ^nc
+    		nc = nc ^ (nums[i] & ^na & ^nb)
+    	}
+    	return na & ^nb & ^nc
+    }
+    
+    // 解法二
+    func singleNumberIIII(nums []int) int {
+    	twos, threes, ones := 0xffffffff, 0xffffffff, 0
+    	for i := 0; i < len(nums); i++ {
+    		threes = threes ^ (nums[i] & twos)
+    		twos = (twos ^ nums[i]) & ^ones
+    		ones = ones ^ (nums[i] & ^twos & ^threes)
+    	}
+    	return ones
+    }

Algorithms/0169. Majority Element/169. Majority Element.go

@@ -0,0 +1,30 @@
+package leetcode
+
+// 解法一 时间复杂度 O(n) 空间复杂度 O(1)
+func majorityElement(nums []int) int {
+	res, count := nums[0], 0
+	for i := 0; i < len(nums); i++ {
+		if count == 0 {
+			res, count = nums[i], 1
+		} else {
+			if nums[i] == res {
+				count++
+			} else {
+				count--
+			}
+		}
+	}
+	return res
+}
+
+// 解法二 时间复杂度 O(n) 空间复杂度 O(n)
+func majorityElement_(nums []int) int {
+	m := make(map[int]int)
+	for _, v := range nums {
+		m[v]++
+		if m[v] > len(nums)/2 {
+			return v
+		}
+	}
+	return 0
+}