Ejercicios resueltos en Ensamblador 8086

| 2013-05-20 | No hay comentarios »

En este artículo les voy a dejar los programas más importantes que he hecho en Ensamblador. La mayoría de los programas eran tareas que me dio mi profesor en la universidad.

Ejercicio 1: Escribir un código que verifique si dos cadenas son iguales

org 100h
comienzo: 
mov si, x
mov al, msg2[si]
cmp msg[si], al ;comparar letra por letra las cadenas, si uno no coincide manda directamente a fin y termina el programa
jne fin:
cmp msg[si], "$" ;si es el final y el programa llega aca, quiere decir que son iguales
jz final:
inc x
loop comienzo
final:
mov dx, offset msg3 
mov ah, 9
int 21h
fin:
ret
msg db "hello world $" 
msg2 db "hello world $" 
msg3 db "Son iguales $"
x dw 0

Ejercicio 2: Escribir un código que verifique si una cadena es subcadena de otra.

Por ejemplo: “la Mu” es subcadena de “Hola Mundo”.

La cadena: “233″ es subcadena de la cadena “2122432234″

org 100h
mov si, 0 ;ponemos si en 0
comienzo: 
mov al, msg2[0] ;copiar la primera letra de la palabra a al
cmp msg[si],"$" ;si es el fin de la cadena mandar a final
jz final
cmp msg[si], al ;comparar si encuentra la primera letra de la cadena
jne seguir

 mov di, 1 ;poner en 1 di
 comprobar:
 mov al, msg2[di]
 mov bx, di
 cmp msg[si+bx], al ;posicion de la letra coincidente + di, comparar con la cadena
 jne seguir ;si no coincide mandar a seguir

 inc di ;incrementar di para seguir recorriendo cadena 

 cmp msg2[di],"$" ;si es el fin de la cadena y el programa llego aca quiere decir que la cadena es parte de la palabra
 jz resultado 

 loop comprobar ;bucle para recorrer cadena 

seguir: 
inc si ;para seguir recorriendo la palabra
loop comienzo ;bucle principal para recorrer palabra
resultado:
mov dx, offset msg3 ;copiar msg3 a dx
mov ah, 9 ;preparar ah con 9 para la interrupcion 21h
int 21h ;mostrar contenido en dx
final:
ret
msg db "Hola Mundo$" 
msg2 db "ola$" 
msg3 db "Si es subcadena$"

Ejercicio 3: Escribir un código que verifique que todas los caracteres de una cadena se encuentran en otra.

Por ejemplo: todas las letras de la cadena “casa” se encuentran en “escaso”. Pero no todas las letras de “cerro” se en cuentran en “recanate”

org 100h
mov si, 0 ;ponemos si en 0
comienzo:
cmp msg[si],"$" ;si es el fin de la cadena mandar a final
jz resultado

 mov di, 0 ;poner en 0 di
 comprobar:
 mov al, msg2[di] ;copiar msg2 con su posicion a al
 cmp msg[si], al ;comparar msg con su posicion con al
 jz seguir ;si se encuentra entonces continua

 inc di ;incrementar di para seguir recorriendo cadena
cmp msg2[di], "$" ;si es que llega al final y no encontro coincidencia, entonces ya termina el programa
 jz final 

 loop comprobar ;bucle para recorrer

seguir: 
inc si ;para seguir recorriendo la palabra
loop comienzo ;bucle principal para recorrer palabra
resultado:
mov dx, offset msg3 ;copiar msg3 a dx
mov ah, 9 ;preparar ah con 9 para la interrupcion 21h
int 21h ;mostrar contenido en dx
final:
ret
msg db "cerro$" 
msg2 db "recanate$" 
msg3 db "Si se encuentran todos los caracteres$"

Ejercicio 4: Escribir una programa que reciba una cadena ingresada por teclado, terminada en ENTER. Luego que elimine todos los caracteres que no son dígitos, sin utilizar una variable auxiliar.

ORG 100H
mov si, 0
lectura:
 mov ah,1
 int 21h

 cmp al,13 
 jz resultado: 

 cmp al, 57 ;si tecla es mayor a 57 entonces ir a fin3 (tecla > 57) 
 ja fin3
cmp al,47 ;si tecla no es mayor a 47 ir a fin3 (tecla <= 47)
 jng fin3
mov bx[si], al ;si es un digito entonces guardo en bx

 inc si ;incrementa si

 fin3: 

jmp lectura 

resultado:
 mov ah,00h ;limpia la pantalla
 mov al,03h
 int 10h
mov bx[si], "$" 
mov dx, offset bx
mov ah, 9 ;preparar ah con 9 para la interrupcion 21h
int 21h ;mostrar contenido en dx
ret

