Reordering Sequences in Scala - scala

Question

I have a sequence with the following data order:
A, B, C, D, E, F, G, H, I, J, K, L, M, N, O
and I need to sort it so that it looks like this:
A, F, K, B, G, L, C, H, M, D, I, N, E, J, O
which is basically grouping the first sequence in to three groups, stacking them on the top of each other and reading down the first column and then the next etc to form the new sequence.
ABCDE
FGHIJ
KLMNO
I have a conceptual understanding that this might involve mapping and zipping. I could implement this in short order in imperative style, but I want it as a functional style.
Any help/pointers gratefully received, thanks!

Answer 1

Here you go:
val xs = Seq('A, 'B, 'C, 'D, 'E, 'F, 'G, 'H, 'I, 'J, 'K, 'L, 'M, 'N, 'O)
val grouped = xs.grouped(5).toList
// List(List('A, 'B, 'C, 'D, 'E), List('F, 'G, 'H, 'I, 'J), List('K, 'L, 'M, 'N, 'O))
val result = grouped.transpose.flatten
// List('A, 'F, 'K, 'B, 'G, 'L, 'C, 'H, 'M, 'D, 'I, 'N, 'E, 'J, 'O)

Answer 2

Any solution should start out with grouped, which chops the collection into pieces:
scala> val g = "ABCDEFGHIJKLMN".grouped(5)
g: Iterator[String] = non-empty iterator // Will return "ABCDE", then "FGHIJ", then "KLMN"
We then turn everything into a list so we can take tails easily:
scala> val l = g.map(_.toList).toList
List[List[Char]] = List(List(A, B, C, D, E), List(F, G, H, I, J),
List(K, L, M, N))
Now we gather these by taking successive tails, stopping when there's nothing left:
scala> val i = Iterator.iterate(l)(_.map(_ drop 1).filter(_.nonEmpty)).takeWhile(_.nonEmpty)
i: Iterator[List[List[Char]]] = non-empty iterator
// List(List(A, B, C, D, E), List(F, G, H, I, J), List(K, L, M, N))
// List(List(B, C, D, E), List(G, H, I, J), List(L, M, N))
// List(List(C, D, E), List(H, I, J), List(M, N))
// List(List(D, E), List(I, J), List(N))
// List(List(E), List(J))
That looks big, but since we're using a List, the shorter lists share memory with the longer ones, so it's not a horrible O(n^2) explosion in size. But we really just want the heads, and we already filtered out everything empty, so we can just do it:
scala> val h = i.map(_.map(_.head))
h: Iterator[List[Char]] = non-empty iterator
// List(A, F, K)
// List(B, G, L)
// List(C, H, M)
// List(D, I, N)
// List(E, J)
and finally convert from an iterator to a strict collection and flatten:
scala> val ans = h.toList.flatten
ans: List[Char] = List(A, F, K, B, G, L, C, H, M, D, I, N, E, J)
(add mkString if you want a String back).
Note that the temporary variables are for clarity of explanation only. If you feel like writing it all on one line, you could. (It'd be a rather long line.)
(Also note that if you e.g. print out iterators, they get consumed.)
Here it is in one big swoop:
("ABCDEFGHIJKLMN".grouped(5).map(_.toList).toList match {
case l => Iterator.iterate(l)(_.map(_ drop 1).filter(_.nonEmpty)).takeWhile(_.nonEmpty)
}).map(_.map(_.head)).toList.flatten
but that's pretty opaque, so spreading things out to give room for comments is a good idea.