Code Review Stack Exchange is a question and answer site for peer programmer code reviews. It's 100% free, no registration required.

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top
    def toPairs[A](xs : Seq[A]) : Seq[Tuple2[A,A]] = {
      @tailrec
      def accumulator(as : Seq[A], accum: Seq[Tuple2[A,A]]) : Seq[Tuple2[A,A]] = as match {
        case Nil => accum
        case x :: tail => tail match {
          case Nil => accum
          case _ =>  accumulator(as.tail, accum :+ (x,tail.head))
        }
      }

      accumulator(xs, Seq.empty[Tuple2[A,A]])
    }

I use this code for the following use case: for a Seq[A] i.e. List(1,2,3) I want a Seq of Tuples of A i.e. List((1,2)(2,3)). Is this the most optimal, idiomatic way in Scala, what could be improved?

For the record: the order of the elements is important and is expected to be congruent with the example in the preceding paragraph.

share|improve this question
up vote 2 down vote accepted

I find the way you go back and forth between as and x a bit annoying. You should be able to collapse the nested match into one match that covers three cases.

The :+ operator, which appends an element to a sequence, should be avoided at all costs, because it involves traversing to the end of the sequence. That makes your algorithm O(n2), when it should ideally be O(n).

Anyway, the solution can be much simpler than that.

def toPairs[A](xs: Seq[A]): Seq[(A,A)] = xs.zip(xs.tail)
share|improve this answer
    
Awesome, esp. the short syntax of Tuple typeargs: (A,A) vs Tuple2[A,A]! – Quant Nov 13 '15 at 18:30

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.