sudokuhandler 0.1.2 → 0.1.3

data/lib/sudoku/solver.rb

@@ -0,0 +1,176 @@
+module Sudoku
+  #Methodes de resolution des sudokus
+  module Solver
+    #Renvoie les nombres manquants dans le carré comprenant la case x,y
+    # @param [Fixnum] x La colonne d'une case du carré à traiter
+    # @param [Fixnum] y La rangée d'une case du carré à traiter
+    # @return [Array] Les nombres manquants
+    def missing_square x, y
+      Array.new(size){|i| i+1} - square(x,y)
+    end
+    
+    #Renvoie les nombres manquants dans la colonne
+    # @param [Fixnum] x La colonne à traiter
+    # @return [Array] Les nombres manquants
+    def missing_col x
+      Array.new(size){|i| i+1} - col(x)
+    end
+    
+    #Renvoie les nombres manquants dans la colonne
+    # @param [Fixnum] y La ligne à traiter
+    # @return [Array] Les nombres manquants
+    def missing_row y
+      Array.new(size){|i| i+1} - row(y)
+    end
+    
+    #Ajoute un nombre chaque fois que c'est la seule possibilité
+    # @return [Fixnum] le nombre de nombres ajoutés dans la grille
+    def solve_uniq_possibilities!
+      res = 0
+      loop do
+        adds = 0
+        each do |x, y, val|
+          next unless val.zero?
+          
+          p = possibilities x, y
+          if p.length == 1
+            set x, y, p.first
+            adds += 1
+          end
+          
+        end
+        break if adds == 0
+        res += adds
+      end
+      res
+    end
+    
+    #Ajoute un nombre chaque fois que c'est la seule position possible dans la colonne
+    # @param [Fixnum] x La colonne à traiter
+    # @return [Fixnum] le nombre de nombres ajoutés
+    def solve_col! x
+      adds = 0
+      
+      missing_col(x).each do |val|
+        pos = []
+        size.times do |y|
+          next unless get(x,y) == 0
+          pos << [x,y] if valid? x, y, val
+        end
+        if pos.length == 1
+          set pos[0][0], pos[0][1], val
+          adds += 1
+        end
+      end
+      
+      adds
+    end
+    
+    #Ajoute un nombre chaque fois que c'est la seule position possible dans la ligne
+    # @param [Fixnum] y La ligne à traiter
+    # @return [Fixnum] le nombre de nombres ajoutés
+    def solve_row! y
+      adds = 0
+      
+      missing_row(y).each do |val|
+        pos = []
+        size.times do |x|
+          next unless get(x,y) == 0
+          pos << [x,y] if valid? x, y, val
+        end
+        if pos.length == 1
+          set pos[0][0], pos[0][1], val
+          adds += 1
+        end
+      end
+      
+      adds
+    end
+    
+    #Ajoute un nombre chaque fois que c'est la seule position possible dans le carré
+    # @param [Fixnum] x La colonne d'une case du carré à traiter
+    # @param [Fixnum] y La rangée d'une case du carré à traiter
+    # @return [Fixnum] le nombre de nombres ajoutés
+    def solve_square! xx, yy
+      xmin = xx - (xx%base)
+      ymin = yy - (yy%base)
+      adds = 0
+      
+      missing_square(xx, yy).each do |val|
+        pos = []
+        base.times do |i|
+          base.times do |j|
+            x = xmin + i
+            y = ymin + j
+            next unless get(x,y) == 0
+            pos << [x,y] if valid? x, y, val
+          end
+        end
+        if pos.length == 1
+          set pos[0][0], pos[0][1], val
+          adds += 1
+        end
+      end
+      
+      adds
+    end
+    
+    #Utilise solve_uniq_possibilities!, solve_col!, solve_row! et solve_square!
+    #tant qu'ils ajoutent des nombres
+    # @return [Fixnum] le nombre de nombres ajoutés
+    def solve_naive!
+      res = 0
+      
+      loop do
+        adds = solve_uniq_possibilities!
+        size.times do |i|
+          adds += solve_col! i
+          adds += solve_row! i
+          
+          x = (i*base) % size
+          y = (i/base) * base
+          adds += solve_square! x, y
+        end
+        break if adds.zero?
+        res += adds
+      end
+      
+      res
+    end
+    
+    #Resoud le sudoku par backtracking
+    # @return (Fixnum) le nombre de nombres ajoutés dans la grille
+    def solve_backtrack!
+      res = solve_naive!
+      
+      each do |x, y, cur_val|
+        next unless cur_val.zero?
+        p = possibilities x, y
+        p.each do |val|
+          copy = clone
+          copy.set x, y, val
+          adds = copy.solve_backtrack!
+          if copy.complete?
+            self.import copy
+            return res+adds+1
+          end
+        end
+      end
+      
+      res
+    end
+    
+    #Enleve les nombres qui sont impossibles de la grille
+    # @return (Fixnum) le nombre de nombres enlevés
+    def remove_impossible!
+      removes = 0
+      each do |x, y, val|
+        unless valid_cell? x, y, val
+          set x, y, 0 
+          removes += 1
+        end
+      end
+      removes
+    end
+  end
+end

data/lib/sudoku/version.rb

@@ -1,3 +1,3 @@
 module Sudoku
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/tests/test_sudoku.rb

@@ -1,19 +1,33 @@
 require 'test/unit'
 require 'sudoku'
 
+class MyTestCase < Test::Unit::TestCase
+  #Certains Rubys n'ont pas refute...
+  def refute what, *args
+    begin
+      return super(what, *args)
+    rescue NoMethodError => e
+      return assert(!what, args)
+    end
+  end
+  
+  def test_myrefute
+    refute false, "Implementation refute"
+  end
+end
+
 module GridTest
   def create
     klass.new base
   end
   
-  def diagonal
+  def test_initialize
     s = create
-    s.each{|x, y, val| s.set x,x,x+1 if x==y}
-    s
+    s.each{|x,y,val| assert_equal 0, val, "Sudoku initialise a 0 partout"}
   end
   
   def test_diagonal
-    s = diagonal
+    s = create.make_diagonal
     (s.size-1).times{|i| assert_equal 1, s.get(i+1, i+1)-s.get(i, i)}
   end
   
@@ -34,15 +48,16 @@ module GridTest
   
   def test_clone
     s1 = create
-    s1.set 0, 0, 1
+    s1.each{|x,y,v| s1.set x, y, rand(s1.size)+1}
       
     s2 = s1.clone
-      
-    assert_equal 1, s2.get(0, 0)
+    s2.each do |x, y, v|
+      assert_equal s1.get(x,y), v, "Clonage cellule #{x},#{y}"
+    end
   end
   
   def test_each
-    s = diagonal
+    s = create.make_diagonal
     s.size.times{|x| assert_equal x+1, s.get(x, x)}
   end
   
@@ -67,25 +82,27 @@ module GridTest
 
   def test_possibilities
     s = create
-    s.set 0,0,1
+    s.set 1,0,1
     s.set 0,1,2
     
     assert s.possibilities(1, 1).include?(3)
-    assert s.possibilities(1, 1).include?(4)
-    
-    assert s.valid?(1,1,3)
-    assert s.valid?(1,1,4)
+    refute s.possibilities(1, 1).include?(1)
+    refute s.valid?(1,1,1), "Case non occupee, valeur impossible"
+    refute s.valid?(0,1,1), "Case deja occupee, valeur impossible"
+    assert s.valid?(1,1,4), "Case non occupee, valeur plausible"
+    assert s.valid?(1,1,0), "0 est toujours valide"
+    assert s.valid?(1,0,1), "Case deja occupee, valeur plausible"
     
-    refute s.valid?(1,1,0)
-    refute s.valid?(1,1,1)
-    assert s.valid?(0,0,1)
+    s.possibilities(1, 1).each do |p|
+      assert s.valid?(1, 1, p), "Possibilite #{p} doit etre valide"
+    end
   end
 
   def test_sutxt
     sutxt = "#{base}:"
     size = base*base
     size.times do |y|
-      size.times {|x| sutxt << " #{x+1}"}
+      size.times {|x| sutxt += " #{x+1}"}
     end
     sutxt += ';'
     
@@ -107,38 +124,94 @@ module GridTest
     assert s.completable?
     refute s.valid?
   end
-end
 
-module GeneratorTest
-  def generator
-    Class.new klass do
-      include Sudoku::Generator
+  def test_count
+    s = create    
+    assert_equal s.length, s.count(0)[0], "Comptage de 0 dans un sudoku vide"
+    
+    s.make_diagonal
+    expected = {}
+    s.size.times{|x| expected[x+1] = 1}
+    assert_equal expected, s.count, "Comptage de valeurs dans un sudoku diagonal"
+    
+    assert_raise(ArgumentError, "Comptage de valeur > size impossible"){s.count(s.size+1)}
+  end
+
+  def test_import
+    s  = create.make_valid
+    s2 = Sudoku::Sn.new(s.size)
+    s2.each do |x,y,v|
+      assert_equal s.get(x,y), v, "Importation d'une grille vers grille generique, cellules egales"
     end
+    
+    s3 = Sudoku::Sn.new(s.size+1)
+    assert_raise(Sudoku::NotCompatibleError, "Importation d'une grille vers grille de taille differente"){s3.import s}
   end
-  
-  def test_diagonal
-    s = generator.new(base).make_diagonal
+end
+
+module GeneratorTest
+  def test_generator_diagonal
+    s = create.make_diagonal
     s.size.times{|x| assert_equal x+1, s.get(x, x)}
   end
   
-  def test_valid
-    s = generator.new(base).make_valid
+  def test_generator_valid
+    s = create.make_valid
     assert s.valid?
     assert s.completable?
     assert s.complete?
   end
 end
 
-class S3Test < Test::Unit::TestCase
+module SolverTest
+  SOLVER_TIMEOUT = 10 #sec
+  
+  def test_missing
+    s = create
+    s.set 0,1,1
+    s.set 1,0,2
+    
+    assert s.missing_square(0,0).include?(3)
+    refute s.missing_square(0,0).include?(1)
+    
+    assert s.missing_col(0).include?(2)
+    refute s.missing_col(0).include?(1)
+    
+    assert s.missing_row(0).include?(1)
+    refute s.missing_row(0).include?(2)
+  end
+
+  def test_solve_uniq
+    s = create.make_valid
+    s.set 0,0,0
+    s.set 1,1,0
+    
+    assert_equal 2, s.solve_uniq_possibilities!, "Solution par possibilites uniques d'un sudoku complet-2cases"
+    assert s.complete?
+  end
+
+  def test_solve_backtrack
+    s = create.make_valid_incomplete
+    t = Thread.new(s){|sudoku| sudoku.solve_backtrack!}
+    t.join SOLVER_TIMEOUT
+    assert s.complete?, "Toujours une solution en backtracking en max. #{SOLVER_TIMEOUT}s"
+  end
+end
+
+module SudokuTest
   include GridTest
+  include SolverTest
   include GeneratorTest
+end
+
+class S3Test < MyTestCase
+  include SudokuTest
   
   def base; 3; end
   def klass; Sudoku::S3; end
-  def create; klass.new; end
   
   def test_square
-    s = diagonal
+    s = create.make_diagonal
     9.times do |i|
       assert_equal [1+3*(i/3), 2+3*(i/3), 3+3*(i/3)], s.square(i,i)
     end
@@ -146,14 +219,28 @@ class S3Test < Test::Unit::TestCase
 
   def test_possibilities
     super
-    s = diagonal
+    s = create.make_diagonal
     assert_equal [1, 4, 5, 6, 7, 8, 9], s.possibilities(0, 0).sort
   end
+
+  #Tests pour l'implementation en C de valid_cell?
+  def test_valid_cimpl
+    s = klass.new
+    s.set 0, 7, 1
+    s.set 7, 0, 2
+    s.set 1, 1, 3
+    
+    refute s.valid?(0, 0, 1), "Colonne"
+    refute s.valid?(0, 0, 2), "Ligne"
+    refute s.valid?(0, 0, 3), "Carre"
+    assert s.valid?(0, 0, 4)
+    
+    assert_raise(ArgumentError){s.valid?(9, 2, 3)}
+  end
 end
 
-class S4_15Test < Test::Unit::TestCase
-  include GridTest
-  include GeneratorTest
+class S4_15Test < MyTestCase
+  include SudokuTest
   
   def base; 4; end
   def klass; Sudoku::S4_15; end
@@ -163,19 +250,35 @@ class S4_15Test < Test::Unit::TestCase
   end
 end
 
-class SnTest < Test::Unit::TestCase
-  include GridTest
-  include GeneratorTest
+class SnTest < MyTestCase
+  include SudokuTest
   
   def base; 2; end
   def klass; Sudoku::Sn; end
 end
 
-class SudokuTest < Test::Unit::TestCase
+class GlobalTest < Test::Unit::TestCase
   def test_autoclass
-    [S3Test, S4_15Test, SnTest].each do |g|
-      grid = g.new nil
-      assert_equal grid.klass, Sudoku[grid.base]
+    {Sudoku::S3 => 3, Sudoku::S4_15 => 4, Sudoku::Sn => 2}.each do |klass, base|
+      assert_equal klass, Sudoku[base], "Sudoku[#{base}] => #{klass}"
+    end
+    
+    Sudoku[2..7] = GridTest
+    assert_equal GridTest, Sudoku[6], "Definition d'autoclasses persos"
+  end
+  
+  def test_speed
+    t = [Time.now]
+    klasses = [Sudoku::S3, Sudoku::S4_15, Sudoku::Sn]
+    
+    klasses.each do |k|    
+      s = k.new 3
+      1000.times{|i| s.each{|x,y,v| s.valid? x,y,9}}
+      t << Time.now
+    end
+    
+    2.times do |i|
+      assert (t[i+1] - t[i])<(t[i+2] - t[i+1]), "#{klasses[i]} plus rapide que #{klasses[i+1]}"
     end
   end
 end