sudoku_gem 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cc3301c8876d099d322ce989574598232841a388
+  data.tar.gz: 333dc8fa1b65c8296e571c7316279e660405556d
+SHA512:
+  metadata.gz: 6aec0f8e6e95b1b38b0a8212b425f108f429f13018a702d7e7f57d80235457ace45627fbc3e5405104a1cf5917bb0098a4e3a1ff1f449372625a621dad072435
+  data.tar.gz: 9f28eae02891e28f1388b0fab319bc6b93b99b271c58148a592e341618f4cf19d011ce6887ca1058695a43df9877d4425029fd8788a3c9aa5fab6cf18c5d18af

data/ext/sudoku_gem/extconf.rb

@@ -0,0 +1,8 @@
+require 'mkmf'
+
+CONFIG['CC'] = CONFIG['CXX'] or 'g++'
+$CFLAGS << ' --std=c++11'
+have_library('stdc++')
+$warnflags.gsub!(' -Wdeclaration-after-statement','')
+$warnflags.gsub!(' -Wimplicit-function-declaration','')
+create_makefile 'sudoku_gem/sudoku_gem'

data/ext/sudoku_gem/grid.cpp

@@ -0,0 +1,89 @@
+/*
+ *  Sudoku Base - a library for solving Sudoku puzzles
+ *  Copyright (C) 2013  Neal Patel <nealp9084@gmail.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "grid.h"
+
+#include <sstream>
+
+Grid::Grid(std::size_t n) : matrix(boost::extents[n][n]), dim(n)
+{
+}
+
+Grid::Grid(const Grid& grid) : matrix(grid.matrix), dim(grid.dim)
+{
+}
+
+Grid& Grid::operator=(const Grid& grid)
+{
+  this->matrix = grid.matrix;
+  this->dim = grid.dim;
+  return *this;
+}
+
+int Grid::get(std::size_t x, std::size_t y) const
+{
+  return this->matrix[y][x];
+}
+
+void Grid::set(std::size_t x, std::size_t y, int i)
+{
+  this->matrix[y][x] = i;
+}
+
+std::size_t Grid::n() const
+{
+  return this->dim;
+}
+
+void Grid::reset(std::size_t n)
+{
+  this->matrix.resize(boost::extents[n][n]);
+  this->dim = n;
+}
+
+std::string Grid::to_s() const
+{
+  std::stringstream out;
+  this->to_s(out);
+  return out.str();
+}
+
+void Grid::to_s(std::ostream& out) const
+{
+  for (std::size_t y = 0; y < this->dim; y++)
+  {
+    if (y != 0)
+    {
+      out << std::endl;
+    }
+
+    for (std::size_t x = 0; x < this->dim; x++)
+    {
+      if (x != 0)
+      {
+        out << ' ';
+      }
+
+      out << this->matrix[y][x];
+    }
+  }
+}
+
+Grid::~Grid()
+{
+}

data/ext/sudoku_gem/grid.h

@@ -0,0 +1,115 @@
+/*
+ *  Sudoku Base - a library for solving Sudoku puzzles
+ *  Copyright (C) 2013  Neal Patel <nealp9084@gmail.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GRID_H
+#define GRID_H
+
+#include <cstddef>
+#include <string>
+#include <streambuf>
+#include <boost/multi_array.hpp>
+
+/**
+ * @brief A class that represents the state of a Sudoku board
+ * 
+ * The Grid class represents the current state of a particular Sudoku board. It is essentially a
+ * wrapper around a square, 2D array, except that it does not need to be defined at compile-time.
+ * The grid is stored in an underlying boost::multi_array<int, 2>, and it has all the typical
+ * accessors: set an element, get an element, get the grid size, and set the grid size.
+ **/
+class Grid
+{
+public:
+  /**
+   * @brief Construct a n*n grid
+   *
+   * @param n Side length of the square, 2D array.
+   **/
+  Grid(std::size_t n);
+  /**
+   * @brief Copy-construct a grid from another grid
+   *
+   * @param grid The other grid.
+   **/
+  Grid(Grid const& grid);
+  virtual ~Grid();
+
+  /**
+   * @brief Copy another grid
+   *
+   * @param grid The other grid.
+   * @return Grid& The current grid.
+   **/
+  Grid& operator =(Grid const& grid);
+
+  /**
+   * @brief Resize the existing grid so that it is an n*n grid
+   *
+   * @param n Side length of the square, 2D array.
+   **/
+  void reset(std::size_t n);
+
+  /**
+   * @brief Get the value of a specific element
+   *
+   * @param x The X-index of the element.
+   * @param y The Y-index of the element.
+   * @return int The value of the element.
+   **/
+  int get(std::size_t x, std::size_t y) const;
+  /**
+   * @brief Set the value of a specific element
+   *
+   * @param x The X-index of the element.
+   * @param y The Y-index of the element.
+   * @param i The new value of the element.
+   **/
+  void set(std::size_t x, std::size_t y, int i);
+
+  /**
+   * @brief The side length of the square, 2D array
+   *
+   * @return std::size_t The side-length.
+   **/
+  std::size_t n() const;
+  
+  /**
+   * @brief Show the grid in a human-readable form.
+   *
+   * @return std::string The grid.
+   **/
+  std::string to_s() const;
+  /**
+   * @brief Convert the grid to a human-readable form and pipe that into the given output stream.
+   *
+   * @param out The output stream.
+   **/
+  void to_s(std::ostream& out) const;
+
+private:
+  /**
+   * @brief The underlying grid.
+   **/
+  boost::multi_array<int, 2> matrix;
+  /**
+   * @brief The side length of the grid.
+   **/
+  std::size_t dim;
+};
+
+#endif // GRID_H

data/ext/sudoku_gem/main.cpp

@@ -0,0 +1,48 @@
+/*
+ *  Sudoku Base - a library for solving Sudoku puzzles
+ *  Copyright (C) 2013  Neal Patel <nealp9084@gmail.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "sudoku.h"
+#include <iostream>
+
+int main(int argc, char* argv[])
+{
+  Sudoku puzzle;
+  puzzle.read_puzzle_from_file(std::cin);
+
+  if (puzzle)
+  {
+    std::cout << "Read the board in OK." << std::endl;
+  }
+  else
+  {
+    std::cout << "Failed to read the board from cin." << std::endl;
+    return 1;
+  }
+
+  std::cout << "Here's the current state of the board." << std::endl;
+  puzzle.print(std::cout);
+
+  std::cout << std::endl << "Solving the puzzle..." << std::endl;
+
+  puzzle.solve_colorability_style();
+
+  std::cout << "A solution was found!" << std::endl;
+  puzzle.print(std::cout);
+
+  return 0;
+}

data/ext/sudoku_gem/sudoku.cpp

@@ -0,0 +1,385 @@
+/*
+ *  Sudoku Base - a library for solving Sudoku puzzles
+ *  Copyright (C) 2013  Neal Patel <nealp9084@gmail.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "sudoku.h"
+#include "validator.h"
+
+#include <stdexcept>
+#include <sstream>
+#include <algorithm>
+#include <boost/algorithm/string.hpp>
+
+Sudoku::Sudoku() : grid(0), status_ok(false)
+{
+}
+
+bool Sudoku::insert_row(std::vector<std::string>& tokens, std::size_t y)
+{
+  for (std::size_t x = 0; x < this->grid.n(); x++)
+  {
+    std::string const& token = tokens[x];
+
+    try
+    {
+      int value = std::stoi(token);
+
+      //integer tokens must be between 1 and n, and unknowns should be question marks
+      if (value < 1 || value > (int)this->grid.n())
+      {
+        //invalid value in board
+        return false;
+      }
+      else
+      {
+        this->grid.set(x, y, value);
+      }
+    }
+    catch (std::invalid_argument &)
+    {
+      if (token == "?")
+      {
+        this->grid.set(x, y, -1);
+      }
+      else
+      {
+        //invalid character in board
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+bool Sudoku::parse_puzzle(std::istream& f)
+{
+  std::string line;
+  std::vector<std::string> tokens;
+
+  //read the first line, to figure out n
+  std::getline(f, line);
+  boost::split(tokens, line, boost::is_any_of(" "));
+  std::size_t n = tokens.size();
+
+  if (n == 0 || line.empty())
+  {
+    //empty puzzle
+    return false;
+  }
+
+  //make sure n is a perfect square
+  std::size_t n_sq = std::size_t(sqrt(n));
+
+  if (n_sq * n_sq != n && (n_sq + 1) * (n_sq + 1) != n)
+  {
+    //n is not a perfect square
+    return false;
+  }
+
+  //make sure n is not too big
+
+  if (n > 64)
+  {
+    //the board cannot be solved with this program
+    return false;
+  }
+
+  //create the n*n grid
+  this->grid.reset(n);
+
+  //put in the first row
+  this->insert_row(tokens, 0);
+
+  //read n-1 lines
+  for (std::size_t y = 1; y < n; y++)
+  {
+    std::getline(f, line);
+    boost::split(tokens, line, boost::is_any_of(" "));
+
+    //each line must have n tokens
+    if (tokens.size() != n)
+    {
+      //invalid board
+      return false;
+    }
+
+    //insert that row
+    this->insert_row(tokens, y);
+  }
+
+  return true;
+}
+
+bool Sudoku::validate() const
+{
+  //whether this board is solvable
+  return Validator::is_good_partial_board(this->grid);
+}
+
+bool Sudoku::read_puzzle_from_file(std::istream& f)
+{
+  if (this->parse_puzzle(f))
+  {
+    if (this->validate())
+    {
+      this->status_ok = true;
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool Sudoku::read_puzzle_from_string(std::string const& s)
+{
+  std::stringstream iss(s);
+
+  if (this->parse_puzzle(iss))
+  {
+    if (this->validate())
+    {
+      this->status_ok = true;
+      return true;
+    }
+  }
+
+  return false;
+}
+
+void Sudoku::print(std::ostream& out) const
+{
+  if (!this->status_ok)
+  {
+    throw std::logic_error("Puzzle has not been initialized");
+  }
+
+  out << this->to_s() << std::endl;
+}
+
+std::string Sudoku::to_s() const
+{
+  std::string str = this->grid.to_s();
+  boost::replace_all(str, "-1", "?");
+  return str;
+}
+
+bool Sudoku::find_unknown(Grid& cur_grid, std::size_t cur_x, std::size_t cur_y,
+  std::size_t& x_out, std::size_t& y_out)
+{
+  //find the next unknown node from where we left off, so we don't need to re-examine any elements
+  for (std::size_t y = cur_y; y < cur_grid.n(); y++, cur_x = 0)
+  {
+    for (std::size_t x = cur_x; x < cur_grid.n(); x++)
+    {
+      if (cur_grid.get(x, y) == -1)
+      {
+        x_out = x;
+        y_out = y;
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+bool Sudoku::color_node(Grid& cur_grid, std::size_t cur_x, std::size_t cur_y)
+{
+  std::size_t unknown_x, unknown_y;
+
+  //check if we can keep coloring nodes, or if we need to stop and assess the generated board
+  if (find_unknown(cur_grid, cur_x, cur_y, unknown_x, unknown_y))
+  {
+    std::uint_fast64_t colors = Validator::good_colors(cur_grid, unknown_x, unknown_y);
+
+    //clone the existing game board
+    Grid new_grid(cur_grid);
+
+    for (int i = 1; i <= (int)cur_grid.n(); i++)
+    {
+      //can we use this color here?
+      if ((colors & (1 << (i - 1))) != 0)
+      {
+        //color the node
+        new_grid.set(unknown_x, unknown_y, i);
+
+        //if the coloring was successful, then return the colored graph indicate success
+        if (color_node(new_grid, unknown_x, unknown_y))
+        {
+          cur_grid = new_grid;
+          return true;
+        }
+      }
+    }
+
+    //we couldn't find a coloring :(
+    return false;
+  }
+  else
+  {
+    //the board is completely colored, so we can't color any more nodes, but is it a valid coloring?
+    return Validator::is_good_board(cur_grid);
+  }
+}
+
+void Sudoku::solve_colorability_style()
+{
+  if (!this->status_ok)
+  {
+    throw std::logic_error("Puzzle has not been initialized");
+  }
+
+  color_node(this->grid);
+}
+
+bool Sudoku::bruteforce_node(Grid& cur_grid, std::size_t cur_x, std::size_t cur_y)
+{
+  std::size_t unknown_x, unknown_y;
+
+  //check if we can keep coloring nodes, or if we need to stop and assess the generated board
+  if (find_unknown(cur_grid, cur_x, cur_y, unknown_x, unknown_y))
+  {
+    //clone the existing game board
+    Grid new_grid(cur_grid);
+
+    for (int i = 1; i <= (int)cur_grid.n(); i++)
+    {
+      //color the cell value
+      new_grid.set(unknown_x, unknown_y, i);
+
+      //if the coloring was successful, then return the colored graph indicate success
+      if (bruteforce_node(new_grid, unknown_x, unknown_y))
+      {
+        cur_grid = new_grid;
+        return true;
+      }
+    }
+
+    //we couldn't find a solution :(
+    return false;
+  }
+  else
+  {
+    //the board is completely colored, so we can't color any more nodes, but is it a valid coloring?
+    return Validator::is_good_board(cur_grid);
+  }
+}
+
+void Sudoku::solve_bruteforce_style()
+{
+  if (!this->status_ok)
+  {
+    throw std::logic_error("Puzzle has not been initialized");
+  }
+
+  bruteforce_node(this->grid);
+}
+
+int Sudoku::singular_decider(Grid& cur_grid, bool found_one, std::size_t cur_x, std::size_t cur_y)
+{
+  std::size_t unknown_x, unknown_y;
+
+  //check if we can keep coloring nodes, or if we need to stop and assess the generated board
+  if (find_unknown(cur_grid, cur_x, cur_y, unknown_x, unknown_y))
+  {
+    std::uint_fast64_t colors = Validator::good_colors(cur_grid, unknown_x, unknown_y);
+
+    //clone the existing game board
+    Grid new_grid(cur_grid);
+
+    for (int i = 1; i <= (int)cur_grid.n(); i++)
+    {
+      //can we use this color here?
+      if ((colors & (1 << (i - 1))) != 0)
+      {
+        //color the node
+        new_grid.set(unknown_x, unknown_y, i);
+
+        //if the coloring was successful, then return the colored graph indicate success
+        switch (singular_decider(new_grid, found_one, unknown_x, unknown_y))
+        {
+          case 0: { break; } //that branch did not yield a solution, so keep going
+          case 1: { found_one = true; break; } //found one solution, so keep going
+          case 2: { return 2; } //confirmed multiple solutions, so stop
+        }
+      }
+    }
+
+    //we're done with this branch
+    return found_one ? 1 : 0;
+  }
+  else
+  {
+    //the board is completely colored, so we can't color any more nodes, but is it a valid coloring?
+    if (Validator::is_good_board(cur_grid))
+    {
+      if (found_one)
+      {
+        //oh no, we've got multiple solutions!
+        return 2;
+      }
+      else
+      {
+        //this is just the first solution
+        return 1;
+      }
+    }
+    else
+    {
+      //this branch did not yield a solution
+      return 0;
+    }
+  }
+}
+
+bool Sudoku::singular()
+{
+  if (!this->status_ok)
+  {
+    throw std::logic_error("Puzzle has not been initialized");
+  }
+
+  if (this->validate())
+  {
+    return (singular_decider(this->grid) == 1);
+  }
+  else
+  {
+    return false;
+  }
+}
+
+bool Sudoku::good() const
+{
+  return this->status_ok;
+}
+
+bool Sudoku::bad() const
+{
+  return !this->good();
+}
+
+Sudoku::operator bool() const
+{
+  return this->good();
+}
+
+Sudoku::~Sudoku()
+{
+
+}