Adding colution of 75, 78, 79, 80, 82, 83 problems

Author: Garvit244

75.py

@@ -0,0 +1,30 @@
+'''
+	Given an array with n objects colored red, white or blue, sort them in-place so that objects of the same color are adjacent, with the colors in the order red, white and blue.
+
+	Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.
+
+	Note: You are not suppose to use the library's sort function for this problem.
+
+	Example:
+
+	Input: [2,0,2,1,1,0]
+	Output: [0,0,1,1,2,2]
+'''
+class Solution(object):
+    def sortColors(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: void Do not return anything, modify nums in-place instead.
+        """
+        zero, last = 0, len(nums)-1
+        index = 0
+        while  index <= last:
+        	if nums[index] == 1:
+        		index += 1
+        	elif nums[index] == 0:
+        		nums[index], nums[zero] = nums[zero], nums[index]
+        		index += 1
+        		zero += 1
+        	elif nums[index] == 2:
+        		nums[last], nums[index] = nums[index], nums[last]
+        		last -= 1

78.py

@@ -0,0 +1,15 @@
+'''
+Given a set of distinct integers, nums, return all possible subsets (the power set).
+'''
+
+class Solution(object):
+    def subsets(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: List[List[int]]
+        """
+        result = [[]]
+        for num in nums:
+        	for j in range(len(result)):
+        		result.append(result[j] + [num])
+        return result

79.py

@@ -0,0 +1,48 @@
+'''
+	Given a 2D board and a word, find if the word exists in the grid.
+
+	The word can be constructed from letters of sequentially adjacent cell, where "adjacent" cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once.
+
+	Example:
+
+	board =
+	[
+	  ['A','B','C','E'],
+	  ['S','F','C','S'],
+	  ['A','D','E','E']
+	]
+
+	Given word = "ABCCED", return true.
+	Given word = "SEE", return true.
+	Given word = "ABCB", return false.
+'''
+
+class Solution(object):
+    def exist(self, board, word):
+        """
+        :type board: List[List[str]]
+        :type word: str
+        :rtype: bool
+        """
+
+        result = False
+        for row in range(len(board)):
+        	for col in range(len(board[0])):
+        		if self.dfs(board, word, row, col, 0):
+        			return True
+        return False
+
+    def dfs(self, board, word, row, col, curr_len):
+    	if row < 0 or col < 0 or row >= len(board) or col >= len(board[0]):
+    		return False
+    	if board[row][col] == word[curr_len]:
+    		c = board[row][col]
+    		board[row][col] = '#'
+
+    		if curr_len == len(word) - 1:
+    			return True
+    		elif (self.dfs(board, word, row-1, col, curr_len+1) or self.dfs(board, word, row+1, col, curr_len+1) or self.dfs(board, word, row, col-1, curr_len+1) or self.dfs(board, word, row, col+1, curr_len+1)):
+    			return True
+
+    		board[row][col] = c
+    	return False

80.py

@@ -0,0 +1,33 @@
+'''
+	Given a sorted array nums, remove the duplicates in-place such that duplicates appeared at most twice and return the new length.
+
+	Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.
+
+	Example 1:
+
+	Given nums = [1,1,1,2,2,3],
+
+	Your function should return length = 5, with the first five elements of nums being 1, 1, 2, 2 and 3 respectively.
+
+	It doesn't matter what you leave beyond the returned length.
+'''
+
+class Solution(object):
+    def removeDuplicates(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        if len(nums) <= 2:
+        	return len(nums)
+
+        prev, curr = 1, 2
+
+        while curr < len(nums):
+        	if nums[prev] == nums[curr] and nums[curr] == nums[prev-1]:
+        		curr += 1
+        	else:
+        		prev += 1
+        		nums[prev] = nums[curr]
+        		curr += 1
+        return prev+1

81.py

@@ -0,0 +1,43 @@
+'''
+	Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
+
+	(i.e., [0,0,1,2,2,5,6] might become [2,5,6,0,0,1,2]).
+
+	You are given a target value to search. If found in the array return true, otherwise return false.
+
+	Example 1:
+
+	Input: nums = [2,5,6,0,0,1,2], target = 0
+	Output: true
+	Example 2:
+
+	Input: nums = [2,5,6,0,0,1,2], target = 3
+	Output: false
+'''
+
+class Solution(object):
+    def search(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: bool
+        """
+        left, right = 0, len(nums) -1
+        while left <= right: 	
+        	mid = (left + right) / 2
+        	if nums[mid] == target:
+        		return True
+        	if nums[left] < nums[mid]:
+        		if nums[left] <= target < nums[mid]:
+        			right = mid - 1
+        		else:
+        			left = mid + 1
+        	elif nums[mid] < nums[left]:
+        		if nums[mid] < target <= nums[right]:
+        			left = mid + 1
+        		else:
+        			right = mid -1
+        	else:
+        		left += 1
+
+        return False

82.py

@@ -0,0 +1,41 @@
+'''
+Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list.
+
+Example 1:
+
+Input: 1->2->3->3->4->4->5
+Output: 1->2->5
+Example 2:
+
+Input: 1->1->1->2->3
+Output: 2->3
+'''
+
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def deleteDuplicates(self, head):
+        """
+        :type head: ListNode
+        :rtype: ListNode
+        """
+        if not head:
+        	return None
+
+        result = ListNode(0)
+        ans = result
+        curr = head
+        while curr:
+        	value = curr.val
+        	count = 0
+        	while curr and curr.val == value:
+        		curr = curr.next
+        		count += 1
+        	if count == 1:
+        		result.next = ListNode(value)
+        		result = result.next
+        return ans.next

83.py

@@ -0,0 +1,36 @@
+'''
+	Given a sorted linked list, delete all duplicates such that each element appear only once.
+
+	Example 1:
+
+	Input: 1->1->2
+	Output: 1->2
+	Example 2:
+
+	Input: 1->1->2->3->3
+	Output: 1->2->3
+'''
+
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def deleteDuplicates(self, head):
+        """
+        :type head: ListNode
+        :rtype: ListNode
+        """
+        if not head:
+        	return None
+
+        curr = head
+        while curr and curr.next:
+        	if curr.val == curr.next.val:
+        		curr.next = curr.next.next
+        	else:
+	        	curr = curr.next
+
+        return head