Leetcode solutions.
This commit is contained in:
parent
67ac823d3b
commit
a041130c3d
|
@ -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:])
|
|
@ -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()
|
|
@ -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
|
|
@ -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()
|
|
@ -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)
|
|
@ -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
|
|
@ -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
|
|
@ -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
|
|
@ -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
|
|
@ -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
|
Loading…
Reference in New Issue