Updating all of the new ones that are done.

go/octal/README.md

@@ -0,0 +1,59 @@
+# Octal
+
+Write a program that will convert a octal number, represented as a string (e.g. '1735263'), to its decimal equivalent using first principles (i.e. no, you may not use built-in or external libraries to accomplish the conversion).
+
+Implement octal to decimal conversion.  Given an octal input
+string, your program should produce a decimal output.
+
+## Note
+- Implement the conversion yourself.
+  Do not use something else to perform the conversion for you.
+- Treat invalid input as octal 0.
+
+## About Octal (Base-8)
+Decimal is a base-10 system.
+
+A number 233 in base 10 notation can be understood
+as a linear combination of powers of 10:
+
+- The rightmost digit gets multiplied by 10^0 = 1
+- The next number gets multiplied by 10^1 = 10
+- ...
+- The *n*th number gets multiplied by 10^*(n-1)*.
+- All these values are summed.
+
+So:
+```
+   233 # decimal
+ = 2*10^2 + 3*10^1 + 3*10^0
+ = 2*100  + 3*10   + 3*1
+```
+
+Octal is similar, but uses powers of 8 rather than powers of 10.
+
+So:
+```
+   233 # octal
+ = 2*8^2 + 3*8^1 + 3*8^0
+ = 2*64  + 3*8   + 3*1
+ = 128   + 24    + 3
+ = 155
+```
+
+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
+
+All of Computer Science [http://www.wolframalpha.com/input/?i=base+8](http://www.wolframalpha.com/input/?i=base+8)
+
+## Submitting Incomplete Problems
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.
+

go/octal/octal.go

@@ -0,0 +1,24 @@
+package octal
+
+import (
+	"errors"
+	"math"
+)
+
+// ParseOctal takes a string representation of an octal number
+// and returns the decimal value of that number, or an error if it
+// was unparseable as an octal number
+func ParseOctal(v string) (int64, error) {
+	var ret float64
+	octLen := float64(len(v))
+	for i := range v {
+		octLen--
+		switch {
+		case v[i] > 47 && v[i] < 56:
+			ret = ret + float64(v[i]-48)*math.Pow(8, octLen)
+		default:
+			return 0, errors.New("Unparseable as octal")
+		}
+	}
+	return int64(ret), nil
+}

go/octal/octal_test.go

@@ -0,0 +1,50 @@
+package octal
+
+import (
+	"testing"
+)
+
+var testCases = []struct {
+	input       string
+	expectedNum int64
+	expectErr   bool
+}{
+	{"1", 1, false},
+	{"10", 8, false},
+	{"1234567", 342391, false},
+	{"carrot", 0, true},
+	{"35682", 0, true},
+}
+
+func TestParseOctal(t *testing.T) {
+	for _, test := range testCases {
+		actualNum, actualErr := ParseOctal(test.input)
+		if actualNum != test.expectedNum {
+			t.Fatalf("ParseOctal(%s): expected[%d], actual [%d]",
+				test.input, test.expectedNum, actualNum)
+		}
+
+		// if we expect an error and there isn't one
+		if test.expectErr && actualErr == nil {
+			t.Errorf("ParseOctal(%s): expected an error, but error is nil", test.input)
+		}
+		// if we don't expect an error and there is one
+		if !test.expectErr && actualErr != nil {
+			t.Errorf("ParseOctal(%s): expected no error, but error is: %s", test.input, actualErr)
+		}
+	}
+}
+
+func BenchmarkParseOctal(b *testing.B) {
+	b.StopTimer()
+
+	for _, test := range testCases {
+		b.StartTimer()
+
+		for i := 0; i < b.N; i++ {
+			ParseOctal(test.input)
+		}
+
+		b.StopTimer()
+	}
+}