Added all the summaries in the world

Author: peterbonnesoeur

1-D Dynamic Programming/100-palindromeSubstring.py

@@ -0,0 +1,19 @@
+class Solution:
+    def countSubstrings(self, s: str) -> int:
+        res = ""
+        resLen = 0
+        count_palyndrome = 0
+        for i in range(len(s)):
+
+            l, r = i, i
+            while l >= 0 and r < len(s) and s[l] == s[r]:
+                count_palyndrome += 1
+                l -= 1
+                r += 1
+
+            l, r = i, i + 1
+            while l >= 0 and r < len(s) and s[l] == s[r]:
+                count_palyndrome += 1
+                l -= 1
+                r += 1
+        return count_palyndrome

1-D_Dynamic_Programming/100-palindromeSubstring.py

@@ -5,48 +5,45 @@ def numDecodings(self, s: str) -> int:
             if s[i] == "0":
                 dp[i] = 0
             else:
-                dp[i] = dp[i+1]
+                dp[i] = dp[i + 1]
 
-            if i+1 < len(s) and (
+            if i + 1 < len(s) and (
                 (s[i] == "1") or s[i] == "2" and s[i + 1] in "0123456"
             ):
-                dp[i] += dp[i+2]
+                dp[i] += dp[i + 2]
 
         return dp[0]
-            
-
-
 
     def numDecodings_(self, s: str) -> int:
 
         if s.startswith("0"):
             return 0
-        
-        keys = set([str(i) for i in range(1,27)])
+
+        keys = set([str(i) for i in range(1, 27)])
         count = 1
         preMade = 0
 
         for i in range(len(s)):
             if s[i] in keys:
                 pass
-    
-            if i>=1 and s[i] == "0":
-                if int(s[i-1:i+1])>26:
+
+            if i >= 1 and s[i] == "0":
+                if int(s[i - 1 : i + 1]) > 26:
                     return 0
                 else:
                     print("here")
                     count -= 1
                     if preMade:
-                        count -=1
+                        count -= 1
                         preMade = 0
 
-            if i>=1 and s[i-1:i+1] in keys:
-                print("Add", s[i-1:i+1])
-                count+=1
-                if preMade>=2:
+            if i >= 1 and s[i - 1 : i + 1] in keys:
+                print("Add", s[i - 1 : i + 1])
+                count += 1
+                if preMade >= 2:
                     preMade
-                    count+=1
+                    count += 1
                 preMade = 1
             else:
                 preMade = False
-        return max(count,0)
+        return max(count, 0)

…D Dynamic Programming/101-numDecoding.py …D_Dynamic_Programming/101-numDecoding.py1-D Dynamic Programming/101-numDecoding.py renamed to 1-D_Dynamic_Programming/101-numDecoding.py 1-D Dynamic Programming/101-numDecoding.py renamed to 1-D_Dynamic_Programming/101-numDecoding.py

@@ -1,16 +1,15 @@
 # TO REDO
 
+
 class Solution:
     def coinChange(self, coins: List[int], amount: int) -> int:
-        dp = [amount + 1]*(amount + 1)
+        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], dp[a-c] + 1)
+                    dp[a] = min(dp[a], dp[a - c] + 1)
 
         print(dp)
         return dp[amount] if dp[amount] != amount + 1 else -1
-
-

1-D Dynamic Programming/102-coinChange.py 1-D_Dynamic_Programming/102-coinChange.py1-D Dynamic Programming/102-coinChange.py renamed to 1-D_Dynamic_Programming/102-coinChange.py

@@ -1,13 +1,12 @@
 class Solution:
     def maxProduct(self, nums: List[int]) -> int:
         res = nums[0]
-        curr_min, curr_max = 1,1
+        curr_min, curr_max = 1, 1
 
         for n in nums:
-            temp = n*curr_max
-            curr_max = max(temp, n*curr_min, n)
-            curr_min = min(temp, n*curr_min, n)
+            temp = n * curr_max
+            curr_max = max(temp, n * curr_min, n)
+            curr_min = min(temp, n * curr_min, n)
             res = max(curr_max, res)
 
         return res
-        

…ynamic Programming/103-MaximumProduct.py …ynamic_Programming/103-MaximumProduct.py1-D Dynamic Programming/103-MaximumProduct.py renamed to 1-D_Dynamic_Programming/103-MaximumProduct.py 1-D Dynamic Programming/103-MaximumProduct.py renamed to 1-D_Dynamic_Programming/103-MaximumProduct.py

@@ -5,16 +5,16 @@ def wordBreak(self, s: str, wordDict: List[str]) -> bool:
 
         # I have to get used to this structure. I had some
         # "Math issues" with the indexes here
-        dp = [0]*(len(s) + 1)
-        for i in range(len(s) +1):
+        dp = [0] * (len(s) + 1)
+        for i in range(len(s) + 1):
             for word in wordDict:
                 if len(word) < i + 1:
