Exemple de probleme rezolvate in assembler

1) Scrieti un program in assembler care evalueaza expresia: r=((a-b*c)/(d+15))/f.

Pentru a calcula aceast expresie se cunosc urmtoarele:

toate numerele sunt reprezentate cu semn
variabilele de intrare si r sunt reprezentate pe 16 bii
b*c si a-b*c sunt reprezentate pe 32 de bii, iar restul subexpresiilor pe 16 bii.
in cazul impartirilor cu rest, acesta se va ignora (se ia in calcul doar catul)
.MODEL SMALL
.STACK 100H
.DATA
A DW -10000
B DW 300
C DW 15
D DW 100
F DW 20
R DW ?

MOV AX, A
CWD ; DX:AX = A
SUB AX, CX
SBB DX, BX ; DX:AX = A-B*C

.CODE
START:
MOV AX, @DATA
MOV DS, AX
MOV AX, B
IMUL C ; DX:AX = B*C
MOV BX, DX
MOV CX, AX ; BX:CX = B*C

IDIV F ; AX = ((A-B*C)/(D+15))/F
MOV R, AX

MOV CX, D
ADD CX, 15 ; CX = D+15
IDIV CX ; AX = (A-B*C)/(D+15)
CWD ; DX:AX = (A-B*C)/(D+15)

MOV AH, 04CH

INT 21H
END START

2) Sa se scrie un program in assembler care permuta circular elementele unui

vector. Se considera un vector de trei componente, fiecare componenta avand

dimensiunea de un cuvant (word). Se vor permuta circular elementele vectorului
cu o pozitie la stinga.
.MODEL SMALL
.STACK 10H
.DATA
VECT DW 100H,200H,300H
.CODE
START: MOV AX,@DATA
MOV DS,AX
MOV DX,VECT
MOV AX,VECT+2
MOV VECT,AX

MOV AX,VECT+4
MOV VECT+2,AX
MOV VECT+4,DX
MOV AH, 04CH
INT 21H
END START

3) Sa se scrie un program in assembler care defineste o variabila locala pe 32 de

biti (dublu cuvant) si initializeaza aceasta variabila astel :

- In primul cuvant se va memora offsetul acestei variabile
- In al doilea cuvans se va memoria segmental acestei variabile
.MODEL SMALL
MOV AX,OFFSET VAR_PTR
.STACK 10H
MOV WORD PTR VAR_PTR,AX
.DATA
; operatorul offset selecteaza componenta
VAR_PTR DD ?
de offset a adresei unei variabile
; DIRECTIVA DD ARE CA EFECT GENERAREA MOV AX,SEG VAR_PTR
SAU REZERVAREA UNOR ENTITATI PE 32 DE MOV WORD PTR VAR_PTR+2,AX
BITI (4 OCTETI=4 ADRESE DE MEMORIE)
; operatorul seg selecteaza componenta de
.CODE
segment a adresei unei variabile
BEGIN:
MOV AX,@DATA
MOV AH, 04CH
MOV DS,AX
INT 21H
END BEGIN

4) Sa se scrie un program in assembler care defineste doua variabile pe 8 biti si

doua variabile pe 16 biti. Programul va memora rezultatul inmultirii numerelor

pe 8 biti in registrul BX si rezultatul inmultirii numerelor pe 16 biti in registrul
DX:AX.
.MODEL SMALL
.STACK 100H
.DATA
VAL1 DB 2
VAL2 DB 9
VAL3 DW 900
VAL4 DW 500
.CODE

MOV AX,0
MOV AL,VAL1
MUL VAL2
MOV BX,AX

START:
MOV AX,@DATA
MOV DS,AX

MOV AH,4CH
INT 21H
END START

MOV DX,0
MOV AX,VAL3
MUL VAL4

5) Sa se scrie un program in assembler care defineste doua variabile pe 8 biti si

doua variabile pe 16 biti. Programul va memora rezultatul impartiri numerelor

pe 8 biti in registrul BL catul si in registrul BH- restul si rezultatul impartirii
numerelor pe 16 biti in registrul AX catul, iar in registrul DX restul.
.MODEL SMALL
.STACK 100H
.DATA
VAL1 DB 21
VAL2 DB 98
VAL3 DW 456
VAL4 DW 123
.CODE

MOV AL,VAL2
DIV VAL1
MOV BX,AX
MOV AX,VAL3
DIV VAL4
MOV AH,4CH

START:
MOV AX,@DATA
MOV DS,AX
6)

INT 21H
END START

Scrieti un program in assembler care evalueaza expresia: (CX:BX)= a*b+c*d

unde a,b,c si d sunt numere intregi fara semn pe 16 biti. Se va tine cont de faptul ca
inmultirea a doua numere pe 16 biti va fi un numar pe 32 de biti. Programul se va
asambla incapand de la adresa 100H.
.MODEL SMALL
MOV BX,AX
.STACK 100H
MOV CX,DX
.DATA
A DW 400
MOV AX,C
B DW 300
MUL D
C DW 200
D DW 100
ADD BX,AX
.CODE
ADC CX,DX
START:
MOV AX,@DATA
MOV AH,4CH
MOV DS,AX
INT 21H
ORG 100H
END START
MOV AX,A
MUL B
7)

Scrieti un program in assembler care evalueaza expresia: (CX:BX)= a*b-c*d

unde a,b,c si d sunt numere intregi fara semn pe 16 biti. Se va tine cont de faptul ca
inmultirea a doua numere pe 16 biti va fi un numar pe 32 de biti. Programul se va
asambla incapand de la adresa 100H.
.MODEL SMALL
MOV BX,AX
.STACK 100H
MOV CX,DX
.DATA
A DW 400
MOV AX,C
B DW 300
MUL D
C DW 200
D DW 100
ADD BX,AX
.CODE
SBB CX,DX
START:
MOV AX,@DATA
MOV AH,4CH
MOV DS,AX
INT 21H
ORG 100H
END START
MOV AX,A
MUL B
8) Sa se scrie un program in assembler care citeste in fereastra dos o litara mica si o
converteste in litera mare. In tabelul ASCII diferenta intre codul unei litere mici si codul
unei litere mari este 32. In fereastra dos se vor afisa mesajele: Introduceti litera mica:
si Litera mare este:
.MODEL SMALL
.STACK 100H
.DATA
MSG1 DB 'Introduceti litera mica : $'
MSG2 DB 13,10,'Litera mare este: $'
CHAR DB ?,13,10,'$'
.CODE
START:
MOV AX,@DATA
MOV DS, AX

SUB AL, 20H ; conversie intre litere mari si

litere mici
MOV CHAR, AL
LEA DX, MSG2
MOV AH,9 ; DISPLAY STRING
INT 21H
LEA DX, CHAR

LEA DX, MSG1

MOV AH,9 ; DISPLAY STRING
INT 21H
MOV AH, 1 ; READ CHARACTER FUNCTION
INT 21H
9)

MOV AH,9 ; DISPLAY STRING

INT 21H
MOV AH, 04CH
INT 21H ; EXIT TO DOS
END START

Scrieti un program in assembler care utilizeaza o bucla pentru a afisa intreg setul de
caracterea ASCII. Se va folosi funtia de asifare in fereastra dos a unui character ascii.
Programul va incepe asamblarea la adresa 50H

.MODEL SMALL
.STACK 100H
.DATA
.CODE
START:
ORG 50H
MOV AH, 2
MOV CX, 256
MOV DL,00H

LOOP_HERE:
INT 21H
INC DL ; INCREMENTS ASCII CODE
LOOP LOOP_HERE
MOV AH, 04CH
INT 21H
END START

10 ) Fiind data o matrice patratica, sa se permute a doua linie cu a treia. Matricea se va

declara astfel:
Matr db 1, 2, 3, 4
db 5, 6, 7, 8
db 1, 2, 3, 4
db 5, 6, 7, 8
dim equ 4
Programul va folosi:
- in SI adresa de inceput a liniei 2
- in DI adresa de inceput a liniei 3
.MODEL SMALL
MOV SI, OFFSET MATR+DIM
.STACK 100H
MOV DI,OFFSET MATR+2*DIM
.DATA
MOV CX,DIM
MATR DB 1, 2, 3, 4
ETICHETA:
DB 5, 6, 7, 8
MOV AL,[SI] ;DIN MEMORIE DE LA ADRESA
DB 1, 2, 3, 4
DATA DE SI IN REGISTRUL AL
DB 5, 6, 7, 8
XCHG AL,[DI]
DIM EQU 4
MOV [SI], AL
.CODE
INC SI
START:
INC DI
LOOP ETICHETA
START:
MOV AX, @DATA
MOV AH, 04CH
MOV DS, AX
INT 21H
XOR AX,AX
END START
11) Scriecti un program care inverseaza un sir de caractere folosindu-va de stiva. Tinand
cont de faptul ca stiva functioneaza pe principiul : ultimul intrat primul iesit,
elementelere sirului se vor intruduce pe rand in stiva, dupa care vor fi scoase in ordine
inversa si memorate intr-o noua locatie de memorie libera.
.MODEL SMALL
.STACK 100H
.DATA
SURSA DB 1,2,3,4
LSIR EQU $-SURSA
DEST DB LSIR DUP(?)
.CODE

ET1:
MOV AL, [SI]
PUSH AX
INC SI
LOOP ET1
MOV CX,LSIR
ET2:

START:
MOV AX, @DATA
MOV DS, AX
XOR AX,AX
MOV SI,OFFSET SURSA
MOV DI,OFFSET DEST
MOV CX,LSIR

POP AX
MOV [DI],AL
INC DI
LOOP ET2
MOV AH, 04CH
INT 21H
END START

12) Fie a si b doua numere naturale pe 8 biti, a si b se citesc de la tastura. Daca a=b

atunci se va afisa in fereasta dos semnul = si registrul CX va lua valoarea 10.

Daca a!=b atunci se va afisa in fereastra dos semnul != si registurl CX va lua
valoare 5.
.MODEL SMALL
.STACK 10h
.DATA
m1 DB 13,10,'a=','$'
m2 DB 13,10,'b=','$'
m3 DB 13,10,'=',13,10,'$'
m4 DB 13,10,'!=',13,10,'$'
.CODE
start:
mov ax,@data
mov ds,ax
mov dx, offset m1
mov ah,09h
int 21h
mov ah, 01h
int 21h
mov bl,al
mov dx, offset m2
mov ah,09h
int 21h

mov ah, 01h

int 21h
Cmp al, bl
JE Egale
Mov cx, 5
mov dx, offset m4
mov ah,09h
int 21h
Jmp Sfarsit
Egale:
Mov cx,10
mov dx, offset m3
mov ah,09h
int 21h
Sfarsit:
mov ah,4ch
int 21h
END start

13) Sa se calculeze suma elementelor unui sir de 5 numere naturele pe 8 biti.

Rezultatul se va pastra in registrul DX. In registrul CX se va memora media

aritmetica a celor 5 elemente. Se vor tine cont de cazurile in care se vor
semnaliza depasiri.
.MODEL SMALL
.STACK 10h
.DATA
vector DB 421,233,223,123,321
.CODE
start:
mov ax,@data
mov ds,ax

depasire:
inc si
cmp si,5
jne inceput

xor si,si

mov cx,ax

mov ax,dx
mov bl,5
div bl

inceput:
add dl,vector[si]
jnc depasire
inc dh

mov ah,4ch
int 21h
END start

14) Sa se scrie un program in assembler care defineste si initializeaza un sir de

caractere. Programul va cauta in acest sir de caractere de cate ori apare litera
s. Rezultatul se va memora in registru BX.
Sirul va fi definit incepanda de la adresa 0000H si se va folosi o constanta
pentru lungimea sirului.
.MODEL SMALL
.STACK 10h
.DATA
sir DB 'acesta este un sir!'
l EQU $-sir
.CODE

urm:
inc si
cmp al,sir[si]
jne ne_gasit
gasit:
inc bx

begin:
mov ax,@DATA
mov ds,ax

ne_gasit:
loop urm

mov cx,l
mov si,-1

mov ah,4ch
int 21h

mov al,'s'

END begin

15) Scrieti pun program in assembler care defineste si initialize doi vectroi de

numere intregi positive pe 8 biti cu cate 6 elemente. Programul va realiza suma

celor doi vectori si va memora rezultatul intr-un al treilea vector.
.MODEL SMALL
.STACK 10h
.DATA
v1 DB 1,2,3,4,5,6
v2 DB 6,5,4,3,2,1
v3 db 6 dup(?)
.CODE
begin:
mov ax,@DATA
mov ds,ax
mov cx,6
xor si,si

inceput:
mov al,v1[si]
add al,v2[si]
mov v3[si],al
inc si
loop inceput
mov ah,4ch
int 21h
END begin

16) Scieti un program in assembler care cauta intr-un vector de numere naturale pe

8 biti, cel mai mic element. Rezultatul se va memora in registrul DL. Se va utiliza
o bucla prin care se va parcurge sirul de la primul pana la ultimul element.
.MODEL SMALL
.STACK 10h

inceput:
inc si

.DATA
v1 DB 8,7,3,9,1,6
sf DB ?
.CODE
begin:
mov ax,@DATA
mov ds,ax
mov cx, offset sf - offset v1
mov si,0
mov bl,v1[si]

cmp v1[si],bl
jnc negasit
mov bl,v1[si]
negasit:
loop inceput
mov dl,bl
mov ah,4ch
int 21h
END begin

17) Scrieti un program in assembler care citeste un numar natural N din fereastra DOS
(N<10). Apoi se va calcula suma numerelor de la 1 pana la N, iar rezultatul se va
memora in registrul DL. Pentru afisarea si citire in fereastra DOS se vor utiliza funtiile
corespunzatoare intreruperilor DOS.
.MODEL SMALL
.STACK 100H
.DATA
MSG1 DB 'DATI N:','$'
N DB 0
.CODE
START:
MOV AX,@DATA
MOV DS,AX
MOV DX, OFFSET MSG1
MOV AH,09H
INT 21H
MOV AH,01H
INT 21H

SUB AL,48
MOV N, AL
MOV DL,0
MOV AL,0
@LOOP :
INC AL
ADD DL,AL
CMP AL,N
JNE @LOOP
MOV AH,4CH
INT 21H
END START

18) Scrieti un program in assembler care citeste doua cifre de la tastrura in fereastra DOS.
Daca prima este mai mica decat a doua, in registrul CX se va memora produsul lor,
altfel, in registrul CX se va memora rezultatul impartirii primei cifre la a doua. Se vor
utilizata functiile corespunzatorea intreruperilor DOS.
.MODEL SMALL
.STACK 100H
.DATA
MSG1 DB 'A=','$'
MSG2 DB 'B=','$'
.CODE
START:
MOV AX,@DATA
MOV DS,AX
MOV AX,0
LEA DX,MSG1
MOV AH,09H
INT 21H
MOV AH,01H
INT 21H
SUB AL,48

MOV AH,01H
INT 21H
SUB AL,48
CMP BL,AL
JB @LABEL1
JMP @LABEL2
@LABEL1:
MUL BL
MOV CX,AX
JMP @SFARSIT
@LABEL2:
MOV AH,0
MOV BH,0
XCHG AX,BX
DIV BL
MOV CX,AX

MOV BL,AL
LEA DX,MSG2
MOV AH,09H
INT 21H

@SFARSIT:
MOV AH,4CH
INT 21H
END START

19) Scrieti un program in assembler care citeste cu ecou in fereastra DOS doua caractere.
Daca aceste caractere sunt egale, se va afisa in fereastra DOS caracterul corespunzator
sumei celor doua coduri ASCII ale caracterelor citite, daca sunt diferite se va afisa
caracterul corespunzator diferentei celor doua coduri ASCII.
.MODEL SMALL
.STACK 100H
.DATA
MSG1 DB 13,10,'Primul caracter=','$'
MSG2 DB 13,10,'Al doilea caracter=','$'
.CODE
START:
MOV AX,@DATA
MOV DS,AX
LEA DX,MSG1
MOV AH,09H
INT 21H
MOV AH,01H
INT 21H
MOV BL,AL
LEA DX,MSG2
MOV AH,09H
INT 21H
MOV AH,01H
INT 21H

CMP AL,BL
JE @egale
SUB BL,AL
MOV DL,BL
MOV AH,02H
INT 21H
JMP @sfarsit
@egale :
ADD AL,BL
MOV DL,AL
MOV AH,02H
INT 21H
@sfarsit :
MOV AH,4CH
INT 21H
END START

20) Scrieti un program in assembler care citeste un sir de caractere pana la intalnirea
caracterului #(codul ASCII al caracterului # este 35). Aflati la ce adresa de memorie
se gaseste primul spatiu din sirul citit si memoriti aceasta adresa in registrul CX.
.MODEL SMALL
.STACK 100H
.DATA
MSG1 DB 13,10,'Introduceti sirul care
se termina cu #:','$'
SIR DB ?
.CODE
START:
MOV AX,@DATA
MOV DS,AX
LEA DX,MSG1
MOV AH,09H
INT 21H

MOV CX,BX
MOV SI,0
@loop:
CMP SIR[SI],' '
JE @gasit
INC SI
LOOP @loop
@gasit:
LEA CX,SIR
ADD CX,SI
MOV AH,4CH
INT 21H

END START
LEA BX,SIR
@eticheta:
MOV AH,01H
INT 21H
MOV BYTE PTR [BX],AL
INC BX
CMP AL,35
JNE @eticheta