Ne peut pas tout à fait obtenir de Projet Euler problème #2 compris

Vous utilisez y à la fois comme la variable de boucle, et le deuxième terme de la séquence.

Ce que tu veux faire c'est:

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);

En notant que vous devez probablement initialiser sum.

OriginalL'auteur Matt Joiner

Vous n'êtes pas à l'initialisation de la somme à zéro.

OriginalL'auteur Alex Deem

Ici est de savoir comment nous pouvons le faire en un minimum de nombre de boucles. Si nous écrivons la suite de Fibonacci en termes des deux premiers chiffres, c'est:

un, b, (a+b), (a+2b), (2a+3b), (3a+5b), (5a+8b), (8a+13b), (13a+21b), (21a+34b), (34a+55b)....

Dans la série ci-dessus a est 1 et b est de 2, a mis en évidence les nombres sont des nombres pairs. Dans la suite de Fibonacci chaque troisième numéro est le même numéro de séquence est pair-IMPAIR-IMPAIR-MÊME-. Donc, si nous écrire, même numéro de cette série, c'est:

b, (2a+3b), (8a+13b), (34a+55b), (144a+233b)...

Si nous observons modèle dans cette série, coefficient_of_next_a est 4*(coefficient_of_current_a)+(coefficient_of_previous_a).
Et coefficient_of_next_b est (coefficient_of_current_a)+(coefficient_of_current_b)+(coefficient_of_next_a).

Code Python:

# 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))

De sortie est:

8
34
144
610
2584
10946
46368
196418
832040
3524578
Sum: 4613732

OriginalL'auteur Harshveer Singh

    //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;
    }

OriginalL'auteur andy

Il montre chaque Séquence de Fibonacci Nombre et sélectionne même,
à la fin donne la somme de la même.

 #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();
}

OriginalL'auteur T4RZ4N

Ici est de savoir comment le faire dans 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()

Les résultats du programme:

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.

OriginalL'auteur Faisal Memon

Chaque 3ème numéro est le même, de sorte que la somme d'un nombre pair est (somme de n fib numéros)/2.

Mais, certains de n fib. nombres = (n+2)'terme - 2ème terme(1).

Vous pouvez obtenir (n+2)ème terme de benet la formule de

OriginalL'auteur JagsVG

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))

OriginalL'auteur Sajan Legend