Haskell - 在列表中累计的总和

Question

I need to create or know if there is a function in Haskell that allows you to add items from a list. So, for example:

cumulativeAmount :: [Integer] -> [Integer]

cumulativeAmount [1,2,5,8,8,0,4,2] = [1,3,8,16,24,24,28,30]

cumulativeAmount [1,4,7,0,5] = [1, 1+4, 1+4+7, 1+4+7+0, 1+4+7+0+5] = [1,5,12,12,17]

I tried to use the map and scanl function, but I didn't get what I wanted, because I added all the elements.

Answer 1

This is exactly the purpose of scanl1 :: (a -> a -> a) -> [a] -> [a] :

Prelude> scanl1 (+) [1,2,5,8,8,0,4,2]
[1,3,8,16,24,24,28,30]

scanl1 takes as input a function f :: a -> a -> a (here (+) ), and a list of a s. It constructs a list where the first item is the first item of the list. This is the first value of the accumulator . Then for every value, the accumulator is updated by calling f with the accumulator and the next value of the list, this item is then yielded.

So in case of scal1 (+) [1,2,5] the first item we emit is 1 , we also set the accumulator to 1 . The next item is 2 , so we call (+) 1 2 (which is 3 ) and this is the result and the new accumulator, next we call (+) ((+) 1 2) 5 (which is 8 ), etc.

But I think it is better, as an exercise to use recursion. Like said before we use an accumulator. We can implement this by introducing an extra function where the accumulator is a function we pass through the recursive calls (and update). So in that case it looks like:

cumulativeAmount :: [Integer] -> [Integer]
cumulativeAmount [] = ...
cumulativeAmount (x:xs) = go x xs
    where go x xs = ...

so here the first argument of go ( x ) is the accumulator. I leave it as an exercise to implement it with recursion.

Answer 2

What about using an accumulator:

cumulativeAmount :: (Num a) => [a] -> [a]
cumulativeAmount xs = go xs 0
    where go [] acc = []
          go (x:xs) acc = (acc+x) : go xs (acc+x)

Which works as follows:

*Main> cumulativeAmount [1,2,5,8,8,0,4,2]
[1,3,8,16,24,24,28,30]

The above code keeps a state variable acc to accumulate sums whenever a new number is encountered, and adds the new sum to the resulting list.

Now a good exercise would be to replace the above code with higher order functions.

Answer 3

在我的头顶，您可以通过列表理解来解决这个问题，如下所示：

cumulativeAmount xs = [ sum $ take x xs | x <- [1..length xs] ]