Average for adjacent items in scala

Question

I have a seq

val seq = Seq(1, 9, 5, 4, 3, 5, 5, 5, 8, 2)

I want to get an average for each adjacent (left and right) numbers, meaning in the above example to have the following calculations: [(1+9)/2, (1+9+5)/3, (9+5+4)/3, (5+4+3)/3, (4+3+5)/3, (3+5+5)/3, (5+5+5)/3, (5+5+8)/3, (5+8+2)/3, (8+2)/2]

The other examples are:

Seq() shouldBe Seq()
Seq(3) shouldBe Seq(3.0d)
Seq(1, 4) shouldBe Seq(2.5d, 2.5d)
Seq(1, 9, 5, 4, 3, 5, 5, 5, 8, 2) shouldBe Seq(5.0, 5.0, 6.0, 4.0, 4.0, 13.0 / 3, 5.0, 6.0, 5.0, 5.0)

I was able to get: numbers.sliding(2, 1).map(nums => nums.sum.toDouble / nums.length).toSeq. But it doesn't consider the previous value.
I tried to do it with foldLeft - it is also cumbersome.

Is there an easy way to do this? What am I missing?

Answer 1

Being honest, this is the kind of problems that I believe are easier to solve using a simple (albeit a bit long) tail-recursive algorithm.

def adjacentAverage(data: List[Int]): List[Double] = {
  @annotation.tailrec
  def loop(remaining: List[Int], acc: List[Double], previous: Int): List[Double] =
    remaining match {
      case x :: y :: xs =>
        loop(
          remaining = y :: xs,
          ((previous + x + y).toDouble / 3.0d) :: acc,
          previous = x
        )
  
      case x :: Nil =>
        (((previous + x).toDouble / 2.0d) :: acc).reverse
    }

  data match {
    case x :: y :: xs => loop(remaining = y :: xs, acc = ((x + y).toDouble / 2.0d) :: Nil, previous = x)
    case x :: Nil     => x.toDouble :: Nil
    case Nil          => Nil
  }
}

You can see it running here.

Answer 2

My cumbersome solution through foldLeft (no rocket science)

    def adjacentAverage(numbers: Seq[Int]): Seq[Double] = numbers.foldLeft(("x", Seq[Double](), 0)) {(acc, num) => acc._1 match {
      case "x" => if (numbers.isEmpty) ("x", Seq(), acc._3 + 1) else if (numbers.length == 1) ("x", Seq(num.toDouble), acc._3 + 1) else (num.toString, acc._2 :+ ((num.toDouble + numbers(acc._3 + 1).toDouble) / 2.0), acc._3 + 1)
      case _ => (num.toString, try {acc._2 :+ ((acc._1.toDouble + num.toDouble + numbers(acc._3 + 1).toDouble) / 3.0)} catch {case e: IndexOutOfBoundsException => acc._2 :+ ((acc._1.toDouble + num.toDouble) / 2.0) }, acc._3 + 1)
    }}._2

Answer 3

What if you want a sliding window of a different size, like maybe 4 or 7 or ...? The challenge is getting the build-up, (1), (1,2), (1,2,3), (1,2,3,4), ... and the tail-off, ..., (6,7,8,9), (7,8,9), (8,9), (9).

def windowAvg(input: Seq[Int], windowSize: Int): Seq[Double] =
  if (input.isEmpty || windowSize < 1) Seq()
  else {
    val windows = input.sliding(windowSize).toSeq
    val buildUp = windows.head.inits.toSeq.tail.reverse.tail
    val tailOff = windows.last.tails.toSeq.tail.init
    (buildUp ++ windows ++ tailOff).map(x => x.sum.toDouble / x.length)
  }

If you really need to trim off the opening and ending single-number entries in the result, then I'll leave that as an exercise for the reader.