Uniform cost player

Author: jamesrcounts

src/main/java/org/teachingextensions/logo/BreadthFirstPlayer.java

@@ -1,39 +1,14 @@
 package org.teachingextensions.logo;
 
-import java.util.*;
+import java.util.ArrayDeque;
 
 /**
  * A player who solves puzzles using breadth-first search.
  */
-public class BreadthFirstPlayer {
-  private final Puzzle puzzle;
-  private final Set<PuzzleState>  visited  = new HashSet<>();
-  private final Queue<PuzzleState> frontier = new ArrayDeque<>();
+public class BreadthFirstPlayer extends PuzzlePlayer {
 
   public BreadthFirstPlayer(Puzzle puzzle) {
-
-    this.puzzle = puzzle;
+    super(puzzle, new ArrayDeque<PuzzleState>());
   }
 
-  public PuzzleState solve() {
-    PuzzleState state = new PuzzleState(this.puzzle);
-    do {
-      visited.add(state);
-      if (!state.isSolution()){
-        this.search(state);
-      }
-      state = frontier.remove();
-    } while (!state.isSolution());
-
-    return state;
-  }
-
-  private void search(PuzzleState state) {
-    List<PuzzleState> branches = state.getBranches();
-    for(PuzzleState b : branches){
-      if (!visited.contains(b)){
-        frontier.add(b);
-      }
-    }
-  }
 }

src/main/java/org/teachingextensions/logo/PuzzlePlayerTest.java

@@ -0,0 +1,30 @@
+package org.teachingextensions.logo;
+
+import org.teachingextensions.approvals.lite.Approvals;
+
+/**
+ * Test a puzzle player
+ */
+public abstract class PuzzlePlayerTest {
+
+
+  protected void verifySolution() {
+    int[] cells = {0, 1, 2, 3, 4, 5, 6, 8, 7};
+    Puzzle p = new Puzzle(cells);
+    PuzzlePlayer b = getPlayer(p);
+    PuzzleState s = b.solve();
+    Approvals.verifyAll("Solve " + p, s.getHistory());
+  }
+
+  protected abstract PuzzlePlayer getPlayer(Puzzle puzzle);
+
+
+  protected void verifyLongSolution() {
+    int[] cells = {0, 1, 2, 3, 4, 8, 5, 6, 7};
+    Puzzle p = new Puzzle(cells);
+    PuzzlePlayer b = getPlayer(p);
+
+    PuzzleState s = b.solve();
+    Approvals.verifyAll("From " + p + " to " + s.getPuzzle(), s.getHistory());
+  }
+}

src/main/java/org/teachingextensions/logo/PuzzleState.java

@@ -1,14 +1,15 @@
 package org.teachingextensions.logo;
 
 import java.util.ArrayList;
+import java.util.Comparator;
 import java.util.List;
 import java.util.Stack;
 
 /**
  * Represents a node in the puzzle-solving graph.  Keeps track of the current puzzle arrangement and the actions
  * required to arrive at the current arrangement from the starting arrangement.
  */
-public class PuzzleState {
+public class PuzzleState implements Comparator<PuzzleState> , Comparable<PuzzleState>{
   private final Puzzle           puzzle;
   private final Stack<Direction> history;
 
@@ -77,6 +78,20 @@ public Puzzle getPuzzle() {
     return this.puzzle;
   }
 
+  public int getActualCost() {
+    return this.history.size();
+  }
+
+  @Override
+  public int compare(PuzzleState o1, PuzzleState o2) {
+    return o1.getActualCost() - o2.getActualCost();
+  }
+
+  @Override
+  public int compareTo(PuzzleState o) {
+    return compare(this, o);
+  }
+
   public enum Direction {
     Left(-1), Right(1), Up(-3), Down(3);
 

src/main/java/org/teachingextensions/logo/UniformCostPlayer.java

@@ -0,0 +1,15 @@
+package org.teachingextensions.logo;
+
+import java.util.PriorityQueue;
+
+/**
+ * Uniform cost player tries to pick the solution with the least number of steps.  The player treats every step as
+ * if to costs the same as any other step.
+ */
+public class UniformCostPlayer extends PuzzlePlayer {
+  public UniformCostPlayer(Puzzle puzzle) {
+    super(puzzle, new PriorityQueue<PuzzleState>());
+  }
+
+
+}

src/test/java/org/teachingextensions/logo/BreadthFirstPlayerTest.java

@@ -1,34 +1,30 @@
 package org.teachingextensions.logo;
 
 import org.junit.Test;
-import org.teachingextensions.approvals.lite.Approvals;
 import org.teachingextensions.approvals.lite.reporters.UseReporter;
 import org.teachingextensions.approvals.lite.reporters.macosx.BeyondCompareReporter;
 
 @UseReporter(BeyondCompareReporter.class)
-public class BreadthFirstPlayerTest {
+public class BreadthFirstPlayerTest extends PuzzlePlayerTest {
+
+  @Override
+  protected PuzzlePlayer getPlayer(Puzzle puzzle) {
+    return new BreadthFirstPlayer(puzzle);
+  }
+
   /**
    * Produces a puzzle solution
    */
   @Test
   public void solve_puzzle() throws Exception {
-    int[] cells = {0, 1, 2, 3, 4, 5, 6, 8, 7};
-    Puzzle p = new Puzzle(cells);
-    BreadthFirstPlayer b = new BreadthFirstPlayer(p);
-    PuzzleState s = b.solve();
-    Approvals.verifyAll("Solve " + p, s.getHistory());
+    verifySolution();
   }
 
   /**
    * Solve longer puzzle
    */
   @Test
   public void solve_longer_puzzle() throws Exception {
-    int[] cells = {0, 1, 2, 3, 4, 8, 5, 6, 7};
-    Puzzle p = new Puzzle(cells);
-    BreadthFirstPlayer b = new BreadthFirstPlayer(p);
-
-    PuzzleState s = b.solve();
-    Approvals.verifyAll("From " + p + " to " + s.getPuzzle(), s.getHistory());
+    verifyLongSolution();
   }
 }

src/test/java/org/teachingextensions/logo/PuzzleStateTest.java

@@ -5,6 +5,9 @@
 import org.teachingextensions.approvals.lite.reporters.UseReporter;
 import org.teachingextensions.approvals.lite.reporters.macosx.BeyondCompareReporter;
 
+import java.util.Stack;
+
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
 @UseReporter(BeyondCompareReporter.class)
@@ -60,7 +63,7 @@ public void moves_from_top_right() {
    * Or we can see the next moves from the center
    */
   @Test
-  public void moves_from_center(){
+  public void moves_from_center() {
     Puzzle p = getPuzzle(4);
     PuzzleState s = new PuzzleState(p);
     Approvals.verifyAll("Branches for " + s, s.getBranches());
@@ -70,8 +73,29 @@ public void moves_from_center(){
    * Finally, lets see what moves we can do from top center.
    */
   @Test
-  public void moves_from_top_center(){
+  public void moves_from_top_center() {
     PuzzleState s = new PuzzleState(getPuzzle(1));
     Approvals.verifyAll("Branches for " + s, s.getBranches());
   }
+
+  /**
+   * The actual cost is zero when there is no history
+   */
+  @Test
+  public void actual_cost() {
+    PuzzleState s = new PuzzleState(getSolvedPuzzle());
+    assertEquals(0, s.getActualCost());
+  }
+
+  /**
+   * The actual cost is the number of steps in the the history
+   */
+  @Test
+  public void actual_cost_is_actual_steps() {
+    Stack<PuzzleState.Direction> history = new Stack<>();
+    history.add(PuzzleState.Direction.Right);
+    history.add(PuzzleState.Direction.Right);
+    PuzzleState s = new PuzzleState(getSolvedPuzzle(), history);
+    assertEquals(2, s.getActualCost());
+  }
 }

src/test/java/org/teachingextensions/logo/UniformCostPlayerTest.java

@@ -0,0 +1,29 @@
+package org.teachingextensions.logo;
+
+import org.junit.Test;
+import org.teachingextensions.approvals.lite.reporters.UseReporter;
+import org.teachingextensions.approvals.lite.reporters.macosx.BeyondCompareReporter;
+
+@UseReporter(BeyondCompareReporter.class)
+public class UniformCostPlayerTest extends PuzzlePlayerTest {
+  @Override
+  protected PuzzlePlayer getPlayer(Puzzle puzzle) {
+    return new UniformCostPlayer(puzzle);
+  }
+
+  /**
+   * Produces a puzzle solution
+   */
+  @Test
+  public void solve_puzzle() throws Exception {
+    verifySolution();
+  }
+
+  /**
+   * Solve longer puzzle
+   */
+  @Test
+  public void solve_longer_puzzle() throws Exception {
+    verifyLongSolution();
+  }
+}

src/test/java/org/teachingextensions/logo/UniformCostPlayerTest.solve_longer_puzzle.approved.txt

@@ -0,0 +1,16 @@
+From [0, 1, 2, 3, 4, 8, 5, 6, 7] to [0, 1, 2, 3, 4, 5, 6, 7, 8]
+
+
+{Down = 3}
+{Left = -1}
+{Left = -1}
+{Up = -3}
+{Right = 1}
+{Down = 3}
+{Right = 1}
+{Up = -3}
+{Left = -1}
+{Left = -1}
+{Down = 3}
+{Right = 1}
+{Right = 1}

src/test/java/org/teachingextensions/logo/UniformCostPlayerTest.solve_puzzle.approved.txt

@@ -0,0 +1,4 @@
+Solve [0, 1, 2, 3, 4, 5, 6, 8, 7]
+
+
+{Right = 1}