Adding initial project of sorts and algorithms

Author: havkarl

README.md

@@ -1,2 +1,6 @@
-# level-0-python-coding-interview
-A level 0 series of common interview and data structure problems every professional developer should know
+# Practice Problems
+
+## Sorting Algorithms
+1. Merge Sort
+
+

environment.yml

@@ -0,0 +1,6 @@
+name: Practice
+channels:
+    - conda-forge
+dependencies:
+    - plumbum
+    - pytest

practice_problems/__init__.py

@@ -0,0 +1,85 @@
+from plumbum import cli
+from graph import Graph, inf
+from collections import deque
+import pprint
+
+'''
+https://www.geeksforgeeks.org/dijkstras-shortest-path-algorithm-greedy-algo-7/
+https://dev.to/mxl/dijkstras-algorithm-in-python-algorithms-for-beginners-dkc
+http://interactivepython.org/courselib/static/pythonds/Graphs/DijkstrasAlgorithm.html
+'''
+class DijkstrasAlgorithm(cli.Application):
+
+    # a - 2  -> b - 7 -> |
+    # |         | 10     |
+    # | - 9  -> c        |
+    # |         | 2      |
+    # | - 14 -> d <- - - |
+
+    _graph = Graph([
+        ("a", "b", 2), ("a", "c", 9), ("b", "c", 10),
+        ("b", "d", 7), ("a", "d", 14), ("c", "d", 2)
+    ])
+
+    def main(self):
+        if list is None or len(self._graph.vertices) is 0:
+            print("List should have at least one element")
+            return 1
+        else:
+            dijkstras = self.run_dijkstras(self._graph, "a", "d")
+            pprint.pprint(dijkstras)
+
+    def run_dijkstras(self, graph, source, destination):
+
+        # 1.)   Create a shortest path tree set, initially empty
+        #       Optimization - use a parent path dict to retain previous short path
+        shortest_path_tree = []
+        previous_vertices = {vertex: None for vertex in graph.vertices}
+
+        # 2.)   Creates a map of each vertex (variable) to infinity
+        #       Set the source to 0
+        distances = {vertex: inf for vertex in graph.vertices}
+        distances[source] = 0
+
+        # 3.)   While we have visited all vertices in set
+        #       Technique is to create a copy, and remove from set as its consumed
+        vertices = graph.vertices.copy()
+        while vertices:
+
+            # 4.)   Select node with the minimum distance value
+            #       Once we pull from minimum distance, remove from our vertices
+            next_node = min(vertices, key=lambda key: distances[key])
+            vertices.remove(next_node)
+
+            # 5.)   Add the minimum distance node to set
+            #       ... As long as we're not left with all unreachable vertices
+            if distances[next_node] == inf:
+                break
+            shortest_path_tree.append(next_node)
+            distance = distances[next_node]
+
+            # 6.)   Update the distance values the next node's neighbors
+            neighbors = graph.neighbours[next_node]
+            for neighbor, cost in neighbors:
+                neighbor_distance = distance + cost
+
+                #   ... either if we've found a shorter distance to neighbor
+                #       or we haven't been here before
+                if neighbor not in distances or \
+                        (neighbor in distances
+                            and neighbor_distance < distances[neighbor]):
+                    distances[neighbor] = neighbor_distance
+                    previous_vertices[neighbor] = next_node
+
+        # 7.)   Work our way backwards from the destination and
+        #       Find the shortest path by looking up in the previous_vertices map
+        shortest_path, current_vertex = deque(), destination
+        while previous_vertices[current_vertex] is not None:
+            shortest_path.appendleft(current_vertex)
+            current_vertex = previous_vertices[current_vertex]
+
+        #       When we reach the source, append to the path
+        if shortest_path:
+            shortest_path.appendleft(current_vertex)
+        return shortest_path, distances
+

practice_problems/graph/__init__.py

