nsudoku 0.1.6 → 0.2.0

data/README.md

@@ -1,6 +1,6 @@
 # Sudoku
 
-This gem solve puzzle game sudoku 9x9
+This gem solves puzzle game sudoku (n^2, n^2), for example (3^2, 3^2) = (9, 9) or (4, 4)
 
 ## Installation
 
@@ -29,15 +29,34 @@ Usage class NSudoku for example:
       "050906010",
       "000320908",
       "000580107",
-      "000000240"].join
+      "000000240"
+    ].join
 
-Solve game the sudoku
+Solve the sudoku game
 
-    > require 'nsudoku'
-    > NSudoku.new(SUDOKU).solve    #=> "712460850394852671685170420070208596926715384050906712540320968269584137030690245"
-    > NSudoku.new(SUDOKU).solution #=> "712463859394852671685179423173248596926715384458936712541327968269584137837691245"
+Result which match to all solutions of SUDOKU (if sample has got more than one result)
+
+    NSudoku.new(SUDOKU).solve    #=> "712460850394852671685170420070208596926715384050906712540320968269584137030690245"
+
+First correct solution for variable SUDOKU
+
+    NSudoku.new(SUDOKU).solution #=> "712463859394852671685179423173248596926715384458936712541327968269584137837691245"
+
+You can solve sudoku (4, 4)
+
+    SUDOKU44 = [
+      "1030",
+      "4000",
+      "0140",
+      "3001"
+    ].join
+
+    NSudoku.new(SUDOKU44).solution #=> "1234431221433421"
+    NSudoku.new(SUDOKU44).solve    #=> "1234431221433421"
+
+If you see the same results in methods "solution " and "solve", then sudoku has got only one result
 
 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(SUDOKU).repeat_in #=> nil
+    NSudoku::Checker.new(SUDOKU).repeat_in #=> nil

data/lib/nsudoku/checker.rb

@@ -6,7 +6,6 @@ class NSudoku
       @sudoku = sudoku
       @width = Math.sqrt(@sudoku.length).to_i
       @block_width = Math.sqrt(@width).to_i
-     # puts @block_width
     end
 
     def correct?

data/lib/nsudoku/solver.rb

@@ -0,0 +1,168 @@
+# encoding: utf-8
+
+class NSudoku
+  class Solver
+
+    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
+
+    # search result of sudoku
+    def search
+      revers = nil
+      while not revers == @revers
+        revers = Marshal.load(Marshal.dump(@revers))
+        @width.times do |index|
+          [:row, :column, :block].each do |type|
+            search_pair(type, index)
+            search_single(type, index)
+            only_one(type, index)
+          end
+        end
+      end
+      self
+    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 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
+
+    # get vector values for row, column or block from variable @revers
+    def get_vector(type, index)
+      result = []
+      case type
+      when :row
+        result = @revers[index]
+      when :column
+        result = @revers.map{ |element| element[index] }
+      when :block
+        @width.times do |block|
+          row, column = block_position(index, block)
+          result << @revers[row][column]
+        end
+      end
+      result
+    end
+
+    # get vector values for row, column or block from variable @revers
+    def set_vector(type, index, vector)
+      case type
+      when :row
+        @revers[index] = vector
+      when :column
+        @width.times do |row|
+          @revers[row][index] = vector[row]
+        end
+      when :block
+        @width.times do |block|
+          row, column = block_position(index, block)
+          @revers[row][column] = vector[block]
+        end
+      end
+    end
+
+    def positions_values(vector)
+      result = {}
+      vector.each_with_index do |values, index|
+        values.each do |value|
+          (result[value] ||= []) << index
+        end
+      end
+      result
+    end
+
+    def only_two_positions(vector)
+      result = {}
+      positions_values(vector).select do |value, positions|
+        positions.length == 2
+      end.each do |value, positions|
+        (result[positions] ||= []) << value
+      end
+      result
+    end
+
+    # if vector (row, column or block) has got two cells like this [n1, n2, n3] and [n1, n2, n4]
+    # and variables n1, n2 don't exist in other cells of vector than two cells should be equal [n1, n2].
+    # [[1, 4], [2, 4, 1, 3], [1, 2, 4], [4]] #=> [[1, 4], [2, 4], [2, 4], [4]]
+    def search_pair(type, index)
+      vec = get_vector(type, index)
+      only_two_positions(vec).each do |positions, value|
+        next unless value.size == 2
+        vec[positions[0]] = value.clone
+        vec[positions[1]] = value.clone
+      end
+      set_vector(type, index, vec)
+    end
+
+    # if vector (row, column or block) has got cell like this [n1, n2, ..., nk]
+    # and variable ni exist only one in all vector than cell should be equal [ni].
+    # [[1, 2, 3, 4], [2, 4], [1, 2, 4], [1, 4]] #=> [[3], [2, 4], [1, 2, 4], [1, 4]]
+    def only_one(type, index)
+      vec = get_vector(type, index)
+      vec.each_with_index do |values, position|
+        next unless values.size == 1
+        cell = values.first
+        @width.times do |sub_position|
+          vec[sub_position].delete(cell) unless sub_position == position
+        end
+      end
+      set_vector(type, index, vec)
+    end
+
+    # if vector (row, column or block) has got cell like this [n1]
+    # than should be erase value n1 from rest of cells.
+    # [[1, 2, 3, 4], [2], [1, 2, 4], [1, 4]] #=> [[1, 3, 4], [2], [1, 4], [1, 4]]
+    def search_single(type, index)
+      vec = get_vector(type, index)
+      positions_values(vec).each do |value, positions|
+        vec[positions.first] = [value] if positions.size == 1
+      end
+      set_vector(type, index, vec)
+    end
+
+    # @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.6"
+  VERSION = "0.2.0"
 end

data/lib/nsudoku.rb

@@ -1,14 +1,12 @@
 # encoding: utf-8
 require_relative "nsudoku/version"
 require_relative "nsudoku/checker"
-require_relative "nsudoku/logic"
+require_relative "nsudoku/solver"
 
 class NSudoku
 
   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
@@ -24,27 +22,7 @@ class NSudoku
 
   # return result which match to all solutions of sudoku
   def solve
-    revers_table = nil
-    while not revers_table == @revers_table
-      revers_table = Marshal.load(Marshal.dump(@revers_table))
-
-     9.times do |index|
-        cells_with_two_elements_for('row', index)
-        cells_with_two_elements_for('column', index)
-        cells_with_two_elements_for('block', index)
-        erase_in_horizontal_three(index)
-        erase_in_vertical_three(index)
-     end
-
-      9.times do |row|
-        9.times do |column|
-          erase_in_vertical_one(row, column)
-          erase_in_horizontal_one(row, column)
-          erase_in_block_one(row, column)
-        end
-      end
-    end
-    revers_table_to_result
+    NSudoku::Solver.new(@sudoku).search.sudoku
   end
 
 private
@@ -57,167 +35,14 @@ private
     data[position] = value.to_s
     return unless NSudoku::Checker.new(data).correct?
     @solution = data.clone if position == @length - 1
-    if @data[position + 1] == "0"
+    if @sudoku[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], [], ..., []],
-  #          [[],                  ..., []],
-  #                    ...
-  #          [[],                  ..., []]
-  #         ]
-  def create_revers_table(data)
-    result = 9.times.map{|row_element| 9.times.map{|col_element| []}}
-    data.each_with_index do |cell, index|
-      column = index % 9
-      row = (index - column)/9 % 9
-      cell = cell.to_i
-      result[row][column] = [cell]
-      result[row][column] = 9.times.map{|element| element + 1} if cell == 0
-    end
-    return result
-  end
-
-  # revers table @revers_table into string where cell [n] return n and [a1, a2, ..., ak] return 0
-  def revers_table_to_result
-    result = ""
-    @revers_table.flatten(1).each do |element|
-      result << (element.size == 1 ? element.first.to_s : "0")
-    end
-    result
-  end
-
-
-  def positions_for(type, index0, index1)
-    case type
-    when 'column'
-      return {
-        row: index0,
-        column: index1
-      }
-    when 'row'
-      return {
-        row: index0,
-        column: index1
-      }
-    when 'block'
-      return {
-        row: (index0/3)*3 + index1/3,
-        column: (index0%3)*3 + index1%3
-      }
-    end
-  end
-
-  def positions_of_values(kind, value)
-    result = {}
-     row, column = nil, nil
-     9.times do |index|
-      case kind
-      when 'column'
-        row = index
-        column = value
-      when 'row'
-        row = value
-        column = index
-      when 'block'
-        row = (value/3)*3 + index/3
-        column = (value%3)*3 + index%3
-      end
-      next if row.nil? or column.nil?
-      @revers_table[row][column].each do |value|
-        result[value] ||= []
-        result[value] << index
-      end
-    end
-    result
-  end
-
-  # erase values in vertical, which are that same like value from positnio row, column
-  # type: "block", "row","column"
-  def cells_with_two_elements_for(type, index)
-  only_two_positions = positions_of_values(type, index).select {|k,v| v.length == 2}
-    result = {}
-    only_two_positions.each do |value, positions|
-      result[positions] ||= []
-      result[positions] << value
+      solver(data, position + 1, @sudoku[position + 1])
     end
