Intereting Posts

Étendre la propriété expressjs res Supprimer la dernière ligne dans le tableau Vérification et désactivation des boutons radio avec Jquery Mobile Comment fonctionne le nouvel opérateur en JavaScript? Passer l'id dans url pour une vue individuelle dans angular.js Node.js multiple Répéter les requêtes de requête raw sql Razor MVC 5.2.3 comment appeler OnFailure avec ajax post Avast donne une erreur de JS: Injection-A sur mon site API YouTube – ne pas déclencher 'sur YoutubeTubeReady ()' Comment trouver des éléments dans array2 qui ne sont pas dans array1? Renommer les noms de propriétés et modifier les valeurs de plusieurs objets Event.returnValue est obsolète. Utilisez l'événement standard.preventDefault () à la place Désactiver un bouton sur le clic L'API visibilité de la page ne fonctionne pas sur Chrome OS X lorsque la fenêtre est minimisée Jquery: obtenir un clic de souris si dans un div ou non

Génération de la séquence de Fibonacci

var x=0, var y=1; var z; fib[0] = 0; fib[1] = 1; for(i=2; i<=10; i++) { alert(x+y); fib[i]=x+y; x=y; z=y; }

J'essaie d'obtenir une séquence Fibonacci simple, mais il n'y a pas de sortie. Est-ce que quelqu'un peut me faire savoir ce qui ne va pas?

Vous n'avez jamais déclaré fib pour être un tableau. Utilisez var fib = []; Pour résoudre ce problème.

En outre, vous ne modifiez jamais la variable y , ni l'utilisez.

Le code ci-dessous a plus de sens, plus, il ne crée pas de variables inutilisées:

 var i; var fib = []; // Initialize array! fib[0] = 0; fib[1] = 1; for(i=2; i<=10; i++) { // Next fibonacci number = previous + one before previous // Translated to JavaScript: fib[i] = fib[i-2] + fib[i-1]; console.log(fib[i]); }

Selon la question Interview Cake , la séquence va 0,1,1,2,3,5,8,13,21 . Si c'est le cas, le mien fonctionne très bien et est récursif sans utilisation de tableaux.

 function fibonacci(n) { return n < 1 ? 0 : n <= 2 ? 1 : fibonacci(n - 1) + fibonacci(n - 2); } console.log(fibonacci(4));

Pensez-y comme ça.

  fibonacci(4) .--------> 2 + 1 = 3 | / | '--> fibonacci(3) + fibonacci(2) | ^ | '----------- 2 = 1 + 1 <----------. 1st step -> | ^ | | | | '----> fibonacci(2) -' + fibonacci(1)-'

Voici une fonction simple pour itérer la séquence Fibonacci dans un tableau utilisant des arguments dans la fonction for plus que le corps de la boucle:

 fib = function(numMax){ for(var fibArray = [0,1], i=0,j=1,k=0; k<numMax;i=j,j=x,k++ ){ x=i+j; fibArray.push(x); } console.log(fibArray); } fib(10)

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

Vous n'êtes pas assigner une valeur à z , alors qu'attendez-vous de y=z; faire? De même, vous ne lisez jamais le tableau. Il semble que vous essayez une combinaison de deux approches différentes ici … essayez de vous débarrasser entièrement du tableau, et utilisez simplement:

 // Initialization of x and y as before for (i = 2; i <= 10; i++) { alert(x + y); z = x + y; x = y; y = z; }

EDIT: L'OP a changé le code après avoir ajouté cette réponse. À l'origine, la dernière ligne de la boucle était y = z; – et cela a du sens si vous avez initialisé z selon mon code.

Si le tableau est requis plus tard, il est évident qu'il faut être peuplé encore – mais sinon, le code que j'ai donné devrait être bien.

Vous devriez avoir déclaré la variable fib pour être un tableau en premier lieu (par exemple var fib = [] ou var fib = new Array() ) et je pense que vous êtes un peu confus quant à l'algorithme.
Si vous utilisez un tableau pour stocker la séquence de fibonacci, vous n'avez pas besoin des autres variables auxiliaires ( x,y,z ):

 var fib = [0, 1]; for(var i=fib.length; i<10; i++) { fib[i] = fib[i-2] + fin[i-1]; } console.log(fib);

Vous devriez également considérer la méthode récursive (notez qu'il s'agit d'une version optimisée):

 function fib(n, undefined){ if(fib.cache[n] === undefined){ fib.cache[n] = fib(n-1) + fib(n-2); } return fib.cache[n]; } fib.cache = [0, 1, 1];

Et puis, après avoir appelé la fonction fibonacci, vous avez toutes les séquences dans le champ fib.cache :

 fib(1000); console.log(fib.cache);

Cliquez pour la démo

Une autre réponse serait d'utiliser les fonctions du générateur es6.

 function* fib() { var current = a = b = 1; yield 1; while (true) { current = b; yield current; b = a + b; a = current; } } sequence = fib(); sequence.next(); // 1 sequence.next(); // 1 sequence.next(); // 2 // ...

 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1"> <title>fibonacci series</title> <script type="text/javascript"> function generateseries(){ var fno = document.getElementById("firstno").value; var sno = document.getElementById("secondno").value; var a = parseInt(fno); var result = new Array(); result[0] = a; var b = ++fno; var c = b; while (b <= sno) { result.push(c); document.getElementById("maindiv").innerHTML = "Fibonacci Series between "+fno+ " and " +sno+ " is " +result; c = a + b; a = b; b = c; } } function numeric(evt){ var theEvent = evt || window.event; var key = theEvent.keyCode || theEvent.which; key = String.fromCharCode(key); var regex = /[0-9]|\./; if (!regex.test(key)) { theEvent.returnValue = false; if (theEvent.preventDefault) theEvent.preventDefault(); } } </script> <h1 align="center">Fibonacci Series</h1> </head> <body> <div id="resultdiv" align="center"> <input type="text" name="firstno" id="firstno" onkeypress="numeric(event)"><br> <input type="text" name="secondno" id="secondno" onkeypress="numeric(event)"><br> <input type="button" id="result" value="Result" onclick="generateseries();"> <div id="maindiv"></div> </div> </body> </html>

Je sais que c'est une petite question, mais j'ai compris que beaucoup de réponses ici utilisaient des boucles plutôt que des boucles.

Parfois, alors que les boucles sont plus rapides que pour les boucles, alors j'ai pensé que je devrais apporter un code qui exécute la séquence Fibonacci dans une boucle while aussi! Utilisez tout ce qui vous convient selon vos besoins.

 function fib(length) { var fibArr = [], i = 0, j = 1; fibArr.push(i); fibArr.push(j); while (fibArr.length <= length) { fibArr.push(fibArr[j] + fibArr[i]); j++; i++; } return fibArr; }; fib(15);

Il existe également une généralisation de la formule de Binet pour les entiers négatifs:

 static float phi = (1.0f + sqrt(5.0f)) / 2.0f; int generalized_binet_fib(int n) { return round( (pow(phi, n) - cos(n * M_PI) * pow(phi, -n)) / sqrt(5.0f) ); } ... for(int i = -10; i < 10; ++i) printf("%i ", generalized_binet_fib(i));

Un moyen rapide d'obtenir ~ 75

Ty @geeves pour la capture, j'ai remplacé Math.floor pour Math.round qui semble l'atteindre jusqu'à 76 où les problèmes de virgule flottante entrent en jeu: / … de toute façon, je ne voudrais pas utiliser la récurrence et Jusqu'à ce point.

 /** * Binet Fibonacci number formula for determining * sequence values * @param {int} pos - the position in sequence to lookup * @returns {int} the Fibonacci value of sequence @pos */ var test = [0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,17711,28657,46368,75025,121393,196418,317811,514229,832040,1346269,2178309,3524578,5702887,9227465,14930352,24157817,39088169,63245986,102334155,165580141,267914296,433494437,701408733,1134903170,1836311903,2971215073,4807526976,7778742049,12586269025,20365011074,32951280099,53316291173,86267571272,139583862445,225851433717,365435296162,591286729879,956722026041,1548008755920,2504730781961,4052739537881,6557470319842,10610209857723,17167680177565,27777890035288,44945570212853,72723460248141,117669030460994,190392490709135,308061521170129,498454011879264,806515533049393,1304969544928657,2111485077978050,3416454622906707,5527939700884757,8944394323791464,14472334024676221,23416728348467685,37889062373143906,61305790721611591,99194853094755497,160500643816367088,259695496911122585,420196140727489673,679891637638612258,1100087778366101931,1779979416004714189,2880067194370816120,4660046610375530309,7540113804746346429,12200160415121876738,19740274219868223167,31940434634990099905,51680708854858323072,83621143489848422977,135301852344706746049,218922995834555169026]; var fib = function (pos) { return Math.round((Math.pow( 1 + Math.sqrt(5), pos) - Math.pow( 1 - Math.sqrt(5), pos)) / (Math.pow(2, pos) * Math.sqrt(5))); }; /* This is only for the test */ var max = test.length, i = 0, frag = document.createDocumentFragment(), _div = document.createElement('div'), _text = document.createTextNode(''), div, text, err, num; for ( ; i < max; i++) { div = _div.cloneNode(); text = _text.cloneNode(); num = fib(i); if (num !== test[i]) { err = i + ' == ' + test[i] + '; got ' + num; div.style.color = 'red'; } text.nodeValue = i + ': ' + num; div.appendChild(text); frag.appendChild(div); } document.body.appendChild(frag);

Si vous utilisez es6

 function fib(n, prev = 0, current = 1) { return !n ? prev + current : fib(--n, current, prev+current) } var f = fib(10)

La ration d'or "phi" ^ n / sqrt (5) est asymptotique pour les fibonacci de n, si nous dépassons cette valeur, nous obtenons effectivement la valeur de la fibonacci.

 function fib(n) { let phi = (1 + Math.sqrt(5))/2; let asymp = Math.pow(phi, n) / Math.sqrt(5); return Math.round(asymp); } fib(1000); // 4.346655768693734e+208 in just 0.62s

Cela s'exerce plus rapidement sur de gros nombres par rapport aux solutions basées sur la récursivité.

Sparkida, a trouvé un problème avec votre méthode. Si vous cochez la position 10, elle renvoie 54 et entraîne l'inexécution de toutes les valeurs ultérieures. Vous pouvez voir ceci apparaître ici: http://jsfiddle.net/createanaccount/cdrgyzdz/5/

 (function() { function fib(n) { var root5 = Math.sqrt(5); var val1 = (1 + root5) / 2; var val2 = 1 - val1; var value = (Math.pow(val1, n) - Math.pow(val2, n)) / root5; return Math.floor(value + 0.5); } for (var i = 0; i < 100; i++) { document.getElementById("sequence").innerHTML += (0 < i ? ", " : "") + fib(i); } }());

 <div id="sequence"> </div>

Vous pouvez obtenir du cache pour accélérer l'algorithme …

 var tools = { fibonacci : function(n) { var cache = {}; // optional seed cache cache[2] = 1; cache[3] = 2; cache[4] = 3; cache[5] = 5; cache[6] = 8; return execute(n); function execute(n) { // special cases 0 or 1 if (n < 2) return n; var a = n - 1; var b = n - 2; if(!cache[a]) cache[a] = execute(a); if(!cache[b]) cache[b] = execute(b); return cache[a] + cache[b]; } } };

 function fib(n) { if (n <= 1) { return n; } else { return fib(n - 1) + fib(n - 2); } } fib(10); // returns 55

J'espère que quelqu'un trouvera le prochain code utile, dans le cadre d'une approche laconique dans JS.

 var fib = function(n) { fib.r = fib.r || [0,1,1]; return fib.r[n] ? fib.r[n] : fib.r[n] = fib(n-1) + fib(n-2); } fib(20); console.log(fib.r); // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]

Ce script prendra un nombre en tant que paramètre, que vous souhaitez que votre séquence Fibonacci soit lancée.

 function calculateFib(num) { var fibArray = []; var counter = 0; if (fibArray.length == 0) { fibArray.push( counter ); counter++ }; fibArray.push(fibArray[fibArray.length - 1] + counter); do { var lastIndex = fibArray[fibArray.length - 1]; var snLastIndex = fibArray[fibArray.length - 2]; if (lastIndex + snLastIndex < num) { fibArray.push(lastIndex + snLastIndex); } } while (lastIndex + snLastIndex < num); return fibArray; };

C'est ce à quoi je suis venu

 //fibonacci numbers //0,1,1,2,3,5,8,13,21,34,55,89 //print out the first ten fibonacci numbers 'use strict'; function printFobonacciNumbers(n) { var firstNumber = 0, secondNumber = 1, fibNumbers = []; if (n <= 0) { return fibNumbers; } if (n === 1) { return fibNumbers.push(firstNumber); } //if we are here,we should have at least two numbers in the array fibNumbers[0] = firstNumber; fibNumbers[1] = secondNumber; for (var i = 2; i <= n; i++) { fibNumbers[i] = fibNumbers[(i - 1)] + fibNumbers[(i - 2)]; } return fibNumbers; } var result = printFobonacciNumbers(10); if (result) { for (var i = 0; i < result.length; i++) { console.log(result[i]); } }

Débutant, pas trop élégant, mais montre les étapes de base et les déductions en JavaScript

 /* Array Four Million Numbers */ var j = []; var x = [1,2]; var even = []; for (var i = 1;i<4000001;i++){ j.push(i); } // Array Even Million i = 1; while (i<4000001){ var k = j[i] + j[i-1]; j[i + 1] = k; if (k < 4000001){ x.push(k); } i++; } var total = 0; for (w in x){ if (x[w] %2 === 0){ even.push(x[w]); } } for (num in even){ total += even[num]; } console.log(x); console.log(even); console.log(total);

Voici des exemples d'écriture de fibonacci à l'aide de la récursivité, du générateur et de la réduction.

 'use strict' //------------- using recursion ------------ function fibonacciRecursion(n) { return (n < 2) ? n : fibonacciRecursion(n - 2) + fibonacciRecursion(n - 1) } // usage for (let i = 0; i < 10; i++) { console.log(fibonacciRecursion(i)) } //-------------- using generator ----------------- function* fibonacciGenerator() { let a = 1, b = 0 while (true) { yield b; [a, b] = [b, a + b] } } // usage const gen = fibonacciGenerator() for (let i = 0; i < 10; i++) { console.log(gen.next().value) } //------------- using reduce --------------------- function fibonacciReduce(n) { return new Array(n).fill(0) .reduce((prev, curr) => ([prev[0], prev[1]] = [prev[1], prev[0] + prev[1]], prev), [0, 1])[0] } // usage for (let i = 0; i < 10; i++) { console.log(fibonacciReduce(i)) }

J'aimerais ajouter un peu plus de code en réponse :), il n'est jamais trop tard pour coder: P

 function fibonacciRecursive(a, b, counter, len) { if (counter <= len) { console.log(a); fibonacciRecursive(b, a + b, counter + 1, len); } } fibonacciRecursive(0, 1, 1, 20);

Résultat

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

 function fibo(count) { //when count is 0, just return if (!count) return; //Push 0 as the first element into an array var fibArr = [0]; //when count is 1, just print and return if (count === 1) { console.log(fibArr); return; } //Now push 1 as the next element to the same array fibArr.push(1); //Start the iteration from 2 to the count for(var i = 2, len = count; i < len; i++) { //Addition of previous and one before previous fibArr.push(fibArr[i-1] + fibArr[i-2]); } //outputs the final fibonacci series console.log(fibArr); }

Tout ce dont nous avons besoin, nous pouvons le donner à la méthode de fibotique ci-dessus et obtenir la série de fibonacci jusqu'au compte.

 fibo(20); //output: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181]

Voici un autre avec un appel approprié.

La fonction de fib interne récursive peut réutiliser la pile car tout est nécessaire (le tableau de nombres) pour produire le prochain numéro est transmis en tant qu'argument, pas d'expressions supplémentaires à évaluer.

Cependant, l'optimisation des appels de queue a été introduite dans ES2015.

Aussi un inconvénient est-il que la longueur du tableau dans chaque itération (mais une seule fois) génère le nombre suivant et obtient les éléments du tableau sur leur index (il est plus rapide que le pop ou l'épissage ou d'autres méthodes de tableau) mais je n'ai pas La performance a été testée dans l'ensemble de la solution.

 var fibonacci = function(len) { var fib = function(seq) { var seqLen = seq.length; if (seqLen === len) { return seq; } else { var curr = seq[seqLen - 1]; var prev = seq[seqLen - 2]; seq[seqLen] = curr + prev; return fib(seq); } } return len < 2 ? [0] : fib([0, 1]); } console.log(fibonacci(100));

Mes 2 cents:

 function fibonacci(num) { return Array.apply(null, Array(num)).reduce(function(acc, curr, idx) { return idx > 2 ? acc.concat(acc[idx-1] + acc[idx-2]) : acc; }, [0, 1, 1]); } console.log(fibonacci(10));

Pour rendre quelque chose de plus humain lisible et réel, voici ma contribution.

Il utilise une fonction * génératrice et une instruction do … while , ici limitée à 1480 itérations, car elle atteint une limite infinie au-delà de cela. Cette fonction * est également très rapide.

Pour d'autres commentaires, consultez la démo codepen ou la démo codepen en français

 function* life() { var life = null, evolution = true while (true) { var now = life life = evolution evolution = now + life yield now }} var harmonics = true, evolution = life() do document.write(evolution.next().value+'\n'), harmonics++ while (harmonics<1480) // (harmonics<Number.POSITIVE_INFINITY)

J'aimerais simplement contribuer avec une version optimisée de la queue par ES6. C'est assez simple;

 var fibonacci = (n, f = 0, s = 1) => n === 0 ? f : fibonacci(--n, s, f + s); console.log(fibonacci(12));

 (function fib(max,i,j) { i = i||this[0];j=j||this[1]; if (max!==0) { this.push(i+j); max--; return fib.bind(this, max, j, i+j)(); } else { return this; } }.bind([0,1], 10))();

Résultat: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Un autre moyen facile d'y parvenir:

 // declare the array starting with the first 2 values of the fibonacci sequence var fibonacci = [0,1]; function listFibonacci() { // starting at array index 1, and push current index + previous index to the array for (var i = 1; i < 10; i++) { fibonacci.push(fibonacci[i] + fibonacci[i - 1]); } console.log(fibonacci); } listFibonacci();

Vous pouvez utiliser la récursivité et mettre en cache les résultats d'une manière fonctionnelle.

 const fibonacci = (n, cache = {1: 1, 2: 1}) => cache[n] || (cache[n] = fibonacci(--n, cache) + fibonacci(--n, cache)); console.log(fibonacci(1000)); console.log(fibonacci(100)); console.log(fibonacci(10));

 function fib(n) { return n < 1 ? 0 : n <= 2 ? 1 : fib(n - 1) + fib(n - 2); } fib(4);

N – est l'indice du nombre de fibanacci

Ce qui se passe est:

  fib(2) = 1 / \ (4-1)=3 -> fib(3) => \ \ \ fib(1) = 1 --- (1+1+1)= 3 (our fib number) 4 => / / (4-2)=2 -> fib(2) => = 1