trackler 2.0.0.8 → 2.0.0.9

data/tracks/go/exercises/all-your-base/all_your_base_test.go

@@ -0,0 +1,185 @@
+package allyourbase
+
+import "testing"
+
+// Note: ConvertToBase should accept leading zeroes in its input,
+// but never emit leading zeroes in its output.
+// Exception: If the value of the output is zero, represent it with a single zero.
+var testCases = []struct {
+	description  string
+	inputBase    uint64
+	outputBase   uint64
+	inputDigits  []uint64
+	outputDigits []uint64
+	error        error
+}{
+	{
+		description:  "single bit one to decimal",
+		inputBase:    2,
+		inputDigits:  []uint64{1},
+		outputBase:   10,
+		outputDigits: []uint64{1},
+	},
+	{
+		description:  "binary to single decimal",
+		inputBase:    2,
+		inputDigits:  []uint64{1, 0, 1},
+		outputBase:   10,
+		outputDigits: []uint64{5},
+	},
+	{
+		description:  "single decimal to binary",
+		inputBase:    10,
+		inputDigits:  []uint64{5},
+		outputBase:   2,
+		outputDigits: []uint64{1, 0, 1},
+	},
+	{
+		description:  "binary to multiple decimal",
+		inputBase:    2,
+		inputDigits:  []uint64{1, 0, 1, 0, 1, 0},
+		outputBase:   10,
+		outputDigits: []uint64{4, 2},
+	},
+	{
+		description:  "decimal to binary",
+		inputBase:    10,
+		inputDigits:  []uint64{4, 2},
+		outputBase:   2,
+		outputDigits: []uint64{1, 0, 1, 0, 1, 0},
+	},
+	{
+		description:  "trinary to hexadecimal",
+		inputBase:    3,
+		inputDigits:  []uint64{1, 1, 2, 0},
+		outputBase:   16,
+		outputDigits: []uint64{2, 10},
+	},
+	{
+		description:  "hexadecimal to trinary",
+		inputBase:    16,
+		inputDigits:  []uint64{2, 10},
+		outputBase:   3,
+		outputDigits: []uint64{1, 1, 2, 0},
+	},
+	{
+		description:  "15-bit integer",
+		inputBase:    97,
+		inputDigits:  []uint64{3, 46, 60},
+		outputBase:   73,
+		outputDigits: []uint64{6, 10, 45},
+	},
+	{
+		description:  "empty list",
+		inputBase:    2,
+		inputDigits:  []uint64{},
+		outputBase:   10,
+		outputDigits: []uint64{0},
+		error:        nil,
+	},
+	{
+		description:  "single zero",
+		inputBase:    10,
+		inputDigits:  []uint64{0},
+		outputBase:   2,
+		outputDigits: []uint64{0},
+	},
+	{
+		description:  "multiple zeros",
+		inputBase:    10,
+		inputDigits:  []uint64{0, 0, 0},
+		outputBase:   2,
+		outputDigits: []uint64{0},
+	},
+	{
+		description:  "leading zeros",
+		inputBase:    7,
+		inputDigits:  []uint64{0, 6, 0},
+		outputBase:   10,
+		outputDigits: []uint64{4, 2},
+	},
+	{
+		description:  "invalid positive digit",
+		inputBase:    2,
+		inputDigits:  []uint64{1, 2, 1, 0, 1, 0},
+		outputBase:   10,
+		outputDigits: nil,
+		error:        ErrInvalidDigit,
+	},
+	{
+		description:  "first base is one",
+		inputBase:    1,
+		inputDigits:  []uint64{},
+		outputBase:   10,
+		outputDigits: nil,
+		error:        ErrInvalidBase,
+	},
+	{
+		description:  "second base is one",
+		inputBase:    2,
+		inputDigits:  []uint64{1, 0, 1, 0, 1, 0},
+		outputBase:   1,
+		outputDigits: nil,
+		error:        ErrInvalidBase,
+	},
+	{
+		description:  "first base is zero",
+		inputBase:    0,
+		inputDigits:  []uint64{},
+		outputBase:   10,
+		outputDigits: nil,
+		error:        ErrInvalidBase,
+	},
+	{
+		description:  "second base is zero",
+		inputBase:    10,
+		inputDigits:  []uint64{7},
+		outputBase:   0,
+		outputDigits: nil,
+		error:        ErrInvalidBase,
+	},
+}
+
+func digitsEqual(a, b []uint64) bool {
+	if len(a) != len(b) {
+		return false
+	}
+
+	for i := 0; i < len(a); i++ {
+		if a[i] != b[i] {
+			return false
+		}
+	}
+
+	return true
+}
+
+func TestConvertToBase(t *testing.T) {
+	for _, c := range testCases {
+		output, err := ConvertToBase(c.inputBase, c.inputDigits, c.outputBase)
+		if err != c.error {
+			t.Fatalf(`FAIL: %s
+	Expected error: %v
+	Got: %v`, c.description, c.error, err)
+		}
+
+		if !digitsEqual(c.outputDigits, output) {
+			t.Fatalf(`FAIL: %s
+    Input base: %d
+    Input digits: %v
+    Output base: %d
+    Expected output digits: %v
+    Got: %v`, c.description, c.inputBase, c.inputDigits, c.outputBase, c.outputDigits, output)
+		} else {
+			t.Logf("PASS: %s", c.description)
+		}
+	}
+}
+
+const targetTestVersion = 1
+
+func TestTestVersion(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Errorf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
+	}
+}

