; suma los 10 primeros numeros enteros mov ah,4ch

; el resultado queda almacenado en AX int 21h

.model small end ini
.code
ini: ; halla AX^BX, resultado en AX
mov cx,10 ; asigna a CX la cantidad de enteros .model small
a sumar .code
mov ax,0 ; inicializa la suma (AX) con 0 ini:
mov bx,1 ; BX <-- 1 , es el 1er entero a sumar mov ax,3 ; establece la base
otra_vez: mov bx,7 ; establece la potencia
add ax,bx ; suma a AX el N_esimo entero
inc bx ; pasar al siguiente entero mov cx,bx ; establece # de iteraciones (7)
loop otra_vez ; decrementa CX, sino es 0 vuelve a mov bx,ax ; BX <-- 3, asigna a BX la base (3)
iterar mov ax,1 ; AX <-- 1, inicializa la potencia con 1
mov ah,4ch ; salir a01:
int 21h mul bx ; AX <-- AX * BX (multiplica CX veces
end ini BX)
loop a01
; calcula el factorial de NUM y lo almacena en AX
; AX = NUM*(NUM-1)*(NUM-2)... mov ah,4ch
.model small int 21h
.const end ini
NUM=5 ; factorial de 5
.code ; halla el N_esimo termino de la serie de fibonacci
ini: ; AX contiene el resultado
mov cx,NUM ; establece # de iteraciones .model small
mov ax,1 ; inicializa factorial a 1 .code
a01: ini:
mul cx ; AX = AX * CX mov cx,8 ; CX es la cantidad de terminos a
loop a01 ; CX = CX - 1 determinar
mov ax,1 ; AX es el termino -1
mov ah,4ch mov bx,0 ; BX es el termino 0, T(1)=T(-1)+T(0),
int 21h T(2)=T(0)+T(1)...
end ini a01:
mov dx,ax ; DX <-- AX
; halla el MCD mediante el algoritmo de Euclides add dx,bx ; DX <-- DX + BX = AX + BX
; AX contiene al MCD mov ax,bx ; AX pasa a ser el siguiente termino
.model small mov bx,dx ; BX pasa a ser el ultimo termino
.code loop a01 ; mientras CX>0 vuelve a iterar
ini:
mov ax,42 ; AX es el numero mayor mov ah,4ch
mov bx,18 ; BX es el numero menor int 21h
a01: end ini
xor dx,dx ; hace DX=0
div bx ; DX_AX/BX ; halla la suma de los digitos del numero AX
mov ax,bx ; divisor pasa a ser dividendo ; divide sucesivamente AX entre 10 y acumula los
mov bx,dx ; residuo pasa a ser divisor residuos (digitos)
or dx,dx ; si residuo es 0 ; en SI, resultado en SI
jne a01 ; vuelve a iterar .model small
; sino sale .code
mov ah,4Ch ini:
int 21h mov ax,1234 ; AX <-- # a procesar
end ini mov bx,10 ; BX <-- 10
mov si,0 ; inicializa suma(SI) con 0
; halla la suma de los divisores de un numero a01:
dividiendolo xor dx,dx ; DX <-- 0
; entre 1, 2, 3, ... cada vez que el residuo es 0, lo div bx ; DX_AX/BX
acumula add si,dx ; suma a SI el residuo de la division
; en el registro DI (digito)
.model small or ax,ax ; comprueba si dividendo es 0
.code jnz a01 ; regresa a a01 sino es 0
ini:
mov si, 18 ; SI contiene el nro a analizar mov ah,4ch
mov di,0 ; se inicializa la suma (DI) con 0 int 21h
mov bx, 1 ; BX divisor inicial (1) end ini
a01:
mov ax,si ; Dividendo (AX) <-- SI ; halla el entero mas cercano a la raiz
div bl ; AX/BL ; cuadrada de un entero
cmp ah,0 ; comparar residuo con 0 .model small
jne a02 ; saltar a a02 si no es igual .data
add di,bx ; si residuo es 0, acumular en DI el x dw 30
divisor a dw 20
a02: .code
inc bl ; pasar al siguiente valor (divisor) ini:
cmp al,0 ; si AL=0 ==> ya no hay mas divisores mov ax,@data
jne a01 mov ds,ax

1
a01: cmp al,min ; AL < min ?
xor dx,dx jae a03 ; salta a a03 si no lo es
mov ax,x mov min,al ; si AL < min ===> min <-- AL
mov bx,a a03:
div bx loop a01
add ax,a
shr ax,1 mov ah,4ch
cmp ax,a int 21h
je salir end ini
mov a,ax
jmp a01 ; halla el mayor y menor elemento de un arreglo
salir: ; de 13 elementos, las variables max y min
; AX contiene la raiz contienen
mov ah,4ch ; los resultados
int 21h .model small
end ini .data
notas db 10,12,7,16,5,19,12,8,10,8,9,10,11
; Imprime el entero AX en el sistema de max db ?
; numeracion base 5 min db ?
.model small .code
.code ini:
extrn impchr:near mov ax,@data
ini: mov ds,ax ; DS apunta al segmento de
mov ax,1234 ; establece el numero a imprimir datos
mov bx,5 ; establece la base mov si,offset notas ; SI apunta al 1er elemento del
xor cx,cx ; inicializa el contador de digitos arreglo notas
sge: xor dx,dx ; DX <-- 0 mov al,[si] ; tomamos el 1er elemento en AL
div bx ; DX_AX/BX y lo asignamos
push dx ; apilar residuo mov max,al ; a max y min (variables) debido
inc cx ; incrementar contador de digitos a que no esta
cmp ax,0 ; verificar si aun se puede mov min,al ; permitido MOV max,[SI]
descomponer el # (memoria a memoria)
jne sge ; regresa a descompner el # mov cx,13 ; CX <-- cantidad de elementos
imp: pop ax ; desapila digito en AX (AL contiene del arreglo
el digito) a01:
add al,'0' ; se convierte digito a caracter ( 7 --> lodsb ; cargamos elemento apuntado por
'7' SI
call impchr ; se imprime caracter AL cmp al,max ; AL > max ?
loop imp ; decrementa CX, sino es 0 regresa jbe a02 ; salta a a02 si no lo es
imp mov max,al ; si AL > max ===> max <-- AL
mov ah,4ch a02:
int 21h cmp al,min ; AL < min ?
end ini jae a03 ; salta a a03 si no lo es
mov min,al ; si AL < min ===> min <-- AL
ARREGLOS a03:
loop a01
; halla el mayor y menor elemento de un arreglo ;
de 13 elementos, las variables max y min mov ah,4ch
contienen ; los resultados int 21h
.model small end ini
.data
notas db 10,12,7,16,5,19,12,8,10,8,9,10,11 ; halla la cantidad de veces que apaprece la "a" en
max db ? una ; cadena asciiz, CX contiene resultado
min db ? .model small
.code .data
ini: cadena db "bienvenidos al maravilloso mundo del
mov ax,@data ensamblador",0
mov ds,ax ; DS apunta al segmento de .code
datos ini:
mov si,offset notas ; SI apunta al 1er elemento mov ax,@data
del arreglo notas mov ds,ax ; DS apunta al segmento de
mov al,[si] ; tomamos el 1er elemento en AL datos
y lo asignamos mov si,offset cadena ; SI apunta al 1er elemento
mov max,al ; a max y min (variables) debido de la cadena
a que no esta mov cx,0 ; CX contador
mov min,al ; permitido MOV max,[SI] a01:
(memoria a memoria) lodsb ; carga caracter de la cadena
mov cx,13 ; CX <-- cantidad de elementos apuntada por SI
del arreglo or al,al ; es fin de cadena? (caracter nulo)
a01: je fin ; si es el caracter nulo, salir
lodsb ; cargamos elemento apuntado por cmp al,'a' ; es el caracter 'a'?
SI jne a01 ; sino es, regresa a a01
cmp al,max ; AL > max ? inc cx ; incrementa contador
jbe a02 ; salta a a02 si no lo es jmp a01
mov max,al ; si AL > max ===> max <-- AL
a02: fin:

2
 mov ah,4ch ADD AL, [203] ;sumar el contenido de la localidad 201
int 21h a AL 8 LSB
end ini MOV [206], AL ;mover el contenido de AL a la
localidad 206
; Determina si una palabra es o no un palindromo MOV AL, [201] ;mover el contenido de la localidad 201
.model small a AL
.data ADC AL, [204] ;sumar el contenido de la localidad 204
cad db 'anilina',0 con AL 2º BYTE
sies db 'Si es un palindromo',0 MOV [207], AL ;mover el contenido de AL a la
noes db 'No es un palindromo',0 localidad 207
.code MOV AL, [202] ;mover el contenido de la localidad 202
extrn impcad:near a AL
ini: ADC AL, [205] ;sumar el contenido de la localidad 205
mov ax,@data con AL 8 MSB
mov ds,ax MOV [208], AL ;mover el contenido de AL a la
mov bl,14h ; establece color de impresion localidad 208
RET
mov di,offset cad ; DI apunta al 1er chr de cad
mov si,di ; SI apunta al 1er chr de cad Uso del registro CX como contador. Vamos a mover
a01: cmp byte ptr [di],0 ; [DI] apunta al chr nulo? los 8 bits menos
je a02 ; salir del bucle significativos del registro BL al registro BH.
inc di ; sino pasa al sgte chr Sean los datos iniciales:
jmp a01 ; vuelve a iterar BX = BH y BL = 43A6
a02: dec di ; retrocede un chr La instrucción que usaremos será RLC BX, 1, 8
cmp si,di ; compara los punteros veces. Para este tipo
jae a03 ; si SI>=DI, salta a a03 de repeticiones usaremos al registro CX como contado
lodsb ; sino, carga en AL el chr apuntado ROTA8: MOV BX, 43A6 ;(1)
por DS:SI (SI incremnta) MOV CX, 08 ;(2)
cmp al,[di] ; compara los caracteres OTRAVEZ: RLC BX, 1 ;(3)
je a02 ; si son iguales regresa a a02 LOOP OTRAVEZ ;(4)
mov si,offset noes ; sino MOV AH, 4C ;(5)
call impcad ; imprime "no es palindromo" INT 21 ;(6)
jmp salir ; salir
a03: mov si,offset sies ; imprime "si es palindromo" Investigar una cadena de caracteres ASCII para
call impcad determinar el último carácter distinto del blanco.
salir: La cadena empieza en la localidad 202 y
mov ah,4ch finaliza con CR (0Dh) Colocar la dirección del último
int 21h carácter diferente
end ini del espacio en la localidad 200 y 201.

El contenido de la localidad 0200 tiene un dato de X: MOV AL, [SI]

8 bits. Realizar un programa que coloque en la CMP AL, 0dh ;AL vs ´CR´
localidad de memoria 0201 el nibble (4bits) más JE Almacena
significativo, tomando en cuenta que el nibble CMP AL, 20h ;AL vs ´SPACE´
menos significativo JE ANTESALM
debe ser 0. INC SI
JMP X
MOV AL, [200] ;mueve el contenido de la localidad 200 ANTESALM: DEC SI
a AL ALMACENA: MOV 200, SI
AND AL, F0 ;coloca 1111 0000 en AL END
MOV [201], AL ;mueve el contenido de AL a la
localidad 201 Comparar dos cadenas de caracteres ASCII para
MOV AH, 4C ;mueve el contenido de 4C a AH determinar cuál sigue a la otra en orden alfabético.
INT 21 La longitud de las cadenas está en la localidad
201. Una cadena inicia en la localidad 202 y la otra
Realizar un programa que coloque en la localidad en la localidad 252. Si la cadena que inicia en la
de memoria 202 el número menor de los localidad 202 es menor o igual a la otra cadena,
contenidos en las localidades 200 y 201. Considere borrar la localidad 200, en caso contrario
números sin signo almacenar FF en la localidad 200.

COMPARA: MOV AL, [200] COMPARA: SUB [200], [200] ;asumimos que cadena 1
CMP AL, [201] es menor o igual a cadena 2
JNB SII MOV DI, 0202h ;DI apunta al inicio de la cadena 1
MOV AL, [201] MOV CH, 00h ;CX igual a la longitud de las cadenas
SII: MOV [202], AL MOV CL, [0201]
MOV AH, 4C R: MOV AL, [DI]
INT 21 CMP AL, [DI+10h] ;apunta a la otra cadena
JNC NO
Sumar 2 números binarios de 24 bits y almacenar INC DI
el resultado a partir de la localidad de memoria LOOPNZ R
0206h. Los bits menos significativos de los números END
empiezan en las localidades 0200h y 0203h. NO: JB SII
MOV [0200], FFh
SUMA: SII: END
MOV AL, [200] ;mover el contenido de la localidad 200
a AL

3
MODULOS jne a04
inc x ; desplaza hacia la derecha un
;Este programa es un simple juego que lo unico columna
que hace es desplazar cmp x,79
;por la pantalla un asterisco por medio de las jle imp
teclas direccion (flechas) mov x,0
;el color del sterisco se puede cambiar jmp imp
presionando una Nº entre 1 y 7 a04:
;Hace uso del modulo VIDEO.ASM (procedimientos cmp ah,48h ; es flecha arriba?
limpiar, ir_axy y impchr) jne otk
dec y ; desplaza hacia arriba una fila
.model small cmp y,0
.const jge a05
scp equ 27 mov y,24
spc equ ' ' a05:
chr equ '*' jmp imp
.data fin:
x db 39 mov ah,4ch ; sale a DOS
y db 13 int 21h
color db 4
pintar db 0FFh end ini
.code
extrn limpiar:near Modulo de salida video.asm
extrn ir_axy:near .model small
extrn impchr:near .code
ini: public limpiar
mov ax,@data ; limpia la pantalla
mov ds,ax limpiar proc
call limpiar ; limpia pantalla push ax
imp: push bx
mov dh,y push cx
mov dl,x push dx
call ir_axy ; posiciona cursor en x,y mov ax,600h
cmp pintar,0FFh mov bh,7
jne otk xor cx,cx
mov bl,color ; establece el color del caracter mov dx,184fh
mov al,chr int 10h
call impchr ; imprime asterisco * xor dx,dx
otk: call ir_axy
mov ah,0 pop dx
int 16h ; espera que se presione una tecla pop cx
cmp al,'0' ; si tecla es un # entre 0 pop bx
jb a00 pop ax
cmp al,'7' ; y 7, establece un color para el * ret
ja a00 limpiar endp
and al,0Fh
mov color,al public ir_axy
a00: ; ubica el cursor en la fila DH, columna DL
cmp al,spc ; es tecla barra espaciadora (activa ir_axy proc
y desactiva pintado) push ax
jne a01 push bx
not pintar ; conmutar variable pintar mov ah,2
jmp otk mov bh,0
a01: int 10h
cmp al,scp ; es tecla escape? pop bx
je fin ; salta a fin de programa pop ax
cmp al,0 ; es tecla especial (F1, F2,...->, <-,... ret
jne otk ; si no lo es, lee otro caracter ir_axy endp
cmp ah,50h ; es flecha abajo?
jne a02 comment * Desactiva el cursor *
inc y ; desplaza hacia abajo una fila public descur
cmp y,24 descur proc
jle imp push ax
mov y,0 push bx
jmp imp push cx
a02: push dx
cmp ah,4bh ; es flecha izquierda? mov ah,3
jne a03 mov bh,0
dec x ; desplaza hacia la izquierda un int 10h
columna mov cs:cursor,cx
cmp x,0 mov cx,02929h
jge imp mov ah,1
mov x,79 int 10h
jmp imp pop dx
a03: pop cx
cmp ah,4dh ; es flecha derecha? pop bx

4
 pop ax cld
ret g00: lodsb
descur endp or al,al
jz g01
cursor dw ? call impchr
jmp g00
comment * Activa el cursor * g01: pop si
public actcur pop ax
actcur proc popf
push ax ret
push cx impcad endp
mov cx,cs:cursor end limpiar
mov ah,1
int 10h teclado.asm modulo de entrada
pop cx
pop ax .model small
ret .code
actcur endp public leechr
leechr proc
public impnum mov ah,0
; imprime el n£mero AX con el color BL int 16h
impnum proc ret
push ax leechr endp
push bx
push cx public leecad
push dx ;lee una cadena desde teclado y la almacena de ES:DI
push si leecad proc
mov si,10 push ax
xor cx,cx push bx
sge: xor dx,dx push cx
div si push dx
push dx push di
inc cx mov ah,0fh ; obtiene modo de video
cmp ax,0 int 10h ; y pag de visualizacion
jne sge mov ah,3 ; lee posicion del cursor
imp: pop ax int 10h
add al,'0' a01: mov ah,8 ; lee chr y atrib de la pos
call impchr int 10h ; actual del cursor
loop imp mov bl,ah ; guarda en BL el atributo
pop si mov ah,0 ; lee caracter desde teclado
pop dx int 16h
pop cx cmp al,0 ; tecla especial F1,INSERT,INICIO,etc
pop bx je a01
pop ax cmp al,8 ; tecla BACKSPACE
ret jne a02
impnum endp dec di
dec dl ; pasa a la columna anterior
public impchr mov ah,2 ; ubica el cursor
; imprime el caracter AL con el color BL int 10h
impchr proc mov ax,920h ; borra caracter anterior
push ax mov cx,1 ; imprimiendo espacio en blanco
push bx int 10h
push cx jmp a01
push dx a02: cmp al,13 ; tecla ENTER
mov ah,9 je a99
mov bh,0 cmp al,' ' ; ascii=32
mov cx,1 jb a01
int 10h cmp al,'' ; ascii=127
mov ah,3 ja a01
int 10h stosb
inc dl mov ah,9 ; imprime caracter leido
call ir_axy mov cx,1
pop dx int 10h
pop cx inc dl
pop bx mov ah,2 ; ubica el cursor en la sgte columna
pop ax int 10h
ret jmp a01
impchr endp a99: mov al,0
stosb
public impcad pop di
; imprime una cadena ASCIIZ apuntada por DS:SI con pop dx
el color BL pop cx
impcad proc pop bx
pushf pop ax
push ax ret
push si leecad endp

5
 mov si,ax
xor ax,ax
public leenum mov ds,ax
;lee una cadena numerica desde teclado y la les bx,[si]
almacena de ES:DI pop ds
leenum proc pop si
push ax pop ax
push bx ret
push cx obtvec endp
push dx
push di public estvec
mov ah,0fh ; obtiene modo de video ; redirecciona el vector de interrupcion AL al segmento
int 10h ; y pag de visualizacion DS y
mov ah,3 ; lee posicion del cursor ; offset DX
int 10h estvec proc
b01: mov ah,8 ; lee chr y atrib de la pos push ax
int 10h ; actual del cursor push di
mov bl,ah ; guarda en BL el atributo push es
mov ah,0 ; lee caracter desde teclado xor ah,ah
int 16h shl ax,1
cmp al,0 ; tecla especial F1,INSERT,INICIO,etc shl ax,1
je b01 mov di,ax
cmp al,8 ; tecla BACKSPACE xor ax,ax
jne b02 mov es,ax
dec di mov ax,ds
dec dl ; pasa a la columna anterior cli
mov ah,2 ; ubica el cursor mov es:[di],dx
int 10h mov es:[di+2],ax
mov ax,920h ; borra caracter anterior sti
mov cx,1 ; imprimiendo espacio en blanco pop es
int 10h pop di
jmp b01 pop ax
b02: cmp al,13 ; tecla ENTER ret
je b99 estvec endp
cmp al,'.' ; chr es punto decimal
je b03 end
cmp al,'0' ; chr='0'
jb b01
cmp al,'9' ; chr='9'
ja b01
b03: stosb
mov ah,9 ; imprime caracter leido
mov cx,1
int 10h
inc dl
mov ah,2 ; ubica el cursor en la sgte columna
int 10h
jmp b01
b99: mov al,0
stosb
pop di
pop dx
pop cx
pop bx
pop ax
ret
leenum endp

end leechr

modulo para redireccionar vectores de

interrupción

.model small
.code
public obtvec
; retorna en ES el segmento y en BX el offset de la
rutina
; procesadora de la interrupcion AL
obtvec proc
push ax
push si
push ds
xor ah,ah
shl ax,1
shl ax,1