Dogeku 1.0.1

data/app/utils/DSubset.rb

@@ -0,0 +1,98 @@
+
+##
+## Technique Disjoint Subset.
+##
+class DSubset < Technique
+
+	##
+	## Constructeur de la classe DSubset
+	##
+	## @return     Une instance de la classe DSubset
+	##
+	def DSubset.creer()
+		new()
+	end
+
+	##
+	## Recherche une solution pour la technique utilisée
+	##
+	## @param      grille  La grille
+	##
+	## @return     Les informations pour aider l'utilisateur, ou nul si la méthode ne trouve rien
+	##
+	def solution(grille)
+		grilleIndice = indice(grille)
+		
+		res = Array.new()
+		[0,1,2,3,4,5,6,7,8].each { |x|
+			col = colonne(grilleIndice,x)
+			col.each_with_index{ |c,y|
+				i = 0
+				c.each_value{|v| if v == true then i+=1 end }
+				if i>1 then
+					res << [x,y]
+					col[(y+1)..(-1)].each_with_index{ |cBis,yBis|
+						if cBis.eql?(c) then res << [x,y+yBis+1] end
+					}
+					if res.length == i then
+						return res
+					end
+				end
+				res = Array.new()
+			}
+		}
+		
+		[0,1,2,3,4,5,6,7,8].each { |y|
+			lig = ligne(grilleIndice,y)
+			lig.each_with_index{ |c,x|
+				i = 0
+				c.each_value{|v| if v == true  then i+=1 end }
+				if i>1 then
+					res << [x,y]
+					lig[(x+1)..(-1)].each_with_index{|cBis,xBis|
+						if cBis.eql?(c) then res << [x+xBis+1,y] end
+					}
+					if res.length == i then
+						return res
+					end
+				end
+				res = Array.new()
+			}
+		}
+		
+		return nil
+	end
+
+	##
+	## Retourne le nombre d'étape pour faire la technique
+	##
+	## @return     Le nombre d'étape(s)
+	##
+	def combienEtape()
+		return 4
+	end
+
+	##
+	## Retourne les étapes pour faire la technique
+	##
+	## @param      n     Le numéro de la technique
+	##
+	## @return     Un text expliquant l'étape sinon
+	##
+	def etape(n)
+
+		case(n)
+		when 1
+			return "Bienvenue sur l'explication de la technique "+self.class.to_s+"."
+		when 2
+			return "Recherchez les candidats possibles pour chaque case d'une ligne/colonne."
+		when 3
+			return "Il arrive que N candicats soient possibles sur N cases d'une même ligne/colonne"
+		when 4
+			return "Dans ce cas, les N candidats sont applicable uniquement dans ces N cases et non ailleur."
+		end
+		
+		return nil
+	end
+
+end

data/app/utils/Generateur.rb

