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)