From fbea5081e883dd3cd1d43e15b508021402401c07 Mon Sep 17 00:00:00 2001
From: dbriksza <dbriksza@gmail.com>
Date: Thu, 19 Mar 2020 12:14:02 -0400
Subject: [PATCH 1/3] day 2 mvp

---
 projects/ancestor/ancestor.py |  54 +++++++++++++++++-
 projects/ancestor/util.py     |  28 +++++++++
 projects/graph/graph.py       | 104 ++++++++++++++++++++++++++++++----
 3 files changed, 173 insertions(+), 13 deletions(-)
 create mode 100644 projects/ancestor/util.py

diff --git a/projects/ancestor/ancestor.py b/projects/ancestor/ancestor.py
index 3bd003098..0a16e65c6 100644
--- a/projects/ancestor/ancestor.py
+++ b/projects/ancestor/ancestor.py
@@ -1,3 +1,55 @@
+from util import Stack, Queue
 
 def earliest_ancestor(ancestors, starting_node):
-    pass
\ No newline at end of file
+
+    q = Queue()
+    visited = set()
+    most_recent = []
+
+
+    if has_parents(ancestors,starting_node) is False:
+        return -1
+
+    q.enqueue(starting_node)
+    while q.size() > 0:
+
+        v = q.dequeue()
+        #print(v)
+        print(f"Current Node {v}")
+
+        if v not in visited:
+            visited.add(v)
+
+            if has_parents(ancestors,v):
+
+                most_recent.clear()
+
+                for parent,child in ancestors:
+                    if child == v:
+                        q.enqueue(parent)
+                        #print(f"queue {parent}")
+                        print(f"queueing {parent} as the parents of {v}")
+
+                        most_recent.append(parent)
+
+
+                print()
+            else:
+                print(f"{v} has no parents\n")
+
+    return min(most_recent)
+
+def has_parents(ancestors,node):
+    children = set()
+    for parent, child in ancestors:
+        children.add(child)
+    if node in children:
+        return True
+    else:
+        return False      
+
+
+# print(earliest_ancestor(test_ancestors,9))
+
+# ancestor = earliest_ancestor(test_ancestors,6)           
+# print(f"The earliest ancestor to the input is {ancestor}")
\ No newline at end of file
diff --git a/projects/ancestor/util.py b/projects/ancestor/util.py
new file mode 100644
index 000000000..f757503fb
--- /dev/null
+++ b/projects/ancestor/util.py
@@ -0,0 +1,28 @@
+
+# Note: This Queue class is sub-optimal. Why?
+class Queue():
+    def __init__(self):
+        self.queue = []
+    def enqueue(self, value):
+        self.queue.append(value)
+    def dequeue(self):
+        if self.size() > 0:
+            return self.queue.pop(0)
+        else:
+            return None
+    def size(self):
+        return len(self.queue)
+
+class Stack():
+    def __init__(self):
+        self.stack = []
+    def push(self, value):
+        self.stack.append(value)
+    def pop(self):
+        if self.size() > 0:
+            return self.stack.pop()
+        else:
+            return None
+    def size(self):
+        return len(self.stack)
+
diff --git a/projects/graph/graph.py b/projects/graph/graph.py
index ec4de9d6e..1af844720 100644
--- a/projects/graph/graph.py
+++ b/projects/graph/graph.py
@@ -13,42 +13,78 @@ def add_vertex(self, vertex_id):
         """
         Add a vertex to the graph.
         """
-        pass  # TODO
+        self.vertices[vertex_id] = set()
 
     def add_edge(self, v1, v2):
         """
         Add a directed edge to the graph.
         """
-        pass  # TODO
+        if v1 in self.vertices and v2 in self.vertices:
+            self.vertices[v1].add(v2)
+        else:
+            raise ValueError('Error: Vertex does not exists')
 
     def get_neighbors(self, vertex_id):
         """
         Get all neighbors (edges) of a vertex.
         """
-        pass  # TODO
+        if vertex_id in self.vertices:
+            return self.vertices[vertex_id]
+        else:
+            return ValueError("Error: Vertex does not exist")
+
 
     def bft(self, starting_vertex):
         """
         Print each vertex in breadth-first order
         beginning from starting_vertex.
         """
