combinatorial_puzzle_solver 0.1.0

data/lib/combinatorial_puzzle_solver/solution_space.rb

@@ -0,0 +1,159 @@
+
+module CombinatorialPuzzleSolver
+
+  # A mapping between each identifier of a puzzle and their possible values.
+  class SolutionSpace < Hash
+
+    # @return [Puzzle] the Puzzle that this solution space is associated with.
+    attr_reader :puzzle
+
+    # Creates a solution space for a given puzzle.
+    # @param puzzle [Puzzle,SolutionSpace] the puzzle that this solution space is
+    #                                      based on, or a clone if a SolutionSpace is
+    #                                      given.
+    def initialize(puzzle)
+      if puzzle.is_a?(Puzzle) then
+        @puzzle = puzzle
+        @puzzle.identifiers.each{|identifier|
+          self[identifier] = Possibilities.new(self, identifier)
+        }
+
+        select{|identifier| identifier.has_value? }.each{|identifier, possibilities|
+          possibilities.dependent_identifiers_cannot_be!(identifier.value)
+        }
+      elsif puzzle.is_a?(SolutionSpace)
+        puzzle.each{|identifier, possibilities|
+          clone = Possibilities.new(self, identifier)
+          clone.clear
+          clone.concat(possibilities)
+          self[identifier] = clone
+        }
+        @puzzle = puzzle.puzzle
+      end
+    end
+
+    # @return [Hash<Identifier,Object>] a Hash of all identifiers that are resolved,
+    #                                   mapped to the value they are resolved to.
+    def resolved_identifiers
+      resolved = {}
+      each{|identifier, possibilities|
+        if !identifier.has_value? && possibilities.resolved? then
+          resolved[identifier] = possibilities.first
+        end
+      }
+      resolved
+    end
+
+    # @return [Hash<Identifier,Possibilities>] the unresolved identifiers and their
+    #                                          possible values.
+    def unresolved_identifiers
+      select{|identifier, possibilities|
+        !identifier.has_value? && !possibilities.resolved?
+      }
+    end
+
+    # @return [Hash<Identifier,Object>] a Hash of all identifiers that can be
+    #                                   resolved by iterating possible values of each
+    #                                   constraint.
+    def resolvable_from_constraints
+      resolvable=Hash.new
+      @puzzle.constraints.each{|constraint|
+        constraint.resolvable_identifiers(self, resolvable)
+      }
+      resolvable
+    end
+
+    # Resolves the given implications and the new implications they yield (including
+    # those resolved from constraints, if no implications are given) until no more
+    # identifiers can be resolved.
+    #
+    # If the solution space does not become {#resolved?} by this, it is necessary to
+    # {#resolve_by_trial_and_error!} to find a complete solution.
+    #
+    # If a block is given it will yield the solution space with the corresponding
+    # identifier and value before each time a resolution is made
+    # ({Possibilities#must_be!}), and it will abort unless the block returns true.
+    #
+    # @param implications [Hash<Identifier,Object>] a mapping between identifiers and
+    #                                               their assumed value.
+    # @yieldparam solution_space [SolutionSpace] the solution space in the state
+    #                                            right before a resolution is made.
+    # @yieldparam identifier [Identifier] an identifier that is resolved.
+    # @yieldparam value [Object] the value the identifier is resolved to.
+    # @yieldreturn [true,nil] the resolution will abort unless the block returns true
+    #                         for each identifier that is resolved.
+    # @return [true,false] true if the solution space became completely resolved.
+    # @raise [Inconsistency] if the solution space becomes inconsistent without any
+    #                         possible solution.
+    def resolve!(implications)
+
+      loop do
+        resolvable = Hash.new
+
+        implications.each{|identifier, value|
+          if block_given? then
+            return false unless yield(self, identifier, value) == true
+          end
+          self[identifier].must_be!(value, resolvable)
+        }
+
+        if resolvable.empty? then
+          implications = resolvable_from_constraints
+        else
+          implications = resolvable
+        end
+
+
+        break if implications.empty?
+      end
+
+      resolved?
+    end
+
+    # Iterates the possible values of unresolved identifiers and returns the solution
+    # space for the first attempt that yields a complete solution. It will return
+    # itself if it becomes resolved by eliminating the attempts that failed.
+    #
+    # @return [SolutionSpace] a solution space that is completely resolved
+    # @raise [Inconsistency] if no complete solution is found.
+    def resolve_by_trial_and_error!
+      unresolved_identifiers.each{|identifier, possibilities|
+        until possibilities.resolved? do
+          maybe_value = possibilities.first
+          maybe_solution = try_resolve_with(identifier, maybe_value)
+          return maybe_solution unless maybe_solution.nil?
+
+          resolve!(self[identifier].cannot_be!(maybe_value))
+        end
+      }
+
+      self
+    end
+
+    # Creates a clone of the solution space and tries to solve it with the assumption
+    # that the given identifier has the given value.
+    # @return [SolutionSpace, nil] a solution space that is completely resolved, or
+    #                              nil if no complete solution was found.
+    def try_resolve_with(identifier, value)
+      possible_solution_space = SolutionSpace.new(self)
+      assumption = {identifier => value}
+
+      begin
+        if possible_solution_space.resolve!(assumption) then
+          return possible_solution_space
+        else
+          return possible_solution_space.resolve_by_trial_and_error!
+        end
+      rescue Inconsistency
+        return nil
+      end
+    end
+
+    # @return [true, false] true if all identifiers have been resolved.
+    def resolved?
+      all?{|identifier,possibilities|
+        identifier.has_value? || possibilities.resolved?
+      }
+    end
+  end
+end

data/lib/combinatorial_puzzle_solver/sudoku.rb

@@ -0,0 +1,95 @@
+
+module CombinatorialPuzzleSolver
+
+
+  # A sudoku puzzle.
+  #
+  # A puzzle with dimension 3 implies the standard 9x9 puzzle, whereas dimension 2
+  # implies a 4x4 puzzle.
+  class Sudoku < Puzzle
+
+    # @return [Fixnum] the width/height of the sudoku board (9 for a 9x9 puzzle).
+    attr_reader :size
+
+    # Parses a string where 1-9 are interpreted as values and 0 is interpreted as
+    # unassigned, whereas all other characters (including whitespaces) are
+    # discarded.
+    #
+    # @param string [String] the input string.
+    # @param dimension [Fixnum] Dimension 2 implies a 4x4 puzzle, 3 implies 9x9.
+    # @yieldparam sudoku [Sudoku] each parsed sudoku puzzle.
+    # @return [Array[Sudoku]] the parsed sudoku puzzles.
+    # @raise [RuntimeError] if the parsed digits don't match up to even puzzles.
+    def self.scan(string, dimension=3)
+      digits = string.scan(/\d/).collect{|value| value.to_i}
+      size = dimension**4
+      digits.each_slice(size).collect{|digits|
+        puzzle = Sudoku.new(dimension, digits)
+        yield puzzle if block_given?
+        puzzle
+      }
+    end
+
+    # Creates a new and empty sudoku puzzle, with all identifiers unassigned.
+    # @param dimension [Fixnum] the dimension of the puzzle ('2' implies a 4x4 puzzle
+    #                           and '3' implies a 9x9 puzzle).
+    # @param digits [Array[Fixnum]] an optional array of digits, where each digit
+    #                               corresponds to an identifier's value from 0 to 9.
+    # @raise [RuntimeError] if the digits array (if given) is of incorrect size.
+    def initialize(dimension=3, digits=[])
+      @dimension = dimension
+      @size = dimension*dimension
+      super(@size*@size, (1..@size).to_a) {|identifier|
+        (rows + columns + squares).collect{|group| Constraint.new(group) }
+      }
+
+      unless digits.empty? then
+        unless digits.size == @size*@size then
+          error_msg = "Parsed #{digits.size} digits instead of #{@size*@size})."
+          raise RuntimeError.new(error_msg)
+        end
+
+        digits.each_with_index{|value, index|
+          identifiers[index].set!(value) unless value == 0
+        }
+      end
+    end
+
+    # @return [Array<Array<Identifier>>] the identifiers grouped by rows
+    def rows
+      @identifiers.each_slice(@size).to_a
+    end
+
+    # @return [Array<Array<Identifier>>] the identifiers grouped by columns
+    def columns
+      rows.transpose
+    end
+
+    # @return [Array<Array<Identifier>>] the identifiers grouped by squares
+    def squares
+      slices = @identifiers.each_slice(@dimension).each_slice(@dimension).to_a
+      slices.transpose.flatten.each_slice(@size).to_a
+    end
+
+    # @return [String] a simple string representation of the sudoku puzzle.
+    def to_s
+      horizontal = "\n#{Array.new(@dimension){"-" * (@dimension*2-1) }.join("+")}\n"
+      divisors = [horizontal, "\n", "|", " "]
+
+      strings = @identifiers.collect{|id| (id.has_value?) ? id.value.to_s : " "}
+      while divisor = divisors.pop do
+        strings = strings.each_slice(@dimension).collect{|s| s.join(divisor) }
+      end
+      strings.join
+    end
+
+    # @return [String] a string representation of an identifier, which would be
+    #                  "[row,column]"
+    def identifier_to_s(identifier)
+      index = identifiers.index(identifier)
+      "[#{index / size + 1},#{index % size + 1}]"
+    end
+
+
+  end
+end

data/lib/combinatorial_puzzle_solver/version.rb

@@ -0,0 +1,4 @@
+module CombinatorialPuzzleSolver
+  # the current version
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: combinatorial_puzzle_solver
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Erik Schlyter
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-04-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-illustrate
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.7.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.7.6
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.2
+description: A resolver of combinatorial number-placement puzzles, like Sudoku.
+email:
+- erik@erisc.se
+executables:
+- solve_sudoku
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- bin/setup
+- combinatorial_puzzle_solver.gemspec
+- example_puzzles/4x4
+- example_puzzles/compile_examples.rb
+- example_puzzles/examples.yaml
+- example_puzzles/hard
+- example_puzzles/medium
+- example_puzzles/simple
+- exe/solve_sudoku
+- lib/combinatorial_puzzle_solver.rb
+- lib/combinatorial_puzzle_solver/constraint.rb
+- lib/combinatorial_puzzle_solver/identifier.rb
+- lib/combinatorial_puzzle_solver/inconsistency.rb
+- lib/combinatorial_puzzle_solver/possibilities.rb
+- lib/combinatorial_puzzle_solver/puzzle.rb
+- lib/combinatorial_puzzle_solver/solution_space.rb
+- lib/combinatorial_puzzle_solver/sudoku.rb
+- lib/combinatorial_puzzle_solver/version.rb
+homepage: https://github.com/ErikSchlyter/combinatorial_puzzle_solver
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3113729172667928250
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3113729172667928250
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A resolver of combinatorial number-placement puzzles, like Sudoku.
+test_files: []
+has_rdoc: