Adding solutions of 86, 87, 90, 91 problems

Author: Garvit244

86.py

@@ -0,0 +1,48 @@
+'''
+	Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.
+
+	You should preserve the original relative order of the nodes in each of the two partitions.
+
+	Example:
+
+	Input: head = 1->4->3->2->5->2, x = 3
+	Output: 1->2->2->4->3->5
+'''
+
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def partition(self, head, x):
+        """
+        :type head: ListNode
+        :type x: int
+        :rtype: ListNode
+        """
+        if not head or not head.next:
+        	return head
+
+        left, right = ListNode(0), ListNode(0)
+        leftPtr, rightPtr = left, right
+
+        while head:
+        	if head.val < x:
+        		leftPtr.next = ListNode(head.val)
+        		leftPtr = leftPtr.next
+        	else:
+        		rightPtr.next = ListNode(head.val)
+        		rightPtr = rightPtr.next
+        	head = head.next
+
+        if not left.next:
+        	return right.next
+        elif not right.next:
+        	return left.next
+        else:
+        	leftPtr.next = right.next
+        	return left.next
+# Time: O(N)
+# Space: O(N)

87.py

@@ -0,0 +1,50 @@
+'''
+	Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively.
+
+	Below is one possible representation of s1 = "great":
+
+	    great
+	   /    \
+	  gr    eat
+	 / \    /  \
+	g   r  e   at
+	           / \
+	          a   t
+
+	To scramble the string, we may choose any non-leaf node and swap its two children.
+
+	For example, if we choose the node "gr" and swap its two children, it produces a scrambled string "rgeat".
+
+	    rgeat
+	   /    \
+	  rg    eat
+	 / \    /  \
+	r   g  e   at
+	           / \
+	          a   t
+
+	We say that "rgeat" is a scrambled string of "great".
+'''
+
+class Solution(object):
+	def __init__(self):
+		self.cache = {}
+
+	def isScramble(self, s1, s2):
+		if s1 == s2:
+			return True
+		if s1+s2 in self.cache:
+			return self.cache[s1+s2]
+		if len(s1) != len(s2) or sorted(s1) != sorted(s2):
+			self.cache[s1+s2] = False
+			return False
+		for index in range(1, len(s1)):
+			if self.isScramble(s1[:index], s2[:index]) and self.isScramble(s1[index:], s2[index:]):
+				self.cache[s1+s2] =True
+				return True
+			if self.isScramble(s1[:index], s2[-index:]) and self.isScramble(s1[index:], s2[0:-index]):
+				self.cache[s1+s2] = True
+				return True
+
+		self.cache[s1+s2] =False
+		return False  		

90.py

@@ -0,0 +1,33 @@
+'''
+	Given a collection of integers that might contain duplicates, nums, return all possible subsets (the power set).
+
+		Note: The solution set must not contain duplicate subsets.
+
+		Example:
+
+		Input: [1,2,2]
+		Output:
+		[
+		  [2],
+		  [1],
+		  [1,2,2],
+		  [2,2],
+		  [1,2],
+		  []
+		]
+'''
+
+class Solution(object):
+    def subsetsWithDup(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: List[List[int]]
+        """   
+        result = [[]]
+        for num in nums:
+        	for index in range(len(result)):
+        		new_list = result[index] + [num]
+        		new_list.sort()
+        		result.append(new_list)
+        unique = set(tuple(val) for val in result)
+        return list(list(val) for val in unique)

91.py

@@ -0,0 +1,59 @@
+'''
+	A message containing letters from A-Z is being encoded to numbers using the following mapping:
+
+	'A' -> 1
+	'B' -> 2
+	...
+	'Z' -> 26
+
+	Given a non-empty string containing only digits, determine the total number of ways to decode it.
+
+	Example 1:
+
+	Input: "12"
+	Output: 2
+	Explanation: It could be decoded as "AB" (1 2) or "L" (12).
+
+	Example 2:
+
+	Input: "226"
+	Output: 3
+	Explanation: It could be decoded as "BZ" (2 26), "VF" (22 6), or "BBF" (2 2 6).
+'''
+
+class Solution(object):
+    def numDecodings(self, s):
+        """
+        :type s: str
+        :rtype: int
+        """
+        if not s or s[0] == '0':
+        	return 0
+        if len(s) == 1:
+        	return 1
+
+        dp = [0]*len(s)
+        dp[0] = 1
+
+        if int(s[:2]) > 26:
+        	if s[1] != '0':
+        		dp[1] = 1
+        	else:
+        		dp[0] = 0
+        else:
+        	if s[1] != '0':
+        		dp[1] = 2
+        	else:
+        		dp[1] = 1
+
+        for index in range(2, len(s)):
+        	if s[index] != '0':
+        		dp[index] += dp[index-1]
+
+        	val = int(s[index-1:index+1])
+        	if val >= 10 and val <= 26:
+        		dp[index] += dp[index-2]
+        return dp[len(s)-1]
+
+# Time: O(N)
+# Space: O(N)