Java - numeros primos

 
Vista:
Imágen de perfil de Fernando
Val: 18
Ha disminuido su posición en 2 puestos en Java (en relación al último mes)
Gráfica de Java

numeros primos

Publicado por Fernando (26 intervenciones) el 11/06/2014 18:14:19
Hola, resulta que estoy estudiando java, me dieron un ejercicio, donde me piden que ingrese un numero y que la aplicacion me diga si es primo o no.

Esto es el codigo que tengo hasta ahora:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void main(String[] args) {
        // TODO code application logic here
        int numero;
        int contador=2;
        numero =Integer.parseInt(JOptionPane.showInputDialog("Ingrese numero"));
 
        while (numero % contador != 0 && contador<numero)
         {   contador++;
             JOptionPane.showMessageDialog(null,"es primo");
         }
 
 
    }
 
}

Mi codigo tiene un problema (o varios). Por ejemplo, si ingreso el numero 5 (que es primo), el sistema me devuelve un cuadro diciendo que es primo pero esto me lo repite 4 veces, y yo solo quiero que solamente me salga una vez.

Si ingreso un numero que no es primo por ejemplo, el 6, no me aparece nada.

Que me está faltando?

Saludos
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Carlos
Val: 75
Ha aumentado 1 puesto en Java (en relación al último mes)
Gráfica de Java

numeros primos

Publicado por Carlos (31 intervenciones) el 12/06/2014 02:48:56
Esta es la solucion, un numero primo solo es dividido por el 1 y el mismo.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public static void main(String[] args)
{ // TODO code application logic here 
int numero,x;
int contador=0;
x=1;
numero =Integer.parseInt(JOptionPane.showInputDialog("Ingrese numero"));
while (x<=numero)
{
if(numero % x==0) contador++;
x++;
 
 }
if(contador==2)
JOptionPane.showMessageDialog(null,"es primo");
else
JOptionPane.showMessageDialog(null," no es primo");
 }
 }

Saludos
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
2
Comentar
Imágen de perfil de fernando143
Val: 18
Ha disminuido su posición en 2 puestos en Java (en relación al último mes)
Gráfica de Java

numeros primos

Publicado por fernando143 (26 intervenciones) el 12/06/2014 03:43:43
Hola, gracias por el código, pero me podrías decir como es el funcionamiento? es decir, el proceso lógico que usaste.

x=1; ¿Es el divisor?
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Carlos
Val: 75
Ha aumentado 1 puesto en Java (en relación al último mes)
Gráfica de Java

numeros primos

Publicado por Carlos (31 intervenciones) el 13/06/2014 21:01:15
Por concepto un numero primo es divisible por el 1 y el mismo, en el programa x genera sus posibles divisores, en el if verifico si es su divisor, es su divisor si el residuo da 0, cuento cuantas veces fu dividido por el valor de x, si esprimo c se incrementa a 2.

Saludos
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de sandro makaviel
Val: 392
Bronce
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

numeros primos

Publicado por sandro makaviel (166 intervenciones) el 14/06/2014 03:09:12
Esta bien tu código, pero no es optimo, ya que se estamos hablando de numero grande, extremadamente grande. sigue haciendo las divisiones aun cuando detecta que no es primo. Si en el mismo while le pondrías una condición de verificación de que el contador ya es mayor a 2, termine. Sin hacer el resto de las divisiones.

while (x<=numero && contador<=2)


saludos
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de fernando143
Val: 18
Ha disminuido su posición en 2 puestos en Java (en relación al último mes)
Gráfica de Java

numeros primos

Publicado por fernando143 (26 intervenciones) el 14/06/2014 15:08:36
Si, pero por ejemplo, el 15 no es primo, y no es divisible por 2, por lo que si el contador solo hace la division por 1 y por 2, el programa me va a dar que es primo, pero como el 15 es divisible por 3 entonces no es primo,
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Carlos
Val: 75
Ha aumentado 1 puesto en Java (en relación al último mes)
Gráfica de Java

numeros primos

Publicado por Carlos (31 intervenciones) el 15/06/2014 05:55:36
Pongale un breaak dentro del bucle si deseas que no continue y listo...
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

numeros primos

Publicado por celia (1 intervención) el 30/10/2017 16:06:18
ayudaaa!!! .. me pidieron que resuelva el ejercicio en java .. ingresado un numero me muestre la cantidad de numeros primos.. ejemplo
ingreso 4.
que me muestre 1,2,3,5.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

numeros primos

