So, here is more Haskell from me, because I really like it. This time around, I wrote a small and simple sudoku solver. Sudokus are really nice little puzzles that involve a partially filled 9x9 grid containing numbers from one to nine. The objective is to fill it following these rules:

- Each number must only appear once per row
- Each number must only appear once per column
- Each number must only appear once per 3x3 ‘box’, of which there are nine

A common strategy is checking empty cells for available numbers to fill in, so the ones that are not already present in the corresponding row, column or box. This is also the approach my solver takes, by checking each of the empty cells for options and, if there is only one possible option, filling it in. Repeat this until there are no empty cells anymore and you have a guaranteed correct solution. There is a great deal of mathematics behind sudoku puzzles, and if you are interested in that, the Wikipedia article is a great read.

Because I wrote my solver before conducting any research, it emulates my approach, which is brute forcing. Still, it solves 9x9 sudokus in <0.01 seconds. We will now have an in-depth look at it. If you want context, the whole code including an example is on Github.

I implemented the solver in form of a Haskell library that exports three functions:

`build`

builds the internal representation of the puzzle from a list of integers`prettyPrint`

prints a puzzle`solve`

solves a puzzle

`build`

is really simple, because it looks like this:

build :: [Value] -> Grid build vs = zip [0..] vs

This already exposes the internal structure of a puzzle, which is this:

type Value = Int type Coord = Int type Cell = (Coord, Value) type Grid = [Cell]

I chose to use a single associative list over a nested list because it makes the code a whole lot easier to read when accessing various cells of a grid, at the expense of having to do some maths.

`prettyPrint`

is not really worth explaining or even showing, all it does is
dividing a grid into nine chunks, the lines, converting the integers to chars,
replacing zeros with underscores, insert some spaces for readability and prints
the whole thing out. I just added it so I could check the results easily.

`solve`

is the really interesting part here. Solve loops until a puzzle is
solved, which looks like this:

solved :: Grid -> Bool solved = foldr (\(_, v) r -> if v == 0 then False else r) True solve :: Grid -> Grid solve g | solved g = g | otherwise = solve $ fill g (0, get g 0)

What `fill`

does is it iterates once through all the cells, and each time it
encounters an empty cell (`(_, 0)`

), it checks which numbers could be placed in
it. If there is only one possibility, it changes the grid accordingly and
continues. After a complete iteration, it returns the changed grid.

fill :: Grid -> Cell -> Grid fill g c@(n, v) | n >= 81 = g | v /= 0 = fill g next | length opts == 1 = fill (change g (n, (head opts))) next | otherwise = fill g next where next = (n + 1, get g (n + 1)) opts = options g c

`change`

goes through the grid, looking for the cell we want to change,
replaces the value and returns the changed grid, so we can use it for the
remainder of the iteration. It is very easily implemented using a single `map`

:

change :: Grid -> Cell -> Grid change g (n, v) = map (\(gn, gv) -> if gn == n then (n, v) else (gn, gv)) g

`get`

gets the value of the cell at a coordinate in a grid, pretty simple:

get :: Grid -> Coord -> Value get g n = snd $ g !! n

`options`

on the other hand is a little bit more complicated. It has to check
the row, the column and the box a given cell is in, and check for a number
between one and nine that is not already present in any of them. And because I
chose to use a single list to represent the whole grid, having the list indices
stored inside a cell comes in very handy, because we can use it to calculate
the indices of the other cells in the same row, column and box. But first, this
is `options`

:

options :: Grid -> Cell -> [Value] options g (n, _) = let r = (rowWise n) ++ (colWise n) ++ (boxWise n) in filter (`notElem` (map (get g) r)) [1..9]

It looks a bit overloaded, but is actually quite easy. `r`

is a composite list
that includes all the coordinates (/indices) of the cells that affect the
possible content of this cell. We `map`

it to get to transform it to a list of
numbers that are not possible here, and then simply return all numbers between
one and nine that are not in that list. If you go back to `fill`

above, you can
see that if the length of this list is one, this solution is filled in.

To finish this off, here are the three remaining functions that calculate the coordinates of the affecting cells. I planned these out when I could not sleep yesterday.

rowWise :: Coord -> [Coord] rowWise n = let r = n `div` 9 * 9 in [r..(r+8)] colWise :: Coord -> [Coord] colWise n = let os = n`mod` 9 in [os,(os+9)..80] boxWise :: Coord -> [Coord] boxWise n = let c = n `mod` 9 `div` 3 r = n `div` 27 * 3 s = r * 9 + c * 3 in [s..(s+2)] ++ [(s+9)..(s+11)] ++ [(s+18)..(s+20)]

`rowWise`

and `colWise`

should be pretty easy to understand if you imagine a
grid and try out some example cells. `boxWise`

is a bit more contrived, what it
generally does it figures out in which of the nine boxes the cell is by
comparing the offset from the left and the offset from the top separately, and
then using the top-left cell of this box as a starting point to get the other
eight coordinates, which are always in the same relative position.

So this is the complete code to solve a sudoku puzzle. If you exclude the printing stuff, it is about 50 lines long, and there is a lot to optimize here, but I will leave it as it is, because I am only interested in the PoC.