upload on 3/21

Author: gyb1325

61. Rotate List.py

@@ -0,0 +1,41 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+
+class Solution:
+
+    def rotateRight(self, head, k):
+        """
+        :type head: ListNode
+        :type k: int
+        :rtype: ListNode
+        """
+        if not head:
+            return None
+        ptr = head
+        length = 1
+        while ptr.next != None:
+            ptr = ptr.next
+            length += 1
+
+        r_number = k % length
+        if k == 0 or r_number == 0:
+            return head
+
+        fast_ptr = head
+        slow_ptr = head
+        for _ in range(r_number):
+            fast_ptr = fast_ptr.next
+
+        while fast_ptr.next != None:
+            fast_ptr = fast_ptr.next
+            slow_ptr = slow_ptr.next
+
+        temp = slow_ptr.next
+        fast_ptr.next = head
+        slow_ptr.next = None
+        head = temp
+        return head

62. Unique Paths.py

@@ -0,0 +1,14 @@
+class Solution:
+
+    def uniquePaths(self, m, n):
+        """
+        :type m: int
+        :type n: int
+        :rtype: int
+        """
+        aux = [[1 for x in range(m)] for y in range(n)]
+
+        for i in range(1, m):
+            for j in range(1, n):
+                aux[j][i] = aux[j][i - 1] + aux[j - 1][i]
+        return aux[-1][-1]

63. Unique Paths II.py

@@ -0,0 +1,16 @@
+class Solution:
+
+    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
+        m = len(obstacleGrid)
+        n = len(obstacleGrid[0])
+        aux = [[0] * n for _ in range(m)]
+        aux[0][0] = 1 * (1 - obstacleGrid[0][0])
+        for i in range(1, m):
+            aux[i][0] = aux[i - 1][0] * (1 - obstacleGrid[i][0])
+        for j in range(1, n):
+            aux[0][j] = aux[0][j - 1] * (1 - obstacleGrid[0][j])
+        for i in range(1, m):
+            for j in range(1, n):
+                if obstacleGrid[i][j] != 1:
+                    aux[i][j] = aux[i - 1][j] + aux[i][j - 1]
+        return aux[-1][-1]

64. Minimum Path Sum.py

@@ -0,0 +1,16 @@
+class Solution:
+
+    def minPathSum(self, grid: 'List[List[int]]') -> 'int':
+        m = len(grid)
+        n = len(grid[0])
+        aux = [[0] * n for _ in range(m)]
+        aux[0][0] = grid[0][0]
+        for i in range(m):
+            for j in range(n):
+                if i - 1 >= 0 and j - 1 >= 0:
+                    aux[i][j] = min(aux[i - 1][j], aux[i][j - 1]) + grid[i][j]
+                elif i - 1 >= 0:
+                    aux[i][j] = aux[i - 1][j] + grid[i][j]
+                elif j - 1 >= 0:
+                    aux[i][j] = aux[i][j - 1] + grid[i][j]
+        return aux[-1][-1]

66. Plus One.py

@@ -0,0 +1,10 @@
+class Solution:
+
+    def plusOne(self, digits: List[int]) -> List[int]:
+        n = len(digits)
+        carry = 1
+        for i in range(n - 1, -1, -1):
+            temp = digits[i] + carry
+            digits[i] = temp % 10
+            carry = temp // 10
+        return digits if carry == 0 else [1] + digits

67. Add Binary.py

@@ -0,0 +1,24 @@
+class Solution:
+
+    def addBinary(self, a: str, b: str) -> str:
+        new = ""
+        m = len(a) - 1
+        n = len(b) - 1
+        carry = 0
+        while m >= 0 and n >= 0:
+            temp = int(a[m]) + int(b[n]) + carry
+            new = str(temp % 2) + new
+            carry = temp // 2
+            m -= 1
+            n -= 1
+        while m >= 0:
+            temp = int(a[m]) + carry
+            new = str(temp % 2) + new
+            carry = temp // 2
+            m -= 1
+        while n >= 0:
+            temp = int(b[n]) + carry
+            new = str(temp % 2) + new
+            carry = temp // 2
+            n -= 1
+        return new if not carry else "1" + new