Solution of 3, 6, 17, 19, 22, 23, 24 problems

Author: Garvit244

03.py

@@ -0,0 +1,28 @@
+'''
+Given a string, find the length of the longest substring without repeating characters.
+
+Examples:
+
+Given "abcabcbb", the answer is "abc", which the length is 3.
+
+Given "bbbbb", the answer is "b", with the length of 1.
+
+Given "pwwkew", the answer is "wke", with the length of 3. Note that the answer must be a substring, "pwke" is a subsequence and not a substring.
+'''
+
+class Solution(object):
+ def lengthOfLongestSubstring(self, s):
+ """
+ :type s: str
+ :rtype: int
+ """
+ mapSet = {}
+ start, result = 0, 0
+
+ for end in range(len(s)):
+ if s[end] in mapSet:
+ start = max(mapSet[s[end]], start)
+ result = max(result, end-start+1)
+ mapSet[s[end]] = end+1
+
+ return result 

5.py renamed to 05.py

@@ -0,0 +1,41 @@
+'''
+The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility)
+
+P A H N
+A P L S I I G
+Y I R
+
+And then read line by line: "PAHNAPLSIIGYIR"
+'''
+
+class Solution(object):
+ def convert(self, s, numRows):
+ """
+ :type s: str
+ :type numRows: int
+ :rtype: str
+ """
+ 
+ if numRows == 1:
+ return s
+
+ result = ["" for _ in range(numRows)]
+ row, down = 0, 1
+ for char in s:
+ result[row] += char
+
+ if row == numRows - 1:
+ down = 0
+ if row == 0:
+ down = 1
+
+ if down:
+ row += 1
+ else:
+ row -= 1
+ final_string = ""
+ for value in result:
+ final_string += value
+ return final_string
+
+print Solution().convert("PAYPALISHIRING",3)

06.py

@@ -0,0 +1,33 @@
+'''
+Given a string containing digits from 2-9 inclusive, return all possible letter combinations that the number could represent.
+
+A mapping of digit to letters (just like on the telephone buttons) is given below. Note that 1 does not map to any letters.
+'''
+
+class Solution(object):
+ def letterCombinations(self, digits):
+ """
+ :type digits: str
+ :rtype: List[str]
+ """
+ 
+ phoneMap = { '2': 'abc', '3': 'def', '4': 'ghi', '5': 'jkl', '6': 'mno', '7' : 'pqrs', '8': 'tuv', '9':'wxyz'}
+ number = str(digits)
+
+ if number == "":
+ return []
+
+ result = ['']
+ for char in number:
+ values = phoneMap[char]
+ new_result = []
+ for prefix in result:
+ currElement = prefix
+ for value in values:
+ new_result.append(currElement+value)
+
+ result = new_result
+ # result = [prefix+value for prefix in result for value in values]
+ return result
+
+print Solution().letterCombinations("23")

17.py

@@ -0,0 +1,42 @@
+'''
+Given a linked list, remove the n-th node from the end of list and return its head.
+
+Example:
+
+Given linked list: 1->2->3->4->5, and n = 2.
+
+After removing the second node from the end, the linked list becomes 1->2->3->5.
+
+'''
+
+# Definition for singly-linked list.
+# class ListNode(object):
+# def __init__(self, x):
+# self.val = x
+# self.next = None
+
+class Solution(object):
+ def removeNthFromEnd(self, head, n):
+ """
+ :type head: ListNode
+ :type n: int
+ :rtype: ListNode
+ """
+ if not head:
+ return None
+
+ ref = head
+ while n > 0:
+ ref = ref.next
+ n -= 1
+
+ if ref is None:
+ return head.next
+ else:
+ main = head
+ while ref.next:
+ main = main.next
+ ref = ref.next
+
+ main.next = main.next.next
+ return head

19.py

@@ -0,0 +1,36 @@
+'''
+ Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.
+
+For example, given n = 3, a solution set is:
+
+[
+ "((()))",
+ "(()())",
+ "(())()",
+ "()(())",
+ "()()()"
+]
+'''
+
+class Solution(object):
+ def generateParenthesis(self, n):
+ """
+ :type n: int
+ :rtype: List[str]
+ """
+
+ result = []
+
+ def backtracking(S, left, right):
+ if len(S) == 2*n:
+ result.append(S)
+ return 
+
+ if left < n:
+ backtracking(S+'(', left+1, right)
+
+ if right < left:
+ backtracking(S+')', left, right+1)
+
+ backtracking('', 0, 0)
+ return result

22.py

@@ -0,0 +1,83 @@
+'''
+Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.
+
+Example:
+
+Input:
+[
+ 1->4->5,
+ 1->3->4,
+ 2->6
+]
+Output: 1->1->2->3->4->4->5->6
+
+'''
+
+class Solution(object):
+ def mergeKLists(self, lists):
+ """
+ :type lists: List[ListNode]
+ :rtype: ListNode
+ """
+
+ from heapq import heappush, heappop
+
+ heap = []
+ head = point = ListNode(0)
+ for element in lists:
+ if element:
+ heapq.heappush(heap, (element.val, element))
+
+ while heap:
+ value, node = heapq.heappop(heap)
+ head.next = ListNode(value)
+ head = head.next
+ node = node.next
+ if node:
+ heapq.heappush(heap, (node.val, node))
+
+ return point.next
+
+# Space: O(K)
+# Time: O(N*log(K))
+
+class Solution(object):
+ def mergeKLists(self, lists):
+ """
+ :type lists: List[ListNode]
+ :rtype: ListNode
+ """
+
+ def merge2Lists(l1, l2):
+ head = point = ListNode(0)
+ while l1 and l2:
+ if l1.val <= l2.val:
+ point.next = ListNode(l1.val)
+ l1 = l1.next
+ else:
+ point.next = ListNode(l2.val)
+ l2 = l2.next
+ point = point.next
+
+ if l1:
+ point.next = l1
+ else:
+ point.next = l2
+ return head.next
+
+ if not lists:
+ return lists
+
+ interval = 1
+ while interval < len(lists):
+ for index in range(0, len(lists) - interval ,interval*2):
+ lists[index] = merge2Lists(lists[index], lists[index+interval])
+
+ interval *= 2
+
+ return lists[0]
+
+
+
+# Time: O(N*log(k))
+# Space: O(1)

23.py

@@ -0,0 +1,31 @@
+'''
+Given a linked list, swap every two adjacent nodes and return its head.
+
+Example:
+
+Given 1->2->3->4, you should return the list as 2->1->4->3.
+'''
+
+# Definition for singly-linked list.
+# class ListNode(object):
+# def __init__(self, x):
+# self.val = x
+# self.next = None
+
+class Solution(object):
+ def swapPairs(self, head):
+ """
+ :type head: ListNode
+ :rtype: ListNode
+ """
+ 
+ if head is None:
+ return head
+ 
+ ref = head
+ 
+ while ref is not None and ref.next is not None:
+ ref.val, ref.next.val = ref.next.val, ref.val
+ ref = ref.next.next
+ 
+ return head