Преобразование нормальной рекурсии в хвостовую рекурсию

в случаях, когда существует простая модификация значения рекурсивного вызова, эта операция может быть перемещена в начало рекурсивной функции. Классический пример этого -хвост рекурсии по модулю минусы, где простая рекурсивная функция в таком виде:

def recur[A](...):List[A] = {
  ...
  x :: recur(...)
}

это не хвост рекурсивной, превращается в

def recur[A]{...): List[A] = {
   def consRecur(..., consA: A): List[A] = {
     consA :: ...
     ...
     consrecur(..., ...)
   }
   ...
   consrecur(...,...)
}

Это такая известная ситуация, что некоторые компиляторы (Я знаю примеры пролога и схемы, но Scalac этого не делает) может обнаруживать простые случаи и выполнять эту оптимизацию автоматически.

проблемы, объединяющие несколько вызовов рекурсивных функций, не имеют такого простого решения. Tmrc optimisatin бесполезен, так как вы просто перемещаете первый рекурсивный вызов в другую позицию без хвоста. Единственный способ достичь хвостового рекурсивного решения-удалить все, кроме одного из рекурсивных вызовов; как это сделать, полностью зависит от контекста, но требуется найти совершенно другой подход к решению проблемы.

как это происходит, в некотором роде ваш пример похож на классическую проблему последовательности Фибоннаси; в этом случае наивное, но элегантное дважды рекурсивное решение может быть заменено тем, которое петляет вперед от 0-го числа.

def fib (n: Long): Long = n match {
  case 0 | 1 => n
  case _ => fib( n - 2) + fib( n - 1 )
}

def fib (n: Long): Long = {
  def loop(current: Long, next: => Long, iteration: Long): Long = {
    if (n == iteration) 
      current
    else
      loop(next, current + next, iteration + 1)
  }
  loop(0, 1, 0)
}

для последовательности Fibonnaci это наиболее эффективный подход (решение на основе потоков - это просто другое выражение этого решения, которое может кэшировать результаты для последующих звонков). Сейчас, вы также можете решить свою проблему, зацикливаясь вперед от c0/r0 (ну, c0 / r2) и вычисляя каждую строку последовательно - разница в том, что вам нужно кэшировать всю предыдущую строку. Так что пока это имеет сходство с приврал, он резко отличается спецификой и также значительно менее эффективен, чем ваше оригинальное, дважды рекурсивное решение.

вот подход для вашего примера треугольника Паскаля, который можете вычислить pascal(30,60) эффективно:

def pascal(column: Long, row: Long):Long = {
  type Point = (Long, Long)
  type Points = List[Point]
  type Triangle = Map[Point,Long]
  def above(p: Point) = (p._1, p._2 - 1)
  def aboveLeft(p: Point) = (p._1 - 1, p._2 - 1)
  def find(ps: Points, t: Triangle): Long = ps match {
    // Found the ultimate goal
    case (p :: Nil) if t contains p => t(p)
    // Found an intermediate point: pop the stack and carry on
    case (p :: rest) if t contains p => find(rest, t)
    // Hit a triangle edge, add it to the triangle
    case ((c, r) :: _) if (c == 0) || (c == r) => find(ps, t + ((c,r) -> 1))
    // Triangle contains (c - 1, r - 1)...
    case (p :: _) if t contains aboveLeft(p) => if (t contains above(p))
        // And it contains (c, r - 1)!  Add to the triangle
        find(ps, t + (p -> (t(aboveLeft(p)) + t(above(p)))))
      else
        // Does not contain(c, r -1).  So find that
        find(above(p) :: ps, t)
    // If we get here, we don't have (c - 1, r - 1).  Find that.
    case (p :: _) => find(aboveLeft(p) :: ps, t)
  }
  require(column >= 0 && row >= 0 && column <= row)
  (column, row) match {
    case (c, r) if (c == 0) || (c == r) => 1
    case p => find(List(p), Map())
  }
}

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

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