标签: fibonacci

我试图想出一个程序,从用户获取任何数字,并产生斐波那契代码的第n个数字.当我完成我的工作时,它会显示下一个#而不是#I需要.例如,我正在寻找第11个#并且它正在生成233而不是144.这是我的代码:

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


public static void main(String[] args)
{
    System.out.println("Enter a Number:");
    Scanner keyboard = new Scanner(System.in);
    int number = keyboard.nextInt();
    System.out.println("You Entered Number:" + number);
    System.out.println(number + "th Fibonacci Number is:"+ fibonacci(number));
    keyboard.close();        
}

我只是Haskell的初学者.我编写了一个代码来显示Fibonacci序列中的N个数字.这是我在Haskell中的代码,

fib_seq 1 = 1:[]
fib_seq 2 = 1:1:[]
fib_seq n = sum(take 2 (fib_seq (n-1))):fib_seq (n-1)

当我fib_seq 40在GHCI中运行此代码以获得更高的数字时,需要花费很长时间来评估它并且我的计算机挂起并且我必须中断.但是,当我在C中写出相同的逻辑时,(我只是打印而不是将其保存在列表中),

#include<stdio.h>

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


void print_fib(int n){
    if(n==0)    return;
    else        printf("%i ", fib_seq(n));
                print_fib(n-1);     }

int main(int argn, char* argc){
    print_fib(40);
    return 0;     }

代码非常快.使用GCC编译时运行大约需要1秒.Haskell应该比C慢吗？我在互联网上查找了其他答案,他们说了一些关于memoization的内容.我开始Haskell,我不知道这意味着什么.我所说的是我编写的C代码和Haskell代码都执行相同的步骤,而Haskell比C慢得多,它挂起了我的GHCI.1-2秒的差异是我永远不会担心的,如果C也花了与Haskell相同的时间,我也不会担心.但Haskell崩溃和C在1秒内完成它是不可接受的.

在这里，我有一些代码可以返回斐波那契数字的最后一位。当我将缓存字典放置在函数中时，程序对于小n正常工作。当我尝试更大的n（例如300）时，该程序将永远耗费时间。但是，当使字典成为全局字典时，会得到一个较大的n（例如300）的即时结果。是什么导致在函数中声明的字典与函数外部声明的字典之间如此大的性能差异？

def fib_last_digit_mem(n):
    cache = {}

    if n in cache:
        return cache[n]

    if(n <= 1):
        return n

    fib = (fib_last_digit_mem(n-1) + fib_last_digit_mem(n-2))%10
    cache[n] = fib
    return fib

我正在研究这个问题并试图弄清楚Fibonacci是如何实现的？

public int fibonacci(int x) {
    if (x==1) {
        return 1;
    } else if (x==2) {
        return 1;
    } else {
        return fibonacci(x-1) + fibonacci(x-2)
    }
}

我将此序列显示为正确的序列.

1, 1, 2, 3, 5, 8, 13, 21

问题出在5我得到的迭代上7

(5-1) + (5-2)  = 4 + 3

我在这里错过了什么吗？

我试图得到所有偶数斐波纳契数的总和.我可以打印出数字,但我无法得到它们的总和.这是在java中.

class driver {
    public static void main(String [] args) {
        int a; 
        int b = 0;
        int c = 1;

        for (int i = 0; i < 10; i++) { // Finds fibonacci sequence
            a = b;
            b = c;
            c = a + b;

            if ( c % 2 == 0) { // Check if it's even
                int sum = 0;
                sum = sum + c;
                System.out.println(sum);
            }
            else {

            }
        }
    }
}

以下是我的代码.它运行.有用.问题是,第一个1000位斐波那契数的INDEX不是4872 ......它是4871. 4872是POSITION,而不是INDEX.欧拉是否接受了错误的答案,或者他们在使用职位时是否使用了索引这个词？

def fib_of_a_certain_digit(num)
    fibs = [1, 1]
    idx = 1
    while true 
      fib = fibs[idx] + fibs[idx-1]
      fibs << fib
      idx += 1
      digilength = fib.to_s.split("").length
      return "The first #{num} digit Fibonacci number is at index #{idx}, the fibonacci array is #{fibs.length} long" if digilength == num
     end
end

puts fib_of_a_certain_digit(3)
puts fib_of_a_certain_digit(1000)

这是输出.前三位Fibonacci数位于索引11,斐波纳契数组为12长.前1000位斐波纳契数位于索引4781,斐波那契数组为4782长

如您所见,控制案例与已知数据匹配.[1,1,2,3,5,8,13,21,34,55,89,144]数组中的最后一个数字是144.它在索引11处,但是是数组中的第12个数字.同样的原则适用于较大的数字(它太大而无法粘贴).它在阵列的最后一个位置(4872)结束,其索引为4871.

为什么没有人注意到这个？

这是代码:

class qual
{
    public static int fibonacci(int n)
    { 
        if (n == 0 || n == 1) 
        { 
            return 1; 
        } 
        else 
        { 
            return fibonacci(n-1) + fibonacci(n-2); 
        } 
    } 

    public static void main(String[] arg) 
    {
        System.out.println(fibonacci(5));
    }
}

输出是8.输出应该是8但是当我看这个时我觉得它应该是7((5-1) +(5-2)).

为什么输出8？我认为获得8后面的推理会使递归可能不再让我感到困惑.

下来两个功能.一个计算一定数量的斐波那契,另一个尝试使用地图显示斐波纳契序列达到一定数量.当我键入斐波那契数字时会发生错误,例如斐波纳契8和抛出错误.我究竟做错了什么？

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

fibonacci :: [Integer]
fibonacci = map fib [0..]

所以我编写了可以找到N'th Fibonacci数的java代码.我的问题是,我必须输出答案%1000000007.我以为我可以通过写作来完成

System.out.println(answer.mod(1000000007));

但它不允许我这样做,我得到一个错误"BigInteger类型中的方法mod(BigInteger)不适用于参数(int)"

有人可以帮助我,这是我的代码.

import java.io.IOException;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Scanner;

public class dmoj
{
   public static void main(String[] args) throws IOException{
       Scanner scan = new Scanner(System.in);
       BigDecimal d, v, t, a;
       BigInteger  b;
       int index;

       int n = scan.nextInt();

       double phi1 = (1 + Math.sqrt(5)) / 2;
       double phi2 = (1 - Math.sqrt(5)) / 2;    
       double sqrt = Math.sqrt(5);

       d = new BigDecimal(phi1);
       v = new BigDecimal(phi2);
       a = new BigDecimal(sqrt);

       d = d.pow(n);
       v = v.pow(n); …

我一直在尝试各种方法.但是我不知道是否可以在java中打印Fibonacci系列而不使用递归,循环和自定义函数.如果是,那怎么样？

#include <iostream>
using namespace std;
void main()
{
  int i = 0;
  while (i < 1000)
  {
      int TEMP = i * 2;
      cout << i << endl;
      TEMP = i;
      i = i +1;
      // ???
  }

  return;
}

我很困惑？？:(

我在这里使用这个函数创建点。

local GR = (math.sqrt(5) + 1) / 2
local GA = (2 - GR) * (2 * math.pi)

local function fibonacciSpiralSphere(num_points)
    local vectors = {}

    for i = 1, num_points do
        local lat = math.asin(-1 + 2 * i / (num_points + 1))
        local lon = GA * i

        local x = math.cos(lon) * math.cos(lat)
        local y = math.sin(lon) * math.cos(lat)
        local z = math.sin(lat)

        table.insert(vectors, Vector3.new(x, y, z))
    end

    return vectors
end

分数结果如何。

我只是不知道如何用它们制作球体网格。