Adding a lot more problems. Many are not properly documented and without a complementary solution file.

thundergolfer-two · thundergolfer-two · commit 6fcbc8270c63 · 2016-08-30T14:35:54.000+10:00
diff --git a/TODO.md b/TODO.md
@@ -7,4 +7,8 @@
 ### FOR... PROBLEMS
 
 * Document and Explain all code exercises that don't have it.
-* We want to include all the CodeJam problems. There are a lot of them so we need either a lot of time, or a scraping solution. So investigate a scraping solution for CodeJam past problems. 
+* We want to include all the CodeJam problems. There are a lot of them so we need either a lot of time, or a scraping solution. So investigate a scraping solution for CodeJam past problems.
+* Go through this https://www.quora.com/What-algorithms-and-data-structures-should-any-software-engineer-know page and extract good problem ideas.
+* Go throuh project euler https://projecteuler.net/archives to extract good problems
+
+### FOR... WORDED PROBLEMS
diff --git a/problems/adjacency-list/README.md b/problems/adjacency-list/README.md
@@ -0,0 +1,3 @@
+# Adjacency List
+
+Implement an adjacency list in python code.
diff --git a/problems/adjacency-matrix/README.md b/problems/adjacency-matrix/README.md
@@ -0,0 +1,3 @@
+# Adjacency Matrix
+
+Implement an adjacency matrix graph in python code.
diff --git a/problems/breadth-first-traversal/README.md b/problems/breadth-first-traversal/README.md
@@ -0,0 +1,5 @@
+# Breadth First Traversal Problems
+
+Problems tied to the classic searching algorithm.
+
+// TODO 
diff --git a/problems/counting-sort/README.md b/problems/counting-sort/README.md
@@ -0,0 +1,3 @@
+# Counting Sort
+
+// TODO: do problem description
diff --git a/problems/depth-first-traversal/README.md b/problems/depth-first-traversal/README.md
@@ -0,0 +1,5 @@
+# Depth first traversal problems
+
+Problems relating to depth first graph/tree traversal.
+
+// TODO
diff --git a/problems/deterministic-quick-select/README.md b/problems/deterministic-quick-select/README.md
@@ -0,0 +1,5 @@
+# Deterministic Quick Select
+
+Implement the [Deterministic Selection Algorithm](https://www.ics.uci.edu/~eppstein/161/960130.html) in python code.
+
+// TODO
diff --git a/problems/dijkstras_algorithm/README.md b/problems/dijkstras_algorithm/README.md
@@ -0,0 +1,3 @@
+# Dijkstra's Algorithm
+
+Implement [Dijkstra's Algorithm](https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm) in python code. Try to use not code 'crutches'.
diff --git a/problems/euclids-algorithm/README.md b/problems/euclids-algorithm/README.md
@@ -0,0 +1,5 @@
+# Euclid's Algorithm
+
+Implement Euclid's algorithm for finding the GCD of two integers. The algorithm is described below.
+
+// TODO; describe it
diff --git a/problems/floyd-warshall-algorithm/README.md b/problems/floyd-warshall-algorithm/README.md
@@ -0,0 +1,5 @@
+# Floyd-Warshall Algorithm
+
+Implement the Floyd-Warshall algorithm in python code.
+
+// TODO: Finish problem description
diff --git a/problems/hashtable/README.md b/problems/hashtable/README.md
@@ -0,0 +1,3 @@
+# Hashtable
+
+Implement a [hashtable](https://en.wikipedia.org/wiki/Hash_table) in python code.
diff --git a/problems/knapsack-problems/README.md b/problems/knapsack-problems/README.md
@@ -0,0 +1,12 @@
+# Knapsack Problem
+
+The Classic Knapsack problem and a couple of its variants.
+
+# Class Knapsack problem
+
+Implement an algorithm to solve the knapsack problem.
+
+
+# Multi-choice Knapsack Problem
+
+Implement an algorithm to solve the multiple choice knapsack problem.
diff --git a/problems/markov-chain-monte-carlo/README.md b/problems/markov-chain-monte-carlo/README.md
@@ -0,0 +1,5 @@
+# Markov Chain Monte Carlo
+
+Approximate integral, expected value computation based on a conditional specification of the probability distribution. This gives us a general way of doing data analysis.
+
+// TODO: Finish problem description
diff --git a/problems/n-choose-k-problems/README.md b/problems/n-choose-k-problems/README.md
@@ -0,0 +1,7 @@
+# N Choose K Problems
+
+A series of problems related to N choose K problems in mathematics.
+
+# Problem One
+
+// TODO
diff --git a/problems/page-rank/README.md b/problems/page-rank/README.md
@@ -0,0 +1,6 @@
+# Page Rank
+
+Implement Google's famous page rank algorithm in python code.
+
+
+// TODO finish problem descr.
diff --git a/problems/pancake-sort/README.md b/problems/pancake-sort/README.md
@@ -0,0 +1,3 @@
+# Pancake Sort
+
+// TODO: Finish problem description
diff --git a/problems/probability-problems/README.md b/problems/probability-problems/README.md
@@ -0,0 +1,3 @@
+# Probablity Problems
+
+A series of problems aiming to test some basic probablity knowledge.
diff --git a/repo_health_checkup.py b/repo_health_checkup.py
@@ -15,9 +15,16 @@ def main():
 
             # if: problem solution source code file then check for -> tags, unit tests, spelling
 
-            # if: any other file check for -> spelling
+            # and... any other file check for -> spelling, "TODO" markers, amount of commenting
 
 
+def check_amount_of_commenting( lines ):
+    """
+    Check lines of file to see whether it has a lot of commenting in it,
+    which we take to mean the presence of code explanation.
+    """
+    raise NotImplementedError
+
 def check_for_tags( lines ):
     """ Check if a problem solution file has tags in it. True, if yes. """
     raise NotImplementedError
diff --git a/repo_stats.py b/repo_stats.py
@@ -0,0 +1,6 @@
+# Get stats on the number of questions, answers, lines of code etc etc in the repo.
+
+import os
+
+
+# TODO: This whole thing
diff --git a/solutions/n-choose-k.py b/solutions/n-choose-k.py
@@ -0,0 +1,3 @@
+import unittest
+
+# TODO: put useful stuff in here
diff --git a/solutions/python/adjacency-list.py b/solutions/python/adjacency-list.py
@@ -0,0 +1,57 @@
+import unittest
+
+## SOLUTION ONE ##########################
+class Vertex:
+    def __init__(self,key):
+        self.id = key
+        self.connectedTo = {}
+
+    def addNeighbor(self,nbr,weight=0):
+        self.connectedTo[nbr] = weight
+
+    def __str__(self):
+        return str(self.id) + ' connectedTo: ' + str([x.id for x in self.connectedTo])
+
+    def getConnections(self):
+        return self.connectedTo.keys()
+
+    def getId(self):
+        return self.id
+
+    def getWeight(self,nbr):
+        return self.connectedTo[nbr]
+
+class Graph:
+    def __init__(self):
+        self.vertList = {}
+        self.numVertices = 0
+
+    def addVertex(self,key):
+        self.numVertices = self.numVertices + 1
+        newVertex = Vertex(key)
+        self.vertList[key] = newVertex
+        return newVertex
+
+    def getVertex(self,n):
+        if n in self.vertList:
+            return self.vertList[n]
+        else:
+            return None
+
+    def __contains__(self,n):
+        return n in self.vertList
+
+    def addEdge(self,f,t,cost=0):
+        if f not in self.vertList:
+            nv = self.addVertex(f)
+        if t not in self.vertList:
+            nv = self.addVertex(t)
+        self.vertList[f].addNeighbor(self.vertList[t], cost)
+
+    def getVertices(self):
+        return self.vertList.keys()
+
+    def __iter__(self):
+        return iter(self.vertList.values())
+
+## END SOLUTION ONE #####
diff --git a/solutions/python/adjacency-matrix.py b/solutions/python/adjacency-matrix.py
@@ -0,0 +1,3 @@
+import unittest
+
+# TODO: // This whole thing. Wasn't easy to find a good implementation online.
diff --git a/solutions/python/deterministic-quick-select.py b/solutions/python/deterministic-quick-select.py
@@ -0,0 +1,3 @@
+import unittest
+
+# TODO: all of it
diff --git a/solutions/python/dijsktra.py b/solutions/python/dijsktra.py
@@ -0,0 +1,115 @@
+import unittest
+from priodict import priorityDictionary # for Two
+
+
+class Graph_One:
+  def __init__(self):
+    self.nodes = set()
+    self.edges = defaultdict(list)
+    self.distances = {}
+
+  def add_node(self, value):
+    self.nodes.add(value)
+
+  def add_edge(self, from_node, to_node, distance):
+    self.edges[from_node].append(to_node)
+    self.edges[to_node].append(from_node)
+    self.distances[(from_node, to_node)] = distance
+
+
+def dijsktra_one(graph, initial):
+    """ from https://gist.github.com/econchick/4666413 """
+    visited = {initial: 0}
+    path = {}
+
+    nodes = set(graph.nodes)
+
+    while nodes:
+    min_node = None
+    for node in nodes:
+        if node in visited:
+            if min_node is None:
+                min_node = node
+            elif visited[node] < visited[min_node]:
+                min_node = node
+
+    if min_node is None:
+        break
+
+    nodes.remove(min_node)
+    current_weight = visited[min_node]
+
+    for edge in graph.edges[min_node]:
+        weight = current_weight + graph.distance[(min_node, edge)]
+        if edge not in visited or weight < visited[edge]:
+            visited[edge] = weight
+            path[edge] = min_node
+
+    return visited, path
+
+
+def dijsktra_two(G,start,end=None):
+	"""
+	Find shortest paths from the  start vertex to all vertices nearer than or equal to the end.
+
+	The input graph G is assumed to have the following representation:
+	A vertex can be any object that can be used as an index into a dictionary.
+	G is a dictionary, indexed by vertices.  For any vertex v, G[v] is itself a dictionary,
+	indexed by the neighbors of v.  For any edge v->w, G[v][w] is the length of the edge.
+	This is related to the representation in <http://www.python.org/doc/essays/graphs.html>
+	where Guido van Rossum suggests representing graphs as dictionaries mapping vertices
+	to lists of outgoing edges, however dictionaries of edges have many advantages over lists:
+	they can store extra information (here, the lengths), they support fast existence tests,
+	and they allow easy modification of the graph structure by edge insertion and removal.
+	Such modifications are not needed here but are important in many other graph algorithms.
+	Since dictionaries obey iterator protocol, a graph represented as described here could
+	be handed without modification to an algorithm expecting Guido's graph representation.
+
+	Of course, G and G[v] need not be actual Python dict objects, they can be any other
+	type of object that obeys dict protocol, for instance one could use a wrapper in which vertices
+	are URLs of web pages and a call to G[v] loads the web page and finds its outgoing links.
+
+	The output is a pair (D,P) where D[v] is the distance from start to v and P[v] is the
+	predecessor of v along the shortest path from s to v.
+
+	Dijkstra's algorithm is only guaranteed to work correctly when all edge lengths are positive.
+	This code does not verify this property for all edges (only the edges examined until the end
+	vertex is reached), but will correctly compute shortest paths even for some graphs with negative
+	edges, and will raise an exception if it discovers that a negative edge has caused it to make a mistake.
+	"""
+
+	D = {}	# dictionary of final distances
+	P = {}	# dictionary of predecessors
+	Q = priorityDictionary()	# estimated distances of non-final vertices
+	Q[start] = 0
+
+	for v in Q:
+		D[v] = Q[v]
+		if v == end: break
+
+		for w in G[v]:
+			vwLength = D[v] + G[v][w]
+			if w in D:
+				if vwLength < D[w]:
+					raise ValueError, "Dijkstra: found better path to already-final vertex"
+			elif w not in Q or vwLength < Q[w]:
+				Q[w] = vwLength
+				P[w] = v
+
+	return (D,P)
+
+def shortestPath(G,start,end):
+	"""
+	Find a single shortest path from the given start vertex to the given end vertex.
+	The input has the same conventions as Dijkstra().
+	The output is a list of the vertices in order along the shortest path.
+	"""
+
+	D,P = Dijkstra(G,start,end)
+	Path = []
+	while 1:
+		Path.append(end)
+		if end == start: break
+		end = P[end]
+	Path.reverse()
+	return Path
diff --git a/solutions/python/euclids-algorithm.py b/solutions/python/euclids-algorithm.py
@@ -0,0 +1 @@
+import unittest
diff --git a/solutions/python/hashtable.py b/solutions/python/hashtable.py
diff --git a/solutions/python/knapsack-problems.py b/solutions/python/knapsack-problems.py
diff --git a/solutions/python/kruskals-algorithm/kruskal-one.py b/solutions/python/kruskals-algorithm/kruskal-one.py
diff --git a/solutions/python/kruskals-algorithm/kruskal-two.py b/solutions/python/kruskals-algorithm/kruskal-two.py
diff --git a/solutions/python/probability-problems.py b/solutions/python/probability-problems.py

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+# Adjacency List`
	`2`	`+`
	`3`	`+Implement an adjacency list in python code.`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+# Adjacency Matrix`
	`2`	`+`
	`3`	`+Implement an adjacency matrix graph in python code.`
-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +# Breadth First Traversal Problems
++
 +Problems tied to the classic searching algorithm.
++
 +// TODO
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+# Counting Sort`
	`2`	`+`
	`3`	`+// TODO: do problem description`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+# Dijkstra's Algorithm`
	`2`	`+`
	`3`	`+Implement [Dijkstra's Algorithm](https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm) in python code. Try to use not code 'crutches'.`