From 11764cd9dec90f76bbb091e98967e9e0d5969b4a Mon Sep 17 00:00:00 2001
From: ysfei <ysfei92@gmail.com>
Date: Thu, 17 Mar 2022 16:20:42 -0500
Subject: [PATCH 01/22] Update 121. Best Time to Buy and Sell Stock.py

---
 .../array/easy/121. Best Time to Buy and Sell Stock.py | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/sort_by_leetcode/array/easy/121. Best Time to Buy and Sell Stock.py b/sort_by_leetcode/array/easy/121. Best Time to Buy and Sell Stock.py
index 68dd361..a935185 100644
--- a/sort_by_leetcode/array/easy/121. Best Time to Buy and Sell Stock.py	
+++ b/sort_by_leetcode/array/easy/121. Best Time to Buy and Sell Stock.py	
@@ -24,8 +24,12 @@ def maxProfit(self, prices):
         :type prices: List[int]
         :rtype: int
         """
-        curSum=maxSum=0
+        curSum=maxSum=0 #可以连等，不错！
         for i in range(1,len(prices)):
-            curSum=max(0,curSum+prices[i]-prices[i-1])
+            curSum=max(0,curSum+prices[i]-prices[i-1]) 
+    #开始的条件是当前price比上一个起始点更低，即从上一个起始点开始累计的return<0，此时重新开始累计
             maxSum = max(curSum,maxSum)
-        return maxSum
\ No newline at end of file
+    #结束的条件是当前的累计return比储存的所有累计return都要高
+        return maxSum
+    #这一类题目（对一个动作的起始点都要做决定）都可以通过在每个点做决定的方法来减少时间复杂度：每个点决定要不要开始/结束
+    #节省时间复杂度，暴力解法是对起始点各做循环，复杂度O(n^2)。现在复杂度是O(n)

From ce706e71c877b8bf02073f6e927bb3441d356000 Mon Sep 17 00:00:00 2001
From: ysfei <ysfei92@gmail.com>
Date: Thu, 17 Mar 2022 16:45:14 -0500
Subject: [PATCH 02/22] Update 167. Two Sum II - Input array is sorted.py

---
 .../array/easy/167. Two Sum II - Input array is sorted.py      | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/sort_by_leetcode/array/easy/167. Two Sum II - Input array is sorted.py b/sort_by_leetcode/array/easy/167. Two Sum II - Input array is sorted.py
index d1e2d2a..cb008fb 100644
--- a/sort_by_leetcode/array/easy/167. Two Sum II - Input array is sorted.py	
+++ b/sort_by_leetcode/array/easy/167. Two Sum II - Input array is sorted.py	
@@ -19,6 +19,7 @@ def twoSum(self, numbers, target):
         :type target: int
         :rtype: List[int]
         """
+#暴力解法
         res = dict()
         for i in range(0,len(numbers)):
             sub = target - numbers[i]
@@ -26,4 +27,4 @@ def twoSum(self, numbers, target):
                 return [res[sub]+1,i+1]
             else:
                 res[numbers[i]] = i
-        return []
\ No newline at end of file
+        return []

From 65ea20ba8acb1a93c0f9980ef1bcd7ac7d35bd3d Mon Sep 17 00:00:00 2001
From: ysfei <ysfei92@gmail.com>
Date: Thu, 17 Mar 2022 16:54:54 -0500
Subject: [PATCH 03/22] Update 167. Two Sum II - Input array is sorted.py

---
 .../167. Two Sum II - Input array is sorted.py     | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/sort_by_leetcode/array/easy/167. Two Sum II - Input array is sorted.py b/sort_by_leetcode/array/easy/167. Two Sum II - Input array is sorted.py
index cb008fb..4f44844 100644
--- a/sort_by_leetcode/array/easy/167. Two Sum II - Input array is sorted.py	
+++ b/sort_by_leetcode/array/easy/167. Two Sum II - Input array is sorted.py	
@@ -19,7 +19,19 @@ def twoSum(self, numbers, target):
         :type target: int
         :rtype: List[int]
         """
-#暴力解法
+#暴力解法是n^2的复杂度，这里无非是偷懒了，把第二层循环替换成找dictonary的key
+#难点就在于dictionary的value是不能直接查找的，但我们把数值存在key里面就可以直接查找
+"""
+其实这个答案的写法已经很花哨了，最质朴的写法是：
+        res = dict()
+        for i in range(0,len(numbers)):
+            res[numbers[i]] = i
+        for i in range(0,len(numbers)):
+            sub = target - numbers[i]
+            if sub in res.keys():
+                return [res[sub]+1,i+1]
+给出的最优解无非是把两个相似的循环结合在一起，又省了一些iteration，不过复杂度of the same magnitude
+"""              
         res = dict()
         for i in range(0,len(numbers)):
             sub = target - numbers[i]

From d008d2bd7d8a8daaddfdbb21d5756b5ef403436f Mon Sep 17 00:00:00 2001
From: ysfei <ysfei92@gmail.com>
Date: Wed, 30 Mar 2022 16:16:24 -0500
Subject: [PATCH 04/22] Update 122. Best Time to Buy and Sell Stock II.py

---
 .../array/easy/122. Best Time to Buy and Sell Stock II.py      | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/sort_by_leetcode/array/easy/122. Best Time to Buy and Sell Stock II.py b/sort_by_leetcode/array/easy/122. Best Time to Buy and Sell Stock II.py
index f122fef..6feb7ef 100644
--- a/sort_by_leetcode/array/easy/122. Best Time to Buy and Sell Stock II.py	
+++ b/sort_by_leetcode/array/easy/122. Best Time to Buy and Sell Stock II.py	
@@ -6,10 +6,11 @@
 
 """
 """这道题比较简单，因为没有买卖次数限制，也没有买卖时间限制，如果后面的股价比前面的大，我们就买卖"""
+"""主要学习连加的快捷写法：sum(some_function_of_i for i in ...)"""
 class Solution(object):
     def maxProfit(self, prices):
         """
         :type prices: List[int]
         :rtype: int
         """
-        return sum(max(prices[i+1]-prices[i],0) for i in range(len(prices)-1))
\ No newline at end of file
+        return sum(max(prices[i+1]-prices[i],0) for i in range(len(prices)-1))

From c075362ee9847793eca25704aa236071988d72cf Mon Sep 17 00:00:00 2001
From: ysfei <ysfei92@gmail.com>
Date: Mon, 4 Apr 2022 02:48:17 -0500
Subject: [PATCH 05/22] Update 169. Majority Element.py

---
 .../array/easy/169. Majority Element.py           | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/sort_by_leetcode/array/easy/169. Majority Element.py b/sort_by_leetcode/array/easy/169. Majority Element.py
index 76d711e..2bdf095 100644
--- a/sort_by_leetcode/array/easy/169. Majority Element.py	
+++ b/sort_by_leetcode/array/easy/169. Majority Element.py	
@@ -14,7 +14,18 @@
 """思路，因为出现次数最多的元素大于元素个数的一半，所以使用count和cand，设目标值为a
 """
 
-
+"""
+暴力解法：
+class Solution(object):
+    def majorityElement(self, nums):
+        majority_count = len(nums)//2
+        for num in nums:
+            count = sum(1 for elem in nums if elem == num)
+            if count > majority_count:
+                return num
+这里可以学习对list里出现某个值的计数方法：count = sum(1 for i in nums if i==target)
+但这个解法暴力在sum(1 for ...)本身也是循环，所以复杂度是n^2.
+                
 class Solution(object):
     def majorityElement(self, nums):
         """
@@ -39,4 +50,4 @@ def majorityElement(self, nums):
         :type nums: List[int]
         :rtype: int
         """
-        return sorted(nums)[len(nums)/2]
\ No newline at end of file
+        return sorted(nums)[len(nums)/2]

From b5180f4c4938b910fef5078451452ca87db6cc6e Mon Sep 17 00:00:00 2001
From: ysfei <ysfei92@gmail.com>
Date: Tue, 5 Apr 2022 12:24:30 -0500
Subject: [PATCH 06/22] Update 169. Majority Element.py

---
 sort_by_leetcode/array/easy/169. Majority Element.py | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/sort_by_leetcode/array/easy/169. Majority Element.py b/sort_by_leetcode/array/easy/169. Majority Element.py
index 2bdf095..838c12b 100644
--- a/sort_by_leetcode/array/easy/169. Majority Element.py	
+++ b/sort_by_leetcode/array/easy/169. Majority Element.py	
@@ -15,7 +15,7 @@
 """
 
 """
-暴力解法：
+暴力解法(n^2)：
 class Solution(object):
     def majorityElement(self, nums):
         majority_count = len(nums)//2
@@ -25,6 +25,15 @@ def majorityElement(self, nums):
                 return num
 这里可以学习对list里出现某个值的计数方法：count = sum(1 for i in nums if i==target)
 但这个解法暴力在sum(1 for ...)本身也是循环，所以复杂度是n^2.
+
+Hash table解法(n):
+from collections import Counter
+class Solution:
+    def majorityElement(self, nums):
+        counts = Counter(nums)
+        return max(counts.keys(), key=counts.get)
+这里import了Counter函数，直接生成各个值的频度表，format是dictionary (Hash table)
+max函数。。。
                 
 class Solution(object):
     def majorityElement(self, nums):

From 5988c9545d8ab0a8e51503aca07af012cfa040ec Mon Sep 17 00:00:00 2001
From: ysfei <ysfei92@gmail.com>
Date: Tue, 5 Apr 2022 16:38:30 -0500
Subject: [PATCH 07/22] Update 169. Majority Element.py

---
 .../array/easy/169. Majority Element.py       | 50 +++++++++----------
 1 file changed, 23 insertions(+), 27 deletions(-)

diff --git a/sort_by_leetcode/array/easy/169. Majority Element.py b/sort_by_leetcode/array/easy/169. Majority Element.py
index 838c12b..72c33a0 100644
--- a/sort_by_leetcode/array/easy/169. Majority Element.py	
+++ b/sort_by_leetcode/array/easy/169. Majority Element.py	
@@ -11,9 +11,6 @@
 
 """
 
-"""思路，因为出现次数最多的元素大于元素个数的一半，所以使用count和cand，设目标值为a
-"""
-
 """
 暴力解法(n^2)：
 class Solution(object):
@@ -26,6 +23,14 @@ def majorityElement(self, nums):
 这里可以学习对list里出现某个值的计数方法：count = sum(1 for i in nums if i==target)
 但这个解法暴力在sum(1 for ...)本身也是循环，所以复杂度是n^2.
 
+巧思路（NlogN)
+class Solution:
+    def majorityElement(self, nums):
+        nums.sort()
+        return nums[len(nums)//2]
+        #或者直接一行：return sorted(nums)[len(nums)//2]
+缺点是sort的时间复杂度是NlogN
+
 Hash table解法(n):
 from collections import Counter
 class Solution:
@@ -33,30 +38,21 @@ def majorityElement(self, nums):
         counts = Counter(nums)
         return max(counts.keys(), key=counts.get)
 这里import了Counter函数，直接生成各个值的频度表，format是dictionary (Hash table)
-max函数。。。
-                
+max函数的key选项用于比大小的数字和return数字不同的情况，比如要比较x^2时就用 max(nums, key=lambda x: x**2)
+counts.keys()表示要return的数字是ditionary keys种的一个（得有括号，否则只是个函数）。counts.get是个函数（没有括号），给出key对应的值
+也可以把函数用lambda写出来 max(counts.keys(), key=lambda x:counts[x])
+Counter和max都是n时间复杂度，所以总共时间复杂度也是n。
+
+Boyer-Moore Voting Algorithm （n)
 class Solution(object):
     def majorityElement(self, nums):
-        """
-        :type nums: List[int]
-        :rtype: int
-        """
-        cand = nums[0]
-        count = 1
-        for i in nums[1:]:
-            if count == 0:
-                cand, count = i, 1
+        candidate, count = nums[0], 0
+        for num in nums:
+            if num == candidate:
+                count += 1
+            elif count == 0:
+                candidate, count = num, 1
             else:
-                if i == cand:
-                    count = count + 1
-                else:
-                    count = count - 1
-        return cand
-"""一行的思路"""
-class Solution(object):
-    def majorityElement(self, nums):
-        """
-        :type nums: List[int]
-        :rtype: int
-        """
-        return sorted(nums)[len(nums)/2]
+                count -= 1
+        return candidate
+

From 3076e82a26fae88979a8987a5d0680eef8e5d133 Mon Sep 17 00:00:00 2001
From: ysfei <ysfei92@gmail.com>
Date: Tue, 5 Apr 2022 16:39:06 -0500
Subject: [PATCH 08/22] Update 169. Majority Element.py

---
 sort_by_leetcode/array/easy/169. Majority Element.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/sort_by_leetcode/array/easy/169. Majority Element.py b/sort_by_leetcode/array/easy/169. Majority Element.py
index 72c33a0..a0b378e 100644
--- a/sort_by_leetcode/array/easy/169. Majority Element.py	
+++ b/sort_by_leetcode/array/easy/169. Majority Element.py	
@@ -11,8 +11,8 @@
 
 """
 
-"""
-暴力解法(n^2)：
+
+#暴力解法(n^2)：
 class Solution(object):
     def majorityElement(self, nums):
         majority_count = len(nums)//2
@@ -20,16 +20,16 @@ def majorityElement(self, nums):
             count = sum(1 for elem in nums if elem == num)
             if count > majority_count:
                 return num
-这里可以学习对list里出现某个值的计数方法：count = sum(1 for i in nums if i==target)
-但这个解法暴力在sum(1 for ...)本身也是循环，所以复杂度是n^2.
+#这里可以学习对list里出现某个值的计数方法：count = sum(1 for i in nums if i==target)
+#但这个解法暴力在sum(1 for ...)本身也是循环，所以复杂度是n^2.
 
-巧思路（NlogN)
+#巧思路（NlogN)
 class Solution:
     def majorityElement(self, nums):
         nums.sort()
         return nums[len(nums)//2]
         #或者直接一行：return sorted(nums)[len(nums)//2]
-缺点是sort的时间复杂度是NlogN
+#缺点是sort的时间复杂度是NlogN
 
 Hash table解法(n):
 from collections import Counter

From ffa045cd9ae8159287f99232d50dd78989ff8fc1 Mon Sep 17 00:00:00 2001
From: ysfei <ysfei92@gmail.com>
Date: Tue, 5 Apr 2022 16:39:49 -0500
Subject: [PATCH 09/22] Update 169. Majority Element.py

---
 sort_by_leetcode/array/easy/169. Majority Element.py | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/sort_by_leetcode/array/easy/169. Majority Element.py b/sort_by_leetcode/array/easy/169. Majority Element.py
index a0b378e..f929086 100644
--- a/sort_by_leetcode/array/easy/169. Majority Element.py	
+++ b/sort_by_leetcode/array/easy/169. Majority Element.py	
@@ -28,22 +28,24 @@ class Solution:
     def majorityElement(self, nums):
         nums.sort()
         return nums[len(nums)//2]
-        #或者直接一行：return sorted(nums)[len(nums)//2]
-#缺点是sort的时间复杂度是NlogN
+#或者直接一行：return sorted(nums)[len(nums)//2]
+#sort的时间复杂度是NlogN
 
-Hash table解法(n):
+#Hash table解法(n):
 from collections import Counter
 class Solution:
     def majorityElement(self, nums):
         counts = Counter(nums)
         return max(counts.keys(), key=counts.get)
+'''
 这里import了Counter函数，直接生成各个值的频度表，format是dictionary (Hash table)
 max函数的key选项用于比大小的数字和return数字不同的情况，比如要比较x^2时就用 max(nums, key=lambda x: x**2)
 counts.keys()表示要return的数字是ditionary keys种的一个（得有括号，否则只是个函数）。counts.get是个函数（没有括号），给出key对应的值
 也可以把函数用lambda写出来 max(counts.keys(), key=lambda x:counts[x])
 Counter和max都是n时间复杂度，所以总共时间复杂度也是n。
+'''
 
-Boyer-Moore Voting Algorithm （n)
+#Boyer-Moore Voting Algorithm （n)
 class Solution(object):
     def majorityElement(self, nums):
         candidate, count = nums[0], 0

From c3a6edf36982f16240e7e880e0ad47e065a3d6ec Mon Sep 17 00:00:00 2001
From: ysfei <ysfei92@gmail.com>
Date: Thu, 7 Apr 2022 14:41:52 -0500
Subject: [PATCH 10/22] Update 189. Rotate Array.py

---
 sort_by_leetcode/array/easy/189. Rotate Array.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/sort_by_leetcode/array/easy/189. Rotate Array.py b/sort_by_leetcode/array/easy/189. Rotate Array.py
index a0d8166..989fa2f 100644
--- a/sort_by_leetcode/array/easy/189. Rotate Array.py	
+++ b/sort_by_leetcode/array/easy/189. Rotate Array.py	
@@ -19,7 +19,8 @@
 """
 """直接拼接数组即可"""
 
-
+#就是左边变成n-k+1到n，右边变成1到n-k. 注意slicing是左开右闭，所以写成nums[n-k:n]和nums[0:n-k].而0和n是起始index所以可以省略
+#不知道为什么LHS写成nums[:]，直接用nums就可以了，别忘了还要写return nums
 class Solution(object):
     def rotate(self, nums, k):
         """

From 5594d75b73c66b1fcccc9af32e6c0c6b76242776 Mon Sep 17 00:00:00 2001
From: ysfei <ysfei92@gmail.com>
Date: Thu, 7 Apr 2022 15:03:57 -0500
Subject: [PATCH 11/22] Update 217. Contains Duplicate.py

---
 .../array/easy/217. Contains Duplicate.py           | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/sort_by_leetcode/array/easy/217. Contains Duplicate.py b/sort_by_leetcode/array/easy/217. Contains Duplicate.py
index 7ffa8a3..460d885 100644
--- a/sort_by_leetcode/array/easy/217. Contains Duplicate.py	
+++ b/sort_by_leetcode/array/easy/217. Contains Duplicate.py	
@@ -6,7 +6,8 @@
 
 """
 """利用hash table，别忘了判断空数组的情况.其实更麻烦"""
-
+#如果是暴力解法，会在loop over num的过程中再与过去的出现过的num进行比较，O(N^2).
+#所以常用技巧就是把查找过去出现过的num的任务交给dict，num in dict的复杂度只O(1).所以总的复杂度只有O(N)
 class Solution(object):
     def containsDuplicate(self, nums):
         """
@@ -15,19 +16,19 @@ def containsDuplicate(self, nums):
         """
         if not nums:
             return False
-        dic = dict()
+        dic = dict() #建立空dict的方法： dict()
         for num in nums:
             if num in dic:
-                return True
-            dic[num] = 1
+                return True #一旦出现return，整个def直接结束（不只是loop结束）
+            dic[num] = 1 #if num in dic的in函数判断的是keys而不是dic中的values，所以直接用当前num作为key，value就随便（比如1）
         return False
 
 """直接利用set的性质反而更简单"""
-
+#set()提取nums中的distinct values生成一个set. 原因很简单：set这种data type不能包含重复元素
 class Solution(object):
     def containsDuplicate(self, nums):
         """
         :type nums: List[int]
         :rtype: bool
         """
-        return len(nums) != len(set(nums))
\ No newline at end of file
+        return len(nums) != len(set(nums))

From 33f8245af0c100690d88fff012d2bd7aba10794f Mon Sep 17 00:00:00 2001
From: ysfei <ysfei92@gmail.com>
Date: Thu, 7 Apr 2022 15:18:50 -0500
Subject: [PATCH 12/22] Update 219. Contains Duplicate II.py

---
 .../array/easy/219. Contains Duplicate II.py             | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/sort_by_leetcode/array/easy/219. Contains Duplicate II.py b/sort_by_leetcode/array/easy/219. Contains Duplicate II.py
index 9d3f675..e321678 100644
--- a/sort_by_leetcode/array/easy/219. Contains Duplicate II.py	
+++ b/sort_by_leetcode/array/easy/219. Contains Duplicate II.py	
@@ -4,6 +4,11 @@
 
 """
 """仍然用dict保存数组元素出现的位置，两种情况下更新"""
+#和217一样，无非在判断num in dic时多加一个条件：index - dic[num] <= k
+#for i in nums: 返回list values
+#for i in dic: 返回dictionary keys, 相当于for i in dic.keys()
+#for i in dic.values(): 返回dictionary values
+#for i,value in dic.items(): 返回dictionary的 (key,value) pair
 class Solution(object):
     def containsNearbyDuplicate(self, nums, k):
         """
@@ -12,8 +17,8 @@ def containsNearbyDuplicate(self, nums, k):
         :rtype: bool
         """
         dic = dict()
-        for index,value in enumerate(nums):
+        for index,value in enumerate(nums): 
             if value in dic and index - dic[value] <= k:
                 return True
             dic[value] = index
-        return False
\ No newline at end of file
+        return False

From db7ad25720a64b6f3fc9205b340bd4f20faff9f6 Mon Sep 17 00:00:00 2001
From: ysfei <ysfei92@gmail.com>
Date: Thu, 7 Apr 2022 15:45:44 -0500
Subject: [PATCH 13/22] Update 189. Rotate Array.py

---
 sort_by_leetcode/array/easy/189. Rotate Array.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/sort_by_leetcode/array/easy/189. Rotate Array.py b/sort_by_leetcode/array/easy/189. Rotate Array.py
index 989fa2f..5ecbf43 100644
--- a/sort_by_leetcode/array/easy/189. Rotate Array.py	
+++ b/sort_by_leetcode/array/easy/189. Rotate Array.py	
@@ -19,7 +19,11 @@
 """
 """直接拼接数组即可"""
 
-#就是左边变成n-k+1到n，右边变成1到n-k. 注意slicing是左开右闭，所以写成nums[n-k:n]和nums[0:n-k].而0和n是起始index所以可以省略
+#就是左边变成n-k+1到n，右边变成1到n-k. 
+#注意slicing是左闭右开，同时index=position-1。所以写成nums[n-k:n]和nums[0:n-k].而0和n是起始index所以可以省略
+#rule of thumb 1: 如果想要slice positions [a,b], 写成nums[a-1:b], 里面个数是b-a+1.如果a-1=0或b=N可以省略，其中N是指len(nums)
+#rule of thumb 2: 反过来，code中的nums[a:b]指的是positions[a+1,b], 里面个数是b-a.如果a省略了说明a=0，那就是positions[1,b],如果b省略了说明b=N，那就是[a+1,N]
+#注意nums[N]不存在，但是nums[N-1:N]就是最后一个元素nums[N-1]
 #不知道为什么LHS写成nums[:]，直接用nums就可以了，别忘了还要写return nums
 class Solution(object):
     def rotate(self, nums, k):

From 61b7b3814af18f83738c5fceb0ebd8ecd0a9e0cb Mon Sep 17 00:00:00 2001
From: ysfei <ysfei92@gmail.com>
Date: Thu, 7 Apr 2022 15:48:51 -0500
Subject: [PATCH 14/22] Update 219. Contains Duplicate II.py

---
 sort_by_leetcode/array/easy/219. Contains Duplicate II.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/sort_by_leetcode/array/easy/219. Contains Duplicate II.py b/sort_by_leetcode/array/easy/219. Contains Duplicate II.py
index e321678..4e90c31 100644
--- a/sort_by_leetcode/array/easy/219. Contains Duplicate II.py	
+++ b/sort_by_leetcode/array/easy/219. Contains Duplicate II.py	
@@ -4,8 +4,9 @@
 
 """
 """仍然用dict保存数组元素出现的位置，两种情况下更新"""
-#和217一样，无非在判断num in dic时多加一个条件：index - dic[num] <= k
+#和217一样，无非在判断num in dic时多加一个条件：index - dic[num] <= k，以及在dict中的value不能乱写了，得用nums的index
 #for i in nums: 返回list values
+#for i,value in enumerate(nums): 返回nums的 (index,value) pair
 #for i in dic: 返回dictionary keys, 相当于for i in dic.keys()
 #for i in dic.values(): 返回dictionary values
 #for i,value in dic.items(): 返回dictionary的 (key,value) pair

From d9859fbc088d9cdb3c13f448eb555855e83e0ff8 Mon Sep 17 00:00:00 2001
From: ysfei <ysfei92@gmail.com>
Date: Thu, 7 Apr 2022 17:27:21 -0500
Subject: [PATCH 15/22] Update 26. Remove Duplicates from Sorted Array.py

---
 .../array/easy/26. Remove Duplicates from Sorted Array.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/sort_by_leetcode/array/easy/26. Remove Duplicates from Sorted Array.py b/sort_by_leetcode/array/easy/26. Remove Duplicates from Sorted Array.py
index 12e3617..72a13ca 100644
--- a/sort_by_leetcode/array/easy/26. Remove Duplicates from Sorted Array.py	
+++ b/sort_by_leetcode/array/easy/26. Remove Duplicates from Sorted Array.py	
@@ -14,7 +14,11 @@
 """
 
 """题目要点：返回不重复数的个数，同时要排在数组的前面n个"""
-
+#loop over i in range(len(nums))
+#如果num[i]和第一个num相同就跳过，如果不同就留下replace第二个num (index=1, replacenums[1])，进入下一个i; 
+#...
+#如果num[i]和上一个num相同就跳过，如果不同就留下replace上一个num的后面那一个 (index=index+1并replace nums[index])，进入下一个i;
+#因为i的增速>=index的增速，所以replace nums[index]不会影响之后对nums[i]的比较
 class Solution(object):
     def removeDuplicates(self, nums):
         """
@@ -29,4 +33,4 @@ def removeDuplicates(self, nums):
                 index = index + 1
                 nums[index] = nums[i]
 
-        return index + 1
\ No newline at end of file
+        return index + 1

From b03e8b4650d0da10629c7b322faa5855055f73d2 Mon Sep 17 00:00:00 2001
From: ysfei <ysfei92@gmail.com>
Date: Thu, 7 Apr 2022 17:40:27 -0500
Subject: [PATCH 16/22] Update 268. Missing Number.py

---
 .../array/easy/268. Missing Number.py             | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/sort_by_leetcode/array/easy/268. Missing Number.py b/sort_by_leetcode/array/easy/268. Missing Number.py
index 825169f..9a0f76f 100644
--- a/sort_by_leetcode/array/easy/268. Missing Number.py	
+++ b/sort_by_leetcode/array/easy/268. Missing Number.py	
@@ -6,9 +6,18 @@
 
 Note:
 Your algorithm should run in linear runtime complexity. Could you implement it using only constant extra space complexity?
-
 """
-"""利用求和公式求解"""
+
+#brute force, O(N)
+class Solution(object):
+    def missingNumber(self, nums):
+        nums.sort()
+        for i,num in enumerate(nums):
+            if num != i:
+                return num
+        
+
+"""利用求和公式求解, O(1)"""
 class Solution(object):
     def missingNumber(self, nums):
         """
@@ -16,4 +25,4 @@ def missingNumber(self, nums):
         :rtype: int
         """
         n = len(nums)
-        return n * (n+1) / 2 - sum(nums)
\ No newline at end of file
+        return n * (n+1) / 2 - sum(nums) #一个list求和很方便：sum(nums)

From 29b800b9eeba5e386b2307b629f5f483b134044a Mon Sep 17 00:00:00 2001
From: ysfei <ysfei92@gmail.com>
Date: Thu, 7 Apr 2022 17:52:20 -0500
Subject: [PATCH 17/22] Update 27. Remove Element.py

---
 .../array/easy/27. Remove Element.py             | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/sort_by_leetcode/array/easy/27. Remove Element.py b/sort_by_leetcode/array/easy/27. Remove Element.py
index 70c7c01..848bd78 100644
--- a/sort_by_leetcode/array/easy/27. Remove Element.py	
+++ b/sort_by_leetcode/array/easy/27. Remove Element.py	
@@ -18,6 +18,20 @@
 """类似于26题的思路，要点是要把不等于目标值的元素放到数组前面
 时间复杂度O（n）
 """
+class Solution(object):
+    def removeElement(self, nums, val):
+        """
+        :type nums: List[int]
+        :type val: int
+        :rtype: int
+        """
+        index = 0
+        for i in range(len(nums)):
+            if nums[i] != val:
+                nums[index] = nums[i]
+
+
+
 class Solution(object):
     def removeElement(self, nums, val):
         """
@@ -30,4 +44,4 @@ def removeElement(self, nums, val):
             if nums[i] != val:
                 nums[index] = nums[i]
                 index = index + 1
-        return index
\ No newline at end of file
+        return index

From fce8048e5eabe8eb0d52164e341392ea9d1bf1ed Mon Sep 17 00:00:00 2001
From: ysfei <ysfei92@gmail.com>
Date: Thu, 7 Apr 2022 18:59:41 -0500
Subject: [PATCH 18/22] Update 27. Remove Element.py

---
 sort_by_leetcode/array/easy/27. Remove Element.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/sort_by_leetcode/array/easy/27. Remove Element.py b/sort_by_leetcode/array/easy/27. Remove Element.py
index 848bd78..20838cf 100644
--- a/sort_by_leetcode/array/easy/27. Remove Element.py	
+++ b/sort_by_leetcode/array/easy/27. Remove Element.py	
@@ -18,6 +18,7 @@
 """类似于26题的思路，要点是要把不等于目标值的元素放到数组前面
 时间复杂度O（n）
 """
+#again, 之所以可以不用管i，直接替换index对应的值是因为：index <= i总是成立，所以改变nums[index]不影响下一轮对nums[i+1]的比较
 class Solution(object):
     def removeElement(self, nums, val):
         """
@@ -29,6 +30,8 @@ def removeElement(self, nums, val):
         for i in range(len(nums)):
             if nums[i] != val:
                 nums[index] = nums[i]
+                index += 1
+        return index
 
 
 

From 467a80b75691c38e6b22e8a4e932450b04f5a951 Mon Sep 17 00:00:00 2001
From: ysfei <ysfei92@gmail.com>
Date: Fri, 6 May 2022 11:49:16 -0500
Subject: [PATCH 19/22] Create README.md

---
 README.md | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 README.md

diff --git a/README.md b/README.md
new file mode 100644
index 0000000..b36b88a
--- /dev/null
+++ b/README.md
@@ -0,0 +1,6 @@
+# Cheat Sheet
+slicing: nums[a,b]左闭右开，对应index: a到(b-1)，对应1-based position: (a+1)到b
+
+range: range(a,b)左闭右开，表示a到b-1（所以nums[a,b]相当于用range(a,b)生成index a到(b-1), 然后调用index对应的position (a+1)到b）
+
+pandas.DataFrame: df[a:b] and df.loc[a:b,:]都是用

From 15cd1bb50442eacf52194b8da156cfacf7b35310 Mon Sep 17 00:00:00 2001
From: ysfei <ysfei92@gmail.com>
Date: Fri, 6 May 2022 14:17:13 -0500
Subject: [PATCH 20/22] Update README.md

---
 README.md | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index b36b88a..b44b252 100644
--- a/README.md
+++ b/README.md
@@ -3,4 +3,12 @@ slicing: nums[a,b]左闭右开，对应index: a到(b-1)，对应1-based position
 
 range: range(a,b)左闭右开，表示a到b-1（所以nums[a,b]相当于用range(a,b)生成index a到(b-1), 然后调用index对应的position (a+1)到b）
 
-pandas.DataFrame: df[a:b] and df.loc[a:b,:]都是用
+pandas.DataFrame: df[a:b] and df.iloc[a:b, :]都是左闭右开，取index: a到b-1的行
+
+所以，只用记得code中的范围左闭右开后就是index范围，不要老想实际位置，只要记得位置等于index+1就行了
+
+特例： 
+df.loc在slice时包含start和end
+df.loc[2:5, :]表示index为2到5的行，所以左右都是闭区间  
+而要回到iloc的范围的话就得使用df.loc[df.index[2:5], :]，即先利用普通slice的左闭右开性质，取df.index中的2到4，强行去掉5 (df.index是一个RangeIndex data type)
+note: 若非特殊说明，以上都是在讲index (start from 0)

From 9675dcf1902d00348089871107574917acd63139 Mon Sep 17 00:00:00 2001
From: ysfei <ysfei92@gmail.com>
Date: Fri, 6 May 2022 14:17:25 -0500
Subject: [PATCH 21/22] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index b44b252..bae53a4 100644
--- a/README.md
+++ b/README.md
@@ -10,5 +10,5 @@ pandas.DataFrame: df[a:b] and df.iloc[a:b, :]都是左闭右开，取index: a到
 特例： 
 df.loc在slice时包含start和end
 df.loc[2:5, :]表示index为2到5的行，所以左右都是闭区间  
-而要回到iloc的范围的话就得使用df.loc[df.index[2:5], :]，即先利用普通slice的左闭右开性质，取df.index中的2到4，强行去掉5 (df.index是一个RangeIndex data type)
+而要回到iloc的范围的话就得使用df.loc[df.index[2:5], :]，即先利用普通slice的左闭右开性质，取df.index中的2到4，强行去掉5 (df.index是一个RangeIndex data type)  
 note: 若非特殊说明，以上都是在讲index (start from 0)

From 9b2fa456f13ac58ca42581f727b3fef31636acec Mon Sep 17 00:00:00 2001
From: ysfei <ysfei92@gmail.com>
Date: Sun, 17 Mar 2024 13:01:54 -0700
Subject: [PATCH 22/22] Update README.md

---
 README.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/README.md b/README.md
index bae53a4..4984ac2 100644
--- a/README.md
+++ b/README.md
@@ -12,3 +12,7 @@ df.loc在slice时包含start和end
 df.loc[2:5, :]表示index为2到5的行，所以左右都是闭区间  
 而要回到iloc的范围的话就得使用df.loc[df.index[2:5], :]，即先利用普通slice的左闭右开性质，取df.index中的2到4，强行去掉5 (df.index是一个RangeIndex data type)  
 note: 若非特殊说明，以上都是在讲index (start from 0)
+
+#48
+如果是顺时针旋转90度，transpose, then reverse order within each row (equivalently, 先reverse within each column再transpose)
+如果是逆时针旋转90度，transpose, then reverse order within each column