nsudoku 0.1.2 → 0.1.6

data/README.md

@@ -20,7 +20,7 @@ Or install it yourself as:
 
 Usage class NSudoku for example:
 
-    EXAMPLE = [
+    SUDOKU = [
       "012000000",
       "304052000",
       "605170000",
@@ -34,10 +34,10 @@ Usage class NSudoku for example:
 Solve game the sudoku
 
     > require 'nsudoku'
-    > NSudoku.new(EXAMPLE).solve #=> "712460850394852671685170420070208596926715384050906712540320968269584137030690245"
+    > NSudoku.new(SUDOKU).solve    #=> "712460850394852671685170420070208596926715384050906712540320968269584137030690245"
+    > NSudoku.new(SUDOKU).solution #=> "712463859394852671685179423173248596926715384458936712541327968269584137837691245"
 
 Check whether your array has got that same values in rows, columns or sub blocks. When your array is correct you should expect result nil.
 In other situation you should received array of position with that same value.
 
-    > NSudoku::Checker.new(EXAMPLE).repeat_in #=> nil
-
+    > NSudoku::Checker.new(SUDOKU).repeat_in #=> nil

data/lib/nsudoku/checker.rb

@@ -6,6 +6,12 @@ class NSudoku
       @sudoku = sudoku
       @width = Math.sqrt(@sudoku.length).to_i
       @block_width = Math.sqrt(@width).to_i
+     # puts @block_width
+    end
+
+    def correct?
+      return true if repeat_in.nil?
+      false
     end
 
     def repeat_in

data/lib/nsudoku/logic.rb

@@ -0,0 +1,187 @@
+# encoding: utf-8
+
+class NSudoku
+  class Logic
+
+    attr_accessor :revers
+
+    def initialize(sudoku)
+      @sudoku = sudoku
+      @width = Math.sqrt(sudoku.length).to_i
+      @block_width = Math.sqrt(@width).to_i
+      @revers = create_revers(@sudoku.split(""))
+    end
+
+    def create_revers(data)
+      @revers, index = raw_revers, 0
+      @revers.each_with_index do |row, row_index|
+        row.each_with_index do |col, col_index|
+          cell = data[index]
+          @revers[row_index][col_index] = [cell.to_i] if cell =~ /^[1-9]$/
+          index += 1
+        end
+      end
+    end
+
+    # revers table @revers_table into string where cell [n] return n and [a1, a2, ..., ak] return 0
+    def sudoku
+      result = ""
+      @revers.flatten(1).each do |element|
+        result << (element.size == 1 ? element.first.to_s : "0")
+      end
+      result
+    end
+
+    # change positions: external position of block for sudoku and
+    # internal position of block into array [row_position, column_position]
+    def block_position(external, internal)
+      [
+        (external / @block_width) * @block_width + internal / @block_width,
+        (external % @block_width) * @block_width + internal % @block_width
+      ]
+    end
+
+    def block_positions_values(external)
+      result = {}
+      @width.times do |internal|
+        row, column = block_position(external, internal)
+        @revers[row][column].each { |value| (result[value] ||= []) << [row, column] }
+      end
+      result
+    end
+
+    def row_positions_values(row)
+      result = {}
+      @width.times do |column|
+        @revers[row][column].each { |value| (result[value] ||= []) << column }
+      end
+      result
+    end
+
+    def column_positions_values(column)
+      result = {}
+      @width.times do |row|
+        @revers[row][column].each { |value| (result[value] ||= []) << row }
+      end
+      result
+    end
+
+    # erase values in vertical, which are that same like value from positnio row, column
+    def one_element_vertical(column)
+      column_positions_values(column).each do |value, positions|
+        @revers[positions.first][column] = [value] if positions.size == 1
+      end
+      self
+    end
+
+    # erase values in horizontal, which are that same like value from positnio row, column
+    def one_element_horizontal(row)
+      row_positions_values(row).each do |value, positions|
+        @revers[row][positions.first] = [value] if positions.size == 1
+      end
+      self
+    end
+
+    # erase values in block, which are that same like value from positnio row, column
+    def one_element_block(row)
+      block_positions_values(row).each do |value, positions|
+        horizontal = positions[0][0]
+        vertical = positions[0][1]
+        @revers[horizontal][vertical] = [value] if positions.size == 1
+      end
+      self
+    end
+
+    # erase values in block, which are that same like value from positnio row, column
+    def two_elements_block(index)
+      result = {}
+      only_two_positions = block_positions_values(index).select {|k,v| v.length == 2}
+      only_two_positions.each { |value, positions| (result[positions] ||= []) << value }
+      result.each do |positions, value|
+        next unless value.size == 2
+        @revers[positions[0][0]][positions[0][1]] = value.clone
+        @revers[positions[1][0]][positions[1][1]] = value.clone
+      end
+      self
+    end
+
+    # erase values in vertical, which are that same like value from positnio row, column
+    def two_elements_column(column)
+      result = {}
+      only_two_positions = row_positions_values(column).select {|k,v| v.length == 2}
+      only_two_positions.each { |value, positions| (result[positions] ||= []) << value }
+      result.each do |positions, value|
+        next unless value.size == 2
+        @revers[positions[0]][column] = value.clone
+        @revers[positions[1]][column] = value.clone
+      end
+      self
+    end
+
+    # erase values in row, which are that same like value from positnio row, column
+    def two_elements_row(row)
+      result = {}
+      only_two_positions = column_positions_values(row).select {|k,v| v.length == 2}
+      only_two_positions.each { |value, positions| (result[positions] ||= []) << value }
+      result.each do |positions, value|
+        next unless value.size == 2
+        @revers[row][positions[0]] = value.clone
+        @revers[row][positions[1]] = value.clone
+      end
+      self
+    end
+
+    # erase values in vertical, which are that same like value from positnio row, column
+    def erase_elements_row(row, column)
+      return unless @revers[row][column].size == 1
+      cell = @revers[row][column][0]
+      @width.times do |index|
+        @revers[index][column].delete(cell) unless index == row
+      end
+      self
+    end
+
+    # erase values in hozizontal, which are that same like value from positnio row, column
+    def erase_elements_column(row, column)
+      return unless @revers[row][column].size == 1
+      cell = @revers[row][column][0]
+      @width.times do |index|
+        @revers[row][index].delete(cell) unless index == column
+      end
+      self
+    end
+
+    # erase values in block, which are that same like value from positnio row, column
+    def erase_elements_block(row, column)
+      return unless @revers[row][column].size == 1
+      cell = @revers[row][column][0]
+      block_positions(row, column).each do |horizontal, vertical|
+        @revers[horizontal][vertical].delete(cell) unless horizontal == row and vertical == column
+      end
+      self
+    end
+
+    def block_positions(row, column)
+      row_block = (row / @block_width) * @block_width
+      column_block = (column / @block_width) * @block_width
+      (0...@width).to_a.map { |index| [row_block + index / @block_width, column_block + index % @block_width] }
+    end
+
+  private
+
+    # @width = 4
+    # cell = [1, 2, 3, 4]
+    # return  [[cell, cell, cell, cell],
+    #          [cell, cell, cell, cell],
+    #          [cell, cell, cell, cell],
+    #          [cell, cell, cell, cell]]
+    def raw_revers
+      (1..@width).to_a.map do
+        (1..@width).to_a.map do
+          (1..@width).to_a
+        end
+      end
+    end
+
+  end
+end

data/lib/nsudoku/version.rb

@@ -1,3 +1,3 @@
 class NSudoku
-  VERSION = "0.1.2"
+  VERSION = "0.1.6"
 end

data/lib/nsudoku.rb

@@ -1,12 +1,28 @@
+# encoding: utf-8
 require_relative "nsudoku/version"
 require_relative "nsudoku/checker"
+require_relative "nsudoku/logic"
 
 class NSudoku
 
-  def initialize(data)
-    @revers_table = create_revers_table(data.split(""))
+  def initialize(sudoku)
+    @data = sudoku
+    @sudoku = sudoku
+    @revers_table = create_revers_table(sudoku.split(""))
+    @length = @sudoku.length
+    @width = Math.sqrt(@sudoku.length).to_i
+    @block_width = Math.sqrt(@width).to_i
   end
 
+  # return first correct solution for variable @sudoku
+  def solution
+    @solution = nil
+    data = @sudoku.clone + "0"
+    solver(data, -1, "0")
+    @solution[0, @length] if @solution
+  end
+
+  # return result which match to all solutions of sudoku
   def solve
     revers_table = nil
     while not revers_table == @revers_table
@@ -31,13 +47,26 @@ class NSudoku
     revers_table_to_result
   end
 
-  def show_table_pretty
-     @revers_table.each do |cell|
-       puts cell.inspect
-     end
-  end
 private
 
+  # Recursive solving sudoku game
+  #
+  # solver(data, -1, "0")
+  def solver(data, position, value)
+    return if @solution
+    data[position] = value.to_s
+    return unless NSudoku::Checker.new(data).correct?
+    @solution = data.clone if position == @length - 1
+    if @data[position + 1] == "0"
+      (1..@width).each do |value|
+        solver(data, position + 1, value)
+        data[position + 1] = "0"
+      end
+    else
+      solver(data, position + 1, @data[position + 1])
+    end
+  end
+
   # table = [[[1, 2, 3, 4, 5], [], ..., []],
   #          [[],                  ..., []],
   #                    ...

data/nsudoku.gemspec

@@ -5,7 +5,7 @@ Gem::Specification.new do |gem|
   gem.platform      = Gem::Platform::RUBY
   gem.authors       = ["Michał Szyma"]
   gem.email         = ["raglub.ruby@gmail.com"]
-  gem.date          = "2012-10-09"
+  gem.date          = "2012-11-13"
   gem.description   = %q{This gem solve puzzle game sudoku 9x9}
   gem.summary       = %q{This gem solve puzzle game sudoku}
   gem.homepage      = "http://github.com/raglub/nsudoku"

data/spec/logic_spec.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+require 'nsudoku'
+
+EXAMPLE = [
+  "1004",
+  "0201",
+  "0143",
+  "2010"].join
+
+# REVERS = [
+#   [[1],          [1, 2, 3, 4], [1, 2, 3, 4], [4]],
+#   [[1, 2, 3, 4], [2],          [1, 2, 3, 4], [1]],
+#   [[1, 2, 3, 4], [1],          [4],          [3]],
+#   [[2],          [1, 2, 3, 4], [1],          [1, 2, 3, 4]]
+# ]
+
+REVERS = [
+  [[3],          [1, 2, 3, 4], [1, 2, 4],    [4]],
+  [[1, 2, 4],    [2],          [1, 2, 3, 4], [1]],
+  [[1, 2, 3],    [1, 2, 4],    [4],          [3]],
+  [[4],          [3, 4],       [1],          [1, 2, 3, 4]]
+]
+
+describe NSudoku do
+
+  before do
+    @logic = NSudoku::Logic.new(EXAMPLE)
+  end
+
+  it "can generate reverse of sudoku" do
+    @logic.revers[0][1].should eql([1, 2, 3, 4])
+    @logic.revers[3][3].inspect
+  end
+
+  it "can get result" do
+    @logic.sudoku.should eql(EXAMPLE)
+  end
+
+  it "can erase that same elements in column" do
+    @logic.erase_elements_column(0, 0).revers[0][1].should eql([2, 3, 4])
+  end
+
+  it "can erase that same elements in row" do
+    @logic.erase_elements_row(2, 2).revers[1][2].should eql([1, 2, 3])
+  end
+
+  it "can erase that same elements in block" do
+    @logic.erase_elements_block(2, 2).revers[3][3].should eql([1, 2, 3])
+  end
+
+  it "can choos only one value in elements for vertical situation" do
+    @logic.revers = REVERS
+    @logic.one_element_vertical(2).revers[1][2].should eql([3])
+  end
+
+  it "can choos only one value in elements for horizontal situation" do
+    @logic.revers = REVERS
+    @logic.one_element_horizontal(2).revers[1][2].should eql([3])
+  end
+
+  it "can choos only one value in elements for block situation" do
+    @logic.revers = REVERS
+    @logic.one_element_block(2).revers[1][2].should eql([3])
+  end
+
+  it "can choos only two values in elements for block situation" do
+    @logic.revers = REVERS
+    @logic.two_elements_block(2).revers[2][0].should eql([1, 2])
+    @logic.revers[2][1].should eql([1, 2])
+  end
+
+  it "can choos only two values in elements for vertical situation" do
+    @logic.revers = REVERS
+    @logic.two_elements_column(0).revers[1][0].should eql([1, 2])
+    @logic.revers[2][0].should eql([1, 2])
+  end
+
+  it "can choos only two values in elements for horizontal situation" do
+    @logic.revers = REVERS
+    @logic.two_elements_row(2).revers[2][0].should eql([1, 2])
+    @logic.revers[2][1].should eql([1, 2])
+  end
+
+end

data/spec/nsudoku_spec.rb

@@ -24,8 +24,18 @@ TABLE_EMPTY = [
   "000000000",
   "000000000"].join
 
+SUDOKU44 = [
+  "1030",
+  "4000",
+  "0140",
+  "3001"].join
+
 describe NSudoku do
 
+  it "should properly resolved game sudoku" do
+    NSudoku.new(SUDOKU44).solution.should eq("1234431221433421")
+  end
+
   it "should properly reverse base namber of table" do
     sudoku = NSudoku.new(TABLE_EMPTY)
     sudoku.send(:cell_revers_table, 1, 1, [1])

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nsudoku
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-09 00:00:00.000000000 Z
+date: 2012-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -42,10 +42,12 @@ files:
 - Rakefile
 - lib/nsudoku.rb
 - lib/nsudoku/checker.rb
+- lib/nsudoku/logic.rb
 - lib/nsudoku/version.rb
 - lib/sudoku.rb~
 - nsudoku.gemspec
 - spec/checker_spec.rb
+- spec/logic_spec.rb
 - spec/nsudoku_spec.rb
 homepage: http://github.com/raglub/nsudoku
 licenses: []
@@ -73,4 +75,5 @@ specification_version: 3
 summary: This gem solve puzzle game sudoku
 test_files:
 - spec/checker_spec.rb
+- spec/logic_spec.rb
 - spec/nsudoku_spec.rb