Merge Go Work

go/prime-factors/README.md

@@ -0,0 +1,48 @@
+# Prime Factors
+
+Compute the prime factors of a given natural number.
+
+A prime number is only evenly divisible by itself and 1.
+
+Note that 1 is not a prime number.
+
+## Example
+
+What are the prime factors of 60?
+
+- Our first divisor is 2. 2 goes into 60, leaving 30.
+- 2 goes into 30, leaving 15.
+  - 2 doesn't go cleanly into 15. So let's move on to our next divisor, 3.
+- 3 goes cleanly into 15, leaving 5.
+  - 3 does not go cleanly into 5. The next possible factor is 4.
+  - 4 does not go cleanly into 5. The next possible factor is 5.
+- 5 does go cleanly into 5.
+- We're left only with 1, so now, we're done.
+
+Our successful divisors in that computation represent the list of prime
+factors of 60: 2, 2, 3, and 5.
+
+You can check this yourself:
+
+- 2 * 2 * 3 * 5
+- = 4 * 15
+- = 60
+- Success!
+
+To run the tests simply run the command `go test` in the exercise directory.
+
+If the test suite contains benchmarks, you can run these with the `-bench`
+flag:
+
+    go test -bench .
+
+For more detailed info about the Go track see the [help
+page](http://exercism.io/languages/go).
+
+## Source
+
+The Prime Factors Kata by Uncle Bob [http://butunclebob.com/ArticleS.UncleBob.ThePrimeFactorsKata](http://butunclebob.com/ArticleS.UncleBob.ThePrimeFactorsKata)
+
+## Submitting Incomplete Problems
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.
+

go/prime-factors/prime.go

@@ -0,0 +1,21 @@
+package prime
+
+const testVersion = 2
+
+func Factors(fnd int64) []int64 {
+	var ret []int64
+	var i int64
+	foundFactor := true
+	for i = 2; i < fnd; i++ {
+		for j := range ret {
+			if i%ret[j] == 0 {
+				//  Already covered this case, move on
+				foundFactor = false
+			}
+			if !foundFactor {
+				break
+			}
+		}
+	}
+	return ret
+}

go/prime-factors/primefactors_test.go

@@ -0,0 +1,48 @@
+package prime
+
+// Return prime factors in increasing order
+
+import (
+	"reflect"
+	"testing"
+)
+
+const targetTestVersion = 2
+
+var tests = []struct {
+	input    int64
+	expected []int64
+}{
+	{1, []int64{}},
+	{2, []int64{2}},
+	{3, []int64{3}},
+	{4, []int64{2, 2}},
+	{6, []int64{2, 3}},
+	{8, []int64{2, 2, 2}},
+	{9, []int64{3, 3}},
+	{27, []int64{3, 3, 3}},
+	{625, []int64{5, 5, 5, 5}},
+	{901255, []int64{5, 17, 23, 461}},
+	{93819012551, []int64{11, 9539, 894119}},
+}
+
+func TestPrimeFactors(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
+	}
+	for _, test := range tests {
+		actual := Factors(test.input)
+		if !reflect.DeepEqual(actual, test.expected) {
+			t.Errorf("prime.Factors(%d) = %v; expected %v",
+				test.input, actual, test.expected)
+		}
+	}
+}
+
+func BenchmarkPrimeFactors(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, test := range tests {
+			Factors(test.input)
+		}
+	}
+}