Solution for 1033, 1034, 1035

Author: Garvit244

1000-1100q/1033.py

@@ -0,0 +1,50 @@
+'''
+Three stones are on a number line at positions a, b, and c.
+
+Each turn, let's say the stones are currently at positions x, y, z with x < y < z.  You pick up the stone at either position x or position z, and move that stone to an integer position k, with x < k < z and k != y.
+
+The game ends when you cannot make any more moves, ie. the stones are in consecutive positions.
+
+When the game ends, what is the minimum and maximum number of moves that you could have made?  Return the answer as an length 2 array: answer = [minimum_moves, maximum_moves]
+
+ 
+
+Example 1:
+
+Input: a = 1, b = 2, c = 5
+Output: [1, 2]
+Explanation: Move stone from 5 to 4 then to 3, or we can move it directly to 3.
+Example 2:
+
+Input: a = 4, b = 3, c = 2
+Output: [0, 0]
+Explanation: We cannot make any moves.
+ 
+
+Note:
+
+1 <= a <= 100
+1 <= b <= 100
+1 <= c <= 100
+a != b, b != c, c != a
+'''
+
+class Solution(object):
+    def numMovesStones(self, a, b, c):
+        """
+        :type a: int
+        :type b: int
+        :type c: int
+        :rtype: List[int]
+        """
+        lista = [a, b, c]
+        lista.sort()
+        a, b, c = lista[0], lista[1], lista[2]
+        minsteps = 0
+        if b == a+1 and c == a+2:
+            return [0, 0]
+        elif b == a+1 or c == b+1 or c == b+2 or  b == a+2:
+            minsteps = 1
+        else:
+            minsteps = 2
+        return [minsteps, b-a-1+c-b-1]

1000-1100q/1034.py

@@ -0,0 +1,69 @@
+'''
+Given a 2-dimensional grid of integers, each value in the grid represents the color of the grid square at that location.
+
+Two squares belong to the same connected component if and only if they have the same color and are next to each other in any of the 4 directions.
+
+The border of a connected component is all the squares in the connected component that are either 4-directionally adjacent to a square not in the component, or on the boundary of the grid (the first or last row or column).
+
+Given a square at location (r0, c0) in the grid and a color, color the border of the connected component of that square with the given color, and return the final grid.
+
+Example 1:
+
+Input: grid = [[1,1],[1,2]], r0 = 0, c0 = 0, color = 3
+Output: [[3, 3], [3, 2]]
+Example 2:
+
+Input: grid = [[1,2,2],[2,3,2]], r0 = 0, c0 = 1, color = 3
+Output: [[1, 3, 3], [2, 3, 3]]
+Example 3:
+
+Input: grid = [[1,1,1],[1,1,1],[1,1,1]], r0 = 1, c0 = 1, color = 2
+Output: [[2, 2, 2], [2, 1, 2], [2, 2, 2]]
+ 
+
+Note:
+
+1 <= grid.length <= 50
+1 <= grid[0].length <= 50
+1 <= grid[i][j] <= 1000
+0 <= r0 < grid.length
+0 <= c0 < grid[0].length
+1 <= color <= 1000
+'''
+
+class Solution(object):
+    def colorBorder(self, grid, r0, c0, color):
+        """
+        :type grid: List[List[int]]
+        :type r0: int
+        :type c0: int
+        :type color: int
+        :rtype: List[List[int]]
+        """
+        if not grid:
+            return grid
+        visited, border = [], []
+        m, n = len(grid), len(grid[0])
+        
+        def dfs(r, c):
+            if r < 0 or c < 0 or r >= m or c >= n or grid[r][c] != grid[r0][c0] or (r,c) in visited:
+                return
+            visited.append((r,c))
+            
+            # check if the current row, col index is edge of the matrix
+            # if not then check adjacent cells doesnt have same value as grid[r0][c0] then add in border
+            if (r == 0 or c == 0 or r == m-1 or c == n-1 or 
+                (r+1 < m and grid[r+1][c] != grid[r0][c0]) or
+                (r-1 >= 0 and grid[r-1][c] != grid[r0][c0]) or
+                (c+1 < n and grid[r][c+1] != grid[r0][c0]) or
+                (c-1 >= 0 and grid[r][c-1] != grid[r0][c0])):
+                    border.append((r,c))
+            dfs(r-1, c)
+            dfs(r+1, c)
+            dfs(r, c-1)
+            dfs(r, c+1)
+            
+        dfs(r0, c0)
+        for (x, y) in border:
+            grid[x][y] = color
+        return grid

