Test adding code snapshots using Carbon

Author: cormacpayne

binary-search/binary-search.md

@@ -77,24 +77,7 @@ Now that we have the three possible scenarios handled, we just need to define wh
 
 We want to keep searching while we have some range of numbers to check, so if `lo` ever becomes greater than `hi`, then our target value is not in the array due to the fact that we have run out of numbers to check.
 
-```java
-int lo = 0;
-int hi = N-1;
-
-while (lo <= hi)
-{
-  mid = lo + (hi -lo) / 2;
-  
-  if (array[mid] == targetValue)
-      break;
-  
-  if (array[mid] < targetValue)
-      lo = mid + 1;
-  
-  if (array[mid] > targetValue)
-      hi = mid - 1;
-}
-```
+![binary-search](..\resources\binary-search.png)
 
 ## Problems
 

graph-theory/introduction/introduction.md

@@ -53,32 +53,11 @@ There are many ways to use an adjacency matrix to represent a matrix, but we wil
 
 #### Connection matrix
 
-```java
-boolean[][] conn = new boolean[ N ][ N ];
-```
-
-The matrix `conn` tells us if two vertices are connected
-
-```java
-if ( conn[ i ][ j ] )
-    // there is an edge from vertex i to vertex j
-
-else
-    // there is no edge from vertex i to vertex j
-```
+![graph-theory-introduction-1](..\..\resources\graph-theory-introduction-1.png)
 
 #### Cost matrix
 
-```java
-int[][] cost = new int[ N ][ N ];
-```
-
-The matrix `cost` tells us the cost (or edge weight) between two vertices
-
-```java
-cost[ i ][ j ] = 7; // this means it costs 7 units to travel from vertex i to vertex j
-cost[ i ][ j ] = 0; // this usually means there is no edge from vertiex i to vertex j
-```
+![graph-theory-introduction-2](..\..\resources\graph-theory-introduction-2.png)
 
 #### Pros and Cons
 
@@ -96,19 +75,7 @@ Rather than making space for all _N_ x _N_ possible edge connections, an _adjace
 
 We are able to do this by creating an array that contains `ArrayLists` holding the values of the vertices that a vertex is connected to.
 
-```java
-ArrayList<Integer>[] graph = new ArrayList<Integer>[ N + 1 ];
-
-// For each vertex, we need to initialize the list of vertices the vertex has a connection to
-for ( int i = 0; i <= N; i++ )
-{
-    graph[ i ] = new ArrayList<Integer>();
-}
-
-graph[ i ].add( j ); // get the list of vertices for vertex i and add a connection to vertex j
-
-ArrayList<Integer> neighbors = graph[ k ]; // get the list of vertices that vertex k is connected to
-```
+![graph-theory-introduction-3](..\..\resources\graph-theory-introduction-3.png)
 
 #### Pros and  Cons
 

graph-theory/shortest-path/dijkstras-algorithm/dijkstras-algorithm.md

@@ -53,114 +53,15 @@ There are several ways to implement this algorithm
 
 #### Using an array
 