Publicado por Krlos Kastro (4 intervenciones) el 31/10/2017 00:33:38
Esta es:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public static void main(String[] args) {
        int num,d,c,x,y;
        Scanner leer=new Scanner(System.in);
        System.out.println("Ingrese numero entero:");
        num=leer.nextInt();
        d=1; x=1;
        System.out.println(x);
        while(d<num){
            c=0;
            y=1;
            while(y<=x){
                if(x % y==0){
                    c=c+1;
                }
                y=y+1;
            }
            if(c==2){
                System.out.println(x);
                d=d+1;
            }
 
            x=x+1;
 
        }
    }
 
}

Saludos

Visita a: https://www.facebook.com/cgcastroprognet/
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

numeros primos

Publicado por vivi (1 intervención) el 12/11/2018 12:51:08
Hola buenos Dias! despues de 5 dias al fin di un el codigo como yo queria, asi se hace!!!
te Felicito me reee sirvio tu codigo.... Excelente.
Saludos Vivi
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Sandro
Val: 392
Bronce
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

numeros primos

Publicado por Sandro (166 intervenciones) el 01/08/2019 05:10:31
este es la mas concentrado posible asi

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
// Ingresar un número y determinar si es primo o no - Cisco Bautista
import	java.util.Scanner																;
 
public	class	primos																	{
 
	public	static	void	main					(	String	[]
																args				)	{
		System
			.out
			.println								(	"\nBienvenidos a este programa");
		System
			.out
			.println								(	" Ingrese un número:		")	;
		long		num								=	lee_Teclado.obtiene_Datos
													(		1l						)	;
		if	(	verifica							(	num							))
			System
				.out
				.println							(	"\n El numero "
													+			num
													+			" es primo		")	;
		else
			System
				.out
				.println							(	"\n El numero "
													+			num
													+			" no es primo	")	;
	}
 
	public	static	boolean	verifica				(	long
																num					)	{
		int		cont								=	0								;
		boolean		es								=	true							;
		for	(	int		i							=	1							;
						i							<=	num							;
						i							++								)	{
			System
				.out
				.println							(	"ha pasado:"
													+		i						)	;
			if	((	num		%	i			)		==	0							)
				cont								++									;
			if	(	cont							>	2							)	{
				es									=	false							;
				break																	;
			}
		}
		return		es																	;
	}
}

tomando en cuanta, que cuando dividió mas de dos veces con residuo cero se sale del for.

Falta optimizarlo sin hacer división alguna, cuando el ultimo dígito de la cantidad proporcionada, es par o cinco no hacer nada, a menos de que se ingrese un solo dígito, ya que el dos y cinco son primos, de ahi en fuera todos los demás no son primos, por lógica. no debe hacerse división alguna.

ingrese al azar estos dígitos 1231321645645646543 lleva mas de 3 horas dividiendo, debe haber una forma mas dinámica de identificar sin tanta división que es primo

1
van 720 millones de vueltas y no termina
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Rodrigo
Val: 2.041
Plata
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

numeros primos

Publicado por Rodrigo (623 intervenciones) el 01/08/2019 13:15:09
No necesitas dividir por 1 o por el numero, pues estas divisiones sabes que dara resto 0. Si cualquiera de las otras divisiones es 0, puedes deterner tu ciclo, pues ese numero ya no es primo.
No es necesario dividir por todos los numeros, divide por 2, por 3 y de ahi en adelante, divide solo por los numeros impares.
No es necesario dividir por numeros mayores que la raiz cuadrada del numero.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Sandro
Val: 392
Bronce
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

numeros primos

Publicado por Sandro (166 intervenciones) el 01/08/2019 15:06:47
aun no termina lleva 1 mil 949 millones 974 mil 629 vueltas

Imagínense que todas esas vueltas serian para un numero primo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
// Ingresar un número y determinar si es primo o no - Cisco Bautista
import	java.util.Date																	;
 
public	class	primos																	{
 
	public	static	void	main					(	String	[]
																args				)	{
		Date		fechaInicio						=	fechas
															.dame
													(								)	;
		System
			.out
			.println								(	"\nBienvenidos a este programa");
		System
			.out
			.println								(	" Ingrese un número:		")	;
		long		num								=	lee_Teclado
															.obtiene_Datos
													(		1l						)	;
		if	(	verifica							(	num							))
			System
				.out
				.println							(	"\n El numero "
													+			num
													+			" es primo		")	;
		else
			System
				.out
				.println							(	"\n El numero "
													+			num
													+			" no es primo	")	;
		Date		fechaFin						=	fechas
															.dame
													(								)	;
		String	salida								=	segundosXHoras
															.detecta
													(		segundosXHoras
															.convierte
													(		fechas
															.diferencia
													(		fechaInicio				,
															fechaFin				)))	;
		System
			.out
			.println								(	"El tiempo llevado en esta o"
													+	"peracion:					"
													+		salida					)	;
	}
 
