标签: fibonacci

我的任务：

给定一个数字，比如说 prod（对于产品），我们搜索两个斐波那契数 F(n) 和 F(n+1) 验证

F(n) * F(n+1) = prod if F(n) * F(n+1) = prod

Run Code Online (Sandbox Code Playgroud)

您的函数 productFib 接受一个整数 (prod) 并返回一个数组：

[F(n), F(n+1), True] else 

Run Code Online (Sandbox Code Playgroud)

F(m) 是最小的，例如 F(m) * F(m+1) > prod

[F(m), F(m+1), False] 

Run Code Online (Sandbox Code Playgroud)

例子：

productFib(714) # should return [21, 34, True], 
            # since F(8) = 21, F(9) = 34 and 714 = 21 * 34

productFib(800) # should return [34, 55, False], 
            # since F(8) = 21, F(9) = 34, F(10) = 55 and 21 * …

Run Code Online (Sandbox Code Playgroud)

如果我将使用以下方法计算Fibonacci数,它将比线性方法更快:

我对吗？

方法是从这里开始的.

我是Python（自学）的初学者，并了解了Lambda（无名）函数，但我无法推导出斐波那契数列的以下表达式（从Google获得），但在线（Google）没有关于如何评估它的解释（一步步）。这里有很多脑力，我想有人可以帮助我。您能帮忙逐步评估并解释一下吗？

lambda n: reduce(lambda x, _: x+[x[-1]+x[-2]],range(n-2), [0, 1])

提前致谢。

（感谢 xnkr，解释了关于减少函数的建议，是的，我能够理解这一点，这是我所做的自我训练的一部分，但我不明白的是这对于 lambda x, _ : x+[x[ -1]+x[-2]],range(n-2), [0, 1]。这不仅仅是一个关于reduce的问题，而是关于整个构造的问题——有两个lambda，一个reduce，我不知道表达式的计算结果如何。下划线代表什么，它是如何工作的，等等）

有人可以花 2 分钟来解释一下这里的整个结构吗？

fibs = 1:1:[x+y|x <- fibs, y <- tail fibs]

返回

[1,1,2,3,4,5,6,7,8,9]

fibs = 1:1:[x+y|(x, y) <- zip fibs (tail fibs)]

返回

[1,1,2,3,5,8,13,21,34,55...]

我正在处理一项看似典型的面试任务 - 通过该数字的指数计算斐波那契数。但是任务的难点是索引可以达到2000000。我遇到了几个问题，我不明白为什么会发生。

先上代码：

function fib(number) {  
  const left = Math.pow((1 + Math.sqrt(5)) / 2, number);
  const right = Math.pow((1 - Math.sqrt(5)) / 2, number);
  const result = Math.round((left - right) / Math.sqrt(5));
  
  console.log(result); // 
  return BigInt(result); // 
}

问题：

1. BigInt 不同于数字

fib(96);
console.log(result) // -> 51680708854858490000
BigInt(result) // 51680708854858489856

2. 错误的答案。我认为这与之前的问题有关

fib(96);
// Must return 51680708854858323072
// But return BigInt 51680708854858489856

问题是这样的：

你有 n 级台阶要爬。您一次只能爬 1 或 2 级台阶。找出到达第 N 步的方法数。

解被描述为 t(n) = t(n-1) + t(n-2)。

我一直在想为什么不添加一个常数 2 来表示 t(n-1) 和 t(n-2) 的最后一两步？我直觉上有困难，为什么不在每个阶段添加它？

问题是 t(n-1) 和 t(n-2) 的总和，但我觉得它在哪里解释了向后退一两步的原因？

因为有两个选项，并且您尚未在 t(n-1) 或 t(n-2) 处执行两个步骤，所以不应该在每个步骤中添加一个常数吗？我该如何概念化这个？

我正在做斐波那契序列函数，返回类型应该返回 BigUint 类型。我搜索了很多网站，但找不到指明方向的网站。这是我到目前为止的过程。

pub fn fibo_seq(n: u32) -> Vec<num_bigint::BigUint> {
    let mut f1 = 0;
    let mut temp = 1;
    let mut f2 = 1;
    let mut vec:Vec<u32> = Vec::new();

    while vec.len() < n.try_into().unwrap(){
       vec.push(f2);
       temp = f2;
       f2 = f1 + f2;
       f1 = temp;  

    }

    vec // return wrong data type

}

我正在尝试使用生成器进行斐波那契继承，但我的代码返回 2**a...

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a = b
        b = a + b
n = int(input("How long? "))
fib = fibonacci()

for i in range(n):
    print(next(fib))

我目前正在 riscv32I 中实现运行斐波那契数列（最多第 60 个数字）的代码，这意味着我可以使用的内存地址只有 32 位。

我首先用 C 实现了代码，然后用汇编实现了代码，但我很好奇我使用的算法是否有名称，以便我可以做更多研究。代码是这样的，

#include <stdint.h>
#include <stdio.h>
#include <inttypes.h>

int main() {
    uint32_t n1 = 0;        // first pre number  (n - 2)
    uint32_t n2 = 1;        // second pre number (n - 1)
    uint32_t add = 0;       // current number

    uint32_t store_hi = 0;  
    uint32_t store_lo = 0; 
    uint32_t result;        // result
    uint32_t carry;         // carry bit

    for (int i = 2; i < 61; i++) {
        carry = 0;                              // reset …

我最近对算法产生了兴趣,由于其简单性,斐波纳契序列引起了我的注意.

我已经设法将一些东西放在javascript中,在网上阅读大量信息后,在不到15毫秒的时间内计算出斐波那契序列中的第n个项.它上升到1476 ... 1477是无穷大,1478是NaN(根据javascript!)

我为代码本身感到自豪,除了它是一个彻头彻尾的怪物.

所以这是我的问题:A)有更快的方法来计算序列吗？B)是否有更快/更小的方法来乘以两个矩阵？

这是代码:

//Fibonacci sequence generator in JS
//Cobbled together by Salty
m = [[1,0],[0,1]];
odd = [[1,1],[1,0]];
function matrix(a,b) {
    /* 
        Matrix multiplication
        Strassen Algorithm
        Only works with 2x2 matrices.
    */
    c=[[0,0],[0,0]];
    c[0][0]=(a[0][0]*b[0][0])+(a[0][1]*b[1][0]);
    c[0][1]=(a[0][0]*b[0][1])+(a[0][1]*b[1][1]);
    c[1][0]=(a[1][0]*b[0][0])+(a[1][1]*b[1][0]);
    c[1][1]=(a[1][0]*b[0][1])+(a[1][1]*b[1][1]);
    m1=(a[0][0]+a[1][1])*(b[0][0]+b[1][1]);
    m2=(a[1][0]+a[1][1])*b[0][0];
    m3=a[0][0]*(b[0][1]-b[1][1]);
    m4=a[1][1]*(b[1][0]-b[0][0]);
    m5=(a[0][0]+a[0][1])*b[1][1];
    m6=(a[1][0]-a[0][0])*(b[0][0]+b[0][1]);
    m7=(a[0][1]-a[1][1])*(b[1][0]+b[1][1]);
    c[0][0]=m1+m4-m5+m7;
    c[0][1]=m3+m5;
    c[1][0]=m2+m4;
    c[1][1]=m1-m2+m3+m6;
    return c;
}
function fib(n) {
    mat(n-1);
    return m[0][0];
}
function mat(n) {
    if(n > 1) {
        mat(n/2);
        m = matrix(m,m);
    }
    m = (n%2<1) ? m : …