-        pass  # TODO
+        q = Queue()
+        q.enqueue(starting_vertex)
+        visited = set()
+        while q.size() > 0:
+            v = q.dequeue()
+            if v not in visited:
+                print(v)
+                visited.add(v)
+                for neighbor in self.get_neighbors(v):
+                    q.enqueue(neighbor) 
 
     def dft(self, starting_vertex):
         """
         Print each vertex in depth-first order
         beginning from starting_vertex.
         """
-        pass  # TODO
+        s = Stack()
+        s.push(starting_vertex)
+        visited = set()
+        while s.size() > 0:
+            v = s.pop()
+            if v not in visited:
+                print(v)
+                visited.add(v)
+                for neighbor in self.get_neighbors(v):
+                    s.push(neighbor)
 
-    def dft_recursive(self, starting_vertex):
+    def dft_recursive(self, starting_vertex, visited = set()):
         """
         Print each vertex in depth-first order
         beginning from starting_vertex.
 
         This should be done using recursion.
         """
-        pass  # TODO
+        visited.add(starting_vertex)
+        print(starting_vertex)
+
+        edges = self.get_neighbors(starting_vertex)
+        if len(edges) == 0:
+            return
+        else:
+            for edge in edges:
+                if edge not in visited:
+                    self.dft_recursive(edge, visited)
+                else:
+                    return
 
     def bfs(self, starting_vertex, destination_vertex):
         """
@@ -56,7 +92,22 @@ def bfs(self, starting_vertex, destination_vertex):
         starting_vertex to destination_vertex in
         breath-first order.
         """
-        pass  # TODO
+        q = Queue()
+        visited = set()
+        q.enqueue([starting_vertex])
+        while q.size() > 0:
+            current_path = q.dequeue()
+            current_node = current_path[-1]
+            if current_node == destination_vertex:
+                return current_path
+            else:
+                if current_node not in visited:
+                    visited.add(current_node)
+                    edges = self.get_neighbors(current_node)
+                    for edge in edges:
+                        path_copy = list(current_path)
+                        path_copy.append(edge)
+                        q.enqueue(path_copy)
 
     def dfs(self, starting_vertex, destination_vertex):
         """
@@ -64,9 +115,24 @@ def dfs(self, starting_vertex, destination_vertex):
         starting_vertex to destination_vertex in
         depth-first order.
         """
-        pass  # TODO
-
-    def dfs_recursive(self, starting_vertex):
+        s = Stack()
+        visited = set()
+        s.push([starting_vertex])
+        while s.size() > 0:
+            current_path = s.pop()
+            current_node = current_path[-1]
+            if current_node == destination_vertex:
+                return current_path
+            else:
+                if current_node not  in visited:
+                    visited.add(current_node)
+                    edges = self.get_neighbors(current_node)
+                    for edge in edges:
+                        path_copy = list(current_path)
+                        path_copy.append(edge)
+                        s.push(path_copy)
+
+    def dfs_recursive(self, starting_vertex, target_value, visited = None, path = None):
         """
         Return a list containing a path from
         starting_vertex to destination_vertex in
@@ -74,7 +140,21 @@ def dfs_recursive(self, starting_vertex):
 
         This should be done using recursion.
         """
-        pass  # TODO
+
+        if visited is None:
+            visited = set()
+        if path is None:
+            path = []
+        visited.add(starting_vertex)
+        path = path + [starting_vertex]
+        if starting_vertex == target_value:
+            return path
+        for child_vert in self.vertices[starting_vertex]:
+            if child_vert not in visited:
+                new_path = self.dfs_recursive(child_vert, target_value, visited, path)
+                if new_path:
+                    return new_path
+        return None
 
 if __name__ == '__main__':
     graph = Graph()  # Instantiate your graph

From 6f9da807e78440a8cad9949a05fe1bb03ba2db95 Mon Sep 17 00:00:00 2001
From: dbriksza <dbriksza@gmail.com>
Date: Sat, 21 Mar 2020 14:54:13 -0400
Subject: [PATCH 2/3] no joy

---
 projects/adventure/adv.py     | 194 ++++++++++++++++++++++++++++++++--
 projects/adventure/util.py    |  28 +++++
 projects/ancestor/ancestor.py |   2 +-
 3 files changed, 213 insertions(+), 11 deletions(-)
 create mode 100644 projects/adventure/util.py

diff --git a/projects/adventure/adv.py b/projects/adventure/adv.py
index 8bc540b5e..ac94debde 100644
--- a/projects/adventure/adv.py
+++ b/projects/adventure/adv.py
@@ -5,6 +5,8 @@
 import random
 from ast import literal_eval
 
+from util import Stack, Queue
+
 # Load world
 world = World()
 
@@ -29,7 +31,179 @@
 # traversal_path = ['n', 'n']
 traversal_path = []
 
-
+room_map = {}
+
+visited = set()
+q = Queue()
+q.enqueue([player.current_room.id])
+
+while len(visited) < 500:
+    visited.add(player.current_room.id)
+
+    possible_moves = list(room_map[player.current_room.id].keys())
+    possible_moves = [x for x in possible_moves if x not in visited]
+    for move in possible_moves:
+        if room_map[move]:
+            continue
+        else:
+            room_map[move] = '?'
+    next_room = random.choice(possible_moves)
+
+    path = q.dequeue()
+    
+    room_map[next_room] = path
+
+        for room in room_map[next_room]:
+            new_path = list(path)
+            new_path.append(room)
+            q.enqueue(new_path)
+
+
+
+
+# def findroute():
+#     player = Player(world.starting_room)
+#     travel_path = []
+#     last_move = None
+#     next_move = None
+#     visited = set()
+#     while len(visited) < 500:
+#         visited.add(player.current_room.id)
+#         possible_moves = player.current_room.get_exits()
+        
+#         if len(possible_moves) > 1:
+#             if last_move == 'n':
+#                 possible_moves.remove('s')
+#                 next_move = random.choice(possible_moves)
+#             if last_move == 's':
+#                 possible_moves.remove('n')
+#                 next_move = random.choice(possible_moves)
+#             if last_move == 'e':
+#                 possible_moves.remove('w')
+#                 next_move = random.choice(possible_moves)
+#             if last_move == 'w':
+#                 possible_moves.remove('e')
+#                 next_move = random.choice(possible_moves)
+#             else:
+#                 next_move = random.choice(possible_moves)
+#         else:
+#             if last_move == 'n':
+#                 next_move = 's'
+#             if last_move == 's':
+#                 next_move = 'n'
+#             if last_move == 'e':
+#                 next_move = 'w'
+#             if last_move == 'w':
+#                 next_move = 'e'
+#         print(f"next Move: {last_move} rooms visited: {len(visited)} current room {player.current_room.id} moves {len(travel_path)}")
+#         travel_path.append(next_move)
+#         player.travel(next_move)
+#         last_move = next_move
+#         if len(travel_path) > 2000:
+#             findroute()
+#             break
+#     return travel_path
+
+# traversal_path = findroute()
+
+# last_move = None
+# next_move = None
+# visited = set()
+# rooms = {}
+# moves_made = {}
+# while len(visited) < 500:
+#     visited.add(player.current_room.id)
+    
+#     rooms[player.current_room.id] = player.current_room.get_exits()
+
+#     possible_moves = player.current_room.get_exits()
+#     if player.current_room.id in moves_made.keys():
+#         for move in moves_made[player.current_room.id]:
+#             possible_moves.remove(move)
+#     next_move = random.choice(possible_moves)
+
+#     if player.current_room.id in moves_made.keys():
+#         moves_made[player.current_room.id].append(next_move)
+#     else:
+#         moves_made[player.current_room.id] = [next_move]
+
+#     possible_moves = rooms[player.current_room.id]
+
+#     print(f"next Move: {last_move} rooms visited: {len(visited)} current room {player.current_room.id} moves {len(traversal_path)}")
+#     traversal_path.append(next_move)
+#     player.travel(next_move)
+#     last_move = next_move
+
+# last_move = None
+# next_move = None
+# visited = set()
+# room_map = {}
+# last_room = None
+# while len(visited) < 500:
+#     visited.add(player.current_room.id)
+#     possible_moves = player.current_room.get_exits()
+    
+#     if len(possible_moves) > 1:
+#         if last_move == 'n': 
+#             possible_moves.remove('s')
+#             next_move = random.choice(possible_moves)
+#         if last_move == 's':
+#             possible_moves.remove('n')
+#             next_move = random.choice(possible_moves)
+#         if last_move == 'e':
+#             possible_moves.remove('w')
+#             next_move = random.choice(possible_moves)
+#         if last_move == 'w':
+#             possible_moves.remove('e')
+#             next_move = random.choice(possible_moves)
+#         else:
+#             next_move = random.choice(possible_moves)
+#     else:
+#         if last_move == 'n':
+#             next_move = 's'
+#         if last_move == 's':
+#             next_move = 'n'
+#         if last_move == 'e':
+#             next_move = 'w'
+#         if last_move == 'w':
+#             next_move = 'e'
+#     if last_room not in room_map:
+#         room_map[last_room] = {}
+#     room_map[last_room][player.current_room.id] = last_move
+#     last_room = player.current_room.id
+#     player.travel(next_move)
+#     last_move = next_move
+
+# player.current_room = world.starting_room
+
+# next_move = None
+# visited = set()
+# last_move = None
+# while len(visited) < 500:
+#     visited.add(player.current_room.id)
+#     possible_moves = player.current_room.get_exits()
+#     if len(possible_moves) > 1:
+#         remove = []
+#         possible_moves = list(room_map[player.current_room.id].keys())
+#         possible_moves = [x for x in possible_moves if x not in visited]
+#         print(possible_moves)
+#         if possible_moves:
+#             next_move = room_map[player.current_room.id][max(possible_moves)]
+#         else:
+#             next_move = room_map[player.current_room.id][min(room_map[player.current_room.id].keys())]
+#     else:
+#         next_move = str(possible_moves[0])
+#     print(f"next Move: {next_move} rooms visited: {len(visited)} current room {player.current_room.id} length {len(traversal_path)}")
+#     last_move = next_move
+#     traversal_path.append(next_move)
+#     player.travel(next_move)
+
+# print(visited)
+
+
+
+# while len(traversal_path) > 2000:
+#     traversal_path = findroute()
 
 # TRAVERSAL TEST
 visited_rooms = set()
@@ -51,12 +225,12 @@
 #######
 # UNCOMMENT TO WALK AROUND
 #######
-player.current_room.print_room_description(player)
-while True:
-    cmds = input("-> ").lower().split(" ")
-    if cmds[0] in ["n", "s", "e", "w"]:
-        player.travel(cmds[0], True)
-    elif cmds[0] == "q":
-        break
-    else:
-        print("I did not understand that command.")
+# player.current_room.print_room_description(player)
+# while True:
+#     cmds = input("-> ").lower().split(" ")
+#     if cmds[0] in ["n", "s", "e", "w"]:
+#         player.travel(cmds[0], True)
+#     elif cmds[0] == "q":
+#         break
+#     else:
+#         print("I did not understand that command.")
diff --git a/projects/adventure/util.py b/projects/adventure/util.py
new file mode 100644
index 000000000..f757503fb
--- /dev/null
+++ b/projects/adventure/util.py
@@ -0,0 +1,28 @@
+
+# Note: This Queue class is sub-optimal. Why?
+class Queue():
+    def __init__(self):
+        self.queue = []
+    def enqueue(self, value):
+        self.queue.append(value)
+    def dequeue(self):
+        if self.size() > 0:
+            return self.queue.pop(0)
+        else:
+            return None
+    def size(self):
+        return len(self.queue)
+
+class Stack():
+    def __init__(self):
+        self.stack = []
+    def push(self, value):
+        self.stack.append(value)
+    def pop(self):
+        if self.size() > 0:
+            return self.stack.pop()
+        else:
+            return None
+    def size(self):
+        return len(self.stack)
+
diff --git a/projects/ancestor/ancestor.py b/projects/ancestor/ancestor.py
index 0a16e65c6..095fcb0f1 100644
--- a/projects/ancestor/ancestor.py
+++ b/projects/ancestor/ancestor.py
@@ -1,4 +1,4 @@
-from util import Stack, Queue
+from util import Stack, Queue  # These may come in handy
 
 def earliest_ancestor(ancestors, starting_node):
 

