Added solution for Two Sum and best time to buy and sell stock

challenge-01/README.md

@@ -0,0 +1,6 @@
+## Personal Information
+### Name
+Khalid Adeel p
+
+### Email
+adeelpv360@gmail.com

challenge-01/two-sum.py

@@ -0,0 +1,8 @@
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        num_indices = {}
+        for i,num in enumerate(nums):
+            difference = target - num
+            if difference in num_indices:
+                return [num_indices[difference], i]
+            num_indices[num]=i

challenge-02/best-time-to-buy-and-sell-stoc.py

@@ -0,0 +1,13 @@
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        right, left = 1, 0
+        profit = 0
+
+        while right < len(prices):
+            if prices[right] > prices[left]:
+                if profit < (prices[right] - prices[left]):
+                    profit = prices[right] - prices[left]
+            else:
+                left = right
+            right +=1
+        return profit

challenge-03/contains-duplicate.py

@@ -0,0 +1,9 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        array = set()
+        for i in nums:
+            if i in array:
+                return True
+            else:
+                array.add(i)
+        return False

challenge-04/sum-of-two-integers.py

@@ -0,0 +1,8 @@
+class Solution:
+    def getSum(self, a: int, b: int) -> int:
+        mask = 0xffffffff
+        while (mask&b) > 0:
+            a, b = a ^ b, (a&b)<<1
+        return (mask&a) if b > 0 else a 
+
+

challenge-05/product-of-array-except-self.py

@@ -0,0 +1,12 @@
+class Solution:
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        res = [1] * (len(nums))
+        prefix = 1
+        for i in range(len(nums)):
+            res[i] = prefix
+            prefix *= nums[i]
+        postfix = 1
+        for i in range(len(nums) -1, -1, -1):
+            res[i] *= postfix
+            postfix *= nums[i]
+        return res

challenge-06/maximum-product-subarray.py

@@ -0,0 +1,16 @@
+class Solution:
+    def maxProduct(self, nums: List[int]) -> int:
+        cur_min = 1
+        cur_max = 1
+        res = nums[0]
+
+        for num in nums:
+            temp = cur_max * num
+            cur_max = max(temp, cur_min * num, num)
+            cur_min = min(temp, cur_min * num, num)
+
+            res = max(res, cur_max)
+
+        return res
+
+

challenge-07/maximum-subarray.py

@@ -0,0 +1,12 @@
+class Solution:
+    def maxSubArray(self, nums: List[int]) -> int:
+        max_sum = nums[0]
+        cur_sum = 0
+
+        for i in nums:
+            if cur_sum < 0:
+                cur_sum = 0
+            cur_sum += i
+            max_sum = max(max_sum, cur_sum)
+
+        return max_sum

challenge-08/find-minimum-in-rotated-sorted-array.py

@@ -0,0 +1,23 @@
+class Solution:
+    def findMin(self, nums: List[int]) -> int:
+        l = 0
+        r = len(nums)-1
+        res = nums[0]
+
+        while l <= r:
+            if nums[l] < nums[r]:
+                res = min(res, nums[l])
+                break
+            m = (l+r)//2
+            res = min(res, nums[m])
+
+            if nums[l] <= nums[m]:
+                l = m+1
+            else:
+                r = m-1
+
+        return res
+
+
+# Time : O(LogN)
+# Space : O(1)

challenge-09/search-in-rotated-sorted-array.py

@@ -0,0 +1,29 @@
+class Solution:
+    def search(self, nums: List[int], target: int) -> int:
+        l = 0
+        r = len(nums) - 1
+
+        while l <= r:
+            mid = (l + r) // 2
+
+            if nums[mid] == target:
+                return mid
+
+            # left sorted portion
+            elif nums[mid] >= nums[l]:
+                if nums[l] <= target <= nums[mid]:
+                    r = mid - 1
+                else:
+                    l = mid + 1
+
+            # right sorted portion
+            else:
+                if nums[mid] <= target <= nums[r]:
+                    l = mid + 1
+                else:
+                    r = mid - 1
+
+        return -1
+
+# TC : O(LogN)
+# SC : O(1)

challenge-10/3sum.py

@@ -0,0 +1,30 @@
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        nums.sort()
+        res = []
+
+        for i in range(len(nums) - 2):
+            if i > 0 and nums[i] == nums[i-1]:
+                continue
+            l = i+1
+            r = len(nums) - 1
+
+            while l < r:
+                total = nums[i] + nums[l] + nums[r]
+                if total < 0:
+                    l +=1
+                elif total > 0:
+                    r -= 1
+                else:
+                    triplet = [nums[i], nums[l], nums[r]]
+                    res.append(triplet)
+                    while l < r and nums[l] == triplet[1]:
+                        l += 1
+                    while l < r and nums[r] == triplet[2]:
+                        r -= 1
+        return res 
+
+
+
+# TC : O(N^2)
+# sc : o(1)

challenge-11/container-with-most-water.py

