In this presentation, we will be building a Sudoku Solver solely using Functional Programming idioms in Scala. This is a great opportunity to learn the very basics of Scala, the power of its built in Vector library and how it differs from what's build in Java 8. The presentation will be structured as follow: 1. Quick Introduction to Sudoku 2. Short introduction to Scala and the concepts required for the Solver 3. Let's get coding!

1. Functional Sudoku
HOW TO SOLVE SUDOKU GRIDS IN SCALA
1

2. 1 - Introduction
2

3. Table of content
1. Introduction
2. What is a Sudoku?
3. Brief introduction to Scala features
4. Let’s Get coding!
3

4. 1-Introduction – Who am I?
 I’m Cesar Tron-Lozai
 I work for a Startup in London
 I love Java, Scala and Functional Programming
4

5. 1-Introduction – What will talk about?
 How to solve Sudoku grids using Functional Idioms in Scala
 Have fun and hopefully learn something
 Disclaimers:
 I’m no Scala experts => please be tolerant if the Scala code smells
 Original idea from Anton Loss (@avloss) developed during a London Scala
Users Group in London
 It is not meant to be the fastest solution to solve a grid
 It does not solve hard grids (where backtracking is required)
5

6. 2 – What’s Sudoku
6

7. 2 – What’s Sudoku? - The rules
 9 x 9 grids
 Goal is to fill the whole grid
 All rows must have 1-9 once
 All columns must have 1-9 once
 All squares must have 1-9 once
Image credit: Wikipedia
7

8. 3 – Brief introduction to Scala features
8

9. 3 – Scala – Case Classes
 Case classes
 “regular classes which export their
constructor parameters and which
provide a recursive
decomposition mechanism via
pattern matching”
 Immutable
 Automatic constructors and
getters
sealed trait Shape
case class Circle(d: Double) extends Shape
case class Rectangle(w: Double, h: Double) extends Shape
val circle = Circle(22)
val rectangle = Rectangle(10, 20)
def shapePrint(shape: Shape) : String = shape match{
case Circle(d) => s"Circle [d=$d]"
case Rectangle(w, h) => s"Rectangle [w= $w, h=$h]"
}
9

10. 3 – Scala – Filter operator
def filter[A](as: Vector[A])(f: A => Boolean) : Vector[A]
val l1 = Vector(1, 2, 3)
l1.filter(x => x % 2 == 0) //= Vector(2)
10

11. 3 – Scala – Map operator
def map[A, B](as: Vector[A])(f: A=>B) : Vector[B]
val l1 = Vector(1, 2, 3)
l1.map(x => 2 * x) //= Vector(2, 4, 6)
11

12. 3 – Scala – Flat Map operator
def flatMap[A, B](as: Vector[A])(f: A => Vector[B]) : Vector[B]
val l1 = Vector(1, 2, 3)
val l2 = l1.flatMap(x => Vector(x, x))
//l2 = Vector(1, 1, 2, 2, 3, 3)
12

13. 3 – Scala – Grouped Operator
val row1 = Vector(1, 2, 3, 4): Vector[Int]
val row2 = Vector(5, 6, 7, 8): Vector[Int]
val row3 = Vector(9, 10, 11, 12): Vector[Int]
val row4 = Vector(13, 14, 15, 16): Vector[Int]
val matrix = Vector(row1, row2, row3, row4): Vector[Vector[Int]]
val g = matrix.grouped(2).toList
/*
g = [
[[1, 2, 3, 4],[5, 6, 7, 8]],
[[9, 10, 11, 12], [9, 10, 11, 12]]
]
*/
var rowIndex = 1
var colIndex = 0
val square = g(rowIndex)
.flatMap(row => row.grouped(2).toList(colIndex)) : Vector[Int]
/*
square = [9, 10, 13, 14]
*/
13

14. 3 – Scala – Tuples
val tuple = (1, 2, 3)
//val tuple = Tuple3(1, 2, 3)
val e1 = tuple._1 //=1
val e2 = tuple._2 //=2
val e3 = tuple._3 //=3
14

