Completed Exercises

PC-coding · PC-coding · commit 72e4dce27070 · 2020-08-18T11:31:58.000-04:00
diff --git a/algorithms/graph_traversal/1_count_edges_matrix/solution/.model_solution.py b/algorithms/graph_traversal/1_count_edges_matrix/solution/.model_solution.py
@@ -1,2 +1,6 @@
 def count_edges(matrix):
-    return
+    edge_count = 0
+    for i in range(len(matrix)):
+        for j in range(len(matrix[i])):
+            edge_count += matrix[i][j]
+    return edge_count
diff --git a/algorithms/graph_traversal/1_count_islands_list/solution/solution.py b/algorithms/graph_traversal/1_count_islands_list/solution/solution.py
@@ -1,2 +1,28 @@
 def count_islands(adjacency_list):
-    return
+    dictionary_count_edges = dict.fromkeys(adjacency_list.keys(), 0)
+    for adj_keyNode, edge_list in adjacency_list.items():
+        for keyNode in dictionary_count_edges.keys():
+            if not adj_keyNode == keyNode:
+                if keyNode in edge_list:
+                    dictionary_count_edges[keyNode] += 1
+    number_of_Islands = 0
+    for edgeCount in dictionary_count_edges.values():
+        if edgeCount == 0:
+            number_of_Islands += 1
+    return number_of_Islands
+
+#adjacency_list = { 0: [1], 1: [0, 1, 2], 2: []}
+
+# dictionary_count_edges -> assigns every key:value pair to 0
+
+#dictionary_count_edges = {0:0, 1:0, 2: 0}
+#for every key and list in adjacency_list
+#0 : [1]
+#1 : [0, 1, 2]
+#2 : []
+
+#dictionary_count_edges = {0:2, 1:1, 2:1}
+# for every key in dictionary_count_edges
+# 0 -> in 0 and 1 so increment by 2
+# 1 -> in 0 so increment by 1
+# 2 -> in 1 so increment by 1
diff --git a/algorithms/graph_traversal/1_list_to_matrix_representation/solution/solution.py b/algorithms/graph_traversal/1_list_to_matrix_representation/solution/solution.py
@@ -1 +1,7 @@
-adjacency_matrix = []
+adjacency_matrix = [
+    [1, 1, 0, 1, 0],
+    [0, 0, 0, 1, 1],
+    [0, 1, 0, 0, 0],
+    [1, 0, 1, 0, 0],
+    [0, 0, 0, 0, 0],
+]
diff --git a/algorithms/graph_traversal/1_matrix_to_list_representation/solution/solution.py b/algorithms/graph_traversal/1_matrix_to_list_representation/solution/solution.py
@@ -1 +1,6 @@
-adjacency_list = {}
+adjacency_list = {
+    0: [1,2,3],
+    1: [0,3],
+    2: [1],
+    3: [0,3]
+}
diff --git a/algorithms/graph_traversal/2_defining_a_graph_list/solution/solution.py b/algorithms/graph_traversal/2_defining_a_graph_list/solution/solution.py
@@ -1 +1,6 @@
-adjacency_list = {}
+adjacency_list = {
+    0: [], 
+    1: [2], 
+    2: [1, 3], 
+    3: [1]
+}
diff --git a/algorithms/graph_traversal/2_defining_a_graph_matrix/solution/solution.py b/algorithms/graph_traversal/2_defining_a_graph_matrix/solution/solution.py
@@ -1 +1,5 @@
-adjacency_matrix = []
+adjacency_matrix = [
+    [0, 1, 0],
+    [1, 0, 1],
+    [0, 1, 0]
+]
diff --git a/algorithms/graph_traversal/2_most_neighbors/solution/solution.py b/algorithms/graph_traversal/2_most_neighbors/solution/solution.py
@@ -1,2 +1,11 @@
 def most_neighbours(adjacency_list):
-    return
+    maximum_len = -1
+    maximum_key = -1
+    for keyNode, edge_list in adjacency_list.items():
+        number_of_neighbours = len(edge_list)
+        if number_of_neighbours > maximum_len:
+            maximum_key = keyNode
+            maximum_len = number_of_neighbours
+        elif number_of_neighbours == maximum_len and keyNode < maximum_key:
+            maximum_key = keyNode
+    return maximum_key
diff --git a/algorithms/graph_traversal/2_num_hops_away_list/solution/solution.py b/algorithms/graph_traversal/2_num_hops_away_list/solution/solution.py
@@ -1,2 +1,14 @@
 def hops_away(adjacency_list, node, num_hops):
-    return
+    if not node in adjacency_list.keys():
+        return []
+    elif num_hops == 0:
+        return [node]
+    else:
+        number_hops_away = []
+        for neighbour in adjacency_list[node]:
+            number_hops_away.extend(hops_away(adjacency_list, neighbour, num_hops-1))
+        number_hops_away_1 = []
+        for n in number_hops_away:
+            if not n in number_hops_away_1:
+                number_hops_away_1.append(n)
+        return number_hops_away_1
diff --git a/algorithms/graph_traversal/3_depth_first_search_matrix/solution/solution.py b/algorithms/graph_traversal/3_depth_first_search_matrix/solution/solution.py
@@ -1,2 +1,28 @@
 def exists_path(matrix, origin, destination):
-    return
+    def exists_path_visited(matrix, origin, destination, visited):
+        if origin in visited:
+            return False
+        if not (origin in range(len(matrix)) and 
+                destination in range(len(matrix))):
+                return False
+        elif matrix[origin][destination] == 1:
+            return True
+        visited.append(origin)
+        for j in range(len(matrix[origin])):
+            if matrix[origin][j] == 1 and exists_path_visited(matrix, j, destination, visited):
+                return True
+        return False
+    return exists_path_visited(matrix, origin, destination, [])
+
+# matrix = [ [0, 1, 0], [0, 0, 1], [0, 1, 0] ]
+
+# exists_path(matrix, 0, 2) => True
+
+# exists_path_visited(matrix, 0, 2, [])
+
+# visited = [0]
+# for j = 0, 1, 2
+#                     matrix, j, destination, visitedlist
+# exists_path_visited(matrix, 1, 2, [0])
+
+#matrix[1][2] == 1, so we would return True
diff --git a/algorithms/graph_traversal/3_num_components/solution/solution.py b/algorithms/graph_traversal/3_num_components/solution/solution.py
@@ -1,2 +1,32 @@
+def reachable_dict(matrix):
+    reachable_dict = {}
+    for i in range(len(matrix)):
+        reachable_lst = []
+        for j in range(len(matrix[i])):
+            if matrix[i][j] == 1:
+                reachable_lst.append(j)
+        reachable_dict[i] = reachable_lst
+#getting every key that's directly reachable and putting it into a list
+    all_reachable = {}
+    for i, neighbours in reachable_dict.items():
+        all_reachable_lst = []
+        for n in neighbours:
+            all_reachable_lst = all_reachable_lst + reachable_dict[n]
+            all_reachable_lst = all_reachable_lst + [n]
+        all_reachable[i] = all_reachable_lst
+    return all_reachable
+#getting every key that's neighbors of the directly reachables and putting it into a list
+
 def num_components(adjacency_matrix):
-    return
+    reachableDict = reachable_dict(adjacency_matrix)
+    num_components = 0
+    visited = [False for i in range(len(adjacency_matrix))]
+    for i in range(len(adjacency_matrix)):
+        if visited[i] == False:
+            num_components += 1
+            for j in reachableDict[i]:
+                visited[j] = True
+    return num_components
+
+# visited [False, False, False, False]
+# visited []