	public	static	boolean	verifica				(	long
																num					)	{
		if	(	terminacion							(	num							))	{
			int		size							=	convert
															.longToString
													(		num						)
															.length
													(								)	;
			if	(	size							==	1							)
				return		true														;
		}	else
			return		false															;
		int		cont								=	0								;
		boolean		es								=	true							;
		for	(	int		i							=	1							;
						i							<=	num							;
						i							++								)	{
			System
				.out
				.println							(	"ha pasado:"
													+		i						)	;
			if	((	num		%	i			)		==	0							)
				cont								++									;
			if	(	cont							>	2							)	{
				es									=	false							;
				break																	;
			}
		}
		return		es																	;
	}
 
	public	static	boolean	terminacion				(	long
																num					)	{
		char	[]	tmp								=	convert
															.stringToChar
													(		convert
															.longToString
													(			num					))	;
		int		size								=	tmp.length						;
		if	(	size								==	1							)
			switch	(	tmp	[ 0 ]													)	{
				case	'2'							:
				case	'3'							:
				case	'5'							:
				case	'7'							:
					break																;
				default								:
					return		false													;
			}
		else	if	(	size						>	1							)
			switch	(	tmp	[ size	-	1 ]											)	{
				case	'0'							:
				case	'2'							:
				case	'4'							:
				case	'5'							:
				case	'6'							:
				case	'8'							:
					return		false													;
			}
		return		true																;
	}
}

Sabiendo todas las facilidades de java, para que buscar y hacer cosas duplicadas siempre en los programas, yo tengo muchos programas sencillo, como convertir a cualquier cosas inclusive octal, ejemplo del programa convertidor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
class	convert																				{
	public	static	int		binaryToInt					(	String
																	numeric				)	{
		int		binaryToInt								=	Integer.parseInt
														(		numeric					,
																	2					)	;
		return		binaryToInt																;
	}
 
	public	static	int		booleanToInt				(	boolean
																	trueFalse			)	{
		int		booleanToInt							=	trueFalse
														?		1	:	0					;
		return		booleanToInt															;
	}
 
	public	static	String		booleanToString			(	boolean
																	trueFalse			)	{
		String		booleanToString						=	String.valueOf
														(		trueFalse				)	;
		return		booleanToString															;
	}
 
	public	static	int		doubleToInt					(	double
																	numeric		)	{
		int		doubleToInt								=	(int)	numeric					;
		return		doubleToInt																;
	}
 
	public	static	String		charToString			(	char
																	charValue			)	{
		String		charToString						=	String.valueOf
														(		charValue				)	;
		return		charToString															;
	}
 
	public	static	String		charToString			(	char	[]
																	charValue			)	{
		String		charToString						=	new	String
														(	charValue					)	;
		return		charToString															;
	}
 
	public	static	String		doubleToString			(	double
																	numeric				)	{
		String		doubleToString						=	Double.toString
														(		numeric					)	;
		return		doubleToString															;
	}
 
	public	static	String		floatToString			(	float
																	numeric				)	{
		String		floatToString						=	Float.toString
														(		numeric					)	;
		return		floatToString															;
	}
 
	public	static	int		hexToInt					(	String
																	numeric				)	{
		int		binaryToInt								=	Integer.parseInt
														(		numeric					,
																	16					)	;
		return		binaryToInt																;
	}
 
	public	static	String		intToBinary				(	int
																	numeric				)	{
		String		intToBinary							=	Integer.toBinaryString
														(		numeric					)	;
		return		intToBinary																;
	}
 
	public	static	boolean		intToBoolean			(	int
																	numeric				)	{
		int		x										=	1								;
		boolean		intToBoolean						=	(	x	==
																	numeric				)	;
		return		intToBoolean															;
	}
 
	public	static	double		intToDouble				(	int
																	numeric				)	{
		Double		intToDouble							=	Double.valueOf
														(		numeric					)	;
		return		intToDouble																;
	}
 
	public	static	float		intToFloat				(	int
																	numeric				)	{
		float		intToFloat							=	(float) numeric					;
		return		intToFloat																;
	}
 
	public	static	String		intToHex				(	int
																	numeric				)	{
		String		intToHex							=	Integer.toHexString
														(		numeric					)	;
		return		intToHex																;
	}
 
	public	static	long		intToLong				(	int
																	numeric				)	{
		long		intToLong							=	numeric							;
		return		intToLong																;
	}
 
	public	static	String		intToString				(	int
																	numeric				)	{
		String		intToString							=	Integer.toString
														(		numeric					)	;
		return		intToString																;
	}
 
	public	static	String	[]	intToString				(	int	[]
																	numeric				)	{
		int		size									=	numeric.length					;
		String	[]	intToString							=	new	String	[ size ]			;
		for	(	int 		i							=	0							;
							i							<	size						;
							i							++								)
			intToString	[ i ]							=	intToString
														(		numeric	[ i ]			)	;
		return		intToString																;
	}
 
