### Context

As hinted at in the first post, I found Abhinav’s posts to be a great source material for learning and (over this weekend) recreation 🙂

I picked the second post, where the pruning process is tweaked to be faster.

### Pruning changes

I pretty much stuck to the original code, just *Scala-ized* it, most of the action happens here:

def exclusivePossibilities(row: Row): List[List[Int]] = { def foldHelper1(m: Map[Int, List[Int]], entry: (Cell, Int)): Map[Int, List[Int]] = entry match { case (Possible(nums), idx) => nums.foldLeft(m) { (m,n) => m.updatedWith(n)( (optList) => optList match { case None => Some(List(idx)) case Some(list) => Some(list.appended(idx)) }) } } def foldHelper2(m: Map[List[Int], List[Int]], entry: (Int, List[Int])): Map[List[Int], List[Int]] = entry match { case (idx, nums) => m.updatedWith(nums)( (optList) => optList match { case None => Some(List(idx)) case Some(list) => Some(list.appended(idx)) }) } // Get map of indices to values. val interim = row. zip(Range(1,10).toList). filter { case (c, _) => isPossible(c) }. foldLeft(Map(): Map[Int, List[Int]])(foldHelper1(_, _)). filter(_._2.length < 4) // Flip map and extract list of indices. interim. foldLeft(Map(): Map[List[Int], List[Int]])(foldHelper2(_, _)). filter { case (k, v) => k.length == v.length }. values. toList } def makeCell(nums: List[Int]): Option[Cell] = nums match { case List() => None case List(x) => Some(Fixed(x)) case xs => Some(Possible(xs)) }

… which is then used by the pruning functions (the first largely kept from before, the second one something new) …

def pruneCellsByFixed(cells: List[Cell]): Option[List[Cell]] = { val fixeds = cells.collect { case Fixed(x) => x } def pruneCell(c: Cell): Option[Cell] = c match { case f @ Fixed(_) => Some(f) case Possible(nums) => makeCell(nums.filterNot(fixeds.toSet)) } traverser(cells)(pruneCell) } def pruneCellsByExclusives(cells: List[Cell]): Option[List[Cell]] = { val exclusives = exclusivePossibilities(cells) val allExclusives = exclusives.flatten def pruneCell(c: Cell): Option[Cell] = c match { case f @ Fixed(_) => Some(f) case p @ Possible(nums) => { val intersection = nums.intersect(allExclusives) if (exclusives.contains(intersection)) { makeCell(intersection) } else { Some(p) } } } exclusives match { case List() => Some(cells) case _ => traverser(cells)(pruneCell) } }

… and the *replacement for the old* `pruneCells`

is:

def pruneCells(cells: List[Cell]): Option[List[Cell]] = { for { step1 <- fixM[List[Cell]](pruneCellsByFixed, cells) step2 <- fixM[List[Cell]](pruneCellsByExclusives, step1) } yield step2 }

View source here.

(**Note:** I had a bug where I had forgotten to filter out keys/values of identical length within `exclusivePossibilities`

, which led to a few rounds of debugging … once again, I elected to leave that commit history instead of cleaning it up)

### Results

sbt:sudoku> run "/home/agam/tmp/sudoku17-top-100.txt" … Total time: 2 s,

I found a *massive* speedup too (**100x!** … two seconds to solve the sample set of a hundred problems, instead of two *hundred* seconds earlier)