Initial Commit

go/queen-attack/README.md

@@ -0,0 +1,40 @@
+# Queen Attack
+
+Write a program that positions two queens on a chess board and indicates whether or not they are positioned so that they can attack each other.
+
+In the game of chess, a queen can attack pieces which are on the same
+row, column, or diagonal.
+
+A chessboard can be represented by an 8 by 8 array.
+
+So if you're told the white queen is at (2, 3) and the black queen at
+(5, 6), then you'd know you've got a set-up like so:
+
+```plain
+_ _ _ _ _ _ _ _
+_ _ _ _ _ _ _ _
+_ _ _ W _ _ _ _
+_ _ _ _ _ _ _ _
+_ _ _ _ _ _ _ _
+_ _ _ _ _ _ B _
+_ _ _ _ _ _ _ _
+_ _ _ _ _ _ _ _
+```
+
+You'd also be able to answer whether the queens can attack each other.
+In this case, that answer would be yes, they can, because both pieces
+share a diagonal.
+
+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://help.exercism.io/getting-started-with-go.html).
+
+## Source
+
+J Dalbey's Programming Practice problems [view source](http://users.csc.calpoly.edu/~jdalbey/103/Projects/ProgrammingPractice.html)

go/queen-attack/queen_attack.go

@@ -0,0 +1,29 @@
+package queenattack
+
+import (
+	"errors"
+	"math"
+)
+
+// CanQueenAttack takes two positions one for a
+// white queen (wq) and one for a black queen (bq)
+// it returns a boolean value: if an attack can
+// be made, and an error
+func CanQueenAttack(wq, bq string) (bool, error) {
+	if len(wq) != 2 || len(bq) != 2 ||
+		wq[0] < 'a' || wq[0] > 'z' ||
+		wq[1] < '0' || wq[1] > '8' ||
+		bq[0] < 'a' || bq[0] > 'z' ||
+		bq[1] < '0' || bq[1] > '8' ||
+		wq == bq {
+		return false, errors.New("Invalid pieces/placement")
+	}
+	wx, wy := float64(int8(wq[0])), float64(int8(wq[1]))
+	bx, by := float64(int8(bq[0])), float64(int8(bq[1]))
+	if wx == bx || wy == by ||
+		math.Abs(wx-bx) == math.Abs(wy-by) {
+		return true, nil
+	}
+
+	return false, nil
+}

go/queen-attack/queen_attack_test.go

@@ -0,0 +1,53 @@
+package queenattack
+
+import "testing"
+
+// Arguments to CanQueenAttack are in algebraic notation.
+// See http://en.wikipedia.org/wiki/Algebraic_notation_(chess)
+
+var tests = []struct {
+	w, b   string
+	attack bool
+	ok     bool
+}{
+	{"b4", "b4", false, false},      // same square
+	{"a8", "b9", false, false},      // off board
+	{"here", "there", false, false}, // invalid
+	{"", "", false, false},
+
+	{"b3", "d7", false, true}, // no attack
+	{"b4", "b7", true, true},  // same file
+	{"e4", "b4", true, true},  // same rank
+	{"a1", "f6", true, true},  // common diagonals
+	{"a6", "b7", true, true},
+	{"d1", "f3", true, true},
+	{"f1", "a6", true, true},
+}
+
+func TestCanQueenAttack(t *testing.T) {
+	for _, test := range tests {
+		switch attack, err := CanQueenAttack(test.w, test.b); {
+		case err != nil:
+			if test.ok {
+				t.Fatalf("CanQueenAttack(%s, %s) returned error %q.  "+
+					"Error not expected.",
+					test.w, test.b, err)
+			}
+		case !test.ok:
+			t.Fatalf("CanQueenAttack(%s, %s) = %t, %v.  Expected error.",
+				test.w, test.b, attack, err)
+		case attack != test.attack:
+			t.Fatalf("CanQueenAttack(%s, %s) = %t, want %t.",
+				test.w, test.b, attack, test.attack)
+		}
+	}
+}
+
+// Benchmark combined time for all test cases
+func BenchmarkCanQueenAttack(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, test := range tests {
+			CanQueenAttack(test.w, test.b)
+		}
+	}
+}