initial commit

Author: lilianweng

.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+.xlsx
+*.*~
+_*_.*
+

3sum.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python
+
+
+from __future__ import division
+import random
+
+
+'''
+Leetcode: 3Sum
+
+Given an array S of n integers, are there elements a, b, c in S such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.
+
+Note:
+Elements in a triplet (a,b,c) must be in non-descending order. (ie, a ? b ? c)
+The solution set must not contain duplicate triplets.
+    For example, given array S = {-1 0 1 2 -1 -4},
+    A solution set is:
+    (-1, 0, 1)
+    (-1, -1, 2)
+http://leetcode.com/2010/04/finding-all-unique-triplets-that-sums.html
+'''
+# ~ O(n^2)
+def three_sum(s):
+    s = sorted(s) # O(nlogn)
+    output = set()
+    for k in range(len(s)):
+        target = -s[k]
+        i,j = k+1, len(s)-1
+        while i < j:
+            sum_two = s[i] + s[j]
+            if sum_two < target:
+                i += 1
+            elif sum_two > target:
+                j -= 1
+            else:
+                output.add((s[k],s[i],s[j]))
+                i += 1
+                j -= 1
+    return output
+
+
+'''
+Leetcode: Two sum
+Given an array of integers, find two numbers such that they add up to a specific target number.
+The function twoSum should return indices of the two numbers such that they add up to the target, where index1 must be less than index2. Please note that your returned answers (both index1 and index2) are not zero-based.
+You may assume that each input would have exactly one solution.
+Input: numbers={2, 7, 11, 15}, target=9
+Output: index1=1, index2=2
+'''
+def two_sum(L, target):
+    L = sorted(L)
+    i = 0; j = len(L)-1
+    while i < j:
+        if L[i]+L[j] == target:
+            return i+1, j+1
+        elif L[i]+L[j] > target:
+            j -= 1
+        else:
+            i += 1
+    return -1,-1
+
+
+# O(n^(k-1))
+def k_sum(s, k, target):
+    s = sorted(s) # O(nlogn)
+    if k == 0:
+        yield []
+    
+    elif k == 1:
+        if target in set(s): yield [target]
+    
+    elif k == 2:
+        i = 0; j = len(s)-1
+        while i < j:
+            sum_two = s[i] + s[j]
+            if sum_two < target: i += 1
+            elif sum_two > target: j -= 1
+            else:
+                yield [s[i], s[j]]
+                i += 1
+                j -= 1
+    else:
+        for i in range(len(s)):
+            next_target = target - s[i]
+            for p in k_sum(s[i+1:], k-1, next_target):
+                yield [s[i]] + p
+
+
+if __name__ == '__main__':
+    #print three_sum([-1, 0, 1, 2, -1, -4])
+    #for p in k_sum([1, 0, -1, 0, -2, 2, 3, 5, -3], 4, 0): print p
+    print two_sum([2, 7, 11, 15, 3], 13)

