Add files via upload

Author: rai-abhi24

3Sum - Leetcode 15.py

@@ -0,0 +1,16 @@
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        h = {}
+        n = len(nums)
+        s = set()
+
+        for i, num in enumerate(nums):
+            h[num] = i
+
+        for i in range(n):
+            for j in range(i + 1, n):
+                desired = -nums[i] - nums[j]
+                if desired in h and h[desired] != i and h[desired] != j:
+                    s.add(tuple(sorted([nums[i], nums[j], desired])))
+
+        return s

Container With Most Water - Leetcode 11.py

@@ -0,0 +1,18 @@
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        n = len(height)
+        l = 0
+        r = n - 1
+        max_area = 0
+
+        while l < r:
+            w = r - l
+            h = min(height[l], height[r])
+            a = w * h
+            max_area = max(max_area, a)
+            if height[l] < height[r]:
+                l += 1
+            else:
+                r -= 1
+
+        return max_area

Daily Temperatures - Leetcode 739.py

@@ -0,0 +1,14 @@
+class Solution:
+    def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
+        temps = temperatures
+        n = len(temps)
+        answer = [0] * n
+        stk = []
+
+        for i, t in enumerate(temps):
+            while stk and stk[-1][0] < t:
+                stk_t, stk_i = stk.pop()
+                answer[stk_i] = i - stk_i
+
+            stk.append((t, i))
+        return answer

Evaluate Reverse Polish Notation (RPN) - Leetcode 150.py

@@ -0,0 +1,23 @@
+from math import ceil, floor
+class Solution:
+    def evalRPN(self, tokens: List[str]) -> int:
+        stk = []
+        for t in tokens:
+            if t in "+-*/":
+                b, a = stk.pop(), stk.pop()
+
+                if t == "+":
+                    stk.append(a + b)
+                elif t == "-":
+                    stk.append(a - b)
+                elif t == "*":
+                    stk.append(a * b)
+                else:
+                    division = a / b
+                    if division < 0:
+                        stk.append(ceil(division))
+                    else:
+                        stk.append(floor(division))
+            else:
+                stk.append(int(t))
+        return stk[0]

Longest Consecutive Sequence - Leetcode 128.py

@@ -0,0 +1,14 @@
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        s = set(nums)
+        longest = 0
+        for num in nums:
+            if num - 1 not in s:
+                next_num = num + 1
+                length = 1
+                while next_num in s:
+                    length += 1
+                    next_num += 1
+                longest = max(longest, length)
+        
+        return longest

Min Stack - Leetcode 155.py

@@ -0,0 +1,23 @@
+class MinStack:
+    def __init__(self):
+        self.stk = []
+        self.min_stk = []
+
+    def push(self, val: int) -> None:
+        self.stk.append(val)
+        if not self.min_stk:
+            self.min_stk.append(val)
+        elif self.min_stk[-1] < val:
+            self.min_stk.append(self.min_stk[-1])
+        else:
+            self.min_stk.append(val)
+
+    def pop(self) -> None:
+        self.stk.pop()
+        self.min_stk.pop()
+
+    def top(self) -> int:
+        return self.stk[-1]
+
+    def getMin(self) -> int:
+        return self.min_stk[-1]

Reverse String - Leetcode 344.py

@@ -0,0 +1,12 @@
+class Solution:
+    def reverseString(self, s: List[str]) -> None:
+        """
+        Do not return anything, modify s in-place instead.
+        """
+        n = len(s)
+        l = 0
+        r = n - 1
+        while l < r:
+            s[l], s[r] = s[r], s[l]
+            l += 1
+            r -= 1

Squares of a Sorted Array - Leetcode 977.py

@@ -0,0 +1,17 @@
+class Solution:
+    def sortedSquares(self, nums: List[int]) -> List[int]:
+        left = 0
+        right = len(nums) - 1
+        result = []
+
+        while left <= right:
+            if abs(nums[left]) > abs(nums[right]):
+                result.append(nums[left] ** 2)
+                left += 1
+            else:
+                result.append(nums[right] ** 2)
+                right -= 1
+
+        result.reverse()
+
+        return result

Trapping Rain Water - Leetcode 42.py

@@ -0,0 +1,20 @@
+class Solution:
+    def trap(self, height: List[int]) -> int:
+        l_wall = r_wall = 0
+        n = len(height)
+        max_left = [0] * n
+        max_right = [0] * n
+
+        for i in range(n):
+            j = -i - 1
+            max_left[i] = l_wall
+            max_right[j] = r_wall
+            l_wall = max(l_wall, height[i])
+            r_wall = max(r_wall, height[j])
+
+        summ = 0
+        for i in range(n):
+            pot = min(max_left[i], max_right[i])
+            summ += max(0, pot - height[i])
+
+        return summ

Two Sum II - Leetcode 167.py

@@ -0,0 +1,14 @@
+class Solution:
+    def twoSum(self, numbers: List[int], target: int) -> List[int]:
+        n = len(numbers)
+        l = 0
+        r = n - 1
+
+        while l < r:
+            summ = numbers[l] + numbers[r]
+            if summ == target:
+                return [l + 1, r + 1]
+            elif summ < target:
+                l += 1
+            else:
+                r -= 1