sudokuhandler 0.1.2 → 0.1.3

data/lib/sudoku.rb

@@ -4,192 +4,14 @@
 
 require "sudokucore"
 require "sudoku/version"
+require "sudoku/grid"
 
 module Sudoku 
   #Exception lancée lors d'erreurs de lecture d'une chaine Sutxt
   class MalformedSutxtError < Exception; end
   
-  #Permet de generer rapidement un sudoku
-  module Generator
-    #Remplit la diagonale descendante de 1 a self.size
-    def make_diagonal
-      each{|x,y,val| set x,x,x+1 if x==y}
-      self
-    end
-    
-    #Remplit tout le sudoku de maniere a ce qu'il soit valide
-    def make_valid
-      pattern = Array.new(size){|i| i+1}
-      size.times do |y|
-        size.times do |x|
-          set x, y, pattern[x]
-        end
-        base.times{|i| pattern.push pattern.shift}
-        pattern.push pattern.shift if base - (y%base) == 1
-      end
-      self
-    end
-  end
-  
-  #Taches communes a tous les Sudokus
-  module Grid
-    #Renvoie le contenu de la ligne x
-    def col x
-      res = []
-      size.times do |y|
-        val = get x, y
-        res << val if val != 0
-      end
-      res
-    end
-    
-    #Renvoie le contenu de la ligne y
-    def row y 
-      res = []
-      size.times do |x|
-        val = get x, y
-        res << val if val != 0
-      end
-      res
-    end
-    
-    #Renvoie le contenu du carré contenant la case x,y
-    def square x, y
-      xmin = x - (x%base)
-      ymin = y - (y%base)
-      res = []
-      
-      base.times do |xx|
-        base.times do |yy|
-          val = get xx+xmin, yy+ymin
-          res << val if val != 0
-        end
-      end
-      
-      res
-    end
-    
-    #Renvoie true si le sudoku ne contient aucune case vide
-    def complete?
-      each{|x,y,val| return false if val == 0}
-      true
-    end
-    
-    #Renvoie true si chaque case a au moins 1 possibilité à ce stade
-    def completable?
-      completed = 0
-      each do |x, y, val|
-        return false if possibilities(x, y).empty?
-      end
-      return true
-    end
-    
-    #Renvoie toutes les possibilités pour la case x,y
-    def possibilities x, y
-      res = Array.new(size){|i| i+1}
-      xmin = x-x%base
-      ymin = y-y%base
-      
-      size.times do |i|
-        res.delete get(x,i) if i!=y
-        res.delete get(i,y) if i!=x
-        xx, yy = xmin+i%base, ymin+i/base
-        res.delete get(xx, yy) if xx!=x && yy!=y
-      end
-      
-      res
-    end
-    
-    #Renvoie true si tous les nombres de la grille sont valides
-    def valid_grid?
-      each do |x, y, val|
-        next if val.zero?
-        return false unless valid_cell? x, y, val
-      end
-      
-      true
-    end
-    
-    #Renvoie true si val est possible en x,y
-    def valid_cell? x, y, val
-      val  = val.to_i
-      xmin = x-x%base
-      ymin = y-y%base
-      
-      size.times do |i|
-        return false if i!=y && get(x,i)==val
-        return false if i!=x && get(i,y)==val
-        xx, yy = xmin+i%base, ymin+i/base
-        return false if xx!=x && yy!=y && get(xx, yy) == val
-      end
-      
-      true
-    end
-    
-    #Si aucun argument n'est passé => valid_grid?
-    #Si 3 arguments sont passés    => valid_cell? x, y, val
-    def valid? *args
-      if args.empty?
-        valid_grid?
-      elsif args.length == 3
-        valid_cell? *args
-      else
-        raise ArgumentError, "wrong number of arguments(#{args.length} for 0 or 3)"
-      end
-    end
-    
-    #Renvoie la base du sudoku
-    def base
-      if @base
-        @base
-      else
-        @base = (size**0.5).to_i
-      end
-    end
-    
-    #Renvoie le nombre de cases dans le sudoku
-    def length
-      if @length
-        @length
-      else
-        @length = size*size
-      end
-    end
-    
-    #Représentation texte humainement lisible
-    def to_s
-      res  = ""
-      width = size.to_s.length
-      zero = ".".center width+1
-      
-      size.times do |y|
-        res += "\n" if y>0 && y%base == 0
-        size.times do |x|
-          res += " " if x>0 && x%base == 0
-          val = get x, y
-          res += val.zero? ? zero : "#{val.to_s.center width} "
-        end
-        res += "\n"
-      end
-      res
-    end
-    
-    #Représentation courte (utile dans irb)
-    def inspect
-      "#<#{self.class} #{size}x#{size} [#{get 0, 0}, #{get 0, 1}, ... , #{get size-2, size-1}, #{get size-1, size-1}]>"
-    end
-    
-    #Représentation pour l'enregistrement
-    def to_sutxt
-      res = "#{base}:"
-      size.times do |y|
-        size.times do |x|
-          res << " #{get x, y}"
-        end
-      end
-      res+';'
-    end
-  end
+  #Exception lancée lors d'operations sur deux sudokus incompatibles
+  class NotCompatibleError < Exception; end
   
   #Sudoku 9x9 (base 3) très rapide
   class S3
