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.
This Algorithm goes a bit beyond TicTacToeBoardCheck, with the goal of actually solving the board and playing the game.
Test cases in Scala
assert( TicTacToe( nextTurn = TicTacToe.PlayerId.X, board = Vector( Some(TicTacToe.PlayerId.O), Some(TicTacToe.PlayerId.X), Some(TicTacToe.PlayerId.X), None, None, Some(TicTacToe.PlayerId.O), Some(TicTacToe.PlayerId.X), None, Some(TicTacToe.PlayerId.O) ) ).nextBestMoveAndScore == Some((1 -> 1) -> 2) )
Algorithm in Scala
71 lines of Scala (version 2.13).
MinMax works by testing all the different next moves (and then the moves after that, recursively), to find the move for which the total score of winning is maximised.
It is a great simple approach to solving two-player games. (this is © from www.scala-algorithms.com)
We define nextBestMoveAndScore in terms of nextBestMoveAndScore: running two in sequence means running a next best move for one player and a next best move for the player after that; this means that nextBestMoveAndScore(move 1 for player O) = function of (-nextBestMoveAndScore(move 2 for player X)).
Scala concepts & Hints
'collect' allows you to use Pattern Matching, to filter and map items.
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!
Pattern matching in Scala lets you quickly identify what you are looking for in a data, and also extract it.
scanLeft and scanRight
Scala's `scan` functions enable you to do folds like foldLeft and foldRight, while collecting the intermediate results
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.
.viewsyntax creates a structure that mirrors another structure, until "forced" by an eager operation like .toList, .foreach, .forall, .count.