diff --git a/problems/0213.打家劫舍II.md b/problems/0213.打家劫舍II.md
index cd9d596d..385c5867 100644
--- a/problems/0213.打家劫舍II.md
+++ b/problems/0213.打家劫舍II.md
@@ -225,32 +225,38 @@ class Solution:
 // 打家劫舍Ⅱ 动态规划
 // 时间复杂度O(n) 空间复杂度O(n)
 func rob(nums []int) int {
-    if len(nums) == 1 {
-        return nums[0]
+    // 如果长度为0或1，那么有没有环的限制都一样
+    if len(nums) <= 1 {
+        return robWithoutCircle(nums)
     }
-    if len(nums) == 2 {
-        return max(nums[0], nums[1])
-    }
-    
-    result1 := robRange(nums, 0)
-    result2 := robRange(nums, 1)
-    return max(result1, result2)
+
+    // 否则，去头或去尾，取最大
+    res1 := robWithoutCircle(nums[:len(nums)-1])
+    res2 := robWithoutCircle(nums[1:])
+
+    return max(res1, res2)
 }
 
-// 偷盗指定的范围
-func robRange(nums []int, start int) int {
+// 原始的打家劫舍版
+func robWithoutCircle(nums []int) int {
+    switch len(nums) {
+        case 0: return 0
+        case 1: return nums[0]
+    }
     dp := make([]int, len(nums))
-    dp[1] = nums[start]
-    
-    for i := 2; i < len(nums); i++ {
-        dp[i] = max(dp[i - 2] + nums[i - 1 + start], dp[i - 1])
+    dp[0]=nums[0]
+    dp[1] = max(nums[0], nums[1])
+
+    for i:=2; i<len(nums); i++ {
+        dp[i] = max(dp[i-1], dp[i-2]+nums[i])
     }
-    
-    return dp[len(nums) - 1]
+
+    return dp[len(nums)-1]
+
 }
 
-func max(a, b int) int {
-    if a > b {
+func max(a, b int ) int {
+    if a>b {
         return a
     }
     return b
diff --git a/problems/1356.根据数字二进制下1的数目排序.md b/problems/1356.根据数字二进制下1的数目排序.md
index cc7a7007..c2455cf0 100644
--- a/problems/1356.根据数字二进制下1的数目排序.md
+++ b/problems/1356.根据数字二进制下1的数目排序.md
@@ -171,36 +171,29 @@ class Solution:
 
 ```go
 func sortByBits(arr []int) []int {
-    var tmp int
-    for i := 0; i < len(arr); i++ {
-        for j := i+1; j < len(arr); j++ {
-            // 冒泡排序的手法，但是排序的规则从比大小变成了比位运算1的个数
-            if isCmp(arr[i], arr[j]) {
-                tmp = arr[i]
-                arr[i] = arr[j]
-                arr[j] = tmp
-            }
-        } 
+    // 是否arr[i]<=arr[j]
+    // 先比较1的数量，后比较值本身
+    cmp := func(i, j int) bool {
+        c1, c2 := bitCount(arr[i]), bitCount(arr[j])
+        if c1 == c2 {
+            return arr[i] <= arr[j]
+        }
+        return c1 <= c2
     }
+
+    // 调用库函数
+    // 第一个参数是待排序切片，第二个是第i位是否小于第j位的函数
+    sort.Slice(arr, cmp)
+
     return arr
 }
 
-func isCmp(a, b int) bool {
-    bitA := bitCount(a)
-    bitB := bitCount(b)
-    if bitA == bitB {
-        return a > b
-    } else {
-        return bitA > bitB 
-    }
-}
-
-func bitCount(n int) int {
-    count := 0
-    for n != 0 {
-        n &= (n-1) // 清除最低位的1
+func bitCount(num int) (count int) {
+    for num != 0 {
+        num &= num-1    // 每次运算将最右侧的1变成0
         count++
     }
+
     return count
 }
 ```