Move files here from Google Drive

Author: bap2pecs0

Cracking_the_coding_interview/1.1.py

@@ -0,0 +1,37 @@
+'''Question:
+implement an algorithm to determine if a string has all unique characters. 
+What if you can not use additional data structures?
+'''
+
+'''Algorithm Design
+Confusions:
+1. What do you mean by "all unique characters"? I assume it is ACSII string with value 0~255.
+2. What do you mena by "cannot use addtional data structures"? I assume I can only use string.
+Examples:
+1) agshdhfkd -> False
+2) agsdhfk -> True
+Design:
+	Create a hash function to map all unique characters
+'''
+
+def hash_function(char):
+    return ord(char)
+    
+
+def all_unique_string(string):
+    table = [0 for x in range(256)]
+    for char in string:
+        index = hash_function(char)
+        if table[index] == 0:
+            table[index] = 1
+        else:
+            return False
+    return True
+
+if __name__ == '__main__':
+    print all_unique_string('agshdhfkd')
+    print all_unique_string('agsdhfk')
+
+
+
+

Cracking_the_coding_interview/1.2_reverse_c_style_string.py

@@ -0,0 +1,34 @@
+'''
+Write code to reverse a C-Style String. (C-String means that 'abcd' is represented as five characters, including the null character.)
+
+
+In C and C++, strings are typically represented as char arrays that have a null terminator. A null terminator means that the string ends with a '\0' character (which has ASCII code 0)
+
+'''
+
+
+# clarification questions:
+# 1) input is a string ending with '\0'
+# 2) i cannot use .reverer(), right?
+import copy
+def strReverse(string):
+    string = copy.deepcopy(string)
+    string = string[:-1]
+    lst = list(string)
+    lst.reverse() # the same as: reverse(lst)  
+    lst.append('\0')
+    return str(lst)
+
+# the same as list's reverse() function
+def reverse(lst):
+    # swap from the beginning to the middle point of the array
+    for i in range(len(lst)/2):
+        tmp = lst[i]
+        right = len(lst) - 1 - i
+        lst[i] = lst[right]
+        lst[right] = tmp        
+        
+    return None
+
+if __name__ == '__main__':
+    print strReverse('abocd\0')

Cracking_the_coding_interview/1.3_remove_duplicate_chars.py

@@ -0,0 +1,72 @@
+'''
+Design an algorithm and write code to remove the duplicate characters in a string without using any additional buffer. NOTE: One or two additional variables are fine. An extra copy of the array is not.
+FOLLOW UP
+Write the test cases for this method.
+'''
+
+# clarification question:
+# 1) does order matter? If not simple use ''.join(set(string) will work (yes, it matters)
+# 2) for duplicates, we keep its first occurance. is that correct? (yes)
+# 3) what do you mean by 'An extra copy of the array'?
+#    i plan to use a dictionary to store unique chars, is this allowed?
+#    (yes)
+# 4) can I use python's set? (yes)
+# 5) can I use python's collections library? (yes)
+
+# solution 1: use Set
+def remove_duplicates_1(string):
+    uniques = list(set(string))
+    lst = list(string)
+    for i in range(len(lst)):
+        char = lst[i]
+        if char in uniques:
+            uniques.remove(char)
+        else:
+            lst[i] = ''
+    return ''.join(lst)
+    
+# solution 2: use OrderedDict
+from collections import OrderedDict
+def remove_duplicates_2(string):
+    return ''.join(OrderedDict.fromkeys(string))
+ 
+    
+# solution 3: scan from the beginning, remove all duplicates of index - O(n^2)
+def remove_duplicates_3(string):
+    lst = list(string)
+    for i in range(len(lst)-1):
+        char = lst[i]
+        for j in range(i+1,len(lst)):
+            if lst[j] == char:
+                lst[j] = ''
+    return ''.join(lst)
+
+# solution 4: if order does not matter, use Set
+def remove_duplicates_4(string):  
+    return ''.join(set(string))
+
+
+# solution 5: if order does not matter (cannot use Set):
+# 1) merge sort O(nlogn)
+# 2) remove duplicates O(n)
+def remove_duplicates_5(string):  
+    lst = list(string)
+    lst.sort()
+    cur = None
+    for i in range(len(lst)):
+        if lst[i] != cur:
+            cur = lst[i]
+        else:
+            lst[i] = ''
+    return ''.join(lst)
+    
+      
+if __name__ == '__main__':
+    print remove_duplicates_5('abdcda')
+    print remove_duplicates_5('ab')
+    print remove_duplicates_5('aa')
+    print remove_duplicates_5('a') 
+    print remove_duplicates_5('')
+    
+    
+    

Cracking_the_coding_interview/19.1_swap_numbers_in_space.py

@@ -0,0 +1,21 @@
+'''
+19.1
+Write a function to swap two numbers in place without temporary variables.
+
+'''
+def foo(a,b):
+    a +=b
+    b = a-b
+    a -= b
+    return a,b
+
+    
+def foo2(a,b):
+    a = a^b
+    b = a^b
+    a = a^b
+    return a,b
+    
+if __name__ == '__main__': 
+    print foo(10,19)
+    print foo2(10,19)

