标签: fibonacci

我需要编写一个Java代码来检查用户输入的数字是否在Fibonacci序列中.

我没有问题写Fibonacci序列输出,但(可能是因为它深夜)我正在努力想到"是否"它是斐波纳契数的序列.我一遍又一遍地开始.它确实在我的脑海里.

我现在拥有的是第n个.

public static void main(String[] args)
{
    ConsoleReader console = new ConsoleReader();

    System.out.println("Enter the value for your n: ");
    int num = (console.readInt());
    System.out.println("\nThe largest nth fibonacci: "+fib(num));
    System.out.println();
}

static int fib(int n){
    int f = 0;
    int g = 1;
    int largeNum = -1;
    for(int i = 0; i < n; i++)
    {
      if(i == (n-1))
          largeNum = f;
      System.out.print(f + " ");
      f = f + g;
      g = f - g;
    }
    return largeNum; …

什么是计算斐波纳契数从总和最有效的方式F(n),以F(m)其中F(n)和F(m)是第n和分别第m斐波那契数和0 = <N <= M <10 ⁹(以F(0)= 0,F(1)= 1).

例如,如果n=0,m=3我们需要找到F(0)+F(1)+F(2)+F(3).

只是通过蛮力,它将需要很长时间的范围n和m提到.如果可以通过矩阵求幂来完成那么如何？

我在看这个网站:http://rosettacode.org/wiki/Fibonacci_sequence#JavaScript并看到了这个程序:

function fib(n) {
  return function(n,a,b) {
    return n>0 ? arguments.callee(n-1,b,a+b) : a;
  }(n,0,1);
}

这是如何工作的,这两个参数(a和b)有什么帮助.我追踪它仍然无法弄清楚它是如何工作的

在阅读了memoization介绍之后,我通过使用更通用的memoize函数重新实现了Fibonacci示例(仅用于学习目的):

memoizer :: (Int -> Integer) -> Int -> Integer
memoizer f = (map f [0 ..] !!)

memoized_fib :: Int -> Integer
memoized_fib = memoizer fib
    where fib 0 = 0
          fib 1 = 1
          fib n = memoized_fib (n-2) + memoized_fib (n-1)

这有效,但是当我将最后一行更改为以下代码时,memoization突然无法正常工作(程序再次变慢):

          fib n = memoizer fib (n-2) + memoizer fib (n-1)

记忆化的关键区别在哪里？

我对课堂作业有疑问,我需要知道如何使用迭代返回第n个Fibonacci序列(不允许递归).

我需要一些关于如何做到这一点的提示,以便我能更好地理解我做错了什么.我在program.cs中输出到控制台,因此它在下面的代码中不存在.

    // Q1)
    //
    // Return the Nth Fibonacci number in the sequence
    //
    // Input: uint n (which number to get)
    // Output: The nth fibonacci number
    //

    public static UInt64 GetNthFibonacciNumber(uint n)
    {

    // Return the nth fibonacci number based on n.


    if (n == 0 || n == 1)
        {
            return 1;
        }

        // The basic Fibonacci sequence is 
        // 1, 1, 2, 3, 5, 8, 13, 21, 34...
        // f(0) = 1
        // f(1) = …

几个月前,作为一个笑话,我的一位同事试图通过使用这种指数算法计算斐波纳契数来"加速宇宙的热死":

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

这怎么不会导致C#中的stackoverflow？我们设法在放弃之前得到了Fib(52)(而Fib(51)花了很多时间).我认为这会严重破坏堆栈以导致堆栈溢出,因为CLR默认只将1M分配给堆栈.另外,我很确定这也不适合尾递归.

我试图在单位球体的表面上或多或少均匀地排列点.

我被告知虽然这个问题很难解决,但Fibonacci Lattices提供了一个非常好的解决方案.

我已经尝试了几天来关注链接文档中提供的非常简单的方法,但我根本无法让它看起来正确.

我正在使用javascript,我有一个对象数组e,每个对象都公开一个lat和lon参数.这是我用来排列球体上的点的函数:(现在假设点的数量总是奇数)

function arrangeEntries(e)
{
    var p = e.length;
    var N = (p - 1) / 2;

    for (var i = -N; i <= N; i++)
    {
        e[i + N].lat = Math.asin((2 * i) / (2 * N + 1));
        e[i + N].lon = mod(i, 1.618034) * 3.883222;
    }
}

同

function mod(a, b)
{
    return a - Math.floor(a / b) * b;
}

不同于文档中,我lat和lon …

我正在尝试编写C代码,它将打印出前100万个Fibonacci数字.

实际问题是我想得到10位F(1,000,000)

我理解序列是如何工作的,以及如何编写代码来实现它,但是F(1,000,000)非常大,我正在努力寻找一种方法来表示它.

这是我正在使用的代码:

#include<stdio.h>

int main()
{
   unsigned long long n, first = 0, second = 1, next, c;

   printf("Enter the number of terms\n");
   scanf("%d",&n);

   printf("First %d terms of Fibonacci series are :-\n",n);

   for ( c = 0 ; c < n ; c++ )
   {
      if ( c <= 1 )
         next = c;
      else
      {
         next = first + second;
         first = second;
         second = next;
      }
      printf("%d\n",next);
   }

   return 0;
}

我正在long …

我最近在Java中遇到了这段代码.它涉及功能和印刷斐波那契数字,它的工作原理.

public class AppLambdaSubstitution {

public static Function<Integer, Integer> Y(Function<Function<Integer, Integer>, Function<Integer, Integer>> f) {
    return x -> f.apply(Y(f)).apply(x);
}

public static void main(String[] args) {
    Function<Integer, Integer> fib = Y(
            func -> x -> {
        if (x < 2)
            return x;
        else
            return func.apply(x - 1) + func.apply(x - 2);
    });

    IntStream.range(1,11).
    mapToObj(Integer::valueOf).
    map(fib).forEach(System.out::println);
  }
}

困惑的部分是return x -> f.apply(Y(f)).apply(x);.是不是Y(f)递归调用该方法Y？我们一直以函数f作为参数来调用它.对我来说,这种递归调用没有基本情况.为什么无休止的递归调用没有溢出？

我试图了解有关 Haskell 函数的一些内容。

首先，这是一个以典型的“慢”方式定义的斐波那契函数（即没有记忆的递归，也没有无限列表技巧）

slowfib :: Int -> Integer
slowfib 0 = 0
slowfib 1 = 1
slowfib n = slowfib (n-2) + slowfib (n-1)

接下来，相同的规范记忆版本。（仅与教程/书籍/等中的典型示例略有不同，因为我更喜欢!!运算符的前缀版本。）

memfib = (!!) (map fib [0..])
  where
    fib 0 = 0
    fib 1 = 1
    fib k = memfib(k-2) + memfib(k-1)

上面的解决方案使用了!!运算符的部分应用，这是有道理的：我们希望memfib最终成为一个带参数的函数，并且我们正在定义它而不在定义中包含参数。

到现在为止还挺好。现在，我想我可以编写一个等效的记忆函数，在定义中包含一个参数，所以我这样做了：

memfib_wparam n = ((!!) (map fib [0..])) n
  where
    fib 0 = 0
    fib 1 = 1
    fib k = memfib_wparam(k-2) + memfib_wparam(k-1) …