let arr=[0,1]; let sum=0; for(let i=2;i<4000000;i++) { arr.push(arr[i-1]+arr[i-2]); } for (let i=0;i<arr.length;i++) { if (arr[i]%2==0) { sum+=arr[i]; } } console.log(sum);Al considerar los términos en la sucesión de Fibonacci cuyos valores no superan los cuatro millones, encuentre la suma de los términos de valor par.
Mi solución a esta pregunta es incorrecta y no puedo entender por qué. No tengo tanta experiencia, así que si alguien puede explicar de una manera simple por qué mi código es incorrecto. ¿¿Que puedo hacer para arreglarlo??
Nota: no he incluido el código en esta respuesta porque creo que el punto de lo que estás haciendo es aprender a codificar estas cosas. (Ahora que ha recorrido la mayor parte del camino, agregué una solución al final).
El problema es que sus sumas van rápidamente más allá del rango de lo que puede representar el tipo de número de JavaScript, llegando al punto en que simplemente se representan por Infinity . El tipo de número solo tiene 53 bits significativos efectivos para contener números. Estás excediendo eso:
let seen4M = false; let seenInfinity = false; let arr=[0,1]; let sum=0; for(let i=2;i<4000000;i++) { const num = arr[i-1]+arr[i-2]; if (!seen4M && num > 4_000_000) { console.log(`Too big: ${num}`); seen4M = true; } else if (!seenInfinity && !isFinite(num)) { console.log(`Overflowed just after ${arr[i-1]}`); seenInfinity = true; } arr.push(num); } for (let i=0;i<arr.length;i++) { if (arr[i]%2==0) { sum+=arr[i]; } } console.log(sum);Estás haciendo cuatro millones (menos dos) de bucles, pero la pregunta te pide que consideres los números de Fibonacci cuyos valores son menores o iguales a cuatro millones (4M), que es algo muy diferente y se alcanza mucho más rápido. Entonces, en lugar de (casi) bucles de 4M, deténgase cuando su código determine que el siguiente número es> 4M.
También tenga en cuenta que no hay razón para usar una matriz para esto, y al hacerlo consumirá una gran cantidad de memoria innecesariamente. En su lugar, solo recuerda los valores penúltimo y último, y mézclalos en el ciclo. Mantenga la sum en el primer ciclo en lugar de usar un segundo.
En un comentario mostraste que lo habías resuelto usando una matriz pero que no podías ver cómo resolverlo sin usar una matriz. He aquí cómo hacerlo (ver comentarios):
// The penultimate (second-to-last) Fibonacci number we've done let pen = 0; // The ultimate (last) Fibonacci number we've done let ult = 1; // The sum so far let sum = 0; // A variable for each number as we go let num; // Create the next number and keep looping if it's less than or // equal to four million while ((num = pen + ult) <= 4_000_000) { // We have a new number (`num`), count it if appropriate if (num % 2 == 0) { sum += num; } // Now that we have a new number, shuffle the last two: // our ultimate number is our penultimate number, and // our ultimate number is the new one pen = ult; ult = num; } console.log(sum);