Adding solution of 30, 44, 45, 46, 48, 54, 56, 57, 60 id problems

Author: Garvit244

30.py

@@ -0,0 +1,64 @@
+'''
+	You are given a string, s, and a list of words, words, that are all of the same length. Find all starting indices of substring(s) in s that is a concatenation of each word in words exactly once and without any intervening characters.
+
+	Example 1:
+
+	Input:
+	  s = "barfoothefoobarman",
+	  words = ["foo","bar"]
+	Output: [0,9]
+	Explanation: Substrings starting at index 0 and 9 are "barfoor" and "foobar" respectively.
+	The output order does not matter, returning [9,0] is fine too.
+	Example 2:
+
+	Input:
+	  s = "wordgoodstudentgoodword",
+	  words = ["word","student"]
+	Output: []
+'''
+
+class Solution(object):
+    def findSubstring(self, s, words):
+        """
+        :type s: str
+        :type words: List[str]
+        :rtype: List[int]
+        """
+        if not str or not words:
+        	return []
+
+        counts = {}
+        for word in words:
+        	if word in counts:
+        		counts[word] += 1
+        	else:
+        		counts[word] = 1
+
+        result = []
+        n, numOfWords, fixLen = len(s), len(words),len(words[0])
+
+        for index in range(0, n-numOfWords*fixLen+1):
+        	seen = {}
+
+        	index_j = 0
+        	while index_j < numOfWords:
+        		word = s[index + index_j*fixLen: index + (index_j+1)*fixLen]
+        		if word in counts:
+        			if word in seen:
+        				seen[word] += 1
+        			else:
+        				seen[word] = 1
+
+        			if seen[word] > counts[word]:
+        				break
+        		else:
+        			break
+        		index_j += 1
+
+        	if index_j == numOfWords:
+        		result.append(index)
+
+    	return 
+
+# Time: O(N^2)
+# Space: O(N)

44.py

@@ -0,0 +1,40 @@
+'''
+	Given an input string (s) and a pattern (p), implement wildcard pattern matching with support for '?' and '*'.
+
+	'?' Matches any single character.
+	'*' Matches any sequence of characters (including the empty sequence).
+	The matching should cover the entire input string (not partial).
+
+	Note:
+
+	s could be empty and contains only lowercase letters a-z.
+	p could be empty and contains only lowercase letters a-z, and characters like ? or *.
+'''
+
+class Solution(object):
+    def isMatch(self, s, p):
+        """
+        :type s: str
+        :type p: str
+        :rtype: bool
+        """
+        
+        if len(p) == 0:
+        	return len(s) == 0
+
+        dp = [[False for _ in range(len(p) + 1)] for _ in range(len(s) + 1)]
+        dp[0][0] = True
+
+        for index in range(1,len(dp[0])):
+            if p[index-1] == '*':
+                dp[0][index] = dp[0][index-1]
+
+        for index_i in range(1, len(dp)):
+        	for index_j in range(1, len(dp[0])):
+        		if s[index_i - 1] == p[index_j - 1] or p[index_j - 1] == '?':
+        			dp[index_i][index_j] = dp[index_i-1][index_j-1]
+        		elif p[index_j-1] == '*':
+        			dp[index_i][index_j] = dp[index_i][index_j-1] or dp[index_i-1][index_j]
+        		else:
+        			dp[index_i][index_j] = False
+        return dp[len(s)][len(p)]

45.py

@@ -0,0 +1,31 @@
+'''
+	Given an array of non-negative integers, you are initially positioned at the first index of the array.
+
+	Each element in the array represents your maximum jump length at that position.
+
+	Your goal is to reach the last index in the minimum number of jumps.
+
+	Example:
+
+	Input: [2,3,1,1,4]
+	Output: 2
+	Explanation: The minimum number of jumps to reach the last index is 2.
+	    Jump 1 step from index 0 to 1, then 3 steps to the last index.
+
+
+ '''
+class Solution(object):
+    def jump(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        steps, lastRearch, maxReach = 0, 0 ,0
+
+        for index in range(len(nums)):
+        	if index > lastRearch:
+        		lastRearch = maxReach
+        		steps += 1
+        	maxReach = max(maxReach, index + nums[index])
+
+       	return steps if maxReach == len(nums) - 1 else 0

46.py

@@ -0,0 +1,18 @@
+class Solution(object):
+    def permute(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: List[List[int]]
+        """
+        
+        if len(nums) == 0:
+        	return []
+        if len(nums) == 1:
+        	return [nums]
+
+        result = []
+        for index in range(len(nums)):
+        	for p in self.permute(nums[0:index] + nums[index+1:]):
+        		result.append([nums[index]] + p)
+
+        return result

48.py

@@ -0,0 +1,24 @@
+'''
+	You are given an n x n 2D matrix representing an image.
+
+	Rotate the image by 90 degrees (clockwise).
+'''
+class Solution(object):
+    def rotate(self, matrix):
+        """
+        :type matrix: List[List[int]]
+        :rtype: void Do not return anything, modify matrix in-place instead.
+        """
+        n = len(matrix)
+        if n%2 == 0:
+        	m = n/2
+        else:
+        	m = n/2 + 1
+
+        for i in range(n/2):
+        	for j in range(m):
+        		temp = matrix[i][j]
+        		matrix[i][j] = matrix[n-j-1][i]
+        		matrix[n-j-1][i] = matrix[n-i-1][n-j-1]
+        		matrix[n-i-1][n-j-1] = matrix[j][n-i-1]
+        		matrix[j][n-i-1] = temp

54.py

@@ -0,0 +1,43 @@
+'''
+	Given a matrix of m x n elements (m rows, n columns), return all elements of the matrix in spiral order.
+
+	Example 1:
+
+	Input:
+	[
+	 [ 1, 2, 3 ],
+	 [ 4, 5, 6 ],
+	 [ 7, 8, 9 ]
+	]
+	Output: [1,2,3,6,9,8,7,4,5]
+'''
+
+class Solution(object):
+    def spiralOrder(self, matrix):
+        """
+        :type matrix: List[List[int]]
+        :rtype: List[int]
+        """
+        if not matrix:
+        	return []
+
+        R, C = len(matrix), len(matrix[0])
+        dr = [0, 1, 0, -1]
+        dc = [1, 0, -1, 0]
+
+        result = []
+        seen = [[False]*C for _ in range(R)]
+        row = 0
+        col = 0
+        di = 0
+        for _ in range(R*C):
+        	result.append(matrix[row][col])
+        	seen[row][col] = True
+        	rr, cc = row + dr[di], col + dc[di]
+        	if 0 <= rr < R and 0 <= cc < C and not seen[rr][cc]:
+        		row, col = rr, cc
+        	else:
+        		di = (di+1)%4
+        		row, col = row + dr[di], col + dc[di]
+
+        return result

56.py

@@ -0,0 +1,49 @@
+'''
+	Given a collection of intervals, merge all overlapping intervals.
+
+	Example 1:
+
+	Input: [[1,3],[2,6],[8,10],[15,18]]
+	Output: [[1,6],[8,10],[15,18]]
+	Explanation: Since intervals [1,3] and [2,6] overlaps, merge them into [1,6].
+	Example 2:
+
+	Input: [[1,4],[4,5]]
+	Output: [[1,5]]
+	Explanation: Intervals [1,4] and [4,5] are considerred overlapping.
+'''
+
+# Definition for an interval.
+# class Interval(object):
+#     def __init__(self, s=0, e=0):
+#         self.start = s
+#         self.end = e
+
+class compare(object):
+	def __init__(self, interval):
+		self.interval = interval
+
+	def __lt__(self, other):
+		if self.interval.start == other.interval.start:
+			return self.interval.end < other.interval.end
+		return self.interval.start < other.interval.end
+
+class Solution(object):
+    def merge(self, intervals):
+        """
+        :type intervals: List[Interval]
+        :rtype: List[Interval]
+        """
+        
+        intervals = sorted(intervals, key= compare)
+        # intervals.sort(key=lambda x: x.start)
+        merged = []
+        for interval in intervals:
+        	if not merged or merged[-1].end < interval.start:
+        		merged.append(interval)
+        	else:
+        		merged[-1].end = max(merged[-1].end, interval.end)
+        return merged
+
+# Time: O(N*log(N))
+# Space: O(1)

57.py

@@ -0,0 +1,41 @@
+'''
+	Given a set of non-overlapping intervals, insert a new interval into the intervals (merge if necessary).
+
+	You may assume that the intervals were initially sorted according to their start times.
+
+	Example 1:
+
+	Input: intervals = [[1,3],[6,9]], newInterval = [2,5]
+	Output: [[1,5],[6,9]]
+	Example 2:
+
+	Input: intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
+	Output: [[1,2],[3,10],[12,16]]
+	Explanation: Because the new interval [4,8] overlaps with [3,5],[6,7],[8,10].
+'''
+
+# Definition for an interval.
+# class Interval(object):
+#     def __init__(self, s=0, e=0):
+#         self.start = s
+#         self.end = e
+
+class Solution(object):
+    def insert(self, intervals, newInterval):
+        """
+        :type intervals: List[Interval]
+        :type newInterval: Interval
+        :rtype: List[Interval]
+        """
+        result = []
+        for interval in intervals:
+        	if newInterval.start > interval.end:
+        		result.append(interval)
+        	elif newInterval.end < interval.start:
+        		result.append(newInterval)
+        		newInterval = interval
+        	elif newInterval.start <= interval.end or newInterval.end >= interval.start:
+        		newInterval = Interval(min(newInterval.start, interval.start), max(interval.end, newInterval.end))
+
+        result.append(newInterval)
+       	return result

60.py

@@ -0,0 +1,30 @@
+class Solution(object):
+    def getPermutation(self, n, k):
+        """
+        :type n: int
+        :type k: int
+        :rtype: str
+        """
+        
+        nums = []
+        for index in range(1, n+1):
+        	nums.append(index)
+
+        def permute(nums):
+        	if len(nums) == 0:
+        		return []
+        	if len(nums) == 1:
+        		return [nums]
+
+        	result = []
+        	for index in range(len(nums)):
+        		for p in permute(nums[0:index] + nums[index+1:]):
+        			result.append([nums[index]] + p)
+
+        	return result
+
+        value = permute(nums)[k-1]
+        result = ""
+        for val in value:
+        	result += str(val)
+        return result