Algoritmos

Project Euler -> Problema 10
Publicado el 14 febrero, 2011por MaritoCares
Finalmente
Ok resulta que a principios de enero me llamaron de una empresa, y ps resulta
que estoy trabajando en vacaciones si Por lo que he tenido bien

pocaso tiempo la verdad…
En los tiempos muertos que tengo, ps decidí seguir con los problemas del
proyecto así que aquí va el Nº 10.
La suma de los números primos por debajo de 10 es: 2 + 3 + 5 + 7 = 17.

Encuentra la suma de todos los primos por debajo de 2 millones.
Como pueden ver, se parece al problema 7 (vamos… es igual ). Así que

dije: ok… cambio el valor por 2e6 y listo… ERROR!! Java estuvo corriendo
por MEDIA HORA (si… esperé todo el rato xD) hasta que finalmente cancelé
el proceso. Mi máquina es relativamente rápida… por lo que esperar hasta que
terminara NO era una opción (recuerden que las respuestas tienen que correr en
un máquina antigua, y en menos de 1 minuto).
En los comentarios del problema 7, Mr. Ignorante me dio el corte necesario para
optimizar el código. Por lo que manos al teclado, logré llegar a la respuesta

El código es el siguiente:
public class Problema10 {

1
public Problema10(){
2
ArrayList<Long> primos = new ArrayList<Long>();
3
Double raizNumero; Long suma;
4
primos.add(2l); primos.add(3l);/*primos.add(5l); primos.add(7l);
5
primos.add(11l); primos.add(13l);*/
6
//aca con trampa... porque uno sabe cual es la suma de los de arri
7
// suma = 41l;
8 suma=5l;
9 while (primos.get(primos.size()-1) <= 2e6){
10 Long numero = primos.get(primos.size()-1)+2;
Boolean esPrimo=false;
11
Boolean salidaOk;
12
while(!esPrimo){
13
salidaOk= true;
14
// System.out.println("Numero a evaluar: "+numero+" {");
15
raizNumero = Math.floor(Math.sqrt(numero));
16
// System.out.print("\tPrimer Corte Control: "+raizNumero+
17
for(Long val: primos){
18 // System.out.print("->"+numero + "/"+val+" ");
19 if (val>raizNumero) {
20 // System.out.print("\n\tEl divisor es mayor a la r
21 break;
}else{
22
if (numero % val == 0) {
23
//ya no es un primo, se aumenta el numero en 2
24
// System.out.print("\n\tNo es primo. Sale del For:
25
salidaOk=false;
26
break;
27
}
28
}
29
}
30 if (!salidaOk) {
31 // salio del For:Each a la fuerza. Aumenta número en 2
numero+=2;
32
}else{
33
// System.out.print("\n\tNúmero primo encontrado: "+num
34
esPrimo=true;
35
}
36
}
37
primos.add(numero);
38
if (numero<2e6) {
39 suma+=numero;
40 }
41 }
42 System.out.println("Suma de los números primos menores a "+2e6+" e
}
43
}
44
45
46
47
48
Eso si, tiene un problema… si se fijan, el while termina con el primo

inmediatamente después del número deseado. En éste caso, termina en el
2.000.003, por lo que en teoría no sirve. El arreglo que le hice, fue preguntar
nuevamente si era menor o no. Y de ésta forma quedo correcto
GENERACIÓN CORRECTA (total time: 4 seconds)
En el PC del trabajo… viejo y lento, osea que la respuesta es aceptable
n mi PC tu solución me tarda 1.367 milisegundos.

Tiene varios problemas, entre ellos la claridad del código, pero también la
eficiencia. Usas Long y Boolean en lugar de los tipos primitivos (long y boolean).
Una versión mejorada tarda 528 milisegundos.
private static final long LIMIT = 2000000;

private static long sum(List values) {
long res = 0l;
for (int i = 0; i < values.size(); i++) {
res += values.get(i);
}
return res;
}
private static boolean esPrimo(int x, List primos){

int i = 1;
int factor;
final int size = primos.size();
boolean prime = true;
while(prime && i x){
i = size;
}else{
prime = x % factor != 0;
}
i++;
}
return prime;
}
private static void mejorado() {

List primos = new ArrayList(10000);
primos.add(2);
int current = 3;
while(current <= LIMIT){
if(esPrimo(current, primos)){
primos.add(current);
}
current +=2;
}
sum(primos);
}
Responder
La última línea debería ser:
System.out.println(“Suma de los números primos menores a ” + LIMIT + ” es: ”

+ sum(primos));
Ejercicio 3 Proyecto Euler