@@ -201,6 +23,8 @@ module Sudoku
       __initialize nil
     end
     
+    #Renvoie le coté du Sudoku
+    # @return (Fixnum)
     def size
       SIZE
     end
@@ -211,6 +35,8 @@ module Sudoku
     include Grid
     private :size_internal
     
+    #Renvoie le coté du Sudoku
+    # @return (Fixnum)
     def size
       if @size
         @size
@@ -234,6 +60,8 @@ module Sudoku
       end
     end
     
+    #Renvoie le coté du Sudoku
+    # @return (Fixnum)
     def set x, y, val
       if x<0 || x>=size || y<0 || y>=size || val<0 || val > size
         raise ArgumentError, "#{x},#{y} => #{val} is impossible in a #{size}x#{size} sudoku"
@@ -241,6 +69,8 @@ module Sudoku
       @grid[x][y] = val
     end
     
+    #Renvoie la valeur en x,y
+    # @return (Fixnum)
     def get x, y
       if x<0 || x>=size || y<0 || y>=size
         raise ArgumentError, "Is there a #{x},#{y} cell in a #{size}x#{size} sudoku ?"
@@ -248,15 +78,20 @@ module Sudoku
       @grid[x][y]
     end
     
+    #Parcourt tout le sudoku
+    # @yield [x, y, val] la position et la valeur courante
+    # @return (self)
     def each
       @size.times do |y|
         @size.times do |x|
           yield x, y, @grid[x][y]
         end
       end
+      self
     end
   end
   
+  #Adaptateurs de base
   ADAPTERS = [
     [3, S3],
     [4..15, S4_15],
@@ -264,8 +99,11 @@ module Sudoku
   ]
   
   class << self
-    #Renvoie la classe de la meilleure implémentation pour un sudoku de base n
-    def [] n
+    #Renvoie la classe de la première implémentation dont la zone comprend n
+    # @param [Fixnum] n La base du sudoku
+    # @return [Class] La première classe dont la zone comprend n, ou la première classe
+    #                 donc la zone est 0 (zone par défaut)
+    def best_class_for n
       n = n.to_i
       ADAPTERS.each do |ad|
         zone    = ad[0]
@@ -279,37 +117,35 @@ module Sudoku
         end
       end
     end
+    alias :[] :best_class_for
     
-    #Ajoute un element 
-    def []= zone, adapter
+    #Ajoute un adapteur pour la zone definie. 
+    # @param [Range, Fixnum] zone La zone de validité de l'adapteur
+    # @param [Class] adapter L'adaptateur à ajouter
+    def define_class_for zone, adapter
       ADAPTERS.unshift [zone, adapter]
     end
+    alias :[]= :define_class_for
     
     #Renvoie une instance de la meilleure implémentation pour un sudoku de base n
+    # @param [Fixnum] n La base du sudoku
+    # @return [Grid]
     def best_grid_for n=3
       n = n.to_i
-      self[n].new n
+      best_class_for(n).new n
     end
     alias :new :best_grid_for
     
     #Renvoie un nouveau Sudoku a partir de la chaine donnee
+    # @param [String] str Une chaine Sutxt
+    # @return [Grid] Un sudoku rempli avec les données Sutxt
     def parse str
       unless str =~ /(\d+):(.+);/
         raise MalformedSutxtError, "It doesn't seem to be a sutxt line..."
       end
 
       base = $1.to_i
-      data = $2.split(/\s+/).delete_if(&:empty?).map(&:to_i)
-      unless data.length == base**4
-        raise MalformedSutxtError, "Expecting #{base**4} numbers, #{data.length} given"
-      end
-
-      res = self.best_grid_for base
-      res.each do |x, y, val|
-        res.set x, y, data[x+y*res.size]
-      end
-
-      return res
+      return best_grid_for(base).load(str)
     end
   end
 end

data/lib/sudoku/generator.rb

@@ -0,0 +1,40 @@
+module Sudoku
+  #Permet de generer rapidement un sudoku
+  module Generator
+    #Remplit la diagonale descendante de 1 a self.size
+    # @return [self]
+    def make_diagonal
+      each{|x,y,val| set x,x,x+1 if x==y}
+      self
+    end
+    
+    #Remplit tout le sudoku de maniere a ce qu'il soit valide
+    # @return [self]
+    def make_valid
+      pattern = Array.new(size){|i| i+1}.shuffle
+      size.times do |y|
+        size.times do |x|
+          set x, y, pattern[x]
+        end
+        base.times{|i| pattern.push pattern.shift}
+        pattern.push pattern.shift if base - (y%base) == 1
+      end
+      self
+    end
+  
+    #Cree un sudoku valide et laisse des cases vides au hasard
+    # @param [Fixnum] seed Le parametre a utiliser pour rand()
+    # @return [self]
+    def make_valid_incomplete seed=2
+      pattern = Array.new(size){|i| i+1}.shuffle
+      size.times do |y|
+        size.times do |x|
+          set x, y, pattern[x] if rand(seed) == seed-1
+        end
+        base.times{|i| pattern.push pattern.shift}
+        pattern.push pattern.shift if base - (y%base) == 1
+      end
+      self
+    end
+  end
+end

data/lib/sudoku/grid.rb

@@ -0,0 +1,14 @@
+SUDOKU_LIBDIR = File.dirname File.expand_path(__FILE__)
+
+require "#{SUDOKU_LIBDIR}/logic"
+require "#{SUDOKU_LIBDIR}/solver"
+require "#{SUDOKU_LIBDIR}/generator"
+
+module Sudoku
+  #Interface commune des sudokus
+  module Grid
+    include Logic
+    include Generator
+    include Solver
+  end
+end

data/lib/sudoku/logic.rb

