GANADORES

Phicar HA GANADO CON JAVA
0.316
0.313
0.271
lenguaje:java
promedio 0.300

csarlg HA GANADO CON C++
0.050
0.040
0.050
lenguaje:c++
promedio 0.046


;D un buen reto escrito por el dragonauta Ric_Monje, gracias por el.


Bueno señores, veo que aki la gente se limita a a pstear vinculos de paginas, y muy pocos a redactar articulos o mini tutoriales, pero en este moento vengo es a proponerles una pequeño concurso, la idea es qu dirante los proximos dias, todo el que desee participar postee un metodo encargado de hallar los numeros primos del 1 al 20.000, el concurso lo gana el que lo haga en el algritmo que lo haga en el menor tiempo posible..que les parece...animence, por lo menos nos entretenemos un rato Tongue

Con esto nos enseñamos no solo a desarrollar x cosa, sino a hacerla lo más eficiente posible. Las aplicaciones concursantes serán compiladas y ejecutadas en la misma pc, para que no haya problema.. échenle lógica pues, quiero ver a varios de aqui inscritos, he visto que varios juegan con java. Lo mejor seria ver al menos 5 propuestas.

pd. esto también es oportunidad para los que quieran iniciarse en java puesto que es sencillo este desafío por parte del lenguaje..


Código:
public class Primo{
public void numeros(){
for(int i=0; i<=20000;i++)primos(i);
}
public void primos(int n){
..............
...........
......... //Al final pondre el mio :P
.......
....
..
public static void main(String args[]) {
Primo p = new Primo();
long inicial=System.nanoTime(); //Usare el metodo nanoTime() para medir el tiempo.
p.numeros();
System.out.println((System.nanoTime()-inicial)*0.000000001);
}
}dragonuta que lo acepta ratahack, ;D ;D




Mi idea es crear un contador del 1 al 20.000 que se guarde en la variable “x”
Luego esa variable “x” se pasara a dividir entre los principales números primos Ej.: 2, 3, 5, 7, 11, 13, 17,19 luego si el resto de la división es = a 0 pasara a contarse. ya que cada numero mencionado tendrá una variable especifica. Esto con la finalidad de que si un número dividido entre los ya mencionados nunca su resto es 0 es porque, lo más probable, sea un número primo.

Pero como hacemos para contar los primos?

Si el tope que es 20000 le restamos todas las cantidades de números acumulados cuyo resto dio 0 para ver cual es la diferencia. Y esa diferencia son todos esos números primos. Aquí puse pongo un ejemplo programado con visual Basic:

Private Sub Command1_Click()

For x = 1 To 20000

If x Mod 2 = 0 Then
i = i + 1
ElseIf x Mod 3 = 0 Then
o = o + 1
ElseIf x Mod 5 = 0 Then
p = p + 1
ElseIf x Mod 7 = 0 Then
k = k + 1
ElseIf x Mod 11 = 0 Then
q = q + 1
ElseIf x Mod 13 = 0 Then
r = r + 1
ElseIf x Mod 17 = 0 Then
z = z + 1
ElseIf x Mod 19 = 0 Then
b = b + 1
End If

Next

alex = 20000 - (o + i + p + k + q + r + z + b) + 8

Text1.Text = alex

End Sub
Esto dará la respuesta en cuadro de texto llamado Text1.
Discúlpenme si esta mal redactado y acepto todas las sugerencias posible ya que me estoy iniciando en el mundo de la programación.

Aduxer no se quedo atras bien por el ::) ;D

su aporte fue:

Bueno Amigos aquiles dejo el codigo escrito en c para hallar los numeros primos!!
en determinado dominio!



#include <stdio.h>
#include <conio.h>


void primos (int n1)
{
int aux,i,j;
for (i=1;i<=n1;i++)
{
/* Estudiamos si el numero 'i' es primo o no. Para ello contabilizamos sus divisores.*/

aux=0;
for (j=1;j<=i;j++)
{
if (i%j==0)
aux++;
}
/* Todo numero es divisible entre 1 y entre si mismo; por tanto, si el numero total de divisores
Es igual a 2, el numero es primo. */
if (aux==2)
printf("%d\n",i);
}
}

int main()
{
int n1;
do
{

printf("Introduce un numero mayor que cero: ");
scanf("%d",&n1);
}while(n1<1);
printf("Los numeros primos entre 1 y %d son:\n",n1);
primos(n1);


getch();
return 0;
} y Yshua, por que las pequeñas ideas tambien son grandes soluciones, su aporte:


acabo de ver este post. tengo una pequeña idea. la voy a probar y la posteo, mientras se me ocurre algo mejor.

EDITADO

OK.
ya implementé mi idea.

Código: (java)
public static boolean primo(int x){
if(x==1)return false;
if(x==2)return true;
if(x%2==0)return false;
else{
for(int i=3;i<x;i+=2){
if(x%i==0)return false;
}
}
return true;
}

el metodo retorna true si x es primo así que el main cambiaria por este
Código: (java)
public static void main(String[] args) {
for(int i=0;i<20000;i++)
if(primo(i))System.out.println(i+" ");

}

Tengo otra idea, no se si mas rápida o lenta. pero ahora la pongo también

Escrito por Mandrake originalmente ahora llamado en los bajos mundos como ExtreamShocker

Bueno ya termine mi codiguin¡¡¡¡ , a ver que tal les va con esto 8)

Código:

public class Primo {
public static void main(String[] args) {
int j=2;
boolean p=true;
System.out.print("1\n2\n3\n");
long inicial=System.nanoTime();
for(int i=5;i<20000;i+=2)
{
for(int k=2;k<=j;k++)
{
if(i%k==0)
{
p=false;
break;
}
}
j++;
if(p)
System.out.println(i);
p=true;
}
System.out.println((System.nanoTime()-inicial)*0.000000001);
}
}
Solo como sugerencia para calcular el tiempo, para ver cual es mas rapido, se podria tomar 10 tiempos de cada codigo y elegir el mas bajo de las 10 mediciones, asi para cada codigo, ya que al estar ejecutando varias veces el codigo me di cuenta que el tiempo en que tardaba en ejecutarse variaba.

P.D.:El codigo que mide el tiempo fue utilizado del ejemplo que dieron como referencia

de momento hay 3 códigos para competir entre si, esperemos unos cuantos mas para realizar las primeras pruebas, luego se les da los resultados de sus códigos y un tiempo para mejorarlo si desean, después se realiza la prueba final y se anuncia el ganador.

que paso con los otros programadores antes de lo sucedido en el foro habian mas de los que hay ahora

jaja, que entrete :D, primero que todo hola, y segundo no soy programador pero quise aportar, la verdad me he entretenido bastante con esto de los "retos" :D, primero el codigo


#include <stdio.h>

main ()
{

int n,i,cont=0;
float div3,div5,div7,div9;
for (n=0;n<10000;n++)
{
i=2*n+1;
div3=i%3;
div5=i%5;
div7=i%7;
div9=i%9;
if( (div3!=0) && (div5!=0) && (div7!=0) && (div9!=0))
{
cont++;
}
}
printf("N° total de Primos %d\n",cont);
}


segundo lo que se demoro poco, pero hay que hacer las mediciones en pc del mismo calibre, tengo un amd64 3000+ con 1 gb



zefiro@slack:~$ nano primos.c
zefiro@slack:~$ cc primos.c -o primos
zefiro@slack:~$ time ./primos
N° total de Primos ####

real 0m0.002s
user 0m0.003s
sys 0m0.000s
zefiro@slack:~$

zefiro!!!!! :o :o :o
yo lo habia intentado ya asi, pero otro concursante me aclaro que estaba malo ese algoritmo, empieza aceptando numeros primos que no lo son, yo tambien pensaba que si el numero no era divisible entre 3,5,7,9 deberia ser primo, :-[ pero lamentablemente eso no fue asi , como ejemplo mira el numero 121 es un numero que no es divisible entre 3,5,7,9 pero si lo es entre el numero primo 11, ya que 121 mod 11 =0,lo cual tu algoritmo lo reconoce como num primo,pero no lo es!! y si te das cuenta 11 es primo tambien, entonces no solo tenes que ver si es divisible entre 3,5,7,9 , sino que tambien entre los mismos primos!!!! ;)..
***en tu algoritmo**
143 mod 11 =0 no es primo, | reconocido
169 mod 13 =0 no es primo, | reconocido
187 mod 11 =0 no es primo, | reconocido
..... | reconocido
.... | reconocido
... | reconocido

aca esta el mio en c++


#include <iostream.h>




unsigned long pro(int divisor );
int n;
int i;
int numero,divisor;
main ()

{
system("color 0a");
int a,b;
cout<<"ingrese un numero";
cin>>numero;

n = pro(numero);

}

unsigned long pro(int divisor )

{
for (i=numero;i<=20000;i++)
{
for(divisor=2; (divisor*divisor<=i)&&(i%divisor!=0); divisor++)
{
}
if (divisor*divisor>i)
{
cout<<" "<<i<<endl;


numero = numero +1;


}

}


system("pause");
return 0;
}







anexo un video que hize comparando mi code con el de otro y bueno el mio salio mas rapido

Hola, hace algún tiempo hice este algoritmo para calcular los primos y es bastante rápido. Se trata de crear una lista enlazada con los números primos. Inicialmente solo se le agrega el 2 luego dentro de un bucle se llama a una función que trata de añadir los siguientes números (3, 4, 5 ,6...) a la lista pero solo se añaden los primos. La lista también sirve para comprobar que un numero es primo. Esto es si un numero no es múltiplo de ningún elemento de la lista entonces es primo. Para hacerlo mas eficiente se añade otra optimizacion para que no evalue la multiplicidad con todos los elementos de la lista sino solo con aquellos cuyo valor multiplicado por 2 sea menor o igual al numero.

Datos Adicionales:
Lenguaje: C++
SO: Windows
Compilador: Dev-C++ Version 4
Tiempo en resolver el reto: un par de segundos.



#include <iostream.h>
#include <stdlib.h>


struct nodo{
unsigned long int val;
nodo *sgte;
};

void calcular_primos(nodo *Raiz, nodo **Final, unsigned long int val);

void main(){
unsigned long int val = 2;
nodo *Lista, *Final;

Lista = new nodo;
Lista->val = val;
Lista->sgte = NULL;
Final = Lista;

cout<<val<<" ";

while( 1 ){
calcular_primos(Lista, &Final, ++val);
if(val == 20000){break;} //* Numero limite 100*//
}
system("pause>nul");
}

void calcular_primos(nodo *Raiz, nodo **Final, unsigned long int val){

bool es_primo = true;
nodo *p = Raiz;

while(p != NULL){
if(val%(p->val) == 0){
es_primo = false;
break;
}
if((p->sgte) != NULL){
if(((p->sgte)->val)*((p->sgte)->val) > val){
break;
}
}
p = p->sgte;
}

if(es_primo){
(*Final)->sgte = new nodo;
((*Final)->sgte)->val = val;
((*Final)->sgte)->sgte = NULL;
*Final = (*Final)->sgte;

cout<<val<<endl;
}

}


//Comentario: Modifique el algoritmo para que sea mas rapido. (¿se vale?)

Bueno ya hay varios competidores... ¿les parece si empezamos a testear?

Si! Que comienze el testeo!! ;D ... Veremos quien gana :P

Oigan aun puedo entrar a competir????
igual ahi les va mi codigo

//////////////////Created by Roguer////////////////////////
#include<iostream>
#include<stdlib.h>
using namespace std;

int main()
{
int numero=3;
int limite;
bool primo=true;
cout<<"1,2,";
while(numero<20000)
{
limite=numero/2;
primo=true;
for(int i=3;i<limite;i+=2)
{
if(numero%i==0)
{
primo=false;
}
}
if(primo)
{
cout<<numero<<",";
}
numero+=2;
}
cout<<endl;
system("pause");
return 0;
}
///////////////////////////fin//////////////////////////////////

Espero les guste es bastante rapido
y ojala no tenga errores en la logica, si detectan algo me avisan
jejejeje

0.016 ms demora el mio :P

GNU nano 2.0.7 Fichero: primeTest.java

import java.util.*;
public class primeTest{
public static boolean primes&#91;] = new boolean[20000];
public static void main(String args&#91;]){
Arrays.fill(primes,true);
for(int n = 2;n<=Math.sqrt(primes.length);n++)
if(primes[n])for(int k = n*n;k<primes.length;k+=n)primes[k]=false;
int conta = 1;
for(int n = 3;n<primes.length;n+=2)
if(primes[n])conta++;
System.out.println(conta);
}
}


roguer lo podrias hacer mas rapido, agregale un break cuando le das false al booleano de prime :)

Monje nunca dijiste nada :P.. todo falso como el de premaraton phone..me quede esperando que calificaras :P

A pedido de Dragon, Resultados:

roguer
&#160; &#160; &#160; &#160; &#160; 0.612
&#160; &#160; &#160; &#160; &#160; 0.632
&#160; &#160; &#160; &#160; &#160; 0.640
lenguaje:c++
promedio 0.628s

csarlg
&#160; &#160; &#160; &#160; &#160; 0.050
&#160; &#160; &#160; &#160; &#160; 0.040
&#160; &#160; &#160; &#160; &#160; 0.050
lenguaje:c++
promedio 0.046

Mandrake
&#160; &#160; &#160; &#160; &#160; 0.768
&#160; &#160; &#160; &#160; &#160; 0.769
&#160; &#160; &#160; &#160; &#160; 0.770
lenguaje:java
prfomedio 0.769

Radical
&#160; &#160; &#160; &#160; &#160; &#160; 0.065
&#160; &#160; &#160; &#160; &#160; &#160; 0.072
&#160; &#160; &#160; &#160; &#160; &#160; 0.069
lenguaje:c++
promedio 0.068

Phicar
&#160; &#160; &#160; &#160; &#160; &#160; 0.316
&#160; &#160; &#160; &#160; &#160; &#160; 0.313
&#160; &#160; &#160; &#160; &#160; &#160; 0.271
lenguaje:java
promedio 0.300


lo hice con time...les dejo foto...modifique los programas de los que usaron windows un poquito...(basicamente nada) pero para que funcaran toco cambiar un par de lineas que no afectan en nada el algoritmo :)

*1 no es primo :P
*Zefiro tenia mal el resultado
*Hay ganador java y ganador c++ porque no hay punto de comparacion entre los dos lenguajes en cuanto a velocidad se refiere..memoria contra maquina virtual es como jodido
*Mambru se fue a la guerra, que dolor que dolor que pena

http://img147.imageshack.us/img147/7595/primosdragonnj4.th.png (http://img147.imageshack.us/my.php?image=primosdragonnj4.png)

GANADORES

Phicar HA GANADO CON JAVA
0.316
0.313
0.271
lenguaje:java
promedio 0.300

csarlg HA GANADO CON C++
0.050
0.040
0.050
lenguaje:c++
promedio 0.046

se les a añadido el premio que en este caso son 10 puntos de reputación, los próximos retos tendrán premios materiales.

hola q tal, aprovechando este tema me gustaria sabes como se hace el testeo de los codigos, hay programas para hacerlo????

Como que como se hace el testeo??? lo tienes que compilar

Si eso creo q ya lo sabia, creo q hice mal la pregunta, yo me referia a como obtienen el tiempo q tarda el programa en hallar los numeros primos... ej
0.050
0.040
0.050

