move problems in notebooks to leetcode dir

Author: jsgoller1

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/211-design-add-and-search-words-data-structure/solution.py

@@ -0,0 +1,59 @@
+class TrieNode:
+    def __init__(self):
+        self.children = {}
+        self.is_leaf = False
+
+
+class WordDictionary:
+    def __init__(self):
+        """
+        Initialize your data structure here.
+        """
+        self.root = TrieNode()
+
+    def addWord(self, word: str) -> None:
+        node = self.root
+        for letter in word:
+            if letter in node.children:
+                node = node.children[letter]
+            else:
+                new_node = TrieNode()
+                node.children[letter] = new_node
+                node = new_node
+        node.is_leaf = True
+
+    def _search(self, word, i, node):
+        if i == len(word):
+            return node.is_leaf
+        if word[i] == ".":
+            for child in node.children.values():
+                if self._search(word, i+1, child):
+                    return True
+            return False
+        if word[i] not in node.children:
+            return False
+        return self._search(word, i+1, node.children[word[i]])
+
+    def search(self, word: str) -> bool:
+        return self._search(word, 0, self.root)
+
+
+null, true, false = None, True, False
+cases = [
+    [
+        ["addWord", "addWord", "search", "search", "search", "search", "search", "search", "search", "search"],
+        [["a"], ["ab"], ["a"], ["a."], ["ab"], [".a"], [".b"], ["ab."], ["."], [".."]],
+        [null, null, true, true, true, false, true, false, true, true]
+    ]
+]
+wd = WordDictionary()
+for commands, args, expecteds in cases:
+    for i, _ in enumerate(commands):
+        command = commands[i]
+        arg = args[i][0]
+        expected = expecteds[i]
+        if command == "addWord":
+            wd.addWord(arg)
+        else:
+            actual = wd.search(arg)
+            assert expected == actual, f"{command,arg}: {expected} != {actual}"

leetcode/240-search-a-2d-matrix-ii/solution.2.py

@@ -0,0 +1,47 @@
+from typing import List
+
+
+def binary_search(row, val):
+    lo, hi = 0, len(row)-1
+    while lo <= hi:
+        mid = (hi+lo) // 2
+        if row[mid] == val:
+            return mid, True
+        elif row[mid] < val:
+            lo = mid + 1
+        else:
+            hi = mid - 1
+    return lo, False
+
+
+class Solution:
+    def searchMatrix(self, matrix: List[List[int]], val: int) -> bool:
+        # List construction here is O(n) and O(m), but we only do each
+        # once regardless of input size.
+        lowest_row, found = binary_search([row[-1] for row in matrix], val)
+        if found:
+            return found
+        highest_row, found = binary_search([row[0] for row in matrix], val)
+        if found:
+            return found
+
+        # if lowest row == 0 and highest row == len(matrix)-1, this becomes
+        # O(nlog(m)) for n rows and m columns.
+        for y in range(lowest_row, highest_row):
+            _, found = binary_search(matrix[y], val)
+            if found:
+                return found
+
+        return False
+
+
+cases = [
+    ([[1]], 1, True),
+    ([[6]], 1, False),
+    ([[1, 4, 7, 11, 15], [2, 5, 8, 12, 19], [3, 6, 9, 16, 22], [10, 13, 14, 17, 24], [18, 21, 23, 26, 30]], 666, False),
+    ([[1, 4, 7, 11, 15], [2, 5, 8, 12, 19], [3, 6, 9, 16, 22], [10, 13, 14, 17, 24], [18, 21, 23, 26, 30]], 5, True),
+]
+s = Solution()
+for matrix, val, expected in cases:
+    actual = s.searchMatrix(matrix, val)
+    assert actual == expected, f"{matrix,val}: {expected} != {actual}"

leetcode/261-graph-valid-tree/solution.py

@@ -0,0 +1,35 @@
+from collections import deque
+from typing import List
+
+
+class Solution:
+    def validTree(self, n: int, edges: List[List[int]]) -> bool:
+        if not edges:
+            return n < 2
+        adj_list = {i: set() for i in range(0, n)}
+        for n1, n2 in edges:
+            adj_list[n1].add(n2)
+            adj_list[n2].add(n1)
+
+        visited = set()
+        q = deque([(edges[0][0], None)])
+        while q:
+            curr, parent = q.popleft()
+            visited.add(curr)
+            for child in adj_list[curr]:
+                if child == parent:
+                    continue
+                if child in visited:
+                    return False
+                q.append((child, curr))
+        return len(visited) == n
+
+
+s = Solution()
+cases = [
+    (5, [[0, 1], [0, 2], [0, 3], [1, 4]], True),
+    (5, [[0, 1], [1, 2], [2, 3], [1, 3], [1, 4]], False),
+]
+for n, edges, expected in cases:
+    actual = s.validTree(n, edges)
+    assert actual == expected, f"{n, edges}"

leetcode/421-maximum-xor-of-two-numbers-in-array/solution.py

@@ -0,0 +1,43 @@
+from typing import List
+
+
+def flipped(bit):
+    return '0' if bit == '1' else '1'
+
+
+class Solution:
+    def findMaximumXOR(self, nums: List[int]) -> int:
+        root = {}
+        required = len(bin(max(nums))[2:])
+        bitstrs = [bin(val)[2:].zfill(required) for val in nums]
+        for bitstr in bitstrs:
+            node = root
+            for bit in bitstr:
+                if bit not in node:
+                    node[bit] = {}
+                node = node[bit]
+
+        best_xor = 0
+        for bitstr in bitstrs:
+            curr_xor = ''
+            node = root
+            for bit in bitstr:
+                next_bit = flipped(bit) if flipped(bit) in node else bit
+                curr_xor += '1' if next_bit != bit else '0'
+                node = node[next_bit]
+            best_xor = max(best_xor, int(curr_xor, 2))
+        return best_xor
+
+
+s = Solution()
+cases = [
+    ([3, 10, 5, 25, 2, 8], 28),
+    ([0], 0),
+    ([2, 4], 6),
+    ([8, 10, 2], 10),
+    ([14, 70, 53, 83, 49, 91, 36, 80, 92, 51, 66, 70], 127),
+    ([32, 18, 33, 42, 29, 20, 26, 36, 15, 46], 62)
+]
+for vals, expected in cases:
+    actual = s.findMaximumXOR(vals)
+    assert actual == expected, f"{vals}: {expected} != {actual}"

notebooks/Data Structure - Graphs.ipynb

@@ -76,43 +76,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
-    "from collections import deque\n",
-    "\n",
-    "class Solution:\n",
-    "    def validTree(self, n: int, edges: List[List[int]]) -> bool:\n",
-    "        if not edges:\n",
-    "            return n < 2\n",
-    "        adj_list = {i:set() for i in range(0, n)}\n",
-    "        for n1,n2 in edges:\n",
-    "            adj_list[n1].add(n2)\n",
-    "            adj_list[n2].add(n1)\n",
-    "        \n",
-    "        visited = set()\n",
-    "        q = deque([(edges[0][0], None)])\n",
-    "        while q:\n",
-    "            curr, parent = q.popleft()\n",
-    "            visited.add(curr)\n",
-    "            for child in adj_list[curr]:\n",
-    "                if child == parent:\n",
-    "                    continue\n",
-    "                if child in visited:\n",
-    "                    return False\n",
-    "                q.append((child,curr))\n",
-    "        return len(visited) == n\n",
-    "\n",
-    "s = Solution()\n",
-    "cases = [\n",
-    "    (5, [[0,1], [0,2], [0,3], [1,4]], True),\n",
-    "    (5, [[0,1], [1,2], [2,3], [1,3], [1,4]], False),\n",
-    "]\n",
-    "for n, edges, expected in cases:\n",
-    "    actual = s.validTree(n, edges)\n",
-    "    assert actual == expected, f\"{n, edges}\"\n",
-    "            "
+    "%run ../leetcode/261-graph-valid-tree/solution.py"
    ]
   }
  ],