@@ -0,0 +1,171 @@
+## 	Author:: 		BastienMor
+## 	Developers: 	BastienMor
+## 	Version:: 		0.1
+## 	Copyright:: 	© 2017
+## 	License:: 		Distributes under the same terms as Ruby
+## 	
+
+##
+## Génération de grille de Sudoku (création de difficulté)
+##
+class Generateur
+
+	@grid
+	@difficulte
+
+	attr_reader :grid, :difficulte
+
+	##
+	## Initialisation
+	## 
+	## @param difficulte	Difficulté à prendre en compte
+	##
+	def initialize(difficulte)
+		@grid = Array.new()
+		ligne = Array.new()
+
+		@difficulte = difficulte
+
+		9.times do
+			val = 1+rand(9)
+			while(ligne.include? val)
+				val = 1+rand(9)
+			end
+			ligne.unshift(val)
+		end
+
+		3.times do
+			3.times do
+				@grid.push(ligne.clone)
+				3.times do
+					ligne.unshift(ligne.pop())
+				end
+			end
+			ligne.unshift(ligne.pop())
+		end
+
+		4.times do
+			a = rand(3)
+			b = rand(3)
+			while(a == b)
+				b = rand(3)
+			end
+
+			switchrow(a, b)
+			switchcol(a, b)
+			switchrow(5-a, 5-b)
+			switchcol(8-a, 8-b)
+		end
+
+		complexifier()
+	end
+
+
+	##
+	## Génère une grille avec une difficulté variable
+	##
+	def generer()
+		self.convert()
+	end
+
+	##
+	## Echange la place de 2 lignes.
+	##
+	## @param 	a 	Première ligne
+	## @param 	b 	Deuxième ligne
+	##
+	def switchrow(a, b)
+		@grid[a], @grid[b] = @grid[b], @grid[a]
+	end
+
+	##
+	## Echange la place de 2 colonnes.
+	## 
+	## @param 	a 	Première colonne
+	## @param 	b 	Deuxième colonne
+	##
+	def switchcol(a, b)
+		@grid.map {|e| e[a], e[b] = e[b], e[a]}
+	end
+
+
+	##
+	## Retire des cases pour créer la difficulté.
+	##
+	## @return la grille
+	def complexifier()
+
+		present = Array.new
+		9.times do
+			val = 1+rand(9)
+			while(present.include? val)
+				val = 1+rand(9)
+			end
+			present.unshift(val)
+		end
+
+		1.upto(@difficulte) do
+			victime = present.pop()
+			@grid.each do |a|
+				a.each_with_index do |c, index|
+					if c == victime
+						a[index] = nil
+					end
+				end
+			end
+		end
+
+
+		nbkill = 0
+		@grid.each do |a|
+			nbkill += a.count(nil)
+		end
+		nbkill = (81-nbkill)* @difficulte *0.1
+
+		0.upto(nbkill) do
+			x = rand(9)
+			y = rand(9)
+			while(@grid[x][y] == nil)
+				x = rand(9)
+				y = rand(9)
+			end
+			@grid[x][y] = nil
+		end
+
+		return @grid
+	end
+
+
+	##
+	## Convertit la grille de list
+	##
+	## @return la grille convertie.
+	##
+	def convert()
+
+		res = Array.new()
+		ligne = Array.new()
+
+		@grid.each do |line|
+			line.each do |elem|
+				val = Hash.new()
+				val["value"] = elem
+				val["editable"] = false
+				
+				if(elem == nil)
+					val["editable"] = true
+				end
+
+				ligne.push(val.clone())
+			end
+			res.push(ligne.clone())
+			ligne = Array.new()
+		end
+
+		return res
+	end
+end
+
+# gen = Generateur.new()
+# g1 = gen.generer(1)
+# g2 = gen.generer(1)

data/app/utils/HPTriple.rb

@@ -0,0 +1,75 @@
+# => Author:: 		yguenver
+# => Version:: 		0.1
+# => Copyright:: 	© 2016
+# => License:: 		Distributes under the same terms as Ruby
+
+
+##
+## Technique des jumeaux et triplés
+##
+class HPTriple < Technique
+
+	##
+	## Constructeur de la classe HPTriple
+	##
+	## @return une instance de la classe HPTriple
+	##
+	def HPTriple.creer
+		new()
+	end
+
+	##
+	## Recherche une solution pour la technique utilisée
+	##
+	## @param      grille  La grille
+	##
+	## @return     Les informations pour aider l'utilisateur, ou nil si la méthode ne trouve rien
+	##
+	def solution(grille)
+		grilleIndice = indice(grille)
+
+ 		# res = Array.new()
+		# [1,2,3,4,5,6,7,8,9].sort_by{rand}.each { |b|
+		#   [0,1,2,3,4,5,6,7,8].sort_by{rand}.each { |x|
+		#     [1,2,3,4,5,6,7,8,9].sort_by{rand}.each{ |n|
+		#       col = colonne(block(grilleIndice,b),x)
+		#       col.each_with_index{ |hash,y| if hash[n.to_s] then res << [x,y] end}
+		#     }
+		#   }
+		# }
+
+		return nil
+	end
+
+	##
+	## Retourne le nombre d'étape pour faire la technique
+	##
+	## @return     Le nombre d'étape(s)
+	##
+	def combienEtape()
+		return 4
+	end
+
+	##
+	## Retourne les étapes pour faire la technique
+	##
+	## @param      n     Le numéro de la technique
+	##
+	## @return     Un texte expliquant l'étape sinon nil
+	##
+	def etape(n)
+
+		# case(n)
+		# when 1
+		# 	return "Bienvenue sur l'explication de la technique "+self.class.to_s+"."
+		# when 2
+		# 	return "Recherchez les candidats possibles pour chaque case d'une ligne/colonne."
+		# when 3
+		# 	return "Il arrive que N candicats soient possibles sur N cases d'une même ligne/colonne"
+		# when 4
+		# 	return "Dans ce cas, les N candidats sont applicable uniquement dans ces N cases et non ailleur."
+		# end
+
+		return nil
+	end
+end

