Leetcode submissions

theabbie · theabbie · commit a6f8f56b97aa · 2022-04-12T23:16:55.000+05:30
diff --git a/angle-between-hands-of-a-clock.py b/angle-between-hands-of-a-clock.py
@@ -0,0 +1,6 @@
+class Solution:
+    def angleClock(self, hour: int, minutes: int) -> float:
+        mAngle = minutes * 6
+        hAngle = (hour * 30 + minutes / 2) % 360
+        diff = abs(mAngle - hAngle)
+        return min(diff, 360 - diff)
diff --git a/compare-version-numbers.py b/compare-version-numbers.py
@@ -0,0 +1,13 @@
+class Solution:
+    def compareVersion(self, version1: str, version2: str) -> int:
+        a = [int(r) for r in version1.split(".")]
+        b = [int(r) for r in version2.split(".")]
+        if len(a) < len(b):
+            a += [0] * (len(b) - len(a))
+        else:
+            b += [0] * (len(a) - len(b))
+        if tuple(a) > tuple(b):
+            return 1
+        elif tuple(a) < tuple(b):
+            return -1
+        return 0
diff --git a/copy-list-with-random-pointer.py b/copy-list-with-random-pointer.py
@@ -11,14 +11,29 @@ class Solution:
     def copy(self, head):
         newhead = None
         if head:
-            newhead = self.visited.get(head, Node(head.val))
-            self.visited[head] = newhead
+            newhead = self.visited.get(head.val, Node(head.val))
+            self.visited[newhead.val] = newhead
             if head.random != None:
-                newhead.random = self.visited.get(head.random, Node(head.random.val))
-                self.visited[head.random] = newhead.random
+                newhead.random = self.visited.get(head.random.val, Node(head.random.val))
+                self.visited[newhead.random.val] = newhead.random
             newhead.next = self.copy(head.next)
         return newhead
     
     def copyRandomList(self, head: 'Optional[Node]') -> 'Optional[Node]':
         self.visited = {}
-        return self.copy(head)
+        i = 0
+        vals = []
+        curr = head
+        while curr:
+            vals.append(curr.val)
+            curr.val = i
+            curr = curr.next
+            i += 1
+        newhead = self.copy(head)
+        i = 0
+        curr = newhead
+        while curr:
+            curr.val = vals[i]
+            curr = curr.next
+            i += 1
+        return newhead
diff --git a/course-schedule-ii.py b/course-schedule-ii.py
@@ -0,0 +1,26 @@
+class Solution:
+    def topologicalSort(self, graph, node, visited):
+        visited.add(node)
+        for j in graph.get(node, []):
+            if j not in visited:
+                self.topologicalSort(graph, j, visited)
+        self.sorted.append(node)
+    
+    def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
+        graph = {}
+        for a, b in prerequisites:
+            graph[b] = graph.get(b, []) + [a]
+        self.sorted = []
+        visited = set()
+        for node in range(numCourses):
+            if node not in visited:
+                self.topologicalSort(graph, node, visited)
+        self.sorted.reverse()
+        pos = {}
+        for i, node in enumerate(self.sorted):
+            pos[node] = i
+        for i in graph:
+            for j in graph[i]:
+                if pos[i] > pos[j]:
+                    return []
+        return self.sorted
diff --git a/course-schedule.py b/course-schedule.py
@@ -0,0 +1,22 @@
+class Solution:
+    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
+        graph = {}
+        indegree = [0] * numCourses
+        for a, b in prerequisites:
+            graph[b] = graph.get(b, []) + [a]
+            indegree[a] += 1
+        queue = []
+        for i in range(numCourses):
+            if indegree[i] == 0:
+                queue.append(i)
+        ctr = 0
+        while len(queue) > 0:
+            curr = queue.pop(0)
+            for j in graph.get(curr, []):
+                indegree[j] -= 1
+                if indegree[j] == 0:
+                    queue.append(j)
+            ctr += 1
+        if ctr < numCourses:
+            return False
+        return True
diff --git a/delete-leaves-with-a-given-value.py b/delete-leaves-with-a-given-value.py
@@ -0,0 +1,16 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def removeLeafNodes(self, root: Optional[TreeNode], target: int) -> Optional[TreeNode]:
+        if root:
+            if not root.left and not root.right and root.val == target:
+                return None
+            root.left = self.removeLeafNodes(root.left, target)
+            root.right = self.removeLeafNodes(root.right, target)
+            if not root.left and not root.right and root.val == target:
+                return None
+        return root
diff --git a/find-words-that-can-be-formed-by-characters.py b/find-words-that-can-be-formed-by-characters.py
@@ -0,0 +1,16 @@
+from collections import Counter
+
+class Solution:
+    def countCharacters(self, words: List[str], chars: str) -> int:
+        chars = Counter(chars)
+        l = 0
+        for w in words:
+            curr = Counter(w)
+            possible = True
+            for c in curr:
+                if chars[c] < curr[c]:
+                    possible = False
+                    break
+            if possible:
+                l += len(w)
+        return l
diff --git a/flower-planting-with-no-adjacent.py b/flower-planting-with-no-adjacent.py
@@ -0,0 +1,23 @@
+class Solution:
+    def gardenNoAdj(self, n: int, paths: List[List[int]]) -> List[int]:
+        types = [1] * n
+        graph = {}
+        for a, b in paths:
+            graph[a - 1] = graph.get(a - 1, []) + [b - 1]
+            graph[b - 1] = graph.get(b - 1, []) + [a - 1]
+        visited = set()
+        stack = list(range(n))
+        while len(stack) > 0:
+            curr = stack.pop()
+            visited.add(curr)
+            colors = set()
+            for j in graph.get(curr, []):
+                colors.add(types[j])
+                if j not in visited:
+                    stack.append(j)
+            if types[curr] in colors:
+                for i in range(1, n + 1):
+                    if i not in colors:
+                        types[curr] = i
+                        break
+        return types
diff --git a/largest-number.py b/largest-number.py
@@ -0,0 +1,10 @@
+from functools import cmp_to_key
+
+class Solution:
+    def compare(self, a, b):
+        if a + b > b + a:
+            return -1
+        return 1
+    
+    def largestNumber(self, nums: List[int]) -> str:
+        return str(int("".join(sorted([str(num) for num in nums], key = cmp_to_key(self.compare)))))
diff --git a/maximal-network-rank.py b/maximal-network-rank.py
@@ -0,0 +1,13 @@
+class Solution:
+    def maximalNetworkRank(self, n: int, roads: List[List[int]]) -> int:
+        l = len(roads)
+        edges = [set() for _ in range(n)]
+        for k in range(l):
+            a, b = roads[k]
+            edges[a].add(k)
+            edges[b].add(k)
+        mnetwork = 0
+        for i in range(n):
+            for j in range(i + 1, n):
+                mnetwork = max(mnetwork, len(set.union(edges[i], edges[j])))
+        return mnetwork
diff --git a/maximum-width-of-binary-tree.py b/maximum-width-of-binary-tree.py
@@ -0,0 +1,23 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def inorder(self, root, l, w):
+        if root:
+            self.inorder(root.left, l + 1, 2 * w)
+            if l in self.levels:
+                self.levels[l] = (min(self.levels[l][0], w), max(self.levels[l][1], w))
+                self.mwidth = max(self.mwidth, self.levels[l][1] - self.levels[l][0] + 1)
+            else:
+                self.levels[l] = (w, w)
+                self.mwidth = max(self.mwidth, 1)
+            self.inorder(root.right, l + 1, 2 * w + 1)
+    
+    def widthOfBinaryTree(self, root: Optional[TreeNode]) -> int:
+        self.levels = {}
+        self.mwidth = 0
+        self.inorder(root, 0, 0)
+        return self.mwidth
diff --git a/minimum-absolute-difference.py b/minimum-absolute-difference.py
@@ -0,0 +1,12 @@
+class Solution:
+    def minimumAbsDifference(self, arr: List[int]) -> List[List[int]]:
+        n = len(arr)
+        mindiff = float('inf')
+        arr.sort()
+        for i in range(n - 1):
+            mindiff = min(mindiff, arr[i + 1] - arr[i])
+        op = []
+        for i in range(n - 1):
+            if arr[i + 1] - arr[i] == mindiff:
+                op.append([arr[i], arr[i + 1]])
+        return op
diff --git a/pascals-triangle.py b/pascals-triangle.py
@@ -0,0 +1,12 @@
+class Solution:
+    def generate(self, numRows: int) -> List[List[int]]:
+        tri = []
+        curr = [1]
+        n = 1
+        for i in range(numRows):
+            tri.append(curr)
+            curr = [0] + curr
+            n += 1
+            for i in range(n - 1):
+                curr[i] = curr[i] + curr[i + 1]
+        return tri
diff --git a/power-of-two.py b/power-of-two.py
@@ -0,0 +1,6 @@
+class Solution:
+    def isPowerOfTwo(self, n: int) -> bool:
+        i = 1
+        while i < n:
+            i = i << 1
+        return i == n
diff --git a/rotate-array.py b/rotate-array.py
@@ -0,0 +1,23 @@
+class Solution:
+    def gcd(self, a, b):
+        while b:
+            a, b = b, a % b
+        return a
+    
+    def rotate(self, nums: List[int], k: int) -> None:
+        n = len(nums)
+        k = n - k % n
+        gcd = self.gcd(k, n)
+        for i in range(gcd):
+            temp = nums[i]
+            j = i
+            while 1:
+                l = j + k
+                if l >= n:
+                    l = l - n
+                if l == i:
+                    break
+                nums[j] = nums[l]
+                j = l
+            nums[j] = temp
+        return nums
diff --git a/shortest-path-visiting-all-nodes.py b/shortest-path-visiting-all-nodes.py
@@ -0,0 +1,26 @@
+class Solution:
+    def shortestPathLength(self, graph: List[List[int]]) -> int:
+        n = len(graph)
+        if n == 1:
+            return 0
+        req = (1 << n) - 1
+        visited = {}
+        queue = []
+        for i in range(n):
+            queue.append((0 | (1 << i), i))
+        lvl = 1
+        while len(queue) > 0:
+            k = len(queue)
+            while k > 0:
+                curr, currnode = queue.pop(0)
+                for u in graph[currnode]:
+                    newMask = curr | (1 << u)
+                    if newMask == req:
+                        return lvl
+                    if newMask in visited.get(u, {}):
+                        continue
+                    visited[u] = visited.get(u, set()).union({newMask})
+                    queue.append((newMask, u))
+                k -= 1
+            lvl += 1
+        return -1
diff --git a/tenth-lineundefined b/tenth-lineundefined
@@ -0,0 +1 @@
+sed -n '10p' < file.txt
diff --git a/two-sumundefined b/two-sumundefined
@@ -0,0 +1,15 @@
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) {
+        unordered_map<int, int> seen;
+        for (int i = 0; i < nums.size(); i++) {
+            if (seen.count(target - nums[i]) != 0) {
+                return {seen[target - nums[i]], i};
+            }
+            else {
+                seen[nums[i]] = i;
+            }
+        }
+        return {0, 0};
+    }
+};