1000-1100q/1035.py

@@ -0,0 +1,60 @@
+'''
+We write the integers of A and B (in the order they are given) on two separate horizontal lines.
+
+Now, we may draw a straight line connecting two numbers A[i] and B[j] as long as A[i] == B[j], and the line we draw does not intersect any other connecting (non-horizontal) line.
+
+Return the maximum number of connecting lines we can draw in this way.
+
+ 
+
+Example 1:
+
+
+Input: A = [1,4,2], B = [1,2,4]
+Output: 2
+Explanation: We can draw 2 uncrossed lines as in the diagram.
+We cannot draw 3 uncrossed lines, because the line from A[1]=4 to B[2]=4 will intersect the line from A[2]=2 to B[1]=2.
+Example 2:
+
+Input: A = [2,5,1,2,5], B = [10,5,2,1,5,2]
+Output: 3
+Example 3:
+
+Input: A = [1,3,7,1,7,5], B = [1,9,2,5,1]
+Output: 2
+ 
+
+Note:
+
+1 <= A.length <= 500
+1 <= B.length <= 500
+1 <= A[i], B[i] <= 2000
+'''
+
+class Solution(object):
+    def maxUncrossedLines(self, A, B):
+        """
+        :type A: List[int]
+        :type B: List[int]
+        :rtype: int
+        """
+        dp = [[0]*len(A) for _ in range(len(B))]
+        
+        dp[0][0] = 1 if A[0] == B[0] else 0
+        for index_i in range(1, len(dp)):
+            dp[index_i][0] = dp[index_i-1][0]
+            if A[0] == B[index_i]:
+                dp[index_i][0] = 1
+                
+        for index_j in range(1, len(dp[0])):
+            dp[0][index_j] = dp[0][index_j-1]
+            if B[0] == A[index_j]:
+                dp[0][index_j] = 1
+                
+        for index_i in range(1, len(dp)):
+            for index_j in range(1, len(dp[0])):
+                if A[index_j] == B[index_i]:
+                    dp[index_i][index_j] = max(dp[index_i-1][index_j-1] + 1, max(dp[index_i-1][index_j], dp[index_i][index_j-1]))
+                else:
+                    dp[index_i][index_j] = max(dp[index_i-1][index_j-1], max(dp[index_i-1][index_j], dp[index_i][index_j-1]))
+        return dp[len(B)-1][len(A)-1]

README.md

@@ -7,6 +7,9 @@ Python solution of problems from [LeetCode](https://leetcode.com/).
 ##### [Problems 1000-1100](./1000-1100q/)
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|1035|[Uncrossed Lines](https://leetcode.com/problems/uncrossed-lines/)|[Python](./1000-1100q/1035.py)|Medium|
+|1034|[Coloring A Border](https://leetcode.com/problems/coloring-a-border/)|[Python](./1000-1100q/1034.py)|Medium|
+|1033|[Moving Stones Until Consecutive](https://leetcode.com/problems/moving-stones-until-consecutive)|[Python](./1000-1100q/1033.py)|Easy
 |1032|[Stream of Characters](https://leetcode.com/problems/stream-of-characters)|[Python](./1000-1100q/1032.py)|Hard|
 |1031|[Maximum Sum of Two Non-Overlapping Subarrays](https://leetcode.com/problems/maximum-sum-of-two-non-overlapping-subarrays)|[Python](./1000-1100q/1031.py)|Medium|
 |1030|[Matrix Cells in Distance Order](https://leetcode.com/problems/matrix-cells-in-distance-order)|[Python](./1000-1100/1030.py)|Easy|