Question

因此，如果嵌套总和的限制不相互依赖，我可以写下：

sumgrand k q l r = k*q*l*r
kspace = [1..10]
qspace = [1..10]
lspace = [1..10]
rspace = [1..10]
result = sum $ map sumgrand kSpace <*> qSpace <*> lSpace <*> rSpace

这似乎是高效和干净的，但是假设内部总和的极限取决于外部总和中的i（m和的极限取决于k和或r的极限）总和取决于q和）。 最好（高效和干净）的方式是什么？我想出的是以下内容：

applyNsaveIdx y f x = (f x, (y, x))

sumInAtIdx limitsFunction (outerGrand, oindex) =
    map ( applyNsaveIdx oindex outerGrand) innerSpace where
      innerSpace = limitsFunction oindex

sumInner partiallyAppliedOuter limitF = foldl (++) [] $ 
    map (sumInAtIdx limitF) partiallyAppliedOuter

kspace = [0..10]
qspace (0,k)         = [0..k]
lspace ((0,k),q)     = [0..q]
rspace (((0,k),q),l) = [0..l]

kSum     = map (applyNsaveIdx 0 sumgrand) kspace
qkSum    = sumInner kSum   qspace
lqkSum   = sumInner qkSum  lspace
rlqkSum  = sumInner lqkSum rspace
result = sum $ map fst rlqkSum

这最终会慢得多。我想如果我使用递归，我可以更快地完成它，但我不能想到一个干净的递归方式。看起来monad（控制一系列计算）在这里会有所帮助，但我不能很好地理解它们。我的applyNsaveIdx让我想起了我对作家monad的模糊认识，但我不确定如何在这里使用它，或者它是否有用。

感谢您提供任何帮助或建议。

Answer 1

列表理解怎么样？

sum [f x y z | x <- [1..10], y <- [x..2*x], z <- [x+y..x+y+4]]

什么是在haskell中编写嵌套总和的最佳方法

1 个答案: