10

Author: Xynoclafe

easy/countPrimes.py

@@ -0,0 +1,17 @@
+from collections import defaultdict
+class Solution:
+    def countPrimes(self, n: int) -> int:
+        
+        seen = defaultdict(lambda: True)
+        count = 0
+        
+        for i in range(2, n):
+            if seen[i]:
+                count += 1
+                init = i * i
+                while init < n:
+                    seen[init] = False
+                    init += i
+        
+        return count
+        

hard/frogJump.py

@@ -0,0 +1,32 @@
+from collections import deque
+class Solution:
+    def canCross(self, stones: List[int]) -> bool:
+        lastElem = stones[-1]
+        stoneSet = set(stones)
+        if stones[1] != 1:
+            return False
+        
+        if len(stones) == 2:
+            return True
+        
+        seen = set((0, 0))
+        nextJumps = deque([(1, 1)])
+        nextSet = deque()
+        
+        while nextJumps:
+            stone, jump = nextJumps.popleft()
+            for i in [-1, 0, 1]:
+                if jump + i > 0:
+                    nextStone = stone + jump + i
+                    if nextStone == lastElem:
+                        return True
+                    if (nextStone, jump + i) not in seen and nextStone in stoneSet:
+                        seen.add((nextStone, jump + i))
+                        nextSet.append((nextStone, jump + i))
+            
+            if len(nextJumps) == 0:
+                nextJumps = nextSet
+                nextSet = deque()
+        
+        return False
+            

medium/coinChange.py

@@ -0,0 +1,30 @@
+from collections import defaultdict
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        
+        seen = defaultdict(lambda: -1)
+        seen[0] = 0
+        
+        for coin in coins:
+            seen[coin] = 1
+        
+        def changeCoin(amount):
+            
+            if amount < 0:
+                return float("inf")
+            
+            if seen[amount] > -1:
+                return seen[amount]
+            
+            minm = float("inf")
+            
+            for coin in coins:
+                minm = min(minm, changeCoin(amount - coin) + 1)
+                
+            seen[amount] = minm
+            
+            return seen[amount]
+        
+        minm = changeCoin(amount)
+        
+        return minm if minm != float("inf") else -1

medium/coinChange_BottomUp.py

@@ -0,0 +1,17 @@
+from collections import defaultdict
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        
+        
+        seen = defaultdict(lambda: float("inf"))
+        seen[0] = 0
+        for coin in coins:
+            seen[coin] = 1
+        
+        for i in range(amount + 1):
+            amt = i
+            for j in range(len(coins)):
+                if coins[j] <= amt:
+                    seen[amt] = min(seen[amt], seen[amt - coins[j]] + 1)
+        
+        return seen[amount] if seen[amount] != float("inf") else -1

medium/firstAndLastElementSortedArray_bisectApproach.py

@@ -0,0 +1,12 @@
+import bisect
+class Solution:
+    def searchRange(self, nums: List[int], target: int) -> List[int]:
+        
+        x = bisect.bisect(nums, target - 0.1)
+        y = bisect.bisect(nums, target + 0.1)
+        
+        if x == y:
+            return [-1, -1]
+        
+        else:
+            return [x, y - 1]

medium/stringToInteger.py

@@ -0,0 +1,34 @@
+from collections import deque
+class Solution:
+    def myAtoi(self, str: str) -> int:
+        negative = False
+        queue = deque()
+        sign = True
+        
+        nums = {"0": 0, "1": 1, "2": 2, "3": 3, "4": 4, "5": 5, "6": 6, "7": 7, "8": 8, "9": 9}
+        
+        for char in str:
+            if char == "-" and sign:
+                sign = False
+                negative = True
+            elif char == "+" and sign:
+                sign = False
+            elif char == " ":
+                if not sign:
+                    break
+            elif char in nums:
+                if sign:
+                    sign = False
+                queue.append(char)
+            else:
+                break
+        
+        runningSum = 0
+        while queue:
+            num = queue.popleft()
+            if num in nums:
+                runningSum = runningSum * 10 + nums[num]
+            if runningSum >= pow(2, 31):
+                return - pow(2,31) if negative else pow(2,31) - 1
+        
+        return -runningSum if negative else runningSum

medium/swapNodesInPairs.py

@@ -0,0 +1,29 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def swapPairs(self, head: ListNode) -> ListNode:
+        
+        node = head
+        prev = None
+        
+        while node:
+            node2 = node.next
+            if node2:
+                if head == node:
+                    head = node2
+                swap = node2.next
+                node2.next = node
+                node.next = swap
+                if prev:
+                    prev.next = node2
+            else:
+                break
+            prev = node
+            node = node.next
+            
+        
+        return head

medium/theMaze.py

@@ -0,0 +1,37 @@
+from collections import deque
+class Solution:
+    def hasPath(self, maze: List[List[int]], start: List[int], destination: List[int]) -> bool:
+        
+        l1 = deque([start])
+        l2 = deque()
+        directions  = [[0,1], [1,0], [-1,0], [0,-1]]
+        
+        visited = set()
+        visited.add(tuple(start))
+        
+        def findExtreme(position, direction):
+            newPos = position
+            while((0 <= newPos[0] < len(maze)) and (0 <= newPos[1] < len(maze[0]) and maze[newPos[0]][newPos[1]] != 1)):
+                prevPos = newPos
+                newPos = [newPos[0] + direction[0], newPos[1] + direction[1]]
+            if tuple(prevPos) not in visited:
+                return prevPos
+            else:
+                return None
+            
+        
+        while l1:
+            curPos = l1.popleft()
+            for direction in directions:
+                newPos = findExtreme(curPos, direction)
+                if newPos:
+                    if newPos == destination:
+                        return True
+                    l2.append(newPos)
+                    visited.add(tuple(newPos))
+            
+            if len(l1) == 0:
+                l1 = l2
+                l2 = deque()
+        
+        return False

medium/theMazeII.py

@@ -0,0 +1,41 @@
+from collections import deque
+from collections import defaultdict
+class Solution:
+    def shortestDistance(self, maze: List[List[int]], start: List[int], destination: List[int]) -> int:
+        
+        l1 = deque([(start, 0)])
+        l2 = deque()
+        directions  = [[0,1], [1,0], [-1,0], [0,-1]]
+        minJumps = float("inf")
+        
+        visited = defaultdict(lambda: float("inf"))
+        visited[tuple(start)] = 0
+        
+        def findExtreme(position, direction, numJumps):
+            newPos = position
+            while((0 <= newPos[0] < len(maze)) and (0 <= newPos[1] < len(maze[0]) and maze[newPos[0]][newPos[1]] != 1)):
+                prevPos = newPos
+                newPos = [newPos[0] + direction[0], newPos[1] + direction[1]]
+                numJumps += 1
+            if visited[tuple(prevPos)] > (numJumps - 1):
+                return prevPos, numJumps - 1
+            else:
+                return None
+            
+        
+        while l1:
+            curPos, jumps = l1.popleft()
+            for direction in directions:
+                retVal = findExtreme(curPos, direction, jumps)
+                if retVal:
+                    newPos = retVal[0]
+                    numJumps = retVal[1]
+                    l2.append((newPos, numJumps))
+                    visited[tuple(newPos)] = numJumps
+            
+            if len(l1) == 0:
+                l1 = l2
+                l2 = deque()
+                jumps += 1
+        
+        return visited[tuple(destination)] if visited[tuple(destination)] != float("inf") else -1