Move all problems in notebooks to Leetcode dir, and rename notebooks

Author: jsgoller1

leetcode/1-two-sum/solution_v2.py

@@ -1,6 +1,7 @@
 """
 See prefix sums notebook for explanation.
 """
+from typing import List
 
 
 class Solution:
@@ -10,3 +11,13 @@ def twoSum(self, nums: List[int], target: int) -> List[int]:
             if val in comps and i != comps[val]:
                 return [i, comps[val]]
             comps[target - val] = i
+
+
+s = Solution()
+cases = [
+    ([2, 7, 11, 15], 9, [0, 1]),
+    ([-1, -2, -3, -4, -5], -8, [2, 4])
+]
+for arr, target, expected in cases:
+    actual = s.twoSum(arr, target)
+    assert sorted(expected) == sorted(actual), f"arr,target: {expected} != {actual}"

leetcode/1094-car-pooling/solution.py

@@ -0,0 +1,33 @@
+from collections import Counter
+from typing import List
+
+
+class Solution:
+    def carPooling(self, trips: List[List[int]], capacity: int) -> bool:
+        first, last = float('inf'), -float('inf')
+        stops = Counter()
+        for passengers, start, end in trips:
+            stops[start] += passengers
+            stops[end] -= passengers
+            first = min(first, start)
+            last = max(last, end)
+
+        seats = 0
+        for i in range(first, last+1):
+            seats += stops[i]
+            if seats > capacity:
+                return False
+        return True
+
+
+s = Solution()
+cases = [
+    ([[2, 1, 5], [3, 3, 7]], 4, False),
+    ([[2, 1, 5], [3, 3, 7]], 5, True),
+    ([[2, 1, 5], [3, 5, 7]], 3, True),
+    ([[3, 2, 7], [3, 7, 9], [8, 3, 9]], 11, True),
+]
+
+for trips, capacity, expected in cases:
+    actual = s.carPooling(trips, capacity)
+    assert actual == expected, f"{trips, capacity}: {expected} != {actual}"

leetcode/1109-corporate-flight-bookings/solution.py

@@ -0,0 +1,21 @@
+from typing import List
+
+
+class Solution:
+    def corpFlightBookings(self, bookings: List[List[int]], n: int) -> List[int]:
+        flights = [0] * (n+1)
+        for first, last, count in bookings:
+            flights[first-1] += count
+            flights[last] -= count
+        for i in range(1, n):
+            flights[i] += flights[i-1]
+        return flights[:-1]
+
+
+s = Solution()
+cases = [
+    ([[1, 2, 10], [2, 3, 20], [2, 5, 25]], 5, [10, 55, 45, 25, 25])
+]
+for bookings, n, expected in cases:
+    actual = s.corpFlightBookings(bookings, n)
+    assert actual == expected, f"{bookings, n}: {expected} != {actual}"

leetcode/1589-maximum-sum-obtained-of-any-permutation/solution.py

