@@ -1,5 +1,5 @@
 {
-"python.pythonPath": "/Users/alvee/.pyenv/versions/3.8.3/bin/python",
+"python.pythonPath": "/usr/local/bin/python3",
 "python.linting.pylintEnabled": true,
 "python.linting.enabled": true,
 "python.linting.mypyEnabled": false

@@ -0,0 +1,10 @@
+class Solution:
+def canJump(self, nums: List[int]) -> bool:
+max_reach = 0
+
+for i in range(len(nums)):
+max_reach = max(nums[i] + i, max_reach)
+if max_reach == i:
+break
+
+return max_reach >= len(nums) - 1

@@ -0,0 +1,18 @@
+class Solution:
+def uniquePaths(self, m: int, n: int) -> int:
+dp = [[0] * n for _ in range(m)]
+
+for r in range(m):
+dp[r][0] = 1
+
+for c in range(n):
+dp[0][c] = 1
+
+# list comprehension for above code
+# dp = [[1 if (c == 0 or r == 0) else 0 for c in range(n)] for r in range(m)]
+
+for r in range(1, m):
+for c in range(1, n):
+dp[r][c] = dp[r-1][c] + dp[r][c-1]
+
+return dp[m-1][n-1]

@@ -0,0 +1,20 @@
+class Solution:
+def coinChange(self, coins: List[int], amount: int) -> int:
+# dp table:
+# index denotes the current amount
+# value denotes the minimum number of coins requried to reach amount
+dp = [float('inf') for _ in range(amount + 1)]
+# 0 amount is always possible with 0 coins
+dp[0] = 0
+
+for coin in coins:
+for i in range(amount - coin + 1): # coin + i must be < amount
+cur_amount = i + coin # skips amounts that are less than current denomination
+cur_min = dp[i + coin]
+pos_min = dp[i] + 1 # current minimum coins + 1 coin of current denomination
+dp[cur_amount] = min(pos_min, cur_min)
+
+if dp[amount] == float('inf'):
+return -1
+
+return dp[amount]

@@ -0,0 +1,17 @@
+class Solution:
+def lengthOfLIS(self, nums: List[int]) -> int:
+dp = [1 for _ in range(len(nums))]
+max_len = 1
+
+# i: current index
+# j: previous index
+for i in range(len(dp)):
+for j in range(i):
+# cond 1: nums[j] < nums[i] as we want an increasing sequence
+# cond 2: dp[j] >= dp[i] to choose LIS if it's bigger
+# without including the num at current index
+if nums[j] < nums[i] and dp[j] >= dp[i]:
+dp[i] = dp[j] + 1
+max_len = max(dp[i], max_len)
+
+return max_len

@@ -0,0 +1,18 @@
+class Solution:
+def isHappy(self, n: int) -> bool:
+seen = set()
+
+while n not in seen:
+seen.add(n)
+n = self.findSquare(n)
+
+return n == 1
+
+def findSquare(self, n: int) -> int:
+square = 0
+
+while n != 0:
+square += (n % 10) ** 2
+n = n // 10
+
+return square

@@ -0,0 +1,9 @@
+class Solution:
+def trailingZeroes(self, n: int) -> int:
+num_fives = 0
+
+while n >= 5:
+num_fives += n // 5
+n = n // 5
+
+return num_fives

@@ -0,0 +1,7 @@
+class Solution:
+def titleToNumber(self, columnTitle: str) -> int:
+res = 0
+for char in columnTitle:
+diff = ord(char) - ord('A') + 1
+res = res * 26 + diff
+return res

@@ -0,0 +1,29 @@
+class Solution:
+def myPow(self, x: float, n: int) -> float:
+if n < 0:
+return 1 / self.powRec(x, -n)
+return self.powRec(x, n)
+
+def powRec(self, x, n):
+if n == 0:
+return 1
+elif n == 1:
+return x
+elif n % 2 == 0:
+return self.powRec(x * x, n / 2)
+else:
+return x * self.powRec(x, n - 1)
+
+class Solution2:
+def myPow(self, x, n):
+if n < 0:
+x = 1 / x
+n = -n
+
+res = 1
+while n:
+if n % 2 != 0:
+res *= x
+x *= x
+n //= 2
+return res

@@ -0,0 +1,17 @@
+class Solution:
+def mySqrt(self, x: int) -> int:
+l = 1
+r = x
+
+while l <= r:
+mid = (l + r) // 2
+
+x_temp = mid * mid
+if x_temp == x:
+return mid
+elif x_temp > x:
+r = mid - 1
+else:
+l = mid + 1
+
+return r