+
+You'll build a simple, undirected, unweighted graph implementation using an adjacency list. The focus is on understanding how to store and manipulate graph relationships. For simplicity, you may assume that the values of each vertex are unique in the graph.
+
+Build a `Graph` class (or factory) to represent your graph. For now, it should only include storage for an `adjacencyList`. Then proceed to create the following methods:
+
+1. `addVertex(value)`: Adds `value` to the adjacency list. Does nothing if `value` is already in the graph.
+
+
+
+ #### An important graph invariant
+
+ The number of entries in the adjacency list should always be the same as the number of vertices in the graph.
+
+
+
+1. `addEdge(value1, value2)`: Creates an edge between the two vertices `value1` and `value2`. If either `value1` or `value2` are not in the graph, creates a vertex for them before creating the edge. Remember that our graph is *simple*, *undirected*, and *unweighted*, so you must take this into consideration.
+1. `toString()`: Returns a string that represents the underlying adjacency list. You can use this to print the graph and inspect its state. The string representation should look something like this:
+
+ ```text
+ X -> ( Y, Z )
+ Y -> ( X )
+ Z -> ( X )
+ ```
+
+1. `hasVertex(value)`: Returns `true` if the graph contains the vertex `value`. Returns `false` if the graph does not contain `value`.
+1. `areAdjacent(value1, value2)`: Returns `true` if the vertices `value1` and `value2` are adjacent. Returns `false` if they are not adjacent. Recall that two vertices are adjacent if they are connected by an edge.
+1. `removeVertex(value)`: Removes the vertex `value` from the adjacency list. Any edges that were connected to this vertex should be removed as well. Does nothing if `value` is not in the graph.
+1. `removeEdge(value1, value2)`: Removes an edge between the vertices `value1` and `value2`. Does nothing if either `value1` or `value2` are not in the graph.
+1. `getOrder()`: Returns a number that represents the order of the graph. This is the number of vertices in the graph.
+1. `getSize()`: Returns a number that represents the size of the graph. This is the number of edges in the graph.
+1. `getDegree(value)`: Returns a number that represents the degree of the vertex `value`. If `value` is not in the graph, return `undefined`. The degree of a vertex is the number of edges that are connected to that vertex.
+1. `getNeighbors(value)`: Returns an array of all the vertices that are adjacent to the vertex `value`. If `value` is not in the graph, return `undefined`.
+1. `getCommonNeighbors(value1, value2)`: Returns an array of all the vertices that are adjacent to both of the vertices `value1` and `value2`. If either `value1` or `value2` are not in the graph, return `undefined`.
+
+#### Test Your Graph
+
+1. Create a new JavaScript file. Import your `Graph` class or factory.
+1. Create a new instance of your graph.
+
+ ```javascript
+ const graph = new Graph() // or Graph() if using a factory
+ ```
+
+1. Populate your graph using the `addVertex(value)` and `addEdge(value1, value2)` methods by copying the following:
+
+ ```javascript
+ // Add some vertices
+ graph.addVertex("A")
+ graph.addVertex("B")
+ graph.addVertex("C")
+ graph.addVertex("D")
+
+ // Add some edges
+ graph.addEdge("A", "B")
+ graph.addEdge("B", "C")
+ graph.addEdge("A", "C")
+ graph.addEdge("C", "D")
+ ```
+
+
+
+ #### A vertex can be anything
+
+ We're using letters as the vertices here, but they could be anything we wanted. We could be using strings, numbers, or even a custom `Vertex` class or factory.
+
+
+
+1. Now you have your graph populated, try out a few of the methods by copying the following:
+
+ ```javascript
+ console.log(graph.toString())
+ // The list should now look like this:
+ // A -> ( B, C )
+ // B -> ( A, C )
+ // C -> ( A, B, D )
+ // D -> ( C )
+
+ console.log(graph.getOrder()) // Should log 4
+ console.log(graph.getSize()) // Should log 4
+
+ graph.removeEdge('C', 'B')
+ console.log(graph.getSize()) // Should log 3
+
+ console.log(graph.getNeighbors('A')) // Should log ['B', 'C']
+ console.log(graph.getCommonNeighbors('A', 'D')) // Should log ['C']
+ console.log(graph.getCommonNeighbors('A', 'B')) // Should log []
+ ```
+
+1. Lastly, experiment with different combinations of all the methods you have in your graph! Make sure everything is working as you expect it to.
+
+
+
+You'll build a simple, undirected, unweighted graph implementation using an adjacency list. The focus is on understanding how to store and manipulate graph relationships. For simplicity, you may assume that the values of each vertex are unique in the graph.
+
+Build a `Graph` class to represent your graph. For now, it should only include storage for an `@adjacency_list`. Then proceed to create the following methods:
+
+1. `add_vertex(value)`: Adds `value` to the adjacency list. Does nothing if `value` is already in the graph.
+
+
+
+ #### An important graph invariant
+
+ The number of entries in the adjacency list should always be the same as the number of vertices in the graph.
+
+
+
+1. `add_edge(value1, value2)`: Creates an edge between the two vertices `value1` and `value2`. If either `value1` or `value2` are not in the graph, creates a vertex for them before creating the edge. Remember that our graph is *simple*, *undirected*, and *unweighted*, so you must take this into consideration.
+1. `to_s`: Returns a string that represents the underlying adjacency list. You can use this to print the graph and inspect its state. The string representation should look something like this:
+
+ ```text
+ X -> ( Y, Z )
+ Y -> ( X )
+ Z -> ( X )
+ ```
+
+1. `vertex?(value)`: Returns `true` if the graph contains the vertex `value`. Returns `false` if the graph does not contain `value`.
+1. `adjacent?(value1, value2)`: Returns `true` if the vertices `value1` and `value2` are adjacent. Returns `false` if they are not adjacent. Recall that two vertices are adjacent if they are connected by an edge.
+1. `remove_vertex(value)`: Removes the vertex `value` from the adjacency list. Any edges that were connected to this vertex should be removed as well. Does nothing if `value` is not in the graph.
+1. `remove_edge(value1, value2)`: Removes an edge between the vertices `value1` and `value2`. Does nothing if either `value1` or `value2` are not in the graph.
+1. `order`: Returns a number that represents the order of the graph. This is the number of vertices in the graph.
+1. `size`: Returns a number that represents the size of the graph. This is the number of edges in the graph.
+1. `degree(value)`: Returns a number that represents the degree of the vertex `value`. If `value` is not in the graph, return `nil`. The degree of a vertex is the number of edges that are connected to that vertex.
+1. `neighbors(value)`: Returns an array of all the vertices that are adjacent to the vertex `value`. If `value` is not in the graph, return `nil`.
+1. `common_neighbors(value1, value2)`: Returns an array of all the vertices that are adjacent to both of the vertices `value1` and `value2`. If either `value1` or `value2` are not in the graph, return `nil`.
+
+#### Test Your Graph
+
+1. Create a new Ruby file. `require_relative` your `Graph` class.
+
+1. Create a new instance of your graph.
+
+ ```ruby
+ graph = Graph.new
+ ```
+
+1. Populate your graph using the `add_vertex(value)` and `add_edge(value1, value2)` methods by copying the following:
+
+ ```ruby
+ # Add some vertices
+ graph.add_vertex("A")
+ graph.add_vertex("B")
+ graph.add_vertex("C")
+ graph.add_vertex("D")
+
+ # Add some edges
+ graph.add_edge("A", "B")
+ graph.add_edge("B", "C")
+ graph.add_edge("A", "C")
+ graph.add_edge("C", "D")
+ ```
+
+
+
+ #### A vertex can be anything
+
+ We're using letters as the vertices here, but they could be anything we wanted. We could be using strings, numbers, or even a custom `Vertex` class or factory.
+
+
+
+1. Now you have your graph populated, try out a few of the methods by copying the following:
+
+ ```ruby
+ puts graph
+ # The list should now look like this:
+ # A -> ( B, C )
+ # B -> ( A, C )
+ # C -> ( A, B, D )
+ # D -> ( C )
+
+ puts graph.order # Should print 4
+ puts graph.size # Should print 4
+
+ graph.remove_edge('C', 'B')
+ puts graph.size # Should print 3
+
+ p graph.neighbors('A') # Should print ['B', 'C']
+ p graph.common_neighbors('A', 'D') # Should print ['C']
+ p graph.common_neighbors('A', 'B') # Should print []
+ ```
+
+1. Lastly, experiment with different combinations of all the methods you have in your graph! Make sure everything is working as you expect it to.
+
+