add a few easy ones.

Author: lilianweng

LinkedList.pyc

@@ -37,6 +37,7 @@ def median_two_arrays(A, B):
 
 ### use binary search
 # http://leetcode.com/2011/03/median-of-two-sorted-arrays.html
+# KEY: #elements being disposed from each array must be the same.
 # ~O(logn + logm)
 def median_two_arrays2(A, B):
     #print A, B, '--->',
@@ -46,13 +47,18 @@ def median_two_arrays2(A, B):
         i = m//2
         j = n//2
         if A[i] <= B[j]:
-            # median is between [A[i], B[j]]
+            # Median is between [A[i], B[j]], so
+            # we can ignore A's left part, A[0:i], length = i
+            # we can ignore B's right part, B[j+1:n], length = n-j-1
             l, r = i, n-j-1
-            k = min(l,r)+1 if l != r else min(l,r) # THIS IS TRICKY!
+            ### THIS IS TRICKY!
+            # '+1' helps include the medians in A & B.
+            # when l == r, we can safely ignore current medians.
+            k = min(l,r)+1 if l != r else min(l,r)
             A = A[k:]
             B = B[:-k]
         elif A[i] > B[j]:
-            # median is between [B[j], A[i]]
+            # Median is between [B[j], A[i]]
             l,r = j, m-i-1
             k = min(l,r)+1 if l != r else min(l,r)
             A = A[:-k]
@@ -73,7 +79,9 @@ def median_one_array(A):
 
 
 ##########################################################
-
+'''
+Find kth smallest in two sorted arrays.
+'''
 def kth_two_arrays(A, B, k):
     k -= 1
     m, n = len(A), len(B)

median_two_arrays.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python
+'''
+Leetcode: There is an array A[N] of N numbers. You have to compose an array Output[N] such that Output[i] will be equal to multiplication of all the elements of A[N] except A[i]. Solve it without division operator and in O(n).
+
+For example Output[0] will be multiplication of A[1] to A[N-1] and Output[1] will be multiplication of A[0] and from A[2] to A[N-1].
+http://leetcode.com/2010/04/multiplication-of-numbers.html
+'''
+from __future__ import division
+import random
+
+
+def multi_of_nums(A):
+    n = len(A)
+    L = [1]*n
+    R = [1]*n
+    for i in range(n-1):
+        L[i+1] = L[i]*A[i]
+    for i in range(n-1,0,-1):
+        R[i-1] = R[i]*A[i]
+    ret = [L[i]*R[i] for i in range(n)]
+    print ret
+    return ret
+
+
+if __name__ == '__main__':
+    multi_of_nums([4,3,2,1,2,3])
+
+

multiplication_of_nums.py

@@ -12,32 +12,30 @@
 from LinkedList import Node
 
 
-def part_list(node, val):
-    root = node
-    small = None # the end of "small part" of the link
-    large = None # the end of "large part" of the link
+def part_list(head, val):
+    dummy = Node(None, next=head)
+    node = head
+    small = dummy # the end of "small part" of the link
+    large = dummy # the end of "large part" of the link
     while node:
-        print 'current node', node.value
+        print head, 'small:', small.value, 'large:', large.value,
+        print 'current:', node, 'next:', node.next
         next_node = node.next
         if node.value >= val:
-            # the first large element
             large = node
         else:
-            if large:
+            # Change the connection
+            if small.next != node:
                 print 'move', node.value
-                # change the connection
-                if small:
-                    node.next = small.next
-                    small.next = node
-                else: # change root
-                    node.next = root
-                    root = node 
+                node.next = small.next
+                small.next = node
                 large.next = next_node
             # update the tail pointer to the small part
             small = node
         node = next_node
-    print root
-    return root
+    head = dummy.next
+    print head
+    return head
 
 
 if __name__ == '__main__':

partition_list.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python
+
+from __future__ import division
+import random
+from math import sqrt
+
+'''
+Output all prime numbers up to a specified integer n.
+'''
+# using The Sieve of Erantosthenes
+def prime_sieve(n):
+    is_prime = dict((i,True) for i in range(2,n+1))
+    limit = int(sqrt(n))
+    for i in range(2, limit+1):
+        for j in range(2, n//i+1):
+            is_prime[i*j] = False
+    ret = [n for n in is_prime if is_prime[n]]
+    print ret
+    return ret
+
+'''
+Output first n prime numbers
+'''
+def prime(n):
+    primes = [2]
+    num = 3
+    while len(primes) < n:
+        is_prime = True
+        for p in primes:
+            if num % p == 0:
+                is_prime = False
+                break
+        if is_prime:
+            primes.append(num)
+        num += 1
+    print primes
+    return primes
+
+
+if __name__ == '__main__':
+    prime_sieve(230)
+    prime(50)
+
+

prime_num.py

@@ -16,7 +16,7 @@
 
 # S[i][j] = min{S[i-1][j-1], S[i-1][j]} + T[i][j]
 # We only need to keep the record of the last row
-# S[j] = min{S[j-1], S[j]} + T[i][j]
+# S[j] = min{S[j-1], S[j]} + T[i][j]}
 # top-down
 def triangle(T):
     if not T: return 0