added some python solutions

Author: Kurt-Yu

README.md

@@ -8,9 +8,12 @@ LeetCode
 
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|976|[Largest Perimeter Triangle](https://leetcode.com/problems/largest-perimeter-triangle/) | [Python](./algorithms/python/LargestPerimeterTriangle/largestPerimeter.py)|Easy|
 |971|[Flip Binary Tree To Match Preorder Traversal](https://leetcode.com/problems/flip-binary-tree-to-match-preorder-traversal/) | [Python](./algorithms/python/FlipBinaryTreeToMatchPreorderTraversal/flipMatchVoyage.py)|Medium|
+|969|[Pancake Sorting](https://leetcode.com/problems/pancake-sorting/) | [Python](./algorithms/python/PancakeSorting/pancakeSort.py)|Medium|
 |958|[Check Completeness of a Binary Tree](https://leetcode.com/problems/check-completeness-of-a-binary-tree/) | [Python](./algorithms/python/CheckCompletenessOfABinaryTree/isCompleteTree.py)|Medium|
 |951|[Flip Equivalent Binary Trees](https://leetcode.com/problems/flip-equivalent-binary-trees/) | [Python](./algorithms/python/FlipEquivalentBinaryTrees/flipEquiv.py)|Medium|
+|950|[Reveal Cards In Increasing Order](https://leetcode.com/problems/reveal-cards-in-increasing-order/) | [Python](./algorithms/python/RevealCardsInIncreasingOrder/deckRevealedIncreasing.py)|Medium|
 |859|[Buddy Strings](https://leetcode.com/problems/buddy-strings/description/) | [C++](./algorithms/cpp/buddyStrings/BuddyStrings.cpp)|Easy|
 |858|[Mirror Reflection](https://leetcode.com/problems/mirror-reflection/description/) | [C++](./algorithms/cpp/mirrorReflection/MirrorReflection.cpp)|Medium|
 |852|[Peak Index in a Mountain Array](https://leetcode.com/problems/peak-index-in-a-mountain-array/description/) | [C++](./algorithms/cpp/peakIndexInAMountainArray/PeakIndexInAMountainArray.cpp)|Easy|
@@ -30,6 +33,7 @@ LeetCode
 |563|[Binary Tree Tilt](https://leetcode.com/problems/binary-tree-tilt/) | [Python](./algorithms/python/BinaryTreeTilt/findTilt.py)|Easy|
 |543|[Diameter of Binary Tree](https://leetcode.com/problems/diameter-of-binary-tree/) | [Python](./algorithms/python/DiameterOfBinaryTree/diameterOfBinaryTree.py)|Easy|
 |538|[Convert BST to Greater Tree](https://leetcode.com/problems/convert-bst-to-greater-tree/) | [Python](./algorithms/python/ConvertBSTtoGreaterTree/convertBST.py)|Easy|
+|509|[Fibonacci Number](https://leetcode.com/problems/fibonacci-number/) | [Python](./algorithms/python/FibonacciNumber/fib.py)|Easy|
 |477|[Total Hamming Distance](https://leetcode.com/problems/total-hamming-distance/) | [C++](./algorithms/cpp/totalHammingDistance/totalHammingDistance.cpp)|Medium|
 |450|[DeleteNodeInABST](https://leetcode.com/problems/delete-node-in-a-bst/) | [Python](./algorithms/python/DeleteNodeInABST/deleteNode.py)|Medium|
 |449|[Serialize and Deserialize BST](https://leetcode.com/problems/serialize-and-deserialize-bst/) | [Python](./algorithms/python/SerializeAndDeserializeBST/serialize.py)|Medium|
@@ -130,8 +134,8 @@ LeetCode
 |258|[Add Digits](https://leetcode.com/problems/add-digits/)| [C++](./algorithms/cpp/addDigits/addDigits.cpp)|Easy|
 |257|[Binary Tree Paths](https://leetcode.com/problems/binary-tree-paths/)| [C++](./algorithms/cpp/binaryTreePaths/binaryTreePaths.cpp)|Easy|
 |242|[Valid Anagram](https://leetcode.com/problems/valid-anagram/)| [C++](./algorithms/cpp/anagrams/ValidAnagram.cpp), [Java](./algorithms/java/src/validAnagram/ValidAnagram.java)|Easy|
-|241|[Different Ways to Add Parentheses](https://leetcode.com/problems/different-ways-to-add-parentheses/)|[C++](./algorithms/cpp/differentWaysToAddParentheses/DifferentWaysToAddParentheses.cpp)|Medium|
-|240|[Search a 2D Matrix II](https://leetcode.com/problems/search-a-2d-matrix-ii/)|[C++](./algorithms/cpp/search2DMatrix/search2DMatrix.II.cpp), [Java](./algorithms/java/src/searchA2DMatrixII/SearchA2DMatrixII.java)|Medium|
+|241|[Different Ways to Add Parentheses](https://leetcode.com/problems/different-ways-to-add-parentheses/)|[C++](./algorithms/cpp/differentWaysToAddParentheses/DifferentWaysToAddParentheses.cpp), [Python](./algorithms/python/DifferentWaysToAddParentheses/diffWaysToCompute.py)|Medium|
+|240|[Search a 2D Matrix II](https://leetcode.com/problems/search-a-2d-matrix-ii/)|[C++](./algorithms/cpp/search2DMatrix/search2DMatrix.II.cpp), [Java](./algorithms/java/src/searchA2DMatrixII/SearchA2DMatrixII.java), [Python](./algorithms/python/SearchA2DMatrixII/searchMatrix.py)|Medium|
 |239|[Sliding Window Maximum](https://leetcode.com/problems/sliding-window-maximum/)| [C++](./algorithms/cpp/slidingWindowMaximum/SlidingWindowMaximum.cpp)|Hard|
 |238|[Product of Array Except Self](https://leetcode.com/problems/product-of-array-except-self/)| [C++](./algorithms/cpp/productOfArrayExceptSelf/ProductOfArrayExceptSelf.cpp)|Medium|
 |237|[Delete Node in a Linked List](https://leetcode.com/problems/delete-node-in-a-linked-list/)| [C++](./algorithms/cpp/deleteNodeInALinkedList/DeleteNodeInALinkedList.cpp)|Easy|
@@ -169,11 +173,11 @@ LeetCode
 |205|[Isomorphic Strings](https://leetcode.com/problems/isomorphic-strings/)| [C++](./algorithms/cpp/isomorphicStrings/IsomorphicStrings.cpp)|Easy|
 |204|[Count Primes](https://leetcode.com/problems/count-primes/)| [C++](./algorithms/cpp/countPrimes/CountPrimes.cpp)|Easy|
 |203|[Remove Linked List Elements](https://leetcode.com/problems/remove-linked-list-elements/)| [C++](./algorithms/cpp/removeLinkedListElements/RemoveLinkedListElements.cpp)|Easy|
-|202|[Happy Number](https://leetcode.com/problems/happy-number/)| [C++](./algorithms/cpp/happyNumber/HappyNumber.cpp)|Easy|
+|202|[Happy Number](https://leetcode.com/problems/happy-number/)| [C++](./algorithms/cpp/happyNumber/HappyNumber.cpp), [Python](./algorithms/python/HappyNumber/isHappy.py)|Easy|
 |201|[Bitwise AND of Numbers Range](https://leetcode.com/problems/bitwise-and-of-numbers-range/)| [C++](./algorithms/cpp/bitwiseANDOfNumbersRange/BitwiseAndOfNumbersRange.cpp)|Medium|
-|200|[Number of Islands](https://leetcode.com/problems/number-of-islands/)| [C++](./algorithms/cpp/numberOfIslands/NumberOfIslands.cpp)|Medium|
+|200|[Number of Islands](https://leetcode.com/problems/number-of-islands/)| [C++](./algorithms/cpp/numberOfIslands/NumberOfIslands.cpp), [Python](./algorithms/python/NumberOfIslands/numIslands.py)|Medium|
 |199|[Binary Tree Right Side View](https://leetcode.com/problems/binary-tree-right-side-view/)| [C++](./algorithms/cpp/binaryTreeRightSideView/binaryTreeRightSideView.cpp)|Medium|
-|198|[House Robber](https://leetcode.com/problems/house-robber/)| [C++](./algorithms/cpp/houseRobber/houseRobber.cpp)|Easy|
+|198|[House Robber](https://leetcode.com/problems/house-robber/)| [C++](./algorithms/cpp/houseRobber/houseRobber.cpp), [Python](./algorithms/python/HouseRobber/rob.py)|Easy|
 |191|[Number of 1 Bits](https://oj.leetcode.com/problems/number-of-1-bits/)| [C++](./algorithms/cpp/numberOf1Bits/numberOf1Bits.cpp)|Easy|
 |190|[Reverse Bits](https://oj.leetcode.com/problems/reverse-bits/)| [C++](./algorithms/cpp/reverseBits/reverseBits.cpp)|Easy|
 |189|[Rotate Array](https://oj.leetcode.com/problems/rotate-array/)| [C++](./algorithms/cpp/rotateArray/rotateArray.cpp), [Java](./algorithms/java/src/rotateArray/RotateArray.java)|Easy|
@@ -212,12 +216,12 @@ LeetCode
 |146|[LRU Cache](https://oj.leetcode.com/problems/lru-cache/)| [C++](./algorithms/cpp/LRUCache/LRUCache.cpp), [Java](./algorithms/java/src/lruCache/LRUCache.java)|Hard|
 |145|[Binary Tree Postorder Traversal](https://oj.leetcode.com/problems/binary-tree-postorder-traversal/)| [C++](./algorithms/cpp/binaryTreePostorderTraversal/binaryTreePostorderTraversal.cpp), [Python](./algorithms/python/BinaryTreePostorderTraversal/postorderTraversal.py)|Hard|
 |144|[Binary Tree Preorder Traversal](https://oj.leetcode.com/problems/binary-tree-preorder-traversal/)| [C++](./algorithms/cpp/binaryTreePreorderTraversal/binaryTreePreorderTraversal.cpp), [Java](./algorithms/java/src/binaryTreePreorderTraversal/binaryTreePreorderTraversal.java)|Medium|
-|143|[Reorder List](https://oj.leetcode.com/problems/reorder-list/)| [C++](./algorithms/cpp/reorderList/reorderList.cpp)|Medium|
-|142|[Linked List Cycle II](https://oj.leetcode.com/problems/linked-list-cycle-ii/)| [C++](./algorithms/cpp/linkedListCycle/linkedListCycle.II.cpp)|Medium|
+|143|[Reorder List](https://oj.leetcode.com/problems/reorder-list/)| [C++](./algorithms/cpp/reorderList/reorderList.cpp), [Python](./algorithms/python/ReorderList/reorderList.py)|Medium|
+|142|[Linked List Cycle II](https://oj.leetcode.com/problems/linked-list-cycle-ii/)| [C++](./algorithms/cpp/linkedListCycle/linkedListCycle.II.cpp), [Python](./algorithms/python/LinkedListCycleII/detectCycle.py)|Medium|
 |141|[Linked List Cycle](https://oj.leetcode.com/problems/linked-list-cycle/)| [C++](./algorithms/cpp/linkedListCycle/linkedListCycle.cpp)|Medium|
 |140|[Word Break II](https://oj.leetcode.com/problems/word-break-ii/)| [C++](./algorithms/cpp/wordBreak/wordBreak.II.cpp)|Hard|
 |139|[Word Break](https://oj.leetcode.com/problems/word-break/)| [C++](./algorithms/cpp/wordBreak/wordBreak.cpp)|Medium|
-|138|[Copy List with Random Pointer](https://oj.leetcode.com/problems/copy-list-with-random-pointer/)| [C++](./algorithms/cpp/copyListWithRandomPointer/copyListWithRandomPointer.cpp)|Hard|
+|138|[Copy List with Random Pointer](https://oj.leetcode.com/problems/copy-list-with-random-pointer/)| [C++](./algorithms/cpp/copyListWithRandomPointer/copyListWithRandomPointer.cpp), [Python](./algorithms/python/CopyListWithRandomPointer/copyRandomList.py)|Hard|
 |137|[Single Number II](https://oj.leetcode.com/problems/single-number-ii/)| [C++](./algorithms/cpp/singleNumber/singleNumber.II.cpp)|Medium|
 |136|[Single Number](https://oj.leetcode.com/problems/single-number/)| [C++](./algorithms/cpp/singleNumber/singleNumber.cpp)|Medium|
 |135|[Candy](https://oj.leetcode.com/problems/candy/)| [C++](./algorithms/cpp/candy/candy.cpp)|Hard|

algorithms/python/CopyListWithRandomPointer/copyRandomList.py

@@ -0,0 +1,51 @@
+# method 1: using a dict and store each node as key, each copied node as value
+# Space complexity: O(n)
+# Time complexity: O(n)
+
+def copyRandomList(self, head):
+    d = {}
+    m = n = head
+    while m:
+        d[m] = RandomListNode(m.label)
+        m = m.next
+        
+    while n:
+        d[n].next = d.get(n.next)
+        d[n].random = d.get(n.random)
+        n = n.next
+        
+    return d.get(head)
+
+# Method 2:
+# Space complexity: O(1)
+# Time complexity: O(n)
+
+def copyRandomList(self, head):
+    if not head: return None
+    
+    # Step 1: copy each node and link them together with original ones 
+    curr = head
+    while curr:
+        new = RandomListNode(curr.label)
+        new.next = curr.next
+        curr.next = new
+        curr = curr.next.next
+    
+    # Step 2: build random node for each copied nodes
+    curr = head    
+    while curr:
+        if curr.random: curr.next.random = curr.random.next
+        curr = curr.next.next
+        
+    # Step 3: restore the original list and extract copied list
+    newhead = head.next
+    pold = head
+    pnew = newhead
+    while pnew.next:
+        pold.next = pnew.next
+        pold = pold.next
+        pnew.next = pold.next
+        pnew = pnew.next
+    pold.next = None
+    pnew.next = None
+    return newhead

algorithms/python/DifferentWaysToAddParentheses/diffWaysToCompute.py

@@ -0,0 +1,5 @@
+def diffWaysToCompute(self, input):
+    return [a + b if c == '+' else a - b if c == '-' else a * b \
+            for i, c in enumerate(input) if c in '+-*' \
+            for a in self.diffWaysToCompute(input[:i]) \
+            for b in self.diffWaysToCompute(input[i+1:])] or [int(input)]

algorithms/python/FibonacciNumber/fib.py

@@ -0,0 +1,27 @@
+"""
+Method 1: iterative:
+"""
+def fib1(self, N):
+    if N <= 1: return N
+    a, b = 0, 1
+    for _ in range(2, N + 1):
+        a, b = b, a + b
+    return b
+    
+"""
+Method 2: recursive without memorization:
+"""
+def fib2(self, N):
+    if N <= 1: return N
+    return self.fib(N - 1) + self.fib(N - 2)
+
+"""
+Method 3: recursive with memorization
+"""
+def fib3(self, N):
+    memo = {0:0, 1:1}
+    def helper(n):
+        if n not in memo:
+            memo[n] = helper(n - 1) + helper(n - 2)
+        return memo[n]
+    return helper(N)

algorithms/python/HappyNumber/isHappy.py

@@ -0,0 +1,33 @@
+# Method 1: straight forward solution, use a set to track if there is a cycle
+
+def isHappy1(self, n):
+    if n <= 0: return False
+    s = set()
+    while n not in s:
+        s.add(n)
+        n = sum([int(i) ** 2 for i in str(n)])
+        if n == 1: return True
+    return False
+
+# Method 2: using a slow and fast pointer to determine cycle (like in linked list)
+# No extra space needed
+def isHappy2(self, n):
+    """
+    :type n: int
+    :rtype: bool
+    """
+    if n <= 0: return False
+    def helper(n):
+        res = 0
+        while n:
+            res += (n % 10) ** 2
+            n = n // 10
+        return res
+    
+    slow = fast = n
+    while True:
+        slow = helper(slow)
+        fast = helper(helper(fast))
+        if slow == 1: return True
+        if slow == fast: break
+    return False

algorithms/python/HouseRobber/rob.py

@@ -0,0 +1,6 @@
+def rob(self, nums):
+    temp = [0, 0]
+    for n in nums:
+        temp[0], temp[1] = max(temp), n + temp[0]
+    
+    return max(temp)

algorithms/python/LargestPerimeterTriangle/largestPerimeter.py

@@ -0,0 +1,7 @@
+def largestPerimeter(self, A):
+    A.sort()
+    n = len(A)
+    for i in range(1, len(A) - 1):
+        if A[n - i - 2] + A[n - i - 1] > A[n - i]:
+            return A[n - i - 2] + A[n - i - 1] + A[n - i]
+    return 0

algorithms/python/LinkedListCycleII/detectCycle.py

@@ -0,0 +1,13 @@
+def detectCycle(self, head):
+    slow, fast = head, head
+    while fast and fast.next:
+        slow = slow.next
+        fast = fast.next.next
+        if slow == fast: break
+    
+    if not fast or not fast.next: return None
+    slow = head
+    while slow != fast:
+        slow = slow.next
+        fast = fast.next
+    return slow

algorithms/python/NumberOfIslands/numIslands.py

@@ -0,0 +1,24 @@
+def numIslands(self, grid):
+    if not grid or not grid[0]: return 0
+    row, col = len(grid), len(grid[0])
+    self.visited = [[False for _ in range(col)] for _ in range(row)]
+    
+    def floodfill(i, j):
+        if grid[i][j] == '1' and self.visited[i][j] == False:
+            self.visited[i][j] = True
+            if i > 0:
+                floodfill(i - 1, j)
+            if i < row - 1:
+                floodfill(i + 1, j)
+            if j > 0:
+                floodfill(i, j - 1)
+            if j < col - 1:
+                floodfill(i, j + 1)
+    
+    res = 0
+    for i in range(row):
+        for j in range(col):
+            if grid[i][j] == '1' and self.visited[i][j] == False:
+                res += 1
+                floodfill(i, j)
+    return res

algorithms/python/PancakeSorting/pancakeSort.py

@@ -0,0 +1,19 @@
+"""
+basic idea: find the index of smallest element in A, filp the list from that index, this makes the smallest element
+comes to the first, then filp the whole list, to make smallest element goes to the tail. And then delete that element.
+
+Do this step until all the smallest element comes to the tail, then just filp the whole list again, and we can get what we want
+"""
+
+def pancakeSort(self, A):
+    res = []
+    n = len(A)
+    while A:
+        smallest = A.index(min(A))
+        res.append(smallest + 1)
+        res.append(len(A))
+        A = list(reversed(A[:smallest + 1])) + A[smallest + 1:]
+        A.reverse()
+        del A[-1]
+    res.append(n)
+    return res

algorithms/python/ReorderList/reorderList.py

@@ -0,0 +1,25 @@
+def reorderList(self, head):
+    if not head or not head.next: return
+    
+    # Step 1: find the middle node
+    middle = None
+    slow, fast = head, head
+    while fast and fast.next:
+        middle = slow
+        slow = slow.next
+        fast = fast.next.next
+    middle.next = None
+    
+    # Step 2: reverse the second half
+    prev = None
+    while slow:
+        nextNode = slow.next
+        slow.next = prev
+        prev, slow = slow, nextNode
+        
+    # Step 3: merge two lists
+    while head and prev:
+        first, second = head.next, prev.next
+        head.next = prev
+        if first: prev.next = first
+        head, prev = first, second

algorithms/python/RevealCardsInIncreasingOrder/deckRevealedIncreasing.py

@@ -0,0 +1,9 @@
+def deckRevealedIncreasing(self, deck):
+    deck.sort()
+    res = [0] * len(deck)
+    index = list(range(len(deck)))
+    
+    for i in range(len(deck)):
+        res[index.pop(0)] = deck[i]
+        if index: index.append(index.pop(0))
+    return res

algorithms/python/SearchA2DMatrixII/searchMatrix.py

@@ -0,0 +1,28 @@
+# Method 1: Binary Search on each row, if the first element of the row is already bigger than target, then skip
+# Time Complexity: O(mlogn)
+def searchMatrix1(self, matrix, target):
+    def helper(low, high, row):
+        while low <= high:
+            mid = (low + high) // 2
+            if matrix[row][mid] < target: low = mid + 1
+            elif matrix[row][mid] > target: high = mid - 1
+            else: return True
+        return False
+    
+    if not matrix or not matrix[0]: return False
+    for i in range(len(matrix)):
+        if matrix[i][0] > target: return False
+        elif matrix[i][0] == target: return True
+        if helper(0, len(matrix[i]) - 1, i): return True
+    return False
+
+# Method 2: compare the element with top-right corner, and reduce the search range
+# Time complexity: O(m + n)
+def searchMatrix2(self, matrix, target):
+    if not matrix or not matrix[0]: return False
+    row, col = 0, len(matrix[0]) - 1
+    while row < len(matrix) and col >= 0:
+        if matrix[row][col] > target: col -= 1
+        elif matrix[row][col] < target: row += 1
+        else: return True
+    return False