标签: fibonacci

是否有一个黑客打印前n个斐波那契数字而不调用循环

for(int i=1; i<n; i++)
    System.out.println(computeF(n));

从主程序？

public static int computeF(int n)
{
    if(n==0)
    {
        return 0;
    }
    else if(n==1)
    {
        return 1;
    }
    else
    {
        return computeF(n-1)+computeF(n-2); 
    }

}

可能有一种方法可以在递归中打印中间值,这将打印斐波那契数字.

我不确定我的逻辑中的错误是什么.样本输出:

How many terms of the Fibonacci Sequence do you wish to compute?
1
1
1
--How many terms of the Fibonacci Sequence do you wish to compute?
5
5
5
5
5
5
5

它为什么这样做？

    // Recursive Fibonacci Sequence
#include <iostream>
using namespace std;

double fib(double number);

int main(void) {
        double number;
        cout << "How many terms of the Fibonacci Sequence do you wish to compute?" << endl;
        cin >> number;

        for(int i = 0; i <= number; ++i) …

public class Arrays {
public static void main(String[] args){
long Fib[] = new long[100];
Fib[0] = 1;
Fib[1] = 1;
int i = 0;
    while(i <= 100){
        Fib[i+2]= Fib[i] + Fib[i+1];
        System.out.println(Fib[i]);
        i++;
    }

}
}

我用它来找到斐波那契数字,但它开始在第94届大约给我奇怪的读数.有人在乎解释吗？我是Java的新手,所以请不要讨厌它是否显而易见.这里是错误输出的一些片段,但其他一切看起来很好:

832040

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100

1346269

...

63245986

at Arrays.main(102334155
Arrays.java:8)

165580141

...

4660046610375530309

7540113804746346429

-6246583658587674878

1293530146158671551

-4953053512429003327

-3659523366270331776

-8612576878699335103

6174643828739884737

我正在尝试学习动态编程,他们在维基百科中给出的不是动态编程的例子之一是将Fibonacci序列提升到一定数量的递归方法.IE

给定递归函数,说:

fib(n) = 0 if n = 0
         1 if n = 1
         fib(n - 1) + fib(n - 2) if n >= 2

我们可以从它的数学形式递归地写出这个:

function fib(n)
  if(n == 0 || n == 1)
    n
  else
    fib(n-1) + fib(n-2)

但我不能让伪代码工作.

当我在Java中执行此方法时,我得到一个错误,操作符+未定义方法void:

 public void fib(int n) {

     if (n == 0 || n == 1) {

         System.out.println(n);
     } else
         return fib(n - 1) + fib(n - 2);

 }

我必须编写一个程序,给出第n个术语的最后三位数字.例如,第20个术语是6765,后三个数字是'765'.现在我需要找到Fibonacci序列的第一个数字,其最后三位数字为"321".

我在网上看了一下,发现第n个术语是479,我编写的程序甚至不能达到那么高.我找不到任何程序高于第100学期的人.

截至目前,他们无法找到高于100的术语？除了递归之外你还有其他任何想法,找到以'321'结尾的数字的第一个数字？

我的递归代码非常基本:

long long fibNum(long long nth)
{
    if (nth == 1)
        return 1;
    else if (nth == 2)
        return 1;
    else
        return fibNum(nth - 1) + fibNum(nth - 2);
}

当我到第43个学期时,它开始减速.

问题描述

通过考虑Fibonacci序列中的值不超过四百万的项,找到偶数项的总和

程序

using System;

class fibonacci {
    // function to return Nth value of fibonacci
    public static long fibo_n(long N) {
        long fibon=0;
        switch (N) {
            case 1: fibon=1; break;
            case 2: fibon=2; break;
        }
        while(N>2) {
        fibon=fibo_n(N-1)+fibo_n(N-2);
        }
    return fibon;
    }
}    

class fibo_tester {
    static void Main() {
        int N=2;
        long sum=0;
        while(fibonacci.fibo_n(N) <= 13) {
            sum = sum + fibonacci.fibo_n(N);
            N=N+3;
        }
        Console.WriteLine("Sum is {0}: ", sum);
    }
}

我将测试数量减少到13而不是400万,但它仍然悬而未决.有人可以建议吗？

编辑2

switch (N) {
        case 1: …

例如,以这样的形式:

let f = [ a | a <- [1..], a == a - 1]

我只是好奇.它似乎有可能,但我无法完全理解它是如何工作的.这个问题更多的是为了理解Haskell的工作原理,而不是因为我正在寻找一个实际的应用程序.

此外,我知道有类似的问题已被提出,但我所看到的帖子都没有提供任何帮助,因为我很好奇.

编辑:抱歉模糊不清.那么让我澄清一条新规则.挑战是找到一种方法来代表一个无限的斐波纳契数列表,使用从了解你的好东西的第一章中的额外内容!尽可能.怎么样？换句话说,你能想到的最具创造性的方法是用尽可能少的"知识"来产生这些数字.对不起让任何人回答无效,现在.

我把一个生成器放在一起来计算Fibonacci数/序列.但是,它没有按照我的预期运作.我已经从python中"编译"了它,但我不知道我的JavaScript代码中的内容是什么不符合我的逻辑,就像python那样......任何人都可以给我一个暗示吗？

这是代码:

// Fibonacci generator
function* fibonacci() {
  var a = 0;
  var b = 1;
  while (true) {
    yield a;
    a = b;
    b = a + b;
  }
}

// Instantiates the fibonacci generator
fib = fibonacci();

// gets first 10 numbers from the Fibonacci generator starting from 0
for (let i = 0; i < 10; i++) {
  console.log(i + ' => ' + fib.next().value);
}

我认为这是一个可变范围的问题.我这样做是为了让这个工作:

// Fibonacci generator
function* fibonacci() {
  var a = 0; …

这个函数找到了第n个斐波那契的作品.

a = 1
b = 2

fibonacci :: Int -> Int
fibonacci 1 = a
fibonacci 2 = b
fibonacci n = (fibonacci (n-1)) + (fibonacci (n-2))

但它很慢.如果我这样做map fibonacci [1..],真的会随着数字的增加而减慢.我猜这是开销,因为正在使用多少堆栈和大量的计算 - 将每一个计算到底a,b而不是仅仅将最后两个放在一起.

我怎样才能改进它以便它更快,但仍然使用函数式编程风格？(我是一个明确的haskell和FP新手!)我在Python中尝试了一些比较闪电的东西.

如果不是比工作代码更受欢迎,提示也是受欢迎的!

我仍然是python中的新生成器.我自己尝试了一个并尝试了一些非常简单的事情:

def fib(a):
...     if a==0 or a==1:return 1
...     yield fib(a-1)+fib(a-2)
print(list(fib(5))

这段代码给了我这个错误:

TypeError: unsupported operand type(s) for +: 'generator' and 'generator'

不能以这种方式使用发电机吗？