3sum_closest.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python
+'''
+Leetcode: 3Sum Closest
+
+Given an array S of n integers, find three integers in S such that the sum is closest to a given number, target. Return the sum of the three integers. You may assume that each input would have exactly one solution.
+
+    For example, given array S = {-1 2 1 -4}, and target = 1.
+    The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).
+
+'''
+from __future__ import division
+import random
+
+### DP? Given a list L
+# S(i, k, target) = True if we can find k elements among L[:i] to sum up to target
+# S(i, k, target) = S(i-1, k-1, target-L[i-1]) or S(i-1, k, target)
+def sum_closest(L, num_k, target):
+    import math
+    n = len(L)
+    S = {}
+    prev = {}
+    max_t = sum([x for x in L if x > 0])
+    min_t = sum([x for x in L if x <= 0])
+    print 'target range: [%d, %d]' %(min_t, max_t)
+    
+    # Initialization:
+    # S(0,any,any) = False
+    # S(any,0,any) = False
+    # S(any,0,0) = True
+    for i in range(n+1): 
+        for t in range(min_t, max_t+1):
+            S[(i,0,t)] = False
+    for k in range(num_k+1):
+        for t in range(min_t, max_t+1):
+            S[(0,k,t)] = False
+    for i in range(n+1):
+        S[(i,0,0)] = True
+    
+    for i in range(1,n+1):
+        for k in range(1,num_k+1):
+            for t in range(min_t, max_t+1):
+                with_elem = S[(i-1,k-1,t-L[i-1])] if min_t <= t-L[i-1] <= max_t else False
+                without_elem = S[(i-1,k,t)]
+                
+                S[(i,k,t)] = with_elem or without_elem
+                if with_elem: prev[(i,k,t)] = (i-1,k-1,t-L[i-1])
+                elif without_elem: prev[(i,k,t)] = (i-1,k,t)
+    
+    # min{|t-target| for S[(n,num_k,t)] == True}
+    cands = [t for t in range(min_t, max_t+1) if S[(n,num_k,t)]]
+    output_t = min(cands, key=lambda x:math.fabs(x-target))
+    
+    # print out
+    output = []
+    i,k,t = n,num_k,output_t
+    while (i,k,t) in prev:
+        next_i,next_k,next_t = prev[(i,k,t)]
+        if next_k == k-1: output.append(L[next_i])
+        i,k,t = next_i,next_k,next_t
+    print 'output:', output, 'sum(output):', sum(output)
+    return output
+
+
+if __name__ == '__main__':
+    sum_closest([-1, 2, 1, -3, 6], 2, 2)
+
+

BinaryTree.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python
+
+from __future__ import division
+from math import log10
+
+class Node(object):
+    def __init__(self, value=0,
+                 left=None, right=None, 
+                 id=None, parent=None):
+        self.id = id
+        self.left = left
+        self.right = right
+        self.value = value
+        self.parent = parent
+    
+    def __str__(self):
+        if self.left is None and self.right is None:
+            return str(self.value)
+        else:
+            return '%s (%s, %s)' % (
+                    str(self.value), 
+                    str(self.left), 
+                    str(self.right))
+    
+    def __repr__(self):
+        s = 'TreeNode Object (id=' + str(self.id) + \
+            ' value='+str(self.value)+')'
+        return s
+    
+    def pretty_print(self):
+        # get each levels
+        level = [self]
+        to_prints = [[self.value]]
+        while True:
+            is_all_none = True
+            next_level = []
+            to_print = []
+            for n in level:
+                if n is None:
+                    next_level += [None, None]
+                    to_print += ['#','#']
+                else:
+                    is_all_none = False
+                    next_level += [n.left, n.right]
+                    left_val = n.left.value if n.left and n.left.value else '#'
+                    right_val = n.right.value if n.right and n.right.value else '#'
+                    to_print += [left_val, right_val]
+            if is_all_none: break
+            level = next_level
+            to_prints.append(to_print)
+        
+        #max_val_digits = max([max([len(str(v)) for v in r]) for r in to_prints])
+        #print max_val_digits
+        
+        to_prints = to_prints[:-1] # remove the last row with only '#'
+        to_pretty_prints = []
+        to_prints.reverse()
+        for i, row in enumerate(to_prints):
+            row = map(str,row)
+            #row = [' '*(max_val_digits-len(v))+v for v in row]
+            sep = ' '*(2**(i+1) - 1)
+            space = ' '*(2**i - 1)
+            to_pretty_prints.insert(0, space + sep.join(row) + space)
+        print '\n'.join(to_pretty_prints)
+
+
+root = Node(value=5,
+            left=Node(value=4,
+                 left=Node(value=1,
+                      right=Node(value=2))
+            ),
+            right=Node(value=8,
+                 left=Node(value=3),
+                 right=Node(value=4,
+                    left=Node(value=9),
+                    right=Node(value=1))
+            )
+        )
+
+BST = Node(value=5,
+            left=Node(value=2,
+                 left=Node(value=1,
+                    right=Node(value=1.5, 
+                        left=Node(value=1.2))),
+                 right=Node(value=3)
+            ),
+            right=Node(value=9,
+                 left=Node(value=7),
+                 right=Node(value=15,
+                    right=Node(value=16)
+                 )
+            )
+        )
+
+root_with_id = Node(id=0,value=-3,
+                    left=Node(id=1,value=-2,
+                         left=Node(id=3,value=3,
+                              left=Node(id=7,value=1,
+                                    left=Node(id=11,value=4)),
+                              right=Node(id=8,value=1)),
+                         right=Node(id=4,value=-1,
+                              left=Node(id=9,value=4),
+                              right=Node(id=10,value=2))
+                    ),
+                    right=Node(id=2,value=2,
+                         left=Node(id=5,value=-1),
+                         right=Node(id=6,value=3,
+                            right=Node(id=12,value=2))
+                    )
+                )
+
+
+if __name__ == '__main__':
+    root.pretty_print()
+    print
+    BST.pretty_print()

