revert several python solution changes

Author: neetcode-gh

python/0003-longest-substring-without-repeating-characters.py

@@ -1,16 +1,13 @@
 class Solution:
     def lengthOfLongestSubstring(self, s: str) -> int:
-        
-        repeats = dict()
-        start = longest = 0
+        charSet = set()
+        l = 0
+        res = 0
 
-        for i, char in enumerate(s):
-            if char in repeats and repeats[char] >= start:
-                start = repeats[char] + 1
-                    
-            repeats[char] = i
-
-            if longest < i - start + 1:
-                longest = i - start + 1
-        
-        return longest
+        for r in range(len(s)):
+            while s[r] in charSet:
+                charSet.remove(s[l])
+                l += 1
+            charSet.add(s[r])
+            res = max(res, r - l + 1)
+        return res

python/0023-merge-k-sorted-lists.py

@@ -18,16 +18,19 @@ def mergeKLists(self, lists: List[ListNode]) -> ListNode:
         return lists[0]
 
     def mergeList(self, l1, l2):
-        dummy = node = ListNode()
+        dummy = ListNode()
+        tail = dummy
 
         while l1 and l2:
             if l1.val < l2.val:
-                node.next = l1
+                tail.next = l1
                 l1 = l1.next
             else:
-                node.next = l2
+                tail.next = l2
                 l2 = l2.next
-            node = node.next
-
-        node.next = l1 or l2
+            tail = tail.next
+        if l1:
+            tail.next = l1
+        if l2:
+            tail.next = l2
         return dummy.next

python/0025-reverse-nodes-in-k-group.py

@@ -1,24 +1,25 @@
 class Solution:
     def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
-        dummy = groupPrev = ListNode(0, head)
-        
+        dummy = ListNode(0, head)
+        groupPrev = dummy
+
         while True:
             kth = self.getKth(groupPrev, k)
             if not kth:
                 break
-            groupPrev.next = kth
             groupNext = kth.next
 
             # reverse group
-            prev, curr = groupNext, head
+            prev, curr = kth.next, groupPrev.next
             while curr != groupNext:
-                nxt = curr.next
+                tmp = curr.next
                 curr.next = prev
                 prev = curr
-                curr = nxt
+                curr = tmp
 
-            groupPrev = head
-            head = groupNext
+            tmp = groupPrev.next
+            groupPrev.next = kth
+            groupPrev = tmp
         return dummy.next
 
     def getKth(self, curr, k):

python/0042-trapping-rain-water.py

@@ -1,16 +1,18 @@
 class Solution:
     def trap(self, height: List[int]) -> int:
+        if not height:
+            return 0
 
-        c = height.index(max(height))
-    
-        vol = 0
-        for arr in [height[:c], height[:c:-1]]:
-            first = 0
-            for i in arr:
-                if i < first:
-                    vol += first - i
-                else:
-                    first = i
-    
-        return vol
-   
+        l, r = 0, len(height) - 1
+        leftMax, rightMax = height[l], height[r]
+        res = 0
+        while l < r:
+            if leftMax < rightMax:
+                l += 1
+                leftMax = max(leftMax, height[l])
+                res += leftMax - height[l]
+            else:
+                r -= 1
+                rightMax = max(rightMax, height[r])
+                res += rightMax - height[r]
+        return res

python/0084-largest-rectangle-in-histogram.py

@@ -3,13 +3,13 @@ def largestRectangleArea(self, heights: List[int]) -> int:
         maxArea = 0
         stack = []  # pair: (index, height)
 
-        for right, short in enumerate(heights):
-            start = right
-            while stack and short < stack[-1][1]:
-                left, tall = stack.pop()
-                maxArea = max(maxArea, tall * (right - left))
-                start = left
-            stack.append((start, short))
+        for i, h in enumerate(heights):
+            start = i
+            while stack and stack[-1][1] > h:
+                index, height = stack.pop()
+                maxArea = max(maxArea, height * (i - index))
+                start = index
+            stack.append((start, h))
 
         for i, h in stack:
             maxArea = max(maxArea, h * (len(heights) - i))

python/0121-best-time-to-buy-and-sell-stock.py

@@ -1,13 +1,10 @@
 class Solution:
     def maxProfit(self, prices: List[int]) -> int:
+        res = 0
 
-        profit = 0
         lowest = prices[0]
-        
-        for price in prices[1:]:
+        for price in prices:
             if price < lowest:
                 lowest = price
-            elif price - lowest > profit:
-                profit = price - lowest
-
-        return profit
+            res = max(res, price - lowest)
+        return res

python/0134-gas-station.py

@@ -1,18 +1,14 @@
 class Solution:
     def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int:
-        total_gas = 0
-        remaining_gas = 0
-        start_index = 0
+        start, end = len(gas) - 1, 0
+        total = gas[start] - cost[start]
 
-        for i in range(len(gas)):
-            total_gas += gas[i] - cost[i]
-            remaining_gas += gas[i] - cost[i]
-
-            if remaining_gas < 0:
-                remaining_gas = 0
-                start_index = i + 1
-
-        if total_gas >= 0:
-            return start_index
-        else:
-            return -1
+        while start >= end:
+            while total < 0 and start >= end:
+                start -= 1
+                total += gas[start] - cost[start]
+            if start == end:
+                return start
+            total += gas[end] - cost[end]
+            end += 1
+        return -1

python/0150-evaluate-reverse-polish-notation.py

@@ -1,29 +1,17 @@
 class Solution:
     def evalRPN(self, tokens: List[str]) -> int:
-        h = {
-            '+': self.add,
-            '-': self.subtract,
-            '*': self.multiply,
-            '/': self.divide
-        }
-        
         stack = []
-        for t in tokens:
-            if t in h:
-                b, a = stack.pop(), stack.pop()
-                t = h[t](a, b)
-            stack.append(int(t))
-                
+        for c in tokens:
+            if c == "+":
+                stack.append(stack.pop() + stack.pop())
+            elif c == "-":
+                a, b = stack.pop(), stack.pop()
+                stack.append(b - a)
+            elif c == "*":
+                stack.append(stack.pop() * stack.pop())
+            elif c == "/":
+                a, b = stack.pop(), stack.pop()
+                stack.append(int(float(b) / a))
+            else:
+                stack.append(int(c))
         return stack[0]
-    
-    def add(self, a, b):
-        return a + b
-
-    def subtract(self, a, b):
-        return a - b
-    
-    def multiply(self, a, b):
-        return a * b
-    
-    def divide(self, a, b):
-        return a / b

python/0153-find-minimum-in-rotated-sorted-array.py

@@ -1,10 +1,18 @@
 class Solution:
     def findMin(self, nums: List[int]) -> int:
-        l, r = 0, len(nums) - 1
-        while l < r:
-            m = l + (r - l) // 2
-            if nums[m] > nums[r]:
-                l = m + 1
+        start , end = 0, len(nums) - 1 
+        curr_min = float("inf")
+        
+        while start  <  end :
+            mid = (start + end ) // 2
+            curr_min = min(curr_min,nums[mid])
+            
+            # right has the min 
+            if nums[mid] > nums[end]:
+                start = mid + 1
+                
+            # left has the  min 
             else:
-                r = m
-        return nums[l]
+                end = mid - 1 
+                
+        return min(curr_min,nums[start])

python/0424-longest-repeating-character-replacement.py

@@ -1,13 +1,15 @@
 class Solution:
-    def characterReplacement(self, s, k):
-        counts = {}
-        maxf = 0
+    def characterReplacement(self, s: str, k: int) -> int:
+        count = {}
+        
         l = 0
-        for r, ch in enumerate(s):
-            counts[ch] = 1 + counts.get(ch, 0)
-            maxf = max(maxf, counts[ch])
-            if maxf + k < r - l + 1:
-                counts[s[l]] -= 1
+        maxf = 0
+        for r in range(len(s)):
+            count[s[r]] = 1 + count.get(s[r], 0)
+            maxf = max(maxf, count[s[r]])
+
+            if (r - l + 1) - maxf > k:
+                count[s[l]] -= 1
                 l += 1
 
-        return len(s) - l
+        return (r - l + 1)

python/0567-permutation-in-string.py

@@ -1,5 +1,5 @@
 class Solution:
-    def checkInclusion(self, s1, s2):
+    def checkInclusion(self, s1: str, s2: str) -> bool:
         if len(s1) > len(s2):
             return False
 
@@ -8,24 +8,27 @@ def checkInclusion(self, s1, s2):
             s1Count[ord(s1[i]) - ord("a")] += 1
             s2Count[ord(s2[i]) - ord("a")] += 1
 
-        matches = sum(map(lambda i: s1Count[i] == s2Count[i], range(26)))
+        matches = 0
+        for i in range(26):
+            matches += 1 if s1Count[i] == s2Count[i] else 0
 
-        for l in range(len(s2) - len(s1)):
+        l = 0
+        for r in range(len(s1), len(s2)):
             if matches == 26:
                 return True
 
-            i = ord(s2[l]) - ord("a")
-            s2Count[i] -= 1
-            if s2Count[i] == s1Count[i]:
+            index = ord(s2[r]) - ord("a")
+            s2Count[index] += 1
+            if s1Count[index] == s2Count[index]:
                 matches += 1
-            elif s2Count[i] == s1Count[i] - 1:
+            elif s1Count[index] + 1 == s2Count[index]:
                 matches -= 1
 
-            i = ord(s2[l + len(s1)]) - ord("a")
-            s2Count[i] += 1
-            if s2Count[i] == s1Count[i]:
+            index = ord(s2[l]) - ord("a")
+            s2Count[index] -= 1
+            if s1Count[index] == s2Count[index]:
                 matches += 1
-            elif s2Count[i] == s1Count[i] + 1:
+            elif s1Count[index] - 1 == s2Count[index]:
                 matches -= 1
-
-        return matches == 26
+            l += 1
+        return matches == 26