コード例 #1
0
//main entry function that calls the right
//functions for getting sodoku answer
func (inst *Solutionizer) GetSodokuSolution(board *sodoku.Board) string {

	inst.possibilities = 0

	pass := inst.SetIndicesWithLeastPossibleChoices(board)

	if !pass {
		panic("Can't be solved!")
		return ""
	}

	return board.GetStringFormat()
}
コード例 #2
0
//for a particular empty index, returns the
//numbers available that can poltentially be
//inserted in that index
func (inst *Solutionizer) getPossibilities(i, j int, board *sodoku.Board) []int {

	families := board.GetFamilies(i, j)
	availableNumbers := 987654321

	for _, family := range families {
		availableNumbers = inst.availableNumbers(availableNumbers, family)
	}

	numsAvailable := inst.getPossibilitiesFromAvailableNumbers(availableNumbers)

	return numsAvailable
}
コード例 #3
0
//retrieves the family with the least
//free options to choose from. For example
//if a particular row only has one blank
//indices then we know we can fill that entry
//with 100% certainty(the unused number will go there)
//returns true if solution was found
func (inst *Solutionizer) SetIndicesWithLeastPossibleChoices(board *sodoku.Board) bool {

	toBeFilled := board.GetEmptyIndices()

	if len(toBeFilled) <= 0 && board.IsBoardComplete() {
		return true
	}

	oppertunityFound := false
	oppertunities := [9][]oppertunity{}
	boardChange := false

	for _, v := range toBeFilled {

		i, j := v[0], v[1]

		numAvailable := inst.getPossibilities(i, j, board)
		length := len(numAvailable)

		//if no oppertunities or certainties were found then
		//we are dealing with a faulty/broken board
		if length <= 0 {
			return false
			//if we only have one choice to choose from then we know 100% we can set it
		} else if length == 1 {
			//set indices for relatives
			board.SetEntry(i, j, numAvailable[0])
			boardChange = true
			//other wise we track available oppurtunities thats ordered
			//based on amount of numbers available
		} else {
			oppertunityFound = true
			oppertunities[length] = append(oppertunities[length], oppertunity{i, j, numAvailable})
		}
	}

	//if board was changed we call recursion on updated board
	if boardChange {
		return inst.SetIndicesWithLeastPossibleChoices(board)
		//else if at least one oppurtunity was found
		//we insert oppurtunity and recompute recursion
		//notice how oppertunities are traverse based on order
		//of minimum possibilities. This gives it a much higher chance
		//of success
	} else if oppertunityFound {

		//make copy of current entries before any alterations
		originalEntry := inst.copy(board.Entries)
		inst.possibilities += 1

		for _, ops := range oppertunities {

			for _, op := range ops {

				if len(op.Entries) <= 0 {
					continue
				}

				for _, v := range op.Entries {
					board.SetEntry(op.I, op.J, v)
					pass := inst.SetIndicesWithLeastPossibleChoices(board)
					//if recursion returns true
					if pass {
						return true
						//otherwise if this oppertunity wasnt the best choice
						//we set it back to 0 and try next oppertunity
					} else {
						board.SetEntries(originalEntry)
					}
				}

			}

		}
	}

	return false
}