Enunciado:
Los factores primos del número 13195 son 5,7,13 y 29.
¿Cuál es el mayor factor primo del número 600851475143?
Como ya es costumbre empezaremos con un algoritmo de fuerza bruta basado en lo siguiente:

Nos piden encontrar el mayor factor primo de un numero dado, así que pensé en
elaborar una función que determine si un numero es primo y luego de hacer esta evaluación,
evaluar si este número primo es múltiplo del numero dado, de ser así lo voy guardando en una
variable, al final el numero que se encuentre en dicha variable sera el mayor. Veamos...
public class ProyectoEuler3{
public static void main(String[] args){
//Variable para tomar el tiempo en que inicia la ejecución del programa
long inicio = System.currentTimeMillis();
long num = 600851475143L, may = 0; //la variable mayor guardara el mayor múltiplo
//el ciclo va hasta la raíz del numero, según una formula matemática los factores primos no
exceden //la raíz del numero
for(int x=2; x<=Math.sqrt(num); x++){
if(ConsultaPrimo(x)){ //se hace llamado al la función
//si la respuesta al llamado de la función es TRUE, se procede a preguntar si el numero

evaluado (que en este punto se supone primo) es múltiplo del numero 600851475143*/
if(num % x == 0){
if(x > may) may = x; //si es múltiplo se va almacenando en la variable may
} //fin si
} //fin si
} //fin para
//al final el numero que este en la variable may sera el mayor múltiplo
System.out.println("El factor mayor es: " + may);

long fin = System.currentTimeMillis();
System.out.println("Tiempo de ejecucion: " + (fin - inicio) + " ms");
} //fin principal
/*Lo que hace la función es empezar en el primer primo conocido: el 2, e ir hasta la raíz del
numero, si en el
camino se encuentra con que la operación de modulo es igual a cero, pues significa que el
numero NO es primo y se interrumpe la ejecución*/
public static boolean ConsultaPrimo(int i){
for(int y=2; y<=Math.sqrt(i); y++){
if(i % y == 0){
return false;
}//fin si
}//fin para
return true;
}//fin ConsultaPrimo
********************************************************************************************************
Ahora pasemos a una solucion mas practica y elegante que nos evita la necesidad de utilizar
una función...
Num sera el número. F sera el factor, por cada F si es factor de Num entonces
dividimos Num por F (Num/F) antes de pasar a la siguiente F.
Se puede observar (mas fácilmente mediante una prueba de escritorio) que cuando F es factor
de Num, necesariamente sera Primo, como todos los factores mas pequeños ya han sido
removidos entonces al final el resultado sera Num = 1.
El único numero primo que es par es el 2, por lo que la variable factor empieza en 1 y se
incrementa de 2 en 2, por lo que solo tomara números impares, esto ahorra la mitad de las
comparaciones, disminuyendo el tiempo de ejecución.
public class ProyectoEuler3v2{
long num = 600851475143L;
long factor, ult_fac;
//se comprueba si el numero es par, recordemos que el único numero par que es primo es el
2
if(num % 2 == 0){
num = num / 2;
ult_fac = 2;
while(num % 2 == 0){
num = num / 2;
} //fin mientras
} //fin si
factor = 3;
ult_fac = 1;
while(num > 1){
if(num % factor == 0){
num = num / factor;
ult_fac = factor;
while(num % factor == 0){
num = num / factor;
} //fin mientras
} //fin si
factor+= 2; //se incrementa en 2 porque se obvian los pares, se cuentan los impares
} //fin mientras
} //fin si
System.out.println("Factor mayor: " + ult_fac);
Resultado: 6857
Tiempo de ejecución: 1 ms
Como lo he mencionado en los ejercicios anteriores, si cambiamos la cifra inicial por un numero
mucho mas grande, notaremos la diferencia en tiempo de ejecución que ofrece el segundo
ejercicio.
Para los que tienen cuenta en ProjectEuler, podrán ver que una vez ingresen la
respuesta les aparecerá un documento en formato PDF en donde verán este ultimo ejercicio
con una mejora mas, es decir, le realizan una optimización que mejora aun mas el tiempo
de ejecución. Les recomiendo que lean cada uno de los documentos que entrega el
proyecto después de ingresada la solución pues amplia tus conocimientos y son un muy
buen ejercicio mental.
Saludos
Publicadas por ZephyroAlpha a la/s 15:15:00 No hay comentarios.:
Enviar esto por correo electrónicoBlogThis!Compartir en TwitterCompartir en

FacebookCompartir en Pinterest
Etiquetas: Ejercicio 3

Enunciado:
Cada nuevo término en la sucesión de Fibonacci se genera mediante la adición de
los dos términos anteriores. Al comenzar con 1 y 2, los primeros 10 términos serán:
1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...
Considerando los términos en la sucesión de Fibonacci cuyo valor no exceda de cuatro

millones, encuentre la suma de los números pares.
Vamos a dar solución a este ejercicio como lo hicimos con el primer ejercicio, es decir, uno
por fuerza bruta y otro mas depurado.
Lo que se me ocurrió en el primer ejercicio es generar la secuencia Fibonacci y una vez generado
cada termino, evaluarlo para determinar si es par (con MOD de 2), en caso afirmativo, pues
sencillamente se acumula o se van sumando, asi:
/* los primeros dos terminos de la serie son: 1 (ant --> anterior) y 2 (act --
> actual). La variable tg almacenara el Termino Generado que es el resultado
de la suma de ant + act*/
int suma = 2, ant = 1, act = 2, tg = 0;
while(tg <= 4000000){
tg = ant + act;
if(tg % 2 == 0) suma+= tg;
ant = act;
act = tg;
} //fin mientras
System.out.println("La suma de los terminos pares es: " + suma);
*********************************************************************************
El tiempo de ejecución es corto, pero vale la pena resaltar que si se reemplaza el limite de
4000000 por una cifra mas alta, este algoritmo dejara de ser eficiente. La segunda solución se
basa en que cada 3 términos de la serie Fibonacci se genera un número par: 1, 1, 2, 3, 5, 8, 13,
21, 34, 55, 89, 144,... Veamos la solucion:
int suma = 0, ant = 1, act = 1, tg = ant + act;
while(tg < 4000000){
suma += tg;
ant = act + tg;
act = ant + tg;
tg = ant + act;
} //fin mientras
System.out.println("La suma de los terminos pares es: " + suma);
Respuesta: 4613732
Saludos


Enunciado:
Si listamos todos los números naturales por debajo de 10 que son múltiplos de 3 y
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.
Existen muchas maneras de abarcar el ejercicio, realizare 2, una por fuerza bruta y otra mas
depurada. Tal vez la mas común sea recorrer los números desde 3 hasta N (N en este caso es
1000) y realizar una operación de Modulo (donde tomamos el residuo y no el cociente) sobre
cada número por 3 y 5 para determinar si el numero es múltiplo de los números mencionados.
En palabras mas sencillas se divide cada numero (del 3 a N) por 3 y por 5, si su residuo es cero,
significa que es múltiplo y se van acumulando...
El código en java quedaría de esta manera:

/*Con la declaracion de la variable --> inicio, lo que hare es tomar el tiempo
(en milisegundos) en que inicia la ejecucion y mas adelante tomo el fin para
para determinar cuanto se demora la ejecución del programa. Esto sera de
gran utilidad ya que podremos ver como se optimizan los tiempos al aplicar
formulas mas depuradas */

int x, suma = 0;
/*Tomo cada numero (x) y lo opero con MODULO de 3 y 5 para saber si

es multiplo de estos numeros, de ser asi los sumo el la variable suma*/
for(x=3; x<1000; x++){

if((x % 3 == 0) || (x % 5 == 0)) suma += x;
}//fin para
//tomo el tiempo final en la variable ---> fin

System.out.println("El resultado de la suma es: " + suma);
//Le resto a la variable fin la variable inicio para saber el tiempo total en
milisegundos*/
}
Este algoritmo entrega la respuesta inmediatamente ¿pero que pasaría si no fuera hasta
1000 sino hasta 1.000.000 o hasta 10.000.000 o más? La respuesta es simple:
se tardaría mucho más tiempo o en ocasiones provocaría que el computador colapse, por este
motivo la segunda solución es mucho mas elegante y sirve para números mucho mas grandes.
Veamos una solucion mas eficiente.
Antes de leer el código es necesario tener en cuenta lo siguiente: lo que hace el algoritmo es
sumar los múltiplos de 3 y los múltiplos de 5 MENOS los múltiplos de 15
¿porque? porque cuando se suman los múltiplos de 3, el 15 y sus múltiplos van incluidos
o sumados y cuando suma los múltiplos de 5 OTRA VEZ se suma el 15 y
sus múltiplos, así que al final hay que restarlo (recordemos que 15 es múltiplo de 3 y de 5).