	public	static	String		intToOctal				(	int
																	numeric				)	{
		String		intToOctal							=	Integer.toOctalString
														(		numeric					)	;
		return		intToOctal																;
	}
 
	public	static	String		longToString			(	long
																	numeric				)	{
		String		longToString						=	Long.toString
														(		numeric					)	;
		return		longToString															;
	}
 
	public	static	void		main					(	String	[]
																	args				)	{
		if	(	args.length								>	1							)	{
			if	(	args	[ 0 ]						.equals
														(	"bI"						))
				System
					.out
					.println							(	binaryToInt
														(	args	[ 1 ]				))	;
			if	(	args	[ 0 ]						.equals
														(	"dS"						))
				System
					.out
					.println							(	doubleToString
														(	stringToDouble
														(	args	[ 1 ]				)))	;
			if	(	args	[ 0 ]						.equals
														(	"fS"						))
				System
					.out
					.println							(	floatToString
														(	stringToFloat
														(	args	[ 1 ]				)))	;
			if	(	args	[ 0 ]						.equals
														(	"hI"			))
				System
					.out
					.println							(	hexToInt
														(	args	[ 1 ]				))	;
			if	(	args	[ 0 ]						.equals
														(	"iB"						))
				System
					.out
					.println							(	intToBinary
														(	stringToInt
														(	args	[ 1 ]				)))	;
			if	(	args	[ 0 ]						.equals
														(	"iH"						))
				System
					.out
					.println							(	intToHex
														(	stringToInt
														(	args	[ 1 ]				)))	;
			if	(	args	[ 0 ]						.equals
														(	"iS"						))
				System
					.out
					.println							(	intToString
														(	stringToInt
														(	args	[ 1 ]				)))	;
			if	(	args	[ 0 ]						.equals
														(	"iO"						))
				System
					.out
					.println							(	intToOctal
														(	stringToInt
														(	args	[ 1 ]				)))	;
			if	(	args	[ 0 ]						.equals
														(	"iT"						))
				System
					.out
					.println							(	intToBoolean
														(	stringToInt
														(	args	[ 1 ]				)))	;
			if	(	args	[ 0 ]						.equals
														(	"lS"			))
				System
					.out
					.println							(	longToString
														(	stringToLong
														(	args	[ 1 ]				)))	;
			if	(	args	[ 0 ]						.equals
														(	"oI"						))
				System
					.out
					.println							(	octalToInt
														(	args	[ 1 ]				))	;
			if	(	args	[ 0 ]						.equals
														(	"sD"						))
				System
					.out
					.println							(	stringToDouble
														(	args	[ 1 ]				))	;
			if	(	args	[ 0 ]						.equals
														(	"sI"						))
				System
					.out
					.println							(	stringToInt
														(	args	[ 1 ]				))	;
			if	(	args	[ 0 ]						.equals
														(	"sL"						))
				System
					.out
					.println							(	stringToLong
														(	args	[ 1 ]				))	;
			if	(	args	[ 0 ]						.equals
														(	"sT"						))
				System
					.out
					.println							(	stringToBoolean
														(	args	[ 1 ]				))	;
			if	(	args	[ 0 ]						.equals
														(	"tI"						))
				System
					.out
					.println							(	booleanToInt
														(	stringToBoolean
														(	args	[ 1 ]				)))	;
			if	(	args	[ 0 ]						.equals
														(	"tS"						))
				System
					.out
					.println							(	booleanToString
														(	stringToBoolean
														(	args	[ 1 ]				)))	;
		}
	}
 
	public	static	int		octalToInt					(	String
																	numeric				)	{
		int		octalToInt								=	Integer.parseInt
														(		numeric					,
																		8				)	;
		return		octalToInt																;
	}
 
	public	static	String		soloString				(	String	[]
																	string				)	{
		int		size									=	string.length					;
		String		soloString							=	""								;
		for	(	int		i								=	0							;
						i								<	size						;
						i								++								)
			soloString									+=	string	[ i ]					;
		return		soloString																;
	}
 
	public	static	boolean		stringToBoolean			(	String
																	trueFalse			)	{
		boolean		stringToBoolean						=	Boolean.parseBoolean
														(		trueFalse				)	;
		return		stringToBoolean															;
	}
 
	public	static	char		stringToChar			(	int
																	indicador			,
															String
																	string				)	{
		char		stringToChar						=	string.charAt
														(		indicador				)	;
		return		stringToChar															;
	}
 
	public	static	char	[]	stringToChar			(	String
																	string				)	{
		char	[]	stringToCharArray					=	string.toCharArray
														(								)	;
		return		stringToCharArray														;
	}
 
