Question

我正在使用Dev-C ++。它没有显示任何代码错误，但无法工作。

当我尝试像10或20

这样的小数字时，它会起作用

我正在解决这个问题：

Fibonacci序列中的每个新术语都是通过添加   前两个任期。从1和2开始，前10个术语将   是：

1,2,3,5,8,13,21,34,55,89，......

考虑Fibonacci序列中的值，而不是   超过四百万，找到偶数值的总和。

    #include<stdio.h>
#include<stdlib.h>
int main()
{
const int N=100;
int a=1,b=2,i,t[N],S=0,c,j;
t[0]=1;
t[1]=2;
for(i=2;i<N;i++){
t[i]=t[i-2]+t[i-1];
if(t[i]>4000000)
{
for(j=1;j<=i-1;j++){
                    c=t[j]%2;
                    if(c==0){
                             S=S+t[j];
                            }
                    else    {
                             continue;
                    }}
break;
}
}
printf("%d\n",S);
system("pause");
}

Answer 1

您无法定义可变大小的数组（T [N]）。如果你制作N const，问题应该解决。

const int N = 3999998;
int T(N);

另外，main应该有一个返回类型。改为“int main（）”？

Answer 2

你不需要一个数组来存储所有这些数字，你可以在序列中存储最后两个术语，因为这就是计算下一个术语所需的全部内容。

尝试在堆栈上分配那么多空间是一件麻烦事，因为堆栈是一个相对有限的资源。

事实上，在我尝试运行它时，在Linux机器上输入gcc的确切代码会给我一个分段违规，正是出于这个原因。

最重要的是，你的代码不获得了有价值的条款，它正在获得每个条款，而你获得前四百万个值，而不是指定的值低于四百万。

你所追求的代码看起来像这样：

#include <stdio.h>

int main (void) {
    // Accumulator and terms (acc is zero because first two terms are odd).

    int acc = 0, t1 = 1, t2 = 1, t3;

    // Continue until next term is 4mil or more.

    while ((t3 = t1 + t2) < 4000000) {
        // printf ("DEBUG: %d %d %d %s\n", t1, t2, t3,
        //     ((t3 % 2) == 0) ? "<<" : "");

        // Accumulate only even terms.

        if ((t3 % 2) == 0) acc += t3;

        // Cycle through terms.

        t1 = t2; t2 = t3;
    }

    // Print the accumulated value.

    printf ("%d\n", acc);

    return 0;
}

输出：

如果通过取消注释调试语句来测试该程序，则会看到：

DEBUG: 1 1 2 <<
DEBUG: 1 2 3 
DEBUG: 2 3 5 
DEBUG: 3 5 8 <<
DEBUG: 5 8 13 
DEBUG: 8 13 21 
DEBUG: 13 21 34 <<
DEBUG: 21 34 55 
DEBUG: 34 55 89 
DEBUG: 55 89 144 <<
DEBUG: 89 144 233 
DEBUG: 144 233 377 
DEBUG: 233 377 610 <<
DEBUG: 377 610 987 
DEBUG: 610 987 1597 
DEBUG: 987 1597 2584 <<
DEBUG: 1597 2584 4181 
DEBUG: 2584 4181 6765 
DEBUG: 4181 6765 10946 <<
DEBUG: 6765 10946 17711 
DEBUG: 10946 17711 28657 
DEBUG: 17711 28657 46368 <<
DEBUG: 28657 46368 75025 
DEBUG: 46368 75025 121393 
DEBUG: 75025 121393 196418 <<
DEBUG: 121393 196418 317811 
DEBUG: 196418 317811 514229 
DEBUG: 317811 514229 832040 <<
DEBUG: 514229 832040 1346269 
DEBUG: 832040 1346269 2178309 
DEBUG: 1346269 2178309 3524578 <<
4613732

并且，如果你在这些DEBUG行的末尾加上所有偶数，你确实得到了给定的值。

Answer 3

我注意到的两件事是main没有返回类型（try int main()）而N用作数组大小但不是常量。

Answer 4

这是一个非常常见的编程错误，称为“堆栈溢出”。事实上，它已经命名了一个非常受欢迎的问答网站，“Stack Overflow”，也许你已经听过它了，这是很常见的吗？

（自从我加入“Stack Overflow”以来，我一直在等待能够给出这个答案!!!）

简单的程序无法编译

4 个答案: