queen-attack: add to track

config.json

@@ -44,7 +44,8 @@
     "pascals-triangle",
     "beer-song",
     "difference-of-squares",
-    "largest-series-product"
+    "largest-series-product",
+    "queen-attack"
   ],
   "exercises": [
     {
@@ -251,6 +252,11 @@
       "slug": "largest-series-product",
       "difficulty": 1,
       "topics": []
+    },
+    {
+      "slug": "queen-attack",
+      "difficulty": 1,
+      "topics": []
     }
   ],
   "deprecated": [

exercises/queen-attack/build.gradle

@@ -0,0 +1,17 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  testCompile "junit:junit:4.12"
+}
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/queen-attack/src/example/java/QueenAttackCalculator.java

@@ -0,0 +1,86 @@
+import java.util.Arrays;
+
+public final class QueenAttackCalculator {
+
+    private final int[] queen1Coordinates;
+
+    private final int[] queen2Coordinates;
+
+    public QueenAttackCalculator(final int[] queen1Coordinates, final int[] queen2Coordinates)
+            throws IllegalArgumentException {
+
+        this.queen1Coordinates = queen1Coordinates;
+        this.queen2Coordinates = queen2Coordinates;
+
+        validateInputs();
+    }
+
+    public boolean canQueensAttackOneAnother() {
+        return queensShareFile() || queensShareRank() || queensShareDiagonal();
+    }
+
+    private void validateInputs() throws IllegalArgumentException {
+        if (queen1Coordinates == null
+                || queen2Coordinates == null
+                || queen1Coordinates.length != 2
+                || queen2Coordinates.length != 2) {
+
+            throw new IllegalArgumentException("You must supply valid 2-dimensional coordinate arrays for both Queens.");
+        }
+
+        final int[] rankCoordinates = new int[2];
+        rankCoordinates[0] = queen1Coordinates[0];
+        rankCoordinates[1] = queen2Coordinates[0];
+        Arrays.sort(rankCoordinates);
+
+        if (rankCoordinates[0] < 0) {
+            throw new IllegalArgumentException("Queens must both have positive rank.");
+        }
+
+        if (rankCoordinates[1] > 7) {
+            throw new IllegalArgumentException("Queens must both have rank <= 7.");
+        }
+
+        final int[] fileCoordinates = new int[2];
+        fileCoordinates[0] = queen1Coordinates[1];
+        fileCoordinates[1] = queen2Coordinates[1];
+        Arrays.sort(fileCoordinates);
+
+        if (fileCoordinates[0] < 0) {
+            throw new IllegalArgumentException("Queens must both have positive file.");
+        }
+
+        if (fileCoordinates[1] > 7) {
+            throw new IllegalArgumentException("Queens must both have file <= 7.");
+        }
+
+        if (queensShareSquare()) {
+            throw new IllegalArgumentException("Queens must not occupy the same square.");
+        }
+    }
+
+    private boolean queensShareRank() {
+        return differenceBetweenRanks() == 0;
+    }
+
+    private boolean queensShareFile() {
+        return differenceBetweenFiles() == 0;
+    }
+
+    private boolean queensShareSquare() {
+        return queensShareRank() && queensShareFile();
+    }
+
+    private boolean queensShareDiagonal() {
+        return differenceBetweenRanks() == differenceBetweenFiles();
+    }
+
+    private int differenceBetweenRanks() {
+        return Math.abs(queen1Coordinates[0] - queen2Coordinates[0]);
+    }
+
+    private int differenceBetweenFiles() {
+        return Math.abs(queen1Coordinates[1] - queen2Coordinates[1]);
+    }
+
+}

exercises/queen-attack/src/main/java/QueenAttackCalculator.java

@@ -0,0 +1,5 @@
+public final class QueenAttackCalculator {
+
+
+
+}

exercises/queen-attack/src/test/java/QueenAttackCalculatorTest.java

@@ -0,0 +1,114 @@
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import static org.junit.Assert.assertTrue;
+
+public final class QueenAttackCalculatorTest {
+
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    @Test
+    public void testNoExceptionThrownIfBothQueenPositionsValid() {
+        new QueenAttackCalculator(new int[]{2, 2}, new int[]{0, 7});
+    }
+
+    @Ignore
+    @Test
+    public void testNullInputNotAllowed() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("You must supply valid 2-dimensional coordinate arrays for both Queens.");
+
+        new QueenAttackCalculator(null, new int[]{3, 4});
+    }
+
+    @Ignore
+    @Test
+    public void testNegativeRankNotAllowed() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Queens must both have positive rank.");
+
+        new QueenAttackCalculator(new int[]{-2, 2}, new int[]{2, 2});
+    }
+
+    @Ignore
+    @Test
+    public void testRankGreaterThan7NotAllowed() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Queens must both have rank <= 7.");
+
+        new QueenAttackCalculator(new int[]{8, 4}, new int[]{1, 6});
+    }
+
+    @Ignore
+    @Test
+    public void testNegativeFileNotAllowed() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Queens must both have positive file.");
+
+        new QueenAttackCalculator(new int[]{2, -2}, new int[]{5, 3});
+    }
+
+    @Ignore
+    @Test
+    public void testFileGreaterThan7NotAllowed() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Queens must both have file <= 7.");
+
+        new QueenAttackCalculator(new int[]{4, 8}, new int[]{7, 4});
+    }
+
+    @Ignore
+    @Test
+    public void testQueensMustNotOccupyTheSameSquare() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Queens must not occupy the same square.");
+
+        new QueenAttackCalculator(new int[]{2, 2}, new int[]{2, 2});
+    }
+
+    @Ignore
+    @Test
+    public void testQueensCanAttackOnTheSameRank() {
+        final QueenAttackCalculator calculator = new QueenAttackCalculator(new int[]{2, 4}, new int[]{2, 6});
+        assertTrue(calculator.canQueensAttackOneAnother());
+    }
+
+    @Ignore
+    @Test
+    public void testQueensCanAttackOnTheSameFile() {
+        final QueenAttackCalculator calculator = new QueenAttackCalculator(new int[]{4, 5}, new int[]{2, 5});
+        assertTrue(calculator.canQueensAttackOneAnother());
+    }
+
+    @Ignore
+    @Test
+    public void testQueensCanAttackOnFirstDiagonal() {
+        final QueenAttackCalculator calculator = new QueenAttackCalculator(new int[]{2, 2}, new int[]{0, 4});
+        assertTrue(calculator.canQueensAttackOneAnother());
+    }
+
+    @Ignore
+    @Test
+    public void testQueensCanAttackOnSecondDiagonal() {
+        final QueenAttackCalculator calculator = new QueenAttackCalculator(new int[]{2, 2}, new int[]{3, 1});
+        assertTrue(calculator.canQueensAttackOneAnother());
+    }
+
+    @Ignore
+    @Test
+    public void testQueensCanAttackOnThirdDiagonal() {
+        final QueenAttackCalculator calculator = new QueenAttackCalculator(new int[]{2, 2}, new int[]{1, 1});
+        assertTrue(calculator.canQueensAttackOneAnother());
+    }
+
+    @Ignore
+    @Test
+    public void testQueensCanAttackOnFourthDiagonal() {
+        final QueenAttackCalculator calculator = new QueenAttackCalculator(new int[]{2, 2}, new int[]{5, 5});
+        assertTrue(calculator.canQueensAttackOneAnother());
+    }
+
+}

exercises/settings.gradle

@@ -25,6 +25,7 @@ include 'pangram'
 include 'pascals-triangle'
 include 'phone-number'
 include 'pig-latin'
+include 'queen-attack'
 include 'raindrops'
 include 'rna-transcription'
 include 'robot-name'