Cracking_the_coding_interview/2.1_remove_duplicates_from_linked_list.py

@@ -0,0 +1,124 @@
+'''
+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 questions:
+# 1) what's the return value (assume no return value)
+# 2) the input is the head node.
+
+class Node:
+    def __init__(self,data,next):
+        self.data = data
+        self.next = next
+
+# solution 1: if can use a buffer, store key in a dictionary
+def removeDuplicate_hash(node):
+	if node == None:
+		return
+
+	hash_table = [node.data]
+
+    
+  	pre = node
+	cur = node
+	while cur.next != None:
+		cur = cur.next
+		if cur.data in hash_table:
+			pre.next = cur.next
+			cur.next = None
+			cur = pre
+		else:
+			hash_table.append(cur.data)
+			pre = cur
+
+
+
+
+# solution 2: cannot use a buffer, scan from the head, remove duplicates after        
+def removeDuplicate(node):
+    if node == None:
+        return
+    
+    val = node.data
+    
+    cur = node
+    pre = node
+    while cur.next != None:
+        cur = cur.next
+        if cur.data == val:
+            pre.next = cur.next
+            cur.next = None
+            cur = pre
+        else:
+            pre = cur
+            
+    if node.next != None:        
+        removeDuplicate(node.next)
+      
+if __name__ == '__main__':
+    print '\nTest case 1: 4 -> 8 -> 2-> 4'
+    node4 = Node(4,None)
+    node3 = Node(2,node4)
+    node2 = Node(8,node3)
+    node1 = Node(4,node2)
+    removeDuplicate(node1)
+    while True:
+        print node1.data
+        if node1.next==None:break
+        node1 = node1.next 
+        
+    print '\nTest case 2: 4 -> 4'
+    node2 = Node(4,None)
+    node1 = Node(4,node2)
+    removeDuplicate(node1)
+    while True:
+        print node1.data
+        if node1.next==None:break
+        node1 = node1.next
+        
+    print '\nTest case 3: 4'
+    node1 = Node(4,None)
+    removeDuplicate(node1)
+    while True:
+        print node1.data
+        if node1.next==None:break
+        node1 = node1.next
+        
+    print '\nTest case 4: None'
+    node1 = None
+    print removeDuplicate(node1)
+    
+    print '\nTest case 5: 4 -> 2 -> 2-> 4'
+    node4 = Node(4,None)
+    node3 = Node(2,node4)
+    node2 = Node(2,node3)
+    node1 = Node(4,node2)
+    removeDuplicate(node1)
+    while True:
+        print node1.data
+        if node1.next==None:break
+        node1 = node1.next 
+        
+        
+    print '\nTest case 6: 4 -> 2 -> 3-> 4 -> 8 -> 6 -> 6 -> 2'
+    node8 = Node(2,None)
+    node7 = Node(6,node8)
+    node6 = Node(6,node7)
+    node5 = Node(8,node6)
+    node4 = Node(4,node5)
+    node3 = Node(3,node4)
+    node2 = Node(2,node3)
+    node1 = Node(4,node2)
+    removeDuplicate_hash(node1)
+    while True:
+        print node1.data
+        if node1.next==None:break
+        node1 = node1.next 
+    
+    
+    
+    
+    
+    
+    

Cracking_the_coding_interview/2.2_find_the_nth_last_element_from_link_list.py

@@ -0,0 +1,56 @@
+#!/usr/bin/python
+'''
+Implement an algorithm to fnd the nth to last element of a singly linked list.
+
+assume n is valid (will not exceed the length of the list)
+'''
+
+# clarification questions:
+# 1) what's the return value (assume no return value)
+# 2) the input is the head node.
+
+class Node:
+    def __init__(self,data,next):
+        self.data = data
+        self.next = next
+
+# 1,2,3,4,5,6,7
+# n=3, goal = 5
+# 1,4
+# 5, None
+def foo(node,n):
+    pt1 = node
+    pt2 = node
+    for i in range(n):
+        pt2 = pt2.next
+    while pt2 != None:
+        pt1 = pt1.next
+        pt2 = pt2.next
+    return pt1
+        
+        
+if __name__ == '__main__':
+         
+    print '\nTest case 6: 4 -> 2 -> 3-> 4 -> 8 -> 6 -> 6 -> 2'
+    node8 = Node(2,None)
+    node7 = Node(6,node8)
+    node6 = Node(6,node7)
+    node5 = Node(8,node6)
+    node4 = Node(4,node5)
+    node3 = Node(3,node4)
+    node2 = Node(2,node3)
+    node1 = Node(4,node2)
+    print foo(node1,3).data
+    print foo(node1,1).data
+    print foo(node1,8).data
+    '''while True:
+        print node1.data
+        if node1.next==None:break
+        node1 = node1.next '''
+    
+    
+    
+    
+    
+    
+