@@ -0,0 +1,58 @@
+from collections import deque, namedtuple
+# Credit to: https://dev.to/mxl/dijkstras-algorithm-in-python-algorithms-for-beginners-dkc
+inf = float('inf')
+Edge = namedtuple('Edge', 'start, end, cost')
+
+
+def make_edge(start, end, cost=1):
+  return Edge(start, end, cost)
+
+
+class Graph:
+    def __init__(self, edges):
+        # let's check that the data is right
+        wrong_edges = [i for i in edges if len(i) not in [2, 3]]
+        if wrong_edges:
+            raise ValueError('Wrong edges data: {}'.format(wrong_edges))
+
+        self.edges = [make_edge(*edge) for edge in edges]
+
+    @property
+    def vertices(self):
+        return set(
+            sum(
+                ([edge.start, edge.end] for edge in self.edges), []
+            )
+        )
+
+    def get_node_pairs(self, n1, n2, both_ends=True):
+        if both_ends:
+            node_pairs = [[n1, n2], [n2, n1]]
+        else:
+            node_pairs = [[n1, n2]]
+        return node_pairs
+
+    def remove_edge(self, n1, n2, both_ends=True):
+        node_pairs = self.get_node_pairs(n1, n2, both_ends)
+        edges = self.edges[:]
+        for edge in edges:
+            if [edge.start, edge.end] in node_pairs:
+                self.edges.remove(edge)
+
+    def add_edge(self, n1, n2, cost=1, both_ends=True):
+        node_pairs = self.get_node_pairs(n1, n2, both_ends)
+        for edge in self.edges:
+            if [edge.start, edge.end] in node_pairs:
+                return ValueError('Edge {} {} already exists'.format(n1, n2))
+
+        self.edges.append(Edge(start=n1, end=n2, cost=cost))
+        if both_ends:
+            self.edges.append(Edge(start=n2, end=n1, cost=cost))
+
+    @property
+    def neighbours(self):
+        neighbours = {vertex: set() for vertex in self.vertices}
+        for edge in self.edges:
+            neighbours[edge.start].add((edge.end, edge.cost))
+
+        return neighbours

practice_problems/graph/dijkstras_algorithm.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+from plumbum import cli
+from longest_connected_values import LongestConnectedValues
+from dijkstras_algorithm import DijkstrasAlgorithm
+
+class GraphAlgorithms(cli.Application):
+
+    def main(self, *args):
+        if args:
+            print("Unknown command {0!r}".format(args[0]))
+            return 1   # error exit code
+        if not self.nested_command:           # will be ``None`` if no sub-command follows
+            print("No command given")
+            return 1   # error exit code
+
+
+if __name__ == '__main__':
+    GraphAlgorithms.subcommand("longest", LongestConnectedValues)
+    GraphAlgorithms.subcommand("dijkstras", DijkstrasAlgorithm)
+    GraphAlgorithms.run()

practice_problems/graph/graph.py

@@ -0,0 +1,45 @@
+from plumbum import cli
+import pprint
+
+class LongestConnectedValues(cli.Application):
+    # Making the assumption that values are not repeated!
+    # 6 , 5 , 7
+    # 1 , 4 , 8
+    # 2 , 3 , 9
+    _graph = {
+        6: [1, 5],
+        1: [6, 4, 2],
+        2: [1, 3],
+        5: [6, 4, 7],
+        4: [5, 8, 3, 1],
+        3: [2, 4, 9],
+        7: [5, 8],
+        8: [7, 4, 9],
+        9: [3, 8]
+    }
+
+    def main(self):
+        if list is None or len(self._graph) is 0:
+            print("List should have at least one element")
+            return 1
+        else:
+            longest = self.search_graph(self._graph)
+            pprint.pprint(longest)
+
+    def search_graph(self, graph):
+        found_longest = {}
+
+        for parent,children in graph.items():
+            found_longest[parent] = self.find_longest(graph, parent, children, [parent], found_longest)
+        return found_longest
+
+    def find_longest(self, graph, parent, children, longest, found_longest):
+            for child in children:
+                if parent+1 == child:
+                    if child in found_longest:
+                        longest.extend(found_longest[child])
+                    else:
+                        longest.append(child)
+                        self.find_longest(graph, child, graph[child], longest, found_longest)
+
+            return longest

practice_problems/graph/graph_algorithms.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python
+from plumbum import cli
+from max_overlapping_intervals import MaxOverlappingIntervals
+
+class InterviewProblems(cli.Application):
+
+    def main(self, *args):
+        if args:
+            print("Unknown command {0!r}".format(args[0]))
+            return 1   # error exit code
+        if not self.nested_command:           # will be ``None`` if no sub-command follows
+            print("No command given")
+            return 1   # error exit code
+
+
+if __name__ == '__main__':
+    InterviewProblems.subcommand("intervals", MaxOverlappingIntervals)
+    InterviewProblems.run()