Scala раздел отсортирован список элементов на основе расстояния

Question

Я новичок в Scala и функциональном программировании.У меня есть задача, которую я хочу разделить список Scala на список подсписков, где расстояние между каждым элементом в любом подсписке меньше 2. Я нашел код где-то в сети, может сделать это, но я не понимаю, какэтот код работает внутри, кто-то может дать подробное объяснение?

    def partition(input: List[Int], prev: Int, 
    splits: List[List[Int]]): List[List[Int]] = {
  input match {
    case Nil => splits
    case h :: t if h-prev < 2 => partition(t, h, (h :: splits.head) :: splits.tail)
    case h :: t => partition(t, h, List(h) :: splits)
  }
}


val input = List(1,2,3,5,6,7,10)
partition(input,input.head,List(List.empty[Int]))

Результат выглядит следующим образом:

List [List [Int]] = List (List (10), List (7, 6, 5), Список (3, 2, 1))

, который является желаемым результатом.

Answer 1

def partition(input  :List[Int]       // a sorted List of Ints
             ,prev   :Int             // Int previously added to the accumulator
             ,splits :List[List[Int]] // accumulator of Ints for eventual output
             ): List[List[Int]] = {   // the output (same type as accumulator)

  input match {         // what does input look like?
    case Nil => splits  // input is empty, return the accumulator

    // input has a head and tail, head is close to previous Int
    case h :: t if h-prev < 2 =>
      // start again with new input (current tail), new previous (current head),
      // and the current head inserted into accumulator
      partition(t, h, (h :: splits.head) :: splits.tail)

    // input has a head and tail, head is not close to previous Int
    case h :: t => 
      // start again with new input (current tail), new previous (current head),
      // and the current head is the start of a new sub-list in the accumulator
      partition(t, h, List(h) :: splits)
  }
}

Answer 2

В этом коде предполагается, что исходный список упорядочен от наименьшего к наибольшему

, он работает рекурсивно, где при каждом вызове вход является тем, что все еще остается в списке, prev содержит предыдущий заголовок списка (входной.head) и split разделяет до сих пор

в каждом вызове, мы смотрим на вход (то, что осталось от списка)

• , если он пуст (Nil), мы завершилиsplit и мы возвращаем разделение
• два других параметра сопоставления используют сопоставление с образцом для разбиения ввода на заголовок и хвост (h и t соответственно)
• во втором сопоставлении используется условие защиты (if), чтобы проверить, принадлежит ли заголовок ввода в последнем разбиении, если он делает это перед разделением
• , последний вариант - создать новое разбиение