Solutions for context 121 and 123

Author: Garvit244

900-1000q/977.py

@@ -0,0 +1,43 @@
+'''
+Given an array of integers A sorted in non-decreasing order, return an array of the squares of each number, also in sorted non-decreasing order.
+
+ 
+
+Example 1:
+
+Input: [-4,-1,0,3,10]
+Output: [0,1,9,16,100]
+Example 2:
+
+Input: [-7,-3,2,3,11]
+Output: [4,9,9,49,121]
+'''
+
+class Solution(object):
+    def sortedSquares(self, A):
+        """
+        :type A: List[int]
+        :rtype: List[int]
+        """
+        N = len(A)
+        j = 0
+        while j <N and A[j] < 0:
+            j += 1
+        i = j-1
+        result = []
+        while i >= 0 and j < N:
+            if A[i]**2 < A[j]**2:
+                result.append(A[i]**2)
+                i -= 1
+            else:
+                result.append(A[j]**2)
+                j += 1
+        while i>= 0:
+            result.append(A[i]**2)
+            i -= 1
+            
+        while j < N:
+            result.append(A[j]**2)
+            j += 1
+                
+        return result

900-1000q/981.py

@@ -0,0 +1,61 @@
+'''
+Create a timebased key-value store class TimeMap, that supports two operations.
+
+1. set(string key, string value, int timestamp)
+
+Stores the key and value, along with the given timestamp.
+2. get(string key, int timestamp)
+
+Returns a value such that set(key, value, timestamp_prev) was called previously, with timestamp_prev <= timestamp.
+If there are multiple such values, it returns the one with the largest timestamp_prev.
+If there are no values, it returns the empty string ("").
+'''
+
+import bisect
+class TimeMap(object):
+
+    def __init__(self):
+        """
+        Initialize your data structure here.
+        """
+        self.time_dict = {}
+        self.key_map = {}
+        
+
+    def set(self, key, value, timestamp):
+        """
+        :type key: str
+        :type value: str
+        :type timestamp: int
+        :rtype: None
+        """
+        if key in self.time_dict:
+            self.time_dict[key].append(timestamp)
+            self.key_map[key].append(value)
+        else:
+            self.time_dict[key] = [timestamp]
+            self.key_map[key] = [value]
+        
+        
+        
+
+    def get(self, key, timestamp):
+        """
+        :type key: str
+        :type timestamp: int
+        :rtype: str
+        """
+        if key in self.time_dict:
+            t_values = self.time_dict[key]
+            index = bisect.bisect_right(t_values, timestamp)
+            if index-1 == len(t_values) or index == 0:
+                return ''
+
+            return self.key_map[key][index-1]
+        
+
+
+# Your TimeMap object will be instantiated and called as such:
+# obj = TimeMap()
+# obj.set(key,value,timestamp)
+# param_2 = obj.get(key,timestamp)

900-1000q/983.py

@@ -0,0 +1,30 @@
+'''
+In a country popular for train travel, you have planned some train travelling one year in advance.  The days of the year that you will travel is given as an array days.  Each day is an integer from 1 to 365.
+
+Train tickets are sold in 3 different ways:
+
+a 1-day pass is sold for costs[0] dollars;
+a 7-day pass is sold for costs[1] dollars;
+a 30-day pass is sold for costs[2] dollars.
+The passes allow that many days of consecutive travel.  For example, if we get a 7-day pass on day 2, then we can travel for 7 days: day 2, 3, 4, 5, 6, 7, and 8.
+
+Return the minimum number of dollars you need to travel every day in the given list of days.
+
+ 
+
+Example 1:
+
+Input: days = [1,4,6,7,8,20], costs = [2,7,15]
+Output: 11
+'''
+
+class Solution:
+    def mincostTickets(self, days: 'List[int]', costs: 'List[int]') -> 'int':
+        def get_days_ago(day, ago):
+            for i in range(len(days)):
+                if days[i] > days[day-1] - ago:
+                    return i
+        out = [0] * (len(days) + 1)
+        for i in range(1, len(days) + 1):
+            out[i] = min(out[i-1] + costs[0], out[get_days_ago(i,7)] + costs[1], out[get_days_ago(i,30)] + costs[2])
+        return out[-1]

900-1000q/984.py

@@ -0,0 +1,62 @@
+'''
+Given two integers A and B, return any string S such that:
+
+S has length A + B and contains exactly A 'a' letters, and exactly B 'b' letters;
+The substring 'aaa' does not occur in S;
+The substring 'bbb' does not occur in S.
+ 
+
+Example 1:
+
+Input: A = 1, B = 2
+Output: "abb"
+Explanation: "abb", "bab" and "bba" are all correct answers.
+'''
+
+class Solution(object):
+    def strWithout3a3b(self, A, B):
+        """
+        :type A: int
+        :type B: int
+        :rtype: str
+        """
+        
+        result = ''
+        if A > B:
+            while B > 0 and A > 0:
+                if A-B >= 3:
+                    if A > 1:
+                        result += 'aab'
+                        A -= 2
+                    else:
+                        result += 'ab'
+                        A -= 1
+                    B -= 1
+                else:
+                    result += 'ab'
+                    A -= 1
+                    B -= 1
+            if A > 0:
+                result += 'a'*A
+            if B > 0:
+                result += 'b'*B
+        else:
+            while B > 0 and A > 0:
+                if B-A >= 3:
+                    if B > 1:
+                        result += 'bba'
+                        B -= 2
+                    else:
+                        result += 'ba'
+                        B -= 1
+                    A -= 1
+                else:
+                    result += 'ba'
+                    A -= 1
+                    B -= 1
+            if A > 0:
+                result += 'a'*A
+            if B > 0:
+                result += 'b'*B
+                
+        return result

