Funktionaler Weg, um eine Matrix aus Text zu erhalten

Question

Ich versuche, einige Google Code Jam-Probleme zu lösen, bei denen eine Eingabematrix typischerweise in dieser Form vorgegeben ist:

2 3 #matrix dimensions
1 2 3 4 5 6 7 8 9 # all 3 elements in the first row
2 3 4 5 6 7 8 9 0 # each element is composed of three integers

wobei jedes Element der Matrix aus, sagen wir, drei ganzen Zahlen zusammengesetzt ist. Dieses Beispiel sollte also umgewandelt werden in

#!scala
Array(
     Array(A(1,2,3),A(4,5,6),A(7,8,9),
     Array(A(2,3,4),A(5,6,7),A(8,9,0),
)

Eine zwingende Lösung wäre in der Form

#!python
input = """2 3
1 2 3 4 5 6 7 8 9
2 3 4 5 6 7 8 9 0
"""
lines = input.split('\n')
class Aclass:
    def __init__(self,a,b,c):
        pass

print lines[0]
m,n = (int(x) for x in lines[0].split())
array = []
row = []
A = []
for line in lines[1:]:
    for elt in line.split():
        A.append(elt)
        if len(A)== 3:
            row.append(Aclass(A[0],A[1],A[2]))
            A = []
    array.append(row)
    row = []

from pprint import pprint
pprint(array)

Eine funktionelle Lösung, die ich mir ausgedacht habe, ist

#!scala
def splitList[A](l:List[A],i:Int):List[List[A]] = {
  if (l.isEmpty) return List[List[A]]()
  val (head,tail) = l.splitAt(i)
  return head :: splitList(tail,i)
}

def readMatrix(src:Iterator[String]):Array[Array[TrafficLight]] = {
  val Array(x,y) = src.next.split(" +").map(_.trim.toInt)
  val mat = src.take(x).toList.map(_.split(" ").
          map(_.trim.toInt)).
          map(a => splitList(a.toList,3).
                map(b => TrafficLight(b(0),b(1),b(2))
                 ).toArray
                ).toArray
    return mat
  }

Aber ich glaube wirklich, dass es der falsche Weg ist, denn:

1. Ich verwende die funktionale List Struktur für jede Zeile und konvertiert sie dann in ein Array. Der gesamte Code scheint viel weniger effizient zu sein
2. Ich finde sie weniger elegant und viel weniger lesbar als die Python-Lösung. Es ist schwieriger zu erkennen, welche der Map-Funktionen auf was wirkt, da sie alle die gleiche Semantik verwenden.

Was ist der richtige funktionale Weg, um das zu tun?