Tic Tac Toe board check

Algorithm goal

In Tic Tac Toe (also known as Naughts and Crosses), players place an X or an O onto a 3x3 grid. The winner is the player who gets three of their own in a row/column/diagonal.

Here, we verify that a Tic Tac Toe board has a winner; and whether a move is valid. To see how we could play Tic-Tac-Toe, see TicTacToeSolveMinMax.

Explanation

The first challenge in solving these two functions is how to represent the board. In this case, the algorithm solution was implemented a TDD approach to allow for the most testable representation of the board.

There are other was of representing the board, such as Vector of Vector, or even a Map, but in this one, it is represented by a Vector, with mappings between Vector indices the the position on the board. (this is © from www.scala-algorithms.com)

A more Scala way of representing whether a position is filled is using an Option of an enumeration (O | X), rather than a Boolean or some other type.

Scala Concepts & Hints

For-comprehension

The for-comprehension is highly important syntatic enhancement in functional programming languages.

val Multiplier = 10

val result: List[Int] = for {
num <- List(1, 2, 3)
anotherNum <-
List(num * Multiplier - 1, num * Multiplier, num * Multiplier + 1)
} yield anotherNum + 1

assert(result == List(10, 11, 12, 20, 21, 22, 30, 31, 32))


Option Type

The 'Option' type is used to describe a computation that either has a result or does not. In Scala, you can 'chain' Option processing, combine with lists and other data structures. For example, you can also turn a pattern-match into a function that return an Option, and vice-versa!

assert(Option(1).flatMap(x => Option(x + 2)) == Option(3))

assert(Option(1).flatMap(x => None) == None)


Pattern Matching

Pattern matching in Scala lets you quickly identify what you are looking for in a data, and also extract it.

assert("Hello World".collect {
case character if Character.isUpperCase(character) => character.toLower
} == "hw")


scanLeft and scanRight

Scala's scan functions enable you to do folds like foldLeft and foldRight, while collecting the intermediate results

assert(List(1, 2, 3, 4, 5).scanLeft(0)(_ + _) == List(0, 1, 3, 6, 10, 15))


Stack Safety

Stack safety is present where a function cannot crash due to overflowing the limit of number of recursive calls.

This function will work for n = 5, but will not work for n = 2000 (crash with java.lang.StackOverflowError) - however there is a way to fix it :-)

In Scala Algorithms, we try to write the algorithms in a stack-safe way, where possible, so that when you use the algorithms, they will not crash on large inputs. However, stack-safe implementations are often more complex, and in some cases, overly complex, for the task at hand.

def sum(from: Int, until: Int): Int =
if (from == until) until else from + sum(from + 1, until)

def thisWillSucceed: Int = sum(1, 5)

def thisWillFail: Int = sum(1, 300)


View

The .view syntax creates a structure that mirrors another structure, until "forced" by an eager operation like .toList, .foreach, .forall, .count.

Algorithm in Scala

54 lines of Scala (version 2.13).

Test cases in Scala

assert(sampleMoveSequence(0).winner.isEmpty, "Started game has no winner")
assert(sampleMoveSequence(1).winner.isEmpty, "One move has no winner")
assert(sampleMoveSequence(2).winner.isEmpty, "Two moves have no winner")
assert(sampleMoveSequence(3).winner.isEmpty, "Three moves have no winner")
assert(sampleMoveSequence(4).winner.isEmpty, "Four moves have no winner")
assert(
sampleMoveSequence(5).winner.contains(TicTacToeBoard.PlayerId.X),
"Game is won by 'x' after 5 moves"
)
assert(
sampleMoveSequence2.flatMap(_.winner) == List(TicTacToeBoard.PlayerId.O),
"Game is won by 'o' after 6 moves"
)
assert(
!sampleMoveSequence(1).isValidMove(0 -> 0),
"If a spot is taken, the move is invalid"
)
assert(TicTacToeBoard.invertPos(7) == (2 -> 1))

def sampleMoveSequence: List[TicTacToeBoard] = ???