@@ -0,0 +1,60 @@
+from collections import Counter
+from typing import List
+
+
+def interval_sweep_shitty(requests):
+    """
+    Given a list of ranges, return an array
+    where arr[i] equals the number of ranges
+    including i.
+    """
+    bounds_counts = Counter()
+    first, last = float('inf'), -float('inf')
+    for start, end in requests:
+        bounds_counts[start] += 1
+        bounds_counts[end+1] -= 1
+        first = min(start, end, first)
+        last = max(start, end, last)
+
+    frequency = 0
+    overlap_count = []
+    for val in range(first, last+1):
+        frequency += bounds_counts[val]
+        overlap_count.append(frequency)
+    return overlap_count
+
+
+def interval_sweep(nums_len, requests):
+    """
+    Same as above, but borrowing from @lee215's
+    technique which is faster.
+    """
+    counts = [0] * (nums_len+1)
+    for start, end in requests:
+        counts[start] += 1
+        counts[end+1] -= 1
+
+    for i in range(1, nums_len+1):
+        counts[i] += counts[i-1]
+    return counts
+
+
+class Solution:
+    def maxSumRangeQuery(self, nums: List[int], requests: List[List[int]]) -> int:
+        nums.sort(reverse=True)
+        overlap_count = interval_sweep(len(nums), requests)
+        max_sum = 0
+        for i, frequency in enumerate(sorted(overlap_count[:-1], reverse=True)):
+            max_sum += frequency*nums[i]
+        return max_sum % (10**9 + 7)
+
+
+s = Solution()
+cases = [
+    ([1, 2, 3, 4, 5], [[1, 3], [0, 1]], 19),
+    ([1, 2, 3, 4, 5, 6], [[0, 1]], 11),
+    ([1, 2, 3, 4, 5, 10], [[0, 2], [1, 3], [1, 1]], 47)
+]
+for nums, requests, expected in cases:
+    actual = s.maxSumRangeQuery(nums, requests)
+    assert actual == expected, f"{nums, requests}: {expected} != {actual}"

leetcode/169-majority-element/solution.py

@@ -0,0 +1,27 @@
+from collections import Counter
+
+
+def majority(arr, lo, hi):
+    if lo == hi:
+        return arr[lo]
+    mid = (hi+lo)//2
+    lo_majority = majority(arr, lo, mid)
+    hi_majority = majority(arr, mid+1, hi)
+
+    # if both have same majority, then return it
+    if lo_majority == hi_majority:
+        return lo_majority
+    # Otherwise, count the occurrences and return the best
+    return Counter(arr[lo:hi+1]).most_common(1)[0][0]
+
+
+cases = [
+    ([3, 3, 4], 3),
+    ([2, 2, 1, 1, 1], 1),
+    ([1, 2, 1, 2, 1], 1),
+    ([1, 1, 1, 2], 1),
+]
+
+for arr, expected in cases:
+    actual = majority(arr, 0, len(arr)-1)
+    assert actual == expected, f"{arr}: {expected} != {actual}"

leetcode/17-letter-combinations-of-a-phone-number/solution.2.py

@@ -0,0 +1,37 @@
+from typing import List
+
+PHONE_PAD = {
+    '2': ["a", "b", "c"],
+    '3': ["d", "e", "f"],
+    '4': ["g", "h", "i"],
+    '5': ["j", "k", "l"],
+    '6': ["m", "n", "o"],
+    '7': ["p", "q", "r", "s"],
+    '8': ["t", "u", "v"],
+    '9': ["w", "x", "y", "z"],
+}
+
+
+def combine(c, strs):
+    return [c+string for string in strs] if strs else [c]
+
+
+class Solution:
+    def letterCombinations(self, nums: str, i=0) -> List[str]:
+        if i >= len(nums):
+            return []
+        solution = []
+        for c in PHONE_PAD[nums[i]]:
+            solution += combine(c, self.letterCombinations(nums, i+1))
+        return solution
+
+
+s = Solution()
+cases = [
+    ("23", ['ad', 'ae', 'af', 'bd', 'be', 'bf', 'cd', 'ce', 'cf']),
+    ("2", ['a', 'b', 'c']),
+    ("", [])
+]
+for number, letters in cases:
+    actual = s.letterCombinations(number)
+    assert sorted(actual) == sorted(letters)

leetcode/207-course-schedule/solution.3.py

@@ -0,0 +1,37 @@
+from collections import defaultdict
+from typing import List
+
+
+def visit(node, child_nodes, ancestors):
+    if node not in child_nodes:
+        return True
+    if node in ancestors:
+        return False
+    ancestors.add(node)
+    valid = True
+    for child in child_nodes[node]:
+        valid &= visit(child, child_nodes, ancestors)
+    ancestors.remove(node)
+    del child_nodes[node]
+    return valid
+
+
+class Solution:
+    def canFinish(self, num_courses: int, prerequisites: List[List[int]]) -> bool:
+        starting_nodes = set([i for i in range(num_courses)])
+        child_nodes = defaultdict(set)
+        for course, prereq in prerequisites:
+            child_nodes[prereq].add(course)
+            starting_nodes.remove(course) if course in starting_nodes else None
+
+        while starting_nodes:
+            ancestors = set()
+            current = starting_nodes.pop()
+            if not visit(current, child_nodes, ancestors):
+                return False
+        return not (starting_nodes or child_nodes)
+
+
+s = Solution()
+s.canFinish(8, [[1, 0], [2, 6], [1, 7], [5, 1], [6, 4], [7, 0], [0, 5]])
+s.canFinish(3, [[1, 0], [1, 2], [0, 1]])

leetcode/209-minimum-size-subarray-sum/solution.py

@@ -0,0 +1,27 @@
+from typing import List
+
+
+class Solution:
+    def minSubArrayLen(self, s: int, nums: List[int]) -> int:
+        csum = l = 0
+        best = float('inf')
+        for r, val in enumerate(nums):
+            csum += val
+            while csum - nums[l] >= s and l < len(nums):
+                csum -= nums[l]
+                l += 1
+            best = min(r-l+1, best) if csum >= s else best
+        return best if best != float('inf') else 0
+
+
+cases = [
+    (7, [2, 3, 1, 2, 4, 3], 2),
+    (7, [0, 0, 0], 0),
+    (7, [10, 10, 10], 1),
+    (7, [], 0)
+]
+
+sol = Solution()
+for s, nums, expected in cases:
+    actual = sol.minSubArrayLen(s, nums)
+    assert actual == expected, f"{nums, s}: {expected} != {actual}"

leetcode/21-merge-two-sorted-lists/solution.2.py

@@ -0,0 +1,18 @@
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+
+class Solution:
+    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
+        if not (l1 and l2):
+            return l1 if not l2 else l2
+        if l1.val <= l2.val:
+            next_node = l1
+            l1 = l1.next
+        else:
+            next_node = l2
+            l2 = l2.next
+        next_node.next = self.mergeTwoLists(l1, l2)
+        return next_node

leetcode/210-course-schedule-ii/solution.py

@@ -0,0 +1,54 @@
+from collections import defaultdict
+from typing import List
+
+
+class CycleExistsError(Exception):
+    pass
+
+
+def visit(course, next_courses, visited, ancestors, top_order):
+    if course in visited:
+        return
+    if course in ancestors:
+        raise CycleExistsError
+
+    ancestors.add(course)
+    for child in next_courses[course]:
+        visit(child, next_courses, visited, ancestors, top_order)
+    ancestors.remove(course)
+    visited.add(course)
+    top_order.append(course)
+
+
+class Solution:
+    def findOrder(self, num_courses: int, prerequisites: List[List[int]]) -> List[int]:
+        starting_courses = set([i for i in range(num_courses)])
+        next_courses = defaultdict(set)
+        for course, prereq in prerequisites:
+            next_courses[prereq].add(course)
+            starting_courses.remove(course) if course in starting_courses else None
+        if not starting_courses:
+            return []
+
+        top_order = []
+        visited = set()
+        while starting_courses:
+            ancestors = set()
+            curr_course = starting_courses.pop()
+            try:
+                visit(curr_course, next_courses, visited, ancestors, top_order)
+            except CycleExistsError:
+                return []
+        return top_order[::-1] if len(visited) == num_courses else []
+
+
+s = Solution()
+cases = [
+    (2, [[1, 0]]),
+    (2, [[1, 0], [0, 1]]),
+    (3, [[1, 0], [0, 1]]),
+    (4, [[1, 0], [2, 1]])
+
+]
+for n_courses, prereqs in cases:
+    print(s.findOrder(n_courses, prereqs))