-                    if word != s[i-len(word):i]:
+                    if word != s[i - len(word) : i]:
                         continue
-                    
-                    if len(word) == i :
+
+                    if len(word) == i:
                         dp[i] = 1
-                    elif dp[i - len(word) ]:
+                    elif dp[i - len(word)]:
                         dp[i] = 1
         # print(dp)
         return dp[-1] == 1

1-D Dynamic Programming/104-WordBreak.py 1-D_Dynamic_Programming/104-WordBreak.py1-D Dynamic Programming/104-WordBreak.py renamed to 1-D_Dynamic_Programming/104-WordBreak.py

@@ -1,18 +1,15 @@
 class Solution:
     def lengthOfLIS(self, nums: List[int]) -> int:
-        dp = [1]* len(nums)
+        dp = [1] * len(nums)
 
-        for i in range(1,len(nums)):
+        for i in range(1, len(nums)):
             j = i - 1
             currMax = 0
             while j >= 0:
                 if nums[i] > nums[j]:
                     currMax = max(dp[j], currMax)
                     # break
-                j-=1
+                j -= 1
             dp[i] += currMax
         # print(dp)
         return max(dp)
-
-
-        

…D Dynamic Programming/105-lengthofLIS.py …D_Dynamic_Programming/105-lengthofLIS.py1-D Dynamic Programming/105-lengthofLIS.py renamed to 1-D_Dynamic_Programming/105-lengthofLIS.py 1-D Dynamic Programming/105-lengthofLIS.py renamed to 1-D_Dynamic_Programming/105-lengthofLIS.py

@@ -2,25 +2,23 @@
 class Solution:
     def canPartition(self, nums: List[int]) -> bool:
         # I am dumb for not thinking about this...
-        sums  = sum(nums)
-        if sums%2:
+        sums = sum(nums)
+        if sums % 2:
             return False
 
-        target = sum(nums)//2
+        target = sum(nums) // 2
 
         dp = set()
         dp.add(0)
-        for i in range (len(nums)):
+        for i in range(len(nums)):
             nextDP = set()
-            # Super simple when you thik about it since we just 
+            # Super simple when you thik about it since we just
             # need to explore the begining of the state
             for t in dp:
-                if (t+ nums[i]) == target:
+                if (t + nums[i]) == target:
                     return True
                 nextDP.add(t + nums[i])
                 nextDP.add(t)
             dp = nextDP
-        
-        return False
 
-        
+        return False

… Dynamic Programming/106-CanPartition.py …_Dynamic_Programming/106-CanPartition.py1-D Dynamic Programming/106-CanPartition.py renamed to 1-D_Dynamic_Programming/106-CanPartition.py 1-D Dynamic Programming/106-CanPartition.py renamed to 1-D_Dynamic_Programming/106-CanPartition.py

@@ -2,10 +2,11 @@
 # give the right solution.
 # Could also use a dfs if memory was not an issue and the depth of the tree was limited.
 
+
 class Solution:
     def climbStairs(self, n: int) -> int:
 
-        if n<=3:
+        if n <= 3:
             return n
 
         n1, n2 = 2, 3
@@ -15,4 +16,4 @@ def climbStairs(self, n: int) -> int:
             n1 = n2
             n2 = temp
 
-        return n1 + n2
+        return n1 + n2

…ynamic Programming/95-Climbing_Stairs.py …ynamic_Programming/95-Climbing_Stairs.py1-D Dynamic Programming/95-Climbing_Stairs.py renamed to 1-D_Dynamic_Programming/95-Climbing_Stairs.py 1-D Dynamic Programming/95-Climbing_Stairs.py renamed to 1-D_Dynamic_Programming/95-Climbing_Stairs.py

@@ -1,22 +1,21 @@
-
 class Solution:
     min_cost = 10_000_000
-    def minCostClimbingStairs(self, cost: List[int]) -> int:
 
-        def climbSteps(step_num: int, current_cost:int):
+    def minCostClimbingStairs(self, cost: List[int]) -> int:
+        def climbSteps(step_num: int, current_cost: int):
             if step_num > len(cost):
                 # print("here")
                 # current_cost += cost[val - 1]
                 # print(step_num, cost, current_cost)
-                if self.min_cost>current_cost:
+                if self.min_cost > current_cost:
                     self.min_cost = current_cost
 
             elif step_num <= len(cost):
                 current_cost += cost[step_num - 1]
                 # print(step_num, current_cost)
                 climbSteps(step_num + 1, current_cost)
                 climbSteps(step_num + 2, current_cost)
-        
-        climbSteps(1,0)
-        climbSteps(2,0)
-        return self.min_cost
+
+        climbSteps(1, 0)
+        climbSteps(2, 0)
+        return self.min_cost