exercises

Author: pwgraham91

binary_tree_traversal.py

@@ -169,37 +169,31 @@ def depth_first_search_recursive(search_for):
 
 def breadth_first_search_iterative(search_for):
     iterator = []
-    a_node = build_3_layer_even_tree()
-    print(a_node)
+    a_node = build_4_layer_even_tree()
 
     if _bfs_iterative(search_for, a_node, iterator):
         return True
     return False
 
 
-def add_to_queue(node, iterator):
-    if node.left is not None:
-        iterator.append(node.left)
-    if node.right is not None:
-        iterator.append(node.right)
-
-
-def _bfs_iterative(search_for, node, iterator):
+def _bfs_iterative(search_for, node, queue):
     if node is None:
         return
 
-    # add root
-    iterator.append(node)
+    print(node)
 
-    add_to_queue(node, iterator)
+    # add root
+    queue.append(node)
 
-    while len(search_for) > 0:
-        obj = iterator.pop(0)
+    while queue:
+        obj = queue.pop(0)
         print(obj.value)
         if obj.value == search_for:
             return True
-        else:
-            add_to_queue(obj, iterator)
+        if obj.left is not None:
+            queue.append(obj.left)
+        if obj.right is not None:
+            queue.append(obj.right)
 
 
 def depth_first_iterative(search_for):
@@ -208,15 +202,25 @@ def depth_first_iterative(search_for):
 
     stack = [root]
     while stack:
-        node = stack.pop(0)
+        node = stack.pop()
         print(node.value)
         if node.value == search_for:
             return True
         if node.right is not None:
-            stack.insert(0, node.right)
+            stack.append(node.right)
         if node.left is not None:
-            stack.insert(0, node.left)
+            stack.append(node.left)
     return False
 
+"""
+        ______a______
+       /             \
+    __b__           __c__
+   /     \         /     \
+  d       e       f       g
+ / \     / \     / \     / \
+h   i   j   k   l   m   n   o
+"""
 
 depth_first_iterative('p')
+breadth_first_search_iterative('z')

insert_ads/__init__.py