From 5939c7875824c79b7da63556df847c7a33150392 Mon Sep 17 00:00:00 2001
From: dbriksza <dbriksza@gmail.com>
Date: Mon, 23 Mar 2020 16:57:07 -0400
Subject: [PATCH 3/3] mvp

---
 projects/adventure/adv.py | 102 +++++++++++++++++++++++++++++++-------
 1 file changed, 85 insertions(+), 17 deletions(-)

diff --git a/projects/adventure/adv.py b/projects/adventure/adv.py
index ac94debde..424a72334 100644
--- a/projects/adventure/adv.py
+++ b/projects/adventure/adv.py
@@ -34,29 +34,97 @@
 room_map = {}
 
 visited = set()
-q = Queue()
-q.enqueue([player.current_room.id])
+
 
 while len(visited) < 500:
+    next_move = None
     visited.add(player.current_room.id)
 
-    possible_moves = list(room_map[player.current_room.id].keys())
-    possible_moves = [x for x in possible_moves if x not in visited]
-    for move in possible_moves:
-        if room_map[move]:
-            continue
-        else:
-            room_map[move] = '?'
-    next_room = random.choice(possible_moves)
+    previous_room = player.current_room.id
 
-    path = q.dequeue()
-    
-    room_map[next_room] = path
+    possible_moves = list(player.current_room.get_exits())
 
-        for room in room_map[next_room]:
-            new_path = list(path)
-            new_path.append(room)
-            q.enqueue(new_path)
+    for move in possible_moves:
+        if previous_room not in room_map.keys():
+            room_map[previous_room] = {}
+        try:
+            room_map[previous_room][move] != '?'
+        except KeyError:
+            room_map[previous_room][move] = '?'
+        
+    for move in possible_moves:
+        if room_map[previous_room][move] == '?':
+            next_move = move
+
+    if next_move != None:
+
+        # next_move = random.choice(possible_moves)
+        traversal_path.append(next_move)
+        player.travel(next_move)
+        current_room = player.current_room.id
+        print(f"previous room: {previous_room}, direction: {next_move}, current room: {current_room}")
+        if next_move == 'n':
+            room_map[previous_room]['n'] = current_room
+            if current_room not in room_map.keys():
+                room_map[current_room] = {}
+            room_map[current_room]['s'] = previous_room
+        if next_move == 's':
+            room_map[previous_room]['s'] = current_room
+            if current_room not in room_map.keys():
+                room_map[current_room] = {}
+            room_map[current_room]['n'] = previous_room
+        if next_move == 'e':
+            room_map[previous_room]['e'] = current_room
+            if current_room not in room_map.keys():
+                room_map[current_room] = {}
+            room_map[current_room]['w'] = previous_room
+        if next_move == 'w':
+            room_map[previous_room]['w'] = current_room
+            if current_room not in room_map.keys():
+                room_map[current_room] = {}
+            room_map[current_room]['e'] = previous_room
+        print(f"previous room: {room_map[previous_room]} current room: {room_map[current_room]} visited: {len(visited)}")
+    else:
+        visited_just_now = set()
+        q = Queue()
+        p = Queue()
+        q.enqueue([player.current_room.id])
+        p.enqueue([player.current_room.id])
+        
+        while q.size() > 0:
+
+            rooms = q.dequeue()
+            path = p.dequeue()
+            print(path)
+            print(rooms)
+            current_node = rooms[-1]
+            print(f"current node {current_node}")
+            if '?' in list(room_map[current_node].values()):
+                # path.append(list(room_map[current_node].keys())[list(room_map[current_node].values()).index('?')])
+                print(path)
+                path.pop(0)
+                for move in path:
+                    player.travel(move)
+                    traversal_path.append(move)
+                    prev = move
+                    print(f"direction: {move} current room: {player.current_room.id}")
+                break
+            else:
+                if current_node not in visited_just_now:
+                    visited_just_now.add(current_node)
+                    edges = room_map[current_node].values()
+                for edge in edges:
+                    print(edge)
+                    new_rooms = list(rooms)
+                    new_path = list(path)
+                    new_rooms.append(edge)
+                    try:
+                        new_path.append(list(room_map[current_node].keys())[list(room_map[current_node].values()).index(edge)])
+                        p.enqueue(new_path)
+                    except ValueError:
+                        continue
+                    q.enqueue(new_rooms)
+