From ab1310289063740d1d1a5dbcf4b1ed095ee0886b Mon Sep 17 00:00:00 2001 From: arjun Date: Mon, 17 Mar 2025 21:17:42 -0400 Subject: [PATCH 01/60] challenge-1-readme --- challenge-1/readme.md | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 challenge-1/readme.md diff --git a/challenge-1/readme.md b/challenge-1/readme.md new file mode 100644 index 0000000..42f7976 --- /dev/null +++ b/challenge-1/readme.md @@ -0,0 +1,2 @@ +arjun a chandran +arjun43250@gmail.com From cd5497bd4822555152a463e2ce704a15ad93de7a Mon Sep 17 00:00:00 2001 From: arjun Date: Tue, 18 Mar 2025 22:32:19 -0400 Subject: [PATCH 02/60] completed: two-sum-py --- challenge-1/readme.md | 2 ++ challenge-2/twosum.py | 12 ++++++++++++ 2 files changed, 14 insertions(+) create mode 100644 challenge-2/twosum.py diff --git a/challenge-1/readme.md b/challenge-1/readme.md index 42f7976..a0f0255 100644 --- a/challenge-1/readme.md +++ b/challenge-1/readme.md @@ -1,2 +1,4 @@ arjun a chandran arjun43250@gmail.com + +https://docs.google.com/spreadsheets/d/17S7OZYJUf5Sm7HgbGBgq5Fc0sIC8_A0kymL4ijSYbCQ/edit \ No newline at end of file diff --git a/challenge-2/twosum.py b/challenge-2/twosum.py new file mode 100644 index 0000000..d119b72 --- /dev/null +++ b/challenge-2/twosum.py @@ -0,0 +1,12 @@ +ls = list(map(int,input().split())) +t = int(input()) + + +#using hashmap + +hm = {} +for i,n in enumerate(ls): + if (t-n) in hm: + print ([hm[t-n],i]) + else: + hm[n] = i From 2063c081709bcc037c803555fd2dc32db45145d3 Mon Sep 17 00:00:00 2001 From: arjun Date: Wed, 19 Mar 2025 21:55:17 -0400 Subject: [PATCH 03/60] feat: best-time-to-buy-and-sell-stock --- challenge-3/best-time-to-buy-and-sell-stock.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 challenge-3/best-time-to-buy-and-sell-stock.py diff --git a/challenge-3/best-time-to-buy-and-sell-stock.py b/challenge-3/best-time-to-buy-and-sell-stock.py new file mode 100644 index 0000000..2fcf205 --- /dev/null +++ b/challenge-3/best-time-to-buy-and-sell-stock.py @@ -0,0 +1,15 @@ +stocks = list(map(int,intpu().split())) + +# using sliding window +l = 0 +r = 1 +ans = 0 + +while r < len(stocks): + if stocks[l] < stocks[r] : + if ans < stocks[r] - stocks[l]: + ans = stocks[r] - stocks[l] + else: + l = r + r+=1 +print (ans) \ No newline at end of file From 453ba8576b694da6f4f467e919fc9ae5dc8971f9 Mon Sep 17 00:00:00 2001 From: arjun Date: Thu, 20 Mar 2025 21:51:26 -0400 Subject: [PATCH 04/60] feat: day-4-contains-duplicate --- challenge-4/contains-duplicate.py | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 challenge-4/contains-duplicate.py diff --git a/challenge-4/contains-duplicate.py b/challenge-4/contains-duplicate.py new file mode 100644 index 0000000..a6fb1ae --- /dev/null +++ b/challenge-4/contains-duplicate.py @@ -0,0 +1,10 @@ +list = list(map(int,input().split())) + +hs= set() +for i,val in enumerate(list): + if val in hs: + print(True) + else: + hs.add(val) + +print(False) From 91e81a079ff7dcbfe5524b5fa5fff5b0b711a590 Mon Sep 17 00:00:00 2001 From: arjun Date: Sat, 22 Mar 2025 19:57:00 -0400 Subject: [PATCH 05/60] feat: challenge-5-completed --- challenge-5/sum-of-two-integer.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 challenge-5/sum-of-two-integer.java diff --git a/challenge-5/sum-of-two-integer.java b/challenge-5/sum-of-two-integer.java new file mode 100644 index 0000000..d6f55d7 --- /dev/null +++ b/challenge-5/sum-of-two-integer.java @@ -0,0 +1,14 @@ +import java.util.*; +public class Main{ + public static void main(String args[]){ + Scanner in = new Scanner(System.in); + int a = in.nextInt(); + int b = in.nextInt(); + while (b != 0){ + int t = (a&b)<<1; + a = a^b; + b = t + } + System.out.println(b); + } +} \ No newline at end of file From 8d8d85d34e03570e5f16acef06d33ef8f3f44f04 Mon Sep 17 00:00:00 2001 From: arjun Date: Sun, 23 Mar 2025 11:38:48 -0400 Subject: [PATCH 06/60] feat: completed-6 --- challenge-6/products-of-array-execpt-self.py | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 challenge-6/products-of-array-execpt-self.py diff --git a/challenge-6/products-of-array-execpt-self.py b/challenge-6/products-of-array-execpt-self.py new file mode 100644 index 0000000..9f3749b --- /dev/null +++ b/challenge-6/products-of-array-execpt-self.py @@ -0,0 +1,16 @@ +ls = list(map(int,input().split())) + +n = len(ls) + +pre = [1] *n +pos = [1] *n + +pre[0] = pos[n-1] = 1 + +for i in range(1,n): + pre[i] = ls[i-1] * pre[i-1] +for i in range(n-2,-1,-1): + pos[i] = ls[i+1] * pos[i+1] +for i in range(n): + ls[i] = pre[i] * pos[i] +print(ls) \ No newline at end of file From 256185701dfb5d83b15bbcf2fb0a12057a2d7462 Mon Sep 17 00:00:00 2001 From: arjun Date: Mon, 24 Mar 2025 23:35:48 -0400 Subject: [PATCH 07/60] feat: complted-challenge-7 --- challenge-7/max-sum-array.py | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 challenge-7/max-sum-array.py diff --git a/challenge-7/max-sum-array.py b/challenge-7/max-sum-array.py new file mode 100644 index 0000000..4d66cf8 --- /dev/null +++ b/challenge-7/max-sum-array.py @@ -0,0 +1,9 @@ +class Solution: + def maxSubArray(self, nums: List[int]) -> int: + res = nums[0] + for i in range(len(nums)): + currmax = 0 + for j in range(i,len(nums)): + currmax += nums[j] + res = max(currmax,res) + return res \ No newline at end of file From 2d8e8bc462b5391671ab8a2341bd2348d8ee81ec Mon Sep 17 00:00:00 2001 From: arjun Date: Mon, 24 Mar 2025 23:40:29 -0400 Subject: [PATCH 08/60] feat: complteted --- challenge-8/max-product-array.py | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 challenge-8/max-product-array.py diff --git a/challenge-8/max-product-array.py b/challenge-8/max-product-array.py new file mode 100644 index 0000000..d8462a0 --- /dev/null +++ b/challenge-8/max-product-array.py @@ -0,0 +1,11 @@ +class Solution: + def maxProduct(self, nums: List[int]) -> int: + res = nums[0] + curMin, curMax = 1, 1 + + for num in nums: + tmp = curMax * num + curMax = max(num * curMax, num * curMin, num) + curMin = min(tmp, num * curMin, num) + res = max(res, curMax) + return res \ No newline at end of file From 2fb4741320fbb638425703cfe604b76d75827f6b Mon Sep 17 00:00:00 2001 From: arjun Date: Tue, 25 Mar 2025 23:12:36 -0400 Subject: [PATCH 09/60] feat: complteted --- challenge-9/min-rotated-sorted-array.py | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 challenge-9/min-rotated-sorted-array.py diff --git a/challenge-9/min-rotated-sorted-array.py b/challenge-9/min-rotated-sorted-array.py new file mode 100644 index 0000000..a30a65a --- /dev/null +++ b/challenge-9/min-rotated-sorted-array.py @@ -0,0 +1,10 @@ +class Solution: + def findMin(self, nums: List[int]) -> int: + l, r = 0, len(nums) - 1 + while l < r: + m = l + (r - l) // 2 + if nums[m] < nums[r]: + r = m + else: + l = m + 1 + return nums[l] \ No newline at end of file From 88194a1afab5b3d365757efedc295404ffb32219 Mon Sep 17 00:00:00 2001 From: arjun Date: Wed, 26 Mar 2025 22:56:30 -0400 Subject: [PATCH 10/60] feat: completeed-challenge-10 --- challenge-10/search-in-rotated-array.py | 29 +++++++++++++++++++++++++ challenge-8/max-product-array.py | 10 ++++++++- 2 files changed, 38 insertions(+), 1 deletion(-) create mode 100644 challenge-10/search-in-rotated-array.py diff --git a/challenge-10/search-in-rotated-array.py b/challenge-10/search-in-rotated-array.py new file mode 100644 index 0000000..9120610 --- /dev/null +++ b/challenge-10/search-in-rotated-array.py @@ -0,0 +1,29 @@ +class Solution: + def search(self, nums: List[int], target: int) -> int: + l, r = 0, len(nums) - 1 + + while l < r: + m = (l + r) // 2 + if nums[m] > nums[r]: + l = m + 1 + else: + r = m + + pivot = l + + def binary_search(left: int, right: int) -> int: + while left <= right: + mid = (left + right) // 2 + if nums[mid] == target: + return mid + elif nums[mid] < target: + left = mid + 1 + else: + right = mid - 1 + return -1 + + result = binary_search(0, pivot - 1) + if result != -1: + return result + + return binary_search(pivot, len(nums) - 1) \ No newline at end of file diff --git a/challenge-8/max-product-array.py b/challenge-8/max-product-array.py index d8462a0..84e7470 100644 --- a/challenge-8/max-product-array.py +++ b/challenge-8/max-product-array.py @@ -8,4 +8,12 @@ def maxProduct(self, nums: List[int]) -> int: curMax = max(num * curMax, num * curMin, num) curMin = min(tmp, num * curMin, num) res = max(res, curMax) - return res \ No newline at end of file + return res + + + + + + + + \ No newline at end of file From ca1d36974ce8a0c0a391adaf4635cadd8d1eb922 Mon Sep 17 00:00:00 2001 From: arjun Date: Fri, 28 Mar 2025 00:13:34 -0400 Subject: [PATCH 11/60] feat: challenge-11-complted --- challenge-11/3sum.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 challenge-11/3sum.py diff --git a/challenge-11/3sum.py b/challenge-11/3sum.py new file mode 100644 index 0000000..e69de29 From cce93cec1293afb918e72a7dd599015e1d4f0bd8 Mon Sep 17 00:00:00 2001 From: arjun Date: Fri, 28 Mar 2025 22:45:34 -0400 Subject: [PATCH 12/60] feat: 12-finished --- challenge-11/3sum.py | 24 ++++++++++++++++++++++++ challenge-12/contains-most-water.py | 12 ++++++++++++ 2 files changed, 36 insertions(+) create mode 100644 challenge-12/contains-most-water.py diff --git a/challenge-11/3sum.py b/challenge-11/3sum.py index e69de29..e4d726c 100644 --- a/challenge-11/3sum.py +++ b/challenge-11/3sum.py @@ -0,0 +1,24 @@ +class Solution: + def threeSum(self, nums: List[int]) -> List[List[int]]: + nums.sort() + count = defaultdict(int) + for num in nums: + count[num] += 1 + + res = [] + for i in range(len(nums)): + count[nums[i]] -= 1 + if i and nums[i] == nums[i - 1]: + continue + + for j in range(i + 1, len(nums)): + count[nums[j]] -= 1 + if j - 1 > i and nums[j] == nums[j - 1]: + continue + target = -(nums[i] + nums[j]) + if count[target] > 0: + res.append([nums[i], nums[j], target]) + + for j in range(i + 1, len(nums)): + count[nums[j]] += 1 + return res \ No newline at end of file diff --git a/challenge-12/contains-most-water.py b/challenge-12/contains-most-water.py new file mode 100644 index 0000000..8d81426 --- /dev/null +++ b/challenge-12/contains-most-water.py @@ -0,0 +1,12 @@ +class Solution: + def maxArea(self, h: List[int]) -> int: + l,r = 0,len(h)-1 + ma = 0 + while l Date: Sun, 30 Mar 2025 09:48:40 -0400 Subject: [PATCH 13/60] feat: complted-13 --- challenege-13/number-1-bits.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 challenege-13/number-1-bits.py diff --git a/challenege-13/number-1-bits.py b/challenege-13/number-1-bits.py new file mode 100644 index 0000000..6ba0f92 --- /dev/null +++ b/challenege-13/number-1-bits.py @@ -0,0 +1,14 @@ +class Solution: + def hammingWeight(self, n: int) -> int: + binn = [] + while n > 0 : + bit = n % 2 + binn.append(str(bit)) + n //=2 + binn.reverse() + s = "".join(binn) + ans = 0 + for i in s: + if i == "1": + ans +=1 + return ans \ No newline at end of file From cb005f35c5f864ea6159b5d686fc269d4564639a Mon Sep 17 00:00:00 2001 From: arjun Date: Sun, 30 Mar 2025 09:54:50 -0400 Subject: [PATCH 14/60] feat: challenege-14-completed --- challenge-14/counting-bits.py | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 challenge-14/counting-bits.py diff --git a/challenge-14/counting-bits.py b/challenge-14/counting-bits.py new file mode 100644 index 0000000..0d78676 --- /dev/null +++ b/challenge-14/counting-bits.py @@ -0,0 +1,12 @@ +class Solution: + def countBits(self, n: int) -> List[int]: + ans = [0] * (n+1) + for i in range(n+1): + ans[i] = self.c(i) + return ans + def c(self , n:int) -> int: + res = 0 + while n > 0: + res += n&1 + n = n>>1 + return res \ No newline at end of file From eba05515dd7d4d21e379ec7be50ea40686588ff6 Mon Sep 17 00:00:00 2001 From: arjun Date: Mon, 31 Mar 2025 20:37:00 -0400 Subject: [PATCH 15/60] feat: complted-day-15 --- challenge-15/missing-number.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 challenge-15/missing-number.py diff --git a/challenge-15/missing-number.py b/challenge-15/missing-number.py new file mode 100644 index 0000000..e69de29 From 541121553e9def72999a6728a9ea501abf2c2a8c Mon Sep 17 00:00:00 2001 From: arjun Date: Tue, 1 Apr 2025 19:12:43 -0400 Subject: [PATCH 16/60] completed-day-16 --- challenge-16/reverse-bits.py | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 challenge-16/reverse-bits.py diff --git a/challenge-16/reverse-bits.py b/challenge-16/reverse-bits.py new file mode 100644 index 0000000..13db012 --- /dev/null +++ b/challenge-16/reverse-bits.py @@ -0,0 +1,7 @@ +class Solution: + def reverseBits(self, n: int) -> int: + res = 0 + for i in range(32): + bit = (n >> i) & 1 + res += (bit << (31 - i)) + return res \ No newline at end of file From c614fba0d2f97e111c8c2efd32c2df274a3efc9f Mon Sep 17 00:00:00 2001 From: arjun Date: Wed, 2 Apr 2025 21:18:57 -0400 Subject: [PATCH 17/60] feat: completed-challenge-17 --- challenge-15/missing-number.py | 8 ++++++++ challenge-17/climbing-stairs.py | 11 +++++++++++ 2 files changed, 19 insertions(+) create mode 100644 challenge-17/climbing-stairs.py diff --git a/challenge-15/missing-number.py b/challenge-15/missing-number.py index e69de29..388a101 100644 --- a/challenge-15/missing-number.py +++ b/challenge-15/missing-number.py @@ -0,0 +1,8 @@ +class Solution: + def missingNumber(self, nums: List[int]) -> int: + s = set(nums) + for i in range(len(nums)): + if i not in s: + return i + return len(nums) + \ No newline at end of file diff --git a/challenge-17/climbing-stairs.py b/challenge-17/climbing-stairs.py new file mode 100644 index 0000000..3c5d497 --- /dev/null +++ b/challenge-17/climbing-stairs.py @@ -0,0 +1,11 @@ +class Solution: + def climbStairs(self, n: int) -> int: + cache = [-1] * n + def dfs(i): + if i >= n: + return i == n + if cache[i] != -1: + return cache[i] + cache[i] = dfs(i+1) + dfs(i+2) + return cache[i] + return dfs(0) \ No newline at end of file From c0403e35df5676c849bd487e5722a442f216215a Mon Sep 17 00:00:00 2001 From: arjun Date: Fri, 4 Apr 2025 09:54:45 -0400 Subject: [PATCH 18/60] feat: completed-chanllenge-18 --- challenge-18/coin-change.py | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 challenge-18/coin-change.py diff --git a/challenge-18/coin-change.py b/challenge-18/coin-change.py new file mode 100644 index 0000000..0752ebc --- /dev/null +++ b/challenge-18/coin-change.py @@ -0,0 +1,10 @@ +class Solution: + def coinChange(self, coins: List[int], amount: int) -> int: + dp = [amount + 1] * (amount + 1) + dp[0] = 0 + + for a in range(1, amount + 1): + for c in coins: + if a - c >= 0: + dp[a] = min(dp[a], 1 + dp[a - c]) + return dp[amount] if dp[amount] != amount + 1 else -1 \ No newline at end of file From ad99949014ad10aa8af1b4d0a55af7fe7a1cab89 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Sat, 5 Apr 2025 11:07:37 +0530 Subject: [PATCH 19/60] feat: challenge-19-completed --- challenge-19/longest-increasing-subseqence.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 challenge-19/longest-increasing-subseqence.py diff --git a/challenge-19/longest-increasing-subseqence.py b/challenge-19/longest-increasing-subseqence.py new file mode 100644 index 0000000..243969e --- /dev/null +++ b/challenge-19/longest-increasing-subseqence.py @@ -0,0 +1,15 @@ +class Solution: + def lengthOfLIS(self, nums): + n = len(nums) + dp = [[0] * (n + 1) for _ in range(n + 1)] + + for i in range(n - 1, -1, -1): + for j in range(i - 1, -2, -1): + LIS = dp[i + 1][j + 1] + + if j == -1 or nums[j] < nums[i]: + LIS = max(LIS, 1 + dp[i + 1][i + 1]) + + dp[i][j + 1] = LIS + + return dp[0][0] \ No newline at end of file From 42b1ffee5f345b9c56892b0fd8774ebd9c262734 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Mon, 7 Apr 2025 11:04:10 +0530 Subject: [PATCH 20/60] feat: completed-challenge-20 --- challenege-20/longest-common-subseqence.py | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 challenege-20/longest-common-subseqence.py diff --git a/challenege-20/longest-common-subseqence.py b/challenege-20/longest-common-subseqence.py new file mode 100644 index 0000000..6e66fa3 --- /dev/null +++ b/challenege-20/longest-common-subseqence.py @@ -0,0 +1,18 @@ +class Solution: + def longestCommonSubsequence(self, text1: str, text2: str) -> int: + memo = {} + + def dfs(i, j): + if i == len(text1) or j == len(text2): + return 0 + if (i, j) in memo: + return memo[(i, j)] + + if text1[i] == text2[j]: + memo[(i, j)] = 1 + dfs(i + 1, j + 1) + else: + memo[(i, j)] = max(dfs(i + 1, j), dfs(i, j + 1)) + + return memo[(i, j)] + + return dfs(0, 0) \ No newline at end of file From b7ac42be60ab6cd517de637dd8f65620863a589f Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Mon, 7 Apr 2025 11:05:02 +0530 Subject: [PATCH 21/60] feat: completed-challenege-21 --- challenge-21/work-break.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 challenge-21/work-break.py diff --git a/challenge-21/work-break.py b/challenge-21/work-break.py new file mode 100644 index 0000000..781c612 --- /dev/null +++ b/challenge-21/work-break.py @@ -0,0 +1,15 @@ +class Solution: + def wordBreak(self, s: str, wordDict: List[str]) -> bool: + wordSet = set(wordDict) + + def dfs(i): + if i == len(s): + return True + + for j in range(i, len(s)): + if s[i : j + 1] in wordSet: + if dfs(j + 1): + return True + return False + + return dfs(0) \ No newline at end of file From f4ba5a80c88695be23c818e0c58493b1bb374494 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Tue, 8 Apr 2025 10:13:38 +0530 Subject: [PATCH 22/60] feat: completed-challenge-22 --- challenege-22/combination-sum-IV.py | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 challenege-22/combination-sum-IV.py diff --git a/challenege-22/combination-sum-IV.py b/challenege-22/combination-sum-IV.py new file mode 100644 index 0000000..c18abb4 --- /dev/null +++ b/challenege-22/combination-sum-IV.py @@ -0,0 +1,10 @@ +class Solution: + def combinationSum4(self, nums: List[int], target: int) -> int: + dp = [0] * (target + 1) + dp[0] = 1 + for currentSum in range(1, target + 1): + for numIndex in range(0, len(nums)): + currentNum = nums[numIndex] + if currentSum - currentNum >= 0: + dp[currentSum] += dp[currentSum - currentNum] + return dp[target] \ No newline at end of file From e0dbd1f96b88b38dd040a66c77f566527b90be5e Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Wed, 9 Apr 2025 10:34:38 +0530 Subject: [PATCH 23/60] feat: challenge-23-complted --- challenege-23/house-robber.py | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 challenege-23/house-robber.py diff --git a/challenege-23/house-robber.py b/challenege-23/house-robber.py new file mode 100644 index 0000000..542b8ef --- /dev/null +++ b/challenege-23/house-robber.py @@ -0,0 +1,19 @@ +class Solution: + def rob(self, nums: List[int]) -> int: + dp = [-1] * (len(nums)+1) + def helper (nums , ind): + if ind == 0: + return nums[0] + if ind < 0: + return 0 + if dp[ind] == -1: + pick = nums[ind] + helper(nums , ind-2) + notPick = 0 + helper(nums,ind-1) + dp[ind] = max(pick ,notPick) + return dp[ind] + return helper(nums,len(nums)-1) + + + + + \ No newline at end of file From 6fb240d9e883e58606310b013aaaba31edc75c27 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Thu, 10 Apr 2025 08:56:15 +0530 Subject: [PATCH 24/60] feat: completed-challenege-24 --- challenege-24/house-robber-2.py | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 challenege-24/house-robber-2.py diff --git a/challenege-24/house-robber-2.py b/challenege-24/house-robber-2.py new file mode 100644 index 0000000..756b965 --- /dev/null +++ b/challenege-24/house-robber-2.py @@ -0,0 +1,11 @@ +class Solution: + def rob(self, nums: List[int]) -> int: + + def helper(ls): + temp , prevMax = 0 , 0 + for n in ls: + newMax = max(temp+n,prevMax) + temp = prevMax + prevMax = newMax + return prevMax + return max(nums[0] , helper(nums[1:]) , helper(nums[:-1])) From 980cfdcec215e8bcb788fb46734870144c4b61ce Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Fri, 11 Apr 2025 10:01:38 +0530 Subject: [PATCH 25/60] feat: completed-challenge-25 --- challenge-25/decodeWays.py | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 challenge-25/decodeWays.py diff --git a/challenge-25/decodeWays.py b/challenge-25/decodeWays.py new file mode 100644 index 0000000..b3add58 --- /dev/null +++ b/challenge-25/decodeWays.py @@ -0,0 +1,20 @@ +class Solution: + def numDecodings(self, s: str) -> int: + dp = {len(s) : 1} + + def dfs(i): + if i in dp: + return dp[i] + if s[i] == "0": + return 0 + + res = dfs(i + 1) + if i + 1 < len(s) and ( + s[i] == "1" or s[i] == "2" and + s[i + 1] in "0123456" + ): + res += dfs(i + 2) + dp[i] = res + return res + + return dfs(0) \ No newline at end of file From b6cca910b374862ad2d4066ed5eb79334021d26e Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Sat, 12 Apr 2025 09:28:08 +0530 Subject: [PATCH 26/60] feat: completed-challenege-26 --- chellenege-26/uniqurePath.py | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 chellenege-26/uniqurePath.py diff --git a/chellenege-26/uniqurePath.py b/chellenege-26/uniqurePath.py new file mode 100644 index 0000000..3317515 --- /dev/null +++ b/chellenege-26/uniqurePath.py @@ -0,0 +1,18 @@ +class Solution: + def uniquePaths(self, m: int, n: int) -> int: + dp = [[-1 for _ in range(n)] for _ in range(m)] + def helper(m,n,x,y,dp): + if x==m-1 and y==n-1: + return 1 + if dp[x][y] != -1: + return dp[x][y] + if x==m-1: + dp[x][y] = helper(m,n,x,y+1,dp) + elif y==n-1: + dp[x][y] = helper(m,n,x+1,y,dp) + else : + left = helper(m,n,x+1,y,dp) + right = helper(m,n,x,y+1,dp) + dp[x][y] = left+right + return dp[x][y] + return helper(m,n,0,0,dp) From 1fe6a55474caac3a84052db3e4ce034f0ab032d0 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Sun, 13 Apr 2025 10:00:13 +0530 Subject: [PATCH 27/60] feat: completed-challenege-27 --- challenege-27/jump-game.py | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 challenege-27/jump-game.py diff --git a/challenege-27/jump-game.py b/challenege-27/jump-game.py new file mode 100644 index 0000000..9815f96 --- /dev/null +++ b/challenege-27/jump-game.py @@ -0,0 +1,7 @@ +class Solution: + def canJump(self, nums: List[int]) -> bool: + g = len(nums) -1 + for i in range(len(nums)-1,-1,-1): + if i+nums[i] >= g: + g = i + return True if g==0 else False From 25ca53210e2ae1d9728ce00ebac5674e982610a9 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Mon, 14 Apr 2025 09:28:00 +0530 Subject: [PATCH 28/60] feat: completed-challenege-28 --- challenege-28/clone-graph.py | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 challenege-28/clone-graph.py diff --git a/challenege-28/clone-graph.py b/challenege-28/clone-graph.py new file mode 100644 index 0000000..73f4fb6 --- /dev/null +++ b/challenege-28/clone-graph.py @@ -0,0 +1,23 @@ +""" +# Definition for a Node. +class Node: + def __init__(self, val = 0, neighbors = None): + self.val = val + self.neighbors = neighbors if neighbors is not None else [] +""" + +from typing import Optional +class Solution: + def cloneGraph(self, node: Optional['Node']) -> Optional['Node']: + hm = {} + def clone(node): + if node in hm: + return hm[node] + copy = Node(node.val) + hm[node] = copy + for n in node.neighbors: + copy.neighbors.append(clone(n)) + return copy + return clone(node) if node else None + + \ No newline at end of file From aa4ea96c6075d9c2154f03c87dfd05be259028c3 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Tue, 15 Apr 2025 10:12:11 +0530 Subject: [PATCH 29/60] feat: challenge-29-completed --- challenge-29/course-shedule.py | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 challenge-29/course-shedule.py diff --git a/challenge-29/course-shedule.py b/challenge-29/course-shedule.py new file mode 100644 index 0000000..d6fe70e --- /dev/null +++ b/challenge-29/course-shedule.py @@ -0,0 +1,23 @@ +class Solution: + def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool: + preM = {i : [] for i in range(numCourses)} + for crs,pre in prerequisites: + preM[crs].append(pre) + + visited = set() + def dfs(crs): + if crs in visited: + return False + if preM[crs] == []: + return True + visited.add(crs) + for pre in preM[crs]: + if not dfs(pre): + return False + visited.remove(crs) + preM[crs] = [] + return True + for c in range(numCourses): + if not dfs(c): + return False + return True \ No newline at end of file From 5278980e92e1da56488b9f997d312c3d63d53713 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Wed, 16 Apr 2025 11:20:14 +0530 Subject: [PATCH 30/60] feat: completed-challenge-30 --- challenge-30/atlantic-pacific.py | 39 ++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 challenge-30/atlantic-pacific.py diff --git a/challenge-30/atlantic-pacific.py b/challenge-30/atlantic-pacific.py new file mode 100644 index 0000000..ba2fa60 --- /dev/null +++ b/challenge-30/atlantic-pacific.py @@ -0,0 +1,39 @@ +class Solution: + def pacificAtlantic(self, heights: List[List[int]]) -> List[List[int]]: + ROWS, COLS = len(heights), len(heights[0]) + directions = [(1, 0), (-1, 0), (0, 1), (0, -1)] + pac = [[False] * COLS for _ in range(ROWS)] + atl = [[False] * COLS for _ in range(ROWS)] + + def bfs(source, ocean): + q = deque(source) + while q: + r, c = q.popleft() + ocean[r][c] = True + for dr, dc in directions: + nr, nc = r + dr, c + dc + if (0 <= nr < ROWS and 0 <= nc < COLS and + not ocean[nr][nc] and + heights[nr][nc] >= heights[r][c] + ): + q.append((nr, nc)) + + pacific = [] + atlantic = [] + for c in range(COLS): + pacific.append((0, c)) + atlantic.append((ROWS - 1, c)) + + for r in range(ROWS): + pacific.append((r, 0)) + atlantic.append((r, COLS - 1)) + + bfs(pacific, pac) + bfs(atlantic, atl) + + res = [] + for r in range(ROWS): + for c in range(COLS): + if pac[r][c] and atl[r][c]: + res.append([r, c]) + return res \ No newline at end of file From dc06331313e179545700c78241bee6b8182f1a8a Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Thu, 17 Apr 2025 09:27:34 +0530 Subject: [PATCH 31/60] feat: completed-challenege-31 --- challenege-31/number-of-islands.py | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 challenege-31/number-of-islands.py diff --git a/challenege-31/number-of-islands.py b/challenege-31/number-of-islands.py new file mode 100644 index 0000000..6f0e960 --- /dev/null +++ b/challenege-31/number-of-islands.py @@ -0,0 +1,23 @@ +class Solution: + def numIslands(self, grid: List[List[str]]) -> int: + directions = [[1, 0], [-1, 0], [0, 1], [0, -1]] + ROWS, COLS = len(grid), len(grid[0]) + islands = 0 + + def dfs(r, c): + if (r < 0 or c < 0 or r >= ROWS or + c >= COLS or grid[r][c] == "0" + ): + return + + grid[r][c] = "0" + for dr, dc in directions: + dfs(r + dr, c + dc) + + for r in range(ROWS): + for c in range(COLS): + if grid[r][c] == "1": + dfs(r, c) + islands += 1 + + return islands \ No newline at end of file From 703bcc4545a061ecc0ac83c319ccee711189b469 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Fri, 18 Apr 2025 09:07:22 +0530 Subject: [PATCH 32/60] feat: completed-challenege-32 --- .../longest-consective-sequence.java | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 challenege-32/longest-consective-sequence.java diff --git a/challenege-32/longest-consective-sequence.java b/challenege-32/longest-consective-sequence.java new file mode 100644 index 0000000..d1b3e78 --- /dev/null +++ b/challenege-32/longest-consective-sequence.java @@ -0,0 +1,20 @@ +import java.util.*; +class Solution { + public int longestConsecutive(int[] nums) { + int l = 0; + HashSet hs = new HashSet(); + for (int n: nums){ + hs.add(n); + } + for (int n :hs){ + if(!hs.contains(n-1)){ + int t = 0; + while (hs.contains(n + t)) { + t++; + } + l = Math.max(t, l); + } + } + return l; + } +} \ No newline at end of file From e321a030fdf19194cf85ecbbac452729fb4a3967 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Sat, 19 Apr 2025 09:14:22 +0530 Subject: [PATCH 33/60] feat: completed-challenge-33 --- .../FInd-building-where-alice-and-bob-meet.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 challenege-33/FInd-building-where-alice-and-bob-meet.py diff --git a/challenege-33/FInd-building-where-alice-and-bob-meet.py b/challenege-33/FInd-building-where-alice-and-bob-meet.py new file mode 100644 index 0000000..0fc5633 --- /dev/null +++ b/challenege-33/FInd-building-where-alice-and-bob-meet.py @@ -0,0 +1,13 @@ +class Solution: + def leftmostBuildingQueries(self, h: List[int], q: List[List[int]]) -> List[int]: + res = [-1] * len(q) + for i,k in enumerate(q): + l,r = sorted(k) + if l == r or h[l] < h[r]: + res[i] = r + continue + for j in range(r+1,len(h)): + if h[j] > max(h[l],h[r]): + res[i] = j + break + return res From d239231f752d00b9b601e5303625c33a02eb5167 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Sun, 20 Apr 2025 09:54:44 +0530 Subject: [PATCH 34/60] feat: completed-challenege-34 --- challenge-34/maximum-star-sum-of-graph.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 challenge-34/maximum-star-sum-of-graph.py diff --git a/challenge-34/maximum-star-sum-of-graph.py b/challenge-34/maximum-star-sum-of-graph.py new file mode 100644 index 0000000..58cf392 --- /dev/null +++ b/challenge-34/maximum-star-sum-of-graph.py @@ -0,0 +1,15 @@ +class Solution: + def maxStarSum(self, vals: List[int], edges: List[List[int]], k: int) -> int: + graph = defaultdict(set) + for i,j in edges: + if vals[i] > 0 : graph[j].add(i) + if vals[j] > 0 : graph[i].add(j) + + stars = [] + for i,v in enumerate(vals): + vv = [vals[j] for j in graph[i]] + vv.sort(reverse=True) + stars.append(v + sum(vv[0:k])) + + return max(stars) + \ No newline at end of file From 4cd7610fbee4c30325c6454fb0f2f641011b8653 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Mon, 21 Apr 2025 06:00:13 +0530 Subject: [PATCH 35/60] feat: completed-challenge-35 --- .../Count-Unreachable-Pairs-of-Nodes-in-an-Undirected-Graph.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 challenge-35/Count-Unreachable-Pairs-of-Nodes-in-an-Undirected-Graph.py diff --git a/challenge-35/Count-Unreachable-Pairs-of-Nodes-in-an-Undirected-Graph.py b/challenge-35/Count-Unreachable-Pairs-of-Nodes-in-an-Undirected-Graph.py new file mode 100644 index 0000000..e69de29 From 503b776dc07805bfa81b6d30299c6f2477a0a675 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Mon, 21 Apr 2025 06:00:51 +0530 Subject: [PATCH 36/60] added-code --- ...e-Pairs-of-Nodes-in-an-Undirected-Graph.py | 34 +++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/challenge-35/Count-Unreachable-Pairs-of-Nodes-in-an-Undirected-Graph.py b/challenge-35/Count-Unreachable-Pairs-of-Nodes-in-an-Undirected-Graph.py index e69de29..31df20d 100644 --- a/challenge-35/Count-Unreachable-Pairs-of-Nodes-in-an-Undirected-Graph.py +++ b/challenge-35/Count-Unreachable-Pairs-of-Nodes-in-an-Undirected-Graph.py @@ -0,0 +1,34 @@ +class UnionFind: + def __init__(self, size): + self.root = [i for i in range(size)] + self.rank = [1] * size + + def find(self, node): + if node != self.root[node]: + self.root[node] = self.find(self.root[node]) + return self.root[node] + + def union(self, node1, node2): + root1 = self.find(node1) + root2 = self.find(node2) + if root1 != root2: + if self.rank[root1] > self.rank[root2]: + self.root[root2] = root1 + elif self.rank[root1] < self.rank[root2]: + self.root[root1] = root2 + else: + self.root[root2] = root1 + self.rank[root1] += 1 + +class Solution: + def countPairs(self, n: int, edges: List[List[int]]) -> int: + uf = UnionFind(n) + for node1, node2 in edges: + uf.union(node1 - 1, node2 - 1) + group_sizes = list(Counter([uf.find(i) for i in range(n)]).values()) + ans = 0 + first_group_size = group_sizes[0] + for i in range(1, len(group_sizes)): + ans += first_group_size * group_sizes[i] + first_group_size += group_sizes[i] + return ans \ No newline at end of file From fa70fc53a214203dfb984064f340c81002f574df Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Tue, 22 Apr 2025 10:39:43 +0530 Subject: [PATCH 37/60] feat: completed-challenege-36 --- challenge-36/insert-interval.py | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 challenge-36/insert-interval.py diff --git a/challenge-36/insert-interval.py b/challenge-36/insert-interval.py new file mode 100644 index 0000000..79c6c01 --- /dev/null +++ b/challenge-36/insert-interval.py @@ -0,0 +1,21 @@ +class Solution: + def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]: + n = len(intervals) + i = 0 + res = [] + + while i < n and intervals[i][1] < newInterval[0]: + res.append(intervals[i]) + i += 1 + + while i < n and newInterval[1] >= intervals[i][0]: + newInterval[0] = min(newInterval[0], intervals[i][0]) + newInterval[1] = max(newInterval[1], intervals[i][1]) + i += 1 + res.append(newInterval) + + while i < n: + res.append(intervals[i]) + i += 1 + + return res \ No newline at end of file From e2801c29f36851730f60d14e6fd3bdc7324356a0 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Wed, 23 Apr 2025 07:27:39 +0530 Subject: [PATCH 38/60] completed-challenge-37 --- challenge-37/merge-interval.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 challenge-37/merge-interval.py diff --git a/challenge-37/merge-interval.py b/challenge-37/merge-interval.py new file mode 100644 index 0000000..b4da019 --- /dev/null +++ b/challenge-37/merge-interval.py @@ -0,0 +1,13 @@ +class Solution: + def merge(self, intervals: List[List[int]]) -> List[List[int]]: + intervals.sort(key=lambda pair: pair[0]) + output = [intervals[0]] + + for start, end in intervals: + lastEnd = output[-1][1] + + if start <= lastEnd: + output[-1][1] = max(lastEnd, end) + else: + output.append([start, end]) + return output \ No newline at end of file From 131ee507fa95ddd68b4ae8b58d141ef4927d5bbc Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Thu, 24 Apr 2025 07:18:47 +0530 Subject: [PATCH 39/60] completed challenge 38 --- challenege-38/non-overlapping-intervals.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 challenege-38/non-overlapping-intervals.py diff --git a/challenege-38/non-overlapping-intervals.py b/challenege-38/non-overlapping-intervals.py new file mode 100644 index 0000000..156d49b --- /dev/null +++ b/challenege-38/non-overlapping-intervals.py @@ -0,0 +1,14 @@ +class Solution: + def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int: + intervals.sort() + + res = 0 + prev = intervals[0][1] + for s,e in intervals[1:]: + if s >= prev: + prev = e + else: + res+=1 + prev = min(prev,e) + return res + \ No newline at end of file From 2be24aaf428ce848e21fb823f6b94fd9be232e86 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Sun, 27 Apr 2025 08:49:52 +0530 Subject: [PATCH 40/60] feat: challenge-40-completed --- challenege-40/meeting-rooms-2.py | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 challenege-40/meeting-rooms-2.py diff --git a/challenege-40/meeting-rooms-2.py b/challenege-40/meeting-rooms-2.py new file mode 100644 index 0000000..c46dedb --- /dev/null +++ b/challenege-40/meeting-rooms-2.py @@ -0,0 +1,19 @@ +""" +Definition of Interval: +class Interval(object): + def __init__(self, start, end): + self.start = start + self.end = end +""" + +class Solution: + def minMeetingRooms(self, intervals: List[Interval]) -> int: + intervals.sort(key=lambda x: x.start) + min_heap = [] + + for interval in intervals: + if min_heap and min_heap[0] <= interval.start: + heapq.heappop(min_heap) + heapq.heappush(min_heap, interval.end) + + return len(min_heap) \ No newline at end of file From bbabb1291411d9095c785dba6f70a3f9b78bba24 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Sun, 27 Apr 2025 08:58:10 +0530 Subject: [PATCH 41/60] feat: challenge-41-completed --- challenge-41/reverse-linkedlist.py | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 challenge-41/reverse-linkedlist.py diff --git a/challenge-41/reverse-linkedlist.py b/challenge-41/reverse-linkedlist.py new file mode 100644 index 0000000..36dbc78 --- /dev/null +++ b/challenge-41/reverse-linkedlist.py @@ -0,0 +1,22 @@ +# Definition for singly-linked list. +# class ListNode: +# def __init__(self, val=0, next=None): +# self.val = val +# self.next = next +class Solution: + def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]: + ls = [] + temp = head + while temp: + ls.append(temp.val) + temp = temp.next + temp = head + n = len(ls)-1 + while temp: + temp.val = ls[n] + n-=1 + temp = temp.next + return head + + + \ No newline at end of file From 0d4438f055e8aa3ada622928227ceda90f7d3845 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Mon, 28 Apr 2025 08:14:42 +0530 Subject: [PATCH 42/60] feat: completed-challenege-42 --- .../detect-cycle-in-linked-list.java | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 challenege-42/detect-cycle-in-linked-list.java diff --git a/challenege-42/detect-cycle-in-linked-list.java b/challenege-42/detect-cycle-in-linked-list.java new file mode 100644 index 0000000..455c3b8 --- /dev/null +++ b/challenege-42/detect-cycle-in-linked-list.java @@ -0,0 +1,27 @@ +/** + * Definition for singly-linked list. + * class ListNode { + * int val; + * ListNode next; + * ListNode(int x) { + * val = x; + * next = null; + * } + * } + */ +public class Solution { + public boolean hasCycle(ListNode head) { + if(head==null){ + return false; + } + ListNode slow = head, fast = head.next; + while(fast!=null && fast.next!=null){ + if(slow == fast){ + return true; + } + slow = slow.next; + fast = fast.next.next; + } + return false; + } +} \ No newline at end of file From fd9f6269ae8375b6d83b1514e911736b0751b5d7 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Tue, 29 Apr 2025 09:30:43 +0530 Subject: [PATCH 43/60] feat: completed-challenege-43 --- challenege-43/merge-two-sorted-list.py | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 challenege-43/merge-two-sorted-list.py diff --git a/challenege-43/merge-two-sorted-list.py b/challenege-43/merge-two-sorted-list.py new file mode 100644 index 0000000..8830025 --- /dev/null +++ b/challenege-43/merge-two-sorted-list.py @@ -0,0 +1,18 @@ +# Definition for singly-linked list. +# class ListNode: +# def __init__(self, val=0, next=None): +# self.val = val +# self.next = next + +class Solution: + def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]: + if list1 is None: + return list2 + if list2 is None: + return list1 + if list1.val <= list2.val: + list1.next = self.mergeTwoLists(list1.next, list2) + return list1 + else: + list2.next = self.mergeTwoLists(list1, list2.next) + return list2 \ No newline at end of file From e32cb393e306418281e6dcb3be3ed13be7d24368 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Wed, 30 Apr 2025 08:10:00 +0530 Subject: [PATCH 44/60] feat: completed-challenge-44 --- challenge-44/merge-k-sorted-list.py | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 challenge-44/merge-k-sorted-list.py diff --git a/challenge-44/merge-k-sorted-list.py b/challenge-44/merge-k-sorted-list.py new file mode 100644 index 0000000..cf9a1b7 --- /dev/null +++ b/challenge-44/merge-k-sorted-list.py @@ -0,0 +1,21 @@ +# Definition for singly-linked list. +# class ListNode: +# def __init__(self, val=0, next=None): +# self.val = val +# self.next = next + +class Solution: + def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]: + nodes = [] + for lst in lists: + while lst: + nodes.append(lst.val) + lst = lst.next + nodes.sort() + + res = ListNode(0) + cur = res + for node in nodes: + cur.next = ListNode(node) + cur = cur.next + return res.next \ No newline at end of file From 8364fb17ec376c52800ac95fa0786914b55e257a Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Thu, 1 May 2025 08:34:45 +0530 Subject: [PATCH 45/60] feat: completed-challenege-45 --- .../remove-nth-node-from-end-of-list.py | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 challenege-45/remove-nth-node-from-end-of-list.py diff --git a/challenege-45/remove-nth-node-from-end-of-list.py b/challenege-45/remove-nth-node-from-end-of-list.py new file mode 100644 index 0000000..f65c53e --- /dev/null +++ b/challenege-45/remove-nth-node-from-end-of-list.py @@ -0,0 +1,20 @@ +# Definition for singly-linked list. +# class ListNode: +# def __init__(self, val=0, next=None): +# self.val = val +# self.next = next + +class Solution: + def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]: + nodes = [] + cur = head + while cur: + nodes.append(cur) + cur = cur.next + + removeIndex = len(nodes) - n + if removeIndex == 0: + return head.next + + nodes[removeIndex - 1].next = nodes[removeIndex].next + return head \ No newline at end of file From ca52058970506cefeee9999f9eabb22e65ad6b4f Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Fri, 2 May 2025 12:12:16 +0530 Subject: [PATCH 46/60] feat: completed-challenge-46 --- challenege-46/reorder-list.py | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 challenege-46/reorder-list.py diff --git a/challenege-46/reorder-list.py b/challenege-46/reorder-list.py new file mode 100644 index 0000000..c588e1b --- /dev/null +++ b/challenege-46/reorder-list.py @@ -0,0 +1,27 @@ +# Definition for singly-linked list. +# class ListNode: +# def __init__(self, val=0, next=None): +# self.val = val +# self.next = next + +class Solution: + def reorderList(self, head: Optional[ListNode]) -> None: + slow, fast = head, head.next + while fast and fast.next: + slow = slow.next + fast = fast.next.next + + second = slow.next + prev = slow.next = None + while second: + tmp = second.next + second.next = prev + prev = second + second = tmp + + first, second = head, prev + while second: + tmp1, tmp2 = first.next, second.next + first.next = second + second.next = tmp1 + first, second = tmp1, tmp2 \ No newline at end of file From 1ffacd32f315f45fe9e8076f9c71b1b23c5a56f0 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Sat, 3 May 2025 10:25:36 +0530 Subject: [PATCH 47/60] feat: completed-challenege-47 --- challenege-47/set-zero.py | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 challenege-47/set-zero.py diff --git a/challenege-47/set-zero.py b/challenege-47/set-zero.py new file mode 100644 index 0000000..26690d9 --- /dev/null +++ b/challenege-47/set-zero.py @@ -0,0 +1,16 @@ +class Solution: + def setZeroes(self, matrix: List[List[int]]) -> None: + ROWS, COLS = len(matrix), len(matrix[0]) + mark = [[matrix[r][c] for c in range(COLS)] for r in range(ROWS)] + + for r in range(ROWS): + for c in range(COLS): + if matrix[r][c] == 0: + for col in range(COLS): + mark[r][col] = 0 + for row in range(ROWS): + mark[row][c] = 0 + + for r in range(ROWS): + for c in range(COLS): + matrix[r][c] = mark[r][c] \ No newline at end of file From 4d00231a780d4638d65cb1d25dbd4b653631e6da Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Sun, 4 May 2025 12:29:03 +0530 Subject: [PATCH 48/60] feat: completed-chalenege-48 --- challenege-48/spiral-matrix.py | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 challenege-48/spiral-matrix.py diff --git a/challenege-48/spiral-matrix.py b/challenege-48/spiral-matrix.py new file mode 100644 index 0000000..9be1a52 --- /dev/null +++ b/challenege-48/spiral-matrix.py @@ -0,0 +1,23 @@ +class Solution: + def spiralOrder(self, matrix: List[List[int]]) -> List[int]: + res = [] + left, right = 0, len(matrix[0]) + top, bottom = 0, len(matrix) + + while left < right and top < bottom: + for i in range(left, right): + res.append(matrix[top][i]) + top += 1 + for i in range(top, bottom): + res.append(matrix[i][right - 1]) + right -= 1 + if not (left < right and top < bottom): + break + for i in range(right - 1, left - 1, -1): + res.append(matrix[bottom - 1][i]) + bottom -= 1 + for i in range(bottom - 1, top - 1, -1): + res.append(matrix[i][left]) + left += 1 + + return res \ No newline at end of file From a9742e6243921ffeaaded444d284a3e6f00027f4 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Mon, 5 May 2025 16:22:50 +0530 Subject: [PATCH 49/60] feat: completed-challenge-49 --- challenge-49/rotate-image.py | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 challenge-49/rotate-image.py diff --git a/challenge-49/rotate-image.py b/challenge-49/rotate-image.py new file mode 100644 index 0000000..afcba1e --- /dev/null +++ b/challenge-49/rotate-image.py @@ -0,0 +1,12 @@ +class Solution: + def rotate(self, matrix: List[List[int]]) -> None: + n = len(matrix) + rotated = [[0] * n for _ in range(n)] + + for i in range(n): + for j in range(n): + rotated[j][n - 1 - i] = matrix[i][j] + + for i in range(n): + for j in range(n): + matrix[i][j] = rotated[i][j] \ No newline at end of file From f307f9521f3758e6cd2b0eacf2f80ac090178335 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Tue, 6 May 2025 09:02:42 +0530 Subject: [PATCH 50/60] feat: challenege-50-completed --- challenege-50/word-search.py | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 challenege-50/word-search.py diff --git a/challenege-50/word-search.py b/challenege-50/word-search.py new file mode 100644 index 0000000..480d4fb --- /dev/null +++ b/challenege-50/word-search.py @@ -0,0 +1,25 @@ +class Solution: + def exist(self, board: List[List[str]], word: str) -> bool: + ROWS, COLS = len(board), len(board[0]) + visited = [[False for _ in range(COLS)] for _ in range(ROWS)] + + def dfs(r, c, i): + if i == len(word): + return True + if (r < 0 or c < 0 or r >= ROWS or c >= COLS or + word[i] != board[r][c] or visited[r][c]): + return False + + visited[r][c] = True + res = (dfs(r + 1, c, i + 1) or + dfs(r - 1, c, i + 1) or + dfs(r, c + 1, i + 1) or + dfs(r, c - 1, i + 1)) + visited[r][c] = False + return res + + for r in range(ROWS): + for c in range(COLS): + if dfs(r, c, 0): + return True + return False \ No newline at end of file From 29e0862b999b5af5de4b98e5489d702474708901 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Wed, 7 May 2025 08:44:59 +0530 Subject: [PATCH 51/60] feat: completed-challenege-51 --- .../longest-substring-without-repeating-character.py | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 challenege-51/longest-substring-without-repeating-character.py diff --git a/challenege-51/longest-substring-without-repeating-character.py b/challenege-51/longest-substring-without-repeating-character.py new file mode 100644 index 0000000..b280664 --- /dev/null +++ b/challenege-51/longest-substring-without-repeating-character.py @@ -0,0 +1,12 @@ +class Solution: + def lengthOfLongestSubstring(self, s: str) -> int: + charset = set() + l = 0 + res = 0 + for r in range(len(s)): + while s[r] in charset: + charset.remove(s[l]) + l+=1 + charset.add(s[r]) + res = max(res, r-l + 1) + return res \ No newline at end of file From e46173cb116a521f1bef43df3044786212d2550f Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Thu, 8 May 2025 08:42:20 +0530 Subject: [PATCH 52/60] feat: completed-challenege-52 --- challenege-52/longest-repeating-char-replacement.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 challenege-52/longest-repeating-char-replacement.py diff --git a/challenege-52/longest-repeating-char-replacement.py b/challenege-52/longest-repeating-char-replacement.py new file mode 100644 index 0000000..002406f --- /dev/null +++ b/challenege-52/longest-repeating-char-replacement.py @@ -0,0 +1,13 @@ +class Solution: + def characterReplacement(self, s: str, k: int) -> int: + count = {} + l= 0 + res = 0 + for r in range(len(s)): + count[s[r]] = 1 + count.get(s[r],0) + while (r-l+1) - max(count.values()) > k: + count[s[l]] -= 1 + l+=1 + res = max(res,r-l+1) + return res + \ No newline at end of file From 7111a3bfc8c9e87e951bc66a7e98dbd40565e7b6 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Sat, 10 May 2025 09:53:36 +0530 Subject: [PATCH 53/60] feat: challenge-53-completed --- challenge-53/minimum-string-window.py | 30 +++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 challenge-53/minimum-string-window.py diff --git a/challenge-53/minimum-string-window.py b/challenge-53/minimum-string-window.py new file mode 100644 index 0000000..8ba7d86 --- /dev/null +++ b/challenge-53/minimum-string-window.py @@ -0,0 +1,30 @@ +class Solution: + def minWindow(self, s: str, t: str) -> str: + if t == "": + return "" + + countT, window = {}, {} + for c in t: + countT[c] = 1 + countT.get(c, 0) + + have, need = 0, len(countT) + res, resLen = [-1, -1], float("infinity") + l = 0 + for r in range(len(s)): + c = s[r] + window[c] = 1 + window.get(c, 0) + + if c in countT and window[c] == countT[c]: + have += 1 + + while have == need: + if (r - l + 1) < resLen: + res = [l, r] + resLen = r - l + 1 + + window[s[l]] -= 1 + if s[l] in countT and window[s[l]] < countT[s[l]]: + have -= 1 + l += 1 + l, r = res + return s[l : r + 1] if resLen != float("infinity") else "" \ No newline at end of file From 75c017bb7000e78ff9ee81be0db4d23197964cf2 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Sat, 10 May 2025 09:56:00 +0530 Subject: [PATCH 54/60] feat: completed-challenge-54 --- challenege-54/valid-anagram.py | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 challenege-54/valid-anagram.py diff --git a/challenege-54/valid-anagram.py b/challenege-54/valid-anagram.py new file mode 100644 index 0000000..cd32ca9 --- /dev/null +++ b/challenege-54/valid-anagram.py @@ -0,0 +1,11 @@ +class Solution: + def isAnagram(self, s: str, t: str) -> bool: + if len(s) != len(t): + return False + countS = {} + countT = {} + for i in range(len(s)): + countS[s[i]] = 1 + countS.get(s[i],0) + countT[t[i]] = 1 + countT.get(t[i],0) + return countS == countT + \ No newline at end of file From 2c453288dcef57ad515c3491e29e7fbc46a1d9dd Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Mon, 12 May 2025 08:52:42 +0530 Subject: [PATCH 55/60] feat: completed-challenge-55 --- challenge-55/valid-paranthesis.py | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 challenge-55/valid-paranthesis.py diff --git a/challenge-55/valid-paranthesis.py b/challenge-55/valid-paranthesis.py new file mode 100644 index 0000000..6c290c1 --- /dev/null +++ b/challenge-55/valid-paranthesis.py @@ -0,0 +1,18 @@ +class Solution: + def isValid(self, s: str) -> bool: + stack = [] + hm = { + ")" : "(", + "]" : "[", + "}" : "{", + } + for c in s: + if c in hm: + if stack and stack[-1] == hm[c]: + stack.pop() + else: + return False + else: + stack.append(c) + return True if not stack else False + \ No newline at end of file From f5a6ee901c1794048cf4e33d04659c425114a42a Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Tue, 13 May 2025 10:14:57 +0530 Subject: [PATCH 56/60] feat: completed-challenge-57 --- challenege-57/valid-palindrome.py | 16 ++++++++++++++++ .../{valid-paranthesis.py => group-anagram.py} | 0 challenge-56/valid-paranthesis.py | 18 ++++++++++++++++++ 3 files changed, 34 insertions(+) create mode 100644 challenege-57/valid-palindrome.py rename challenge-55/{valid-paranthesis.py => group-anagram.py} (100%) create mode 100644 challenge-56/valid-paranthesis.py diff --git a/challenege-57/valid-palindrome.py b/challenege-57/valid-palindrome.py new file mode 100644 index 0000000..00fa3f8 --- /dev/null +++ b/challenege-57/valid-palindrome.py @@ -0,0 +1,16 @@ +class Solution: + def isPalindrome(self, s: str) -> bool: + l,r=0,len(s)-1 + while l l and not self.alphaNum(s[r]): + r -= 1 + if s[l].lower() != s[r].lower(): + return False + l, r = l + 1, r - 1 + return True + def alphaNum(self, c): + return (ord('A') <= ord(c) <= ord('Z') or + ord('a') <= ord(c) <= ord('z') or + ord('0') <= ord(c) <= ord('9')) \ No newline at end of file diff --git a/challenge-55/valid-paranthesis.py b/challenge-55/group-anagram.py similarity index 100% rename from challenge-55/valid-paranthesis.py rename to challenge-55/group-anagram.py diff --git a/challenge-56/valid-paranthesis.py b/challenge-56/valid-paranthesis.py new file mode 100644 index 0000000..6c290c1 --- /dev/null +++ b/challenge-56/valid-paranthesis.py @@ -0,0 +1,18 @@ +class Solution: + def isValid(self, s: str) -> bool: + stack = [] + hm = { + ")" : "(", + "]" : "[", + "}" : "{", + } + for c in s: + if c in hm: + if stack and stack[-1] == hm[c]: + stack.pop() + else: + return False + else: + stack.append(c) + return True if not stack else False + \ No newline at end of file From 09734d56881fae7f13e9f1875240b2e9537ff628 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Wed, 14 May 2025 09:16:16 +0530 Subject: [PATCH 57/60] feat: completed-challenge-58 --- challenege-58/longest-palindrome-substring.py | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 challenege-58/longest-palindrome-substring.py diff --git a/challenege-58/longest-palindrome-substring.py b/challenege-58/longest-palindrome-substring.py new file mode 100644 index 0000000..5852deb --- /dev/null +++ b/challenege-58/longest-palindrome-substring.py @@ -0,0 +1,16 @@ +class Solution: + def longestPalindrome(self, s: str) -> str: + resIdx, resLen = 0, 0 + n = len(s) + + dp = [[False] * n for _ in range(n)] + + for i in range(n - 1, -1, -1): + for j in range(i, n): + if s[i] == s[j] and (j - i <= 2 or dp[i + 1][j - 1]): + dp[i][j] = True + if resLen < (j - i + 1): + resIdx = i + resLen = j - i + 1 + + return s[resIdx : resIdx + resLen] \ No newline at end of file From bbe7a2278f525d47c21a78462240984a819b71ce Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Thu, 15 May 2025 17:57:37 +0530 Subject: [PATCH 58/60] feat: completed-challenege-59 --- challenege-59/palindromic-substring.py | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 challenege-59/palindromic-substring.py diff --git a/challenege-59/palindromic-substring.py b/challenege-59/palindromic-substring.py new file mode 100644 index 0000000..bc6b0d4 --- /dev/null +++ b/challenege-59/palindromic-substring.py @@ -0,0 +1,12 @@ +class Solution: + def countSubstrings(self, s: str) -> int: + n, res = len(s), 0 + dp = [[False] * n for _ in range(n)] + + for i in range(n - 1, -1, -1): + for j in range(i, n): + if s[i] == s[j] and (j - i <= 2 or dp[i + 1][j - 1]): + dp[i][j] = True + res += 1 + + return res \ No newline at end of file From 2919e9c8e32ae3f4f509140d6bd30d7f84da81e2 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Fri, 16 May 2025 08:48:27 +0530 Subject: [PATCH 59/60] feat: completed-challenge-60 --- challenege-60/encode-and-decode-string.py | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 challenege-60/encode-and-decode-string.py diff --git a/challenege-60/encode-and-decode-string.py b/challenege-60/encode-and-decode-string.py new file mode 100644 index 0000000..1e266a1 --- /dev/null +++ b/challenege-60/encode-and-decode-string.py @@ -0,0 +1,22 @@ +class Solution: + + def encode(self, strs: List[str]) -> str: + ans = '' + for i in strs: + l = len(i) + ans += (str(l)+"#"+str(i)) + return ans + def decode(self, s: str) -> List[str]: + ls = [] + i = 0 + while i < len(s): + l = 0 + while s[i] != '#': + l = (l*10) +int(s[i]) + i+=1 + i+=1 + print(s[i: (i+l)]) + ls.append(s[i: (i+l)]) + i = i+l + return ls + From 917eed6d38b1c7707bd25284aa0d325224bf35c8 Mon Sep 17 00:00:00 2001 From: arjun-guvi Date: Sat, 17 May 2025 18:44:19 +0530 Subject: [PATCH 60/60] feat: completed-challenge-61 --- challenege-61/max-depth-bin-tree.py | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 challenege-61/max-depth-bin-tree.py diff --git a/challenege-61/max-depth-bin-tree.py b/challenege-61/max-depth-bin-tree.py new file mode 100644 index 0000000..80947b4 --- /dev/null +++ b/challenege-61/max-depth-bin-tree.py @@ -0,0 +1,23 @@ +# Definition for a binary tree node. +# 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: + q = deque() + if root: + q.append(root) + + level = 0 + while q: + for i in range(len(q)): + node = q.popleft() + if node.left: + q.append(node.left) + if node.right: + q.append(node.right) + level += 1 + return level \ No newline at end of file