如何在Haskell中解决此数学函数？

Question

How can I solve this math Funcion with Haskell? Can anyone help me?

Rekursive math Function

myFunc n m = myFuncRec n m if m <= n then 1
                       else myFuncRec n(m - 1):[]

Do I need two recursion? because for this problem in java needs two or three loops.

Answer 1

I would normally give a hint instead of a full solution, but since this question is mostly about syntax, and the translation is very close, almost literal, I'll just give it to you in full.

p n m 
    | m <= n    = 1
    | otherwise = sum [ p n (m - i) | i <- [1..n] ]

The bars distinguishing the different cases by conditions are called guards , and the bracket structure in the last line is known as a list comprehension .

Answer 2

luqui's answer gives the natural, straightforward translation of the math definition into Haskell code. As a specification, it is perfect: beautiful and obviously correct. As a teaching tool, it is perfect: easy to read, easy to understand, and no advanced features used. But as an algorithm it is a little unfortunate: the existence of many recursive calls that each do recomputation makes it very slow for large inputs. So in this answer I will give a taste of what a solution not intended for simplicity might look like.

One observation of interest is that P(2,-) is the Fibonacci sequence, which has a well-known, beautiful, and efficient definition as an infinite list in Haskell:

fibs = 1:1:zipWith (+) fibs (tail fibs)

This recursively-defined list uses itself as a memoization table. One might ask whether there is a clean generalization of this trick to P with other first arguments than 2; the answer is yes. The basic idea is this: since transpose is the natural extension of zip to arbitrary arity, and sum is the natural extension of (+) to arbitrary arity, we can write:

import Data.List

transposeWith :: ([a] -> b) -> [[a]] -> [b]
transposeWith f xss = map f (transpose xss)

genFib :: Int -> [Integer]
genFib n = result where
    result = replicate n 1 ++ transposeWith sum [drop i result | i <- [0..n-1]]

This gives us an efficient way to compute P(n,-) for any n , using a list for memoization. If we wish to memoize even the n dimension, we can write:

p :: [[Integer]]
p = map genFib [1..]

How much faster is it? On my machine, computing P(100, 130) takes luqui's solution more than ten minutes (and appears to roughly double in time each time you add one to m ), while my solution responds in under a second for even such a large input as P(100, 10000) .