Ejercicio 5: Escribir un programa que tome una cadena que representa un número decimal y escriba su equivalente octal

org 100h ; inicio de programa
mov si, 0
mov al, 0

 cadAnum:
cmp cad[si], "$"
 jz seguir

 mov bl, 10 
 mul bl
sub cad[si], '0' 
 add al, cad[si]

 inc si
loop cadAnum

seguir:
mov cx, si 
mov si, 0
mov bl, 8
pasar: 
 div bl ;dividir al con bl
 mov oct[si], ah ;copiar a la cadena oct el resultado sobrante de la division
 inc si ;incrementar si
 loop pasar
fina:
cmp ah, 0
jnz final
mov oct[si], al
final:
;mov dx, offset res
;mov ah, 9 ;preparar ah con 9 para la interrupcion 21h
;int 21h ;mostrar contenido en dx
ret
cad db "64$"
oct db 0

Ejercicio 6: Escribir un programa que tome tres cadenas, la primera y la tercera representan un número y la segunda una operación, por ejemplo: “329″, “-”, “21″ e imprima el resultado “308″

org 100h ; inicio de programa
include 'emu8086.inc' ;Incluye funciones de libreria emu8086 
; DEFINE_SCAN_NUM
; DEFINE_PRINT_STRING
 DEFINE_PRINT_NUM
 DEFINE_PRINT_NUM_UNS
mov si, 0
mov al, 0
;Convertir primera cadena a numero
 cadAnum:
cmp cad1[si], "$"
 jz seguir

 mov bl, 10 
 mul bl
sub cad1[si], '0' 
 add al, cad1[si]

 inc si
loop cadAnum

seguir:
mov aux1, al
;Convertir segunda cadena a numero
mov si, 0
mov al, 0
cadAnum2:
cmp cad3[si], "$"
 jz seguir2

 mov bl, 10 
 mul bl
sub cad3[si], '0' 
 add al, cad3[si]

 inc si
loop cadAnum2

seguir2:
mov bl, al 
mov al, aux1
;realizar operaciones normalmente teniendo ya los dos numeros decimales
cmp cad2, "-"
jz resta 
cmp cad2, "+"
jz suma 
cmp cad2, "*"
jz multi 
cmp cad2, "/"
jz divi
resta: 
sub al, bl
jmp fin
suma: 
add al, bl
jmp fin
multi: 
mul bl
jmp fin
divi: 
div bl
jmp fin

fin:
mov bx, ax
mov ah,09 
lea dx,msg
int 21h 
mov ax, bx
call PRINT_NUM
ret
cad1 db "10$"
cad2 db "-"
cad3 db "2$"
aux1 db ?
aux2 dw ?
msg dw "El resultado es: $"

Ejercicio 7: Escribir un programa que imprima X en la pantalla hasta que se presiones ESC.

name "keybrd"
org 100h
; print a welcome message:
mov dx, offset msg
mov ah, 9
int 21h
;============================
; eternal loop to get
; and print keys:
wait_for_key:
; check for keystroke in
; keyboard buffer:
mov dh, pos
 mov dl, pos
 mov bh, 0
 mov ah, 2
 int 10h ;Movemos el cursor
 mov al,'X'
 mov bh,0
 mov bl,1
 mov cx,1
 mov ah,09h
 inc pos ;Imprimimos una x
 int 10h
 mov ah, 1
 int 16h
 jz wait_for_key
; get keystroke from keyboard:
; (remove from the buffer)
mov ah, 0
int 16h
; print the key:
mov ah, 0eh
int 10h
; press 'esc' to exit:
cmp al, 1bh
jz exit
jmp wait_for_key
;============================
exit:
ret
msg db "Type anything...", 0Dh,0Ah
 db "[Enter] - carriage return.", 0Dh,0Ah
 db "[Ctrl]+[Enter] - line feed.", 0Dh,0Ah
 db "You may hear a beep", 0Dh,0Ah
 db " when buffer is overflown.", 0Dh,0Ah
 db "Press Esc to exit.", 0Dh,0Ah, "$"
pos db 1
end

Ejercicio 8: Escribir un programa que ordene un vector de mayor a menor.

name "arreglo-mayor"
org 100h
mov cx, 8 
 bucle1:
 mov c, cx

 mov bx, cx
 mov cx, 9

 bucle2: 
 mov si, cx
 mov ah, v[si-1] 
 cmp ah,v[bx-1]
 jnge seguir ;Si v[8] < v[7] no hacer nada, sino:
 mov dh, v[bx-1] ;Copiar v[7] en dh
 mov dl, v[si-1] ;Copiar v[8] en dl
 mov v[bx-1], dl ;Copiar dl en v[7]
 mov v[si-1], dh ;Copiar dh en v[8] 
 seguir:
 loop bucle2

 mov cx, c
 loop bucle1
ret
v db 2,32,64,32,98,12,5,21,91
c dw 0

Ejercicio 9: Escribir un programa que halle el MCM Y MCD

; Programa que calcula el MCD y MCM de dos numeros decimales (soporta numeros de 8 bits o 1 byte)
mov cont,1 ;inicializar variable cont en 1
bucle: 
 mov ah,0
 mov al,cont
 mov bl,nro1
 div bl
 cmp ah,0 ;si el resto de la division del contador con el nro1 es igual 0
 je parte1 
 bc:
 inc cont ;incrementar el contador
 jmp bucle ;bucle hasta que encuentre el MCM

parte1: ;si nro1 es multiplo del contador
 mov ah,0
 mov al,cont
 mov bl,nro2
 div bl
 cmp ah,0 ;compara si el resto de la division del contador con el nro2 es 0
 je parte2 
 jmp bc ;si el nro2 no es multiplo del contador regresa a bucle1
parte2: ;si el nro1 y el nro2 son multiplos del contador
 mov al,cont
 mov MCM,al ;guarda el MCM
 jmp parte3 ;ir a final

 parte3: ;una vez que tengamos el MCM primero multiplicar nro1 * nro 2
 mov al, nro1 ;con ese resultado, dividir por el MCM de nro1 y nro2 y tenemos el MCD
 mov bl, nro2
 mul bl
 mov bl, MCM
 div bl 
 mov MCD, al 
ret ;fin del programa

cont db 0 ;cont = contador 
MCM db 0 ;en esta variable se guarda el MCM
MCD db 0 ;en esta variable se guarda el MCD
nro1 db 48 ;numero1 decimal
nro2 db 60 ;numero2 decimal

Ejercicio 10: Escribir un programa que dibuje una diagonal en la pantalla.

mov cx,1
mov al, 13h
 mov ah, 0
 int 10h ; set graphics video mode. 

bucle1:
 mov dx, cx 
 mov al, color ;AL = pixel color
 mov ah, 0ch ;Change color for a single pixel
 int 10h ;set pixel 

 cmp cx, 101 ;llegar hasta 100 x 100 (va en diagonal)
 jz fin 

 inc cx ;DX = row.
 add color, 2 ;para cambiar colores 
jmp bucle1 ;CX = column
fin:
ret
color db 1

Ejercicio 11: Escribir un programa que lea un archivo y cuente cuantas palabras terminan con la letra a.

name "archivo3"
org 100h
 mov al, 0 ;modo de acceso para abrir arhivo, modo lectura/escritura
 mov dx, offset archivo ;offset lugar de memoria donde esta la variable
 mov ah, 3dh ;se intenta abrir el archivo
 int 21h ;llamada a la interrupcion DOS
 jc error ; si se prendio la bandera c ir a error

 mov handle, ax ;si no paso mover a lo que le dio el SO
 jmp leer

 error:
 ; ....

 ;leer archivo 
 leer:
 mov bx, handle
 mov cx, 1
 mov dx, offset leido
 mov ah, 3fh
 int 21h

 cmp ax, 0 ;ax queda en 0 cuando llega a EOF
 jz FIN ;si es 0 entonces va a fin para cerrar archivo 

 ;Detectar palabras que terminan con a
 mov dl, leido[0]

 cmp dl, " " ;comparar si es espacio
 jz mostrar ;si es espacio entonces ir a mostrar

 jmp abajo ;si no es espacio entonces ir a abajo

 mostrar:
 cmp aux, "a" ;compara si el anterior es a
 jnz abajo

 inc cont ;si es a entonces incrementar contador

 abajo:
 mov aux, dl ;guardar en aux lo que hay en dl para comparar en la proxima vuelta
 jmp leer

FIN: 

 ;cerramos archivo
 mov bx, handle
 mov ah, 3eh
 int 21h

 ret 

archivo db "C:\prueba.txt", 0 ;ascii del nombre del archivo 
leido db "$"
handle dw ? ;identificador del arhivo 
aux db "$"
cont db 0

Acerca del autor: Rodrigo Paszniuk

Técnico Superior en Informática. Estudiante de Ing. Informática, amante de la tecnología, la música y aprender cosas nuevas. En mis tiempos libres me gusta jugar vídeojuegos, programar o practicar ciclismo.

Posts Relacionados

  • Ejemplos de programas en Ensamblador 8086
  • Introducción al lenguaje Ensamblador


Deja un comentario

Tu debes loguearte para hacer comentarios.





GitHub


Comentarios recientes


    Licencia del contenido