Перебрать два списка (разной длины) в обратном порядке в Scala

Простой способ:

 List('a','b','c').reverse zip List(1,2).reverse

Однако перевернуть список можно O(n), если вы беспокоитесь об эффективности.

Согласно scaladoc List, использование reverseIterator может быть более эффективным. Таким образом, вы не создаете новый список, как с reverse, а просматриваете его, продолжая итерацию. Это было бы:

val it = list1.reverseIterator zip list2.reverseIterator  //returns an Iterator you can force
it.toList // List((c,2), (b,1))

Используя параллельные коллекции,

def parRevZip (a: List[String], b: List[Int]) = {

  val max = Math.max(a.size, b.size)
  val n = Math.abs(a.size - b.size)

  if (a.size > b.size)
    (max to n+1 by -1).par.map { i => (a(i-1), b(i-n-1)) }
  else
    (max to n+1 by -1).par.map { i => (a(i-n-1), b(i-1)) }
}

Принимая во внимание разные значения индекса для списков, возможно, разного размера, этот подход выбирает и объединяет одинаковое количество элементов, начиная с конца каждого списка.

Производительность требует тщательной оценки; для небольших списков простой реверс и сжатие могут оказаться намного проще и эффективнее; наоборот, для больших списков этот параллельный подход может быть интересен.

Уточнение кода

def parRevZip[A,B] (a: List[A], b: List[B]) = {

  val aSize = a.size
  val bSize = b.size

  val max = Math.max(aSize, bSize)
  val n = Math.abs(aSize - bSize)

  if (aSize > bSize)
    (max-1 to n by -1).par.map { i => (a(i), b(i-n)) }
  else
    (max-1 to n by -1).par.map { i => (a(i-n), b(i)) }
}

Использование нерекурсивных коллекций

Удобные неизменяемые коллекции здесь, где вычисление размера равно O(1) (или квазипостоянному) (см. Рекурсивные коллекции в Scala, такие как List ) включают, например, Array. Следовательно,

def parRevZip[A,B] (a: Array[A], b: Array[B])

что не соответствует дальнейшему требованию обработки списков.

Я думаю, вы имеете в виду это:

val a = List(1, 2, 3)
val b = List(8, 9)

val result = a.reverse zip b.reverse

Вот моя попытка решить эту проблему. Исходные списки a и b не дублируются. Операция O(N) связана с List.size:

object test extends App {
  val a = List("a", "b", "c")                     //> a  : List[String] = List(a, b, c)
  val b = List(1, 2)                              //> b  : List[Int] = List(1, 2)
  val aSize = a.size                              //> aSize  : Int = 3
  val bSize = b.size                              //> bSize  : Int = 2

  // find which is smaller and which is bigger list
  val (smaller, bigger) = if (aSize < bSize) (a, b) else (b, a)
                                                  //> smaller  : List[Any] = List(1, 2)
                                                  //| bigger  : List[Any] = List(a, b, c)

  // skip the extra entries from head of bigger list
  val truncated = bigger.drop(Math.abs(aSize - bSize))
                                                  //> truncated  : List[Any] = List(b, c)

  val result = if (a == smaller)
    smaller.zip(truncated).reverse
  else
    truncated.zip(smaller).reverse                //> result  : List[(Any, Any)] = List((c,2), (b,1))

}