Números primos

Programa que halla los numeros primos hasta n:

Bajelo Aca ya listo para el Simulador: primos.zip

El algoritmo para hallar los numeros primos es el siguiente:

PROGRAMA

leo limite

num=1

MQ num<=limite Haga

Si num<=3

Imprima Num

Sino Si num % 2 == 0

Break

Sino

x=3

raiz=RaizC(num)

MQ x<=raiz Haga

Si num % x ==0 break SI

x= x+2

FinMQ

imprima num

FinSi

num=num+1

FinMQ

FIN PROGRAMA

//Programa Numeros Primos

//Leo el limite o valor hasta donde quiero hallar numeros primos

//inicializo num en 1

//Repito este bucle hasta que num > limite

//Si el modulo de num/2 = 0 es porque el numero es par.

//aca RaizC() es la funcion que se explica mas adelante.

Funcion RaizC()

y=1

mq (y != raiz) ó (y != raiz+1) haga

raiz = y

y = ( y + ( num / y )) / 2

fin mq

Funcion para hallar la raiz cuadrada de un numero

//inicializo y en 1

//Hago un Bucle que no termine hasta que "y" sea diferente de raiz o raiz+1

Ahora para escribirlo en assembler organizare la memoria del simulador asi:

Variable

limite

num

x

raiz

y

2

3

0

1

Dirección Memoria

34

35

36

37

38

3A

3B

3C

3D

Descripcion

Limite hasta donde quiero que lleguen los primos

empieza en 1 y termina cuando llega a limite

variable usada para hallar si el numero es primo

variable raiz, almacena la raiz de num

variable usada en RaizC()

Constante numero 2 (en binario 10)

Constante numero 3 (en binario 11)

Constante numero 0 (en binario 0)

Constante numero 1 (en binario 1)

Ahora pasemos ese Algoritmo a Assembler, al frente de cada instrucción esta comentado despues del punto y coma que hace esta.

El programa quedaria asi:

Dir

00:

01:

02:

03:

04:

05:

06:

07:

08:

09:

0A:

0B:

0C:

0D:

0E:

0F:

10:

11:

12:

13:

14:

15:

16:

17:

18:

19:

1A:

1B:

1C:

1D:

1E:

1F:

20:

21:

22:

23:

24:

25:

26:

27:

28:

29:

2A:

2B:

2C:

2D:

2E:

2F:

30:

31:

32:

33:

34:

35:

36:

37:

38:

39:

3A:

3B:

3C:

3D:

3E:

3F:

40:

Instrucción y Parámetros

NOP

MOV 35,3D

LDT

MOV 34,AX

MOV AX,34

CMP 35

JME 32

MOV AX,35

CMP 3B

JMA D

MOV AX,35

EAP

JMP 30

MOV AX,35

DIV 3A

MOV AX,BX

CMP 3C

JMA 13

JMP 30

MOV 36,3B

MOV 38,3D

MOV AX,38

CMP 37

JEQ 23

MOV AX,37

INC AX

CMP 38

JEQ 23

MOV 37,38

MOV AX,35

DIV 38

ADD 38

DIV 3A

MOV 38,AX

JMP 15

MOV AX,37

CMP 36

JME 2E

MOV AX,35

DIV 36

MOV AX,BX

CMP 3C

JEQ 30

INC 36

JMP 23

MOV AX,35

EAP

INC 35

JMP 04

HLT

10

11

0

1

Comentarios

;No operacion

;num = 1

;leo del teclado el Limite

;almaceno limite en 34

;cargo limite en AX (Comienzo MQ)

;comparo limite con num

;Si limite es menor que num voy a fin de MQ

;AX=num

;comparo num con 3

;si num > 3 voy a SINO

;AX = num

;Escribo num en pantalla

;voy a FINSI

;AX=num SINO

;AX = AX/2 , BX = modulo

;paso el modulo a AX

;comparo mod con 0

;salto si mod > 0

;break

;x=3

;y=1

;cargo Y en AX (COMIENZO MQ del raiz())

;comparo y con raiz

;si y=raiz salgo del mq

;AX=raiz

;AX=AX+1

;comparo raiz con y

;si raiz=y salgo del mq

;raiz = y

;AX = num

;AX = num/y

;AX = AX + Y

;AX = AX / 2

;y = al valor del Registro AX

;Salto a repetir el blucle MQ del raizC()

;FINMQraiz() y AX = raiz (COMIENZO MQ2)

;comparo raiz con y

;si raiz < x voy a fin MQ2

;AX = num

;AX = AX / x

;AX = residuo que esta en BX

;Comparo residuo con 0

;si residuo = 0 salgo del SI

;x= x+1

;voy a MQ2

;AX = num FIN MQ2

;imprimo num en pantalla

;FINSI

;hago loop

;FIN MQ y PROGRAMA

;Inicializo raiz en 2

;Con el editor de memoria del simulador almaceno las constantes

;Constante 2

;Constante 3

;Constante 0

;Constante 1