Merge pull request #249 from gitarthasarma/master

Added solutions to leetcode problems under arrays

Author: larissalages

leetcode/python/arrays/best_time_to_buy_sell_stock.py

@@ -0,0 +1,18 @@
+class Solution(object):
+    def maxProfit(self, prices):
+        """
+        :type prices: List[int]
+        :rtype: int
+        """
+        #preprocessing
+        minprice = 10000000000
+        maxprofit = 0
+        for i in range(len(prices)):
+            if prices[i] < minprice:
+                minprice = prices[i]
+            elif (prices[i] - minprice > maxprofit):
+                maxprofit = prices[i] - minprice
+        return maxprofit
+        
+            
+        

leetcode/python/arrays/container_with_most_water.py

@@ -0,0 +1,23 @@
+class Solution(object):
+    @staticmethod
+    def area(i,j,h1,h2):
+        return (j-i)*min(h1,h2)
+    def maxArea(self, height):
+        """
+        :type height: List[int]
+        :rtype: int
+        """
+        n= len(height)
+        i=0
+        j=n-1
+        res= 0
+        while (i<j):
+            res= max(res,Solution.area(i,j,height[i],height[j]))
+            #pointer calculation and movement
+            
+            if (height[i]<height[j]):
+                i+=1
+            else:
+                j-=1
+        return res
+        

leetcode/python/arrays/first_last_position_sorted_array.py

@@ -0,0 +1,49 @@
+class Solution(object):
+    def searchRange(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: List[int]
+        """
+        res= [-1]*2
+        lo= 0
+        n= len(nums)
+        hi= n-1
+        if (n==0):
+            return res
+        while (lo<hi):
+            mid= lo + (hi-lo)//2
+            if (nums[mid]>= target):
+                hi= mid
+            else:
+                lo= mid+1
+        
+        
+        if (nums[lo]!=target):
+            return res
+        res[0]= lo #found lower bound
+        
+        
+        lo= 0
+        hi= n-1
+        
+        while (lo<hi):
+            mid= lo +(hi-lo+1)//2
+            
+            if (nums[mid]> target):
+                hi= mid-1
+            else:
+                lo= mid
+        
+        res[1]= lo#upper bound
+        return res
+        
+        
+        
+"""
+Time complexity: O(log(n))
+Space complexity: O(1), constant space
+
+Find more details of the framework used here: https://www.topcoder.com/community/competitive-programming/tutorials/binary-search/
+
+"""

leetcode/python/arrays/product_array_except_self.py

@@ -0,0 +1,31 @@
+class Solution(object):
+    def productExceptSelf(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: List[int]
+        """
+        n= len(nums)  
+        prodSoFar= 1    #running product
+        output = [nums[n-1]]*n
+        
+        #preprocessing the array
+        for i in range(n-2,-1,-1):
+            output[i]= output[i+1]*nums[i]
+        
+
+        for i in range(n-1):
+            output[i]= prodSoFar*output[i+1]
+            prodSoFar*= nums[i]
+        
+        output[n-1]= prodSoFar
+        
+        return output
+    
+    
+
+'''
+
+Time complexity of the above algorith: O(n), n is the length of the input array
+
+Space complexity: O(1), constant space
+'''

leetcode/python/arrays/search_in_rotated_sorted_array.py

@@ -0,0 +1,60 @@
+class Solution(object):
+    @staticmethod
+    def searchHelper(nums,lo,hi,target):
+        while lo<=hi:
+            mid= lo + (hi-lo)/2
+            if nums[mid]==target:
+                return mid
+            elif nums[mid]>target:
+                hi= mid-1
+            else:
+                lo= mid+1
+        return -1
+
+    def search(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: int
+        """
+        n= len(nums)
+        lo= 0
+        hi= n-1
+        if n==0:
+            return -1
+        
+        while (lo<hi):
+            mid= lo+ (hi-lo)/2
+            if (nums[mid]<nums[0]):
+                hi= mid
+            else:
+                lo= mid+1
+        minm= lo
+        #lo is the index of the minimum element
+
+        #now we have 2 sorted(ascending) subarrays, thus do a binary search on each of them
+        
+        if (nums[lo]==target):
+            return lo
+        
+        else:
+            #simple binary search on nums[0:lo-1]
+            resIdx= Solution.searchHelper(nums, 0, minm-1, target)
+            if (resIdx!=-1):
+                return resIdx
+            #not found in the first part
+            resIdx= Solution.searchHelper(nums, minm, n-1, target)
+
+            #binary search on nums[lo+1,n-1] second part
+            
+        
+        return resIdx#target not found anywhere
+    
+    
+'''
+    Time complexity of the algorithm(asymptotically): 
+                            O(log(n)), where n is the size of the input array
+    Space complexity is constant, O(1)
+Find more details of the framework used here: https://www.topcoder.com/community/competitive-programming/tutorials/binary-search/
+
+'''