Initial Commit

go/say/README.md

@@ -0,0 +1,77 @@
+# Say
+
+Write a program that will take a number from 0 to 999,999,999,999 and spell out that number in English.
+
+## Step 1
+
+Handle the basic case of 0 through 99.
+
+If the input to the program is `22`, then the output should be
+`'twenty-two'`.
+
+Your program should complain loudly if given a number outside the
+blessed range.
+
+Some good test cases for this program are:
+
+- 0
+- 14
+- 50
+- 98
+- -1
+- 100
+
+### Extension
+
+If you're on a Mac, shell out to Mac OS X's `say` program to talk out
+loud.
+
+## Step 2
+
+Implement breaking a number up into chunks of thousands.
+
+So `1234567890` should yield a list like 1, 234, 567, and 890, while the
+far simpler `1000` should yield just 1 and 0.
+
+The program must also report any values that are out of range.
+
+## Step 3
+
+Now handle inserting the appropriate scale word between those chunks.
+
+So `1234567890` should yield `'1 billion 234 million 567 thousand 890'`
+
+The program must also report any values that are out of range.  It's
+fine to stop at "trillion".
+
+## Step 4
+
+Put it all together to get nothing but plain English.
+
+`12345` should give `twelve thousand three hundred forty-five`.
+
+The program must also report any values that are out of range.
+
+### Extensions
+
+Use _and_ (correctly) when spelling out the number in English:
+
+- 14 becomes "fourteen".
+- 100 becomes "one hundred".
+- 120 becomes "one hundred and twenty".
+- 1002 becomes "one thousand and two".
+- 1323 becomes "one thousand three hundred and twenty-three".
+
+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
+
+A variation on JavaRanch CattleDrive, exercise 4a [http://www.javaranch.com/say.jsp](http://www.javaranch.com/say.jsp)

go/say/cmd/main.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"fmt"
+
+	"../../say"
+)
+
+func main() {
+	tst := []int{0, 14, 50, 98, -1, 100}
+	for i := range tst {
+		fmt.Println(say.GetPlaceValue(tst[i], 10))
+		//fmt.Println(say.Say(tst[i]))
+	}
+}

go/say/say.go

@@ -0,0 +1,39 @@
+package say
+
+import (
+	"fmt"
+	"strconv"
+)
+
+func Say(num int) string {
+	// Tens place gives us the y-nums (twent_y-num, thirt_y-num, etc)
+	//tens := num % 100
+	/*
+		switch tens - (tens%10)/10 {
+		case tens > 10:
+			switch tens % 10 {
+			case 1:
+				return Say(num-tens) + " eleven"
+			case 2:
+				return Say(num-tens) + " twelve"
+			case 3:
+				return Say(num-tens) + " thirteen"
+			case 4:
+				return Say(num-tens) + " fourteen"
+			case 5:
+				return Say(num-tens) + " fifteen"
+			default:
+				return Say(num-tens) + " " + Say(tens%10) + "teen"
+			}
+		}
+	*/
+	return ""
+}
+
+func GetPlaceValue(num, place int) int {
+	fmt.Println("Testing " + strconv.Itoa(place) + "s place of " + strconv.Itoa(num))
+	if num > place {
+		return num - (num%place)/place
+	}
+	return 0
+}

go/say/say_test.go

@@ -0,0 +1,47 @@
+package say
+
+// The steps are interesting, but all that matters is the final exam.
+
+import (
+	"math"
+	"testing"
+)
+
+var tests = []struct {
+	uint64
+	string
+}{
+	{1, "one"},
+	{14, "fourteen"},
+	{20, "twenty"},
+	{22, "twenty-two"},
+	{100, "one hundred"},
+	{120, "one hundred twenty"},
+	{123, "one hundred twenty-three"},
+	{1000, "one thousand"},
+	{1234, "one thousand two hundred thirty-four"},
+	{1000000, "one million"},
+	{1000002, "one million two"},
+	{1002345, "one million two thousand three hundred forty-five"},
+	{1e9, "one billion"},
+	{987654321123, "nine hundred eighty-seven billion " +
+		"six hundred fifty-four million " +
+		"three hundred twenty-one thousand " +
+		"one hundred twenty-three"},
+	{0, "zero"},
+	{math.MaxUint64, "eighteen quintillion " +
+		"four hundred forty-six quadrillion " +
+		"seven hundred forty-four trillion " +
+		"seventy-three billion " +
+		"seven hundred nine million " +
+		"five hundred fifty-one thousand " +
+		"six hundred fifteen"},
+}
+
+func TestSay(t *testing.T) {
+	for _, test := range tests {
+		if s := Say(test.uint64); s != test.string {
+			t.Errorf("Say(%d) = %q.  Want %q.", test.uint64, s, test.string)
+		}
+	}
+}