1. S se realizeze un program care, calculeaz adunarea, scderea, nmulirea i mprirea a dou numere, iar rezultatul s se pune n memoria RAM.

Varianta 1:
org 100h mov cx, 500h mov ds,cx mov ax,5 mov dx,2 add ax,dx ;aduna cele doua numere si suma pune in ax mov bx,50h mov [bx],ax ;rezultatul se pune in memorie la randul 50h mov ax,5 sub ax,dx ;scade din ax bx-ul si pune in ax mov bx, 52h mov [bx],ax mov ax,5 mul dx ;inmulteste cele doua numere mov bx,54h mov [bx],ax mov ax,5 mov cx,2 div cx ;imparte cele doua numere mov bx,56h mov [bx],ax ;in ax este catul mov bx,58h mov [bx],dx ;in dx se afla restul hlt

2. S se realizeze un program care adun dou numere care se gsesc n memoria RAM la adresele 500h:0h i 501h:0h, iar rezultatul l pune la adresa 502h:0h.
org 100h mov ax,500h mov ds,ax mov cx,7 mov bx,0 mov [bx],cx mov dx,3 mov ax,501h mov ds,ax mov ax,502h mov ds,ax mov bx,0 mov [bx],cx hlt mov bx,0 mov [bx],dx add cx,dx

3. S se realizeze un program care nmulete dou numere care se gsesc n memoria RAM la adresele 500h:0h i 501h:0h, iar rezultatul se pune n 502h:0h.
org 100h mov ax,500h mov ds,ax mov ax,7 mov bx,0 mov [bx],ax mov cx,ax mov dx,3 mov ax,501h mov ds,ax mov bx,0 mov [bx],ax hlt mov bx,0 mov [bx],dx mov ax,502h mov ds,ax mov ax,cx mul dx

4. S se realizeze un program care mparte dou numere care, se gsesc n memoria RAM la adresele 500h:0h i 501h:0h iar, ctul l pune la adresa 502h:0h i restul n 503h:0h
org 100h mov ax,500h mov ds,ax mov ax,7 mov [0],ax mov bx,ax mov ax,501h mov ds,ax mov cx,2 mov [0],cx mov ax,503h mov ds,ax mov [0],dx hlt mov ax,502h mov ds,ax mov ax,bx div cx mov [0],ax

5. S se realizeze un program care, s calculeze n! punnd rezultatele pariale n memoria RAM, ncepnd de la adresa 500h:0h.
org 100h mov ax,500h mov ds,ax mov ax,1 mov cx,5 eticheta: mul cx mov [bx],ax add bx,1 loop eticheta hlt

6. S se realizeze un program care calculeaz a^n , punnd rezultatele pariale n memoria RAM, ncepnd de la adresa 500h:0h.
org 100h mov ax,500h mov ds,ax mov ax,1 mov cx,4 mov bx,0 eticheta: mov dx,2 mul dx mov [bx],ax add bx,2 loop eticheta hlt

7. S se realizeze un program care pune primele 10 numere pare n memoria RAM, ncepnd de la adresa 500h:0h.
org 100h
;vom tine minte in bx numarul de numere pare gasite (initial 0) ;atat timp cat bx != 10 se verifica numarul urmator ;in ax vom tine minte numarul curent(la care suntem - pe care il verificam daca este par sau nu) ;daca div 2 genereaza un dx=0 atunci numarul este par si il vom pune in memorie la adresa 500+bx si bx va creste cu 1 ;in continuare bx-ul va reprezenta din nou numarul de numere pare gasite

mov bx, ds sub bx, 500h cmp dx, 1 jz nu_e_par

mov ax, 0 ;numarul initial pe care il verific. mov bx, 0 ;numarul de numere pare gasite verificare: mov cx, ax; mov dx, 500h add dx, bx mov ds, dx mov dx, 0 mov bx, 2 div bx; impartim

mov [0], cx add bx, 1 ;vom creste numarul de numere pare gasite cu o
unitate. pentru ca am mai gasit un numar par

nu_e_par: mov ax, cx add ax, 1 cmp bx, 10 jz exit jmp verificare exit: hlt

pe ax la bx=2 pentru a afla restul(dx) care daca e 0 inseamna ca numarul ax e par acum ca am folosit bx-ul la imparitre va trebui sa punem in bx din nou valoarea initiala bx = ds-500h

8. S se realizeze un program care pune primele 10 numere impare n memoria RAM, ncepnd de la adresa 500h:0h.
org 100h mov ax, 0 mov bx, 0 verificare: mov cx, ax mov dx, 500h add dx, bx mov ds, dx mov dx, 0 mov bx, 2 div bx mov bx, ds sub bx, 500h cmp dx, 0 jz e_par mov [0], cx add bx, 1 e_par: mov ax, cx add ax, 1 jz exit jmp verificare exit: hlt

9. S se calculeze
mov ax, 501h mov ds, ax mov [0], 8 mov ax, 502h mov ds, ax mov [0], 1 mov ax, 503h

ai
i= 1

unde ai sunt elemnetele pare ale unui vector de numere naturale.

mov ds, ax mov [0], 0 mov ax, 504h mov ds, ax mov [0], 5 mov ax, 505h mov ds, ax

mov [0], 2 mov ax, 506h mov ds, ax mov [0], 1 mov ax, 507h mov ds, ax mov [0], 3 mov ax, 508h mov ds, ax mov [0], 6 mov ax, 509h mov ds, ax mov [0], 1 mov ax, 50Ah mov ds, ax mov [0], 0 mov bx, 0 mov cx, 10

citesteDinVector: mov ax, 500h add ax, cx mov ds, ax mov ax, [0] mov cx, 2 div cx cmp dx, 1; jz nuEPar add bx, [0] nuEPar: mov cx, ds sub cx, 500h loop citesteDinVector hlt

10. S se calculeze
mov ax, 501h mov ds, ax mov [0], 8 mov ax, 502h mov ds, ax mov [0], 1 mov ax, 503h mov ds, ax mov [0], 0 mov ax, 504h mov ds, ax mov [0], 5 mov ax, 505h mov ds, ax mov [0], 2 mov ax, 506h mov ds, ax mov [0], 1 mov ax, 507h mov ds, ax mov [0], 5 mov ax, 508h mov ds, ax mov [0], 6 mov ax, 509h mov ds, ax mov [0], 1

bi
i= 1

,unde bi sunt elementele impare ale unui vector de numere naturale.

mov ax, 50Ah mov ds, ax mov [0], 5 mov ax, 1 mov cx, 10 citesteDinVector: mov bx, ax ;trebuie sa verificam daca elementul este par. Pentru asta il
vom imparti la 2 si vom analiza restul;dar mai intai voi seta coloana(DS) pentru a citi din memorie. Sa zicem ca citesc de la 501h:0h

mov ax, 500h add ax, cx mov ds, ax ;am setat coloana mov ax, [0] ;pune in ax
specificata si linia 0h

elementul de la coloana

mov cx, 2 div cx mov ax, bx

;acum trebuie sa compar restul impartirii(dx) cu 0 daca sunt egale inseamna ca elementul este par

cmp dx, 0 jz ePar

;Dar elementul meu care a fost citit mai devreme (in ax) s-a pierdut ... deci il voi citi iarasi din memorie(DS(coloana) e aceeasi) mul [0]; inmulteste la ax pe bx elementul de la coloana specificata si linia 0h ... adica elementul nostru impar

ePar: mov cx, ds sub cx, 500h loop citesteDinVector

hlt

11. Fiind dai doi vectori An, Bn aparinnd lui N. S se schimbe elementele vectorilor ntre ele (ai - bi i bi ai)
;crearea primului vector

mov ax, 501h mov ds, ax mov [0], 8 mov ax, 502h mov ds, ax mov [0], 1 mov ax, 503h mov ds, ax mov [0], 0 mov ax, 504h mov ds, ax mov [0], 5 mov ax, 505h mov ds, ax mov [0], 2 mov ax, 506h mov ds, ax mov [0], 1 mov ax, 507h mov ds, ax mov [0], 5 mov ax, 508h mov ds, ax mov [0], 6 mov ax, 509h mov ds, ax mov [0], 1 mov ax, 50Ah mov ds, ax mov [0], 5
;crearea celui de-al doilea vector

mov [2], 2 mov ax, 504h mov ds, ax mov [2], 8 mov ax, 505h mov ds, ax mov [2], 4 mov ax, 506h mov ds, ax mov [2], 7 mov ax, 507h mov ds, ax mov [2], 2 mov ax, 508h mov ds, ax mov [2], 6 mov ax, 509h mov ds, ax mov [2], 2 mov ax, 50Ah mov ds, ax mov [2], 9 mov cx, 10 schimbaValorile:
;deci va trebui sa schimbam valorile intre 500+cx:0 cu 500+cx:2 ;unde 500 reprezinta inceputul vectorului si cx al catelea element din vector ;mai intai sa setam DS-ul (numarul coloanei)

mov ax, 500h add ax, cx mov ds, ax mov ax, [0] mov bx, [2] ;pune in bx elementul de pe randul 2 mov [0], bx ;pune pe randul 0 elementul din bx(adica cel care era initial pe randul 2) mov [2], ax ;pune pe randul 2 elementul din ax (adica cel care a fost initial pe randul 0) loop schimbaValorile hlt

mov ax, 501h mov ds, ax mov [2], 5 mov ax, 502h mov ds, ax mov [2], 1 mov ax, 503h mov ds, ax

12. Se dau urmtoarele elemente ale unui vector care ncepe de la adresa 500h:0h. (1,3,6,7,9,0). S se realizeze un program care determin numrul de elemente pare ale vectorului.
mov ax, 500h mov ds, ax mov [0], 1 mov ax, 501h mov ds, ax mov [0], 3 mov ax, 502h mov ds, ax mov [0], 6 mov ax, 503h mov ds, ax mov [0], 7 mov ax, 504h mov ds, ax mov [0], 9 mov ax, 505h mov ds, ax mov [0], 0 mov bx, 0 mov cx, 6;numarul de elemente din vector este 6 urmatorulElement: mov ax, 500h add ax, cx sub ax, 1 mov ds, ax mov ax, [0] ;pune in ax elem. de pe pozitia cx din vector mov cx, bx mov bx, 2 div bx
;acum ca am terminat cu bx pot sa pun in el din nou numarul de elemente pare gasite

mov bx, cx cmp dx, 1 jz eImpar add bx, 1 eImpar: mov cx, ds sub cx, 500h add cx, 1 loop urmatorulElement hlt

13. Se dau urmtoarele elemente ale unui vector care ncepe de la adresa 500h:0h. (1,3,6,7,9,0). S se realizeze un program care determin numrul de elemente impare ale vectorului.
mov ax, 500h mov ds, ax mov [0], 1 mov ax, 501h mov ds, ax mov [0], 3 mov ax, 502h mov ds, ax mov [0], 6 mov ax, 503h mov ds, ax mov [0], 7 mov ax, 504h mov ds, ax mov [0], 9 mov ax, 505h mov ds, ax mov [0], 0 mov bx, 0 mov cx, 6 urmatorulElement: hlt mov ax, 500h add ax, cx sub ax, 1 mov ds, ax mov ax, [0] mov cx, bx mov bx, 2 div bx mov bx, cx cmp dx, 0 jz ePar add bx, 1 ePar: mov cx, ds sub cx, 500h add cx, 1 loop urmatorulElement

14. S se realizeze un program, care ncarc elementele unui vector cu valoarea 10h.
mov cx, 10 urmatoareaCelula: mov ax, 500h add ax, cx mov ds, ax mov [0], 10h loop urmatoareaCelula hlt

15. S se realizeze un program care ncarc elementele unei matrice de 4x4 cu valoarea de 10h.
org 100h mov cx,4 prog: mov ax,500h mov ds,ax mov dx,cx mov cx,4 prog2: mov bx,dx mov [bx],'A' add ax,1 mov ds,ax loop prog2 mov cx,dx loop prog hlt

16. S se realizeze un program care, calculeaz suma elementelor de pe diagonala principal a unei matrice.
org 100h mov bx,0 rowloop: goOn: mov cx,0 mov ds,cx colloop: diagonala: mov [bx],2 add cx,1 mov ds, cx cmp cx,10 jz goBackTorowloop jmp colloop goBackTorowloop: add bx,1 cmp bx,10 hlt cmp bx,10 jz exit: jmp diagonala exit: mov ds,bx mov al, [bx] add dx,ax add bx,1 mov dx,0 mov bx,0 jz goOn: jmp rowloop

17. S se realizeze un program care nmulete un vector cu un numr.

mov ax, 501h mov ds, ax mov [0h], 1 mov ax, 502h mov ds, ax mov [0h], 2 mov ax, 503h mov ds, ax mov [0h], 3 mov ax, 504h mov ds, ax mov [0h], 4 mov ax, 505h mov ds, ax mov [0h], 5 mov ax, 506h mov ds, ax mov [0h], 6 mov ax, 507h mov ds, ax mov [0h], 7 mov ax, 508h mov ds, ax mov [0h], 8 mov cx, 8 element:
;fiecare element va trebui sa fie citit, inmultit cu numarul, si pus la loc; pentru ca inmultirea se face la ax vom pune elementul din memorie tocmai in ax; apoi vom da mul pentru a fi inmultit si il vom pune la loc

mov ax, 500h add ax, cx mov ds, ax mov ax, [0h] mov bx, 2 mul bx
;si acum punem valoarea din ax inapoi in vector

mov [0h], ax loop element hlt

18. S se realizeze un program care nmulete o matrice cu un numr.

mov ax, 501h mov ds, ax mov [1h], 1 mov ax, 502h mov ds, ax mov [1h], 2 mov ax, 503h mov ds, ax mov [1h], 3 mov ax, 501h mov ds, ax mov [2h], 4 mov ax, 502h mov ds, ax mov [2h], 5 mov ax, 503h mov ds, ax mov [2h], 6 mov ax, 501h mov ds, ax mov [3h], 7 mov ax, 502h mov ds, ax mov [3h], 8 mov ax, 503h mov ds, ax mov [3h], 9 mov cx, 3; pentru ca matricea are 3 linii linie: mov bx, cx mov cx, 3; pentru ca matricea are 3 coloane coloana: mov ax, 500h add ax, cx mov ds, ax mov ax, 0 ;pentru ca avem de gand sa lucram
cu al trebuie sa golim ah deci vom goli tot ax si vom seta apoi al mov al, [bx] ; pune in al numarul din matrice de la coloana DS si linia bx ... folosim al pentru a citi un numar pe 16

mov dx, 9; 9 este nr cu care inmultim matricea mul dx mov [bx], al loop coloana mov cx, bx loop linie hlt

19. S se realizeze un program care determin cte elemente nule se gsesc n zona de memorie RAM cuprins ntre adresele 500h:0h i 509h:9h.
mov ax, 0 mov cx, 9 ;pentru ca matricea noastra are 9 linii linie: mov bx, cx mov cx, 9; pentru ca matricea noastra are 9 coloane coloana: mov dx, 500h add dx, cx sub dx, 1 mov ds, dx cmp [bx], 0 jz e0 jmp nuE0 e0: add ax, 1 nuE0: loop coloana mov cx, bx loop linie hlt

20. S se realizeze un program care copiaz o zon de memorie RAM i o pune ntr-o alt zon de memorie RAM. (cele 2 zone nu se intersecteaz)
;Pentru ca nu s-a dat dimensiunea matricii vom considera o matrice de 3 pe 3 care are coltul din stanga sus la adresa 501h:1h

linie: mov bx, cx mov cx, 3 coloana: mov ax, 500h add ax, cx mov ds, ax mov dx, [bx] add ax, 4 mov ds, ax mov [bx+4], dx loop coloana mov cx, bx loop linie hlt

mov ax, 501h mov ds, ax mov [1h], 9 mov ax, 502h mov ds, ax mov [1h], 8 mov ax, 503h mov ds, ax mov [1h], 7 mov ax, 501h mov ds, ax mov [2h], 6 mov ax, 502h mov ds, ax mov [2h], 5 mov ax, 503h mov ds, ax mov [2h], 4 mov ax, 501h mov ds, ax mov [3h], 3 mov ax, 502h mov ds, ax mov [3h], 2 mov ax, 503h mov ds, ax mov [3h], 1
;vom copia aceasta matrice in zona de 505h:5h

mov cx, 3