blocks|key|326910|text|您将y用作循环变量和序列中的第二项。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|326911|你想要做的是：|326912|int+x+=+0;
int+y+=+1;
int+z;
int+sum+=+0;

do+{
++++z+=+x+%2B+y;
++++x+=+y;
++++y+=+z;
++++if+(y+%25+2+==+0)+sum+%2B=+y;
}+while+(y+<=+4000000);|code-block|syntax|javascript|326913|请注意，您可能还应该初始化sum。|326914|entityMap^0|2|1|0|0|0|D|3|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|U|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

You're using <code>y</code> as both the loop variable, and the second term in the sequence.

What you mean to do is:

<pre><code>int x = 0;
int y = 1;
int z;
int sum = 0;

do {
 z = x + y;
 x = y;
 y = z;
 if (y % 2 == 0) sum += y;
} while (y &lt;= 4000000);
</code></pre>

Noting that you should probably initialize <code>sum</code> as well.

blocks|key|322208|text|为了提高速度，请注意序列是Even-Odd-Odd+(重复)、Even-Odd-Odd+(重复)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|322209|你不需要测试每个数字来知道它是偶数还是奇数。每三个数字加一次即可。|322210|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

For a speed improvement, note that the sequence is Even-Odd-Odd (repeats), Even-Odd-Odd.

You don't need to test each number to know if it is even or odd. Just add every third number.

blocks|key|324673|text|您没有将sum初始化为零。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|324674|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You're not initialising sum to zero.

blocks|key|3289953|text|for循环代码块应该类似于|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3289954|while(y+<=+4000000)+{
++++z+=+x+%2B+y;
++++x+=+y;
++++y+=+z;
++++if(y+%25+2+==+0)+{
++++++++sum+%2B=+y;
++++}
}|code-block|syntax|javascript|3289955|基本上，您不应该递增y。|3289956|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

The for loop code block should be something like

<pre><code>while(y &lt;= 4000000) {
 z = x + y;
 x = y;
 y = z;
 if(y % 2 == 0) {
 sum += y;
 }
}
</code></pre>

Basically, you should not increment y.

blocks|key|3076908|text|这是我们如何在最小数量的循环中做到的。如果我们用前两个数来写斐波那契级数，它是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3076909|a，b，(a%2Bb)，(a%2B2b)，(2a%2B3b)，(3a%2B5b)，(5a%2B8b)，(8a%2B13b)，(13a%2B21b)，(21a%2B34b)，(34a%2B55b)....|offset|length|style|CODE|3076910|在上面的系列中，a是1，b是2，突出显示的数字是偶数。在斐波那契级数中，每三个数就是偶数，数列是偶-奇-奇-偶-。所以如果我们写偶数是这个级数，它是：|3076911|b,+(2a%2B3b),+(8a%2B13b),+(34a%2B55b),+(144a%2B233b)...|3076912|如果我们观察本系列中的模式，coefficient_of_next_a就是4*(coefficient_of_current_a)%2B(coefficient_of_previous_a)。coefficient_of_next_b是(coefficient_of_current_a)%2B(coefficient_of_current_b)%2B(coefficient_of_next_a)。|3076913|Python代码：|3076914|#+Start+sum+with+first+event+number
sum+=+2

#+Values+of+first+two+Fibonacci+numbers
a+=+1
b+=+2

#+Previous+coefficient+of+a
prev_coef_a+=+0

#+Current+coefficient+of+a+and+b
coef_a+=+2
coef_b+=+3

while+((coef_a*a)%2B(coef_b*b))+<=+4000000:
++++print(((coef_a*a)%2B(coef_b*b)))
++++sum+%2B=+((coef_a*a)%2B(coef_b*b))

++++#+Coefficient+of+a+for+next+number
++++next_coef_a+=+(coef_a*4)%2Bprev_coef_a
++++prev_coef_a+=+coef_a
++++#+Coefficient+of+b+for+next+number
++++coef_b+=+coef_a%2Bcoef_b%2Bnext_coef_a
++++coef_a+=+next_coef_a

print('Sum:+{}'.format(sum))|code-block|syntax|javascript|3076915|输出为：|3076916|8
34
144
610
2584
10946
46368
196418
832040
3524578
Sum:+4613732|3076917|entityMap^0|0|2|1|H|7|15|8|1Y|9|0|8|1|C|1|0|0|1B|0|E|L|11|1K|2M|L|38|25|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@$D|12|E|13|F|G]|$D|14|E|15|F|G]|$D|16|E|17|F|G]|$D|18|E|19|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1A|8|@$D|1B|E|1C|F|G]|$D|1D|E|1E|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|1F|8|@$D|1G|E|1H|F|G]]|9|@]|A|$]]|$1|L|3|M|5|6|7|1I|8|@$D|1J|E|1K|F|G]|$D|1L|E|1M|F|G]|$D|1N|E|1O|F|G]|$D|1P|E|1Q|F|G]]|9|@]|A|$]]|$1|N|3|O|5|6|7|1R|8|@]|9|@]|A|$]]|$1|P|3|Q|5|R|7|1S|8|@]|9|@]|A|$S|T]]|$1|U|3|V|5|6|7|1T|8|@]|9|@]|A|$]]|$1|W|3|X|5|R|7|1U|8|@]|9|@]|A|$S|T]]|$1|Y|3|-4|5|6|7|1V|8|@]|9|@]|A|$]]]|Z|$]]

Here is how we can do in minimum number of loops. If we write Fibonacci series in terms of first two numbers, it is:

a, <code>b</code>, (a+b), (a+2b), <code>(2a+3b)</code>, (3a+5b), (5a+8b), <code>(8a+13b)</code>, (13a+21b), (21a+34b), <code>(34a+55b)</code>....

In above series <code>a</code> is 1 and <code>b</code> is 2, highlighted numbers are even numbers. In Fibonacci series every third number is even number, sequence is EVEN-ODD-ODD-EVEN-. So if we write even number is this series, it is:

<code>b, (2a+3b), (8a+13b), (34a+55b), (144a+233b)...</code>

If we observe pattern in this series, <code>coefficient_of_next_a</code> is <code>4*(coefficient_of_current_a)+(coefficient_of_previous_a)</code>.
And <code>coefficient_of_next_b</code> is <code>(coefficient_of_current_a)+(coefficient_of_current_b)+(coefficient_of_next_a)</code>.

Python Code:

<pre><code># Start sum with first event number
sum = 2

# Values of first two Fibonacci numbers
a = 1
b = 2

# Previous coefficient of a
prev_coef_a = 0

# Current coefficient of a and b
coef_a = 2
coef_b = 3

while ((coef_a*a)+(coef_b*b)) &lt;= 4000000:
 print(((coef_a*a)+(coef_b*b)))
 sum += ((coef_a*a)+(coef_b*b))

 # Coefficient of a for next number
 next_coef_a = (coef_a*4)+prev_coef_a
 prev_coef_a = coef_a
 # Coefficient of b for next number
 coef_b = coef_a+coef_b+next_coef_a
 coef_a = next_coef_a

print('Sum: {}'.format(sum))
</code></pre>

Output is:

<pre><code>8
34
144
610
2584
10946
46368
196418
832040
3524578
Sum: 4613732
</code></pre>

blocks|key|324729|text|这里有一种在O(log(N))-time中解决这个问题的方法，而O(N)实现速度较慢(O(log(N))来自于需要使用pow()函数)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|324730|首先，您需要能够在O(log(N))时间内计算第N个Fibonacci数：|324731|double+Fib(double+N)
{
++++double+Fn+=+(pow(PHI,+N)+-+pow(PSI,+N))+/+sqrt(5);

++++return+floor(Fn);
}|code-block|syntax|javascript|324732|其中PHI+=+1.6180339...PSI+=+-0.61803398...(有关更多信息，请查看wiki+)|offset|length|324733|其次，您将需要计算最接近目标限制的索引(在问题2的情况下，这将是4,000,000)：|324734|double+nFib(double+F)
{
++++double+nFib+=+log((double)F+*+sqrt(5)+%2B+0.5)+/+log(PHI);

++++return+floor(nFib);
}|324735|第三，您将使用B&Q+identity+#25+(更多信息here)来计算偶数斐波那契数的和：|324736|double+bqIdentity25(double+N)
{
++++return+(Fib(3*floor(N)+%2B+2)+-+1)+/+2;
}|324737|最后，计算和：|324738|double+limit+=+4000000;
double+nearestIndex+=+nFib(limit);
double+sum+=+bqIdentity25(nearestIndex+/+3);|324739|我们只需要每三个元素来计算偶数斐波那契数的和。|324740|希望这能有所帮助！将要|324741|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Fibonacci_number|1|http://www.maths.surrey.ac.uk/hosted-sites/R.Knott/Fibonacci/fibFormulae.html^0|0|0|0|1F|4|0|0|0|0|T|4|1|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1D|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1E|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1F|8|@]|9|@$K|1G|L|1H|1|1I]]|A|$]]|$1|M|3|N|5|6|7|1J|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|1K|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|1L|8|@]|9|@$K|1M|L|1N|1|1O]]|A|$]]|$1|S|3|T|5|F|7|1P|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|W|3|X|5|F|7|1R|8|@]|9|@]|A|$G|H]]|$1|Y|3|Z|5|6|7|1S|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|1T|8|@]|9|@]|A|$]]|$1|12|3|-4|5|6|7|1U|8|@]|9|@]|A|$]]]|13|$14|$5|15|16|17|A|$18|19]]|1A|$5|15|16|17|A|$18|1B]]]]

Here is a way to solve this problem in O(log(N))-time vs. the slower O(N) implementation (O(log(N)) comes from the need to use the pow() function).

First, you need to be able to compute the N-th Fibonacci number in O(log(N)) time:

<pre><code>double Fib(double N)
{
 double Fn = (pow(PHI, N) - pow(PSI, N)) / sqrt(5);

 return floor(Fn);
}
</code></pre>

where PHI = 1.6180339... and PSI = -0.61803398... (check out <a href="http://en.wikipedia.org/wiki/Fibonacci_number" rel="nofollow">wiki</a> for more info)

Second, you will need to calculate the closest index to your target limit (in problem 2's case this would be 4,000,000):

<pre><code>double nFib(double F)
{
 double nFib = log((double)F * sqrt(5) + 0.5) / log(PHI);

 return floor(nFib);
}
</code></pre>

Third, you will use the B&amp;Q identity #25 (more info <a href="http://www.maths.surrey.ac.uk/hosted-sites/R.Knott/Fibonacci/fibFormulae.html" rel="nofollow">here</a>) for calculating the sum of the even Fibonacci numbers:

<pre><code>double bqIdentity25(double N)
{
 return (Fib(3*floor(N) + 2) - 1) / 2;
}
</code></pre>

Finally, compute the sum:

<pre><code>double limit = 4000000;
double nearestIndex = nFib(limit);
double sum = bqIdentity25(nearestIndex / 3);
</code></pre>

we only need every third element to compute the sum of the even Fibonacci numbers.

Hope this helps!
Will

blocks|key|324743|text|++++//fibonacci+sequence
++++#include+<iostream>
++++#include+<vector>

++++using+namespace+std;

++++int+main()
++++{
++++++++vector<unsigned+long+int>+list;
++++++++list.clear();
++++++++list.push_back(1);
++++++++list.push_back(2);
++++++++cout<<"1\n2\n";
++++++++unsigned+long+int+last;
++++++++unsigned+long+int+prev;
++++++++do{
++++++++++++last=list.at(list.size()-1);
++++++++++++prev=list.at(list.size()-2);
++++++++++++list.push_back(last%2Bprev);
++++++++++++cout+<<+list.at(list.size()-1)<<'\n';
++++++++}while(last<4000000);
++++++++unsigned+long+int+sum=0;
++++++++for(int+a=0;a<list.size();a%2B%2B)
++++++++{
++++++++++++if(list.at(a)%252==0)
++++++++++++{
++++++++++++++++sum%2B=list.at(a);
++++++++++++}
++++++++}
++++++++cout+<<'\n'<<sum<<'\n';
++++++++return+0;
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|324744|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code> //fibonacci sequence
 #include &lt;iostream&gt;
 #include &lt;vector&gt;

 using namespace std;

 int main()
 {
 vector&lt;unsigned long int&gt; list;
 list.clear();
 list.push_back(1);
 list.push_back(2);
 cout&lt;&lt;"1\n2\n";
 unsigned long int last;
 unsigned long int prev;
 do{
 last=list.at(list.size()-1);
 prev=list.at(list.size()-2);
 list.push_back(last+prev);
 cout &lt;&lt; list.at(list.size()-1)&lt;&lt;'\n';
 }while(last&lt;4000000);
 unsigned long int sum=0;
 for(int a=0;a&lt;list.size();a++)
 {
 if(list.at(a)%2==0)
 {
 sum+=list.at(a);
 }
 }
 cout &lt;&lt;'\n'&lt;&lt;sum&lt;&lt;'\n';
 return 0;
 }
</code></pre>

blocks|key|327012|text|它显示每个Fibonacci序列号并选择偶数，最后给出偶数的和。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|327013|+#include+<stdio.h>
+#include+<math.h>
+#include+<time.h>
++++//project+euler
++++//problem#+2
int+main()
{
++++long+int+a+=+0;
++++long+int+b+=+1;
++++long+int+sum+=+0;
++++long+int+f+=+0;
++++long+int+t+=+1;
++++long+int+d+=+1;

++while+(f+<=+4000000){
++f+=+a+%2B+b;
++printf("+++%252d.+number+is+%257d",d,f);
++d%2B%2B;
++a+=+b;
++b+=+f;
++++if+(f+%25+2+==+0){
++++++++sum+%2B=+f;
++++++++printf("\t\t%252d.+target+is+%257d",t,f);
++++++++t%2B%2B;
++++}
++printf("\n\n");
++printf("--------------------------------------------------------------------------------");
++}
printf("\n\n\t\t\t\t\tSum+of+targets+is+%25d\n\n\n",+sum);
printf("--------------------------------------------------------------------------------\n");
printf("Press+any+key+to+continue...\n");
getchar();
}|code-block|syntax|javascript|327014|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

It shows each Fibonacci Sequence Number and selects even ones,
at the end gives sum of the even ones.

<pre><code> #include &lt;stdio.h&gt;
 #include &lt;math.h&gt;
 #include &lt;time.h&gt;
 //project euler
 //problem# 2
int main()
{
 long int a = 0;
 long int b = 1;
 long int sum = 0;
 long int f = 0;
 long int t = 1;
 long int d = 1;

 while (f &lt;= 4000000){
 f = a + b;
 printf(" %2d. number is %7d",d,f);
 d++;
 a = b;
 b = f;
 if (f % 2 == 0){
 sum += f;
 printf("\t\t%2d. target is %7d",t,f);
 t++;
 }
 printf("\n\n");
 printf("--------------------------------------------------------------------------------");
 }
printf("\n\n\t\t\t\t\tSum of targets is %d\n\n\n", sum);
printf("--------------------------------------------------------------------------------\n");
printf("Press any key to continue...\n");
getchar();
}
</code></pre>

blocks|key|322343|text|perl+-e+'$a,$b=(0,1);while($a<4*10**6){$a%252==0and$sum%2B=$a;$a%2B=$b;$c=$a;$a=$b;$b=$c;}print"$sum\n"'|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|322344|我最近开始研究Perl的神秘艺术...(爱死它了！)|unstyled|322345|但我会解释的..。我们需要三个变量，我们将移动我们需要的两个值，以便找到序列中的下一步(它将被分配给第三个变量，就像这个$c=$a;$a=$b;$b=$c;)。$a和$b是预先声明的，因为我们知道fibo是以它们开头的($a,$b=(0,1))。从那里我们得到一个while循环，只要我们在布尔运算中使用的变量小于4mil(while($a<4*10**6))。每一次迭代，我们检查具有模数的偶数($a%252==0)，并将它们加等于我们的$sum变量($sum%2B=$a)。在混洗变量之后(如前所述)，它只是“打印并完成”。|offset|length|style|CODE|322346|我知道您想用C/C%2B%2B+(perl是用C编写的)来做这件事，但我只是在研究Perl中的euler问题，并认为这可能会提供一些见解。|322347|如果它根本没有帮助(除了不是正确的语言)，请告诉我如何改进我的答案，以便我可以在未来提供更好的答案。最重要的是，祝你有愉快的一天！|322348|有人要打高尔夫球吗？|322349|entityMap^0|0|0|1O|I|28|2|2B|2|32|B|4I|H|5J|7|69|8|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|V|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|W|8|@$I|X|J|Y|K|L]|$I|Z|J|10|K|L]|$I|11|J|12|K|L]|$I|13|J|14|K|L]|$I|15|J|16|K|L]|$I|17|J|18|K|L]|$I|19|J|1A|K|L]]|9|@]|A|$]]|$1|M|3|N|5|F|7|1B|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|1D|8|@]|9|@]|A|$]]|$1|S|3|-4|5|F|7|1E|8|@]|9|@]|A|$]]]|T|$]]

<pre><code>perl -e '$a,$b=(0,1);while($a&lt;4*10**6){$a%2==0and$sum+=$a;$a+=$b;$c=$a;$a=$b;$b=$c;}print"$sum\n"'
</code></pre>

I recently began studying the arcane art of Perl...(LOVE IT!)

but I will explain it... we need three variables that we will move our 2 values that we need in order to find the next step in the sequence(which will be assigned to the 3rd var like this <code>$c=$a;$a=$b;$b=$c;</code>). <code>$a</code> and <code>$b</code> are declared upfront because we know the fibo starts with them(<code>$a,$b=(0,1)</code>). From there we get a a while loop rolling as long as our variable that we use in our boologic is less than 4mil(<code>while($a&lt;4*10**6)</code>). Every iteration we check for even numbers(<code>$a%2==0</code>) with modulus and plus-equals these to our $sum variable(<code>$sum+=$a</code>). After shuffling the variables(as mentioned earlier) it's just 'print and done'.

I know you wanted to do this in C/C++ (perl is written in C) but I was just messing around with the euler problems in Perl and thought this might provide insight.

if it doesn't help at all(aside from not being the right language) please tell me how to improve my answer so I can provide better answers in the future. Most importantly, have a nice day!

Golf anyone?

blocks|key|327082|text|尝试向problem.Following程序添加一些帮助，可以显示用户输入的给定长度的级数的所有偶数斐波那契级数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|327083|+++++++++#include<iostream.h>
+++++++++#include<conio.h>
++++++++++class+fibonacci
++++++++++{
+++++++++++++++int+input;
++++++++++++++++++++++++public:
++++++++++++++++++++++++++++++++++void+series();
++++++++++};
+++++++++++++++void+fibonacci::series()
++++++++++++++++++++{
+++++++++++++++++++++++++++cout<<"enter+the+value";
+++++++++++++++++++++++++++cin>>input;
+++++++++++++++++++++++++++int+initial=0;
+++++++++++++++++++++++++++int+initial1=1;
+++++++++++++++++++++for(int+loop=0;loop<input;loop%2B%2B)
++++++++++++++++++++++++++{+
+++++++++++++++++++++++++++++int+initial2;
+++++++++++++++++++++++++++++initial2=initial1%2Binitial;
+++++++++++++++++++++++++++++if(initial2%252==0)
+++++++++++++++++++++++++++++{cout<<initial2<<"\t";}
+++++++++++++++++++++++++++++initial=initial1;
+++++++++++++++++++++++++++++initial1=initial2;
+++++++++++++++++++++++++++++}
+++++++++++++++++++++++}
++++++++++++++++++++++void+main()
++++++++++++++++++++++++++++++++++{
++++++++++++++++++++++++++++++++++++++fibonacci+a;
++++++++++++++++++++++++++++++++++++++a.series();
++++++++++++++++++++++++++++++++++++++getch();
+++++++++++++++++++++++++++++++++++}|code-block|syntax|javascript|327084|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Trying to add little help to the problem.Following program shows all even fibonacci series numbers for a given length of series which is input by user.

<pre><code> #include&lt;iostream.h&gt;
 #include&lt;conio.h&gt;
 class fibonacci
 {
 int input;
 public:
 void series();
 };
 void fibonacci::series()
 {
 cout&lt;&lt;"enter the value";
 cin&gt;&gt;input;
 int initial=0;
 int initial1=1;
 for(int loop=0;loop&lt;input;loop++)
 { 
 int initial2;
 initial2=initial1+initial;
 if(initial2%2==0)
 {cout&lt;&lt;initial2&lt;&lt;"\t";}
 initial=initial1;
 initial1=initial2;
 }
 }
 void main()
 {
 fibonacci a;
 a.series();
 getch();
 }
</code></pre>

blocks|key|3290257|text|以下是如何在Swift中执行此操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3290258|/**+Calculate+the+next+even+fibonacci+number+within+a+limit.

Methodology:
1)+Fibonacci+numbers+are+either+odd+(o)+or+even+(e)+as+follows:
o,+e,+o,+o,+e,++o,+o,+e,+o,+o,+e,+...+because+of+the+arithmetic
rule:
Odd+%2B+Odd+=+Even
Even+%2B+Even+=+Even
Odd+%2B+Even+=+Odd

2)+By+do+two+rounds+of+fibonacci,+we+can+get+from+one+"e"+to+the
next+"e".++We+don't+need+to+bother+checking+its+even.

3)+To+avoid+re-computing+past+results,+we+ask+for+the+past+
running+total+to+be+supplied,+and+the+past+pair+of+fibonacci+
numbers+before+doing+our+two+rounds+of+fibonacci

4)+We+assume+the+passed+in+pair+of+fibonacci+numbers+don't+exceed
are+supplied+limit,+and+on+the+next+even+fibonacci+we+can+just+test
for+exceeding+the+limit+there+only.

5)+Fibonacci+numbers+grow+very+fast+(nearly+doubling+each+time).++Since
the+next+even+is+found+after+two+iterations,+it+means+we+have+exponential
growth+for+the+next+fibonacci+number.++For+limit+L,+we'll+find+the+sum
after+O(log(L))+time.

@param++runningTotal++++Total+of+even+fibonacci+numbers+seen+so+far
@param++upperLimit++++++Limit+number+not+to+exceed+the+next+even+fibonacci
@param++n0++++++++++++++First+of+an+adjacent+pair+of+fibonacci+numbers+with
++++++++++++++++++++++++n0+<+upperLimit
@param++n1++++++++++++++Next+fibonacci+number+after+n1+with+n1+<+upperLimit

@returns+(updatedTotal,n3,n4)+where+updatedTotal+is+the+supplied+runningTotal
+++++++++plus+the+next+even+fibonacci+number+not+exceeding+the+supplied
+++++++++upperLimit,+n3+and+n4+are+the+next+pair+of+fibonacci+numbers+to+be
+++++++++supplied+for+the+next+call+to+this+method
*/
func+sumNextEvenFibonacci(runningTotal:Int,+upperLimit:Int,+n0:Int,+n1:Int)+->+(Int,+Int,+Int)
{
++++let+n2+=+n0+%2B+n1
++++let+n3+=+n2+%2B+n1
++++let+n4+=+n3+%2B+n2

++++if+(n4+<+upperLimit)
++++{
++++++++return+(runningTotal+%2B+n4,+n3,+n4)
++++}
++++else
++++{
++++++++return+(runningTotal,+n3,+n4)
++++}
}

func+eulerProblem_02()
{
++++println("Problem+2\n\nEach+new+term+in+the+Fibonacci+sequence+is+generated+by+adding+the+previous+two+terms.+By+starting+with+1+and+2,+the+first+10+terms+will+be:\n+1,+2,+3,+5,+8,+13,+21,+34,+55,+89,+...+\n\nBy+considering+the+terms+in+the+Fibonacci+sequence+whose+values+do+not+exceed+four+million,+find+the+sum+of+the+even-valued+terms.\n")
++++var+n0+=+1,+n1+=+2,+n2+=+0,+runningTotal+=+2
++++do
++++{
++++++++(runningTotal,+n0,+n1)+=+sumNextEvenFibonacci(runningTotal,+4_000_000,+n0,+n1)
++++}+while+(n1+<+4_000_000)
++++println("The+answer+is+\(runningTotal).\n")
}

eulerProblem_02()|code-block|syntax|javascript|3290259|程序输出：|3290260|Problem+2

Each+new+term+in+the+Fibonacci+sequence+is+generated+by+adding+the+previous+two+terms.++++++By+starting+with+1+and+2,+the+first+10+terms+will+be:
1,+2,+3,+5,+8,+13,+21,+34,+55,+89,+...+

By+considering+the+terms+in+the+Fibonacci+sequence+whose+values+do+not+exceed+four+million,+find+the+sum+of+the+even-valued+terms.

The+answer+is+4613732.|3290261|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here is how to do it in Swift:

<pre><code>/** Calculate the next even fibonacci number within a limit.

Methodology:
1) Fibonacci numbers are either odd (o) or even (e) as follows:
o, e, o, o, e, o, o, e, o, o, e, ... because of the arithmetic
rule:
Odd + Odd = Even
Even + Even = Even
Odd + Even = Odd

2) By do two rounds of fibonacci, we can get from one "e" to the
next "e". We don't need to bother checking its even.

3) To avoid re-computing past results, we ask for the past 
running total to be supplied, and the past pair of fibonacci 
numbers before doing our two rounds of fibonacci

4) We assume the passed in pair of fibonacci numbers don't exceed
are supplied limit, and on the next even fibonacci we can just test
for exceeding the limit there only.

5) Fibonacci numbers grow very fast (nearly doubling each time). Since
the next even is found after two iterations, it means we have exponential
growth for the next fibonacci number. For limit L, we'll find the sum
after O(log(L)) time.

@param runningTotal Total of even fibonacci numbers seen so far
@param upperLimit Limit number not to exceed the next even fibonacci
@param n0 First of an adjacent pair of fibonacci numbers with
 n0 &lt; upperLimit
@param n1 Next fibonacci number after n1 with n1 &lt; upperLimit

@returns (updatedTotal,n3,n4) where updatedTotal is the supplied runningTotal
 plus the next even fibonacci number not exceeding the supplied
 upperLimit, n3 and n4 are the next pair of fibonacci numbers to be
 supplied for the next call to this method
*/
func sumNextEvenFibonacci(runningTotal:Int, upperLimit:Int, n0:Int, n1:Int) -&gt; (Int, Int, Int)
{
 let n2 = n0 + n1
 let n3 = n2 + n1
 let n4 = n3 + n2

 if (n4 &lt; upperLimit)
 {
 return (runningTotal + n4, n3, n4)
 }
 else
 {
 return (runningTotal, n3, n4)
 }
}

func eulerProblem_02()
{
 println("Problem 2\n\nEach new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be:\n 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ... \n\nBy considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.\n")
 var n0 = 1, n1 = 2, n2 = 0, runningTotal = 2
 do
 {
 (runningTotal, n0, n1) = sumNextEvenFibonacci(runningTotal, 4_000_000, n0, n1)
 } while (n1 &lt; 4_000_000)
 println("The answer is \(runningTotal).\n")
}

eulerProblem_02()
</code></pre>

The program outputs:

<pre><code>Problem 2

Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be:
1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ... 

By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.

The answer is 4613732.
</code></pre>

blocks|key|322403|text|一个使用Kotlin的解决方案，我正在使用这个问题来练习我的数学，并为我学习这门新语言：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|322404|import+java.math.BigInteger

/**
+*
+*+https://projecteuler.net/problem=2
+*
+*+Each+new+term+in+the+Fibonacci+sequence+is+generated+by+adding+the+previous+two+terms.+By+starting+with+1+and+2,+the+first+10+terms+will+be:
+*
+*+1,+2,+3,+5,+8,+13,+21,+34,+55,+89,+...
+*+By+considering+the+terms+in+the+Fibonacci+sequence+whose+values+do+not+exceed+four+million,+find+the+sum+of+the+even-valued+terms.
+*
+*/
class+Problem2+{

++++var+maxValue:+Int+=+4000000

++++//+Looking+for+this+fibonacci+value
++++var+fibonacci+=+32
++++var+fibonacciValues+=+hashMapOf<Int,+BigInteger>(0+to+BigInteger.ONE,+1+to+BigInteger.ONE);

++++fun+solution():+BigInteger+{
++++++++var+solution:+BigInteger+=+BigInteger.ZERO
++++++++calculateFibonacci(fibonacci)

++++++++fibonacciValues.filter+{
++++++++++++it.value+<+BigInteger.valueOf(maxValue.toLong())+&&
++++++++++++++++++++it.value.mod(BigInteger.ONE.add(BigInteger.ONE)).equals(BigInteger.ZERO)
++++++++}.forEach+{
++++++++++++//println("Key:+${it.key}+and+${it.value}+and+mv+$maxValue")
++++++++++++solution+=+solution.add(it.value)
++++++++}

++++++++return+solution
++++}

++++private+fun+calculateFibonacci(n:+Int):+BigInteger?+{
++++++++if+(+fibonacciValues.contains(n))+{
++++++++++++return+fibonacciValues.get(n)
++++++++}+else+{
++++++++++++val+f+=+calculateFibonacci(n+-+2)!!.add(calculateFibonacci(n+-+1))

++++++++++++fibonacciValues.put(n,+f)
++++++++++++return+f
++++++++}
++++}

}|code-block|syntax|javascript|322405|它有点冗长，因为，我添加了可测试性，如果你想看单元测试，它是：|322406|https://github.com/moxi/project-euler-solutions/blob/master/code/src/test/kotlin/org/rcgonzalezf/onetoten/Problem2Test.kt|offset|length|322407|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|0|3D|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|V|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|W|8|@]|9|@$K|X|L|Y|1|Z]]|A|$]]|$1|M|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|J]]]]

A solution using Kotlin, I'm using this problems to practice my math and learn this new language for me:

<pre><code>import java.math.BigInteger

/**
 *
 * https://projecteuler.net/problem=2
 *
 * Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be:
 *
 * 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...
 * By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.
 *
 */
class Problem2 {

 var maxValue: Int = 4000000

 // Looking for this fibonacci value
 var fibonacci = 32
 var fibonacciValues = hashMapOf&lt;Int, BigInteger&gt;(0 to BigInteger.ONE, 1 to BigInteger.ONE);

 fun solution(): BigInteger {
 var solution: BigInteger = BigInteger.ZERO
 calculateFibonacci(fibonacci)

 fibonacciValues.filter {
 it.value &lt; BigInteger.valueOf(maxValue.toLong()) &amp;&amp;
 it.value.mod(BigInteger.ONE.add(BigInteger.ONE)).equals(BigInteger.ZERO)
 }.forEach {
 //println("Key: ${it.key} and ${it.value} and mv $maxValue")
 solution = solution.add(it.value)
 }

 return solution
 }

 private fun calculateFibonacci(n: Int): BigInteger? {
 if ( fibonacciValues.contains(n)) {
 return fibonacciValues.get(n)
 } else {
 val f = calculateFibonacci(n - 2)!!.add(calculateFibonacci(n - 1))

 fibonacciValues.put(n, f)
 return f
 }
 }

}
</code></pre>

It's a little verbose because, I'm adding testability, if you want to see the Unit Test, here it is:

<a href="https://github.com/moxi/project-euler-solutions/blob/master/code/src/test/kotlin/org/rcgonzalezf/onetoten/Problem2Test.kt" rel="nofollow">https://github.com/moxi/project-euler-solutions/blob/master/code/src/test/kotlin/org/rcgonzalezf/onetoten/Problem2Test.kt</a>

blocks|key|324832|text|每3个数都是偶数，所以偶数之和是(n个fib数之和)/2。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|324833|但是，一些n-+fib。numbers+=(n%2B2)的项-第二项(1)。|324834|你可以从贝内特的公式中得到(n%2B2)项|324835|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Every 3rd number is even, so sum of even numbers is (sum of n fib numbers)/2.

But, some of n fib. numbers = (n+2)'s term - 2nd term(1).

You can get (n+2)th term from benet's formula

blocks|key|322433|text|在javascript中，你可以这样解决这个问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|322434|function+add(a,+b)+{
++++//+body...
++++return+a+%2B+b;
}
function+fabonacci(limit)+{
++++var+i+=+2;+//parseInt(limit);
++++var+fabonacci+=+[0,+1];
++++var+evenFab+=+[];
++++var+valToPush+=+0;
++++var+result+=+[];
++++while+(valToPush+<+4000000)+{
++++++++valToPush+=+fabonacci[fabonacci.length+-+2]+%2B+fabonacci[fabonacci.length+-+1]
++++++++i%2B%2B;
++++++++if+((valToPush+%25+2)+==+0)+{
++++++++++++evenFab.push(valToPush);
++++++++}
++++++++if+(valToPush+>+4000000+%7C%7C+i+>+limit)+{
++++++++++++break;
++++++++}
++++++++fabonacci.push(valToPush);
++++}
++++result['sequence']+=+fabonacci;
++++result['sumOfEven']+=+evenFab;
++++return+result;
}
var+result+=+fabonacci(10);
console.log("Fabonacci+sequence:"+%2B+result['sequence']);
console.log("Sum+of+Even+Number:"+%2B+(result['sumOfEven']).reduce(add,+0));`|code-block|syntax|javascript|322435|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

In javascript you can solve it like this:

<pre><code>function add(a, b) {
 // body...
 return a + b;
}
function fabonacci(limit) {
 var i = 2; //parseInt(limit);
 var fabonacci = [0, 1];
 var evenFab = [];
 var valToPush = 0;
 var result = [];
 while (valToPush &lt; 4000000) {
 valToPush = fabonacci[fabonacci.length - 2] + fabonacci[fabonacci.length - 1]
 i++;
 if ((valToPush % 2) == 0) {
 evenFab.push(valToPush);
 }
 if (valToPush &gt; 4000000 || i &gt; limit) {
 break;
 }
 fabonacci.push(valToPush);
 }
 result['sequence'] = fabonacci;
 result['sumOfEven'] = evenFab;
 return result;
}
var result = fabonacci(10);
console.log("Fabonacci sequence:" + result['sequence']);
console.log("Sum of Even Number:" + (result['sumOfEven']).reduce(add, 0));`
</code></pre>

blocks|key|324837|text|a+=+0
b+=+1
c+=0
sum+=+0
d+=+0

for+s+in+range(4000000):++++
++++while(d<4000000):++++
++++++++d+=+a%2Bb++++
++++++++if+d%252+==+0:
++++++++sum+%2B=+d+++
++++++++print(d)++++
++++++++a+=+b++++
++++++++b+=+d


print++++
print+
print("the+sum+is:"%2Bstr(sum))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|324838|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>a = 0
b = 1
c =0
sum = 0
d = 0

for s in range(4000000): 
 while(d&lt;4000000): 
 d = a+b 
 if d%2 == 0:
 sum += d 
 print(d) 
 a = b 
 b = d


print 
print 
print("the sum is:"+str(sum))
</code></pre>

blocks|key|327119|text|您必须使用long数据类型而不是int。我的解决方案是：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|327120|#include<bits/stdc%2B%2B.h>
using+namespace+std;

int+main()
{
++++long+long+sum+=+0;
++++long+f+=+1,+s+=+2;
++++for(f,+s;++f<4000000+%7C%7C+s+<+4000000;+)
++++{
++++++++++++//cout+<<+f+<<+"+"+<<+s+<<+endl;
++++++++++++if(+f%252+==+0+)
++++++++++++++++++++sum+%2B=+f;
++++++++++++if(+s%252+==+0)
++++++++++++++++++++sum%2B=+s;

++++++++++++f+%2B=+s;
++++++++++++s%2B=f;
++++}
++++cout+<<+sum+<<endl;
++++return+0;|code-block|syntax|javascript|327121|}|327122|entityMap^0|5|4|G|3|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

You have to use <code>long</code> data type instead of <code>int</code> .
My Solution :
<pre><code>#include&lt;bits/stdc++.h&gt;
using namespace std;

int main()
{
 long long sum = 0;
 long f = 1, s = 2;
 for(f, s; f&lt;4000000 || s &lt; 4000000; )
 {
 //cout &lt;&lt; f &lt;&lt; &quot; &quot; &lt;&lt; s &lt;&lt; endl;
 if( f%2 == 0 )
 sum += f;
 if( s%2 == 0)
 sum+= s;

 f += s;
 s+=f;
 }
 cout &lt;&lt; sum &lt;&lt;endl;
 return 0;
</code></pre>
}

I'm trying to learn the basics of C++ by going through some <a href="http://projecteuler.net" rel="nofollow noreferrer">Project Euler</a> problems. I've made it to...#2.

<blockquote>
 Each new term in the Fibonacci
 sequence is generated by adding the
 previous two terms. By starting with 1
 and 2, the first 10 terms will be:
 
 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...
 
 Find the sum of all the even-valued
 terms in the sequence which do not
 exceed four million.
</blockquote>

My logic:

<pre><code>0, 1, 1, 2, 3, 5
x y z
 x y z
 x y z
 x y z
</code></pre>

The above is looping through this:

<pre><code>x + y = z
x = y
y = z
</code></pre>

My code:

<pre><code>#include &lt;iostream.h&gt;

using namespace std;

int main()
{
 int x = 0;
 int y = 1;
 int z;
 int sum;

 for(y = 1; y &lt;= 4000000; y++) {

 z = x + y;
 x = y;
 y = z;
 if(y % 2 == 0) {
 sum += y;
 }
 }
 cout &lt;&lt; sum;
 cin.get();
}
</code></pre>

That outputs <code>4613788</code>
The correct answer, though, is <code>4613732</code>.

I don't know what's wrong. =/.

Can't quite get Project Euler problem #2 figured out

单元测试

Python

Kotlin

Swift

Perl

我正在尝试通过一些问题来学习C++的基础知识。我已经把它做成了to...#2。斐波那契序列中的每个新项都是通过将前两个项相加而生成的。从1和2开始，前10个术语将是：1，2，3，5，8，13，21，34，55，89，...求序列中所有不超过四百万的偶数项之和。我的逻辑是：0, 1, 1, 2, 3, 5x  y  z   x  y  z      x  y  z         x  y  z上面

问无法完全解决Project Euler问题#2
EN

回答 16

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问无法完全解决Project Euler问题#2EN

回答 16

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问无法完全解决Project Euler问题#2
EN