Scala: compte la valeur de l'élément de liste par récursion

Question

Comment puis-je compter mes List éléments valeur en utilisant la récursivité et de retourner la somme de tous mes List éléments valeur totale ??

def getTotalValue(list: ListBuffer[Double], val: Double): Double = { 

    list.foreach(x => { 
     val += x 
    }) 
    } 

Answer 1

Cela devrait fonctionner pour une séquence (Liste et ListBuffer)

@tailrec 
def getTotalValue(list: Seq[Double], value: Double): Double = 
    list.headOption match { 
    case Some(v) => getTotalValue(list.tail, value + v) 
    case None => value 
    } 

Par ex pour l'utiliser:

getTotalValue(ListBuffer(1,2,3,4), 0) 
getTotalValue(List(1,2,3,4), 0) 

retournera 10.0

Si vous voulez quelque chose de spécifique à la liste, vous pouvez profiter des inconvénients (: :) opérateur pour correspondre à la tête :: queue au lieu d'utiliser headOption.

(Bien que, je suppose que vous faites cela plus à des fins académiques. Un moyen plus facile de résumer les valeurs serait d'utiliser la somme. Par exemple, Liste (1,2,3,4) .sum)

Answer 2

Essayez ce

import scala.annotation.tailrec 

def getTotal(list: List[Int]) = { 
    @tailrec 
    def get(list: List[Int], total: Int): Int = list match { 
    case head :: tail => get(tail, total + head) 
    case Nil => total 
    } 
    get(list, 0) 
} 

getTotal(List(90,8,98,10,-3)) // should be return 203 
getTotal(List(15,10,20,10)) // should be return 55 

Answer 3

Pour illustrer la récursion plaine (récursive non queue) considèrent

def f(xs: List[Double]): Double = if (xs.isEmpty) 0D else xs.head + f(xs.tail) 

où nous retournons 0.0 whene La liste actuelle est vide, sinon nous additionnons la valeur de tête de la liste actuelle avec l'appel (récursif) à f avec le reste de la liste actuelle. En réduisant de façon monotone la taille de la liste dans chaque appel récursif, on garantit que le cas trivial (la liste vide) est finalement atteint et que tout appel de sécurité de type à cette fonction se termine. De plus, la fonction est bien définie, elle couvre à la fois les cas de listes vides et non vides.