@@ -0,0 +1,242 @@
+module Sudoku
+  #Logique de base du Sudoku
+  module Logic
+    #Renvoie le contenu de la ligne x
+    # @return (Array)
+    def col x
+      res = []
+      size.times do |y|
+        val = get x, y
+        res << val if val != 0
+      end
+      res
+    end
+    
+    #Renvoie le contenu de la ligne y
+    # @return (Array)
+    def row y 
+      res = []
+      size.times do |x|
+        val = get x, y
+        res << val if val != 0
+      end
+      res
+    end
+    
+    #Renvoie le contenu du carré contenant la case x,y
+    # @return (Array)
+    def square x, y
+      xmin = x - (x%base)
+      ymin = y - (y%base)
+      res = []
+      
+      base.times do |xx|
+        base.times do |yy|
+          val = get xx+xmin, yy+ymin
+          res << val if val != 0
+        end
+      end
+      
+      res
+    end
+    
+    #Renvoie true si le sudoku ne contient aucune case vide
+    def complete?
+      each{|x,y,val| return false if val == 0}
+      true
+    end
+    
+    #Renvoie true si chaque case a au moins 1 possibilité à ce stade
+    def completable?
+      completed = 0
+      each do |x, y, val|
+        return false if possibilities(x, y).empty?
+      end
+      return true
+    end
+    
+    #Renvoie toutes les possibilités pour la case x,y
+    # @return (Array)
+    def possibilities x, y
+      res = Array.new(size){|i| i+1}
+      xmin = x-x%base
+      ymin = y-y%base
+      
+      size.times do |i|
+        res.delete get(x,i) if i!=y
+        res.delete get(i,y) if i!=x
+        xx, yy = xmin+i%base, ymin+i/base
+        res.delete get(xx, yy) if xx!=x && yy!=y
+      end
+      
+      res
+    end
+    
+    #Renvoie true si tous les nombres de la grille sont valides
+    def valid_grid?
+      each do |x, y, val|
+        next if val.zero?
+        return false unless valid_cell? x, y, val
+      end
+      
+      true
+    end
+    
+    #Renvoie true si val est possible en x,y
+    def valid_cell? x, y, val
+      return true if val.zero?
+      val  = val.to_i
+      xmin = x-x%base
+      ymin = y-y%base
+      
+      size.times do |i|
+        return false if i!=y && get(x,i)==val
+        return false if i!=x && get(i,y)==val
+        xx, yy = xmin+i%base, ymin+i/base
+        return false if xx!=x && yy!=y && get(xx, yy) == val
+      end
+      
+      true
+    end
+    
+    # @overload valid?(x, y, val)
+    #   Vérifie si val est valide en x,y
+    #   @param [Fixnum] x   La colonne de la valeur à vérifier
+    #   @param [Fixnum] y   La ligne de la valeur à vérifier
+    #   @param [Fixnum] val La valeur à vérifier
+    #   @return [Boolean] true si la valeur est valide, false sinon
+    # @overload valid?
+    #   Vérifie que toutes les valeurs du Sudoku sont vlaides
+    #   @return [Boolean] true si toutes les valeurs sont valides, false sinon
+    def valid? *args
+      if args.empty?
+        valid_grid?
+      elsif args.length == 3
+        valid_cell? *args
+      else
+        raise ArgumentError, "wrong number of arguments(#{args.length} for 0 or 3)"
+      end
+    end
+    
+    #Renvoie la base du sudoku
+    # @return (Fixnum)
+    def base
+      if @base
+        @base
+      else
+        @base = (size**0.5).to_i
+      end
+    end
+    
+    #Renvoie le nombre de cases dans le sudoku
+    # @return (Fixnum)
+    def length
+      if @length
+        @length
+      else
+        @length = size*size
+      end
+    end
+    
+    # Compte le nombre d'occurences pour les valeurs
+    # @return [Hash] L'association valeur => occurences
+    # @overload count(*values)
+    #   Compte les occurences pour les valeurs passées en paramètres
+    #   @param [*Fixnum] values Les valeurs à compter
+    # @overload count
+    #   Compte les occurences de chaque valeur
+    def count *values
+      values = Array.new(size){|i| i+1} if values.empty?
+      
+      res = {}
+      values.each do |val| 
+        if val<0 || val>size
+          raise ArgumentError, "Impossible value #{val} in a #{size}x#{size} sudoku"
+        end
+        res[val] = 0
+      end
+      
+      each do |x, y, val|
+        res[val] += 1 if values.include? val
+      end
+      
+      res
+    end
+    
+    #Représentation texte humainement lisible
+    # @return (String)
+    def to_s
+      res  = ""
+      width = size.to_s.length
+      zero = ".".center width+1
+      
+      size.times do |y|
+        res += "\n" if y>0 && y%base == 0
+        size.times do |x|
+          res += " " if x>0 && x%base == 0
+          val = get x, y
+          res += val.zero? ? zero : "#{val.to_s.center width} "
+        end
+        res += "\n"
+      end
+      res
+    end
+    
+    #Représentation courte (utile dans irb)
+    # @return [String]
+    def inspect
+      "#<#{self.class} #{size}x#{size} [#{get 0, 0}, #{get 0, 1}, ... , #{get size-2, size-1}, #{get size-1, size-1}]>"
+    end
+    
+    #Représentation pour l'enregistrement
+    # @return (String)
+    def to_sutxt
+      res = "#{base}:"
+      size.times do |y|
+        size.times do |x|
+          res << " #{get x, y}"
+        end
+      end
+      res+';'
+    end
+    
+    #Charge un Sudoku depuis une chaine Sutxt
+    # @return (self)
+    # @raise [MalformedSutxtError] Chaine Sutxt mal formatee
+    # @raise [NotCompatibleError]  La chaine Sutxt correspond a un Sudoku de base differente
+    def load sutxt_str
+      unless sutxt_str =~ /(\d+):(.+);/
+        raise MalformedSutxtError, "It doesn't seem to be a sutxt line..."
+      end
+
+      sutxt_base = $1.to_i
+      unless sutxt_base == base
+        raise NotCompatibleError, "A #{base} sudoku cannot load a #{sutxt_base} Sutxt"
+      end
+      
+      data = $2.split(/\s+/).delete_if(&:empty?).map(&:to_i)
+      unless data.length == length
+        raise MalformedSutxtError, "Expecting #{length} numbers, #{data.length} given"
+      end
+      
+      size.times do |y|
+        size.times do |x|
+          set x, y, data.shift
+        end
+      end
+      self
+    end
+    
+    #Charge un sudoku depuis un autre sudoku
+    # @param [Grid] l'autre Sudoku
+    # @return (self)
+    # @raise [NotCompatibleError] L'autre sudoku est de base differente
+    def import other
+      unless size == other.size
+        raise NotCompatibleError, "Cannot import a #{other.base} sudoku in a #{base} sudoku"
+      end
+      other.each{|x,y,v| set x,y,v}
+      self
+    end
+  end
+end