-```java
-// This array will keep track of the tentative distance up to each vertex
-int[] distance = new int[ N ];
-// This array will tell us if we have visited a vertex or not
-boolean[] visited = new boolean[ N ];
-
-// Mark the tentative distance of the starting vertex as zero
-distance[ start ] = 0;
-// Set the current vertex as the starting vertex
-int current = start;
-
-// While we have not reached our destination...
-while ( !visited[ destination ] )
-{
-    // Mark the current vertex as visited
-    visited[ current ] = true;
-    // Get the neighboring vertices of the current vertex
-    ArrayList<Integer> neighbors = graph[ current ];
-    
-    // For each of the neighbors of the current vertex...
-    for ( int neighbor : neighbors )
-    {
-        // Calculate the new distance to the neighbor
-        // This can be calculated by taking the tentative distance up to the current vertex and adding the
-        // cost to go from the current vertex to the neighbor
-        int newDistance = distances[ current ] + costs[ current ][ neighbor ];
-        
-        // If this new distance we calculated is smaller than the current tentative distance of the neighbor...
-        if ( newDistance < distances[ neighbor ] )
-        {
-            // Update the tentative distance of the neighbor with this new distance
-            distances[ neighbor ] = newDistance;
-        }
-    }
-    
-    // We now need to calculate the new current vertex, which will be the vertex with the smallest tentative
-    // distance that we have yet to visit in the graph
-    
-    // This will keep track of the next vertex that we will set as the current vertex
-    int index = -1;
-    // This will keep track of the minimum tentative distance of the next current vertex
-    int min = Integer.MAX_VALUE;
-    
-    // For each of the vertices in the graph...
-    for ( int j = 0; j < N; j++ )
-    {
-        // If we have not visited the vertex and the tentative distance of the vertex is smaller than our current min...
-        if ( !visited[ j ] && distances[ j ] < min )
-        {
-            // Update the index with the vertex
-            index = j;
-            // Update the min distance value
-            min = distances[ j ];
-        }
-    }
-    
-
-// If we were unable to find another vertex to visit...
-    if ( index == -1 )
-    {
-        // Break out of the loop
-        break;
-    }
-    
-    // Update the current vertex
-    current = index;
-}
-```
+![graph-theory-dijkstras-algorithm-1](..\..\..\resources\graph-theory-dijkstras-algorithm-1.png)
 
 #### Using a priority queue
 
 Remember that as you add items to a priority queue, they are automatically sorted within the queue, so that you are given the "smallest" item when you remove it from the queue.
 
 First, we need to define our `Vertex` class and what attributes it will contain.
 
-```java
-// In order for the Vertex class to be sortable, we need to implement the Comparable interface
-class Vertex implements Comparable<Vertex>
-{
-    // id   - the integer representing the vertex
-    // dist - the tenetative distance to the vertex
-    int id, dist;
-    
-    // neighbors - the integer value of the neighboring vertices
-    ArrayList<Integer> neighbors;
-    
-    public Vertex( int id )
-    {
-        this.id = id;
-        this.dist = Integer.MAX_VALUE;
-        this.neighbors = new ArrayList<Integer>();
-    }
-    
-    // This method needs to be overridden to determine how vertices are sorted
-    public int compareTo( Vertex v )
-    {
-        // The vertex that has a smaller tentative distance should be removed from the queue first
-        if ( this.dist < v.dist )
-        {
-            return -1;
-        }
-        else
-        {
-            return 1;
-        }
-    }
-}
-```
+![graph-theory-dijkstras-algorithm-2](..\..\..\resources\graph-theory-dijkstras-algorithm-2.png)
 
 Remember that when we used `dist[]` to keep track of distances, we had to look through _all_ tentative distances to see which vertex to visit; with this method, we just remove the next vertex from the priority queue and it will be guaranteed to have the smallest distance.
 
@@ -194,45 +95,7 @@ Just like BFS, we are repeating the steps of the algorithm until the queue is em
 
 Now that we have our stopping condition, we can implement the rest of the algorithm
 
-```java
-// While the queue still has vertices left to visit...
-while ( !priorityQueue.isEmpty() )
-{
-    // Get the current vertex
-    Vertex current = priorityQueue.remove();
-    
-    // If the current vertex is our destination...
-    if ( current.id == destination )
-    {
-        // Break from the loop
-        break;    
-    }
-    
-    // Get the neighbors of the current vertex
-    ArrayList<Integer> neighbors = current.neighbors;
-    
-    // For each of the neighbors...
-    for ( Integer j : neighbor )
-    {
-        // Get the Vertex representation of the neighbor
-        Vertex neighbor = graph[ j ];
-        
-        // Calculate the new distance to the neighbor
-        int newDistance = current.dist + cost[ current.id ][ neighbor.id ];
-        
-        // If the new distance we calculated is smaller than the tentative distance of the neighbor...
-        if ( newDistance < neighbor.dist )
-        {
-            // Remove the neighbor from the priority queue so we can update the value
-            priorityQueue.remove( neighbor );
-            // Update the tentative distance of the neighbor
-            neighbor.dist = newDistance;
-            // Add the neighbor into the priority queue so that it can be sorted among the other vertices
-            priorityQueue.add( neighbor );
-        }
-    }
-}
-```
+![graph-theory-dijkstras-algorithm-3](..\..\..\resources\graph-theory-dijkstras-algorithm-3.png)
 
 ## Problems