En Scala, ¿cómo doblo una Lista y devuelvo los resultados intermedios?

Question

Tengo una lista de días del mes:

val days = List(31, 28, 31, ...) 

necesito para devolver una lista con la suma acumulada de días:

val cumDays = List(31, 59, 90) 

he pensado en utilizar el operador veces :

(0 /: days)(_ + _) 

pero esto solo devolverá el resultado final (365), mientras que necesito la lista de resultados intermedios.

De todos modos, ¿puedo hacerlo elegantemente?

Answer 1

Scala 2.8 tiene los métodos scanLeft y scanRight que hacen exactamente eso.

Para 2.7 se puede definir su propio scanLeft así:

def scanLeft[a,b](xs:Iterable[a])(s:b)(f : (b,a) => b) = 
    xs.foldLeft(List(s))((acc,x) => f(acc(0), x) :: acc).reverse 

y luego usarlo como esto:

scala> scanLeft(List(1,2,3))(0)(_+_) 
res1: List[Int] = List(0, 1, 3, 6) 

Answer 2

se pliegan en una lista en lugar de un número entero. Use par (lista parcial con los valores acumulados, acumulador con la última suma) como estado en el doblez.

Answer 3

Obras en 2.7.7:

def stepSum (sums: List [Int], steps: List [Int]) : List [Int] = steps match { 
    case Nil => sums.reverse.tail             
    case x :: xs => stepSum (sums.head + x :: sums, steps.tail) } 

days 
res10: List[Int] = List(31, 28, 31, 30, 31) 

stepSum (List (0), days) 
res11: List[Int] = List(31, 59, 90, 120, 151) 

Answer 4

doblar la lista en una nueva lista. En cada iteración, agregue un valor que es la suma del encabezado + la siguiente entrada. A continuación, invierta todo el asunto.

scala> val daysInMonths = List(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31) 
daysInMonths: List[Int] = List(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31) 

scala> daysInMonths.foldLeft(Nil: List[Int]) { (acc,next) => 
    | acc.firstOption.map(_+next).getOrElse(next) :: acc  
    | }.reverse            
res1: List[Int] = List(31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365) 

Answer 5

No estoy seguro de por qué todo el mundo parece insistir en el uso de algún tipo de plegado, mientras que, básicamente desea asignar los valores a los valores acumulados ...

val daysInMonths = List(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31) 

val cumulated = daysInMonths.map{var s = 0; d => {s += d; s}} 

//--> List[Int] = List(31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365) 

Answer 6

Simplemente puede realizar que:

daysInMonths.foldLeft((0, List[Int]())) 
        {(acu,i)=>(i+acu._1, i+acu._1 :: acu._2)}._2.reverse 

Answer 7

también puede crear una clase monoid que concatena dos listas al tiempo que añade a la segunda el último valor de la primera. No hay mutables ni pliegues involucrados:

case class CumSum(v: List[Int]) { def +(o: CumSum) = CumSum(v ::: (o.v map (_ + v.last))) } 
defined class CumSum 

scala> List(1,2,3,4,5,6) map {v => CumSum(List(v))} reduce (_ + _) 
res27: CumSum = CumSum(List(1, 3, 6, 10, 15, 21))