为什么我的代码在找到斐波那契和时很慢？

Question

我正在为project Euler 问题in this repo 写答案 但在我的解决方案中存在一些性能问题

问题 2： 斐波那契数列中的每个新项都是通过添加前两项来生成的。 从 1 和 2 开始，前 10 个术语将是： 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ... 考虑斐波那契数列中不超过四百万的项，求偶数项之和。

我的解决方案是

func solution2()
{
    func fibonacci(number: Int) -> (Int)
    {
        if number <= 1
        {
            return number
        }
        else
        {
            return fibonacci(number - 1) + fibonacci(number - 2)
        }
    }

    var sum = 0

    print("calculating...")
    for index in 2..<50
    {
        print (index)
        if (fibonacci(index) % 2 == 0)
        {
            sum += fibonacci(index)
        }
    }

    print(sum)
}

我的问题是，为什么在第 42 次迭代后它变得超级慢，我想按照问题所说的那样做 4000000 次，有什么帮助吗？

解决方案 2

func solution2_fast()
{
    var phiOne : Double = (1.0 + sqrt(5.0)) / 2.0
    var phiTwo : Double = (1.0 - sqrt(5.0)) / 2.0

    func findFibonacciNumber (nthNumber : Double) -> Int64
    {
        let nthNumber : Double = (pow(phiOne, nthNumber) - (pow(phiTwo, nthNumber))) / sqrt(5.0)
        return Int64(nthNumber)
    }

    var sum : Int64 = 0

    print("calculating...")
    for index in 2..<4000000
    {
        print (index)
        let f = findFibonacciNumber(Double(index))
        if (f % 2 == 0)
        {
            sum += f
        }
    }

    print(sum)

}

Answer 1

关于体育问题的最重要的事情是思考它在问什么。

这并不是要求您生成所有小于 4000000 的斐波那契数 F(n)。它要求的是所有小于 4000000 的偶数 F(n) 的总和。

考虑所有 F(n) 的总和，其中 F(n)

1 + 2 + 3 + 5 + 8

我可以通过计算 F(1)、F(2)、F(3) 等等来做到这一点……然后在将它们相加之前检查它们是否小于 10。

或者我可以存储两个变量...

F1 = 1
F2 = 2

总共...

Total = 3

现在我可以把它变成一个 while 循环并完全失去递归。事实上，我正在做的最复杂的事情就是将两个数字相加......

我想出了这个...

func sumEvenFibonacci(lessThan limit: Int) -> Int {
    // store the first two Fibonacci numbers
    var n1 = 1
    var n2 = 2

    // and a cumulative total
    var total = 0

    // repeat until you hit the limit
    while n2 < limit {
        // if the current Fibonacci is even then add to total
        if n2 % 2 == 0 {
            total += n2
        }

        // move the stored Fibonacci numbers up by one.
        let temp = n2
        n2 = n2 + n1
        n1 = temp
    }

    return total
}

它在几分之一秒内运行。

sumEvenFibonacci(lessThan: 4000000)

找到正确答案。

事实上这...sumEvenFibonacci(lessThan: 1000000000000000000) 运行大约半秒。

Answer 2

虽然 Int64 不足以存储结果，但第二种解决方案似乎更快（呃）。 2..91 的斐波那契数之和为 7,527,100,471,027,205,936，但您可以存储在 Int64 中的最大数为 9,223,372,036,854,775,807。为此，您需要使用一些其他类型，例如 BigInteger

Answer 3

因为你使用递归，它缓存在内存中。如果你迭代42，它可能在你的内存中有很多斐波那契函数，并且是递归的。所以它不适合递归，你可以存储结果在数组中，不是swift的原因。

Answer 4

这是两种不同的答案

func solution2_recursive()
{
    func fibonacci(number: Int) -> (Int)
    {
        if number <= 1
        {
            return number
        }
        else
        {
            return fibonacci(number - 1) + fibonacci(number - 2)
        }
    }
    var sum = 0
    print("calculating...")
    for index in 2..<50
    {
        print (index)
        let f = fibonacci(index)

        if( f < 4000000)
        {
            if (f % 2 == 0)
            {
                sum += f
            }
        }
        else
        {
            print(sum)
            return
        }
    }
}

解决方案 2

func solution2()
{
    var phiOne : Double = (1.0 + sqrt(5.0)) / 2.0
    var phiTwo : Double = (1.0 - sqrt(5.0)) / 2.0

    func findFibonacciNumber (nthNumber : Double) -> Int64
    {
        let nthNumber : Double = (pow(phiOne, nthNumber) - (pow(phiTwo, nthNumber))) / sqrt(5.0)
        return Int64(nthNumber)
    }

    var sum : Int64 = 0

    print("calculating...")
    for index in 2..<50
    {
        let f = findFibonacciNumber(Double(index))
        if(f < 4000000)
        {
            if (f % 2 == 0)
            {
                sum += f
            }
        }
        else
        {
            print(sum)
            return
        }
    }
}