add 3 new problems

Author: weng

.gitignore

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

candy.py

@@ -1,14 +1,13 @@
 #!/usr/bin/env python
 '''
-Leetcode:
-There are N children standing in a line. Each child is assigned a rating value.
+Leetcode: Candy
 
+There are N children standing in a line. Each child is assigned a rating value.
 You are giving candies to these children subjected to the following requirements:
+    Each child must have at least one candy.
+    Children with a higher rating get more candies than their neighbors.
 
-Each child must have at least one candy.
-Children with a higher rating get more candies than their neighbors.
 What is the minimum candies you must give?
-
 '''
 from __future__ import division
 import random

copy_list_random_pointer.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python
+'''
+Leetcode: Copy List with Random Pointer
+A linked list is given such that each node contains an additional random pointer 
+which could point to any node in the list or null. Return a deep copy of the list.
+'''
+
+from __future__ import division
+import random
+import LinkedList
+
+
+class Node(LinkedList.Node):
+    def __init__(self, value, next=None, prev=None, randp=None):
+        super(Node, self).__init__(value, next, prev)
+        self.randp = randp
+    def __str__(self):
+        if self.randp is None: s = '[%d]' % self.value
+        else: s = '[%d,%d]' % (self.value, self.randp.value)
+        if self.next:
+            s += '->(%s)' % str(self.next)
+        return s
+
+# Brute-force
+# create the list first and then set up the pointer
+def copylist(head):
+    new_head = Node(head.value)
+    # Copy the list
+    prev_n = new_head
+    node = head.next
+    while node:
+        n = Node(node.value)
+        prev_n.next = n
+        prev_n = n
+        node = node.next
+    
+    # Assign pointer
+    node = head
+    new_node = new_head
+    while node:
+        if node.randp:
+            # locate the pointer
+            h = head
+            newh = new_head
+            while h != node.randp:
+                h = h.next
+                newh = newh.next
+            new_node.randp = newh
+        node = node.next
+        new_node = new_node.next
+    print 'Orig:', head
+    print 'Copy:', new_head
+
+
+if __name__ == '__main__':
+    n6 = Node(6)
+    n5 = Node(5, n6)
+    n4 = Node(4, n5)
+    n3 = Node(3, n4)
+    n2 = Node(2, n3)
+    n1 = Node(1, n2)
+    n1.randp = n4
+    n2.randp = n4
+    n4.randp = n6
+    n5.randp = n3
+    
+    copylist(n1)
+    
+    

gas_station.py

@@ -1,15 +1,12 @@
 #!/usr/bin/env python
 '''
-Leetcode:
-There are N gas stations along a circular route, where the amount of gas at station i is gas[i].
+Leetcode: Gas Station
 
+There are N gas stations along a circular route, where the amount of gas at station i is gas[i].
 You have a car with an unlimited gas tank and it costs cost[i] of gas to travel from station i to its next station (i+1). You begin the journey with an empty tank at one of the gas stations.
-
 Return the starting gas station's index if you can travel around the circuit once, otherwise return -1.
 
-Note:
-The solution is guaranteed to be unique.
-
+Note: The solution is guaranteed to be unique.
 '''
 from __future__ import division
 import random
@@ -18,8 +15,9 @@
 # the car can use gas at i-th but not at j-th
 # only valid when G(i,j) >= 0
 # G(i,j) = max{G(i,mid)+G(k,mid) for i < mid < j, 
-#              gas[i] - cost[i]+...+cost[j]}
+#              gas[i] - (cost[i]+...+cost[j])}
 # We use G(i,i) for a circular route.
+# ~ O(n^2)
 def gas_station(gas, cost):
     n = len(gas)
     G = {}

letter_comb_phone.py

@@ -59,7 +59,7 @@ def phone_mapping2(num2lett, dictionary, number, words):
 
     if len(number) == 0: return True
 
-    if number in memo and not memo[number]: return False
+    if number in memo: return memo[number]
 
     n = len(number)
     can_split = False

next_permutation.py

@@ -55,6 +55,7 @@ def iter_permutation(L):
     print L
     while True:
         i = n - 2
+        # Find i-th element that < right element
         while i >= 0:
             if L[i] < L[i+1]: break
             i -=1

single_number.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+
+from __future__ import division
+import random
+
+'''
+Leetcode: Single Number
+
+Given an array of integers, every element appears twice except for one. Find that single one.
+Note: Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?
+'''
+def func():
+    pass
+
+
+'''
+Leetcode: Single Number II
+
+Given an array of integers, every element appears three times except for one. Find that single one.
+Note: Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?
+
+
+'''
+def func():
+    pass
+
+
+if __name__ == '__main__':
+    func()
+
+

valid_palin.pyc

@@ -0,0 +1,90 @@
+#!/usr/bin/env python
+'''
+http://thenoisychannel.com/2011/08/08/retiring-a-great-interview-problem/
+'''
+from __future__ import division
+import random
+
+
+'''
+Leetcode: Word Break
+Given a string s and a dictionary of words dict, determine if s can be segmented into a space-separated sequence of one or more dictionary words.
+For example, given 
+s = "leetcode", 
+dict = ["leet", "code"].
+Return true because "leetcode" can be segmented as "leet code".
+'''
+def wordbreak(s, words):
+    if len(s) == 0: return True
+    # Test all prefixes
+    for i in range(1, len(s)+1):
+        sub = s[:i]
+        if not sub in words: continue
+        if wordbreak(s[i:], words):
+            return True
+    return False
+
+
+### DP? O(n^2)
+# cut(i) = s[:i] can be splitted
+# cut(i+1) = OR{cut(j) and s[j:i] is a word for 0 <= j < i}
+def wordbreak_DP(s, words):
+    words = set(words)
+    cut = {0: True}
+    for i in range(1,len(s)+1):
+        cut[i] = False
+        for j in range(i):
+            if cut[j] and s[j:i] in words:
+                cut[i] = True
+                break
+    return cut[len(s)]
+
+
+memo = {}
+def wordbreak_memo(s, words):
+    if s == '': return True
+    global memo
+    if s in memo: return memo[s]
+    for i in range(1,len(s)+1):
+        sub = s[:i]
+        if not sub in words: continue
+        if wordbreak_memo(s[i:], words):
+            memo[s] = True#; print memo
+            return True
+    return False
+
+'''
+Leetcode: Word Break II
+Given a string s and a dictionary of words dict, add spaces in s to construct a sentence where each word is a valid dictionary word. Return all such possible sentences.
+For example, given
+s = "catsanddog",
+dict = ["cat", "cats", "and", "sand", "dog"].
+A solution is ["cats and dog", "cat sand dog"].
+'''
+# ~O(exponential)
+def wordbreak2_generator(s, words):
+    if len(s) == 0: yield []
+    else:
+        # Test all prefixes
+        for i in range(1, len(s)+1):
+            sub = s[:i]
+            if not sub in words: continue
+            for others in wordbreak2_generator(s[i:], words):
+                yield [sub] + others
+
+def wordbreak2(s, words):
+    words = set(words)
+    for combo in wordbreak2_generator(s, words):
+        print combo
+
+
+
+if __name__ == '__main__':
+    s = "catsanddogseat"
+    words = set(["cat", "cats", "and", "sand", "dog", "dogs", "eat", "seat"])
+    print wordbreak(s, words)
+    print wordbreak_DP(s, words)
+    print wordbreak_memo(s, words)
+    wordbreak2(s, words)
+
+