Parsing matrix data with Scala

I think the state machine is not needed; the following will give you a data structure equivalent in shape and content to the state machine solution:

import scala.io.Source

val input = Source.fromString(
  """|3
     |1 2 1
     |1 2 2
     |1 2 3
     |3 2 1
     |4
     |1 2 3 1
     |1 2 3 2
     |1 2 3 3
     |1 2 3 4""".stripMargin)

val matrices = input.getLines.grouped(5).map {
  case List(w, l1, l2, l3, l4) =>
    // feel free to use the value of `w.toInt` to do an assertion on the 4 lines
    List(l1, l2, l3, l4) map { _.split(' ').map(_.toInt).toList }
}

for (matrix <- matrices)
  println(matrix.map(_.mkString("[", ", ", "]")).mkString("\n"))

// prints:
// [1, 2, 1]
// [1, 2, 2]
// [1, 2, 3]
// [3, 2, 1]
// [1, 2, 3, 1]
// [1, 2, 3, 2]
// [1, 2, 3, 3]
// [1, 2, 3, 4]

stefan's code is a great example of a functional state machine but I personally would prefer something like this

import io.Source

val input = Source.fromString(
   """|3
      |1 2 1
      |1 2 2
      |1 2 3
      |1 2 4
      |4
      |1 2 3 1
      |1 2 3 2
      |1 2 3 3
      |1 2 3 4""".stripMargin)

type Matrix = List[List[Int]]

def readMatrix(list: List[Int], height: Int, width: Int): Matrix =  {
  list.take(height * width).grouped(width).toList
}

def readMatrices(list: List[Int]): List[Matrix] = {
  if (list.isEmpty) List()
  else readMatrix(list.tail, 4, list.head) :: readMatrices(list.drop(4 * list.head + 1))
}

def printMatrix(matrix: Matrix) = println(matrix.map(_.mkString("", ", ", "")).mkString("", "\n", "\n"))

val parsedMatrices = readMatrices(input.mkString.split("\\s+").map(_.toInt).toList)
parsedMatrices.foreach(printMatrix)

How about the following recursive solution?

val fixedHeight = 4

def readMatrices(lines: List[String]): List[Array[Array[Int]]] = {

  def readMatrices0(lines: List[String], result: ListBuffer[Array[Array[Int]]]): List[Array[Array[Int]]] = lines match {
    case None => result.toList
    case head :: tail =>
      val n = head.toInt 
      val mat = readMatrix(tail.take(fixedHeight))
      // check that the matrix has width n:
      require(mat.forall(_.length == n), "Incorrect width")
      readMatrices0(tail.drop(fixedHeight), result + mat)
  }

  def readMatrix(lines: List[String]): Array[Array[Int]] = 
    lines.map(_.split(' ').map(_.toInt).toArray

  readMatrices0(lines, new ListBuffer)
}

val mats = readMatrices(scala.io.Source.fromFile(f).getLines)

OK, I think I have a nice one:

• It deals with matrices with different number of rows (I bet there are matrices with different row numbers in the posters log files :-)
• It does not parse the whole input at once, but step by step (and uses hence not that much memory)
• It allows validation of the input

Preparation

The first part is nearly the same as with my first answer. But I added zipWithIndex to preserve the line numbers of the input.

    import io.Source

    def rawInput = Source.fromString(
       """|3
          |1 2 1
          |1 2 2 
          |1 2 3
          |4
          |1 2 3 1
          |1 2 3 2
          |1 2 3 3
          |1 2 3 4""".stripMargin) // You would probably use Source.fromFile(...)

    type Matrix = List[Array[Int]]

    def parsedInput = rawInput.getLines().map(_.split(" ")).map(_.map(_.toInt)).zipWithIndex

Version with Iterator

This version uses a classical Java iterator with mutable state. It is not in functional style, but should run quite fast:

    def matrixIterator= new Iterator[Matrix] {
      val input = parsedInput

      var expectedNumerOfRows : Option[Int] = None

      override def hasNext = input.hasNext

      override def next() : Matrix = {
        import collection.mutable.MutableList
        var matrix : MutableList[Array[Int]] = MutableList()
        while (input.hasNext) {
          val (currentLine, lineNumber)=input.next()
          if (currentLine.size==1){
            expectedNumerOfRows=Some(currentLine.head)
            return matrix.toList
          }else{
            matrix+=currentLine
            expectedNumerOfRows.filter(_ != currentLine.size).foreach{ expected : Int =>
              //println(String.format("Warning in line %s: Expected %s columns, got %s", lineNumber+1, expected, currentLine.size))
            }
          }
        }
        return matrix.toList
      }
    }.next()

Version with Stream

This version uses Scala streams.It is recursive (although not tail recursive) and does not use mutable variables. It should be a little bit slower than the Iterator version, but is much more readable:

    def matrixStream : Stream[Matrix] = {
      def matrix(input : Iterator[(Array[Int], Int)], numberOfColumns : Int, currentMatrix : Matrix) : Stream[Matrix] = {
        if (!input.hasNext) {
          currentMatrix #:: Stream.empty
        }else{
          val (line, number) = input.next()
          if (line.size == 1) {
            currentMatrix.reverse #:: matrix(input, line.head, List.empty)
          }else{
            //if (numberOfColumns != line.size) println(...)
            matrix(input, numberOfColumns, line :: currentMatrix)
          }
        }
      }
      matrix(parsedInput,0,List()).drop(1)
    }

Even without regular expressions:

for (i <- 0 to 3) {
  matrix(i) = line.split(" ")
}

Regular expressions can help.

val space = " ".r
val arrayOfNumbersAsStrings = space.split(line)
val arrayOfNumbersAsInts = arrayOfNumbersAsStrings.map(_.toInt)

UPD

val arrayOfNumbersAsStrings = space.split(' ')
val arrayOfNumbersAsInts = arrayOfNumbersAsStrings.map(_.toInt)