data/tracks/go/exercises/all-your-base/example.go

@@ -0,0 +1,60 @@
+package allyourbase
+
+import (
+	"errors"
+	"math"
+)
+
+const testVersion = 1
+
+var (
+	ErrInvalidBase  = errors.New("invalid base given")
+	ErrInvalidDigit = errors.New("invalid digit given")
+)
+
+func ConvertToBase(inputBase uint64, inputDigits []uint64, outputBase uint64) ([]uint64, error) {
+	if inputBase < 2 || outputBase < 2 {
+		return nil, ErrInvalidBase
+	}
+
+	for _, d := range inputDigits {
+		if d >= inputBase {
+			return nil, ErrInvalidDigit
+		}
+	}
+
+	total := toCanonicalBase(inputBase, inputDigits)
+	return digitsInBase(total, outputBase), nil
+}
+
+func toCanonicalBase(inputBase uint64, inputDigits []uint64) uint64 {
+	var total uint64
+
+	digits := len(inputDigits)
+	for i := digits - 1; i >= 0; i-- {
+		total += inputDigits[digits-1-i] * uint64(math.Pow(float64(inputBase), float64(i)))
+	}
+
+	return total
+}
+
+func reverse(digits []uint64) []uint64 {
+	var output = make([]uint64, len(digits))
+
+	for i, d := range digits {
+		output[len(digits)-1-i] = d
+	}
+
+	return output
+}
+
+func digitsInBase(total uint64, outputBase uint64) []uint64 {
+	var digits []uint64
+	for total >= outputBase {
+		digits = append(digits, total%outputBase)
+		total /= outputBase
+	}
+	digits = append(digits, total%outputBase)
+
+	return reverse(digits)
+}

data/tracks/go/exercises/isogram/example.go

@@ -0,0 +1,15 @@
+package isogram
+
+import "strings"
+
+const testVersion = 1
+
+func IsIsogram(word string) bool {
+	for i, r := range strings.ToLower(word) {
+		if r != ' ' && r != '-' && i < strings.LastIndex(word, string(r)) {
+			return false
+		}
+	}
+
+	return true
+}

data/tracks/go/exercises/isogram/isogram_test.go

@@ -0,0 +1,50 @@
+package isogram
+
+import "testing"
+
+var testCases = []struct {
+	word     string
+	expected bool
+}{
+	{"duplicates", true},
+	{"eleven", false},
+	{"subdermatoglyphic", true},
+	{"Alphabet", false},
+	{"thumbscrew-japingly", true},
+	{"Hjelmqvist-Gryb-Zock-Pfund-Wax", true},
+	{"Heizölrückstoßabdämpfung", true},
+	{"the quick brown fox", false},
+	{"Emily Jung Schwartzkopf", true},
+	{"éléphant", false},
+}
+
+func TestIsIsogram(t *testing.T) {
+	for _, c := range testCases {
+		if IsIsogram(c.word) != c.expected {
+			t.Fatalf("FAIL: Word %q, expected %v, got %v", c.word, c.expected, !c.expected)
+		}
+
+		t.Logf("PASS: Word %q", c.word)
+	}
+}
+
+func BenchmarkIsIsogram(b *testing.B) {
+	b.StopTimer()
+	for _, c := range testCases {
+		b.StartTimer()
+
+		for i := 0; i < b.N; i++ {
+			IsIsogram(c.word)
+		}
+
+		b.StopTimer()
+	}
+}
+
+const targetTestVersion = 1
+
+func TestTestVersion(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Errorf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
+	}
+}