-    result.each do |key, value|
-      if value.size == 2
-        if type == 'block'
-          positions = positions_for('block', index, key[0])
-          @revers_table[positions[:row]][positions[:column]] = value.clone
-          positions = positions_for('block', index, key[1])
-          @revers_table[positions[:row]][positions[:column]] = value.clone
-        end
-        if type == 'row'
-          @revers_table[index][key[0]] = value.clone
-          @revers_table[index][key[1]] = value.clone
-        end
-        if type == 'column'
-          @revers_table[key[0]][index] = value.clone
-          @revers_table[key[1]][index] = value.clone
-        end
-      end
-    end
-  end
-
-
-  # erase values in vertical, which are that same like value from positnio row, column
-  def erase_in_vertical_one(row, column)
-    return unless @revers_table[row][column].size == 1
-    cell = @revers_table[row][column][0]
-    9.times do |index|
-      @revers_table[index][column].delete(cell) unless index == row
-    end
-  end
-
-  # erase values in hozizontal, which are that same like value from positnio row, column
-  def erase_in_horizontal_one(row, column)
-    return unless @revers_table[row][column].size == 1
-    cell = @revers_table[row][column][0]
-    9.times do |index|
-      @revers_table[row][index].delete(cell) unless index == column
-    end
-  end
-
-  # erase values in block, which are that same like value from positnio row, column
-  def erase_in_block_one(row, column)
-    return unless @revers_table[row][column].size == 1
-    cell = @revers_table[row][column][0]
-    first_row_block = (row/3)*3
-    first_column_block = (column/3)*3
-    3.times do |row_index|
-      row_block = first_row_block + row_index
-      3.times do |column_index|
-        column_block = first_column_block + column_index
-        @revers_table[row_block][column_block].delete(cell) unless row_block == row and column_block == column
-      end
-    end
-  end
-
-  # erase values in vertical, which are that same like value from positnio row, column
-  def erase_in_vertical_three(column)
-    positions_of_values('column', column).each do |value, positions|
-      @revers_table[positions.first][column] = [value] if positions.size == 1
-    end
-  end
-
-  # erase values in horizontal, which are that same like value from positnio row, column
-  def erase_in_horizontal_three(row)
-    positions_of_values('row', row).each do |value, positions|
-      @revers_table[row][positions.first] = [value] if positions.size == 1
-    end
-  end
-
-  def cell_revers_table(row, column, value = nil)
-    @revers_table[row][column] = value unless value.nil?
-    @revers_table[row][column]
   end
 
 end

data/nsudoku.gemspec

@@ -5,8 +5,8 @@ Gem::Specification.new do |gem|
   gem.platform      = Gem::Platform::RUBY
   gem.authors       = ["Michał Szyma"]
   gem.email         = ["raglub.ruby@gmail.com"]
-  gem.date          = "2012-11-13"
-  gem.description   = %q{This gem solve puzzle game sudoku 9x9}
+  gem.date          = "2012-11-16"
+  gem.description   = %q{This gem solve puzzle game sudoku (n^2, n^2), for example (3^2, 3^2) = (9, 9)}
   gem.summary       = %q{This gem solve puzzle game sudoku}
   gem.homepage      = "http://github.com/raglub/nsudoku"
 

data/spec/nsudoku_spec.rb

@@ -2,7 +2,7 @@
 
 require 'nsudoku'
 
-EXAMPLE = [
+SUDOKU99 = [
   "012000000",
   "304052000",
   "605170000",
@@ -13,17 +13,6 @@ EXAMPLE = [
   "000580107",
   "000000240"].join
 
-TABLE_EMPTY = [
-  "000000000",
-  "000000000",
-  "000000000",
-  "000000000",
-  "000000000",
-  "000000000",
-  "000000000",
-  "000000000",
-  "000000000"].join
-
 SUDOKU44 = [
   "1030",
   "4000",
@@ -34,125 +23,11 @@ describe NSudoku do
 
   it "should properly resolved game sudoku" do
     NSudoku.new(SUDOKU44).solution.should eq("1234431221433421")
+    NSudoku.new(SUDOKU99).solution.should eq("712463859394852671685179423173248596926715384458936712541327968269584137837691245")
   end
 
-  it "should properly reverse base namber of table" do
-    sudoku = NSudoku.new(TABLE_EMPTY)
-    sudoku.send(:cell_revers_table, 1, 1, [1])
-    sudoku.send(:cell_revers_table, 8, 8, [3])
-    sudoku.send(:cell_revers_table, 1, 1).should eql([1])
-    sudoku.send(:cell_revers_table, 1 ,0).should eql([1, 2, 3, 4, 5, 6, 7, 8, 9])
-  end
-
-  context "should properly erase values which are that same like in cell with single element" do
-    it "in column (exist cell with single element)" do
-      sudoku = NSudoku.new(TABLE_EMPTY)
-      sudoku.send(:cell_revers_table, 3, 4, [5])
-      sudoku.send(:erase_in_vertical_one, 3, 4)
-      sudoku.send(:cell_revers_table, 0, 4).should eql([1, 2, 3, 4, 6, 7, 8, 9])
-      sudoku.send(:cell_revers_table, 5, 4).should eql([1, 2, 3, 4, 6, 7, 8, 9])
-      sudoku.send(:cell_revers_table, 8, 4).should eql([1, 2, 3, 4, 6, 7, 8, 9])
-      sudoku.send(:cell_revers_table, 3, 4).should eql([5])
-    end
-
-    it "in column (don't exist cell with single element)" do
-      sudoku = NSudoku.new(TABLE_EMPTY)
-      sudoku.send(:erase_in_vertical_one, 3, 4)
-      sudoku.send(:cell_revers_table, 5, 4).should eql([1, 2, 3, 4,5 , 6, 7, 8, 9])
-      sudoku.send(:cell_revers_table, 3, 4).should eql([1, 2, 3, 4,5 , 6, 7, 8, 9])
-    end
-
-    it "in row (exist cell with single element)" do
-      sudoku = NSudoku.new(TABLE_EMPTY)
-      sudoku.send(:cell_revers_table, 3, 4, [5])
-      sudoku.send(:erase_in_horizontal_one, 3, 4)
-      sudoku.send(:cell_revers_table, 3, 2).should eql([1, 2, 3, 4, 6, 7, 8, 9])
-      sudoku.send(:cell_revers_table, 3, 4).should eql([5])
-    end
-
-    it "in column (don't exist cell with single element)" do
-      sudoku = NSudoku.new(TABLE_EMPTY)
-      sudoku.send(:erase_in_horizontal_one, 3, 4)
-      sudoku.send(:cell_revers_table, 3, 2).should eql([1, 2, 3, 4, 5, 6, 7, 8, 9])
-      sudoku.send(:cell_revers_table, 3, 4).should eql([1, 2, 3, 4 ,5, 6, 7, 8, 9])
-    end
-
-    it "in block (exist cell with single element)" do
-      sudoku = NSudoku.new(TABLE_EMPTY)
-      sudoku.send(:cell_revers_table, 7, 3, [8])
-      sudoku.send(:erase_in_block_one, 7, 3)
-      sudoku.send(:cell_revers_table, 6, 2).should eql([1, 2, 3, 4 ,5, 6, 7, 8, 9])
-      sudoku.send(:cell_revers_table, 5, 6).should eql([1, 2, 3, 4 ,5, 6, 7, 8, 9])
-      sudoku.send(:cell_revers_table, 5, 3).should eql([1, 2, 3, 4 ,5, 6, 7, 8, 9])
-      sudoku.send(:cell_revers_table, 7, 6).should eql([1, 2, 3, 4 ,5, 6, 7, 8, 9])
-
-      sudoku.send(:cell_revers_table, 6, 4).should eql([1, 2, 3, 4 ,5, 6, 7, 9])
-      sudoku.send(:cell_revers_table, 8, 3).should eql([1, 2, 3, 4 ,5, 6, 7, 9])
-      sudoku.send(:cell_revers_table, 8, 5).should eql([1, 2, 3, 4 ,5, 6, 7, 9])
-      sudoku.send(:cell_revers_table, 7, 3).should eql([8])
-    end
-
-    it "in block (don't exist cell with single element)" do
-      sudoku = NSudoku.new(TABLE_EMPTY)
-      sudoku.send(:erase_in_block_one, 7, 3)
-      sudoku.send(:cell_revers_table, 6, 2).should eql([1, 2, 3, 4 ,5, 6, 7, 8, 9])
-      sudoku.send(:cell_revers_table, 5, 6).should eql([1, 2, 3, 4 ,5, 6, 7, 8, 9])
-
-      sudoku.send(:cell_revers_table, 6, 4).should eql([1, 2, 3, 4 ,5, 6, 7, 8, 9])
-      sudoku.send(:cell_revers_table, 8, 3).should eql([1, 2, 3, 4 ,5, 6, 7, 8, 9])
-    end
-  end
-
-  context "select cells with two elements (rest erase)" do
-
-    it "in block" do
-      sudoku = NSudoku.new(TABLE_EMPTY)
-      3.times do |row|
-        3.times do |column|
-          sudoku.send(:cell_revers_table, row, column, [2, 3, 4, 5, 6, 7, 9])
-        end
-      end
-
-      sudoku.send(:cell_revers_table, 0, 0, [1, 5, 8])
-      sudoku.send(:cell_revers_table, 2, 2, [1, 3, 8])
-
-      sudoku.send(:cells_with_two_elements_for, "block", 0)
-      sudoku.send(:cell_revers_table, 0, 0).should eql([1, 8])
-      sudoku.send(:cell_revers_table, 2, 2).should eql([1, 8])
-      sudoku.send(:cell_revers_table, 1, 2).should eql([2, 3, 4, 5, 6, 7, 9])
-    end
-
-    it "in column" do
-      sudoku = NSudoku.new(TABLE_EMPTY)
-      sudoku.send(:cell_revers_table, 0, 4, [1, 5, 8])
-      sudoku.send(:cell_revers_table, 1, 4, [1, 3, 8])
-      (2..8).each do |index|
-        sudoku.send(:cell_revers_table, index, 4, [2, 3, 4, 5, 6, 7, 9])
-      end
-
-      sudoku.send(:cells_with_two_elements_for, "column",  4)
-      sudoku.send(:cell_revers_table, 0, 4).should eql([1, 8])
-      sudoku.send(:cell_revers_table, 1, 4).should eql([1, 8])
-      sudoku.send(:cell_revers_table, 2, 4).should eql([2, 3, 4, 5, 6, 7, 9])
-    end
-
-    it "in row" do
-      sudoku = NSudoku.new(TABLE_EMPTY)
-      sudoku.send(:cell_revers_table, 4, 0, [1, 5, 8])
-      sudoku.send(:cell_revers_table, 4, 1, [1, 3, 8])
-      (2..8).each do |index|
-        sudoku.send(:cell_revers_table, 4, index, [2, 3, 4, 5, 6, 7, 9])
-      end
-
-      sudoku.send(:cells_with_two_elements_for, "row",  4)
-      sudoku.send(:cell_revers_table, 4, 0).should eql([1, 8])
-      sudoku.send(:cell_revers_table, 4, 1).should eql([1, 8])
-      sudoku.send(:cell_revers_table, 4, 2).should eql([2, 3, 4, 5, 6, 7, 9])
-    end
-
-  end
-
-  it "solve whole sudoku" do
-    NSudoku.new(EXAMPLE).solve.should eql("712460850394852671685170420070208596926715384050906712540320968269584137030690245")
+  it "should solve game sudoku" do
+    NSudoku.new(SUDOKU44).solve.should eq("1234431221433421")
+    NSudoku.new(SUDOKU99).solve.should eql("712460850394852671685170420070208596926715384050906712540320968269584137030690245")
   end
 end

data/spec/solver_spec.rb

@@ -0,0 +1,102 @@
+# encoding: utf-8
+
+require 'nsudoku'
+
+EXAMPLE = [
+  "1004",
+  "0302",
+  "0143",
+  "3020"].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]]
+# ]
+
+describe NSudoku do
+
+  before do
+    @logic = NSudoku::Solver.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
+
+  context "can erase that same elements in" do
+    it "column" do
+      @logic.set_vector(:column, 3, [[1, 3], [1, 2, 3, 4], [1, 3, 4], [4]])
+      @logic.only_one(:column, 3)
+      @logic.get_vector(:column, 3).should eq([[1, 3], [1, 2, 3], [1, 3], [4]])
+    end
+
+    it "row" do
+      @logic.set_vector(:column, 3, [[1, 3], [1, 2, 3, 4], [1, 3, 4], [4]])
+      @logic.only_one(:column, 3)
+      @logic.get_vector(:column, 3).should eq([[1, 3], [1, 2, 3], [1, 3], [4]])
+    end
+
+    it "block" do
+      @logic.set_vector(:block, 1, [[1, 2, 3], [2], [1, 2, 3, 4], [4]])
+      @logic.only_one(:block, 1)
+      @logic.get_vector(:block, 1).should eq([[1, 3], [2], [1, 3], [4]])
+    end
+  end
+
+  context "can choos only one value in elements for" do
+    it "vertical situation" do
+      @logic.set_vector(:column, 2, [[1, 3], [1, 2, 3, 4], [1, 3, 4], [4]])
+      @logic.search_single(:column, 2)
+      @logic.get_vector(:column, 2).should eq([[1, 3], [2], [1, 3, 4], [4]])
+    end
+
+    it "horizontal situation" do
+      @logic.set_vector(:row, 2, [[1, 3], [1, 2, 3, 4], [1, 3, 4], [4]])
+      @logic.search_single(:row, 2)
+      @logic.get_vector(:row, 2).should eq([[1, 3], [2], [1, 3, 4], [4]])
+    end
+
+    it "block situation" do
+      @logic.set_vector(:block, 2, [[1, 3], [1, 2, 3, 4], [1, 3, 4], [4]])
+      @logic.search_single(:block, 2)
+      @logic.get_vector(:block, 2).should eq([[1, 3], [2], [1, 3, 4], [4]])
+    end
+  end
+
+  context "can choose only two values in elements for" do
+    it "vertical situation" do
+      @logic.set_vector(:column, 2, [[1], [1, 2, 3, 4], [1, 2, 3, 4], [4]])
+      @logic.search_pair(:column, 2)
+      @logic.get_vector(:column, 2).should eq([[1], [2, 3], [2, 3], [4]])
+    end
+
+    it "horizontal situation" do
+      @logic.set_vector(:row, 3, [[3], [1, 2, 3, 4], [1, 2, 4], [4]])
+      @logic.search_pair(:row, 3)
+      @logic.get_vector(:row, 3).should eq([[3], [1, 2], [1, 2], [4]])
+    end
+
+    it "block situation" do
+      @logic.set_vector(:block, 0, [[1], [1, 2, 3, 4], [1, 2, 3, 4], [4]])
+      @logic.search_pair(:block, 0)
+      @logic.get_vector(:block, 0).should eq([[1], [2, 3], [2, 3], [4]])
+    end
+  end
+
+  it "can solve the sudoku" do
+    NSudoku::Solver.new(EXAMPLE).search.sudoku.should eql(
+      "1234" +
+      "4312" +
+      "2143" +
+      "3421"
+    )
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nsudoku
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-13 00:00:00.000000000 Z
+date: 2012-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -27,7 +27,8 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 2.10.0
-description: This gem solve puzzle game sudoku 9x9
+description: This gem solve puzzle game sudoku (n^2, n^2), for example (3^2, 3^2)
+  = (9, 9)
 email:
 - raglub.ruby@gmail.com
 executables: []
@@ -42,13 +43,13 @@ files:
 - Rakefile
 - lib/nsudoku.rb
 - lib/nsudoku/checker.rb
-- lib/nsudoku/logic.rb
+- lib/nsudoku/solver.rb
 - lib/nsudoku/version.rb
 - lib/sudoku.rb~
 - nsudoku.gemspec
 - spec/checker_spec.rb
-- spec/logic_spec.rb
 - spec/nsudoku_spec.rb
+- spec/solver_spec.rb
 homepage: http://github.com/raglub/nsudoku
 licenses: []
 post_install_message: 
@@ -75,5 +76,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
+- spec/solver_spec.rb

data/lib/nsudoku/logic.rb

@@ -1,187 +0,0 @@
-# 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/spec/logic_spec.rb

@@ -1,85 +0,0 @@
-# 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