System.out.println(SumaDivisiblePor(3) + SumaDivisiblePor(5) -
SumaDivisiblePor(15));

}//fin principal
/*La funcion --> SumaDivisiblePor() suma los números que sean divisibles por
la variable que se envie como parametro (x)*/
public static int SumaDivisiblePor(int x){

int limite = 999;
int n = limite / x;
return x * (n * (n + 1)) /2 ;
}
}
Explicación:
sabemos que para sumar los números de 1 hasta una variable N, utilizamos la siguiente
formula: n * (n + 1) / 2. Ahora:
sumar los múltiplos del 3 al 999 es igual que sumar los números del 3 al 333 y multiplicarlo por
3, así:
3 + 6 + 9 + 12 + ... + 999 = (1 + 2 + 3 + ... + 333) * 3 --> esta es la formula que se utiliza, que
es lo mismo que decir (n * (n + 1) / 2) * 3
el 333 resulta de dividir el limite (en este caso 999, recordemos que son los números DEBAJO
de 1000) por 3 o por 5, según sea el caso.
Resultado: 233168
Saludos

[Ayuda]Factorial suma dígitos
n ! significa n × ( n - 1) × ... × 3 × 2 × 1
Por ejemplo, 10! = 10 × 9 × ... × 3 × 2 × 1 = 3.628.800,

y la suma de los dígitos en el número 10! es 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27.
Encuentra la suma de los dígitos en el número 100!

-----------------------------------------------------------------------------------------
El programa hace las multiplicaciones correctamente, de cualquier numero, el problema es en el
divisor, me explico, antes pongo el código:
Código Java:
Ver original
1. public class FactorialDigito {

2.
3. public static void main(String[] args) {
4.
5. double Resultado = 1;
6. double divisor = 1;
7. long Sumatorio = 0;
8.
9.
10. for(int i =100 ; i >= 1;i--){
11.
12. if(divisor < Resultado){
13. divisor = divisor * 10;
14. }
15. Resultado = i * Resultado;
16.
17. if(divisor > Resultado && i == 1){
18. divisor = divisor / 10;
19. }
20.
21. if(i == 1){
22. for(int x = 0; x == 0;){
23. Sumatorio = (long)(Resultado / divisor)%10+(Sumatorio);
24. divisor = divisor / 10;
25.
26. if(divisor == 1){
27. x = 1;
28. }
29. }
30.
31. }
32.
33. }
34.
35. System.out.println(Sumatorio);
36. }
37.
38. }
A ver el problema esta en la variable DIVISOR, cuando pongo un numero chiquitito(como 20)hace
bien los (*10) pero cuando es un numero muy grande como por ejemplo 100, entonces el Divisor
cuando llega a una cantidad muuuuuy grande, "se vuelve loco" y lo que hace es que se vuelve
negativo.
10 = me da 27, que esta bien

20 = me da 54, tambien bien
30 = me da 157,¿Aquí ya no se si esta bien? (Aqui tambien hace cosas raras y se convierte en
9999999999999999 y luego se pone de nuevo a 1.0000000000000007E39 o lo que sea...)
Nota: No me hagan el código porfavor, prefiero que me ayudes antes que me hagas el código, para
mejorar, gracias.
Que rabia me da
Saludos y muchisimas gracias a los que pierda tiempo en mi

#2 (permalink)
27/02/2015, 10:45
Fecha de Ingreso: noviembre-2014

Mensajes: 34
sixtoex Antigüedad: 3 años
Puntos: 1
Respuesta: [Ayuda]Factorial suma dígitos
Tambien quiero aclarar una cosita:
Modifique esta línea:
Código Java:
Ver original
1. for(int e = 0; e < 99;e++){

2. if(divisor < Resultado){
3. divisor = divisor * 10;
4. }
5.
6.
7. }
Creo que asi ahora esta mejor, por que muchas veces la diferencia era de 2-3 ceros
Aunque sigue fallando en numeros altos como el 100
n ! significa n × ( n - 1) × ... × 3 × 2 × 1
Por ejemplo, 10! = 10 × 9 × ... × 3 × 2 × 1 = 3.628.800,

y la suma de los dígitos en el número 10! es 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27.
Encuentra la suma de los dígitos en el número 100!
Código: Java
1. import java.math.BigInteger;
2. public class prueba
3. {
4. public static void main(You are not allowed to view
links. Register or Login[] args) {
5. int valor = 1;
6. You are not allowed to view links.
Register or Login b1 = new You are not allowed to view links.
Register or Login("1");
7. int NumeroFin = 0;
8. int FinalNumero = 0;
9. You are not allowed to view links. Register or Login
NumeroFinCadena = "";
10. long fin = 100;
Register or Login Sumatorio = new You are not allowed to view
links. Register or Login("1");
Register or Login Contador = new You are not allowed to view
13. for(int i = 1; i <= fin;i++){
14. b1 = b1.multiply(Sumatorio);
15. Sumatorio = Sumatorio.add(Contador);
16. if(i == fin){
Register or Login.out.println(b1);
18. NumeroFinCadena = You are not allowed to view
links. Register or Login.valueOf(b1);
19. FinalNumero =NumeroFinCadena.length();
20.
21. }
22.
23. }
Register or Login b2 = new You are not allowed to view links.
Register or Login Multiplicador = new You are not allowed to
view links. Register or Login("10");
26. int Compara = 0;
27. Compara = b1.compareTo(b2);
28. for(int i = 0 ; i <= fin;i++){
29. for(int x = 0; x <= fin*500;x++){
31. if(Compara == 1){
32.
33. b2 =
b2.multiply(Multiplicador);
34. }
36. if(Compara == -1){
37. b2 =
b2.divide(Multiplicador);
38. }
39. }
Register or Login.out.println(b2);
41. i = (int)fin +1;
42. }
43.
Register or Login bDivide = new You are not allowed to view
45. long GuardarAnterior = 0;
46. long ResultadoEntero = 0;
47. for(int i = 0; i < FinalNumero;i++){
Register or Login Resul = b1.divide(b2);
49. Resul = Resul.mod(bDivide);
50. b2 = b2.divide(bDivide);
51. ResultadoEntero = Resul.longValue();
52. GuardarAnterior = ResultadoEntero +
GuardarAnterior;
53. }
54.
Register or Login.out.println(GuardarAnterior);
56. }
57.
58. }
59.
Bueno, cualquier duda, dímelo

« Última modificación: Marzo 07, 2015, 03:28:22 pm por Expermicid »
En línea
blozzter


Underc0der

 Mensajes: 106
 Actividad:
0%
 Reputación 0

o
o
Re:[Java]Factorial suma dígitos

« Respuesta #1 en: Febrero 28, 2015, 03:21:28 pm »
Creo que en tu código te complicas mucho la vida. Además de estar ilegible sucio.
Procura darle una mirada a las convenciones del lenguaje, qué dice sobre identación, nombre
de variables, nombres de clases, etc.
Te dejo mi código para que tengas una idea.
Código: Java
2.
3. public class SumaFactorial {
4.
5. public static void main(You are not allowed to view links.
Register or Login args[]){
6.
7. int numero = 100;
8.
factorial = calcularFactorial(numero);
10. int suma = sumarDigitos(factorial);
11.
Register or Login.out.println(suma);
13. }
14.
15. static You are not allowed to view links.
Register or Login calcularFactorial(int numero){
16. if (numero == 1)
17. return new You are not allowed to view links.
Register or Login("" +
numero).multiply(calcularFactorial(numero-1));
19. }
20.
21. static int sumarDigitos(You are not allowed to view
links. Register or Login numero){
22. int suma = 0;
23.
24. for (You are not allowed to view links.
Register or Login c : numero.toString().toCharArray())
25. suma += You are not allowed to view links.
Register or Login.parseInt("" + c);
26.
27. return suma;
28. }
29.
30. }
31.
En línea
¡< blozzter >!
hackmin

 Underc0der

 Mensajes: 67
 Actividad:
0%
 Reputación 0

o
Re:[Java]Factorial suma dígitos

