Problema 8 Proyecto Euler

Los cuatro números consecutivos en el siguiente número de 1000 dígitos que tienen el mayor producto son: 9 x 9 x 8 x 9 = 5832.

73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866
70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450

Encuentra los 13 dígitos adyacentes en el número de 1000 dígitos que tienen el mayor producto ¿Cuál es el valor de ese producto?


Solución con Ruby

El resultado se obtiene a través de fuerza bruta con varios métodos que ofrece Ruby para simplificar un poco las cosas. El número en un inicio se trabaja como un string y se va obteniendo un rango de 13 números dentro de él. De ahí se ejecutará el ciclo 987 veces (1000 - 13 para tomar todos las series posibles) y dentro del ciclo se hacen las operaciones. Cada producto resultante de la serie de 13 dígitos, se irá guardando en un array para que finalizado el ciclo, se imprima el valor más grande dentro de este array.

1.- Definimos dos variables que serán las encargadas de ir consiguiendo los 13 dígitos para hacer la operación, una iniciada en 0 y otra en 12 para tomar las posiciones iniciales.


2.- Comienza el ciclo times el cual se ejecutará 987 veces para ir recorriendo las posiciones dentro del número. Se debe iniciar la variable mult en 1 que ocuparemos para ir multiplicando los dígitos dentro de cada serie. content recibirá el valor entre el rango definido entre las variables que se declararon anteriormente content = number[limit1..limit2] al entrar la primera vez al ciclo, del número tomaría sus primeros 3 dígitos. Después, ambas variables de límite se incrementarán en 1 para hacer el recorrido de la posición en la siguiente entrada al ciclo.


3.- En estos momentos, content ya tiene 13 digitos, pero estos están como string, por lo cual, convert recibirá el valor de content pero lo transformará en un entero para poder seguir trabajándolo.


4.- Comienza el ciclo while, el cual, irá descomponiendo el número de 13 dígitos en cada uno de sus números. Mientras convert sea diferente de 0, mood tendrá el residuo de convert / 10,  y será cuando entre la variable mult, la cual irá acumulando la multiplicación de mood * mult. Y finalmente, para conservar el valor de convert sin su último dígito, convert se divide entre 10:

(en la primer posición)

convert = 7316717653133

7316717653133 ¿es diferente de 0? .: entra al while
mood = convert % 10 .: 7316717653133 % 10 .: mood = 3 (el residuo es el último digito)

mult = mult * mood .: 1 * 3 .: mult = 3

convert = convert / 10 .: 7316717653133 / 10 .: convert = 731671765313

Así, cada que entre al ciclo, irá "quitando" el último elemento y lo irá multiplicando por la cuenta actual hasta que convert esté "vacío" y salga del ciclo while.


5.- Dentro de products, el array antes declarado, se guardará la el producto resultante de la serie de 13 digitos en cada uno de los times, lo que resultaría en un array con 987 elementos (los productos de cada una de las series)


6.- Finalmente, al terminar el ciclo times, se imprime el máximo valor dentro del arreglo
puts products.max

Y con esto, se habría encontrado el máximo producto de los 13 digitos adyacentes dentro del número de 1000 dígitos.

Código de Ruby:

                number = \
'73167176531330624919225119674426574742355349194934' \
'96983520312774506326239578318016984801869478851843' \
'85861560789112949495459501737958331952853208805511' \
'12540698747158523863050715693290963295227443043557' \
'66896648950445244523161731856403098711121722383113' \
'62229893423380308135336276614282806444486645238749' \
'30358907296290491560440772390713810515859307960866' \
'70172427121883998797908792274921901699720888093776' \
'65727333001053367881220235421809751254540594752243' \
'52584907711670556013604839586446706324415722155397' \
'53697817977846174064955149290862569321978468622482' \
'83972241375657056057490261407972968652414535100474' \
'82166370484403199890008895243450658541227588666881' \
'16427171479924442928230863465674813919123162824586' \
'17866458359124566529476545682848912883142607690042' \
'24219022671055626321111109370544217506941658960408' \
'07198403850962455444362981230987879927244284909188' \
'84580156166097919133875499200524063689912560717606' \
'05886116467109405077541002256983155200055935729725' \
'7163626956188267042825248360082325753042075296345'

limit1 = 0
limit2 = 12
products = []

987.times do
mult = 1
content = number[limit1..limit2]
limit1 += 1
limit2 += 1

convert = content.to_i

while convert != 0 do
mood = convert % 10
mult *= mood
convert /= 10
end
products << mult
end

puts products.max

Problema 7 Proyecto Euler

Problema 7:

Enumerando los primeros seis números primos: 2, 3, 5, 7, 11 y 13, podemos ver que el 6to primo es 13.

¿Cuál es el 10,001o número primo?

Solución a partir de un ciclo for y while:

1.- Se declaran las variables necesarias, una bandera de tipo boolean que definirá si es o no un número primo, y dos de tipo entero que generarán la serie de números (primo) y divisor para el número por el que se dividirá primo.

2.- Comienza un ciclo for, donde se introduce la variable posicion, que será la responsable de ir almacenando la posición del número primo, se limita al ciclo hasta que posicion alcance el valor buscado de 10,001 y la variable primo irá aumentando en 1 en cada ciclo.

3.- Al estar en el ciclo, bandera cambiará a true y divisior tomará el valor de dos, cada vez que entre al ciclo, ejecutará estas dos acciones para poder validar correctamente el while e if que se declaran después.

4.- Inicia ciclo while, el cuál se mantendrá mientras divisor sea menor a la división de primo entre 2, con el fin de reducir divisiones en el proceso, ya que si divisor a alcanzado en valor a la mitad de primo, no tiene caso seguir ejecutando más divisiones mayores, se podrá definir si es o no primo de inmediato, según sea el caso, junto con la segunda condición del while, que se mantendrá mientras también bandera siga siendo verdadera.

5.- Se complementa el while con una condición if, que determina que si el residuo de primo entre divisor es 0, bandera que colocará en false para salir del while. Fuera de esta condición, bandera irá incrementando en 1 en cada ciclo que vaya procesando en el while.

Ejemplo con el número 5:

primo = 5
divisor = 2
mitad = 2
bandera = true

while: ¿2 es menor o igual a  2 y bandera es true?
Sí .: Entra en la condición IF .: ¿5%2==0?
No .: divisor++ .: divisor = 3

while: ¿3 es menor o igual a  2 y bandera es true?
No .: termina el ciclo, valida el siguiente if, posicion aumenta en 1, valida si ha llegado al 1001, y si es así, imprime resultado, si no. entra el ciclo for.


6.-  Al salir del while, se añade una condición if que validará el estado de bandera, si éste aún está en true, entonces sabemos que el número es primo (como en el caso anterior de 5) porque solo se modificó la variable divisor y la variable bandera jamás cambió, y dentro de este if, posicion aumentará en 1 cada vez que se encuentre un primo, después se añadirá un 2do if para determinar si posicion ha alcanzado la posición que buscamos (10001), de ser así, se imprimirá entonces el número primo correspondiente:


Ejemplo con un número no primo:

primo = 9
divisor = 2
mitad = 4
bandera = true

while: ¿2 es menor o igual a  4 y bandera es true?
Sí .: Entra en la condición IF .: ¿9%2==0?
No .: divisor++ .: divisor = 3

while: ¿3 es menor o igual a  4 y bandera es true?
Sí .: Entra en la condición IF .: ¿9%3==0?
Si .: bandera = false  y divisor++ .: divisor = 3

while: ¿4 es menor o igual a  4 y bandera es true?
No .: Sale del while

if: ¿bandera es true?
No .: Ciclo for aumenta a primo a 10.



Código JAVA:

public class problemasiete {

    public static void main(String[] args) {

        boolean bandera;
        int divisor, primo=2;

        for (int posicion=0; posicion < 10001; primo++) {
            bandera = true;
            divisor = 2;
         
            while(divisor <= primo/2 && bandera==true) {
                if (primo % divisor == 0) {
                    bandera = false;
                }
                divisor++;
            }

            if (bandera) {
                posicion++;
                if (posicion == 10001){
                    System.out.println("El número primo " + posicion + " es " + primo);
                }
            }
        }
    }
}

Problema 9 Proyecto Euler

Problema 9:

Una terna de pitagórica es un conjunto de tres números naturales, a < b < c , para el cual:

a ² + b ² = c ²

Por ejemplo, 3 ² + 4 ² = 9 + 16 = 25 = 5 ² 

Existe exactamente una terna de pitagórica para la que a + b + c = 1000.
Encuentra el producto ABC .

Solución a partir de un ciclo for y while:

Otro caso, en el que entender el problema fue otro reto más a parte de solucionarlo, obvio por mi falta de comprensión en la lógica estipulada...

Posiblemente, lo mejor era seguir la fórmula para determinan a,b,c, pero en su defecto, creé lo primero que vino a mi mente: 3 contadores.


1.- Se declara una variable boolean (bandera) en false y que se activará en cuanto haya encontrado el resultado.

2.- Inician los ciclos for, primero será para c, cuyo máximo valor podría ser 997, esto, para cumplir con la regla de que a debe ser menor que b, y a su vez, b debe ser menor que c, por lo cual, el máximo número del 1-1000 podría ser 997 (recordando que la suma de las 3 variables debe ser 1,000). Después inicia b, que siguiendo con la condición citada, el máximo número que podría tener sería de 499. Finalmente, sería para a mientras sea menor que 332. En cada uno de los ciclos, también se añade la restricción de que se mantendrán mientras bandera siga en false.

Nota:
Las variables son acomodadas en este orden para agilizar el recorrido de los ciclos, ya que en primer caso, recorrería la variable que tiene un número máximo más bajo.

3.- Una vez dentro de los ciclos inicia la condición, si la suma de las tres variables es igual a 1,000, entrará en una segunda condición (ya que puede darse el caso, de que esta combinación, aunque su suma sea igual a mil, no sea el de la terna buscada), si el cuadrado de a más el cuadrado de b es igual al cuadrado de c, sabemos que encontramos la terna pitagórica, bandera cambiará a true para terminar con los ciclos, se imprimirán a,b,c con sus valores finales, y se imprimirá directamente la multiplicación de las 3 variables.


Código JAVA:

public class problemanueve {

    public static void main(String[] args) {

        boolean bandera=false;

        for (int c=1; c<997 && !bandera; c++) {
            for (int b = 1; b<499 && !bandera; b++){
                for (int a = 1; a<332 && !bandera; a++){
                    if (a+b+c == 1000){
                        if (a*a + b*b == c*c){
                        bandera = true;
                        System.out.println("a=" + a + " b=" + b + " c=" + c);
                        System.out.println("El producto es: " + (a*b*c));
                        }
                    }
                }
            }
        }
     
    }
}

Problema 5 y 6 Proyecto Euler

Problema 5:

2520 es el número más pequeño que se puede dividir entre cada uno de los números del 1 al 10, sin ningún resto.

¿Cuál es el número positivo más pequeño que es divisible entre todos los números del 1 al 20?

Solución a partir de un ciclo for y un while:

1.- Se declaran dos variables, la primera (bandera) será tipo boolean iniciando en falso, y la segunda (i)será la que genere la serie del 2 - 20 (todos los números son divisibles entre 1, así que ahorramos esta división).

2.- Comienza ciclo for con la variable inicial, la cual tiene un valor de 2520 porque sabemos que es el primer número divisible entre 1-10, sería innecesario dividir entre números más bajos. Mientras bandera siga en falso se irá aumentando la variable inicial.

3.- El primer paso al entrar al ciclo es igualar la variable i en 2, que será el primer valor por el cual se dividirá.

4.- Inicia ciclo while, y se mantendrá mientras el residuo sea cero al dividir inicial entre i. La variable i irá aumentando en 1 mientras se cumpla la condición del residuo, y se pone un if para evaluar el valor de i, si éste es igual a 20, entonces bandera cambiará a verdadero e imprimirá inicial, siendo nuestro valor más pequeño divisible entre los números del 1-20. Al haber cambiado bandera, el ciclo for ser corta y termina la ejecución.


Código JAVA:

public class problemacinco {

    public static void main(String[] args) {

        boolean bandera = false;
        int i;
     
        for (long inicial = 2520l; !bandera; inicial++) {
            i=2;
            while(inicial%i==0){
                i++;
                if (i == 20){
                    bandera = true;
                    System.out.println("El valor más pequeño es: " + inicial);
                }
            }
        }
    }
}





Problema 6:

La suma de los cuadrados de los primeros diez números naturales es:

1 ² + 2 ² + ... + 10 ² = 385

El cuadrado de la suma de los primeros diez números naturales es:

(1 + 2 + ... + 10) ² = 55 ² = 3,025

Por lo tanto la diferencia entre la suma de los cuadrados de los primeros diez números naturales y el cuadrado de la suma es 3025 - 385 = 2640.

Encuentra la diferencia entre la suma de los cuadrados de los primeros cien números naturales y el cuadrado de la suma.

Solución a partir de dos ciclos for y while:


1.- Se declaran las dos variables que guardarán el valor buscado, suma para la suma de los cuadrados y cuadrado para el cuadrado de la suma.

2.- Ciclo for que desplegará la serie del 1-10.

3.- Se guarda en suma el cuadrado del valor de la iteración, multiplicando el valor actual de serie por sí mismo, y sumando el valor actual de suma. La variable cuadrado irá almacenando la suma de serie, tomando el valor actual de serie más el valor actual de cuadrado.

4.- Al terminar el ciclo, se imprimen en pantalla los resultados, primero se muestra el valor final obtenido de suma. Después, se muestra el resultado de cuadrado (suma de todos los valores del 1-100) multiplicado por sí mismo (5050 * 5050). Finalmente, muestra la operación anterior pero añadiendo la resta del valor de suma para hallar la respuesta.


Código JAVA:

public class problemaseis {
    public static void main(String[] args) {
        int suma=0, cuadrado=0;
        for (int serie = 1; serie <= 100; serie++ ) {
            suma = serie * serie + suma;
            cuadrado = serie + cuadrado;
        }
        System.out.println("La suma de los cuadrados es: " + suma);
        System.out.println("La suma de los cuadrados es: " + (cuadrado*cuadrado));
        System.out.println("La diferencia es: " + ((cuadrado*cuadrado)-suma));
    }
}

Problema 3 y 4 Proyecto Euler

Problema 3:

Los factores primos de 13195 son 5, 7, 13 y 29.

¿Cuál es el factor primo más grande del número 600,851,475,143?

Solución a partir de un ciclo for y while:

1.- Se declaran las variables necesarias, incluyendo una de tipo long (variable numero) debido al número muy grande a manejar, por lo cual, al final de dicha cifra se coloca la letra L.

2.- Se inicia el ciclo for que será el responsable de producir los número por los cuales iremos dividiendo(variable factor) nuestra variable numero, con la condición de que este contador sea menor o igual al número original.

3.- El ciclo while se inicia mostrando la condición de que mientras numero sea divisible entre el factor producido por el contador, seguirá usando este valor para seguir dividiendo, hasta que el número no sea divisible, saldrá del ciclo para aumentar el contador hasta encontrar un número divisible entre el valor actual de la variable numero.
Esto nos estaría reduciendo líneas de código y evitando crear un algoritmo más para determinar qué número son primos y cuales no y después dividir entre estos. Simplemente pintamos una lista común del 2 a N, mientras sea divisible entre 2, lo seguirá usando, y de está manera, eliminamos de la lista todos los número pares, al ya no ser divisible entre 2, se aumentará a 3 el contador y ahora, no saldrá de este ciclo mientras el residuo de igual manera siga siendo de 0 y así con todos los demás números.

4.- Se efectúa la operación en que la variable numero tomará el valor de dividir numero entre factor, usando el valor actual de factor que haya sido generado por el contador y que este siga siendo divisible entre el valor actual de numero (lo explicado en el punto anterior).

5.- Se puede terminar el problema agregando la LÍNEA OPCIONAL, la cual, iría imprimiendo todo el proceso de las divisiones que vaya generando, pudiendo ver el último número generado para saber el resultado, y de esta manera, se eliminaría la variable bandera y la impresión de la misma. Pero si se desea que lo único que se entregue es el resultado que nos interesa (el factor primo más grande), completaremos agregando la variable bandera que esta recibirá el valor de factor y al salir del ciclo for la imprimirá, esto, debido a que en la forma que se creó el contador, irá del número más pequeño divisible (2) hasta el más grande que encuentre, por lo tanto, la variable bandera irá guardando cada factor primo y simplemente se quedará con el último valor arrojado por la última división.

Nota:
Si solo se imprimiera la variable factor en lugar de bandera, aún volvería a entrar al ciclo, por lo cual, el valor se vería afectado aumentando en 1, es por eso que se usó la variable bandera.


Código JAVA:

public class problematres {
    public static void main (String[] args){
     
        long numero = 600851475143l;
        int factor, bandera= 0;

        for(factor=2; factor<=numero; factor++) {
            while (numero%factor==0){
                System.out.println(numero + " | " + factor); //LÍNEA OPCIONAL
                numero/=factor;
             
                bandera = factor;
            }
        }
        System.out.println("el factor más grande es: " + bandera);
    }
}




Código RUBY:

En Ruby tuve que modificar un poco el código, debido a que no sé qué tipo de magia negra estaba escribiendo, que no salía del ciclo for, es decir, al llegar al último factor, se quedaba estancado y no mostraba la impresión del factor, así que después use ese if para compararlo y si número y factor son iguales, quiere decir que llegó al máximo y lo imprime. (Mientras descubro por qué no corre de la otra manera)

numero = 600851475143
bandera = 0

for factor in(2..numero)
if numero == factor
  bandera = factor
  puts "El número más grande es: #{bandera}"
  break
end

while numero%factor == 0 do
numero/=factor
end
end



Problema 4:

Un número palíndromo se lee igual en ambos sentidos. El número más grande formado por la multiplicación de 2 números de 2 dígitos es 9009 = 91 x 99.

Encuentra el palíndromo más grande hecho por la multiplicación de 2 números de 3 dígitos.

Solución a partir de dos ciclos for y while:

Hasta ahora, el problema que más me he demorado, ya que quise resolverlo con total fuerza bruta (muy bruta) y sin recurrir a librerías para automatizar o usar un string para transformar los valores en cadenas. Simplemente a través de comparaciones y ciclos.

Sí, la idea es después mejorarlo para simplificar el código, agilizar el proceso etc, etc, etc...
(Como siempre, se aceptan contribuciones =} )

1.- Se declaran las variables a ocupar como tipo long debido a los valores que manejaremos, inicial nos servirá como valor de la multiplicación, comparacion será al que aplicaremos el algoritmo de palíndromo, reverso será la variable inicial invertida, y las variables temp y mayor nos ayudarán a definir el palíndromo de mayor valor.

2.- Inician dos ciclos for, uno dentro del otro, esto permite crear los valores de 3 cifras a multiplicar, las variables van en decremento, con el fin de mejorar el código comenzando con los números más grandes y así encontrar más rápido el mayor palíndromo sin tener que multiplicar todos los valores (por ahora no implementado y hace la multiplicación total). Lo que estaría generando, es una multiplicación del primer valor de i por todos los valores de j, es decir 999 x 999 | 999 x 998 | 999 x 997 ...

3.- La variable inicial hace la operación antes mencionada, luego, la variable comparacion toma el valor de inicial y se asigna el valor de 0 para poder usar la variable reverso.

4.- Comienza el ciclo while con la condición de que mientras comparacion sea mayor que 0, seguirá dividiéndose para encontrar su valor invertido, es por eso que se creó esta variable comparacion, debido a que al final del ciclo, tendrá un valor de 0, y es importarte guardar el valor original (contenido en inicial) para poder compararlo.

5.- La variable reverso tendrá como resultado su valor actual por 10, más el residuo de comparacion entre 10, y comparacion después tendrá el valor de dividirse a sí misma entre diez. De esta manera, se irá "quitando" el último número de la variable comparacion y se irá agregando al lado de reverso de izquierda a derecha. El ejemplo sería así tomando en cuenta los valores iniciales.

inicial = 1234

reverso = 0 * 10 + 1234%10 = 0 + 4 = 4
comparacion = 1234 / 10

.:
reverso = 4
comparacion = 123

-------

reverso = 4 * 10 + 123%10 = 40 + 3 = 43
comparacion = 12

.:
reverso = 43
comparacion = 12


Así sucesivamente.


6.- Se hacen las dos condiciones que darán el resultado buscado. El primer if comparará el valor resultante de la variable comparacion con el de inicial, si ambos son iguales, entonces sabemos que es un palíndromo, así que entrará el segundo if que comparará el valor de temp con inicial. Si temp es mayor, la variable mayor tomará su valor, caso contrario, la variable mayor tomará el valor de inicial y también la variable temp tomará ese valor, así iría comparando y solo guardando el valor más alto, para finalmente imprimirla al salir de los ciclos for.


Código JAVA:

public class problemacuatro {
    public static void main(String[] args) {

        long inicial, comparacion, reverso, temp = 0, mayor = 0;

        for (int i = 999; i >= 100; i--) {
            for (int j = 999; j >= 100; j--) {

                inicial = i * j;
                comparacion = inicial;
                reverso = 0;

                while (comparacion > 0) {
                    reverso = reverso * 10 + comparacion % 10;
                    comparacion /= 10;
                }

                if (inicial == reverso) {
                    if (temp > inicial) {
                        mayor = temp;
                    } else {
                        mayor = inicial;
                        temp = inicial;
                    }
                }
            }
        }
        System.out.println("El mayor palíndormo es: " + mayor);
    }
}



Código RUBY:

Usando dos upto para generar los números, luego la variable pal para hacer la operación, y finalmente, usando las noblezas de Ruby (aunque me parece que en java podría hacerse lo mismo, pero obvio son inútil y ahí no pude) se guardan los resultados en un arreglo y después el método max es encargado de recoger el valor más alto dentro del arreglo:



mayor = 0

100.upto(999){ |numero1|
100.upto(999){ |numero2|

pal = numero1 * numero2

if pal.to_s == pal.to_s.reverse
mayor = [mayor, pal].max
end
}
}

puts mayor

Problemas 1 y 2 Proyecto Euler

Problema 1:

Si una lista de todos los números naturales por debajo de 10, que son múltiplos de 3 o 5, obtenemos 3, 5, 6 y 9. La suma de estos múltiplos es 23.

Encuentra la suma de todos los múltiplos de 3 o 5 por debajo de 1,000.


Solución a partir de un ciclo for:

1.- Se inicia un contador en 1 con un límite hasta 1000.

2.- Se crea una condición, en donde el contador se dividirá entre 3 o(||) 5  y si el residuo (%) es igual a cero, se procede a la operación

3.- La operación consiste en una suma, donde la variable de contador se le sumará el valor actual(variable suma) dando cómo sintaxis normal: suma=suma+contador pero se han usado los operadores de asignación compuestos para reducir el código dando como resultado suma+=contador.



Operadores de Asignación Compuestos:

OPERADOR	EQUIVALENCIA
a += b	a = a + b
a -= b	a = a - b
a *= b	a = a * b
a /= b	a = a / b

Código JAVA:

public class ProblemaUno {

    public static void main (String[] args){
     
        int suma=0;
        for(int contador = 1; contador<1000; contador++) {
            if(contador%3==0 || contador%5==0){
            suma+=contador;
            }
        }
        System.out.println("Sumatoria total: " + suma);
    }
}




Código RUBY:

Usando el método upto se puede llegar al mismo resultado, de igual manera, podría hacerse con un each usando rangos, e igual que en JAVA con un for:

suma = 0

1.upto(1000) do |numero|
if numero%3 == 0 or numero%5 == 0
suma += numero
end
end

puts "La suma total es: #{suma}"


(Aunque la filosofía en Ruby sería usarlo como un objeto, pero ahora no hablamos de un tutorial de Ruby para crear nuestra clase, definir el método, crear el objeto, etc etc...)







Problema 2:

Cada nuevo término en la serie de Fibonacci se genera por la suma de los dos términos anteriores. Al comenzar con 1 y 2, los primeros 10 términos serán los siguientes:

1,2,3,5,8,13,21,34,55,89

Al considerar los términos de la sucesión de Fibonacci cuyos valores no superan los cuatro millones, hallar la suma de los términos pares.


Solución a partir de un ciclo while:

1.- Lo primero que podría considerarse para llegar a la solución, sería encontrar el algoritmo para recrear la serie de Fibonacci, para esto, se crearían 2 variables, una iniciando en 0(anterior) y otra en 1(fibo), las cuales nos ayudarían a definir la posición actual de la serie y la posición anterior.

2.- Sabemos que el rango a cubrir, debe ser menor a 4,000,000 por lo cual, se usará un while para crear el ciclo que se irá repitiendo hasta cumplir su condición en que la variable fibo no exceda el valor antes citado.

3.- Dentro del ciclo, arrancan 2 operaciones para ir alterando a al variable fibo, la primera calcularía la posición anterior, usando el valor actual de fibo para restar el valor actual de la variable anterior. Después entraría una nueva, donde la variable fibo se le añadiría el valor de la variable anterior, y esto nos generaría la serie de Fibonacci.

4.- Se incluye una condición similar al problema anterior, cambiando ahora los valores de la división a 2 para separar solo los términos pares, y si la condición se cumple, genera la operación de calcular la variable suma, a partir del valor actual de la variable fibo y de variable suma (que podría considerarse como el valor que tenía la serie, en la posición anterior)



Código JAVA:

public class ProblemaDos {
    public static void main (String[] args){
     
        int anterior =0;
        int fibo=1;
        int suma = 0;
     
        while(fibo<4000000) {
         
            anterior = fibo-anterior;
            fibo += anterior;
         
            if(fibo%2==0){
                suma += fibo;
            }
        }
        System.out.println("La suma es: " +suma);
    }
}




Código RUBY:


fibo = 1
anterior = 0
suma = 0

while fibo < 4000000

if fibo%2 == 0
suma += fibo
end

anterior = fibo - anterior
fibo += anterior
end

puts "La suma total es: #{suma}"