Finished go/pov

go/pov/pov.go

@@ -2,12 +2,7 @@ package pov
 
 const testVersion = 2
 
-// A Graph is just a collection of Nodes
-type Node struct {
-	label       string
-	connections []Node
-}
-
+// A Graph just holds all nodes in the graph
 type Graph struct {
 	nodes []Node
 }
@@ -16,6 +11,12 @@ func New() *Graph {
 	return new(Graph)
 }
 
+// A Node is a label and a slice of references to other nodes
+type Node struct {
+	label       string
+	connections []Node
+}
+
 func (g *Graph) AddNode(lbl string) {
 	if g.getNode(lbl) == nil {
 		g.nodes = append(g.nodes, Node{label: lbl})
@@ -72,6 +73,7 @@ func (g *Graph) getPath(fr, to string) []string {
 		}
 		tst := g.getPath(st.connections[i].label, to)
 		if len(tst) > 0 {
+			tst = append([]string{fr}, tst...)
 			valPaths = append(valPaths, tst)
 		}
 	}
@@ -101,15 +103,14 @@ func (g *Graph) ChangeRoot(oldRoot, newRoot string) *Graph {
 			if n == nil {
 				return g
 			}
-			n = n.copy()
 			p := g.getNode(pth[0])
 			if p == nil {
 				return g
 			}
-			p = p.copy()
 			p.removeConnection(n.label)
 			n.connections = append(n.connections, *p)
 			oldRoot = n.label
+			pth = g.getPath(oldRoot, newRoot)
 		}
 	}
 	return g
@@ -124,13 +125,3 @@ func (n *Node) removeConnection(to string) {
 		}
 	}
 }
-
-// Node.copy() returns a new node that is a copy of this node
-func (n *Node) copy() *Node {
-	ret := Node{label: n.label}
-	for _, k := range n.connections {
-		cp := k.copy()
-		ret.connections = append(ret.connections, *cp)
-	}
-	return &ret
-}

go/pov/pov_test.go

@@ -1,7 +1,6 @@
 package pov
 
 import (
-	"fmt"
 	"reflect"
 	"sort"
 	"testing"
@@ -267,13 +266,10 @@ func TestTestVersion(t *testing.T) {
 }
 
 func TestConstruction(t *testing.T) {
-	fmt.Println("TestConstruction")
 	for _, tc := range testCases {
-		fmt.Println("Starting test:", tc.description)
 		got := tc.graph().ArcList()
 		want := tc.arcStrings
 		tc.testResult(got, want, "incorrect graph construction", t)
-		fmt.Println("	Test Passed:", tc.description)
 	}
 }
 

go/two-fer/README.md

@@ -0,0 +1,66 @@
+# Two Fer
+
+`Two-fer` or `2-fer` is short for two for one. One for you and one for me.
+
+```
+"One for X, one for me."
+```
+
+When X is a name or "you".
+
+If the given name is "Alice", the result should be "One for Alice, one for me."
+If no name is given, the result should be "One for you, one for me."
+
+
+## Test-Driven Development
+
+As programmers mature, they eventually want to test their code.
+
+Here at Exercism we simulate [Test-Driven
+Development](http://en.wikipedia.org/wiki/Test-driven_development) (TDD), where
+you write your tests before writing any functionality. The simulation comes in
+the form of a pre-written test suite, which will signal that you have solved
+the problem.
+
+It will also provide you with a safety net to explore other solutions without
+breaking the functionality.
+
+### A typical TDD workflow on Exercism:
+
+1. Run the test file and pick one test that's failing.
+2. Write some code to fix the test you picked.
+3. Re-run the tests to confirm the test is now passing.
+4. Repeat from step 1.
+5. Submit your solution (`exercism submit /path/to/file`)
+
+## Instructions
+
+Submissions are encouraged to be general, within reason. Having said that, it's
+also important not to over-engineer a solution.
+
+It's important to remember that the goal is to make code as expressive and
+readable as we can.
+
+## Running the tests
+
+To run the tests run the command `go test` from within the exercise directory.
+
+If the test suite contains benchmarks, you can run these with the `-bench`
+flag:
+
+    go test -bench .
+
+Keep in mind that each reviewer will run benchmarks on a different machine, with
+different specs, so the results from these benchmark tests may vary.
+
+## Further information
+
+For more detailed information about the Go track, including how to get help if
+you're having trouble, please visit the exercism.io [Go language page](http://exercism.io/languages/go/about).
+
+## Source
+
+This is an exercise to introduce users to basic programming constructs, just after hello World. [https://en.wikipedia.org/wiki/Two-fer](https://en.wikipedia.org/wiki/Two-fer)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

go/two-fer/example_two_fer_test.go

@@ -0,0 +1,20 @@
+package twofer
+
+import "fmt"
+
+// ExampleShareWith() is an Example function. Examples are testable snippets of
+// Go code that are used for documenting and verifying the package API.
+// They may be present in some exercises to demonstrate the expected use of the
+// exercise API and can be run as part of a package's test suite.
+//
+// When an Example test is run the data that is written to standard output is
+// compared to the data that comes after the "Output: " comment.
+//
+// Below the result of ShareWith() is passed to standard output
+// using fmt.Println, and this is compared against the expected output.
+// If they are equal, the test passes.
+func ExampleShareWith() {
+	h := ShareWith("")
+	fmt.Println(h)
+	// Output: One for you, one for me.
+}

go/two-fer/two_fer.go

@@ -0,0 +1,15 @@
+// This is a "stub" file.  It's a little start on your solution.
+// It's not a complete solution though; you have to write some code.
+
+// Package twofer should have a package comment that summarizes what it's about.
+// https://golang.org/doc/effective_go.html#commentary
+package twofer
+
+// ShareWith needs a comment documenting it.
+func ShareWith(string) string {
+	// Write some code here to pass the test suite.
+	// Then remove all the stock comments.
+	// They're here to help you get started but they only clutter a finished solution.
+	// If you leave them in, reviewers will protest!
+	return ""
+}

go/two-fer/two_fer_test.go

@@ -0,0 +1,20 @@
+package twofer
+
+import "testing"
+
+// Define a function ShareWith(string) string.
+
+func TestShareWith(t *testing.T) {
+	tests := []struct {
+		name, expected string
+	}{
+		{"", "One for you, one for me."},
+		{"Alice", "One for Alice, one for me."},
+		{"Bob", "One for Bob, one for me."},
+	}
+	for _, test := range tests {
+		if observed := ShareWith(test.name); observed != test.expected {
+			t.Fatalf("ShareWith(%s) = %v, want %v", test.name, observed, test.expected)
+		}
+	}
+}