Question

我想到这个An = 8（An-1）*（An-1）/ An-2而a1 = 1，a0 = 1 使用以下代码，n = 2 a2 = 0.0000，这是完全错误的另一方面（An的和）S（n）= 1 + 1 + 0.0000（假数）理论上是正确的

#include <stdio.h>
float rec(int n);
float sum(int n);
main()
{
    int n;
    printf("\nInput N of term an: ");
    scanf("%d",&n);

printf("\n\na%d=%f",n,rec(n));
printf("\n\nS(%d)=%f",n,sum(n));

}

float rec(int n)
{
    int i;
    float a[1000]={1,1};//a0=1,a1=1
    if(n<0)
        printf("\nNegative values of N are invalid");
    else if(n==0)
        return a[0];
    else if(n==1)
        return a[1];
    else if(n>1)
        for(i=2;i<=n;i++)
            a[i]=((8 * a[i-1]*a[i-1]) - 1)/a[i-2];
    return a[i];
}

float sum(int n)
{
    int i;
    float sum=0;
    for(i=0;i<=n;i++)
        sum+=rec(i);
    return sum;
}

Answer 1

float a[1000]={1,1};

将a[0] = 1和a[1] = 1以及其他元素初始化为0 。

现在，您将从函数返回a[i]。对于n=2，它会返回a[3]，当然是0，但不是您期望的a[2]。

现在只需将返回值更改为a[i-1]即可。

float rec(int n)
{
    int i;
    ...
    ...

    return a[i-1];
}

Answer 2

for(i=2;i<=n;i++)
        a[i]=((8 * a[i-1]*a[i-1]) - 1)/a[i-2];
return a[i];

问题在这里，你永远都会得到零!!!为什么呢？

说我输入3 ,,现在说i = 3，好吧a [3]得到计算，现在你的程序回到for循环，现在i = 4，它现在不适合检查i＆lt; = n ，现在我是4岁，

你正在返回[i]，实际上是[myanswer + 1] ...

通过返回[i-1]

来修复它

Answer 3

此时rec：

return a[i];

i是3而不是2，因为它在循环的最后一次测试之前递增。因此，您将在最后一组之后返回数组的元素。如果通过返回a[i-1]来解决此问题，请小心，因为如果i从未初始化或为0，则会导致问题。您应该稍微清理rec方法以处理这些极端情况，但直接的问题是i是3而不是2。

Answer 4

替换

return a[i];

与

return a[n];

（另外，你不需要0和1的额外分支。）

Answer 5

Schlemiel the Painter's algorithm的一个很好的例子：）

大约一半的计算是不必要地多次完成的
数组是不必要的，并且无法使用递归方法

此外，它定义为保持1000个值，但函数增长得如此之快，以至于在10个左右之后它将超过浮动容量。

更简化的版本here：

#include <stdio.h>

float A (int n, float * sum)
{
    if (n <= 0) { *sum = 0; return 0; }
    if (n == 1) { *sum = 1; return 1; }
    if (n == 2) { *sum = 2; return 1; }
    float anm2 = A(n-2, sum); // store A(n-2). sum will be overwritten by A(n-1)
    float anm1 = A(n-1, sum); // store A(n-1) once to avoid calling A twice, and get preceding sum
    float an = ((8 * anm1*anm1) - 1)/anm2;
    *sum += an;
printf ("index %d : term %g sum %g\n", n, an, *sum);
    return an;
}

int main (void)
{
    int n;
    float sum;
    printf("\nInput N of term an: ");
    scanf("%d",&n); printf("\n");

    printf("\na%d=%f",n,A(n, &sum));
    printf("\n\nS(%d)=%f",n,sum);
}

此外，递归是不必要的，并导致低效和混乱的代码。

查看更直接的解决方案here：

#include <stdio.h>

typedef struct {
    float term;
    float sum;
} A; // current term and sum of series A

void compute_A (int n, A * res)
{
    int i;
    float anm1, // a[n-1]
          anm2; // a[n-2]

    // special case for n<=1
    if (n == 1)
    {
        res->sum = res->term = 1;
        return;
    }
    if (n <= 0)
    {
        res->sum = res->term = 0;
        return;
    }

    // initial terms
    anm2 = anm1 = 1;

    // initial sum
    float sum = anm1+anm2;

    // compute the remaining n-2 terms and cumulate the sum
    for (i = 2 ; i <= n ; i++)
    {
        // curent term
        float an = ((8 * anm1*anm1) - 1)/anm2;

        // cumulate sum
        sum += an;

        // shift computation window
        anm2 = anm1;
        anm1 = an;
printf ("index %d : term %g sum %g\n", i, an, sum);
    }

    // report result
    res->sum  = sum;
    res->term = anm1;
}

int main (void)
{
    int n;
    A res;
    printf("\nInput N of term an: ");
    scanf("%d",&n); printf("\n");

    compute_A (n, &res);

    printf("\na%d=%f",n,res.term);
    printf("\n\nS(%d)=%f",n,res.sum);
}

Answer 6

float rec(int n){
    static max_i = 1;
    static float a[1000]={1,1};//a0=1,a1=1
    int i;
    if(n<0){
        printf("\nNegative values of N are invalid");
        return NAN;//<math.h>
    }
    if(n >= 1000){
        printf("\nMore than 1000 are invalid");
        return NAN;
    }
    if(n<2)
        return a[n];
    if(n>max_i){
        for(i=max_i+1;i<=n;++i)
            a[i]=((8 * a[i-1]*a[i-1]) - 1)/a[i-2];
        max_i = n;
        return a[n];
    }
    return a[n];
}

自定义递归函数|根本不返回任何值在C.

6 个答案: