Solution for Challenge 1

Challenge-1/solution.py

@@ -0,0 +1 @@
+#here my solution goes

Challenge-1/two_sum.py

@@ -0,0 +1,8 @@
+class Solution:
+    def twoSum(self, nums: list[int], target: int) -> list[int]:
+        hash = {}
+        for i in range(len(nums)):
+            temp = target - nums[i]
+            if temp in hash:
+                return [hash[temp], i]
+            hash[nums[i]] = i

Challenge-2/Best_time_to_buy_and_sell_stock.py

@@ -0,0 +1,11 @@
+class Solution:
+    def maxProfit(self, prices: list[int]) -> int:
+        max_profit = 0
+        l = 0
+        for r in range(1,len(prices)):
+            if prices[r]>prices[l]:
+                profit = prices[r]-prices[l]
+                max_profit = max(profit, max_profit)
+            else:
+                l = r
+        return max_profit

Challenge-4/product_of_array_except_self.py

@@ -0,0 +1,14 @@
+class Solution:
+    def productExceptSelf(self, nums: list[int]) -> list[int]:
+        n = len(nums)
+        answer = [1] * n
+        prefix = 1
+        for i in range(n):
+            answer[i] = prefix
+            prefix *= nums[i]
+        suffix = 1
+        for j in range(n - 1, -1, -1):
+            answer[j] *= suffix
+            suffix *= nums[j]
+        return answer
+

Challenge-5/max_subarray.py

@@ -0,0 +1,11 @@
+class Solution:
+    def maxSubArray(self, nums: list[int]) -> int:
+        max_sum = nums[0]
+        curr_sum = 0
+        for n in nums:
+            if curr_sum<0:
+                curr_sum=0
+            curr_sum += n
+            if max_sum<curr_sum:
+                max_sum = curr_sum
+        return max_sum

Challenge-6/max_product_subarrray.py

@@ -0,0 +1,10 @@
+class Solution:
+    def maxProduct(self, nums: list[int]) -> int:
+        result = nums[0]
+        curmax, curmin = 1,1
+        for n in nums:
+            temp = curmax*n
+            curmax = max(temp, curmin*n, n)
+            curmin = min(temp, curmin*n, n)
+            result = max(curmax, result)
+        return result

Challenge-7/min_in_rotated_sorted_array.py

@@ -0,0 +1,16 @@
+class Solution:
+    def findMin(self, nums: list[int]) -> int:
+        n = len(nums)
+        left = 0
+        right = n-1
+        if nums[left]<nums[right]:
+            return nums[0]
+        while left<right:
+            mid = (left+right)//2
+            if nums[mid]>nums[mid+1]:
+                return nums[mid+1]
+            else:
+                if nums[mid]>nums[0]:
+                    right = mid
+                else:
+                    left = mid

Challenge-8/search_in_sorted_rotated_array.py

@@ -0,0 +1,21 @@
+class Solution:
+    def search(self, nums: list[int], target: int) -> int:
+        left = 0
+        right = len(nums) - 1
+        while left <= right:
+            mid = (left + right) // 2
+            if nums[mid] == target:
+                return mid
+            # left half is sorted
+            if nums[left] <= nums[mid]:
+                if nums[left] <= target < nums[mid]:
+                    right = mid-1
+                else:
+                    left = mid+1
+            # right half is sorted
+            else:
+                if nums[mid] < target <= nums[right]:
+                    left = mid+1
+                else:
+                    right = mid-1
+        return -1

Challenge-9/three_sum.py

@@ -0,0 +1,32 @@
+class Solution:
+    def threeSum(self, nums: list[int]) -> list[list[int]]:
+        nums.sort()
+        n = len(nums)
+        result=[]
+
+        for i in range(n):
+            if i>0 and nums[i]==nums[i-1]:
+                continue
+
+            left,right = i+1,n-1
+
+            while left<right:
+                s = nums[i]+nums[left]+nums[right]
+
+                if s == 0:
+                    result.append([nums[i],nums[left],nums[right]])
+
+                    # Skip duplicates at left
+                    while left < right and nums[left] == nums[left + 1]:
+                        left += 1
+                    # Skip duplicates at right
+                    while left < right and nums[right] == nums[right - 1]:
+                        right -= 1
+
+                    left+=1
+                    right-=1
+                elif s<0:
+                    left+=1
+                else:
+                    right-=1
+        return result

Çhallenge-3/contains_duplicate.py

@@ -0,0 +1,8 @@
+class Solution:
+    def containsDuplicate(self, nums: list[int]) -> bool:
+        seen = set()
+        for num in nums:
+            if num in seen:
+                return True
+            seen.add(num)
+        return False