Solution of latest contest

Author: Garvit244

1100-1200q/1189.py

@@ -0,0 +1,38 @@
+'''
+Given a string text, you want to use the characters of text to form as many instances of the word "balloon" as possible.
+You can use each character in text at most once. Return the maximum number of instances that can be formed.
+
+ 
+Example 1:
+Input: text = "nlaebolko"
+Output: 1
+
+Example 2:
+Input: text = "loonbalxballpoon"
+Output: 2
+
+Example 3:
+Input: text = "leetcode"
+Output: 0
+ 
+
+Constraints:
+
+1 <= text.length <= 10^4
+text consists of lower case English letters only.
+'''
+
+class Solution(object):
+    def maxNumberOfBalloons(self, text):
+        """
+        :type text: str
+        :rtype: int
+        """
+        if not text:
+            return 0
+        
+        import collections
+        cnt = collections.Counter(text)
+        cnt_ballon = collections.Counter('balloon')
+        
+        return min([cnt[c]//cnt_ballon[c] for c in cnt_ballon])

1100-1200q/1190.py

@@ -0,0 +1,53 @@
+'''
+Given a string s that consists of lower case English letters and brackets. 
+
+Reverse the strings in each pair of matching parentheses, starting from the innermost one.
+
+Your result should not contain any bracket.
+
+ 
+Example 1:
+Input: s = "(abcd)"
+Output: "dcba"
+
+Example 2:
+Input: s = "(u(love)i)"
+Output: "iloveu"
+
+Example 3:
+Input: s = "(ed(et(oc))el)"
+Output: "leetcode"
+
+Example 4:
+Input: s = "a(bcdefghijkl(mno)p)q"
+Output: "apmnolkjihgfedcbq"
+ 
+
+Constraints:
+
+0 <= s.length <= 2000
+s only contains lower case English characters and parentheses.
+It's guaranteed that all parentheses are balanced.
+'''
+
+class Solution(object):
+    def reverseParentheses(self, s):
+        """
+        :type s: str
+        :rtype: str
+        """
+        if not s:
+            return ''
+        
+        stack = []
+        for char in s:
+            if char == ')':
+                combine_str = ''
+                while stack and stack[-1] != '(':
+                    elem = stack.pop()[::-1]
+                    combine_str += elem
+                stack.pop()
+                stack.append(combine_str)
+            else:
+                stack.append(char)
+        return "".join(stack)

1100-1200q/1191.py

@@ -0,0 +1,65 @@
+'''
+Given an integer array arr and an integer k, modify the array by repeating it k times.
+
+For example, if arr = [1, 2] and k = 3 then the modified array will be [1, 2, 1, 2, 1, 2].
+
+Return the maximum sub-array sum in the modified array. Note that the length of the sub-array can be 0 and its sum in that case is 0.
+
+As the answer can be very large, return the answer modulo 10^9 + 7.
+
+ 
+
+Example 1:
+
+Input: arr = [1,2], k = 3
+Output: 9
+Example 2:
+
+Input: arr = [1,-2,1], k = 5
+Output: 2
+Example 3:
+
+Input: arr = [-1,-2], k = 7
+Output: 0
+ 
+
+Constraints:
+
+1 <= arr.length <= 10^5
+1 <= k <= 10^5
+-10^4 <= arr[i] <= 10^4
+'''
+class Solution(object):
+    def kConcatenationMaxSum(self, arr, k):
+        """
+        :type arr: List[int]
+        :type k: int
+        :rtype: int
+        """
+        def kadane(arr):
+            curr_sum, max_sum = arr[0], arr[0]
+            for index in range(1, len(arr)):
+                curr_sum = max(arr[index], curr_sum + arr[index])
+                max_sum = max(max_sum, curr_sum)
+            return max_sum
+
+        def prefix(arr):
+            curr_sum, max_val = 0, float('-inf')
+            for index, val in enumerate(arr):
+                curr_sum += val
+                max_val = max(max_val, curr_sum)
+            return max_val
+        
+        def suffix(arr):
+            curr_sum, max_val = 0, float('-inf')
+            for index in range(len(arr)-1, -1, -1):
+                curr_sum += arr[index]
+                max_val = max(max_val, curr_sum)
+            return max_val
+        
+        if not arr:
+            return 0
+        if k == 1:
+            return max(0, kadane(arr)) % (10 ** 9 + 7)
+        else:
+            return max(0, max((prefix(arr) + suffix(arr) + (k-2)*max(sum(arr), 0), kadane(arr)))) % (10 ** 9 + 7)

README.md

@@ -15,6 +15,9 @@ Python solution of problems from [LeetCode](https://leetcode.com/).
 ##### [Problems 1100-1200](./1100-1200q/)
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|1191|[K-Concatenation Maximum Sum](https://leetcode.com/problems/k-concatenation-maximum-sum/)|[Python](./1100-1200q/1191.py)|Medium|
+|1190|[Reverse Substrings Between Each Pair of Parentheses](https://leetcode.com/problems/reverse-substrings-between-each-pair-of-parentheses/)|[Python](./1100-1200q/1190.py)|Medium|
+|1189|[ Maximum Number of Balloons](https://leetcode.com/problems/maximum-number-of-balloons/)|[Python](./1100-1200q/1189.py)|Easy|
 |1186|[Maximum Subarray Sum with One Deletion](https://leetcode.com/problems/maximum-subarray-sum-with-one-deletion/)|[Python](./1100-1200q/1186.py)|Medium|
 |1185|[Day of the Week](https://leetcode.com/problems/day-of-the-week/)|[Python](./1100-1200q/1185.py)|Easy|
 |1184|[Distance Between Bus Stops](https://leetcode.com/problems/distance-between-bus-stops/)|[Python](./1100-1200q/1184.py)|Easy|