标签: fibonacci

Python函数对象有一个属性字典func_dict,在函数外部可见并且是可变的,但在调用函数时不会被修改.(我从昨天问过的问题的答案(#1753232)中学到了这一点:谢谢!)我正在阅读代码(http://pythonprogramming.jottit.com/functional_programming),它记住了Fibonacci数字的计算并思考,"为什么不使用该func_dict属性进行记忆？" 它起作用了(见下文;代码末尾的输出).这有点像有一个类属性,但在对象外面有初始化代码(在这种情况下,不是类而是函数).

我想知道使用这个属性可以做什么相似(或不同)的技巧？

def fib(n):
    if n in fib.cache:
        print "found fib.cache[%d] = %d: " %(n, fib.cache[n])
        return fib.cache[n]
    else:
        print "fib.cache[%d] = fib(%d) + fib(%d)" % (n, n-1, n-2)
        fib.cache[n] = fib(n-1) + fib(n-2)
        print "modified fib.cache: ", fib.cache
        return fib.cache[n]

fib.cache = {0:0, 1:1}

for x in range(7):
    print "==================>", x
    print fib( x)

"""
==================> 0
found fib.cache[0] = 0: 
0
==================> 1
found fib.cache[1] = 1: 
1
==================> …

我正在尝试编写一个函数,该函数使用C中的forks从给定的int n递归计算得到的fibonacci数.

这是功能规范:如果print为true,则打印它.否则,将其提供给父进程.解决方案应该是递归的,并且必须为每个调用分叉一个新的子节点.每个进程应该只调用一次doFib().方法签名无法更改.不能使用辅助函数.

这是我到目前为止根据我对fork的理解所写的内容.我试图分叉两次,所以我可以产生两个子进程.一个做fib(n-1),一个做fib(n-2).这样我就可以抓住两个结果并将它们组合起来.

static void doFib(int n, int doPrint)
{
    pid_t pid1;
    pid_t retpid1;
    int status1;

    pid_t pid2;
    pid_t retpid2;
    int status2;

    pid = fork();
    if (pid == 0) // Child Process 1
    {
        exit(100); // sends 100 to the parent
    } 
    else if (pid > 0) // Parent Process 1
    {
        pid2 = fork();
        if (pid2 == 0) // Child Process 2
        {
            exit(200); // sends 200 to the parent
        }
        else if (pid2 > 0) // …

我创办了Project Euler.我遇到了问题2并提出了这个代码来得出甚至斐波那契数字达到400万的总和.代码似乎完全符合我的要求.我确实看到代码运行时列出了​​正确的总和.我真正感到困惑的唯一部分是结果中显示的最后一个数字.这就是它所显示的:

JS代码:

var previous = 0;
var current = 1;
var sum = 0;
var next;

   for(i = 1; i < 100; i++){
        next = current + previous;
        previous = current;
        current = next; 
        if(current % 2 === 0 && current < 4000000) {
            sum += current;
        console.log(sum);
        }
   }

结果:

2
10
44
188
798
3382
14328
60696
257114
1089154
4613732 (this is the number i was trying to get)
=> 354224848179262000000 (confused as to why this number …

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

问题

编写一个程序,跟踪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 …

所以,我已经成功地编写了Fibonacci序列来创建一个array带有数字序列的序列,但我需要知道该数字的长度(多少位数)500th.

我已经尝试了下面的代码,但它找到了科学记数法的长度(22位数),而不是应该返回的正确的105.

有关如何将科学记数法转换为实际整数的任何想法？

var fiblength = function fiblength(nth) {
    var temparr = [0,1];
    for(var i = 2; i<=nth; i++){
        var prev = temparr[temparr.length-2],
            cur = temparr[temparr.length-1],
            next = prev + cur;
            temparr.push(next);
    }
    var final = temparr[temparr.length-1].toString().length;
    console.log(temparr[temparr.length-1]);
    return final;
};
a = fiblength(500);
console.log(a);

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

我需要找到一个给定整数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).任何人都知道为什么会这样吗？

我必须对此有所了解.似乎没有明确解释的好指南.功能树是什么样的？

static long Fib(int n)
{  
    if (n <= 2)  
    {   
        return 1;  
    }  
    return Fib(n - 1) + Fib(n - 2); 
}

假设我这样做Fib(7),我实际上明白它应该是这样的:

事情是,看起来树似乎fib(7)实际意味着fib(6)+ fib(5)应该是真的....但是,如果我理解递归而不是fib(7)实际fib(6)+ fib(5)但是fib(5)还没有操作,因为fib(6)现在将自己称为fib(4)+ fib(3)并且再一次fib(3)将不会执行,因为它fib(4)会自动调用,直到它停止在"停止"状态...而不是什么？

如果fib(7)呼叫fib(6)等等......直到fib(1),所有其他fib(n-2)功能呢？

每次结果如何实际返回并告诉我它的值是fib(7)多少？

我有以下python代码:

a, b = 1, 1
for i in range(0, 100):
    print a
    a, b = b, a + b

它产生了这个:1 1 2 3 5 8等

我在c中写了同样的文章:

#include <stdio.h>
long long unsigned int a = 1, b = 1;
void main(){
    for(int i = 0; i < 100; i++){
        printf("%llu \n", a);
        a = b, b = a + b;
    }
}

它产生了这个:1 1 2 4 8 16 32等

为什么c程序在使用完全相同的操作时会产生2的幂？