@@ -0,0 +1,63 @@
+raw = ['Artisan', 'live-edge', 'ugh', 'DIY', 'poutine', 'flexitarian', 'leggings', 'lo-fi', '3', 'wolf', 'moon',
+           'biodiesel', 'ennui', 'kombucha', 'gentrify', 'XOXO', 'health', 'goth.', 'Brunch', 'fixie', 'put', 'a',
+           'bird', 'on', 'it', 'you', 'probably', "haven't", 'heard', 'of', 'them', 'photo', 'booth', 'hell', 'of',
+           'bespoke', 'bicycle', 'rights.', 'Mustache', 'neutra', 'truffaut,', 'DIY', 'hoodie', 'slow-carb', 'pop-up',
+           'man', 'braid', 'pitchfork.', 'Artisan', 'activated', 'charcoal', 'tofu', 'shoreditch,', 'pug', 'readymade',
+           'church-key', '+1', 'iPhone', 'normcore', 'fingerstache', 'keytar', 'truffaut', 'lumbersexual', 'paleo.',
+           'Crucifix', 'austin', 'cred', 'taxidermy', 'truffaut', 'bicycle', 'rights', 'hell', 'of', 'pabst',
+           'activated', 'charcoal.', 'Narwhal', 'forage', 'letterpress', 'paleo', 'gentrify', 'la', 'croix', 'synth',
+           'freegan', 'bespoke', 'keytar.', 'Dreamcatcher', 'bespoke', 'bushwick', 'listicle', 'lomo.']
+
+added_content = ['Kombucha', 'pop-up', 'blog', 'bitters', 'quinoa', 'blue', 'bottle', 'intelligentsia', 'flexitarian',
+                 'copper', 'mug', 'pour-over', 'messenger', 'bag', "90's", 'neutra', 'lomo.', 'Hella', "90's",
+                 'everyday', 'carry', 'mlkshk', 'scenester', 'four', 'dollar', 'toast', 'live-edge', 'cliche', 'wolf',
+                 'truffaut', 'cronut', 'ramps', 'succulents.', 'Slow-carb', 'fam', 'blue', 'bottle', 'adaptogen',
+                 'hammock', 'shoreditch.', 'Pour-over', 'fingerstache', 'mlkshk', 'tofu', 'normcore.', 'Tote', 'bag',
+                 'four', 'dollar', 'toast', 'lumbersexual', 'raw', 'denim', 'venmo', 'kickstarter', 'fixie',
+                 'stumptown', 'letterpress', 'locavore', 'echo', 'park', 'unicorn.', 'Forage', 'cardigan', 'tote',
+                 'bag', 'mlkshk.', 'Unicorn', 'la', 'croix', 'kickstarter', 'coloring', 'book', 'ugh', 'tilde',
+                 'sourdough', 'starter.']
+
+
+""" 
+Part 1: We have a list of content and we want to inject ads after the 3rd piece of content and then after every 4 
+pieces.
+
+Part 2: We have 20 more pieces of content to add to the list and there should be ads between every 4 of them as a 
+continuation of the previous list.
+"""
+def evenly_ad_ads(content_with_ads, content_without_ads, start_ad_index, ad_interval):
+    # add one to make it so ads go after the interval instead of on the interval
+    ad_interval = ad_interval + 1
+
+    content_length = len(content_without_ads)
+    content_counter = 0
+
+    # iterate through the list and add either an AD or content until there is no more content to add
+    while content_counter < content_length:
+        content_with_ads_size = len(content_with_ads)
+        if content_with_ads_size == start_ad_index or (content_with_ads_size - start_ad_index) % ad_interval == 0:
+            content_with_ads.append("AD!")
+        else:
+            content_with_ads.append(content_without_ads[content_counter])
+            content_counter += 1
+
+    return content_with_ads
+
+"""
+what if we need to insert content into the middle of the list
+"""
+def insert_content(content_with_ads, inserted_content, insert_index, start_ad_index, ad_interval):
+    # divide the list at the spot of insertion. Everything before the insertion spot should stay the same.
+    content_with_ads_left = content_with_ads[:insert_index]
+    content_with_ads_right = content_with_ads[insert_index:]
+    # remove all of the ads after the insertion and re-add the ads after insertion
+    content_without_ads_right = list(filter(lambda x: x != 'AD!', content_with_ads_right))
+    inserted_content.extend(content_without_ads_right)
+
+    return evenly_ad_ads(content_with_ads_left, inserted_content, start_ad_index, ad_interval)
+
+
+
+parts_1_2 = evenly_ad_ads(evenly_ad_ads([], raw, 3, 4), added_content, 3, 4)
+inserted_list = insert_content(parts_1_2, ["INSERT1", "INSERT2", "INSERT3", "INSERT4"], 1, 3, 4)

insert_ads/exercise.py

@@ -0,0 +1,33 @@
+from linked_lists import LinkedList
+
+""" determine if any combination of the linked list is a palindrome """
+
+def is_any_combo_ll_palindrome(linked_list):
+    num_letters = 0
+    unaccounted_letters = set()
+    while linked_list is not None:
+        num_letters += 1
+        current_value = linked_list.val
+        if current_value in unaccounted_letters:
+            unaccounted_letters.remove(current_value)
+        else:
+            unaccounted_letters.add(current_value)
+        linked_list = linked_list.next
+    if num_letters % 2 == 0:
+        return len(unaccounted_letters) == 0
+    else:
+        return len(unaccounted_letters) == 1
+
+a = LinkedList("c")
+b = LinkedList("i")
+c = LinkedList("v")
+d = LinkedList("i")
+b2 = LinkedList("c")
+# e = LinkedList("f")
+a.insert(b)
+b.insert(c)
+c.insert(d)
+d.insert(b2)
+# b2.insert(e)
+
+print(is_any_combo_ll_palindrome(a) is True)

linked_list_any_combo_palindrome.py

@@ -0,0 +1,55 @@
+""" the 2 linked lists given each represent a number where each digit is a node in the linked list in reverse order.
+ Add the two numbers.
+ ex: 4->2->8 = 824
+ +
+     2->3->1 = 132
+ =             956
+ """
+from linked_lists import LinkedList
+
+
+def add_digits(n1, n2):
+    n1_current_node = n1
+    n2_current_node = n2
+    sum_linked_list = None
+    carryover = 0
+    while n1_current_node is not None or n2_current_node is not None:
+        digit_sum = carryover
+        carryover = 0
+        if n1_current_node is not None:
+            digit_sum += n1_current_node.val
+            n1_current_node = n1_current_node.next
+        if n2_current_node is not None:
+            digit_sum += n2_current_node.val
+            n2_current_node = n2_current_node.next
+        if digit_sum >= 10:
+            carryover = 1
+            digit_sum -= 10
+
+        next_link = LinkedList(digit_sum)
+        next_link.next = sum_linked_list
+        sum_linked_list = next_link
+
+    concat_num = []
+    if carryover == 1:
+        concat_num.append(1)
+
+    while sum_linked_list is not None:
+        concat_num.append(sum_linked_list.val)
+        sum_linked_list = sum_linked_list.next
+    return int("".join([str(i) for i in concat_num]))
+
+a = LinkedList(4)
+b = LinkedList(2)
+c = LinkedList(8)
+a.insert(b)
+b.insert(c)
+
+
+a2 = LinkedList(2)
+b2 = LinkedList(3)
+c2 = LinkedList(3)
+a2.insert(b2)
+b2.insert(c2)
+
+print(add_digits(a, a2) == 1156)

linked_list_digit_notification.py

@@ -0,0 +1,56 @@
+""" find the kth to last element in a singly linked list """
+import queue
+
+from linked_lists import LinkedList
+
+
+""" 
+time: n
+space: k
+"""
+def find_kth_last(head, k):
+    counter = 0
+    q = queue.Queue()
+    current = head
+    while True:
+        counter += 1
+        if current is None:
+            break
+        q.put(current)
+        if counter > k:
+            q.get()
+        current = current.next
+    return q.get().val
+
+
+"""
+time: n
+space: 1 
+"""
+def find_kth_last_two_pointers(head, k):
+    slow_pointer = head
+    fast_pointer = head
+
+    for i in range(k):
+        fast_pointer = fast_pointer.next
+
+    while True:
+        if fast_pointer is None:
+            return slow_pointer.val
+        slow_pointer = slow_pointer.next
+        fast_pointer = fast_pointer.next
+
+
+a = LinkedList("a")
+b = LinkedList("b")
+c = LinkedList("c")
+d = LinkedList("d")
+b2 = LinkedList("e")
+e = LinkedList("f")
+a.insert(b)
+b.insert(c)
+c.insert(d)
+d.insert(b2)
+b2.insert(e)
+
+find_kth_last_two_pointers(a, 3)

linked_list_kth_to_last.py

@@ -0,0 +1,22 @@
+""" determine if the linked list is a palindrome """
+from linked_lists import LinkedList
+
+
+def is_palindrome(linked_list):
+    pass
+
+
+a = LinkedList("c")
+b = LinkedList("i")
+c = LinkedList("v")
+d = LinkedList("i")
+b2 = LinkedList("c")
+# e = LinkedList("f")
+a.insert(b)
+b.insert(c)
+c.insert(d)
+d.insert(b2)
+# b2.insert(e)
+
+print(is_palindrome(a) is True)
+

linked_list_palindrome.py

@@ -0,0 +1,54 @@
+""" remove duplicates from linked list """
+from linked_lists import LinkedList
+
+""" time: n
+ space: n
+ """
+def rm_duplicates(head):
+    seen_values = set(head.val)
+    current = head
+    while True:
+        current = current.next
+        if current is None:
+            break
+        if current.val in seen_values:
+            current.prev.next = current.next
+        else:
+            seen_values.add(current.val)
+
+"""
+time: n^2
+space: 1
+"""
+def rm_duplicates_space(head):
+    current = head
+    breaker_one = True
+    while breaker_one:
+        if current is None:
+            break
+        breaker_two = True
+        tracer_two = current.next
+        while breaker_two:
+            if tracer_two is None:
+                break
+            if current.val == tracer_two.val:
+                tracer_two.prev.next = tracer_two.next
+            tracer_two = tracer_two.next
+        current = current.next
+
+
+a = LinkedList("a")
+b = LinkedList("b")
+c = LinkedList("c")
+d = LinkedList("d")
+b2 = LinkedList("b")
+e = LinkedList("e")
+a.insert(b)
+b.insert(c)
+c.insert(d)
+d.insert(b2)
+b2.insert(e)
+
+rm_duplicates_space(a)
+a = 1
+

linked_list_remove_duplicates.py

@@ -32,8 +32,3 @@ def find_continue(link, value):
 
 def search(head, value):
     return find_continue(head, value)
-
-
-head = add_links()
-print_to_end(head)
-c = search(head, 'c')