Imp Leetcode questions solved using python.

Author: headless-start

3Sum.py

@@ -0,0 +1,25 @@
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        
+        res = []
+        nums.sort()
+        for i in range(len(nums)-2):
+            if(i > 0 and nums[i] == nums[i-1]):
+                continue
+            currA = nums[i]
+            left = i+1
+            right = len(nums)-1
+            while(left < right):
+                if((currA + nums[left] + nums[right]) == 0):
+                    res.append([currA,nums[left],nums[right]])
+                    while left < right and nums[left] == nums[left+1]:
+                        left += 1
+                    while left < right and nums[right] == nums[right-1]:
+                        right -= 1
+                    left+=1
+                    right-=1
+                elif((currA + nums[left] + nums[right]) < 0):
+                    left+=1
+                else:
+                    right-=1
+        return res

4Sum-II.py

@@ -0,0 +1,24 @@
+class Solution:
+    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
+        
+        tot = 0
+        mapper = {}
+        for i in range(0, len(nums1)):
+            currA = nums1[i]
+            for j in range(0,len(nums2)):
+                currB = nums2[j]
+                
+                if( currA + currB not in mapper):
+                    mapper[currA+currB] = 1
+                else:
+                    mapper[currA+currB]+=1
+        
+        for i in range(0, len(nums3)):
+            currC = nums3[i]
+            for j in range(0,len(nums4)):
+                currD = nums4[j]
+                ele = (currC + currD)*-1
+                if( ele in mapper):
+                    tot+=mapper[ele]
+        
+        return tot

4Sum.py

@@ -0,0 +1,27 @@
+class Solution:
+    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
+        if not nums or len(nums)<4:
+            return []
+        
+
+        #Without using hashmaps. Complexity - O(n3)
+
+        res = []
+        nums.sort()
+        for i in range(len(nums)-3):
+            for j in range(i+1,len(nums)-2):
+                sum2 = nums[i]+nums[j]
+                left = j + 1
+                right = len(nums)-1
+                while(left < right):
+                    sumTot = sum2 + nums[left] + nums[right]
+                    if(sumTot == target and [nums[i],nums[j],nums[left],nums[right]] not in res):
+                        res.append([nums[i],nums[j],nums[left],nums[right]])
+                        left+=1
+                        right-=1
+                    elif sumTot < target:
+                        left+=1
+                    else:
+                        right-=1
+        
+        return res

LRUCache.py

@@ -0,0 +1,33 @@
+from collections import deque
+class LRUCache:
+
+    def __init__(self, capacity: int):
+        self.hmap = {}
+        self.cap = capacity
+        self.q = deque()
+
+    def get(self, key: int) -> int:
+        if key in self.hmap:
+            val = self.hmap[key]
+            self.q.remove(key)
+            self.q.append(key)
+            return val
+        else:
+            return -1
+            
+
+    def put(self, key: int, value: int) -> None:
+        if key not in self.hmap:
+            if len(self.q) == self.cap:
+                removed = self.q.popleft()
+                del self.hmap[removed]
+        else:
+            self.q.remove(key)
+        self.hmap[key] = value
+        self.q.append(key)
+
+
+# Your LRUCache object will be instantiated and called as such:
+# obj = LRUCache(capacity)
+# param_1 = obj.get(key)
+# obj.put(key,value)

PermutationinString.py

@@ -0,0 +1,29 @@
+class Solution:
+    def checkInclusion(self, s1: str, s2: str) -> bool:
+        if(len(s1) > len(s2)):
+            return False
+        l = 0
+        r = len(s1) - 1
+        targetDict = {}
+        for currChar in s1:
+            targetDict[currChar] = targetDict.get(currChar, 0) + 1
+        
+        currDict = {}
+        for i in range(r+1):
+            currDict[s2[i]] = currDict.get(s2[i], 0) + 1
+
+        while(r < len(s2)):
+            if(currDict == targetDict):
+                return True
+            currToDelete = s2[l]
+            currDict[currToDelete] -= 1
+            if(currDict[currToDelete] == 0):
+                currDict.pop(currToDelete)
+            l += 1
+            r += 1
+
+            if(r < len(s2)):
+                currDict[s2[r]] = currDict.get(s2[r], 0) + 1
+        
+        return False
+

addBinary.py

@@ -0,0 +1,9 @@
+class Solution:
+    def addBinary(self, a: str, b: str) -> str:
+        n1 = int(a,2)
+        n2 = int(b,2)
+        numSum = n1 + n2
+        return bin(numSum)[2:]
+        
+s = Solution()
+print(s.addBinary("010101001","0100100101"))

addTwoNumbers.py

@@ -0,0 +1,59 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+
+''' Not the cleanest approach, but in-place code,
+    the sum is overwritten in 2nd LinkedList
+    Runtime was 60 ms, faster than 96.68% of Python3 online submission'''
+
+class Solution:
+    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
+        ans = l2
+        carry = 0
+        inL1 = False
+        while(l1 and l2):
+            curr1 = l1.val
+            curr2 = l2.val
+            prev1 = l1
+            prev2 = l2
+            if(curr1 + curr2 + carry) == 10:
+                l2.val = 0
+            elif (curr1 + curr2 + carry) > 10:
+                l2.val = curr1 + curr2  - 10 + carry
+            else:
+                l2.val = curr1 + curr2 + carry
+            l1 = l1.next
+            l2 = l2.next
+            carry = int((curr1 + curr2 + carry) / 10)
+
+        # the last element of the shorter list is pointed towards the element after the last 
+        # one of the bigger list and the summation is continued there
+        if(l1):
+            prev2.next = l1
+        else:
+            prev1.next = l2
+        while(l1):
+            inL1 = True
+            prev1 = l1
+            tot = l1.val + carry
+            l1.val = (tot)%10 
+            carry = int(tot / 10)
+            l1 = l1.next
+        while(l2):
+            prev2 = l2
+            tot = l2.val + carry
+            l2.val = (tot)%10 
+            carry = int(tot / 10)
+            l2 = l2.next
+            
+        if(carry == 1):
+            if(inL1):
+                prev1.next = ListNode(1)
+            else:
+                prev2.next = ListNode(1)
+            
+            
+        return ans
+

allConstruct-dp.py

@@ -0,0 +1,103 @@
+# allConstruct
+# from dynamic programming video YT
+# https://www.youtube.com/watch?v=oBt53YbR9Kk&t=11470s
+# Timestamp: 05:10:01
+
+
+# ------------------ i guess this is top down approach ----------------------
+ansFin = []
+def allConstruct(target, wordBank, currList = []):
+
+    if target == '':
+        return True
+    
+    for currWord in wordBank:
+        if(target.startswith(currWord)):
+            currList += [currWord]
+            remainingTarget = target[len(currWord):]
+            res = allConstruct(remainingTarget, wordBank, currList)
+            if res == True:
+                ansFin.append(currList.copy())
+            currList.pop()
+
+
+allConstruct('abcdef', ['ab', 'cd', 'cde', 'ef', 'def', 'abcd', 'f'])
+# allConstruct('purple', ['purp', 'p', 'ur', 'le', 'purpl'])
+# allConstruct('happ', ['cat', 'p', 'dog', 'le', 'mouse'])  # this should give [[]] but gives []
+print(ansFin)
+
+
+# ------------ approach in the video ----------------------------------------------
+# this gives the o/p, but return early hence only gives one occurance
+# not all
+
+ansFin = []
+def allConstruct(target, wordBank):
+    if target == '':
+        return []
+    currList = []
+    for currWord in wordBank:
+        if(target.startswith(currWord)):
+            remainingTarget = target[len(currWord):]
+            res = allConstruct(remainingTarget, wordBank)
+
+            if res is not None:
+                currList += [currWord] + res
+                return currList
+    print(ansFin)
+    ansFin.append(currList)
+
+print('ths gives one occurance only coz of early return')
+print(allConstruct('abcdef', ['ab', 'cd', 'cde', 'ef', 'def', 'abcd', 'f']))
+# print(ansFin)
+
+
+#----------------- from gemini and this works -_- --------------------------------------
+# without DP
+# check the explaination in the chat: https://g.co/gemini/share/479ee118861d
+
+
+def allConstruct(target, wordBank):
+    if target == "":
+        return [[]]  # Base case: empty target has one combination (the empty list)
+    
+    all_combinations = []
+    for word in wordBank:
+        if target.startswith(word):
+            remaining = target[len(word):]
+            remaining_combinations = allConstruct(remaining, wordBank)
+            for combo in remaining_combinations:
+                all_combinations.append([word] + combo)  
+            print(all_combinations)
+
+    return all_combinations
+
+result = allConstruct('abcdef', ['ab', 'cd', 'cde', 'ef', 'def', 'abcd', 'f'])
+print(result)
+
+
+# ----------------- gemini solution with DP --------------------------
+
+def allConstruct(target, wordBank, memo=None):
+    if memo is None:
+        memo = {}  # Initialize memoization dictionary
+
+    if target == "":
+        return [[]]  # Base case: empty target has one combination (the empty list)
+    
+    if target in memo:
+        return memo[target]  # Use memoized result if available
+    
+    all_combinations = []
+    for word in wordBank:
+        if target.startswith(word):
+            remaining = target[len(word):]
+            remaining_combinations = allConstruct(remaining, wordBank, memo)
+            for combo in remaining_combinations:
+                all_combinations.append([word] + combo)  # Add current word to each combination
+
+    memo[target] = all_combinations  # Store result for memoization
+    return all_combinations
+
+# result = allConstruct('aaaaaa', ['a', 'aaa', 'aaaa', 'aaaaaa'])
+# print(result)

avoidScreen.py

@@ -0,0 +1,31 @@
+## This script will simulate a keypress and prevent Windows from locking
+
+import pyautogui
+import time
+
+def no_lock(button):
+    try:
+        print ('Press CTRL+C to stop.')
+        while True:
+            pyautogui.press(button)     # Key pressed
+            time.sleep(2)
+
+    except Exception as ex:
+        print ('no_lock | Error: ', ex)
+
+def main():
+    try:
+        print ('\nPrevent Windows screenlock')
+        kb_button = str(input('Enter keyboard button: '))
+        
+        print ('\nRunning')
+        no_lock(kb_button)
+
+    except KeyboardInterrupt:
+        print('\nStopped')
+
+    except Exception as ex:
+        print ('main | Error: ', ex)
+
+if __name__ == "__main__":
+    main()