F(0) = 0
F(1) = 1
F(n) = F(n-1) + F(n-2), si n > 1

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, ...

P(0) = 0
P(1) = 1
P(2) = 1
P(3) = 2
P(4) = 4
P(n) = P(n-1) + P(n-2) + P(n-3) + P(n-4) + P(n-5), si n > 4

0, 1, 1, 2, 4, 8, 16, 31, 61, 120, 236, 464, 912, 1793, 3525, ...

pentanacci :: [Integer]

λ> take 15 pentanacci
[0,1,1,2,4,8,16,31,61,120,236,464,912,1793,3525]
λ> (pentanacci !! 70000) `mod` (10^30)
231437922897686901289110700696
λ> length (show (pentanacci !! 70000))
20550

import Data.List (zipWith5)

-- 1ª definición (por recursión)
-- =============================

pentanacci1 :: [Integer]
pentanacci1 = [pent n | n <- [0..]]

pent :: Integer -> Integer
pent 0 = 0
pent 1 = 1
pent 2 = 1
pent 3 = 2
pent 4 = 4
pent n = pent (n-1) + pent (n-2) + pent (n-3) + pent (n-4) + pent (n-5)

-- 2ª definición (programación dinámica con zipWith5)
-- ==================================================

pentanacci2 :: [Integer]
pentanacci2 =
    0 : 1 : 1 : 2 : 4 : zipWith5 f (r 0) (r 1) (r 2) (r 3) (r 4)
    where f a b c d e = a+b+c+d+e
          r n         = drop n pentanacci2

-- Comparación de eficiencia de la 1ª y 2ª
-- =======================================

--    λ> pentanacci1 !! 23
--    1546352
--    (2.50 secs, 277,503,776 bytes)
--    λ> pentanacci2 !! 23
--    1546352
--    (0.00 secs, 0 bytes)

-- 3ª definición (con acumuladores)
-- ================================

pentanacci3 :: [Integer]
pentanacci3 = p (0, 1, 1, 2, 4)
    where p (a, b, c, d, e) = a : p (b, c, d, e, a + b + c + d + e)

-- Comparación de eficiencia de la 2ª y 3ª
-- =======================================

--    λ> length (show (pentanacci2 !! 60000))
--    17614
--    (2.41 secs, 942,975,184 bytes)
--    λ> length (show (pentanacci3 !! 60000))
--    17614
--    (1.93 secs, 948,297,024 bytes)