« Respuesta #2 en: Febrero 28, 2015, 03:46:12 pm »
You are not allowed to view links. Register or Login
Creo que en tu código te complicas mucho la vida. Además de estar ilegible sucio.
Procura darle una mirada a las convenciones del lenguaje, qué dice sobre identación, nombre de
variables, nombres de clases, etc.
Te dejo mi código para que tengas una idea.
Código: Java
2.
3. public class SumaFactorial {
4.
5. public static void main(You are not allowed to view links.
Register or Login args[]){
6.
7. int numero = 100;
8.
factorial = calcularFactorial(numero);
10. int suma = sumarDigitos(factorial);
11.
Register or Login.out.println(suma);
13. }
14.
15. static You are not allowed to view links.
Register or Login calcularFactorial(int numero){
16. if (numero == 1)
Register or Login("" +
numero).multiply(calcularFactorial(numero-1));
19. }
20.
21. static int sumarDigitos(You are not allowed to view
links. Register or Login numero){
22. int suma = 0;
23.
24. for (You are not allowed to view links.
Register or Login c : numero.toString().toCharArray())
25. suma += You are not allowed to view links.
Register or Login.parseInt("" + c);
26.
27. return suma;
28. }
29.
30. }
31.
xD como que hace 1 semana empece a programar, yo lo veo bien,este si que lo veo bien
¿Cuanto llevas tu?
Creo que es normal

Algoritmos

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Algoritmos

Diunggah oleh

Hak Cipta:

Format Tersedia

Project Euler -> Problema 10

Publicado el 14 febrero, 2011por MaritoCares

Ok resulta que a principios de enero me llamaron de una empresa, y ps resulta

que estoy trabajando en vacaciones si Por lo que he tenido bien

proyecto así que aquí va el Nº 10.

La suma de los números primos por debajo de 10 es: 2 + 3 + 5 + 7 = 17.

Como pueden ver, se parece al problema 7 (vamos… es igual ). Así que

optimizar el código. Por lo que manos al teclado, logré llegar a la respuesta

public class Problema10 {

10 Long numero = primos.get(primos.size()-1)+2;

18 // System.out.print("->"+numero + "/"+val+" ");

20 // System.out.print("\n\tEl divisor es mayor a la r

31 // salio del For:Each a la fuerza. Aumenta número en 2

42 System.out.println("Suma de los números primos menores a "+2e6+" e

Eso si, tiene un problema… si se fijan, el while termina con el primo

nuevamente si era menor o no. Y de ésta forma quedo correcto

GENERACIÓN CORRECTA (total time: 4 seconds)

En el PC del trabajo… viejo y lento, osea que la respuesta es aceptable

n mi PC tu solución me tarda 1.367 milisegundos.

private static final long LIMIT = 2000000;

private static boolean esPrimo(int x, List primos){

private static void mejorado() {

System.out.println(“Suma de los números primos menores a ” + LIMIT + ” es: ”

Ejercicio 3 Proyecto Euler

Los factores primos del número 13195 son 5,7,13 y 29.

¿Cuál es el mayor factor primo del número 600851475143?

Como ya es costumbre empezaremos con un algoritmo de fuerza bruta basado en lo siguiente:

public class ProyectoEuler3{

public static void main(String[] args){

//Variable para tomar el tiempo en que inicia la ejecución del programa

long inicio = System.currentTimeMillis();

for(int x=2; x<=Math.sqrt(num); x++){

if(ConsultaPrimo(x)){ //se hace llamado al la función

//si la respuesta al llamado de la función es TRUE, se procede a preguntar si el numero

if(x > may) may = x; //si es múltiplo se va almacenando en la variable may

System.out.println("El factor mayor es: " + may);

System.out.println("Tiempo de ejecucion: " + (fin - inicio) + " ms");

public static boolean ConsultaPrimo(int i){

for(int y=2; y<=Math.sqrt(i); y++){

public class ProyectoEuler3v2{

public static void main(String[] args){

long inicio = System.currentTimeMillis();

long num = 600851475143L;

long factor, ult_fac;

while(num > 1){

if(num % factor == 0){

num = num / factor;

while(num % factor == 0){

num = num / factor;

long fin = System.currentTimeMillis();

System.out.println("Factor mayor: " + ult_fac);

System.out.println("Tiempo de ejecucion: " + (fin - inicio) + " ms");

Publicadas por ZephyroAlpha a la/s 15:15:00 No hay comentarios.:

Enviar esto por correo electrónicoBlogThis!Compartir en TwitterCompartir en

Ejercicio 2 Proyecto Euler

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

Considerando los términos en la sucesión de Fibonacci cuyo valor no exceda de cuatro

public class ProyectoEuler2{

public static void main(String[] args){

long inicio = System.currentTimeMillis();

int suma = 2, ant = 1, act = 2, tg = 0;

while(tg <= 4000000){

if(tg % 2 == 0) suma+= tg;

long fin = System.currentTimeMillis();