Solution of 1184, 1185, 1186

Author: Garvit244

1100-1200q/1184.py

@@ -0,0 +1,47 @@
+'''
+A bus has n stops numbered from 0 to n - 1 that form a circle. We know the distance between all pairs of neighboring stops where distance[i] is the distance between the stops number i and (i + 1) % n.
+
+The bus goes along both directions i.e. clockwise and counterclockwise.
+
+Return the shortest distance between the given start and destination stops.
+
+ 
+
+Example 1:
+Input: distance = [1,2,3,4], start = 0, destination = 1
+Output: 1
+Explanation: Distance between 0 and 1 is 1 or 9, minimum is 1.
+ 
+
+Example 2:
+Input: distance = [1,2,3,4], start = 0, destination = 2
+Output: 3
+Explanation: Distance between 0 and 2 is 3 or 7, minimum is 3.
+ 
+
+Example 3:
+Input: distance = [1,2,3,4], start = 0, destination = 3
+Output: 4
+Explanation: Distance between 0 and 3 is 6 or 4, minimum is 4.
+ 
+
+Constraints:
+
+1 <= n <= 10^4
+distance.length == n
+0 <= start, destination < n
+0 <= distance[i] <= 10^4
+'''
+
+class Solution(object):
+    def distanceBetweenBusStops(self, distance, start, destination):
+        """
+        :type distance: List[int]
+        :type start: int
+        :type destination: int
+        :rtype: int
+        """
+        start, destination = min(start, destination), max(start, destination)
+        clock_dist = sum(distance[start:destination])
+        anti_clock_dist = sum(distance[:start]) + sum(distance[destination:])
+        return min(clock_dist, anti_clock_dist)

1100-1200q/1185.py

@@ -0,0 +1,39 @@
+'''
+Given a date, return the corresponding day of the week for that date.
+
+The input is given as three integers representing the day, month and year respectively.
+
+Return the answer as one of the following values {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}.
+
+ 
+
+Example 1:
+
+Input: day = 31, month = 8, year = 2019
+Output: "Saturday"
+Example 2:
+
+Input: day = 18, month = 7, year = 1999
+Output: "Sunday"
+Example 3:
+
+Input: day = 15, month = 8, year = 1993
+Output: "Sunday"
+ 
+
+Constraints:
+
+The given dates are valid dates between the years 1971 and 2100.
+'''
+class Solution(object):
+    def dayOfTheWeek(self, day, month, year):
+        """
+        :type day: int
+        :type month: int
+        :type year: int
+        :rtype: str
+        """
+        day_of_week_map = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]
+        t = [ 0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4 ] 
+        year -= month < 3
+        return day_of_week_map[((year  + int(year / 4) - int(year / 100) + int(year / 400) + t[month - 1] + day) % 7)]

1100-1200q/1186.py

@@ -0,0 +1,63 @@
+'''
+Given an array of integers, return the maximum sum for a non-empty subarray (contiguous elements) with at most one element deletion. In other words, you want to choose a subarray and optionally delete one element from it so that there is still at least one element left and the sum of the remaining elements is maximum possible.
+
+Note that the subarray needs to be non-empty after deleting one element.
+
+ 
+
+Example 1:
+
+Input: arr = [1,-2,0,3]
+Output: 4
+Explanation: Because we can choose [1, -2, 0, 3] and drop -2, thus the subarray [1, 0, 3] becomes the maximum value.
+Example 2:
+
+Input: arr = [1,-2,-2,3]
+Output: 3
+Explanation: We just choose [3] and it's the maximum sum.
+Example 3:
+
+Input: arr = [-1,-1,-1,-1]
+Output: -1
+Explanation: The final subarray needs to be non-empty. You can't choose [-1] and delete -1 from it, then get an empty subarray to make the sum equals to 0.
+ 
+
+Constraints:
+
+1 <= arr.length <= 10^5
+-10^4 <= arr[i] <= 10^4
+'''
+
+class Solution(object):
+    def maximumSum(self, arr):
+        """
+        :type arr: List[int]
+        :rtype: int
+        """
+        forward = [0] * len(arr)
+        backward = [0] * len(arr)
+        
+        curr_max, max_so_far = arr[0], arr[0]
+        forward[0] = arr[0]
+        for index in range(1, len(arr)):
+            curr_max = max(arr[index], curr_max + arr[index])
+            max_so_far = max(max_so_far, curr_max)
+            
+            forward[index] = curr_max
+            
+        curr_max = arr[len(arr) - 1]
+        max_so_far = arr[len(arr) - 1]
+        backward[len(arr) - 1] = arr[len(arr) - 1]
+        
+        index = len(arr) - 2
+        while index >= 0:
+            curr_max = max(arr[index], curr_max + arr[index])
+            max_so_far = max(max_so_far, curr_max)
+            
+            backward[index] = curr_max
+            index -= 1
+            
+        result = max_so_far
+        for index in range(1, len(arr)-1):
+            result = max(result, forward[index-1] + backward[index + 1])
+        return result

README.md

@@ -13,7 +13,11 @@ Python solution of problems from [LeetCode](https://leetcode.com/).
 
 
 ##### [Problems 1100-1200](./1100-1200q/)
-
+| # | Title | Solution | Difficulty |
+|---| ----- | -------- | ---------- |
+|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|
 
 ##### [Problems 1000-1100](./1000-1100q/)
 | # | Title | Solution | Difficulty |