data/tracks/go/exercises/ledger/ledger.go

@@ -201,7 +201,7 @@ func FormatLedger(currency string, locale string, entries []Entry) (string, erro
 				}{e: errors.New("")}
 			}
 			var al int
-			for _ = range a {
+			for range a {
 				al++
 			}
 			co <- struct {
@@ -213,7 +213,7 @@ func FormatLedger(currency string, locale string, entries []Entry) (string, erro
 		}(i, et)
 	}
 	ss := make([]string, len(entriesCopy))
-	for _ = range entriesCopy {
+	for range entriesCopy {
 		v := <-co
 		if v.e != nil {
 			return "", v.e

data/tracks/go/exercises/pangram/example.go

@@ -0,0 +1,32 @@
+package pangram
+
+import (
+	"strings"
+)
+
+const testVersion = 1
+
+func IsPangram(s string) bool {
+	lowerString := strings.ToLower(s)
+	var check [26]bool
+	var count int
+	for _, c := range lowerString {
+		if c >= 'a' {
+			if c > 'z' {
+				continue
+			}
+			c -= 97
+		} else {
+			continue
+		}
+
+		if !check[c] {
+			if count == 25 {
+				return true
+			}
+			check[c] = true
+			count++
+		}
+	}
+	return false
+}

data/tracks/go/exercises/pangram/pangram_test.go

@@ -0,0 +1,43 @@
+package pangram
+
+import (
+	"testing"
+)
+
+const targetTestVersion = 1
+
+type testCase struct {
+	input         string
+	expected      bool
+	failureReason string
+}
+
+var testCases = []testCase{
+	{"", false, "sentence empty"},
+	{"The quick brown fox jumps over the lazy dog", true, ""},
+	{"a quick movement of the enemy will jeopardize five gunboats", false, "missing character 'x'"},
+	{"the quick brown fish jumps over the lazy dog", false, "another missing character 'x'"},
+	{"the 1 quick brown fox jumps over the 2 lazy dogs", true, ""},
+	{"7h3 qu1ck brown fox jumps ov3r 7h3 lazy dog", false, "missing letters replaced by numbers"},
+	{"\"Five quacking Zephyrs jolt my wax bed.\"", true, ""},
+	{"Victor jagt zwölf Boxkämpfer quer über den großen Sylter Deich.", true, ""},
+	{"Широкая электрификация южных губерний даст мощный толчок подъёму сельского хозяйства.", false, "Panagram in alphabet other than ASCII"},
+}
+
+func TestTestVersion(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Errorf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
+	}
+}
+
+func TestPangram(t *testing.T) {
+	for _, test := range testCases {
+		actual := IsPangram(test.input)
+		if actual != test.expected {
+			t.Errorf("Pangram test [%s], expected [%t], actual [%t]", test.input, test.expected, actual)
+			if !test.expected {
+				t.Logf("[%s] should not be a pangram because : %s\n", test.input, test.failureReason)
+			}
+		}
+	}
+}

data/tracks/go/exercises/protein-translation/example.go

@@ -0,0 +1,59 @@
+package protein
+
+const testVersion = 1
+
+func FromCodon(codon string) string {
+	switch codon {
+	case
+		"AUG":
+		return "Methionine"
+	case
+		"UUU",
+		"UUC":
+		return "Phenylalanine"
+	case
+		"UUA",
+		"UUG":
+		return "Leucine"
+	case
+		"UCU",
+		"UCC",
+		"UCA",
+		"UCG":
+		return "Serine"
+	case
+		"UAU",
+		"UAC":
+		return "Tyrosine"
+	case
+		"UGU",
+		"UGC":
+		return "Cysteine"
+	case
+		"UGG":
+		return "Tryptophan"
+	case
+		"UAA",
+		"UAG",
+		"UGA":
+		return "STOP"
+	}
+	return "STOP"
+}
+
+func FromRNA(s string) []string {
+	var res = ""
+	var proteins []string
+	for index, codon := range s {
+		res += string(codon)
+		if index > 0 && (index+1)%3 == 0 {
+			tempCodon := FromCodon(res)
+			if tempCodon == "STOP" {
+				break
+			}
+			proteins = append(proteins, tempCodon)
+			res = ""
+		}
+	}
+	return proteins
+}

data/tracks/go/exercises/protein-translation/protein_translation_test.go

@@ -0,0 +1,69 @@
+package protein
+
+import (
+	"reflect"
+	"testing"
+)
+
+const targetTestVersion = 1
+
+type codonCase struct {
+	input    string
+	expected string
+}
+
+var codonTestCases = []codonCase{
+	{"AUG", "Methionine"},
+	{"UUU", "Phenylalanine"},
+	{"UUC", "Phenylalanine"},
+	{"UUA", "Leucine"},
+	{"UUG", "Leucine"},
+	{"UCU", "Serine"},
+	{"UCC", "Serine"},
+	{"UCA", "Serine"},
+	{"UCG", "Serine"},
+	{"UAU", "Tyrosine"},
+	{"UAC", "Tyrosine"},
+	{"UGU", "Cysteine"},
+	{"UGC", "Cysteine"},
+	{"UGG", "Tryptophan"},
+	{"UAA", "STOP"},
+	{"UAG", "STOP"},
+	{"UGA", "STOP"},
+}
+
+type rnaCase struct {
+	input    string
+	expected []string
+}
+
+var proteinTestCases = []rnaCase{
+	{"AUGUUUUCUUAAAUG", []string{"Methionine", "Phenylalanine", "Serine"}},
+	{"AUGUUUUGG", []string{"Methionine", "Phenylalanine", "Tryptophan"}},
+	{"AUGUUUUAA", []string{"Methionine", "Phenylalanine"}},
+	{"UGGUGUUAUUAAUGGUUU", []string{"Tryptophan", "Cysteine", "Tyrosine"}},
+}
+
+func TestCodon(t *testing.T) {
+	for _, test := range codonTestCases {
+		actual := FromCodon(test.input)
+		if actual != test.expected {
+			t.Errorf("Protein Translation test [%s], expected [%s], actual [%s]", test.input, test.expected, actual)
+		}
+	}
+}
+
+func TestProtein(t *testing.T) {
+	for _, test := range proteinTestCases {
+		actual := FromRNA(test.input)
+		if !reflect.DeepEqual(actual, test.expected) {
+			t.Errorf("Protein Translation test [%s], expected %q, actual %q", test.input, test.expected, actual)
+		}
+	}
+}
+
+func TestTestVersion(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Errorf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
+	}
+}

data/tracks/go/exercises/tree-building/tree_building.go

@@ -63,7 +63,7 @@ func Build(records []Record) (*Node, error) {
 							nn := &Node{ID: r.ID}
 							newTodo = append(newTodo, nn)
 						breakpoint:
-							for _ = range []bool{false} {
+							for range []bool{false} {
 								for i, cc := range c.Children {
 									if cc.ID > r.ID {
 										a := make([]*Node, len(c.Children)+1)

data/tracks/go/exercises/twelve-days/example.go

@@ -0,0 +1,57 @@
+package twelve
+
+import (
+	"fmt"
+)
+
+const testVersion = 1
+
+var verse = map[string]string{
+	"first":    "a Partridge in a Pear Tree.",
+	"twelfth":  "twelve Drummers Drumming",
+	"eleventh": "eleven Pipers Piping",
+	"tenth":    "ten Lords-a-Leaping",
+	"ninth":    "nine Ladies Dancing",
+	"eighth":   "eight Maids-a-Milking",
+	"seventh":  "seven Swans-a-Swimming",
+	"sixth":    "six Geese-a-Laying",
+	"fifth":    "five Gold Rings",
+	"fourth":   "four Calling Birds",
+	"third":    "three French Hens",
+	"second":   "two Turtle Doves",
+}
+
+var wording = map[int]string{
+	1:  "first",
+	2:  "second",
+	3:  "third",
+	4:  "fourth",
+	5:  "fifth",
+	6:  "sixth",
+	7:  "seventh",
+	8:  "eighth",
+	9:  "ninth",
+	10: "tenth",
+	11: "eleventh",
+	12: "twelfth",
+}
+
+func Verse(i int) string {
+	var gifts = ""
+	for from := i; from > 0; from-- {
+		if i != 1 && from == 1 {
+			gifts = fmt.Sprintf("%s, and %s", gifts, verse[wording[from]])
+		} else {
+			gifts = fmt.Sprintf("%s, %s", gifts, verse[wording[from]])
+		}
+	}
+	return fmt.Sprintf("On the %s day of Christmas my true love gave to me%s", wording[i], gifts)
+}
+
+func Song() string {
+	var song = ""
+	for i := 1; i <= 12; i++ {
+		song += Verse(i) + "\n"
+	}
+	return song
+}

data/tracks/go/exercises/twelve-days/twelve_days_test.go

@@ -0,0 +1,79 @@
+package twelve
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+const targetTestVersion = 1
+
+type testCase struct {
+	input    int
+	expected string
+}
+
+var testCases = []testCase{
+	{1, "On the first day of Christmas my true love gave to me, a Partridge in a Pear Tree."},
+	{2, "On the second day of Christmas my true love gave to me, two Turtle Doves, and a Partridge in a Pear Tree."},
+	{3, "On the third day of Christmas my true love gave to me, three French Hens, two Turtle Doves, and a Partridge in a Pear Tree."},
+	{4, "On the fourth day of Christmas my true love gave to me, four Calling Birds, three French Hens, two Turtle Doves, and a Partridge in a Pear Tree."},
+	{5, "On the fifth day of Christmas my true love gave to me, five Gold Rings, four Calling Birds, three French Hens, two Turtle Doves, and a Partridge in a Pear Tree."},
+	{6, "On the sixth day of Christmas my true love gave to me, six Geese-a-Laying, five Gold Rings, four Calling Birds, three French Hens, two Turtle Doves, and a Partridge in a Pear Tree."},
+	{7, "On the seventh day of Christmas my true love gave to me, seven Swans-a-Swimming, six Geese-a-Laying, five Gold Rings, four Calling Birds, three French Hens, two Turtle Doves, and a Partridge in a Pear Tree."},
+	{8, "On the eighth day of Christmas my true love gave to me, eight Maids-a-Milking, seven Swans-a-Swimming, six Geese-a-Laying, five Gold Rings, four Calling Birds, three French Hens, two Turtle Doves, and a Partridge in a Pear Tree."},
+	{9, "On the ninth day of Christmas my true love gave to me, nine Ladies Dancing, eight Maids-a-Milking, seven Swans-a-Swimming, six Geese-a-Laying, five Gold Rings, four Calling Birds, three French Hens, two Turtle Doves, and a Partridge in a Pear Tree."},
+	{10, "On the tenth day of Christmas my true love gave to me, ten Lords-a-Leaping, nine Ladies Dancing, eight Maids-a-Milking, seven Swans-a-Swimming, six Geese-a-Laying, five Gold Rings, four Calling Birds, three French Hens, two Turtle Doves, and a Partridge in a Pear Tree."},
+	{11, "On the eleventh day of Christmas my true love gave to me, eleven Pipers Piping, ten Lords-a-Leaping, nine Ladies Dancing, eight Maids-a-Milking, seven Swans-a-Swimming, six Geese-a-Laying, five Gold Rings, four Calling Birds, three French Hens, two Turtle Doves, and a Partridge in a Pear Tree."},
+	{12, "On the twelfth day of Christmas my true love gave to me, twelve Drummers Drumming, eleven Pipers Piping, ten Lords-a-Leaping, nine Ladies Dancing, eight Maids-a-Milking, seven Swans-a-Swimming, six Geese-a-Laying, five Gold Rings, four Calling Birds, three French Hens, two Turtle Doves, and a Partridge in a Pear Tree."},
+}
+
+// diff compares two multi-line strings and returns a helpful comment
+func diff(got, want string) string {
+	g := strings.Split(got, "\n")
+	w := strings.Split(want, "\n")
+	for i := 0; ; i++ {
+		switch {
+		case i < len(g) && i < len(w):
+			if g[i] == w[i] {
+				continue
+			}
+			return fmt.Sprintf("-- first difference in line %d:\n"+
+				"-- got : %q\n-- want: %q\n", i+1, g[i], w[i])
+		case i < len(g):
+			return fmt.Sprintf("-- got %d extra lines after line %d:\n"+
+				"-- first extra line: %q\n", len(g)-len(w), i, g[i])
+		case i < len(w):
+			return fmt.Sprintf("-- got %d correct lines, want %d more lines:\n"+
+				"-- want next: %q\n", i, len(w)-i, w[i])
+		default:
+			return "no differences found"
+		}
+	}
+}
+
+func TestSong(t *testing.T) {
+	var expected = ""
+	for _, test := range testCases {
+		expected += test.expected + "\n"
+	}
+	actual := Song()
+	if expected != actual {
+		t.Fatalf("Song() =\n%s\n  want:\n%s\n%s", actual, expected, diff(actual, expected))
+	}
+}
+
+func TestVerse(t *testing.T) {
+	for _, test := range testCases {
+		actual := Verse(test.input)
+		if actual != test.expected {
+			t.Errorf("Twelve Days test [%d], expected [%s], actual [%s]", test.input, test.expected, actual)
+		}
+	}
+}
+
+func TestTestVersion(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Errorf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
+	}
+}