first commit

Author: Ataba29

Easy/1.py

@@ -0,0 +1,9 @@
+class Solution(object):
+    def twoSum(self, nums, target):
+        idx = {}
+        for i in range(len(nums)):
+            comp = target - nums[i]
+            if comp in idx:
+                return [i, idx[comp]]
+            idx[nums[i]] = i
+        return []

Easy/100.py

@@ -0,0 +1,24 @@
+# Definition for a binary tree node.
+from typing import Optional
+
+
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+
+class Solution:
+    def isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
+        if not p and not q:
+            return True
+        if (p == None) != (q == None):
+            return False
+        if p.val != q.val:
+            return False
+        return (
+            True
+            and self.isSameTree(p.right, q.right)
+            and self.isSameTree(p.left, q.left)
+        )

Easy/104.py

@@ -0,0 +1,19 @@
+# Definition for a binary tree node.
+from typing import Optional
+
+
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+
+class Solution:
+    def maxDepth(self, root: Optional[TreeNode]) -> int:
+        if root is None:
+            return 0
+
+        max_depth = max(self.maxDepth(root.left), self.maxDepth(root.right))
+
+        return max_depth + 1

Easy/1046.py

@@ -0,0 +1,17 @@
+from typing import List
+import heapq
+
+
+class Solution:
+    def lastStoneWeight(self, stones: List[int]) -> int:
+        stones = [-i for i in stones]
+        heapq.heapify(stones)
+
+        while len(stones) > 1:
+            y = -heapq.heappop(stones)
+            x = -heapq.heappop(stones)
+            newStone = y - x
+            if newStone > 0:
+                heapq.heappush(stones, -newStone)
+
+        return -stones[0] if len(stones) > 0 else 0

Easy/110.py

@@ -0,0 +1,29 @@
+# Definition for a binary tree node.
+from typing import Optional
+
+
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+
+class Solution:
+    res = True
+
+    def isBalanced(self, root: Optional[TreeNode]) -> bool:
+        def dfs(root):
+            if not root:
+                return 0
+
+            left = dfs(root.left)
+            right = dfs(root.right)
+
+            if left - right > 1 or right - left > 1:
+                self.res = self.res and False
+
+            return max(left, right) + 1
+
+        dfs(root)
+        return self.res

Easy/121.py

@@ -0,0 +1,13 @@
+from typing import List
+
+
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        curr_prof, max_prof = prices[0], 0
+
+        for p in prices[1:]:
+            if curr_prof > p:
+                curr_prof = p
+            max_prof = max(max_prof, p - curr_prof)
+
+        return max_prof

Easy/125.py

@@ -0,0 +1,14 @@
+class Solution:
+    def isPalindrome(self, s: str) -> bool:
+        l, r = 0, len(s) - 1
+
+        while l < r:
+            while l < r and not s[l].isalnum():
+                l += 1
+            while l < r and not s[r].isalnum():
+                r -= 1
+            if s[l].lower() != s[r].lower():
+                return False
+            r -= 1
+            l += 1
+        return True

Easy/13.py

@@ -0,0 +1,11 @@
+class Solution:
+    def romanToInt(self, s: str) -> int:
+        mapp = {"I": 1, "V": 5, "X": 10, "L": 50, "C": 100, "D": 500, "M": 1000}
+        res = mapp[s[-1]]
+        for i in range(len(s) - 2, -1, -1):
+            if mapp[s[i]] < mapp[s[i + 1]]:
+                res -= mapp[s[i]]
+            else:
+                res += mapp[s[i]]
+
+        return res

Easy/136.py

@@ -0,0 +1,9 @@
+from typing import List
+
+
+class Solution:
+    def singleNumber(self, nums: List[int]) -> int:
+        res = 0
+        for num in nums:
+            res = res ^ num
+        return res

Easy/14.py

@@ -0,0 +1,18 @@
+from typing import List
+
+
+class Solution:
+    def longestCommonPrefix(self, strs: List[str]) -> str:
+        if not strs:
+            return ""
+
+        res = ""
+
+        for i in range(len(strs[0])):
+            char = strs[0][i]
+            for s in strs[1:]:
+                # Stop if i exceeds length or mismatch found
+                if i >= len(s) or s[i] != char:
+                    return res
+            res += char
+        return res