Trovare la somma di termini, anche valutati in sequenza Fibonacci

Question

#!/usr/bin/python2 

""" 
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. 
""" 

odd, even = 0,1 
total = 0 
while True: 
    odd = odd + even #Odd 
    even = odd + even  #Even 
    if even < 4000000: 
     total += even 
    else: 
     break 
print total 

mio algo:

1. Se prendo primi 2 numeri come 0, 1; il numero che trovo per primo nel ciclo while sarà un numero dispari e il primo della serie di Fibonacci.
2. In questo modo calcolo il numero pari e ogni volta aggiungo il valore anche al totale.
3. Se il valore di even è maggiore di 4e6, interrompo dal ciclo infinito.

Ho provato tanto ma la mia risposta è sempre sbagliata. Googling dice che la risposta dovrebbe essere 4613732 ma mi sembra sempre di ottenere 5702886

Grazie per il supporto.

Answer 1

Fondamentalmente quello che stai facendo qui sta aggiungendo ogni secondo elemento della sequenza di Fibonacci, mentre la domanda chiede di sommare solo le anche elementi.

Che cosa si dovrebbe fare, invece è solo iterare su tutti i valori di Fibonacci sotto 4000000 e fare un if value % 2 == 0: total += value. Il % è il resto dell'operatore di divisione, se il resto quando si divide per 2 è uguale a 0, allora il numero è pari.

Es .:

prev, cur = 0, 1 
total = 0 
while True: 
    prev, cur = cur, prev + cur 
    if cur >= 4000000: 
     break 
    if cur % 2 == 0: 
     total += cur 
print(total) 

Answer 2

dovrebbe essere:

odd, even = 1,0 

Inoltre, ogni terzo numer è ancora (anche + dispari + dispari = pari).

Answer 3

Il tuo codice include ogni altro termine, non pari- valore. Per vedere cosa sta succedendo, print even poco prima di total += even - vedrai numeri dispari. Quello che dovete fare, invece è controllare il numero che si sta aggiungendo al totale per uniformità con l'operatore modulo:

total = 0 
x, y = 0, 1 
while y < 4000000: 
    x, y = y, x + y 
    if x % 2: 
     continue 
    total += x 

print total 

Answer 4

Se si aggiunge ogni secondo valore della sequenza di Fibonacci si otterrà il valore di Fibonacci successivo dopo l'ultimo valore aggiunto. Per esempio:

f(0) + f(2) + f(4) = f(5) 
0 + 1 + 3 + 8 = 13 

Ma il codice attualmente non sia il primo valore pari 1.

Answer 5

Altre risposte sono corrette ma nota che solo aggiungere tutti i numeri in una matrice, basta fare myarray = [1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

sum(map(lambda k:k if k%2 else 0, myarray)) 

o

sum([k if k%2 else 0 for k in [1,2,3,4,5]]) 

Answer 6

Ogni 3 ° elemento della sequenza di Fibonacci è ancora.Quindi, si potrebbe avere questo:

prev, cur = 0, 1 
count = 1 
total = 0 
while True: 
    prev, cur = cur, prev + cur 
    count = count + 1 
    if cur >= 4000000: 
     break 
    if count % 3 == 0: 
     total += cur 
print(total) 

o del presente (cambiando il codice il meno possibile):

even, odd = 0,1      # this line was corrected 
total = 0 
while True: 
    secondOdd = even + odd     # this line was changed 
    even = odd + secondOdd  #Even   # this line was changed 
    if even < 4000000: 
     total += even 
     odd = secondOdd + even    # this line was added 
    else: 
     break 
print total 

---

Un altro modo sarebbe (mediante l'uso di un po 'di semplice matematica) a verificare che la somma di a2+a5+a8+a11+...+a(3N+2) (la somma dei valori pari di Fibonacci) sia uguale a (a(3N+4)-1)/2. Quindi, se puoi calcolare direttamente quel numero, non è necessario calcolare tutti i numeri di Fibonacci precedenti.

Answer 7

def fibonacci_iter(limit): 
    a, b = 0, 1 
    while a < limit: 
     yield a 
     a, b = b, a + b 

print sum(a for a in fibonacci_iter(4e6) if not (a & 1)) 

Answer 8

non so se la tua domanda ha già una risposta o hai trovato una soluzione, ma ecco cosa stai facendo male. Il problema ti chiede di trovare termini con valore pari, il che significa che dovrai trovare ogni valore nella sequenza di Fibonacci che può essere divisa per 2 senza resto. Il problema non ti chiede di trovare ogni valore di indicizzazione pari. Ecco la soluzione al vostro problema, allora, che dà una risposta corretta:

i = 1 
total = 0 
t = fib(i) 
while t <= 4000000: 
    t = fib(i) 
    if t % 2 == 0: 
     total += t 
    i += 1 
print total 

Fondamentalmente si ciclo attraverso ogni ogni valore nella sequenza di Fibonacci, controllando se il valore è ancora utilizzando 'mod' (operatore%) per ottenere resto, e poi se è anche tu lo aggiungi alla somma.

Answer 9

Ecco soluzione semplice in C:

#include <stdio.h> 
#include <stdlib.h> 

int main() 
{ 
int i=1,j=1,sum=0; 
    while(i<4000000) 
    { 
    i=i+j; 
    j=i-j; 
    if(i%2==0) 
    sum+=i; 
    } 
printf("Sum is: %d",sum); 

} 

Answer 10

problema nel codice fondamentalmente in relazione con lo stile looping e controllando condizione di temporizzazione. con l'algoritmo di seguito codificato in Java è possibile trovare (secondo + prima) < 4000000 condizione di controllo e che ti porta corretto (che meno di 4000000) risultato, hanno un bel codifica ...

int first = 0, second = 1, pivot = 0; 

    do { 

     if ((second + first) < 4000000) { // this is the point which makes your solution correct 
      pivot = second + first; 
      first = second; 
      second = pivot; 
      System.out.println(pivot); 
     } else { 
      break; 
     } 


    } while (true); 

Answer 11

Ecco come ero in grado di risolvere questo utilizzando javascript nativo.

var sum = 0, 
x = 1, 
y = 2, 
z = 0; 
while (z < 4000000) { 
    if (y%2==0){ 
     sum +=y; 
    } 
    z = x + y; 
    x = y; 
    y = z; 
} console.log(sum); 

Answer 12

Questa è l'implementazione Python e funziona perfettamente.

from math import pow 
sum=0 
summation=0 
first,second=1,2 
summation+=second 
print first,second, 
while sum < 4*math.pow(10,6): 
    sum=first+second 
    first=second 
    second=sum 
    #i+=1 
    if sum > 4*math.pow(10,6): 
     break 
    elif sum%2==0: 
     summation+=sum 
print "The final summation is %d" %(summation) 

Answer 13

L'ho fatto in modo diverso.

def fibLessThan(lim): 

    ################# 
    # Initial Setup # 
    ################# 
    fibArray=[1, 1, 2] 
    i=3 


    ##################### 
    # While loop begins # 
    ##################### 
    while True: 
     tempNum = fibArray[i-2]+fibArray[i-1] 
     if tempNum <= lim: 
      fibArray.append(tempNum) 
      i += 1 
     else: 
      break 

    print fibArray 
    return fibArray 


limit = 4000000 
fibList = fibLessThan(limit) 


############# 
# summation # 
############# 
evenNum = [x for x in fibList if x%2==0] 
evenSum = sum(evenNum) 
print "evensum=", evenSum 

Answer 14

Hai appena frainteso con la sequenza uniforme e persino il valore.

Esempio: 1, 2, 3, 5, 8, 13, 21

Nella sequenza di cui sopra è necessario raccogliere 1, 3, 5, 13, 21 e non 2 , 5, 13.

Ecco la soluzione fro JAVA

public static void main(String[] args) { 
     int sum = 2; // Starts with 1, 2: So 2 is added 
     int n1=1; 
     int n2=2; 
     int n=0; 

     while(n<4000000){ 
      n=n1+n2; 
      n1=n2; 
      n2=n; 
      if(n%2==0){ 
       sum=sum+n; 
      } 
     } 
     System.out.println("Sum: "+sum); 
    } 

uscita è,

Somma: 4613732

Answer 15

Ecco il mio codice Python:

even_sum = 0 
x = [1, 1] # Fibonacci sequence starts with 1,1... 

while (x [-2] + x [-1]) < 4000000: # Check if the coming number is smaller than 4 million 
    if (x [-2] + x [-1]) % 2 == 0: # Check if the number is even 
     even_sum += (x [-2] + x [-1]) 
    x.append (x [-2] + x [-1]) # Compose the Fibonacci sequence 
print (even_sum)