15. 3 – Scala – ZipWithIndex operator
val list = Vector("a", "b", "c")
val zipped = list.zipWithIndex
//zipped = Vector((a,0), (b,1), (c,2))
15

16. 3 – Scala – Transpose Operator
 Transpose
 Transform a m x n matrix into a n
x m matrix
val row1 = Vector (1, 2) : Vector[Int]
val row2 = Vector(3, 4) : Vector[Int]
val row3 = Vector(5, 6) : Vector[Int]
val matrix = Vector(row1, row2, row3) : Vector[Vector[Int]]
val t = matrix.transpose
//t = Vector(Vector(1, 3, 5), Vector(2, 4, 6))
Example credit: Wikipedia
16

17. 4 – Sudoku Solver
17

18. 4 – Solver – Cell class
sealed trait Cell
case class Fixed(e: Int) extends Cell
case class Undetermined(values: List[Int]) extends Cell
A grid is modelled as: Vector[Vector[Cell]]
18

19. 4 – Solver – Sudoku Class
case class Sudoku(grid: Vector[Vector[Cell]]) {
def isValueAllowedInRow(position: (Int, Int), value: Int): Boolean = ???
def isValueAllowedInColumn(position: (Int, Int), value: Int): Boolean = ???
def isValueAllowedInSquare(position: (Int, Int), value: Int): Boolean = ???
}
19

20. 4 – Solver – Row logic
/**
* Returns true if the given value, at the given position, is allowed within its row.
* Logically this is true if the row doesn't already contain a Fixed cell with the given value
*
* @param position The position of the cell being checked
* @param value The value to test
* @return true if the value is allowed in that cell
*/
def isValueAllowedInRow(position: (Int, Int), value: Int): Boolean =
!grid(position._1).contains(Fixed(value))
20

21. 4 – Solver – Column logic
/**
* Returns true if the given value, at the given position, is allowed within its column.
* Logically this is true if the column doesn't already contain a Fixed cell with the given
value
*
* @param position The position of the cell being checked
* @param value The value to test
* @return true if the value is allowed in that cell
*/
def isValueAllowedInColumn(position: (Int, Int), value: Int): Boolean = {
val t = grid.transpose
!t(position._2).contains(Fixed(value))
}
21

22. 4 – Solver – Square logic
/**
* Returns true if the given value, at the given position, is allowed within its square.
* Logically this is true if the square doesn't already contain a Fixed cell with the given
value
*
* @param position The position of the cell being checked
* @param value The value to test
* @return true if the value is allowed in that cell
*/
def isValueAllowedInSquare(position: (Int, Int), value: Int): Boolean = {
val ci = position._1 / 3
val cj = position._2 / 3
val squareCells = grid.grouped(3).toList(ci).flatMap { row =>
row.grouped(3).toList(cj)
}
!squareCells.contains(Fixed(value))
}
22

23. 4 – Solver – Logic wrapper
/**
* Returns true of the given value, at the given position is allowed. This methods combine
the row, column and
* square strategies
*
* @param position The position of the cell being checked
* @param value The value to test
* @return true if the value is allowed in that cell
*/
def isValueAllowed(position: (Int, Int), value: Int): Boolean =
isValueAllowedInRow(position, value) &&
isValueAllowedInColumn(position, value) &&
isValueAllowedInSquare(position, value)
23

24. 4 – Solver – And finally
def filter(): Sudoku = {
val filtered: Vector[Vector[Cell]] = grid
.zipWithIndex
.map {case (row, rowIdx) =>
row
.zipWithIndex
.map {
case (Undetermined(values), colIdx) =>
Undetermined(values.filter(v => isValueAllowed((rowIdx, colIdx),v)))
case (x, _) => x
}
.map {
case Undetermined(values) if values.size == 1 => Fixed(values.head)
case x => x
}
}
if (filtered == grid) this
else Sudoku(filtered).filter()
}
24

25. References
 Code available on Github: https://github.com/cesartl/sudoku
 It contains a bit more error handling
 Tested again 100 simple Sudokus (https://qqwing.com/instructions.html)
 Thank you:
 Anton Loss (@avloss)
 Julien Truffaut (https://github.com/julien-truffaut)
25