Solution of some problems

Author: Garvit244

1-100q/14.py

@@ -0,0 +1,50 @@
+'''
+Write a function to find the longest common prefix string amongst an array of strings.
+
+If there is no common prefix, return an empty string "".
+
+Example 1:
+
+Input: ["flower","flow","flight"]
+Output: "fl"
+Example 2:
+
+Input: ["dog","racecar","car"]
+Output: ""
+Explanation: There is no common prefix among the input strings.
+Note:
+
+All given inputs are in lowercase letters a-z.
+'''
+
+class Solution(object):
+    def longestCommonPrefix(self, strs):
+        """
+        :type strs: List[str]
+        :rtype: str
+        """
+        def prefix(strs, index):
+            check_prefix = strs[0][:index]
+            for index in range(1, len(strs)):
+                if not strs[index].startswith(check_prefix):
+                    return False
+            return True
+                
+                    
+        if not strs:
+            return ""
+        
+        minLength = float('inf')
+        for string in strs:
+            minLength = min(minLength, len(string))
+            
+        low, high = 0, minLength
+        
+        while low <= high:
+            mid = (low+high)/2
+            if (prefix(strs, mid)):
+                low = mid + 1
+            else:
+                high = mid - 1
+        
+        return strs[0][:(low+high)/2]

600-700q/673.py

@@ -0,0 +1,32 @@
+'''
+Given an unsorted array of integers, find the number of longest increasing subsequence.
+
+Example 1:
+Input: [1,3,5,4,7]
+Output: 2
+Explanation: The two longest increasing subsequence are [1, 3, 4, 7] and [1, 3, 5, 7].
+
+Example 2:
+Input: [2,2,2,2,2]
+Output: 5
+Explanation: The length of longest continuous increasing subsequence is 1, and there are 5 subsequences' length is 1, so output 5.
+Note: Length of the given array will be not exceed 2000 and the answer is guaranteed to be fit in 32-bit signed int.
+'''
+
+class Solution(object):
+    def findNumberOfLIS(self, nums):
+        length = [1]*len(nums)
+        count = [1]*len(nums)
+        result = 0
+        for end, num in enumerate(nums):
+            for start in range(end):
+                if num > nums[start]:
+                    if length[start] >= length[end]:
+                        length[end] = 1+length[start]
+                        count[end] = count[start]
+                    elif length[start] + 1 == length[end]:
+                        count[end] += count[start]
+        for index, max_subs in enumerate(count):
+            if length[index] == max(length):
+                result += max_subs
+        return result

600-700q/674.py

@@ -0,0 +1,31 @@
+'''
+Given an unsorted array of integers, find the length of longest continuous increasing subsequence (subarray).
+
+Example 1:
+Input: [1,3,5,4,7]
+Output: 3
+Explanation: The longest continuous increasing subsequence is [1,3,5], its length is 3. 
+Even though [1,3,5,7] is also an increasing subsequence, it's not a continuous one where 5 and 7 are separated by 4. 
+
+Example 2:
+Input: [2,2,2,2,2]
+Output: 1
+
+Explanation: The longest continuous increasing subsequence is [2], its length is 1. 
+Note: Length of the array will not exceed 10,000.
+'''
+
+class Solution(object):
+    def findLengthOfLCIS(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        if not nums:
+            return 0
+        start, result = 0, 1
+        for end in range(1, len(nums)):
+            if nums[end-1] >= nums[end]:
+                start = end
+            result = max(result, end-start+1)
+        return result

900-1000q/926.py

@@ -0,0 +1,47 @@
+'''
+A string of '0's and '1's is monotone increasing if it consists of some number of '0's (possibly 0), followed by some number of '1's (also possibly 0.)
+
+We are given a string S of '0's and '1's, and we may flip any '0' to a '1' or a '1' to a '0'.
+
+Return the minimum number of flips to make S monotone increasing.
+
+ 
+
+Example 1:
+
+Input: "00110"
+Output: 1
+Explanation: We flip the last digit to get 00111.
+Example 2:
+
+Input: "010110"
+Output: 2
+Explanation: We flip to get 011111, or alternatively 000111.
+Example 3:
+
+Input: "00011000"
+Output: 2
+Explanation: We flip to get 00000000.
+ 
+
+Note:
+
+1 <= S.length <= 20000
+S only consists of '0' and '1' characters.
+'''
+
+class Solution(object):
+    def minFlipsMonoIncr(self, S):
+        """
+        :type S: str
+        :rtype: int
+        """
+        ones = [0]
+        for char in S:
+            ones.append(ones[-1] + int(char))
+        # print ones
+        result = float('inf')
+        for index in range(len(ones)):
+            zeroes = len(S) - index - (ones[-1]-ones[index])
+            result = min(zeroes+ones[index], result)
+        return result

README.md

@@ -61,7 +61,13 @@ Python solution of problems from [LeetCode](https://leetcode.com/).
 |983|[Minimum Cost For Tickets](https://leetcode.com/problems/minimum-cost-for-tickets/) | [Python](./900-1000q/983.py)|Medium|
 |981|[Time Based Key-Value Store](https://leetcode.com/problems/time-based-key-value-store/) | [Python](./900-1000q/981.py)|Medium|
 |977|[Squares of a Sorted Array](https://leetcode.com/problems/squares-of-a-sorted-array/) | [Python](./900-1000q/977.py)|Easy|
+|926|[Flip String to Monotone Increasing](https://leetcode.com/problems/flip-string-to-monotone-increasing)|[Python](./900-1000q/926.py)|Medium|
 
+##### [Problems 600-700](./600-700q/)
+| # | Title | Solution | Difficulty |
+|---| ----- | -------- | ---------- |
+|673|[Number of Longest Increasing Subsequence](https://leetcode.com/problems/number-of-longest-increasing-subsequence)|[Python](./600-700q/673.py)|Medium|
+|674|[Longest Continuous Increasing Subsequence](https://leetcode.com/problems/longest-continuous-increasing-subsequence)|[Python](./600-700/674.py)|Easy|
 
 ##### [Problems 400-500](./400-500q/)
 | # | Title | Solution | Difficulty |
@@ -231,6 +237,7 @@ Python solution of problems from [LeetCode](https://leetcode.com/).
 |17|[Letter Combinations of a Phone Number](https://leetcode.com/problems/letter-combinations-of-a-phone-number/)| [Python](./1-100q/17.py)|Medium|
 |16|[3Sum Closest](https://leetcode.com/problems/3sum-closest/)| [Python](./1-100q/16.py)|Medium|
 |15|[3Sum](https://leetcode.com/problems/3sum/)| [Python](./1-100q/15.py)|Medium|
+|14|[Longest Common Prefix](https://leetcode.com/problems/longest-common-prefix)|[Python](./1-100q/14.py)|Easy|
 |11|[Container With Most Water](https://leetcode.com/problems/container-with-most-water/)| [Python](./1-100q/11.py)|Medium|
 |10|[Regular Expression Matching](https://leetcode.com/problems/regular-expression-matching/)| [Python](./1-100q/10.py)|Hard|
 |6|[ZigZag Conversion](https://leetcode.com/problems/zigzag-conversion/)| [Python](./1-100q/06.py)|Easy|