	public	static	double		stringToDouble			(	String
																	numeric				)	{
		double		stringToDouble						=	Double.parseDouble
														(		numeric					)	;
		return		stringToDouble															;
	}
 
	public	static	float		stringToFloat			(	String
																	numeric				)	{
		float		stringToFloat						=	Float.parseFloat
														(		numeric					)	;
		return		stringToFloat															;
	}
 
	public	static	int		stringToInt					(	String
																	numeric				)	{
		int		stringToInt								=	Integer.parseInt
														(		numeric					)	;
		return		stringToInt																;
	}
 
	public	static	int	[]	stringToInt					(	String	[]
																	numeric				)	{
		int		size									=	numeric.length					;
		int	[]	stringToInt								=	new	int	[ 0 ]					;
		for	(	int		i								=	0							;
						i								<	size						;
						i								++								)	{
			boolean		numero							=	numeric		[ i ]
																.matches
														(	"-?\\d+(\\.\\d+)?"			)	;
			if	(	numero																)
				stringToInt								=	Add.push
														(		stringToInt				,
																stringToInt
														(		numeric	[ i ]			))	;
		}
		return		stringToInt																;
	}
 
	public	static	long		stringToLong			(	String
																	numeric				)	{
		long		stringToLong						=	Long.parseLong
														(		numeric					)	;
		return		stringToLong															;
	}
}

para detectar este numero el sistema se llevo todas esas vueltas, debe haber algo mas facil

1
2
3
4
5
6
7
ha pasado:6917438
ha pasado:6917439
ha pasado:6917440
ha pasado:6917441
 
 El numero 1321231231 no es primo
El tiempo llevado en esta operacion:					2 minutos 40 segundos

sin divisiones

1
2
3
4
5
6
7
8
9
10
11
12
mrco1965@debian:~$ ejecucion primos
***************************************************************************
***         nombre del programa : primos                           ***
***************************************************************************
 
Bienvenidos a este programa
 Ingrese un número:
2545876
 
 El numero 2545876 no es primo
El tiempo llevado en esta operacion:					4 segundos
codigo bien 0

1
2
3
4
5
6
7
8
9
10
11
12
mrco1965@debian:~$ ejecucion primos
***************************************************************************
***         nombre del programa : primos                           ***
***************************************************************************
 
Bienvenidos a este programa
 Ingrese un número:
254125
 
 El numero 254125 no es primo
El tiempo llevado en esta operacion:					3 segundos
codigo bien 0

sin tantas vueltas para detectar el numero primo, cuando el cont es mayor 2, no tiene caso continuar

1
2
3
4
5
6
7
8
9
ha pasado:45
ha pasado:46
ha pasado:47
ha pasado:48
ha pasado:49
 
 El numero 25421543 no es primo
El tiempo llevado en esta operacion:					6 segundos
codigo bien 0

1
2
3
4
5
6
7
8
9
ha pasado:63
ha pasado:64
ha pasado:65
ha pasado:66
ha pasado:67
 
 El numero 254258769 no es primo
El tiempo llevado en esta operacion:					5 segundos
codigo bien 0

1
2
3
4
5
6
ha pasado:358878
ha pasado:358879
 
 El numero 2512153 no es primo
El tiempo llevado en esta operacion:					12 segundos
codigo bien 0

Eso si cuando es primo tiene que dar todas las vueltas, platicare con la almohada para solucionar una cosas sin tener que dar todas las vueltas, para detectar si es primo o no, ya comente que no tiene caso ni siquiera una vuelta cuando termina en 2 4 5 6 7 8 0, es par excepto el 5 no es primo exceptuando cuando es un solo dígito solamente que 2 3 5 7 son primos
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
-1
Comentar
Imágen de perfil de Rodrigo
Val: 2.041
Plata
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

numeros primos

Publicado por Rodrigo (623 intervenciones) el 01/08/2019 16:22:03
No es facil de leer ese codigo de la manera que lo formateas.
Para que lo conviertes en String?
Para saber si un numero es par basta hacer numero % 2 == 0. No es necesario convertirlo a string y comparar contra 2, 4, 6, 9, 0.
No tienes que dividir por todos los numeros, solo divide por los numeros impares.
Si x es impar, el siguiente impar es x +2.
Un ciclo que solo toma numeros impares:

1
2
for( impar = 3; impar <= limite; impar += 2 )
   if(numero % impar == 0 ) return false;  // si se divide de manera exacta, no es primo

Como todos los pares excepto el 2 no son primos, suponiendo mayores que 1, bastaria hacer:

1
2
if( numero == 2 ) return true;
if( numero %2 == 0 ) return false;
justo antes del ciclo.

