Question

I’m programming a Killer Sudoku Solver in Ruby and I try to take human strategies and put them into code. I have implemented about 10 strategies but I have a problem on this one.

In killer sudoku, we have “zones” of cells and we know the sum of these cells and we know possibilities for each cell.

Example :

• Cell 1 can be 1, 3, 4 or 9
• Cell 2 can be 2, 4 or 5
• Cell 3 can be 3, 4 or 9
• The sum of all cells must be 12

I want my program to try all possibilities to eliminate possibilities. For instance, here, cell 1 can’t be 9 because you can’t make 3 by adding two numbers possible in cells 2 and 3.

So I want that for any number of cells, it removes the ones that are impossible by trying them and seeing it doesn’t work.

How can I get this working ?

Answer 1

There’s multiple ways to approach the general problem of game solving, and emulating human strategies is not always the best way. That said, here’s how you can solve your question:

1st way, brute-forcy

Basically, we want to try all possibilities of the combinations of the cells, and pick the ones that have the correct sum.

cell_1 = [1,3,4,9]
cell_2 = [2,4,5]
cell_3 = [3,4,9]
all_valid_combinations = cell_1.product(cell_2,cell_3).select {|combo| combo.sum == 12}
# => [[1, 2, 9], [3, 5, 4], [4, 4, 4], [4, 5, 3]]
#.sum isn't a built-in function, it's just used here for convenience

to pare this down to individual cells, you could do:

cell_1 = all_valid_combinations.map {|combo| combo[0]}.uniq
# => [1, 3, 4]
cell_2 = all_valid_combinations.map {|combo| combo[1]}.uniq
# => [2, 5, 4]
. . .

if you don’t have a huge large set of cells, this way is easier to code. it can get a bit inefficienct though. For small problems, this is the way I’d use.

---

2nd way, backtracking search

Another well known technique takes the problem from the other approach. Basically, for each cell, ask “Can this cell be this number, given the other cells?”

so, starting with cell 1, can the number be 1? to check, we see if cells 2 and 3 can sum to 11. (12-1)
* can cell 2 have the value 2? to check, can cell 3 sum to 9 (11-1)

and so on. In very large cases, where you could have many many valid combinations, this will be slightly faster, as you can return ‘true’ on the first time you find a valid number for a cell. Some people find recursive algorithms a bit harder to grok, though, so your mileage may vary.