Use Board's == instead of ElementsAreArray

[slidingtile] / sliding_tile_lib.cc

diff --git a/sliding_tile_lib.cc b/sliding_tile_lib.cc
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..6b42f284690069e13f0f2371aeb6525018fa0674 100644 (file)
--- a/sliding_tile_lib.cc
+++ b/sliding_tile_lib.cc
@@ -0,0 +1,151 @@
+#include "sliding_tile_lib.h"
+
+#include <cstdlib>
+#include <istream>
+#include <memory>
+#include <ostream>
+#include <stdexcept>
+#include <vector>
+
+signed char Step::adjacent[BOARD_SIZE][5] = {
+  1,   4,   -1,  -1,  -1,
+  0,   2,   5,   -1,  -1,
+  1,   3,   6,   -1,  -1,
+  2,   7,   -1,  -1,  -1,
+  0,   5,   8,   -1,  -1,
+  1,   4,   6,   9,   -1,
+  2,   5,   7,   10,  -1,
+  3,   6,   11,  -1,  -1,
+  4,   9,   12,  -1,  -1,
+  5,   8,   10,  13,  -1,
+  6,   9,   11,  14,  -1,
+  7,   10,  15,  -1,  -1,
+  8,   13,  -1,  -1,  -1,
+  9,   12,  14,  -1,  -1,
+  10,  13,  15,  -1,  -1,
+  11,  14,  -1,  -1,  -1,
+};
+
+bool Board::is_valid() const {
+  bool seen[BOARD_SIZE];
+  for (int i = 0; i < BOARD_SIZE; i++) {
+    seen[i] = false;
+  }
+
+  for (int i = 0; i < BOARD_SIZE; i++) {
+    if (board[i] < 0 || board[i] >= BOARD_SIZE || seen[board[i]]) {
+      return false;
+    }
+    seen[board[i]] = true;
+  }
+
+  // Redundant because pigeon-hole-principle, but check anyway
+  for (int i = 0; i < BOARD_SIZE; i++) {
+    if (!seen[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool Board::operator==(const Board& o) const {
+  for (int i = 0; i < BOARD_SIZE; i++) {
+    if (board[i] != o.board[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool Board::operator!=(const Board& o) const {
+  return !operator==(o);
+}
+
+std::istream& operator>>(std::istream& is, Board& board) {
+  for (int i = 0; i < BOARD_SIZE; i++) {
+    if (!is.good()) {
+      is.setstate(std::istream::failbit);
+      break;
+    }
+    if (i > 0 && is.get() != ',') {
+      is.setstate(std::istream::failbit);
+      break;
+    }
+    int numeric;
+    is >> numeric;
+    board.board[i] = numeric;
+  }
+  if (!board.is_valid()) {
+    is.setstate(std::istream::failbit);
+  }
+  return is;
+}
+
+std::ostream& operator<<(std::ostream& os, const Board& board) {
+  for (int i = 0; i < BOARD_SIZE; i++) {
+    if (i > 0) {
+      os << " ";
+    }
+    os << int(board.board[i]);
+  }
+  return os;
+}
+
+signed char Board::hole() const {
+  for (int i = 0; i < BOARD_SIZE; i++) {
+    if (board[i] == 0) {
+      return i;
+    }
+  }
+  throw std::runtime_error("Board with no hole");
+}
+
+InvertedBoard Board::invert() const {
+  InvertedBoard inv;
+  for (int i = 0; i < BOARD_SIZE; i++) {
+    inv.pos[board[i]] = i;
+  }
+  return inv;
+}
+
+int Board::distance(const Board& o) const {
+  return distance(o.invert());
+}
+
+int Board::distance(const InvertedBoard& invo) const {
+  int dist = 0;
+  for (int i = 0; i < BOARD_SIZE; i++) {
+    dist += std::abs(i % BOARD_DIM - invo.pos[board[i]] % BOARD_DIM) +
+            std::abs(i / BOARD_DIM - invo.pos[board[i]] / BOARD_DIM);
+  }
+  return dist;
+}
+
+std::vector<Step*> Step::successors(std::shared_ptr<Step> shared_this) {
+  std::vector<Step*> suc;
+  signed char hole_pos = board.hole();
+  for (int i = 0; adjacent[hole_pos][i] > 0; i++) {
+    suc.emplace_back(new Step{board, shared_this});
+    std::swap(suc.back()->board.board[hole_pos], suc.back()->board.board[adjacent[hole_pos][i]]);
+  }
+  return suc;
+}
+
+std::ostream& operator<<(std::ostream& os, const Step& step) {
+  if (step.prev != nullptr) {
+    os << *step.prev;
+    signed char this_hole = step.board.hole();
+    signed char prev_hole = step.prev->board.hole();
+    os << int(step.board.board[prev_hole]) << " ";
+    switch (this_hole - prev_hole) {
+      case -1:         os << "right";    break;
+      case  1:         os << "left";     break;
+      case -BOARD_DIM: os << "down";     break;
+      case BOARD_DIM:  os << "up";       break;
+      default:         os << "somehow!"; break;
+    }
+    os << std::endl;
+  }
+  return os;
+}