No es necesario llegar hasta el numero, basta llegar a la raiz cuadrada del numero (limite, en el for anterior tienes que ser la raiz cuadrada del numero.

Hay una optimizacion mas que se puede hacer en vez de considerar los numeros impares, pero supongo que puedes verla despues que hayas eliminado todas las conversiones a string y de vuelta (que no son necesarias) y haber puesto el limite y usar solo los impares en vez de usar todos los numeros.

Mira aqui: http://bit.ly/esPrimov2
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de juan
Val: 16
Ha aumentado su posición en 2 puestos en Java (en relación al último mes)
Gráfica de Java

numeros primos

Publicado por juan (13 intervenciones) el 01/08/2019 18:35:22
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
static boolean esPrimo(int n) {
    int cont=0;
    for (int i=1; i<=n;i++) {
        if(n%i==0) {
            cont++;
        }
    }
    if(n==1) {
        return true;
    }
    if (cont==2) {
        return true;
    }else {
        return false;
    }
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Sandro Makaviel
Val: 392
Bronce
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

numeros primos

Publicado por Sandro Makaviel (166 intervenciones) el 01/08/2019 19:24:06
1
2
3
for( impar = 3; impar <= limite; impar += 2 )
 
   if(numero % impar == 0 ) return false;  // si se divide de manera exacta, no es primo

en for solo toma los impares,es buen consejo
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar
Imágen de perfil de Sandro Makaviel
Val: 392
Bronce
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

numeros primos

Publicado por Sandro Makaviel (166 intervenciones) el 02/08/2019 15:16:37
No tiene que dar todas las vueltas, para localizar un numero primo, con que el numero ingresado, se le saca la mitad, y hasta ahí da las vueltas, después ya no.

se comento que sacándole la cuarta, pero tengo mis dudas!

no por si solo se da vueltas hasta la cuarta, no por que 21 resultaría primo y no lo es por la cuarta de 21 es 4.582576, y el 7 queda afuera, estaría el 3, no estoy muy seguro que hasta la cuarta

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public	static	boolean	verifica				(	long
                                                            num					)	{
    if	(	num									==	1
                                                ||
            num									==	2
                                                ||
            num									==	5							)
            return		true														;
    if	((	num		%	2			)			==	0
                                                ||
        (	num		%	5			)			==	0							)
        return		false															;
    int		cont								=	0								;
    boolean		es								=	true							;
    for	(	int		i							=	3							;
                    i							<=	num							;
                    i							+=	2							)	{
        System
            .out
            .println							(	"ha pasado:"
                                                +		i						)	;
        long		mitad						=	num
                                                /		2							;
        if	((	num		%	i			)		==	0							)
            cont								++									;
        if	(	cont							>	2
                                                ||
                i								>	mitad						)	{
            es									=	false							;
            break																	;
        }
    }
    return		es																	;
}

si sale verdadero es primo
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
-1
Comentar
Imágen de perfil de Sandro Makaviel
Val: 392
Bronce
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

numeros primos

Publicado por Sandro Makaviel (166 intervenciones) el 02/08/2019 15:41:52
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public	static	boolean	verifica				(	long
                                                            num					)	{
    if	(	num									==	1
                                                ||
            num									==	2
                                                ||
            num									==	5							)
            return		true														;
    if	((	num		%	2			)			==	0
                                                ||
        (	num		%	5			)			==	0							)
        return		false															;
    int			cont							=	0								;
    long		mitad							=	( long )	Math.sqrt
                                                (		num						)	;
    boolean		es								=	true							;
    for	(	int		i							=	3							;
                    i							<=	num							;
                    i							+=	2							)	{
        System
            .out
            .println							(	"ha pasado:"
                                                +		i						)	;
        if	((	num		%	i			)		==	0							)
            cont								++									;
        if	(	cont							>	1							)	{
            es									=	false							;
            break																	;
        }	else	if	(	i					>	mitad						)	{
            es									=	true							;
        }
    }
    return		es																	;
}

correcto se me terminaron los minutos

YA VERIFICADO HASTA LA CUARTA
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
-1
Comentar
Imágen de perfil de Rodrigo
Val: 2.041
Plata
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

numeros primos

Publicado por Rodrigo (623 intervenciones) el 02/08/2019 15:54:24
Algo mejoro tu solucion, pero se puede simplificar mas:

Elimina la variable cont. Si el resto de la division no es 0, ya puedes salir, no necesitas contar.
Solo requieres llegar hasta la raiz cuadrada del numero, no hasta la mitad o hasta la cuarta.
Pon el limite en la condicion del for, con eso evitas el if en medio del codigo.
Puedes tambien eliminar la variable "es", si el numero no es primo, haz "return false" inmediatamente.
SI no es, haz return true al final.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Sandro Makaviel
Val: 392
Bronce
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

numeros primos

Publicado por Sandro Makaviel (166 intervenciones) el 02/08/2019 18:09:34
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public	static	boolean	verifica				(	long
																num					)	{
		if	(	num									==	1
													||
				num									==	2
													||
				num									==	5							)
			return		true															;
		if	((	num		%	2			)			==	0
													||
			(	num		%	5			)			==	0							)
			return		false															;
		float		mitad							=	( float )
														Math.pow
													(	num							,
														1	/	2f					)	;
		for	(	int		i							=	3							;
						i							<=	mitad						;
						i							+=	2							)	{
			if	((	num		%	i			)		==	0							)
				return		false														;
		}
		return		true																	;
	}

ahora si mucho mas rapidos

1
2
3
4
5
6
7
8
9
10
11
12
13
mrco1965@debian:~$ ejecucion primos
***************************************************************************
***         nombre del programa : primos                           ***
***************************************************************************
 
Bienvenidos a este programa
 Ingrese un número:
1231321645645646543
 
 El numero 1231321645645646543 es primo
El tiempo llevado en esta operacion:					1 minutos 7 segundos
codigo bien 0
mrco1965@debian:~$


esos programas que mandan y compilan también agregan las estadísticas a base de datos
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
-1
Comentar
Imágen de perfil de Rodrigo
Val: 2.041
Plata
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

numeros primos

Publicado por Rodrigo (623 intervenciones) el 02/08/2019 18:31:34
Cuando uses por fin la raiz cuadrada, tendras mejores resultados.
Edito: es la raiz, con mal nombre tal vez

Se puede optimizar aun mas, haciendo incrementos de 2 y 4 alternadamente, saltandose los multiplos de 3.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Rodrigo
Val: 2.041
Plata
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

numeros primos

Publicado por Rodrigo (623 intervenciones) el 02/08/2019 18:53:07
Saltarse los multiplos de 3 viene de esta observacion

los numeros impares, despues del 5

5 7 9 11 13 15 17 19 21 23 25 27 ..

destaco los multiplos de 3

5 7 9* 11 13 15* 17 19 21* 23 25 27*..

cada 3 impares, uno de ellos es multiplo de 3, no es necesario considerarlo en el ciclo.
Si se eliminan, quedan estos numeros

5 7 11 13 17 19 23 25 ..

y si te fijas en la diferencia entre uno y otro

5 +2 +4 +2 +4 +2 +4 +2 ..

Para conseguir el siguiente impar a sumar, a partir del 5, suma 2 o 4.

Aqui hay un codigo que implementa esto: http://bit.ly/esPrimov3
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Sandro Makaviel
Val: 392
Bronce
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

numeros primos

Publicado por Sandro Makaviel (166 intervenciones) el 03/08/2019 07:24:18
revisando delta queda negativo.

considerando los últimos cambios reflejados, la aplicación de números primes, se desarrolla en mínimo en comparación con todas las divisiones iniciales propuesta, y eliminando múltiplo de 2, de 5, y considerando únicamente hasta la raíz cuadrada aquí la demostración

1
2
3
4
5
6
7
8
9
10
11
12
mrco1965@debian:~$ ejecucion primos 1231321645645646543
***************************************************************************
***         nombre del programa : primos                           ***
***************************************************************************
 
Bienvenidos a este programa
 Ingrese un número:
1231321645645646543
 
 El numero 1231321645645646543 es primo
El tiempo llevado en esta operacion:					53 segundos
codigo bien 0

en comparación a sin cambios a:

1
2
3
4
5
6
7
ha pasado:1109649341 mitad:1.10964928E9
ha pasado:1109649343 mitad:1.10964928E9
ha pasado:1109649345 mitad:1.10964928E9
 
 El numero 1231321645645646543 es primo
El tiempo llevado en esta operacion:					9 horas 6 minutos 4 segundos
codigo bien 0

ultimo codigo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public	static	boolean	verifica				(	long
																num					)	{
		if	(	num									==	1
													||
				num									==	2
													||
				num									==	5							)
			return		true															;
		if	((	num		%	2			)			==	0
													||
			(	num		%	5			)			==	0							)
			return		false															;
		float		mitad							=	( float )
														Math.pow
													(	num							,
														1	/	2f					)	;
		for	(	int		i							=	3							;
						i							<=	mitad						;
						i							+=	2							)
			if	((	num		%	i			)		==	0							)
				return		false														;
		return		true																	;
	}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
-1
Comentar
Imágen de perfil de Rodrigo
Val: 2.041
Plata
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

numeros primos

Publicado por Rodrigo (623 intervenciones) el 03/08/2019 16:43:33
Parece ser el mismo codigo anterior. hiciste algun cambio?
No me puedo acostumbrar a la indentacion que usas.

Puedes dejarlo asi y ya ves que la demora es sustancialmente mejor que las primeras que hiciste.
Hay 2 ideas mas que puedes usar para optimizarlo mas, una es la que te dije antes (saltarse los multiplos de 3) y otra implica una implementacion diferente a esta.

La explicacion de saltarse los multiplos de 3 esta en mi comentario anterior y en el link ( http://bit.ly/esPrimov3) esta la implementacion.
Sugiero que la mires si al intentarlo tu mismo no te funciona.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Sandro Makaviel
Val: 392
Bronce
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

numeros primos

Publicado por Sandro Makaviel (166 intervenciones) el 05/08/2019 08:31:08
ultima prueba correcta en poco tiempo, suma lo esencial y lo único importante

1
2
3
4
5
6
7
8
9
10
11
12
13
mrco1965@debian:~$ ejecucion primos 1231321645645646543
***************************************************************************
***         nombre del programa : primos                           ***
***************************************************************************
 
Bienvenidos a este programa
 Ingrese un número:
1231321645645646543
 
El numero 1231321645645646543 es primo
El tiempo llevado en esta operacion:					17 segundos
codigo bien 0
mrco1965@debian:~$

código
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
protected	static	boolean	no_Primo			(	long
                                                            num					,
                                                    int
                                                            originales			)	{
    if	(	num	%	originales					==	0							)
            return		true														;
    return		false																;
}
 
protected	static	boolean	no_Primo			(	long
                                                            num					,
                                                    int		[]
                                                            originales			)	{
    int		size								=	originales.length				;
    for	(	int		i							=	0							;
                    i							<	size						;
                    i							++								)
        if	(	no_Primo						(	num							,
                                                    originales	[ i ]			))
            return		true														;
    return		false																;
}
 
protected	static	boolean	primo				(	long
                                                            num					,
                                                    int		[]
                                                            originales			)	{
    int	size									=	originales.length				;
    for	(	int		i							=	0							;
                    i							<	size						;
                    i							++								)
        if	(	num								==	originales	[ i ]			)
            return		true														;
    return		false																;
}
 
protected	static	int		sig_Suma			(	int
                                                            limite				,
                                                    int
                                                            sumando				)	{
    if	(	sumando								<	limite	-	1				)
        sumando									++									;
    else
        sumando									=	0								;
    return		sumando																;
}
 
public	static	boolean	verifica				(	long
                                                            num					)	{
    int []	originales							=	{	2						,
                                                        3						,
                                                        5						,
                                                        7						},
            secuencia							=	{	2						,
                                                        4						,
                                                        2						,
                                                        2						,
                                                        2						}	;
    int		limite								=	secuencia.length			,
            sumando								=	limite							;
    double		raiz							=	( double )	Math.sqrt
                                                (	num							)	;
    if	(	primo								(	num							,
                                                    originales					))
        return		true															;
    if	(	no_Primo							(	num							,
                                                    originales					))
        return		false															;
    for	(	int		i							=	3							;
                    i							<	raiz						;
                    i							+=	secuencia	[ sumando ]		)	{
        if	(	no_Primo						(	num							,
                                                    i							))
            return		false														;
        sumando									=	sig_Suma
                                                (	limite						,
                                                    sumando						)	;
    }
    return		true																;
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
-1
Comentar
Imágen de perfil de Rodrigo
Val: 2.041
Plata
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

numeros primos

Publicado por Rodrigo (623 intervenciones) el 05/08/2019 16:46:44
La secuencia 2 4 2 2 2 no tiene sentido.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Sandro Makaviel
Val: 392
Bronce
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

numeros primos

Publicado por Sandro Makaviel (166 intervenciones) el 08/08/2019 05:09:48
se inicializa en 1, en el for va a sumar la secuencia, la ocurrencia al inicio del for es 5, lógico no suma.

después compara la ocurrencia es el tope, la baja a cero, la suma un 2 es 3,

se salta números múltiplos de cinco, y pares, después la sema un 4 es 7

la suma un 2 es 9

la suma un 2 es 11

compara la ocurrencia de la secuencia es 4 el mayor es 5, la reduce a cero

y después 13, 17,19, 21 etc

tomando en cuenta que la terminación 3 puede ser numero primo, como el 23, y 97 es primo y principio del ciclo lo divide entre los primeros números primos, que son 2,3,5,7

has las pruebas necesarias, para decirme que esta mal, pon el numero que quieras no se tarda nada.

saludos
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
-1
Comentar
Imágen de perfil de Rodrigo
Val: 2.041
Plata
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

numeros primos

Publicado por Rodrigo (623 intervenciones) el 08/08/2019 17:48:31
La explicacion para mi, es precaria, ademas de defender una idea incorrecta.
Tu algoritmo indica numeros primos que no son, 121, 437, 551, 703 son algunos ejemplos.

Puedo estar equivocado, sugiero que revises.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar