Question

我正在尝试python中的第二个Project Euler问题，并希望了解为什么我的代码不起作用。

此代码查找甚至斐波那契数字低于400万的总和

counter = 2
total = 0
while counter <= 4000000:
    if counter % 2 == 0:
        total+= counter    
    counter+= (counter -1)
print total

此代码将输出：2

如果我打印计数器，则输出：4194305

我假设if语句正在执行时出现问题，因为while循环正常运行且计数器也正常递增。

Answer 1

问题在于counter+= (counter -1)行。你应该这样做时将它添加到自身（减去1）：

a, b = 1, 1
total = 0
while a <= 4000000:
    if a % 2 == 0:
        total += a
    a, b = b, a+b  # the real formula for Fibonacci sequence
print total

Answer 2

您的代码为counter计算的系列如下：

2 # solid start
3 # good
5 # this is going great
9 # wait, what?
17 # this is going really badly

您每次只能添加counter - 1，您需要在系列中添加之前的号码。

那么为什么你的total这么小？因为奇数减1总是偶数，奇数加偶数总是奇数; 2是您生成的唯一偶数，因此这是您的total。

生成Fibonacci数通常用两个变量a和b来完成，我们从这里开始

a = b = 1

并且每次迭代看起来像：

a, b = b, a + b

Answer 3

如果仔细观察，您会看到以下顺序：

1 1 2 3 5 8 13 21 34 55 89 144 ...

映射Fibonacci序列的公式是：

$F_n = F_{n-1} + F_{n-2}$

您只需要偶数数字的总和，例如：

1 2 3 5 8 13 21 34 55 89 144 ...

因此，您可以映射新公式，例如：

$F_n = 4 \cdot F_{n-1} + F_{n-2}$

您将获得以下序列：

2 8 34 144 ...

代码示例（Go）：

package main

import "fmt"

func fibonacci() func() int {
    first, second := 0, 2
    return func() int {
        ret := first
        first, second = second, first+(4*second)
        return ret
    }
}

func main() {
    sum := 0
    f := fibonacci()
    for i := 0; sum < 4000000; i++ {
        sum += f()
    }
    fmt.Println(sum)
}

在这种情况下，你不需要if条件。

希望对你有所帮助！干杯！

Answer 4

有更简单的方法可以做到这一点（例如，奇怪的解决方案），但这个版本说它做了什么，做了什么： - ）

from itertools import takewhile

def fibonacci():
    a, b = 1, 1
    while 1:
        yield a
        a, b = b, a+b


def even(it):
    for n in it:
        if n % 2 == 0:
            yield n


print sum(takewhile(lambda f: f <= 4000000, even(fibonacci())))

Answer 5

我尝试过这种方式：

fib_num = [0 ,1]
for i in range(2, 4*10**6):
    fib_num.append(fib_num[i-1] + fib_num[i-2])

def even_fib(fib_num):
    result = 0
    result = result + sum([even for even in range(0, fib_num) if even % 2 == 0])
print result

那有什么不对？响应脚本并给出“已杀死”错误需要很长时间

Answer 6

这是我使用XOR门的Python解决方案。我已经初始化了前两个值，然后在每次迭代中，我都存储了前两个数字的状态。从理论上讲，两个数字之和只有在两个数字均为奇数或偶数时才是偶数。

a = 1
b = 2

a_state = 1 #odd = 1 
b_state = 0 #even = 0

sum = b
output = []
while (a+b) < 1000:
    c = a+b
    a = b
    b = c
    
    if (a_state ^ b_state) == 0:
        sum += c
        a_state = b_state
        b_state = 0
    else:
        a_state = b_state
        b_state = 1
print(sum)

Answer 7

首先，你应该使用递归公式生成低于4000000的所有斐波纳契数，并且对于每个数字，如果是偶数，则将它加到总和中。

公式： enter image description here

Answer 8

井算法错了。反击总是很奇怪，甚至只是在开始时。这是怎么回事 2 3 五 9 17 等等。永远不会执行total+= counter

Answer 9

这是我的Python代码。我利用了两件事。首先，第n个斐波那契数可以计算如下：
Fib _n = [φⁿ - （1-φⁿ） ] /√5，
以及每3个斐波纳契数都出现偶数的事实。这避免了大量不必要的计算！

import numpy as np
import time

start = time.perf_counter()
phi_p = (np.sqrt(5)+1)/2
phi_n = phi_p-1
sqrt5_inv = 1/np.sqrt(5)

def Fib(n):
     return int(sqrt5_inv*((phi_p)**n-(-phi_n)**n))

fib_e_sum = 0
index = 3
max_fib = 4e6
tmp_fib = 0
while (tmp_fib<max_fib):
    fib_e_sum += tmp_fib
    tmp_fib=Fib(index)
    index += 3

end = time.perf_counter()
total_time = end-start
print(fib_e_sum)
print(total_time)

Answer 10

这是我解决这个问题的方法：

l = []
k = []
(x, y) = (1, 2)
while x < 4000000:
    k.append(x)
    k.append(y)
    x += y
    y += x
for i in k:
    if i % 2 == 0:
        l.append(i)
print(sum(l))

输出：4613732

Answer 11

算法应该是固定的。在你的代码中，你没有总结斐波那契数字。

以下是修订版：

total = 0

i, j = 1, 0

while j <= 4000000:
        if j % 2 == 0:
                total += j
        i, j = j, i + j

print total

Answer 12

#include <iostream>

using namespace std;

int main()
{

    int total, a=1,b=2,c;

    while(a+b<4000000)
    {
       if(b%2==0)
       {
          total+=b;
       }
       c=a+b;
       a=b;
       b=c;
    }

    cout<<total;

    return 0;
}

甚至斐波那契数字总和低于400万 - Python

12 个答案: