regular leetcode

Author: KrisYu

002._add_two_numbers.md

@@ -0,0 +1,37 @@
+###2. Add Two Numbers
+
+题目： 
+<https://leetcode.com/problems/add-two-numbers/>
+
+
+难度 : Medium
+
+
+跟plus One, add Binary 玩的同一种花样
+
+
+```
+class Solution(object):
+    def addTwoNumbers(self, l1, l2):
+        """
+        :type l1: ListNode
+        :type l2: ListNode
+        :rtype: ListNode
+        """
+        #easiest case
+        if l1 == None:
+            return l2
+        if l2 == None:
+            return l1
+        
+        if l1.val + l2.val < 10:
+            l3 = ListNode(l1.val + l2.val)
+            l3.next = self.addTwoNumbers(l1.next, l2.next)
+
+        elif l1.val + l2.val >= 10:
+            l3 = ListNode(l1.val + l2.val - 10)
+            tmp = ListNode(1)
+            tmp.next = None
+            l3.next = self.addTwoNumbers(l1.next, self.addTwoNumbers(l2.next ,tmp))
+        return l3
+```

024._swap_nodes_in_pairs.md

@@ -0,0 +1,35 @@
+###24. Swap Nodes in Pairs
+
+题目： 
+<https://leetcode.com/problems/swap-nodes-in-pairs/>
+
+
+难度 : Easy
+
+看了hint，用loop做，每个node关系要弄清楚
+
+
+```
+
+class Solution(object):
+    def swapPairs(self, head):
+        """
+        :type head: ListNode
+        :rtype: ListNode
+        """
+        if head == None or head.next == None:
+            return head
+
+        dummy = ListNode(-1)
+        dummy.next = head
+        
+        cur = dummy
+
+        while cur.next and cur.next.next:
+            next_one, next_two, next_three = cur.next, cur.next.next, cur.next.next.next
+            cur.next = next_two
+            next_two.next = next_one
+            next_one.next = next_three
+            cur = next_one
+        return dummy.next
+```

049._group_anagrams_python.md

@@ -0,0 +1,38 @@
+###49. Group Anagrams python
+
+题目： 
+<https://leetcode.com/problems/anagrams/>
+
+
+难度 : Medium
+
+我又来使用我的取巧神奇python大法 
+
+
+```
+class Solution(object):
+    def groupAnagrams(self, strs):
+        """
+        :type strs: List[str]
+        :rtype: List[List[str]]
+        """
+        mapx = {}
+        for str1 in strs:
+           key = self.sortedWord(str1)
+           if key in mapx:
+               mapx[key].append(str1)
+           else:
+               mapx[key] = [str1]
+        return list(mapx.values()) 
+        
+    def sortedWord(self,s):
+        """
+        :type s: str
+        :type t: str
+        :rtype: bool
+        """
+        sList = sorted(list(s))
+        str1 = ''.join(sList)
+        return str1
+
+```

066._plus_one.md

@@ -0,0 +1,31 @@
+###66. Plus One
+
+题目： 
+<https://leetcode.com/problems/plus-one/>
+
+
+难度 : Easy
+
+
+
+
+奇怪的AC了
+😄
+搞笑
+
+
+```
+
+class Solution(object):
+    def plusOne(self, digits):
+        """
+        :type digits: List[int]
+        :rtype: List[int]
+        """
+        if digits == []:
+            return [1]
+        if digits[-1] < 9:
+            return digits[:-1] + [digits[-1] + 1]
+        else:
+            return self.plusOne(digits[:-1]) + [0]
+```

067._add_binary.md

@@ -0,0 +1,33 @@
+###67. Add Binary
+
+题目： 
+<https://leetcode.com/problems/add-binary/>
+
+
+难度 : Easy
+
+
+几种case：
+
+- a or b 为空，最简单
+- 唯一的问题是如果有进位的处理，进位的处理就是先让其中的一个数addBinary +1 ，然后再用addBinary
+
+```
+
+        
+class Solution(object):
+    def addBinary(self, a, b):
+        """
+        :type a: str
+        :type b: str
+        :rtype: str
+        """
+        if (a == '' or b == ''):
+            return a + b
+        elif a[-1] == '0' and b[-1] == '0':
+            return self.addBinary(a[:-1], b[:-1])  +  '0'
+        elif a[-1] == '1' and b[-1] == '1':
+            return self.addBinary(a[:-1], self.addBinary(b[:-1],'1')) + '0'
+        else:
+            return self.addBinary(a[:-1], b[:-1]) + '1'
+```

223._rectangle_area.md