Los números primos desde los tiempos de antigüedad, donde los matemáticos se cuenta que algunos números, son divisibles entre el 1 y los mismos números le consideraron, números primos. En la actualidad los números primos siguen siendo hoy estudiadas, y algunos de los números primos son pueden llenar hojas y hojas, pues constan de millones de dígitos.

En nuestro caso para los programadores, los números primos tiene ciertas aplicaciones, en la criptografía, tales es el uso en la llave RSA, que maneja números primos grandes. Muchos de estos números tienen mas 500 dígitos,.la verificación de números primos son computacionalmente no son posibles pues pueden tardar varios años, por los tanto se inventaron distintos métodos algortimicos de tal modo que no sea engorroso, si no la comprobación de los números primos sea rápida y no lleva mucho tiempo, entre ellos esta el método de Pollard, métodos numéricos la mas usada es el método probabilística, que tiene un algoritmo muy interesante que es específicamente para números que tengan mayor a 100 dígitos. Java en su librería contiene este algoritmo, específicamente esta en la librería esta en BigInteger donde, el método es EsPrimo(BigInteger a) que devuelve mediante el método probabilística en forma true o false.
Los numeros primos fueron atacados desde distintas ópticas de las matemáticas, como analizadores de la algoritmia, también de la teoría de números, para verificar un número primo, pues un numero primo que tiene cerca a 500 digitos y o mas pueden tardar varios años en verificarse.

Uno de los métodos que se usan nórmalmente es dividir sucesivamente el numero que se quiere verificar sucesivamente desde 1 hasta el numero verificar: consideremos x el numero a verificar, entonces en nuestro programa seria:
Sum=0
for(I=1; i<=x;i++)
{if(x%I==0)
sum++;
}
if(sum>=3)
print(no primo)

else
print(primo)

este seria un algoritmo que verifica el numero si es primo o no, pero es muy engorroso y tardad varios segundos, otra idea seria, dividir el numero x/2 de tal modo el algoritmo quedaría:

sum=0
for(I=1; i<=x/2;i++)
{if(x%I==0)
sum++;
}
if(sum>=3)
print(no primo)

else
print(primo)

de manera que este algoritmo mejora por lo menos algunos segundos, pero no es la buena opcion, otra forma de plantearnos y por lo menos la mas efectiva es de la siguiente forma, sabemos que un numero x su raiz es raíz(x): veamos algunos análisis:;
49 su raiz entera es 7
5 su raiz entera es 2
81 su raiz entera es 9
en cada uno de los anteriores ejemplos la raiz va reduciendo de una forma radical las operaciones de comparación que se puede realizar
, esto se puede generalizar de la siguiente forma en un algoritmo:

sum=0
for(I=1; i<=raiz(x);i++)
{if(x%I==0)
sum++;
}
if(sum>=3)
print(no primo)

else
print(primo)

que reduce radicalmente los números de comparaciones, ahora les presento mi algoritmo, que si tiene buenos resultados, por los menos, en el concurso de programación de la ACM donde participe, pero si éxitos algunos, el algoritmo es una modificación a la anterior, pero viene comparando de dos formas, uno va en sentido de avance y el otro en sentido de retroceso, veamos el algoritmo.
sum==0
Inf=1;
sup=raiz(x)

while(sum==0 && inf<=sup+1)
{if(x%Inf==0||x%sup==0)
sw=1;
else
inf++;
sup--;
}
if(sum==1)
print(no primo)

else
print(primo)


entonces nuestro programa seria de la siguuientes forma, con los analisis anteriores y aplicando lla verifiacion del algoritmo de
verificacion de numeros primos, seria de la siguiente forma:
en este algoritmo
cont=1; //inicializamos el contador de numeros primos, pues contamos el dos como primo, y el uno no es considerado primo.
for(i=3; i<=200000;i=i+2)//pues se considera que los multiplos de dos no son primos, entonces solo verificamos 3,5,7,9,11,
{if(veriprimo(i)) //verifica primo si es verdadero el cont aumenta en caso contrario no //ase nada
cont++;
}
print(cont)


