Leetcode solutions.

leetcode/leetcode_017.py

@@ -0,0 +1,39 @@
+from pprint import pprint
+from copy import deepcopy
+import sys
+
+
+class Solution(object):
+    keyboard = {
+                 "1": ["*"]
+               , "2": ["a", "b", "c"]
+               , "3": ["d", "e", "f"]
+               , "4": ["g", "h", "i"]
+               , "5": ["j", "k", "l"]
+               , "6": ["m", "n", "o"]
+               , "7": ["p", "q", "r", "s"]
+               , "8": ["t", "u", "v"]
+               , "9": ["w", "x", "y", "z"]
+               , "0": [" "]
+               }
+
+    def letterCombinations(self, digits):
+        if len(digits) == 0:
+            return []
+        else:
+            processed = self.recurse([], digits)
+            return processed
+
+    def recurse(self, processed, digits):
+        if len(digits) == 0:
+            return processed
+        
+        newOnes = list()
+        if len(processed) == 0:
+            newOnes = deepcopy(self.keyboard[digits[0]])
+        else:
+            for p in processed:
+                for k in self.keyboard[digits[0]]:
+                    newOnes.append(p + k)
+
+        return self.recurse(newOnes, digits[1:])

leetcode/leetcode_088.py

@@ -0,0 +1,76 @@
+class Solution(object):
+    def merge(self, nums1, m, nums2, n):
+        """
+        :type nums1: List[int]
+        :type m: int
+        :type nums2: List[int]
+        :type n: int
+        :rtype: void Do not return anything, modify nums1 in-place instead.
+        """
+        sorted_list = [None] * (m + n)
+        pointer_1 = m - 1
+        pointer_2 = n - 1
+        pointer = m + n - 1
+        while(pointer >=0):
+            if pointer_1 >= 0 and pointer_2 >= 0:
+                if nums1[pointer_1] > nums2[pointer_2]:
+                    sorted_list[pointer] = nums1[pointer_1]
+                    pointer_1 -= 1
+                else:
+                    sorted_list[pointer] = nums2[pointer_2]
+                    pointer_2 -= 1
+            elif pointer_1 >= 0:
+                    sorted_list[pointer] = nums1[pointer_1]
+                    pointer_1 -= 1
+            elif pointer_2 >= 0:
+                    sorted_list[pointer] = nums2[pointer_2]
+                    pointer_2 -= 1
+            else:
+                assert False, "Pointers are broken!"
+            pointer -= 1
+        # because Python does not allow me to change to
+        # nums1 = sorted_list
+        for index in range(0, len(nums1)):
+            if len(nums1) > 0:
+                nums1.pop()
+            
+        for index in range(0,len(sorted_list)):
+                nums1.append(sorted_list[index])
+
+import unittest
+class SolutionTestCase(unittest.TestCase):
+    def setUp(self):
+        self.solution = Solution()
+
+    def test_empty(self):
+        nums1 = []
+        nums2 = []
+        self.solution.merge(nums1, len(nums1), nums2, len(nums2))
+        self.assertEqual(nums1, [])
+
+    def test_just_nums1(self):
+        nums1 = [0]
+        nums2 = []
+        self.solution.merge(nums1, len(nums1), nums2, len(nums2))
+        self.assertEqual(nums1, [0])
+
+    def test_just_nums2(self):
+        nums1 = []
+        nums2 = [0]
+        self.solution.merge(nums1, len(nums1), nums2, len(nums2))
+        self.assertEqual(nums1, [0])
+
+    def test_mine(self):
+        nums1 = [1,4,5,8]
+        nums2 = [2,3,6,7,9]
+        self.solution.merge(nums1, len(nums1), nums2, len(nums2))
+        self.assertEqual(nums1, [1,2,3,4,5,6,7,8,9])
+
+    def test_mine(self):
+        nums1 = [1,4,5,8]
+        nums2 = [2,3,6,7,8,9]
+        self.solution.merge(nums1, len(nums1), nums2, len(nums2))
+        self.assertEqual(nums1, [1,2,3,4,5,6,7,8,8,9])
+
+if __name__ == '__main__':
+    unittest.main()

leetcode/leetcode_162.py

@@ -0,0 +1,30 @@
+class Solution(object):
+    def findPeakElement(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        if not nums:
+            return -1
+        
+        if len(nums) == 1:
+            return 0
+
+        import sys
+        peak_value = -sys.maxint - 1
+        peak_index = -1
+
+        for i in range(0,len(nums)):
+            if i == 0 and nums[i] > nums[i+1]:
+                peak_index = i
+                break
+            elif i == len(nums)-1 and nums[i] > nums[i-1]:
+                peak_index = i
+                break
+            elif nums[i] > nums[i-1] and nums[i] > nums[i+1]:
+                peak_index = i
+                break
+            else:
+                pass
+
+        return peak_index

leetcode/leetcode_210.py

@@ -0,0 +1,103 @@
+from collections import deque
+class Solution(object):
+    def __init__(self):
+        self.scores = None
+
+    def findOrder(self, numCourses, prerequisites):
+        """
+        :type numCourses: int
+        :type prerequisites: List[List[int]]
+        :rtype: List[int]
+        """
+        if numCourses <= 0:
+            return []
+
+        if not prerequisites:
+            return range(0,numCourses)
+
+        all_courses = range(0, numCourses)
+
+        self_references = map(
+            lambda c: self.has_self_reference(prerequisites, c),
+            all_courses
+        )
+        if any(self_references):
+            return []
+
+        self.scores = numCourses * [-1]
+        courses = []
+        for course in all_courses:
+            score = self.compute_score(prerequisites, course)
+            if score < 0:
+                return []
+            courses.append((score, course))
+        ordered_courses = sorted(courses)
+        return [c[1] for c in ordered_courses]
+    
+    def has_self_reference(self, prerequisites, origin):
+#        import pdb
+#        pdb.set_trace()
+        visited = [origin]
+        destinations = deque([p[0] for p in prerequisites if p[1] == origin])
+        while destinations:
+            d = destinations.popleft()
+            if d in visited:
+                return True
+            visited.append(d)
+            destinations.extend([p[0] for p in prerequisites
+                                      if p[1] == d
+                                      and p[0] not in destinations
+          ])
+        return False
+
+    def compute_score(self, prerequisites, course):
+        if self.scores[course] < 0:
+            course_prerequisites = [pre[1] for pre in prerequisites 
+                                        if pre[0] == course]
+            if not course_prerequisites:
+                course_score = 0
+            else:
+                course_score = len(course_prerequisites) + sum(map(lambda c:
+                    self.compute_score(prerequisites, c),
+                    course_prerequisites
+                ))
+            self.scores[course] = course_score
+        return self.scores[course]
+
+import unittest
+class SolutionTestCase(unittest.TestCase):
+    def setUp(self):
+        self.solution = Solution()
+
+    def test_cyclic(self):
+        self.assertEquals(
+            [0, 1, 2, 3],
+            sorted(self.solution.findOrder(4, [[3, 2], [3, 1], [2, 0], [1, 0]]))
+        )
+
+    def test_failure(self):
+        self.assertEquals(
+            [],
+            self.solution.findOrder(3, [[1,0],[0,2],[2,1]])
+        )
+
+    def test_failure_simple(self):
+        self.assertEquals(
+            [1, 0],
+            self.solution.findOrder(2, [[0,1]])
+        )
+
+    def test_failure_other(self):
+        self.assertEquals(
+            [5,4,6,3,2,0,7,1],
+            self.solution.findOrder(8, [[1,0],[2,6],[1,7],[6,4],[7,0],[0,5]])
+        )
+
+    def test_failure_and_another(self):
+        self.assertEquals(
+            [],
+            self.solution.findOrder(3, [[0,2], [1,2], [2,0]])
+        )
+
+if __name__ == '__main__':
+    unittest.main()

leetcode/leetcode_344.py

@@ -0,0 +1,9 @@
+class Solution(object):
+    def reverseString(self, s):
+        length = len(s)
+        i = length - 1
+        reverse = [""]*length
+        while i >= 0:
+            reverse[length-1-i] = s[i]
+            i -= 1
+        return ''.join(reverse)

leetcode/leetcode_404.py

@@ -0,0 +1,24 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def sumOfLeftLeaves(self, root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        left_leaves_sum = 0
+        if root:
+            if root.left and self.is_leaf(root.left):
+                left_leaves_sum += root.left.val
+            left_leaves_sum += self.sumOfLeftLeaves(root.right)
+            left_leaves_sum += self.sumOfLeftLeaves(root.left)
+
+        return left_leaves_sum
+    
+    def is_leaf(self, node):
+        return node and not node.left and not node.right

leetcode/leetcode_412.py

@@ -0,0 +1,21 @@
+class Solution(object):
+    def fizzBuzz(self, n):
+        if n < 1:
+            return []
+        result = []
+        counter = {3: 0, 5: 0}
+        value = ""
+        for i in range(1,n+1):
+            value = ""
+            counter[3]+= 1
+            counter[5]+= 1
+            if counter[3] == 3:
+                value += "Fizz"
+                counter[3] = 0
+            if counter[5] == 5:
+                value += "Buzz"
+                counter[5] = 0
+            if value == "":
+                value = str(i)
+            result.append(value)
+        return result

leetcode/leetcode_434.py

@@ -0,0 +1,18 @@
+class Solution(object):
+    def countSegments(self, s):
+        """
+        :type s: str
+        :rtype: int
+        """
+        if not s:
+            return 0
+        
+        sequences = 0
+        last_char = ' '
+        spaces = [' ', '\t']
+        for character in s:
+            if character not in spaces:
+                if last_char in spaces:
+                    sequences += 1
+            last_char = character
+        return sequences

leetcode/leetcode_461.py

@@ -0,0 +1,17 @@
+class Solution(object):
+    def hammingDistance(self, x, y):
+        """
+        :type x: int
+        :type y: int
+        :rtype: int
+        """
+        bitDifferences = x ^ y
+        return self.countOneBits(bitDifferences)
+    
+    def countOneBits(self, binary):
+        b = binary
+        count = 0
+        while (b != 0):
+            count = count + 1 if b & 1 == 1 else count
+            b = b >> 1
+        return count

leetcode/leetcode_554.py

@@ -0,0 +1,24 @@
+class Solution(object):
+    def leastBricks(self, wall):
+        """
+        :type wall: List[List[int]]
+        :rtype: int
+        """
+        cuts = dict()
+        rowSum = 0
+
+        # get all possible cutss
+        for row in wall:
+            rowSum  = 0
+            for brick in row:
+                rowSum += brick
+                if rowSum not in cuts:
+                    cuts[rowSum] = 0
+                cuts[rowSum] += 1
+
+        amountBestCut = 0
+        for cut, amount in cuts.items():
+            if amount > amountBestCut and cut != 0 and cut != rowSum:
+                amountBestCut = amount
+
+        return len(wall) - amountBestCut