Scala algorithm: Tic Tac Toe board check

Published , last updated

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.

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))

Algorithm in Scala

54 lines of Scala (version 2.13).

Get the full algorithm Scala algorithms logo, maze part, which looks quirky!

or

'Unlimited Scala Algorithms' gives you access to all the Scala Algorithms!

Upon purchase, you will be able to Register an account to access all the algorithms on multiple devices.

Stripe logo

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.

Full explanation is available for subscribers Scala algorithms logo, maze part, which looks quirky

Scala concepts & Hints

  1. 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))
    
  2. 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)
    
  3. 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")
    
  4. 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))
    
  5. 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)
    
  6. View

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

View the rest of Scala algorithms