aqui el codigo en java

import java.util.*;
import java.math.*;
public class Primo
{
boolean veriprimo (int x)
{
boolean sw = true;
int inf = 2;
int sup = (int) (Math.sqrt (x));
while (sw == true && inf < sup + 1)
{
if (x % inf == 0 || x % sup == 0)
sw = false;
else
{
inf++;
sup--;
}
}
return sw;

}


void calcula ()
{
Date a = new Date ();
int i, s = 1;
for (i = 3 ; i <= 20000 ; i += 2)
{
if (veriprimo (i) == true)
{
s++;
}
}
Date b = new Date ();
System.out.println (b.getTime () - a.getTime ());
System.out.println ("el numero total de primos es " + s);
}


public static void main (String args [])
{
Primo p = new Primo ();
p.calcula ();
}
}

Como escribo por primera vez recibo las criticas y aceptó sugerencias.

efrajdk

ya se ha terminado el reto? puedo participar por ejemplo con assembler o python?

si no entonces lo hare solo por diversion xD

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
__inline int fsqrt(__int16 numero)
{
float x = (float)(numero);
float xhalf = 0.5f * x;
register int i = *(int*)&x;
i = 0x5f3759d5 - (i >> 1);
x = *(float*)&i;
x = x*(1.5f - xhalf*x*x);
return (__int8)(1/x);

}
__inline int esprimo(__int16 numero)
{
register __int8 resultado;
register __int8 raiz = fsqrt(numero);

__asm
{
mov ax, numero
mov bl, 2
mov cx, ax
mov dl, raiz
cmp ax, 1
je noprimo
cmp ax, 2
je primo
div bl
cmp ah, 0
je noprimo
mov bl, 3
mov ax, cx

ciclo:
div bl
cmp ah, 0
je noprimo
add bl, 2
mov ax, cx
cmp bl, dl
jb ciclo
jmp primo

primo:
mov resultado, 1
jmp fin

noprimo:
mov resultado, 0

fin:

}

return resultado;
}
int main(){

register __int16 numero = 1;
register __int16 cont = 0;
clock_t t_ini, t_fin;
double diff;

t_ini = clock();
while(numero < 500)
{
if(esprimo(numero) == 1)
{
cont++;
}
if(numero > 2) numero+=2;
else numero++;

}
printf("Hay %d primos entre 1 y 500\n",cont);
t_fin = clock();
diff = (double)(t_fin - t_ini);
printf("%.16g ciclo(s) de reloj\n", diff);


system("pause");
return 0;

}


Me gustaria saber si valió la pena y si es mas rapido o solo fue perder tiempo en assembler xD

Lo compile con Visual C++ 2005, y me da 0.001 en mi maquina PERO solo calcula la cantidad de primos entre 1 y 500 (es assembler de 16bits, el maximo numero que se almacena en un registro de 8bits es 511)

Modifique el de cesrlg para que haga lo mismo que el mio (del 1 al 500 y que muestre solo cantidad), asi quedo:



#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;


struct nodo{
unsigned long int val;
nodo *sgte;
};
int cont = 1;
void calcular_primos(nodo *Raiz, nodo **Final, unsigned long int val);

void main(){
unsigned long int val = 2;
nodo *Lista, *Final;
clock_t t_ini, t_fin;
double diff;

Lista = new nodo;
Lista->val = val;
Lista->sgte = NULL;
Final = Lista;

t_ini = clock();
while( 1 ){
calcular_primos(Lista, &Final, ++val);
if(val == 500){break;} //* Numero limite 100*//
}
cout<<"Hay "<<cont<<" numeros primos entre 1 y 500\n";
t_fin = clock();
diff = (double)(t_fin - t_ini);
printf("%.16g ciclos de reloj\n", diff);
system("pause>nul");
}

void calcular_primos(nodo *Raiz, nodo **Final, unsigned long int val){

bool es_primo = true;
nodo *p = Raiz;

while(p != NULL){
if(val%(p->val) == 0){
es_primo = false;
break;
}
if((p->sgte) != NULL){
if(((p->sgte)->val)*((p->sgte)->val) > val){
break;
}
}
p = p->sgte;
}

if(es_primo){
(*Final)->sgte = new nodo;
((*Final)->sgte)->val = val;
((*Final)->sgte)->sgte = NULL;
*Final = (*Final)->sgte;

cont++;
}

}


cesrlg: 6 ciclos de reloj minimo, 11 ciclos de reloj maximo
mio: 0 ciclos de reloj minimo, 1 ciclo de reloj maximo.

Que pena responder tan tarde.... posiblemente la competencia ya a acabado, y posiblemente este programa no compita con los presentados hasta el momento, pero aca envio un programa de mi autoria que solo los genera hasta el 1024, pero en lenguaje asembler.. para mic 80c51....

PRACTICA: DETECTOR DE NUMEROS PRIMOS DEL 0 AL 1024
DESARROLLADOR: ANDRES ALBERTO DIAZ
;------------------------------------------------------------------------------
ORG 00H ;INICIO DEL PROGRAMA PARA CRIMSON
;------------------------------------------------------------------------------
MOV R2,#03H ;NUMEROS DEL 3 AL 1024 NUMERADOR
MOV R3,#02H ;CONTADOR DE 2 A N-1 DENOMINADOR
MOV R0,#02H ;DIRECCIONADOR QUE CONTROLARA EL NUMERO QUE SE REVISA NUMERADOR
MOV R1,#03H ;DIRECCIONADOR QUE CONTROLARA EL NUMERO DE DIVISIONES QUE HAY QUE HACER PARA DETECTAR SI EL NUMERO ES PAR O IMPAR DENOMINADOR
;------------------------------------------------------------------------------
;************************************************* *EXCLUSIVO DE CRIMSON*********
MOV 40H,#02H ;MOSTRARA EN LA POCISION 40H EL NUMERO EN CASO TAL DE SER PRIMO//EN MICROLAB SE REEMPLAZA POR SHOW IN DISPLAY
;************************************************* *EXCLUSIVO DE CRIMSON*********
;------------------------------------------------------------------------------
AA: MOV 05H,@R0 ;SE CARGA EL R5 CON LO QUE HAYA EN DIRECCION DE R0/ OSEA QUE TENEMOS EN R5 EL NUMERO QUE SE VA A REVISAR/ ESTE IRA AUMENTADO HASTA 1024 DENOMINADOR
MOV 06H,@R1 ;SE CARGA EL R6 CON LO QUE HAYA EN DIRECCION DE R1/ OSEA QUE TENEMOS EN R6 EL NUMERO DE VECES QUE HAY QUE DIVIDIR EL NUMERO PARA SABER SI ES PRIMO O NO NUMERADOR
MOV A,R5 ;SE CARGA EL ACUMULADOR CON EL NUMERO A EVALUAR NUMERADOR
MOV B,R6 ;SE CARGA B CON EL NUMERO QUE SE VA A DIVIDIR DENOMINADOR
CLC C ;SE REINICIA EL CARRY
DIV AB ;SE DIVIDE EL NUMERO A ESTUDIAR POR EL NUMERO CONTADOR/ SI HAY CARRY LA DIV NO FUE ENTERA/ ENTIENDASE VICEVERSA TAMBIEN
MOV A,B
JNZ AAB ;SI HAY CARRY SALTE A "AB" PARA QUE HAGAN CONTEO DE LOS CARRYS QUE SE PRESENTEN EN EL CICLO
AAC: MOV A,06H ;SE CARGA EL ACUMULADOR CON EL DENOMINADOR ACTUAL
MOV 20H,A ;SE CARGA EN R8 EL VALOR DE A// OSEA EL DENOMINADOR ACTUAL
INC 20H ;INC R8 CON EL FIN DE COMPARAR SI NUMERADOR YA ES IGUAL A DENOMINADOR//CON EL FIN DE QUE EL DENOMINADOR SOLO VALLA DE 2 A N-1
MOV A,R5 ;SE CARGA CON EL VALOR DE R5/ Q SE SUPONE TIENE EL NUMERO POR EL CUAL SE ESTA DIVIDIENDO/ ESTO ES CON EL FIN DE SABER SI YA ES IGUAL NUM/DEN
INC R3 ;SE INCREMENTA EN UNO/ PARA PASAR AL SIGUIENTE DENOMINADOR
CJNE A,20H,AA ;SI SON IGUALES QUIERE DECIR QUE YA SE HICIERON TODAS LAS DIVISIONES CORRESPONDIENTES PARA EL NUMERO QU SE EVALUA/ OSEA QUE YA SE SABE SI ES PRIMO O NO
LJMP BA
AAB: INC R4 ;R4 CONTARA EL NUMERO DE CARRYS
LJMP AAC ;SALTA A AC QUE HACE EL CONTEO DE LOS DENOMINADORES Y LO HACE CICLICO HASTA QUE SE HAGAN TODAS LAS DIVISIONES DE 2 A N-1 POR CADA DENOMINADOR
;-------------------------------------------------------------------------------
BA: MOV A,R5 ;SE CARGA ACUMM CON EL VALOR DEL NUMERADOR QUE SE ACABO DE EVALUAR
DEC A
DEC A ;SE DECREMENTA EL NUM 2 VECES PARA COMPARAR SI LUEGO ES IGUAL AL NUMERO DE CARRYS
CJNE A,04H,BB ;COMPARA SI EL NUMERO DE CARRYS ES IGUAL A NUMERADOR-2//SI ES IGUAL ENTONCES EL NUMERO ES PRIMO Y CONTINUE/SI NO ES IGUAL NO ES PRIMO SALTE A BB
;************************************************* *EXCLUSIVO DE CRIMSON*********
MOV 40H,R5 ;MOSTRARA EN LA POCISION 40H EL NUMERO EN CASO TAL DE SER PRIMO//EN MICROLAB SE REEMPLAZA POR SHOW IN DISPLAY
;************************************************* *EXCLUSIVO DE CRIMSON*********
BB: MOV R4,#00H ;SE RESETEA EL CONTADOR DE CARRYs
MOV A,R5 ;GUARDAMOS EN EL ACUMULADOR EL NUMERADOR ACTUAL
INC R2 ;SE AUMENTA R2 PARA QUE PASE AL NUMERADOR SIGUIENTE
MOV R3,#02H ;SE INICIALIZA NUEVAMENTE R3 PARA QUE VUELVA A EMPEZAR DESDE 2 Y PUEDA VOLVER A AUMENTAR HASTA N-1
CJNE A,#0FFH,AA ;VUELVE Y EMPIEZA EL PROGRAMA CON EL SIGUIENTE NUMERADOR
END
;-------------------------------------------------------------------------------

#include <clx.h>
#pragma hdrstop
#pragma argsused
#include<iostream.h>
int main(int argc, char* argv[])
{
int num = 1;
int n = 1;
int cont = 3;
cout<<2<<endl<<3<<endl;
while(num <= 20000)
{
num = 4*n-1;
cout<<num<<" ,";
num = 4*n+1;
cout<<num<<" ,";
n++;
}
return 0;
}

en qbasic xD =)



DIM a, b, c AS INTEGER
CLS
INPUT a
FOR b = 1 TO a
IF a MOD b = 0 THEN
c = c + 1
END IF
NEXT b
IF b > a THEN
IF c = 2 THEN
PRINT "si es primo"
ELSE
PRINT "no es"
END IF
END IF


ahi pa los que estan aprendiendo programacion =) uno de los lenguajes mas faciles =)


saludos
Dedalo(Dédalo)