@@ -0,0 +1,22 @@
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        l, r = 0, len(height) - 1
+        maxArea = 0
+
+        while l < r:
+            if height[l] > height[r]:
+                h = height[r]
+                w = r - l
+                area = h * w
+                r -= 1
+            else: 
+                h = height[l]
+                w = r - l
+                area = h * w
+                l += 1
+            maxArea = max(area, maxArea)
+        return maxArea
+
+
+# TC : O(N)
+# SC : O(1)

challenge-12/number-of-1-bits.py

@@ -0,0 +1,9 @@
+class Solution:
+    def hammingWeight(self, n: int) -> int:
+        bit = list(bin(n))
+        count = 0
+        for i in range(len(bit)):
+            if bit[i] == '1':
+                count += 1
+        return count
+

challenge-13/counting-bits.py

@@ -0,0 +1,10 @@
+class Solution:
+    def countBits(self, n: int) -> List[int]:
+        ans = [0] * (n+1)
+        for i in range(1, n + 1):
+            ans[i] = ans[i >> 1] + (i & 1)
+
+        return ans
+
+# TC : O(N)
+# SC : O(N)

challenge-14/missing-number.py

@@ -0,0 +1,10 @@
+class Solution:
+    def missingNumber(self, nums: List[int]) -> int:
+        value = len(nums)
+
+        for i, num in enumerate(nums):
+            value ^= i ^ num
+        return value
+
+# TC : O(N)
+# SC : O(1)

challenge-15/reverse-bits.py

@@ -0,0 +1,11 @@
+class Solution:
+    def reverseBits(self, n: int) -> int:
+        res = 0
+        for i in range(32):
+            res <<=1
+            res |= (n&1)
+            n >>= 1
+        return res
+
+# TC : O(1)
+# SC : O(1)

challenge-16/climbing-stairs.py

@@ -0,0 +1,12 @@
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        a, b = 1, 1
+
+        for i in range(n - 2, -1, -1):
+            c = a+b
+            a = b
+            b = c
+        return b
+
+# TC : O(N)
+# SC : O(1)

challenge-17/coin-change.py

@@ -0,0 +1,15 @@
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        dp = [amount + 1] * (amount + 1)
+        dp[0] = 0
+
+        for value in range(1, amount + 1):
+            for c in coins:
+                if value - c >= 0:
+                    dp[value] = min(dp[value], 1 + dp[value - c])
+
+        return dp[amount] if dp[amount] != amount + 1 else -1
+
+
+# TC : O(N∗Amount)
+# SC : O(Amount)

challenge-18/longest-increasing-subsequence.py

@@ -0,0 +1,17 @@
+class Solution:
+    def lengthOfLIS(self, nums: List[int]) -> int:
+        if not nums:
+            return 0
+
+        l = len(nums)
+        dp = [1] * l
+
+        for i in range(1, l):
+            for j in range(i):
+                if nums[i] > nums[j]:
+                    dp[i] = max(dp[i], dp[j] + 1)
+
+        return max(dp)
+
+# TC : O(N^2)
+# SC : O(N)

challenge-19/longest-common-subsequence.py

@@ -0,0 +1,14 @@
+class Solution:
+    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
+        c = [[0 for j in range(len(text2)+1)] for i in range(len(text1)+1)]
+        for i in range(len(text1)-1, -1, -1):
+            for j in range(len(text2)-1, -1, -1):
+                if text1[i] == text2[j]:
+                    c[i][j] = 1 + c[i+1][j+1]
+                else:
+                    c[i][j] = max(c[i][j+1], c[i+1][j])
+        ans = c[i][j]
+        return ans
+
+# TC : O(N^2)
+# SC : O(N^2)

challenge-20/word-break.py

@@ -0,0 +1,20 @@
+class Solution:
+    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
+        def construct(current, wordDict, memo={}):
+            if current in memo:
+                return memo[current]
+
+            if not current:
+                return True
+
+            for word in wordDict:
+                if current.startswith(word):
+                    new_current = current[len(word):]
+                    if construct(new_current, wordDict, memo):
+                        memo[current] = True
+                        return True
+
+            memo[current] = False
+            return False
+
+        return construct(s,wordDict)

challenge-21/combination-sum-iv.py

@@ -0,0 +1,14 @@
+class Solution:
+    def combinationSum4(self, nums: List[int], target: int):
+        dp = [0] * (target + 1)
+        dp[0] = 1
+
+        for i in range(1, target + 1):
+            for num in nums:
+                if i - num >= 0:
+                    dp[i] += dp[i - num]
+
+        return dp[target]
+
+# TC : O(Target * N)
+# SC : O(Target)

challenge-22/house-robber.py

@@ -0,0 +1,13 @@
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        rob1 = rob2 = 0
+
+        for val in nums:
+            decision = max(val + rob1, rob2)
+            rob1 = rob2
+            rob2 = decision
+
+        return rob2
+
+# TC : O(N)
+# SC : O(1)