Está en la página 1de 22

PARCIAL 2011 DERAS

SOLUCION

LITERAL A

.MODEL SMALL

.DATA

COCI DW ?;se crea COCI a 3 byte

RESF DW ?;se crea RESF a 3 byte

.CODE

.STARTUP

MOV AX,-250;guardamos el dividendo

CWD ;convierte la palabra a doble palabra

MOV CX, 16;guardamos el divisor

IDIV CX;realizamos la division

MOV COCI,AX;guardamos

;realizamos residuo fraccionario

MOV AX,0

CWD

IDIV CX

MOV RESF,AX

.EXIT

END

LITERAL B

1
.MODEL SMALL

.DATA

DIVID DW ?;se crea COCI a 3 byte

DIVIS DB ?;se crea RESF a 3 byte

COSASCII DW ?

RES DW ?

.CODE

.STARTUP

;VALORES DE PRUEBAS

MOV DIVIS,1H

MOV DIVID,10H

MOV BL,DIVIS

MOV AX,DIVID

AAD;AJUSTAMOS LA DIVISION

DIV BL

MOV DX,AX;SE GUARDA EL COC. Y REC. EN DX

MOV AH,0;EL RECIDUO ES CERO PARA TRABAJAR

;SOLO CON EL COCIENTE

AAM;CONVIERTE EL COCIENTE A BCD

ADD AX,3030H;CONVIERTE A ASCII

MOV COSASCII,AX;ALMACENAMOS EL COCIENTE

;AHORA TRABAJAMOS CON EL RESIDUO

MOV AL,DH;LO PONEMOS EN LA PARTE BAJA PARA

MOV AH,0

ADD AX,3030H;EL RESIDUO PASA A ASCII

MOV RES,AX;GUARDAMOS EN LA LOCALIDAD

.EXIT

END

2
SOLUCION

DATOS_S SEGMENT 'DATA'

ORG 100H

;PUBLIC TABLA1

;PUBLIC TABLA2

;PUBLIC COCIENTE

;PUBLIC RES

TABLA1 DW 3 DUP (?)

TABLA2 DW 3 DUP (?)

COCIENTE DD ?

RES DW ?

DATOS_S ENDS

CODIGO_S SEGMENT 'CODE'

ASSUME CS:CODIGO_S, DS:DATOS_S, ES:DATOS_S

;PUBLIC OPERAR

OPERAR PROC FAR

3
PUSH DS

MOV AX,DATOS_S

MOV DS,AX

MOV ES,AX

CLD;ACTIVA EL INCREMENTO AUTOMATICO

MOV SI,OFFSET TABLA1

MOV DI,OFFSET TABLA2

MOV BX,0

LODSW

SBB AX,TABLA2[BX]

STOSW

;RESTA SUCESIVA FORMA FACIL

MOV DX,TABLA2[BX]

MOV CX,0

RESTA:

SBB DX,5

CMP DX,5

INC CX

JA RESTA

MOV COCIENTE,CX

MOV RES,DX

PARCIAL 2012 ARRIOLA

4
SOLUCION

DATOS SEGMENT 'DATA'

;PUBLIC NUMS

;PUBLIC OFFS

NUM DB 2 DUP (?)

MN DB "EL RESULTADO ES ",'$'

OFFS DB 1 DUP (?)

DATOS ENDS

CODIGO SEGMENT 'CODE'

;PUBLIC LTECLA

ASSUME CS:CODIGO, DS:DATOS

LTECLA PROC FARC

MOV AX,0

MOV DS,AX;INICIAMOS EL SEGMENTO DS

MOV AH,01H

INT 21H;LA TLECA SE GUARDA EN AL

CMP AL,32H

JE GUARDAR1

CMP AL,34H

5
JE GUARDAR2

DESPL2:

MOV BX,AX

MOV AX,0H

MOV AH,02H

MOV DL,BL

INT 21H

RET

GUARDAR1:

AND AL,0FH; PASAMOS DE ASCII A BINARIO

MOV NUM,AL

RET

GUARDAR2:

AND AL,0FH;PASAMOS DE ASCII A BINARIO

MOV NUM+1,AL

RET

LTECLA ENDP

CODIGO ENDS

SOLUCION

DATOS SEGMENT 'DATA'

6
;PUBLIC MIN

;PUBLIC SUSTR

;PUBLIC RESTAX8

MIN DW 4 DUP (?)

SUSTR DW 4 DUP (?)

RESTAX8 DW 5 DUP (?)

DATOS ENDS

CODIGO SEGMENT 'CODE'

;PUBLIC RESTA

ASSUME CS:CODIGO, DS:DATOS

RESTA PROC NEAR

;NOS ASEGURAMOS QUE DS=ES

MOV AX,0H

MOV DS,AX

MOV ES,AX

MOV CX,4H

MOV SI,OFFSET MIN

MOV BX,OFFSET SUSTR

CLC;PONEMOS A CERO EL ACARREO

CLD;AUTO INCREMENTO

REST: LODSW;CARGA AX CON MIN

SBB AX,SUSTR[BX]

STOSW;GUARDA EL CONTENIDO DE AX EN RESTAX8

ADD BX,2H

LOOP REST

XOR BX,BX;REESTABLECEMOS A BX

MOV BX,OFFSET RESTAX8

MOV SI,OFFSET RESTAX8

7
MOV CX,3

DESPLAZAMIENTO:

PUSH CX

SHL WORD PTR [BX],1

MOV CX,3H

ROTACION

RCL RESTAX8[SI],1

ADD SI,2H

LOOP ROTACION

POP CX

ADD BX,2H

LOOP DESPLZAMIENTO

RET

RESTA ENDP

CODIGO ENDS

PARCIAL 2013 DUBON

SOLUCION
LITERAL A

CLC

N1 DB (2H);PONEMOS 2H Y 4H PARA REALIZAR LA PRUEBA

8
N2 DB (4H);NO PORQ EN AMBOS IRIA EL SIGNO ?

PASCI DW ?

COCI DB ?

RES DB ?

MOV AL,N1

MUL N2

AAM;AJUSTA A BCD DESCOMPACTADO

PUSH AX;SE GUARDA EN EL STACK

ADD AX,3030H;CONVERTIMOS A ASCII

MOV PASCI,AX

MOV DL,1;PARA QUE LA DIVISION SE REALIZE

POP AX;RECUPERAMOS EL VALOR HEX DEL PROUDCTO

DIV DL

MOV COCI,AL

MOV RES,AH

LITERAL B

COCI DW ?

RESF DW ?

;INICIALIZACION DE REGISTROS

MOV AX,13

MOV SI,0

MOV BYTE PTR[SI],11

;REALIZA DIVISION

DIV BYTE PTR[SI]

MOV BYTE PTR COCI,AL

;RESIDUO FRACCIONARIO

MOV AL,0

CBW;PASAMOS DE BYTE A PALABRA

9
DIV BYTE PTR[SI]

MOV BYTE PTR RESF,AL

LITERAL C

NUMEROS DB ?

ENE DB ?

NMAX PROC NEAR

CLD

MOV SI,0H

MOV DL,0H

MOV DI,0H

;PARA PROBAR GUARDAMOS UN VALOR ENE

MOV WORD PTR ENE[DI],4

MOV CX,WORD PTR ENE[DI];INICIALIZAMOS EL CONTADOR

;AQUI SABEMOS QUE LA TABLA NUMEROS TENDRA CUATRO ELEMENTOS

COMPARA:

MOV AX,0

MOV AL,NUMEROS[SI+1000H]

CMP DL,AL

JAE COPIADO

COPIADO:

MOV DL,NUMEROS[SI+1000H]

INC SI

LOOP COMPARA

RET

NMAX ENDP

10
SOLUCION

DATSEG SEGMENT 'DATA'

;EXTERN DATOSE: BYTE

;EXTERN ENE: BYTE

DATOSE DB ?

ENE DB ?

DATSEG ENDS

CODSEG SEGMENT 'CODE'

ASSUME CS:CODSEG,DS:DATOSEG

;PUBLIC PROME

PROME PROC FAR

MOV SI,0

MOV ENE[SI],8H;PARA PROBAR

MOV CX,WORD PTR[ENE]

LEER:

IN AL,DX;LEEMOS DEL PUERTO

MOV DATOSE[SI],AL;GUARDAMOS EL DATO DEL PUERTO

INC SI

11
LOOP LEER

CMP ENE,8H

JE PROMEDIO

JB NOT_FUND

NOT_FUND:

RET

PROMEDIO:

MOV BX,OFFSET DATOSE

MOV DL,0H

CLC

MOV CX,4H

SUMA:

ADC DL,BYTE PTR [BX]

INC BX

LOOP SUMA

MOV DATOSE[SI],DL

INC SI

EXTER:

DEC SI

SHR DATOSE[SI],1

PUSH CX

PUSH SI

MOV CX,3

INTER:

RCR DATOSE[SI-1],1

DEC SI

LOOP INTER

POP SI

12
POP CX

LOOP EXTER

PROME ENDP

CODSEG ENDS

END

PROBLEMAS VARIOS

1- Escriba un procedimiento ASCIBIN que suma dos nmeros de 10 dgitos ASCII cada uno.
La tabla NUM1 contiene uno de los nmeros. La tabla NUM2 el otro nmero. El
resultado de la suma debe quedar en binario en la tabla SUMAB, para cada byte que se
suma. Despus de este resultado, si el bit de acarreo es cero se retorna si no lo es se
pone un uno en la localidad CARRY y luego se comprueba sii el bit menos significante de
la suma es 1. Si es, se pone 1 en la localidad IMPAR y se retorna si no lo es, se retorna.
(AYUDA: no sumar 3030, usar AAA y AAD).
SOLUCION

DATOS SEGMENT 'DATA'

;PUBLIC NUM1

;PUBLIC NUM2

;PUBLIC SUMAB

;PUBLIC CARRY

;PUBLIC IMPAR

NUM1 DW ?

NUM2 DW ?

SUMAB DW ?

CARRY DW ?

IMPAR DW ?

DATOS ENDS

CODIGO SEGMENT 'CODE'

;PUBLIC ASCIBIN

ASSUME CS:CODIGO, DS:DATOS

ASCIBIN PROC NEAR

13
MOV SI,0H

MOV AX,NUM1[SI]

MOV BX,NUM2[SI]

AAA;AJUSTAMOS A ASCII

ADC AX,BX

AND AX,AX;PASAMOS A BINARIO

MOV SUMAB[SI],AX

JAE RETORNO

JB COLOCAR

RETORNO:

RET

COLOCAR:

MOV CARRY[SI],1H

TEST AX,1;COMPARAMOS EL BYTE

JE COLOCAR1

RET

COLOCAR1:

MOV IMPAR[SI],1H

RET

ASCIBIN ENDP

CODIGO ENDS

2- Escriba un procedimiento lejano CDIV que primero compara si 2 numeros A y B, de 3


palabras cada uno (A>B), son totalmente diferentes, es decir si ninguna de las palabras
que lo forman son iguales. Si son totalmente diferentes se divide A entre B por medio de
restas sucesivas. Si no lo son se retorna con el bit c en uno. Considere que el segmento
DS coincide con el segmento ES (tienen el mismo inicio de segmento), que A se
encuentra primero en memoria, luego sigue B, despus C (una palabra donde quedara el
cociente de la divisin) y a continuacin la localidad RESTA a partir de la cual se definen
3 palabras que contendrn las restas sucesivas obtenidas. Utilice instrucciones de string
para comparar los numeros, para leer el sustraendo de cada resta use BX con
direccionamiento indirecto. Los numeros A, B y C deben ser accesibles al programa
llamador. Asuma que la divisin es exacta(no hay residuo ).

14
SOLUCION

DATOS SEGMENT 'DATA'

;PUBLIC A

;PUBLIC B

;PUBLIC C

;PUBLIC RESTA

A DW 3 DUP (?)

B DW 3 DUP (?)

C DW 3 DUP (?)

RESTA DW ?

DATOS ENDS

CODIGO SEGMENT 'CODE'

;PUBLIC CDIV

ASSUME CS:CODIGO, DS:DATOS, DS:ES

CDIV PROC FAR

CLC

MOV SI,0H

MOV CX,3H

COMPARAR:

MOV AX,A[SI]

MOV BX,B[SI]

CMP AX,BX

JE SALIR

INC SI

LOOP COMPARAR

SALIR:

STC

RET

15
MOV SI,0H

MOV CX,0H

RESTAR:

MOV AX,A[SI]

MOV BX,B[SI]

SBB AX,BX

MOV RESTA[SI],AX

INC SI

JA RESTAR

MOV C,CX

3- Para un microprocesador 8086 escriba las instrucciones necesarias para multiplicar una
doble palabra almacenada en memoria en el segmento DS, desde la posicin VALOR, por
2(32k+1), usando instrucciones de rotacin y desplazamiento. El resultado debe quedar
almacenado en el mismo lugar donde estaba la doble palabra original con 3 bytes
adicionales a continuacin se pueden usar registros intermedios.
SOLUCION

;VALOR*2(32K+1)=VALOR*64K+VALOR*2
VALOR DD 12345678H
copia DD ?
mov si,offset VALOR
mov di,offset copia
mov ax,[si]
mov bx,[si+2]
mov [di],ax
mov [di+2],bx
mov ax,0h
mov bx,0h
mov ax,2
CWD
mov cx,15
ELEVAR:
shl bx,1;bx es el menos significante
rcl ax,1;palabra mas signicante
loop ELEVAR
add bx,2
VALORPOR2:
clc
adc VALOR,word ptr[di]
sbb ax,1
cmp ax,0

16
ja VALORPOR2
sbb bx,1
cmp bx,0
ja VALORPOR2

shl word ptr[si],1


rcl word ptr[si+2],1

adc word ptr VALOR[si],ax


adc word ptr VALOR[si+2],bx

4- Mtodo de la burbuja para ordenar datos.


SOLUCION

;PROGRAMA QUE ORDENA UNA TABLA


;DE DATOS EN FORMA ASCENDENTE
;AUTORES:INTERNET+JAIME, JAJAJAJA!!!
tabla db 8h
db 4h
db 9h
db 1h
db 3h
db 7h
burbuja proc near
mov si,offset tabla
mov di,si
mov cx,5
mov ax,0h
inicio:
mov bx,5
mov di,0h
ordenar1:
inc di
mov al,[si]
mov dl,[di]
cmp al,dl
jge ordenar2
jmp next
ordenar2:
mov al,[di]
mov dl,[si]
mov [si],al
mov [di],dl
next:
sub bx,1
cmp bx,0
ja ordenar1
inc si
loop inicio
endp burbuja

17
5- Ordenar una lista de n nmeros dentro de una tabla LISTANS de bytes en orden
ascendiente el valor de n se encuentra en la palabra total
SOLUCION

.model small
.data
total dw 7
listans db 7 dup(?)
temp db ?

.code
.startup

;lellendo numeros
mov si,offset listans
mov cx,total
mov ah,1
llenar:
int 21h
mov [si],al
inc si
loop llenar

;ordenando datos
mov si,offset listans
mov cx,total
loop1:
push cx
push si
mov dx,total
sub dx,1
mov cx,dx
loop2:

mov al,[si]
cmp al,[si+1]
jb seguir
mov temp,al
mov al,[si+1]
mov [si],al
mov al,temp
mov [si+1],al

seguir:
inc si
loop loop2
pop si
pop cx
loop loop1

;mostrando numeros

18
mov si,offset listans
mov cx,total
mov ah,2
mostrar:
mov dl,[si]
int 21h
inc si
loop mostrar
.exit
End

6- Realice un codigo que pida dos nmeros desde pantalla,


realice la multiplicacin y muestre su resultado en pantalla
SOLUCION

.MODEL SMALL
.DATA
MN DB 'ESTE PROGRAMA MULTIPLICA NUMEROS CUYO RESULTADO MAXIMO ES
99',0AH,0DH,'$'
MN1 DB 'INGRESE EL PRIMER NUMERO:$'
MN2 DB 0AH,0DH,'INGRESE EL SEGUNDO NUMERO:','$'
MN3 DB 0AH,0DH,'EL RESULTADO DE LA MULTIPLICACION ES:','$'
.CODE
.STARTUP
LEA DX,MN
MOV AH,09H
INT 21H
LEA DX,MN1
MOV AH,09H
INT 21H
MOV AH,01H
INT 21H
SUB AL,30H
MOV BL,AL;GUARDO EL PRIMER NUMERO EN 1000H
LEA DX,MN2
MOV AH,09H
INT 21H
MOV AH,01H
INT 21H
SUB AL,30H
MOV AH,0H
MUL BL; Multiplicamos 1000H * 1001H y el contenido se almacena
en AX por ser el . ;resultado de la multiplicacin de un byte por
otro byte.
PUSH AX;GUARDO EN LA POSICION SIGUIENTE DE DONDE FUERON
TOMADOS LOS DATOS EL RESULTADO
LEA DX,MN3
MOV AH,09H
INT 21H
MOV DX,0H
POP DX
CMP DL,9H

19
JG DECENAS
JMP MUESTRA
MOV CX,2
DECENAS:
SUB DL,0AH
ADD DH,1
CMP DL,0AH
JG DECENAS
MOV BL,DL
MOV DL,DH
ADD DL,30H
MOV AH,02H
INT 21H
ADD BL,30H
MOV DL,BL
MUESTRA:
MOV AH,02H
INT 21H
.EXIT
END

