标签: fibonacci

我只想提前做好这是一项家庭作业.我已经用很多不同的方式尝试了这个问题,我只是出于想法而没有获得所需的输出.

问题

编写一个程序,跟踪Fibonacci数字是如何递归生成的(对于任何N)并以下列方式显示跟踪:

示例(N = 4):

Entering level 0
Entering level 2
Entering level 4
Exiting level 4
Entering level 3
Exiting level 3
Exiting level 2
Entering level 1
Entering level 3
Exiting level 3
Entering level 2
Entering level 4
Exiting level 4
Entering level 3
Exiting level 3
Exiting level 2
Exiting level 1
Exiting level 0

我的主要:

public class A5main {

public static void main(String[] args) {
    //n holds user input
    //level is the current level …

I\xe2\x80\x99d 希望有人指出当函数使用多个递归调用时可以更好地解释递归的参考。我想我明白了当函数使用单个递归实例时 Python 如何处理内存。当函数处理数据时，我可以使用打印语句来跟踪数据在任何给定点的位置。然后我可以回溯每个步骤，看看如何实现最终的返回值。

一旦在单个函数调用期间触发多个递归实例，我就不再确定数据实际上是如何处理的。先前的启发性方法是在适当位置打印陈述，揭示了一个看起来量子的过程，或者至少更像巫术。

为了说明我的困境，这里有两个基本例子：斐波那契问题和河内塔问题。

def getFib(n):\n    if n == 1 or n == 2:\n        return 1\n    return getFib(n-1) + getFib(n-2)\n

斐波那契示例具有两个内联调用。是getFib(n-1)先通过堆栈一路解析，然后getFib(n-2)类似地解析，将每个结果放入新的堆栈中，然后将这些堆栈逐行相加，将这些总和汇总为结果？

def hanoi(n, s, t, b):\n    assert n > 0\n    if n ==1:\n        print 'move ', s, ' to ', t\n    else:\n        hanoi(n-1,s,b,t)\n        hanoi(1,s,t,b)\n        hanoi(n-1,b,t,s)\n

Hanoi 提出了一个不同的问题，因为函数调用是在连续的行中。当函数到达第一个调用时，它是否将其解析为 n=1，然后转到已经是 n=1 的第二个调用，然后转到第三个调用，直到 n=1？

再次强调，只是寻找可以帮助我了解\xe2\x80\x99s 幕后情况的参考资料。我\xe2\x80\x99m确定\xe2\x80\x99s可能在这个设置中解释得有点多。

Stream文档中有一个很好的例子可以获得斐波那契数字.

val fibs:Stream[Int] = 0 #:: 1 #:: fibs.zip(fibs.tail).map { n => n._1 + n._2 }

我想通过使用滑动实现它,所以我尝试了以下.

val test = 0 #:: 1 #:: Stream.empty
test.sliding(2).map(_.sum).toStream

最后一行正确获取Stream(1,？)但是当我将其连接到上面时,如下所示,当我尝试获得第3个成员时,我得到一个错误(可能是堆栈溢出,我看不到确切的错误消息,因为它太长了) .

val fibs2:Stream[Int] = 0 #:: 1 #:: fibs2.sliding(2).map(_.sum).toStream

如果我按如下方式给出3个数字,它会计算前两个数字的总和.但那不是斐波纳契数.

val fibs3:Stream[Int] = 0 #:: 0 #:: 1 #:: fibs3.sliding(2).map(_.sum).toStream

任何想法或帮助将不胜感激.

更新

• 我怀疑错误的原因是滑动方法返回Iterator,它需要知道使用hasNext方法是否可以使用下一个值
• 如果给出第一个播种器,则滑动方法应计算前n个数的任意和,称为tribonacci(n = 3),tetranacci(n = 4)等.

我在这里绝对是初学者。我正在用 Python 尝试回答有关 Project Euler 的问题。你能指出我的代码哪里出了问题吗？

Q) 斐波那契数列中的每一项新项都是通过添加前两项而生成的。从 1 和 2 开始，前 10 项将是：

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

通过考虑斐波那契数列中值不超过四百万的项，求偶数项的总和。

def fib(a):
    if ((a==0) or (a==1)):
        return 1
    else:
        return((fib(a-1))+(fib(a-2)))
    r=0
    sum=0
    while (fib(r))<4000000:
        if(((fib(r))%2)==0):
            sum+=fib(r)
            print(sum)

我正在开发一个 python 程序来计算斐波那契数列中的数字。这是我的代码：

import math
def F(n):
    return ((1+math.sqrt(5))**n-(1-math.sqrt(5))**n)/(2**n*math.sqrt(5))
def fib(n):
    for i in range(n):
        print F(i)

我的代码使用这个公式来查找斐波那契数列中的第 N 个数字：

这可以计算斐波那契数列中的许多数字，但我确实遇到了溢出错误。

如何改进此代码并防止溢出错误？

注意：我使用的是 python 2.7。

我需要找到一个给定整数N的(下一个)斐波纳契数.所以假设我有n = 13并且我需要输出下一个斐波纳契数21,但我该怎么做？我怎样才能找到以前编号形成的数字？

我的意思是我可以轻松地提出一个返回斐波那契序列的for/while循环,但是如何通过给出前一个数字来找到下一个数字.

<?php

$n = 13;

while($n < 1000) {

    $n = $x + $y; 
    echo($n."<br />"); 
    $x = $y;
    $y = $n;
}
?>

以下是我编写的用于计算Fibonacci序列中的值的方法:

def fib(n)

    if n == 0
        return 0
    end
    if n == 1
        return 1
    end

    if n >= 2
        return fib(n-1) + (fib(n-2))
    end

end

它工作起来n = 14,但之后我得到一条消息说该程序花了太长时间才响应(我正在使用repl.it).任何人都知道为什么会这样吗？

我有一个像这样的序列表达式：

let fibSeq = 
    let rec fibSeq' a b = 
        seq { yield a
              yield! fibSeq' b (a + b) }
    fibSeq' 1 1

现在，即使对于很大的数字，这也不会产生堆栈溢出。我想知道为什么，在我看来，要使用此序列表达式生成n 个斐波那契数，每个递归调用都需要返回到调用者，最终将其自身“折叠”到序列中。这里是否有某种优化在幕后进行？

n1 = 0
n2 = 1
fiblist = []
while True:     
     newNum = n1 + n2
     fiblist.append(newNum)
     n1 = n2
     n2 = newNum
     if newNum >= 10000:
          print(flist)
          break

beginner programmer: is there an easier way to write this or some other more effective way

最近在一次求职面试中，我被要求给出第三类斐波那契数列的第 100 个元素的结果(Fib(n)=Fib(n-1)+Fib(n-2)+Fib(n-3)。我用Mathematical Induction完成并构造了一个类来呈现大于long long的数字。然后我被要求通过模板元编程来实现它。问题是结果会超出long long的范围，我不知道如何解决这个问题。这是我使用模板元编程的代码。

template<long long num>
struct fib
{
    enum { result = fib<num - 1>::result + fib<num - 2>::result + fib<num - 3>::result};
};

template<>
struct fib<0>
{
    enum { result = 1 };
};

template<>
struct fib<1>
{
    enum { result = 1 };
};

template<>
struct fib<2>
{
    enum { result = 2 };
};

template<>
struct fib<3>
{
    enum { result = 4 };
};

int main()
{

    cout << fib<100>::result << endl; …