Question

我很难解决如何实现部分递归功能（至少在我看来）。

对于任何给定的p和任意maxsteps = 100，计算L：

Answer 1

您可以将maxsteps传递给递归函数，并在每个步骤上减去1，直到达到0，这是结束条件：

public double L(double p, int maxSteps)
{
    if (maxSteps == 0)
    {
        return 1 / (p + 1);
    }
    return 1 / (p + L(p, maxSteps - 1));
}

Answer 2

感谢您需要递归函数，但我想我会提供一个非递归的替代方法，以防万一它被首选：

private static double CalculateL(double p, int maxsteps)
{
    double val = 1 / (p + 1);
    for (int i = 1; i <= maxsteps; ++i)
    {
        val = 1 / (p + val);
    }
    return val;
}

根据其他答案，我不确定maxsteps的百分百。如果答案不正确，那么您可能想要< maxsteps在我有<= maxsteps的地方。

此外，如果您希望得到非常精确的结果，请阅读Is floating point math broken?。

Answer 3

我为您提供了递归方法的代码：

class Program
{
    static void Main(string[] args)
    {
        double recursiveL = CalculateL(100, 100);
        double notRecursiveLWrong = NotRecursiveCalculateLWrong(100, 100);
        double notRecursiveLRight = NotRecursiveCalculateLRight(100, 100);
    }

    private static double CalculateL(double p, int maxSteps)
    {
        if (maxSteps == 0)
        {
            return (1 / (p + 1));
        }
        else
        {
            return (1 / (p + CalculateL(p, maxSteps - 1)));
        }
    }

    private static double NotRecursiveCalculateLWrong(double p, int maxSteps)
    {
        double result = 0;
        for (int i = 0; i < maxSteps; i++)
        {
            result = (1 / (p + result));
        }
        return result;
    }


    private static double NotRecursiveCalculateLRight(double p, int maxSteps)
    {
        double result = 1 / (p + 1);
        for (int i = 0; i < maxSteps; i++)
        {
            result = (1 / (p + result));
        }
        return result;
    }
}

在进行此操作时，我一直在考虑这样一个事实，即不需要递归，现在我知道我并不是唯一的递归。

我添加了我的非递归方法。

编辑：

如果尝试我的代码，您会发现每个方法都返回相同的值WATCHOUT，这是浮点精度较低的原因。

正确的方法是@John的答案中所述的NotRecursiveCalculateLRight。

在C＃中实现部分递归函数

3 个答案: