Can't quite get Project Euler problem #2 figured out [closed] - c++

Question

Closed. This question is not reproducible or was caused by typos. It is not currently accepting answers.
This question was caused by a typo or a problem that can no longer be reproduced. While similar questions may be on-topic here, this one was resolved in a way less likely to help future readers.
Closed 1 year ago.
Improve this question
I'm trying to learn the basics of C++ by going through some Project Euler problems. I've made it to...#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, ...
Find the sum of all the even-valued
terms in the sequence which do not
exceed four million.
My logic:
0, 1, 1, 2, 3, 5
x y z
x y z
x y z
x y z
The above is looping through this:
x + y = z
x = y
y = z
My code:
#include <iostream.h>
using namespace std;
int main()
{
int x = 0;
int y = 1;
int z;
int sum;
for(y = 1; y <= 4000000; y++) {
z = x + y;
x = y;
y = z;
if(y % 2 == 0) {
sum += y;
}
}
cout << sum;
cin.get();
}
That outputs 4613788
The correct answer, though, is 4613732.

Answer 1

You're using y as both the loop variable, and the second term in the sequence.
What you mean to do is:
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 <= 4000000);
Noting that you should probably initialize sum as well.

Answer 2

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.

Answer 3

You're not initialising sum to zero.

Answer 4

The for loop code block should be something like
while(y <= 4000000) {
z = x + y;
x = y;
y = z;
if(y % 2 == 0) {
sum += y;
}
}
Basically, you should not increment y.

Answer 5

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, b, (a+b), (a+2b), (2a+3b), (3a+5b), (5a+8b), (8a+13b), (13a+21b), (21a+34b), (34a+55b)....
In above series a is 1 and b 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:
b, (2a+3b), (8a+13b), (34a+55b), (144a+233b)...
If we observe pattern in this series, coefficient_of_next_a is 4*(coefficient_of_current_a)+(coefficient_of_previous_a).
And coefficient_of_next_b is (coefficient_of_current_a)+(coefficient_of_current_b)+(coefficient_of_next_a).
Python 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)) <= 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))
Output is:
8
34
144
610
2584
10946
46368
196418
832040
3524578
Sum: 4613732

Answer 6

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:
double Fib(double N)
{
double Fn = (pow(PHI, N) - pow(PSI, N)) / sqrt(5);
return floor(Fn);
}
where PHI = 1.6180339... and PSI = -0.61803398... (check out wiki 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):
double nFib(double F)
{
double nFib = log((double)F * sqrt(5) + 0.5) / log(PHI);
return floor(nFib);
}
Third, you will use the B&Q identity #25 (more info here) for calculating the sum of the even Fibonacci numbers:
double bqIdentity25(double N)
{
return (Fib(3*floor(N) + 2) - 1) / 2;
}
Finally, compute the sum:
double limit = 4000000;
double nearestIndex = nFib(limit);
double sum = bqIdentity25(nearestIndex / 3);
we only need every third element to compute the sum of the even Fibonacci numbers.
Hope this helps!
Will

Answer 7

//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+prev);
cout << list.at(list.size()-1)<<'\n';
}while(last<4000000);
unsigned long int sum=0;
for(int a=0;a<list.size();a++)
{
if(list.at(a)%2==0)
{
sum+=list.at(a);
}
}
cout <<'\n'<<sum<<'\n';
return 0;
}

Answer 8

perl -e '$a,$b=(0,1);while($a<4*10**6){$a%2==0and$sum+=$a;$a+=$b;$c=$a;$a=$b;$b=$c;}print"$sum\n"'
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 $c=$a;$a=$b;$b=$c;). $a and $b are declared upfront because we know the fibo starts with them($a,$b=(0,1)). From there we get a a while loop rolling as long as our variable that we use in our boologic is less than 4mil(while($a<4*10**6)). Every iteration we check for even numbers($a%2==0) with modulus and plus-equals these to our $sum variable($sum+=$a). 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?

Answer 9

It shows each Fibonacci Sequence Number and selects even ones,
at the end gives sum of the even ones.
#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 + 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();
}

Answer 10

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.
#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++)
{
int initial2;
initial2=initial1+initial;
if(initial2%2==0)
{cout<<initial2<<"\t";}
initial=initial1;
initial1=initial2;
}
}
void main()
{
fibonacci a;
a.series();
getch();
}

Answer 11

Here is how to do it in Swift:
/** 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 < 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 + n1
let n3 = n2 + n1
let n4 = n3 + n2
if (n4 < 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 < 4_000_000)
println("The answer is \(runningTotal).\n")
}
eulerProblem_02()
The program outputs:
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.

Answer 12

A solution using Kotlin, I'm using this problems to practice my math and learn this new language for me:
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
}
}
}
It's a little verbose because, I'm adding testability, if you want to see the Unit Test, here it is:
https://github.com/moxi/project-euler-solutions/blob/master/code/src/test/kotlin/org/rcgonzalezf/onetoten/Problem2Test.kt

Answer 13

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

Answer 14

In javascript you can solve it like this:
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 < 4000000) {
valToPush = fabonacci[fabonacci.length - 2] + fabonacci[fabonacci.length - 1]
i++;
if ((valToPush % 2) == 0) {
evenFab.push(valToPush);
}
if (valToPush > 4000000 || i > 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));`

Answer 15

a = 0
b = 1
c =0
sum = 0
d = 0
for s in range(4000000):
while(d<4000000):
d = a+b
if d%2 == 0:
sum += d
print(d)
a = b
b = d
print
print
print("the sum is:"+str(sum))

Answer 16

You have to use long data type instead of int .
My Solution :
#include<bits/stdc++.h>
using namespace std;
int main()
{
long long sum = 0;
long f = 1, s = 2;
for(f, s; f<4000000 || s < 4000000; )
{
//cout << f << " " << s << endl;
if( f%2 == 0 )
sum += f;
if( s%2 == 0)
sum+= s;
f += s;
s+=f;
}
cout << sum <<endl;
return 0;
}