distance to goal

Author: jamesrcounts

src/main/java/org/teachingkidsprogramming/section08tdd/PuzzleSolver.java

@@ -29,7 +29,7 @@ public void run() {
 
       try {
         Thread.sleep(10);
-      } catch (InterruptedException e) {
+      } catch (InterruptedException ignored) {
       }
     }
   }
@@ -52,7 +52,7 @@ private void update(final PuzzleBoard puzzle) {
   private void solve(PuzzleBoard puzzle) {
     this.copyToHistory(puzzle);
 
-    int mininumCost = Integer.MAX_VALUE;
+    int minimumCost = Integer.MAX_VALUE;
     TileMove min = null;
     // create a list of all moves that are possible
     List<TileMove> moves = createMoves();
@@ -68,9 +68,9 @@ private void solve(PuzzleBoard puzzle) {
       int estimate = estimateSolvingCost(next, this.history);
 
       // if the cost is the smallest we've seen so far
-      if (estimate < mininumCost) {
+      if (estimate < minimumCost) {
         // remember the move and the cost
-        mininumCost = estimate;
+        minimumCost = estimate;
         min = tileMove;
       }
 
@@ -144,6 +144,7 @@ private boolean animate(PuzzleBoard puzzle) {
     return true;
   }
 
+  @SuppressWarnings("UnusedDeclaration")
   private static void animationDemo(final PuzzleBoard puzzle) {
     Point target = puzzle.getPositions().get(8);
     Tile piece = puzzle.getPiece(7);
@@ -159,16 +160,12 @@ public static int distance(Point start, Point end) {
     return Math.abs(start.x - end.x) + Math.abs(start.y - end.y);
   }
 
-  public static int distance(PuzzleBoard start, PuzzleBoard end) {
+  public static int distance(PuzzleBoard start) {
     int result = 0;
     for (Tile tile : start.getTiles()) {
-      // tile has a position index of its goal
       int goalIndex = tile.getCorrectPositionIndex();
-      //  get the goal position
       Point goal = start.getPositions().get(goalIndex);
-      // tile has a current position
       Point position = tile.getPosition();
-      // sum the distances
       result += distance(position, goal);
     }
     return result;

src/test/java/org/teachingextensions/logo/tests/PuzzleSolverTest.java

@@ -57,7 +57,7 @@ public void manhattanDistanceFromEightToZeroTest() {
   @Test
   public void distanceFromSolvedToSolved() {
     PuzzleBoard solved = getSolvedPuzzle();
-    assertEquals(0, PuzzleSolver.distance(solved, solved));
+    assertEquals(0, PuzzleSolver.distance(solved));
   }
 
   private PuzzleBoard getSolvedPuzzle() {
@@ -78,6 +78,39 @@ public void distanceForPuzzleWithOneMisplacedTile() {
     List<Tile> tiles = PuzzleBoard.createTiles(positions);
     PuzzleBoard b = new PuzzleBoard(PuzzleBoard.createPositions(), tiles);
     int expected = PuzzleSolver.distance(positions[8], positions[7]);
-    assertEquals(expected, PuzzleSolver.distance(b, getSolvedPuzzle()));
+    assertEquals(expected, PuzzleSolver.distance(b));
+  }
+
+  @Test
+  public void distanceForPuzzleWithSeveralMisplacedTiles() {
+    Point[] positions = PuzzleBoard.createPositions();
+
+    positions = swap(positions, 7, 8);
+    positions = swap(positions, 1, 4);
+    positions = swap(positions, 6, 2);
+
+    List<Tile> tiles = PuzzleBoard.createTiles(positions);
+
+    // cost of swaps
+    int expected = PuzzleSolver.distance(positions[8], positions[7]) +
+        PuzzleSolver.distance(positions[1], positions[4]) +
+        PuzzleSolver.distance(positions[6], positions[2]);
+
+    // each swap requires 2 tiles to move
+    expected *= 2;
+
+    // except the blank
+    expected -= PuzzleSolver.distance(positions[8], positions[7]);
+
+
+    PuzzleBoard b = new PuzzleBoard(PuzzleBoard.createPositions(), tiles);
+    assertEquals(expected, PuzzleSolver.distance(b));
+  }
+
+  private Point[] swap(Point[] positions, int i, int j) {
+    Point p = positions[i];
+    positions[i] = positions[j];
+    positions[j] = p;
+    return positions;
   }
 }