900-1000q/985.py

@@ -0,0 +1,42 @@
+'''
+We have an array A of integers, and an array queries of queries.
+
+For the i-th query val = queries[i][0], index = queries[i][1], we add val to A[index].  Then, the answer to the i-th query is the sum of the even values of A.
+
+(Here, the given index = queries[i][1] is a 0-based index, and each query permanently modifies the array A.)
+
+Return the answer to all queries.  Your answer array should have answer[i] as the answer to the i-th query.
+
+ 
+
+Example 1:
+
+Input: A = [1,2,3,4], queries = [[1,0],[-3,1],[-4,0],[2,3]]
+Output: [8,6,2,4]
+'''
+
+class Solution(object):
+    def sumEvenAfterQueries(self, A, queries):
+        """
+        :type A: List[int]
+        :type queries: List[List[int]]
+        :rtype: List[int]
+        """
+        result = 0
+        for val in A:
+            if val%2 == 0:
+                result += val
+        
+        f_result = []
+        for val_index in queries:
+            val, index = val_index[0], val_index[1]
+            prev_val = A[index]
+            if prev_val%2 == 0:
+                result -= prev_val
+            new_val = prev_val + val
+            if new_val %2 == 0:
+                result += new_val
+            A[index] = new_val
+            f_result.append(result)
+        return f_result
+ 

900-1000q/988.py

@@ -0,0 +1,31 @@
+'''
+Given the root of a binary tree, each node has a value from 0 to 25 representing the letters 'a' to 'z': a value of 0 represents 'a', a value of 1 represents 'b', and so on.
+
+Find the lexicographically smallest string that starts at a leaf of this tree and ends at the root.
+'''
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def smallestFromLeaf(self, root):
+        """
+        :type root: TreeNode
+        :rtype: str
+        """
+        self.result = "~"
+        
+        def dfs(node, A):
+            if node:
+                A.append(chr(node.val + ord('a')))
+                if not node.left and not node.right:
+                    self.result = min(self.result, "".join(reversed(A)))
+
+                dfs(node.left, A)
+                dfs(node.right, A)
+                A.pop()
+        dfs(root, [])
+        return self.result

900-1000q/989.py

@@ -0,0 +1,53 @@
+'''
+For a non-negative integer X, the array-form of X is an array of its digits in left to right order.  For example, if X = 1231, then the array form is [1,2,3,1].
+
+Given the array-form A of a non-negative integer X, return the array-form of the integer X+K.
+
+ 
+
+Example 1:
+
+Input: A = [1,2,0,0], K = 34
+Output: [1,2,3,4]
+Explanation: 1200 + 34 = 1234
+'''
+
+class Solution(object):
+    def addToArrayForm(self, A, K):
+        """
+        :type A: List[int]
+        :type K: int
+        :rtype: List[int]
+        """
+        arr_k = []
+        while K >0:
+            digit = K%10
+            K /= 10
+            arr_k.append(digit)
+            
+        arr_k.reverse()
+        if len(arr_k) > len(A):
+            A, arr_k = arr_k, A
+        
+        sum_arr = [0]*len(A)
+        i, j = len(A)-1, len(arr_k)-1
+        k = len(A) -1
+        digit_sum, carry = 0, 0
+        while j >= 0:
+            curr_sum = A[i] + arr_k[j] + carry
+            sum_arr[k] = (curr_sum%10)
+            carry = curr_sum//10
+            i -= 1
+            k -= 1
+            j -= 1
+        
+        while i >= 0:
+            curr_sum = A[i] + carry
+            sum_arr[k] = (curr_sum%10)
+            carry =curr_sum//10
+            i -= 1
+            k -= 1
+            
+        if carry:
+            sum_arr = [carry] + sum_arr
+        return sum_arr        

900-1000q/990.py

@@ -0,0 +1,46 @@
+'''
+Given an array equations of strings that represent relationships between variables, each string equations[i] has length 4 and takes one of two different forms: "a==b" or "a!=b".  Here, a and b are lowercase letters (not necessarily different) that represent one-letter variable names.
+
+Return true if and only if it is possible to assign integers to variable names so as to satisfy all the given equations.
+
+ 
+
+Example 1:
+
+Input: ["a==b","b!=a"]
+Output: false
+Explanation: If we assign say, a = 1 and b = 1, then the first equation is satisfied, but not the second.  There is no way to assign the variables to satisfy both equations.
+'''
+
+class Solution(object):
+    def equationsPossible(self, equations):
+        """
+        :type equations: List[str]
+        :rtype: bool
+        """
+        equal_list, unequal_list = [], []
+        for equation in equations:
+            x, y = equation[0], equation[3]
+            if '==' in equation:
+                if not equal_list:
+                    equal_list.append(x+y)
+                else:
+                    found = False
+                    for index in range(0, len(equal_list)):
+                        val = equal_list[index]
+                        if x in val or y in val:
+                            val = val+x+y
+                            equal_list[index] = val
+                            found = True
+                    if not found:
+                        equal_list.append(x+y)
+            else:
+                if x == y:
+                    return False
+                unequal_list.append([x, y])
+        
+        for val in unequal_list:
+            for equal in equal_list:
+                if val[0] in equal and val[1] in equal:
+                    return False
+        return True