data/app/utils/Peche.rb

@@ -0,0 +1,46 @@
+# => Author:: 		yguenver
+# => Version:: 		0.1
+# => Copyright:: 	© 2016
+# => License:: 		Distributes under the same terms as Ruby
+
+##
+## Classe pour la technique 'Pêche à la ligne'.
+##
+class Peche < Technique
+
+	##
+	## Constructeur de la classe Peche
+	##
+	## @return     Une instance de la classe Peche
+	##
+	def Peche.creer()
+		new()
+	end
+	
+	##
+	## Recherche une solution pour la technique utilisée
+	##
+	## @param 	grille 			La grille
+	##
+	## @return 	res, les informations pour aider l'utilisateur ou nil si la méthode ne trouve rien
+	##
+	def solution(grille)
+	
+		# res = Array.new()
+
+		# [1,2,3,4,5,6,7,8,9].sort_by{rand}.each { |numero|
+		# 	listPresent = nombreDejaPresent(grille, numero)
+			
+		# 	x = 1
+		# 	y = 1
+			
+		# 	listPresent.each{ |case,index|
+		# 		if case.nil? then
+					
+		# 		end
+		# 	}
+		# }
+	
+		return nil
+	end
+end

data/app/utils/SCandidate.rb

@@ -0,0 +1,86 @@
+# => Author:: 		yguenver
+# => Version:: 		0.1
+# => Copyright:: 	© 2016
+# => License:: 		Distributes under the same terms as Ruby
+
+##
+## Classe pour la technique 'Single Candidate'.
+##
+class SCandidate < Technique
+
+	##
+	## Constructeur de la classe SCandidate
+	##
+	## @return 	Une instance de la classe SCandidate
+	##
+	def SCandidate.creer()
+		new()
+	end
+
+	##
+	## Recherche une solution pour la technique utilisée
+	##
+	## @param 	grille 			La grille
+	##
+	## @return 	res, les informations pour aider l'utilisateur ou nil si la méthode ne trouve rien
+	##
+	def solution(grille)
+		grilleIndice = indice(grille)
+
+		[1,2,3,4,5,6,7,8,9].sort_by{rand}.each { |numero|
+			grilleIndice.sort_by{rand}.each_with_index { |col,x|
+				cpt=0
+				ytmp=0
+					col.sort_by{rand}.each_with_index { |c,y|
+						if c[numero.to_s] then
+							cpt +=1
+							ytmp = y
+						end
+					}
+					if cpt == 1 then return [x,ytmp,numero.to_s] end
+			}
+
+			[0,1,2,3,4,5,6,7,8].sort_by{rand}.each { |y|
+				cpt=0
+				xtmp=0
+				[0,1,2,3,4,5,6,7,8].sort_by{rand}.each { |x|
+					if grilleIndice[x][y][numero.to_s] then
+						cpt +=1
+						xtmp = x
+					end
+				}
+				if cpt == 1 then return [xtmp,y,numero.to_s] end
+			}
+		}
+
+		return nil
+	end
+
+	##
+	## Retourne le nombre d'étapes pour faire la technique
+	##
+	## @return     Le nombre d'étapes
+	##
+	def combienEtape()
+		return 2
+	end
+
+	##
+	## Retourne les étapes pour faire la technique
+	##
+	## @param      n     Le numéro de la technique
+	##
+	## @return     Un texte expliquant l'étape sinon nil
+	##
+	def etape(n)
+
+		case(n)
+		when 1
+			return "Bienvenue sur l'explication de la technique "+self.class.to_s+"."
+		when 2
+			return "Recherchez les candidats possibles pour chaque case d'une ligne/colonne. Remarquez que dans certaines, un candidat n'est possible que dans une seule case de la ligne/colonne."
+		end
+		
+		return nil
+	end
+end