add 2.1_remove_duplicates_from_linked_list.py

Author: bap2pecs0

Cracking_the_coding_interview/2.1_remove_duplicates_from_linked_list.py

@@ -0,0 +1,101 @@
+'''Question:
+Write code to remove duplicates from an unsorted linked list. FOLLOW UP
+How would you solve this problem if a temporary buffer is not allowed?
+
+clarification:
+- singly linked list? yes
+- will there be circles? no
+- can I assume the linked list only contains integer data? yes
+- if thare are dups at position x and x+n, remove the one at x+n
+- the order should be reserved
+- what is a temporary buffer? it means even hash table cannot be used 
+- return head
+'''
+
+import unittest
+from test_utils import UnitTestBase
+from data_structure import Node, LinkedList as LL
+
+# Solution: use hash table
+# Time: O(n)
+# Space: O(n)
+def remove_dups_1(ll):
+  cur = ll.head
+  if cur == None:
+    return ll
+
+  keys = set([cur.data])
+  while cur.next != None:
+    key = cur.next.data
+    if key not in keys:
+      keys.add(key)
+      cur = cur.next
+    else:
+      cur.next = cur.next.next
+    
+  return ll
+
+# Solution: no temporaty buffer
+# Time: O(n*n)
+# Space: O(1)
+def remove_dups_2(ll):
+  anchor = ll.head
+  while anchor != None:
+    cur, key = anchor, anchor.data
+
+    while cur.next != None:
+      if cur.next.data != key:
+        cur = cur.next
+      else:
+        cur.next = cur.next.next
+
+    anchor = anchor.next
+    
+  return ll
+
+# Solution: no temporaty buffer. recursion
+# Time: O(n*n)
+# Space: O(1) - tail recursion
+def remove_dups_3(ll):
+  remove_dups_3_helper(ll.head)
+  return ll
+
+def remove_dups_3_helper(anchor):
+    if anchor == None:
+      return
+
+    cur, key = anchor, anchor.data
+
+    while cur.next != None:
+      if cur.next.data != key:
+        cur = cur.next
+      else:
+        cur.next = cur.next.next
+
+    remove_dups_3_helper(anchor.next)
+
+class Test(UnitTestBase, unittest.TestCase):
+  def data_provider(self):
+    return [
+      (LL(), LL()),
+      (LL([1]), LL([1])),
+      (LL([1, 2, 3]), LL([1, 2, 3])),
+      (LL([1, 1]), LL([1])),
+      (LL([4, 8, 2, 4]), LL([4, 8, 2])),
+      (LL([4, 2, 2, 4]), LL([4, 2])),
+      (LL([1, 4, 6, 8, 6, 2, 1]), LL([1, 4, 6, 8, 2])),
+      (LL([4, 2, 3, 4, 8, 6, 6, 2]), LL([4, 2, 3, 8, 6])),
+    ]
+
+  def func_provider(self):
+    return [
+      remove_dups_1,
+      remove_dups_2,
+      remove_dups_3,
+    ]
+
+  def func_eval(self, func, args):
+    return func(args)
+
+if __name__ == '__main__':
+  unittest.main()

Cracking_the_coding_interview/Cracking the Coding Interview 6th Edition.pdf

@@ -0,0 +1,23 @@
+class Node():
+  def __init__(self, data, next = None):
+    self.data = data
+    self.next = next
+  def __str__(self):
+    return str(self.data)
+
+class LinkedList():
+  def __init__(self, lst = []):
+    cur = None
+    for i in range(len(lst) - 1, -1, -1):
+      data = lst[i]
+      n = Node(data, cur)
+      cur = n
+    self.head = cur
+
+  def __str__(self):
+    res = []
+    cur = self.head
+    while cur != None:
+      res.append(cur.data)
+      cur = cur.next
+    return str(res)

Cracking_the_coding_interview/v6/2.1_remove_dups.py

@@ -26,7 +26,7 @@ def single_test(self, func, data):
 
   def expect(self, result, func, data):
     expected = data[1]
-    self.assertEqual(result, expected, self.err_msg(func, data))
+    self.assertEqual(str(result), str(expected), self.err_msg(func, data))
 
   def err_msg(self, func, data):
     return  'Failed \'' + func.__name__ + '\'. args & expected: ' + str(data)

Cracking_the_coding_interview/v6/__pycache__/data_structure.cpython-36.pyc

@@ -26,3 +26,6 @@ example: 1.5 one_away_1 at Hot Spot 1 & 2
 12. 'header'.join(['a', 'b'])
 - this does not produce: 'headerab', instead it will output 'aheaderb'
 - the right way to do it is: 'header' + ''.join(['a', 'b'])
+13. while len(lst) > 0:
+      data = lst.pop()
+    this will have side effect on the list. not recommended for looping a list