7- Escriba un programa con modelo de memoria tiny, para MASM 6.0


en adelante que acepte un nombre de hasta 30 caracteres
ASCII, con la funcin 0AH de la interrupcin 21H (El tercer
byte correspondiente contiene contiene el primer carcter
introducido). El nombre introducido debe aparecer despus del
mensaje :'introduzca nombre:'. Este mensaje debe aparecer a
partir de la fila 11 y columna 10 de la pantalla. Asuma
pantalla ya limpia. Si una tabla NOMBRES contiene 2 nombres
tambin de 30 caracteres mximo (pueden dejarse indefinidos
en el programa), en la siguiente fila reubicando el cursor
debajo del inicio del mensaje1, debe aparecer el mensaje
'nombre autorizado' si el nombre que se introdujo est en la
tabla y se retorna al DOS. si no lo est, el mensaje es
'nombre no autorizado' y tambin se retorna al DOS Utilice la
instruccin scasb con repe. No use llamadas a subrutinas.
SOLUCION
.MODEL TINY
.CODE
.STARTUP
JMP INICIO
BUFFER DB 32 DUP(?)
MN1 DB 'INTRODUZCA NOMBRE:$'
MN2 DB 0AH,0DH,'NOMBRE AUTORIZADO, YEAH!!','$'
MN3 DB 0AH,0DH,'NOMBRE NO AUTORIZADO, NO ME MOLESTE','$'
BUFFER2 DB 62 DUP (?)
INICIO:

MOV BUFFER2,30
MOV CX,2
RECIBE:

20
LEA DX,BUFFER2
MOV AH,0AH
INT 21H
LOOP RECIBE
MOVDL,11;DL CONTIENE LA FILA
MOVDH,10;DH CONTIENE COLUNMA
MOVAH,02H;INSTRUCCION PARA POSICIONAR CURSOR
INT10H;INTERRUCION QUE USA FUNCIONES DE VIDEO
LEADX,MN1
MOVAH,09H
INT21H
MOV BUFFER,30;LE DECIMOS AL BUFFER EL # DE CARACTERES QUE
LEERA
LEA DX,BUFFER
MOV AH,0AH;CAPTURA DE CADENA CON ECO
INT 21H
MOV CX,30
MOV SI,OFFSET BUFFER
ADD SI,2
MOV AL,[SI]
MOV DI,OFFSET BUFFER2
CLD
COMPARA:
REPE SCASB
JNZ SIGUIENTE
JMP OTRO
SIGUIENTE:
INC SI
CMP SI,30
JA COMPARA
CMP CX,0
JNZ VALIDO
JMP INVALIDO
OTRO:
ADD DI,29
CMP DI,30
JB COMPARA
JMP INVALIDO
VALIDO:
LEA DX,MN2
MOV AH,09H
INT 21H
INVALIDO:
LEA DX,MN3
MOV AH,09H
INT 21H
.EXIT
END

8- PROGRAMA QUE COMPARA UNA CADENA INGRESADA DESDE TECLADO SIN


ECO Y LA GUARDA EN LA DIRECCION DE MEMORIA ETIQUETADA COMO
buffer LUEGO LA COMPARA CON UNA CADENA ALMACENADA EN MEMORIA

21
PARA VERIFICAR SI LA CADENA EN MEMORIA ES IGUAL A LA CADENA
INGRESADA, MOSTRANDONOS EL MENSAJE 'SON IGUALES', SI LA
CADENA INGRESADA ES IGUAL A LA CADENA ALMACENADA EN MEMORIA Y
EL MENSAJE 'SON =!', SI LA CADENA INGRESADA DESDE TECLADO ES
DIFERENTE A LA CEDANA ALMACENADA EN MEMORIA.
SOLUCION
.model tiny
.code
jmp inicio
msj db 'muerto$'
msj1 db 'muerto$'
msj2 db 'son =$'
msj3 db 'son =!$'
buffer db 6 dup(?)

inicio:
lea si,buffer
mov cx,6
recibir:
mov ah,07h
int 21h
mov [si],al
inc si
loop recibir

mov si,offset buffer


mov di,offset msj1
cld
mov cx,6
repe cmpsb
je fin
jne fin2

fin2:
mov ah,09h
mov dx, offset msj3
int 21h
jmp salir

fin:
mov ah,09h
mov dx, offset msj2
int 21h
jmp salir
salir:
end

22

También podría gustarte