@@ -0,0 +1,50 @@
+###223. Rectangle Area
+
+题目： 
+<https://leetcode.com/problems/add-two-numbers/>
+
+
+难度 : Easy
+
+
+这道题是我瞎了狗眼，🐶，之前看错了，以为要求相交的部分，结果是求cover的部分，所以写的长||||||
+
+
+```
+class Solution(object):
+    def computeArea(self, A, B, C, D, E, F, G, H):
+        """
+        :type A: int
+        :type B: int
+        :type C: int
+        :type D: int
+        :type E: int
+        :type F: int
+        :type G: int
+        :type H: int
+        :rtype: int
+        """
+        return self.area(C - A, D - B) + self.area(H - F, G - E ) - self.area(self.interSect(A,C,E,G), self.interSect(B,D,F,H))
+            
+    def area(self, w, h):
+        if w * h < 0:
+            return - w * h
+        return w * h
+        
+    
+    def interSect(self, A, C, E, G):
+        if E > C:
+            return 0
+        elif G < A:
+            return 0
+        elif E >= A and G <= C:
+            return G - E
+        elif A >= E and C <= G:
+            return C - A
+        elif G <= C and G >= A and E <= A:
+            return G - A
+        else:
+            return C - E
+            
+            
+```

235._lowest_common_ancestor_of_a_binary_search_tree.md

@@ -0,0 +1,33 @@
+###235. Lowest Common Ancestor of a Binary Search Tree
+
+题目： 
+<https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/>
+
+
+难度 : Easy
+
+- 两个node，一个大于root，一个小于root，那么必定root两边，共同的ancestor是root，同时再考虑同为空的状况
+- 两个node，都比node小，到左边去寻找，那么先找到那个必定是common ancestor
+- 两个node，都比node大，类似....
+
+
+AC解法
+
+```
+class Solution(object):
+    def lowestCommonAncestor(self, root, p, q):
+        """
+        :type root: TreeNode
+        :type p: TreeNode
+        :type q: TreeNode
+        :rtype: TreeNode
+        """
+        if root == None or root == p or root == q:
+            return root
+        elif p.val < root.val < q.val or q.val < root.val < p.val :
+            return root
+        elif p.val < root.val and q.val < root.val:
+            return self.lowestCommonAncestor(root.left,p,q)
+        else:
+            return self.lowestCommonAncestor(root.right,p,q)
+```

242._valid_anagram.md

@@ -24,3 +24,31 @@ class Solution(object):
             
 ```
 
+
+作弊神奇python大法，看了看别人的解法，用字数统计，因为只可能是26个字母
+
+然后发现作弊大法居然更快
+
+```
+
+class Solution(object):
+    def isAnagram(self, s, t):
+        """
+        :type s: str
+        :type t: str
+        :rtype: bool
+        """
+        if len(s) != len(t):
+            return False
+        
+        charCnt = [0] * 26
+        
+        for i in range(len(s)):
+            charCnt[ord(s[i]) - 97] += 1
+        
+        for i in range(len(t)):
+            charCnt[ord(t[i]) - 97] -= 1 
+            if charCnt[ord(t[i]) - 97] < 0:
+                return False
+        return True
+```

292._nim_game.md

@@ -0,0 +1,55 @@
+###292. Nim Game
+
+题目:
+
+<https://leetcode.com/problems/nim-game/>
+
+
+难度:
+
+Easy
+
+
+对于总是优先开始的那方
+
+
+- 有一到三块，总是赢
+- 有四块，总是输
+- 有五块，总是赢
+
+所以如果自己想赢，总是要迫使对方拿之后，给自己遗留5块，或者三块以及以下。
+
+- 如果是六块：
+	- 拿一块，对方五块，对方赢
+	- 拿两块，对方余下四块，我方赢
+	- 拿三块，余三块，对方赢
+	
+- 七块：
+	- 拿三块，余四块，迫使对方输，总是赢
+
+本打算用递归来看，因为对方也可以重复使用这个函数，但是会超时，所以就看了一下hint
+
+
+- n <= 3 能赢 √
+- n == 4 总输 
+- n = 5,6,7 总赢
+- n == 8， 先手如何选，总可以转成5,6,7 对方总会赢
+
+
+所以 n % 4 != 0 时候，先手必胜
+
+简直是啊，有些游戏就是这样来必赢的啊，没想到你是这样的题目
+
+
+
+```
+class Solution(object):
+    def canWinNim(self, n):
+        """
+        :type n: int
+        :rtype: bool
+        """
+        return n % 4 != 0
+```
+        
+