sudoku-solver 0.1.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Dorian Sarnowski <dorian.sarnowski@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,3 @@
+== sudoku
+
+You should document your project here.

data/Rakefile

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'sudoku-solver'
+  s.version = '0.1.1'
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README.md', 'LICENSE']
+  s.summary = 'sudoku solver library'
+  s.description = 'set of classes to solve sudoku'
+  s.author = 'Dorian Sarnowski'
+  s.email = 'dorian.sarnowski@gmail.com'
+  s.homepage = 'https://github.com/dorians/sudoku'
+  s.executables = ['solve-sudoku']
+  s.files = %w(LICENSE README.md Rakefile) + Dir.glob("{bin,lib,spec}/**/*")
+  s.require_path = "lib"
+  s.bindir = "bin"
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  files =['README.md', 'LICENSE', 'lib/**/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README.md" # page to start on
+  rdoc.title = "sudoku Docs"
+  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
+  rdoc.options << '--line-numbers'
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*.rb']
+end

data/bin/solve-sudoku

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+NAME = $0
+
+require 'sudoku_solver'
+
+begin
+  input = ARGV.first
+  data = open(input).read
+rescue
+  puts "#{NAME}: missing file operand"
+  #puts "Try `#{NAME} --help` for more information."
+else
+  begin
+    sudoku = Sudoku.new(data)
+    solver = SudokuSolver.new sudoku
+    result = solver.solve
+
+    if result.correct?
+      puts result
+    else
+      puts 'Oh no! Something went wrong'
+    end
+  rescue
+  end
+end

data/lib/sudoku.rb

@@ -0,0 +1,88 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+require 'sudoku_item.rb'
+
+class Sudoku
+
+  include Enumerable
+
+  def initialize data
+    # set up data container (9x9 array)
+    @data = Array.new(9) { Array.new(9) }
+
+    # convert insert data into one-dimensional array
+    data = data.scan(/\d| /)
+
+    if data.size == 81
+      # split array into 9-elements arrays
+      data.each_index do |i|
+        @data[i/9][i%9] = SudokuItem.new(self, data.at(i))
+      end
+    end
+  end
+
+  def clone
+    Sudoku.new self.to_s
+  end
+
+  def at x, y
+    @data.at(y).at(x)
+  end
+
+  def set x, y, value
+    at(x, y).set(value) unless at(x, y).related.any? {|item| item.to_i == value }
+  end
+
+  def count_set
+    count {|item| item.set?}
+  end
+
+  def groups
+    boxes + horizontals + verticals
+  end
+
+  def boxes
+    (group_by {|item| (item.x / 3).to_s + (item.y / 3).to_s }).values
+  end
+
+  def horizontals
+    @data
+  end
+
+  def verticals
+    @data.transpose
+  end
+
+  def solved?
+    all? {|item| item.set?}
+  end
+
+  def each
+    each_with_position {|item, x, y| yield item}
+  end
+
+  def each_with_position
+    @data.each_with_index {|row, y| row.each_with_index {|item, x| yield item, x, y}}
+  end
+
+  def to_s
+    # output schemas
+    break_line = '+---+---+---+'
+    data_line = "|%s%s%s|%s%s%s|%s%s%s|"
+
+    # initialize the output variable as an array
+    result = [break_line]
+
+    @data.each_with_index do |row, i|
+      # add formated data line to output variable
+      result.push sprintf(data_line, *row)
+
+      # add a break line to the output variable if nedded
+      result.push break_line if (i.succ % 3).zero?
+    end
+
+    # return output variable with EOL symbol between each element
+    result.join("\n")
+  end
+
+end

data/lib/sudoku_item.rb

@@ -0,0 +1,60 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+class SudokuItem
+
+  def initialize sudoku, value
+    @sudoku = sudoku
+    set value
+  end
+
+  def x
+    position.first
+  end
+
+  def y
+    position.last
+  end
+
+  def set value
+    @value = value.to_i.zero? ? nil : value.to_i unless set?
+  end
+
+  def position
+    @position || @sudoku.each_with_position do |element, x, y|
+      return (@position = x.to_i, y.to_i) if element == self
+    end
+  end
+
+  def related
+    (related_in_box + related_vertical + related_horizontal).uniq
+  end
+
+  def related_in_box
+    @sudoku.find_all {|item| (same_box? item) && (item != self)}
+  end
+
+  def related_vertical
+    @sudoku.find_all {|item| (item.x == self.x) && (item != self)}
+  end
+
+  def related_horizontal
+    @sudoku.find_all {|item| (item.y == self.y) && (item != self)}
+  end
+
+  def same_box? item
+    (self.x / 3) == (item.x / 3) && (self.y / 3) == (item.y / 3)
+  end
+
+  def set?
+    not @value.nil?
+  end
+
+  def to_i
+    @value.to_i
+  end
+
+  def to_s
+    set? ? @value.to_s : ' '
+  end
+
+end

data/lib/sudoku_result.rb

@@ -0,0 +1,46 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+require 'sudoku'
+
+class SudokuResult
+
+  include Enumerable
+
+  attr_reader :depth, :forks
+
+  def initialize depth
+    @results = []
+    @depth = depth
+    @forks = 0
+  end
+
+  def each &block
+    @results.each &block
+  end
+
+  def << sudoku
+    @results << sudoku
+    self
+  end
+
+  def correct?
+    @results.count == 1
+  end
+
+  def many_solutions?
+    @results.count > 1
+  end
+
+  def to_s
+    @results.empty? ? '' : @results.first.to_s
+  end
+
+  def merge other
+    other.each do |sudoku|
+      self.<< sudoku
+    end
+    @depth = [@depth, other.depth].max
+    @forks += other.forks.succ
+  end
+
+end

data/lib/sudoku_solver.rb

@@ -0,0 +1,139 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+require 'sudoku'
+require 'sudoku_result'
+
+class SudokuSolver
+
+  def initialize sudoku
+    @sudoku = sudoku.clone
+    @depth = 0
+
+    initialize_capabilities
+  end
+
+  def clone
+    solver = super
+
+    solver.sudoku = @sudoku.clone
+    solver.capabilities = Marshal.load(Marshal.dump(@capabilities))
+    @depth += 1
+
+    solver
+  end
+
+  def solve
+    result = SudokuResult.new @depth
+
+    while (solve_method1 || solve_method2) do
+      return result unless correct?
+    end
+
+    if @sudoku.solved?
+      result << @sudoku
+    else
+      element = find_best_element_to_random_solve
+
+      @capabilities[element.y][element.x].each do |random|
+        solver = self.clone
+        solver.set(element.x, element.y, random)
+        result.merge solver.solve
+      end
+    end
+
+    result
+  end
+
+  protected
+
+  attr_accessor :sudoku, :capabilities, :depth
+
+  def set x, y, value
+    # delegate a task
+    if @sudoku.set x, y, value
+      # item was set, so clear capabilities
+      @capabilities[y][x].clear
+
+      # remove set value from capabilities of related items
+      @sudoku.at(x, y).related.each do |item|
+        @capabilities[item.y][item.x] -= [value]
+      end
+    end
+  end
+
+  def correct?
+    @sudoku.each do |item|
+      return false if (not item.set?) && @capabilities[item.y][item.x].empty?
+    end
+    true
+  end
+
+  private
+
+  def solve_method1
+    @capabilities.each_with_index do |row, y|
+      row.each_with_index do |element, x|
+        if element.size == 1
+          return set x, y, element.first
+        end
+      end
+    end
+    false
+  end
+
+  def solve_method2
+    @sudoku.groups.each do |group|
+      set_digits = (group.find_all {|item| item.set?}).map {|item| item.to_i}
+      capabilities_digits = (1..9).to_a - set_digits
+
+      capabilities_digits.each do |digit|
+        capabilities_items = group.find_all do |item|
+          @capabilities[item.y][item.x].include? digit
+        end
+        if capabilities_items.size == 1
+          return set capabilities_items.first.x, capabilities_items.first.y, digit
+        end
+      end
+    end
+    false
+  end
+
+  def find_best_element_to_random_solve
+    min_element = nil
+
+    @capabilities.each_with_index do |row, y|
+      row.each_with_index do |capabilities, x|
+        element = @sudoku.at(x, y)
+        current_count = capabilities.count
+        smallest_count = min_element && @capabilities[min_element.y][min_element.x].count
+
+        if current_count > 1
+          if current_count == 2
+            return element
+          elsif smallest_count.nil? || current_count < smallest_count
+            min_element = element
+          end          
+        end
+      end
+    end
+
+    min_element
+  end
+
+  def initialize_capabilities
+    # each item of sudoku can be any digit from 1 to 9 at the beginning
+    @capabilities = Array.new(9) {Array.new(9) { (1..9).to_a }}
+
+    @sudoku.each do |item|
+      # if item is set, then capabilities should be empty
+      @capabilities[item.y][item.x].clear if item.set?
+
+      # get related as array of integers
+      related = item.related.collect {|element| element.to_i}
+
+      # any digit from related shouldn't be one of capabilities
+      @capabilities[item.y][item.x] -= related
+    end
+  end
+
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: sudoku-solver
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Dorian Sarnowski
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-13 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: set of classes to solve sudoku
+email: dorian.sarnowski@gmail.com
+executables: 
+- solve-sudoku
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+- LICENSE
+files: 
+- LICENSE
+- README.md
+- Rakefile
+- bin/solve-sudoku
+- lib/sudoku_result.rb
+- lib/sudoku_item.rb
+- lib/sudoku.rb
+- lib/sudoku_solver.rb
+has_rdoc: true
+homepage: https://github.com/dorians/sudoku
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: sudoku solver library
+test_files: []
+