使用map或javascript中的reduce打印斐波那契数列

Question

我想在Javascript中使用map()或reduce()函数打印斐波那契数列。我无法在网上找到任何相关内容。我不太确定我的情况在地图（）中会是什么。

我基本上是在写

fib(n){
return new Array(n-1).fill(1).map((_,i) => *This is where I am confused* ) ;
}

Answer 1

使用

reduce()

来做到这一点相对容易，只需检查索引并采取相应的行动即可：

function fib(n){
  return new Array(n).fill(1).reduce((arr, _ ,i) => {
      arr.push((i <= 1) ? i : arr[i-2] + arr[i-1])
      return arr
  },[]) ;
}
console.log(fib(10))

map()

不是特别合适，因为您没有自然的方式来访问早期状态。

Answer 2

我为我的学生写的一个野蛮的单行示例：

const fiboReduce = level => new Array(Math.max(0, ++level)).fill(0).reduce((acc, val, index) => [...acc, ...((index > 1 && [acc[--index] + acc[--index]]) || [])], [0, ...((level > 1 && [1]) || [])]);

console.log(fiboReduce(20));

长版导演剪辑版（请原谅我的法语）：

const fiboReduceExplained = level => {
	// on force le rang minimum à 1 en utilisant Math.max
	// on ajoute 1 pour bien calculer jusqu'au rang souhaité
	// on créé un tableau vide qui a pour longueur le rang souhaité
	let array = new Array(Math.max(1, ++level));
	array.fill(0); // on le blinde de 0 jusqu'au bout
	let startValue = [0]; // valeur de départ
	if(level > 1) startValue.push(1); // cas particulier pour fibo(0)
	let fibo = array.reduce((acc, val, index) => { // reduce !
		if(index > 1) { // index strictement supérieur à un, on est sorti des valeurs de départ
			let next = acc[index - 1] + acc[index - 2]; // on calcule le terme suivant 
			acc.push(next); // et on l'ajoute au tableau
		}
		return acc; // on retourne le tableau pour la boucle suivante
	}, startValue); // valeur de départ du reduce
	return fibo; // on retourne le résultat
}

console.log(fiboReduceExplained(20));

Answer 3

您可以使用

Array.from

和两个起始值来映射它以获取系列。

function fib(length) {
    return Array.from({ length }, ((a, b) => _ => ([b, a] = [a + b, b, a])[2])(0, 1));
}

console.log(fib(10));

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 4

下面是您的问题的代码。 “elem”是当前值，“index”是当前索引，“currentArray”是数组的实例。

fibonacci = (n)=>{
    return new Array(n).fill(0).map((elem,index, currentArray)=>{
        if(index === 0){
            currentArray[index] = 0;
        }else if(index === 1){
            currentArray[index] = 1;
        }else{
            currentArray[index] = currentArray[index-2]+currentArray[index-1];
        }
        return currentArray[index];
    });  
}

您可以看到，对于每一步，我们都会使用当前索引修改数组元素，然后返回当前索引处的元素。迭代完成后最终得到斐波那契数列数组。

Answer 5

我在我的控制台中尝试过它工作正常你可以按照这个。希望它可以帮助您尝试从谷歌控制台运行它。

function Fibonacci(n) {
    var f = [];
    for (var c = 0; c < n; ++c) {
        f.push((c < 2) ? c : f[c-1] + f[c-2]);
    }
    return f;
}

Answer 6

减少并连接

const fib = (n) => {

    [...Array(n)].reduce(
    (acc,val,i) => acc.concat(i > 1 ? acc[i-1]+ acc[n-2] : i),
    [])
    
    }

fib(10)

Answer 7

据我了解，斐波那契数列仅针对整数定义。

.reduce()

可以用于最大的

n

（假设我们使用

BigInt

），因为它不需要持久存储整个序列：

fibonacci = function fibonacciDef(n) {
    if (!Number.isInteger(n)) return undefined
    return [...Array(n * Math.sign(n))].reduce((accumulator) => {
        const [secondLast, last] = accumulator
        return [last, last + secondLast]
    }, [BigInt(0), BigInt(Math.sign(n))])[0]
}
window.console.log(`reduce: fibonacci(8) = ${fibonacci(8)}`)

.map()

可以通过使用回调闭包来计算斐波那契：

function fibonacci(n) {
    if (!Number.isInteger(n)) return undefined
    return [...Array(n * Math.sign(n))].map((function closure() {
        let [secondLast, last] = [0, Math.sign(n)]
        return function inner() {
            [secondLast, last] = [last, last + secondLast] 
            return secondLast
        }
    })())[(n * Math.sign(n)) - 1]
}
window.console.log(`map: fibonacci(8) = ${fibonacci(8)}`)