LCA.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python
+'''
+Leetcode: Lowest common ancesters
+http://leetcode.com/2011/07/lowest-common-ancestor-of-a-binary-search-tree.html
+http://leetcode.com/2011/07/lowest-common-ancestor-of-a-binary-tree-part-i.html
+http://leetcode.com/2011/07/lowest-common-ancestor-of-a-binary-tree-part-ii.html
+'''
+from __future__ import division
+import random
+from BinaryTree import Node, BST, root
+
+
+### We traverse from the bottom, and once we reach a node which matches one of the two nodes, we pass it up to its parent. The parent would then test its left and right subtree if each contain one of the two nodes. If yes, then the parent must be the LCA and we pass its parent up to the root. If not, we pass the lower node which contains either one of the two nodes (if the left or right subtree contains either p or q), or NULL (if both the left and right subtree does not contain either p or q) up.
+# O(n)
+def lca(root, a, b):
+    if not root: return None
+    if root.value == a or root.value == b: return root
+    left = lca(root.left, a, b)
+    right = lca(root.right, a, b)
+    if left and right: # if p and q are on both sides
+        return root
+    else: # either a/b is on one side OR a/b is not in L&R subtrees
+        return left if left else right
+
+
+### With parent pointer
+# find the height h(a), h(b)
+# move the lower node b up by h(a)-h(b) steps
+# move a and b up together until a=b
+def lca_parent(root, node_a, node_b):
+    h_a = find_height(root, node_a)
+    h_b = find_height(root, node_b)
+    if h_b > h_a:
+        node_a, node_b = node_b, node_a
+        h_a,h_b = h_b,h_a
+    for _ in range(h_b - h_a):
+        node_b = node_b.parent
+    while node_a != node_b:
+        node_a = node_a.parent
+        node_b = node_b.parent
+    return node_a
+
+def find_height(root, node):
+    h = 0
+    while node:
+        node = node.parent
+        h += 1
+    return h
+
+
+# 1. Both nodes are to the left of the tree.
+# 2. Both nodes are to the right of the tree.
+# 3. One node is on the left while the other is on the right.
+# 4. When the current node equals to either of the two nodes, this node must be the LCA too.
+# O(logn)
+def lca_BST(root, a, b):
+    while root:
+        if a <= root.value <= b:
+            return root
+        elif min(a,b) < root.value:
+            root = root.left
+        elif max(a,b) > root.value:
+            root = root.right
+    return None
+
+
+if __name__ == '__main__':
+    print lca_BST(BST, 1,3)
+    print lca_BST(BST, 9,16)
+
+

LinkedList.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python
+
+from __future__ import division
+
+class Node(object):
+    def __init__(self, value, next=None, prev=None):
+        self.prev = prev
+        self.next = next
+        self.value = value
+    
+    def __str__(self):
+        if self.next is None:
+            return str(self.value)
+        else:
+            return '%d (%s)' % (self.value, str(self.next))
+    
+    def __repr__(self):
+        s = 'LinkedListNode Object (value='+str(self.value)+')'
+        return s
+
+

README.md

@@ -1,4 +1,9 @@
-LeetcodePython
+Leetcode Practice in Python
 ==============
+This repository includes answers to Leetcode coding interview questions.
+
+ALl the problems please refer to http://oj.leetcode.com/problems/
+
+The problem descriptions are also included in each python file.
+
 
-Leetcode Practice in Python