1.Se consid un sir de oct.

Se cere sa se afiseze nr de
oct care au tetr inf mai mica decat tetr sup,nr de octeti
care au nr de oct care au tetr inf mai mare decat tetr
sup si nr de octeti care au tetr egale.
asm:
title problema
.model small^.stack 100h
extrn _sir:byte^extrn _nr
extrn _nxe^extrn _nxmare
extrn _nxmic^extrn _citire:near
extrn _afisare:near^public _main
.code^;procedura tetrade
tetr proc^push cx
mov cl, 4^mov ah, al
ror al, cl^cmp ah, al
jne dif^inc word ptr[di]
jmp exit^dif:mov al, ah
and ah, 0f0h^ror ah, cl
and al, 0fh^cmp ah, al
jg maiMare^inc bx
jmp exit^maiMare:inc dx
exit:nop^pop cx
ret^tetr endp
;macro pt pregatire apel
apel macro s, n, nxe, nxmare, nxmic
local bucla^mov cx, n
xor si, si^lea di, nxe ;in [di] nr octetilor ce au
tertradele egale^xor dx, dx
xor bx, bx^bucla:mov al, s[si]
call tetr
mov nxmare, dx ;in dh nr octetilor ce au tetrada
superioara > tetrada inferioara
mov nxmic, bx ;in dl nr octetilor ce au tetrada
superioara < tetrada inferioara
inc si^loop bucla
endm
_main proc
call near ptr _citire
apel _sir,_nr,_nxe,_nxmare,_nxmic
call near ptr _afisare
mov ax, 4c00h^int 21h
ret^_main endp^end
c:
#include <stdio.h>
#include <conio.h>
char sir[25];
int nr, nxe, nxmare, nxmic;
void citire(void){int i;
printf("Dati nr de elemente= ");
scanf("%d",&nr);
for(i=0;i<nr;i++){
printf("sir[%d]= ", i);
scanf("%s", &sir[i]);}}
void afisare(void){
printf("\nNr oct cu tetr egale=%d",nxe);
printf("\nNr oct cu tetr sup>tetr inf=%d",nxmare);
printf("\nNr oct cu tetr sup<tetr inf=%d",nxmic);
getch();}

2.
title problema
.model small
.stack 100h
data segment
mes_er db 'Nu''i codul unei instr de salt conditionat',
13,10, '$'
tab0 db 'jo',13,10,'$'
tab1 db 'jno',13,10,'$'
tab2 db 'jb sau jnae',13,10,'$'
tab3 db 'jnb sau jae',13,10,'$'
tab4 db 'jz sau je',13,10,'$'
tab5 db 'jnz sau jne',13,10,'$'
tab6 db 'jbe sau jna',13,10,'$'
tab7 db 'ja sau jnbe',13,10,'$'
tab8 db 'js',13,10,'$'
tab9 db 'jns',13,10,'$'
tab10 db 'jp sau jpe',13,10,'$'
tab11 db 'jnp sau jpo',13,10,'$'
tab12 db 'jl sau jnge',13,10,'$'
tab13 db 'jnl sau jge',13,10,'$'
tab14 db 'jle sau jng',13,10,'$'
tab15 db 'jg sau jnle',13,10,'$'
tab dw tab0, tab1, tab2, tab3, tab4, tab5, tab6, tab7,
tab8, tab9, tab10, tab11, tab12, tab13, tab14, tab15
octet db 01110100b
data ends^cod segment
assume cs:cod, ds:data
start:mov ax, data
mov ds, ax^mov al, octet
mov ah, al
xor al, 74h; verif dc prima tetrada e 0111
jnz eroare^mov al, ah
and al, 00001111b ;extrage a doua tetrada
mov bl, al ;in bl scrie cond de salt
xor bh, bh^add bx, bx
mov dx, tab[bx]^mov ah, 09h
int 21h^jmp sfarsit
eroare:lea dx, mes_er
mov ax, 09h^int 21h
sfarsit:mov ah, 01h
int 21h^mov ax, 4c00h
int 21h^cod ends
end start

3.Se cons un sir de nr intregi in dubla precizie.Se cere

sa se afiseze sirul de dublu cuvinte care reprezinta
sirul initial,iar fiecare dublucuv este rotit la dreapta cu
un nr ce reprez poz elem in sir
//asm
title problema
.model small
.stack 100h
extrn _sir^extrn _nr
extrn _citire:near
extrn _afisare:near
public _main^.code
;procedura ce roteste la dreapta dublu'cuvantul din
dx:ax^rotire proc
push cx^mov cx, di
b1:xor bx, bx^pushf
shr ax, 1^jnc b2
mov bl, 80h
b2:popf
shr dx, 1^jnc b3
mov bh, 80h
b3:or ah, bh
or dh, bl^loop b1
pop cx^ret
rotire endp
;macroinstr ce pregateste apelul pt proc
apel macro s, n
mov cx, n^xor si, si
mov di,1 ;rotim de di ori
bucla:mov ax, word ptr s[si]
mov dx, word ptr s[si+2]
call rotire
mov word ptr s[si], ax
mov word ptr s[si+2], dx
inc di^add si, 4
loop bucla^endm
_main proc near
call near ptr _citire
apel _sir, _nr
call near ptr _afisare
mov ax, 4c00h
int 21h^ret
_main endp^end
//c:
#include <stdio.h>
#include <conio.h>
long int sir[25];
int nr;
void citire(void){
int i;printf("Nr de elemente = ");
scanf("%d", &nr);
for(i=0;i<nr;i++){
printf("sir[%d] = ", i);
scanf("%ld", &sir[i]);}}
void afisare(void){int i;
for(i=0;i<nr;i++)
printf("\nsir[%d] = %ld", i, sir[i]);
getch();}

4.Se cere o proced care calc nr de octeti care au cele 2

tetr egale,nr de octeti care au tetr inf mai mare decat
tetr sup si nr de octeti care au tetr inf mai mica decat
tetr sup.
title problema
.model small
.stack 100h
tetri macro x, n, nxe, nxmare, nxmic
local b1^push dx
mov cx, n^lea bx, x
lea di, nxmic^xor si, si
b1: mov al, x[si]
call tetrada^mov nxe, dl
mov nxmare, dh
inc si^loop b1
pop dx^endm
data segment
sir db 44h, 54h, 0aah, 0abh, 2ah, 75, 123o, 11010101b
n equ ($-sir)/type sir
sir1 db 33h, 23h
n1 equ ($-sir1)/type sir1
nxe db ?^nxmic db ?
nxmare db ?^nxe1 db ?
nxmic1 db ?^nxmare1 db ?
data ends^cod segment
assume cs:cod, ds:data
start:mov ax, data
mov ds, ax
tetri sir, n, nxe, nxmare, nxmic
tetri sir1, n1, nxe1, nxmare1, nxmic1
mov ax, 4c00h^int 21h
tetrada proc^push cx
mov cl, 4^mov ah, al
ror al, cl^cmp ah, al
jne dif^inc dl
jmp exit
dif:mov al, ah
and ah, 0f0h
ror ah, cl
and al, 0fh
cmp ah, al
jg mare
inc word ptr [di]
jmp exit
mare:inc dh
exit:nop
pop cx^ret
tetrada endp
cod ends^end start

5. Se consid un sir de nr intregi in dubla precizie.Sa se

afis un sir de cuv care rep in fiecare element nr maxim
de tetrade egale
a)o proced care det nr max de tetrade egale dintr
dublucuvant
b)o macro care apel proced de mai sus pt a roti la dr
fiecare dublucuv..
title problema
.model small
.stack 100h
extrn _citire:near
extrn _afisare:near
extrn _nr_elem
extrn _sir
public _main
.data
max dw ?
max1 dw ?
sir_tertade dw 20 dup(?)
.code
nr_maxim_tetrade proc
push bx ^xor bx,bx ;
inc bh ;maximul de tetrade egale in bh
;in bl se pastreaza tetrada
mov cx,7
bucla1: push cx
push si
mov max1,0 ^ mov si,cx
sub si,7 ^ neg si
mov bl,00001111b
and bl,byte ptr _sir[si]
xor di,di ^ mov di,si
bucla2:mov bh,00001111b
and bh,byte ptr _sir[di]
cmp bh,bl ^ jne ies
inc max1 ^ ies:inc di
loop bucla2
push bx ^ mov bx,max ^ cmp bx,max1
jng nimic ^ mov bx,max1 ^ mov max,bx
nimic: pop bx
pop cx ^ pop si ^ loop bucla1
pop bx ^ ret
nr_maxim_tetrade
endp
apel macro
lea bx,sir ^ mov cx, _ nr _elem
xor si,si ^ bucla:mov ax,bx[si]
mov dx,bx[si+2] ^ push cx
nr_maxim_tetrade ^ pop cx
xor di,di ^ mov di,cx ^ sub di,_nr_elem
neg di ^ push bx ^ mov bx,max
mov sir_tetrade[di],bx ^ pop bx
loop bucla ^ endm
_main proc ^ ret ^ _main ^ endp
End

void afisare(){for (i=0;i<nr_elem;i++){

printf("%ld ",sir[i]);}
printf("\n");}

6.Se da un sir de octeti de la adresa oct.se cere:a)o

poced care det cel mai mic elem din sir si poz in care
apare.Se va fol transmiterea par prin stiva.b)rastoarna
sirul pe loc
title problema
.model small^.stack 100h
data segment
sir db 23h, 65h, 12h, 44h, 67h, 12h, 23h
n equ ($-sir)/type sir
min db ?
poz db n dup(?) ;in pozitiile in care apare minimul
pun 1
bloc dw 2 dup(?)
data ends^cod segment
assume cs:cod, ds:data
;procedura ce det min si poz, fol transmiterea param
prin stiva
p1 proc^push ax
push bx^push bp
mov bp, sp^add bp, 4
mov cx, [bp+8]
mov si, [bp+0ah] ;incarca in si adresa sir
mov al, [si]^mov di, [bp+6]
b1:cmp al, [si+1]^jle b2
mov al, [si+1]^mov [di], al
b2:inc si^loop b1
;tre sa aflam in ce pozitii apare
mov dl, [di] ; in dl se afla min
mov cx, [bp+8]
mov si, [bp+0ah] ;incarca in si adresa sir
mov bx, [bp+4] ;incarca in bx adresa poz
b3: mov al, [si]^cmp al, dl
jne b4^inc word ptr [bx][si] ;sau mov [bx][si],si ca sa
memoreze pozitia
b4:inc si^loop b3
pop bp^pop bx
pop ax^ret 8
p1 endp^p2 proc
push ax^mov si, [bx]
mov cx, [bx+2] ;in cx nr de elemente
mov di, si^add di, cx
dec di ;in di am adresa ultimului elem
shr cx,1 ;imparte cx la 2
r1:mov al, [si]^mov ah, [di]
xchg al, ah^mov [si], al
mov [di], ah^inc si
dec di^loop r1
pop ax^ret
p2 endp^start:mov ax, data
mov ds, ax
;pregatire apel pt prima proc
lea bx, sir^push bx
mov bx, n^push bx
lea bx, min^push bx
lea bx, poz^push bx
call p1
;pregatire apel pt a 2'a proc
lea bx, sir^mov bloc, bx
mov bx, n^mov bloc+2, bx
lea bx, bloc^call p2
mov ax, 4c00h^int 21h
cod ends^end start

//prg.cpp
#include <stdio.h>
long int sir[30];
int nr_elem;
int i;
void citire(){
printf("Dati numarul de elemente:");
scanf("%d",&nr_elem);
for (i=0;i<nr_elem;i++){
printf("elem[%d] ",i); scanf("%ld",&sir[i]);}}

7.Se considera un sir de cuv de la adresa CUV.se

cere:a)genereaza un sir de octetila adr OCT ce contine
nr de biti egali cu 0.. b)proced care ordoneaza sirul de
la a) descrescator
title problema
.model small^.stack 100h
data segment
cuv dw 55h, 34h, 2345h
n equ ($-cuv)/type cuv
oct db n dup(?)
bloc dw 2 dup(?)
ok db ?
data ends^cod segment
assume cs:cod, ds:data
;procedura ce genereaza oct care contine nr de biti
egali cu 0 din cuvintele din CUV, transmitere param
prin stiva
p1 proc^push bp
mov bp, sp
mov si, [bp+8] ;incarca in si adresa CUV
mov cx, [bp+6] ;in cx nr de elemente
mov bx, [bp+4] ;in bx incarca adresa OCT
xor di, di^b0:mov ax, [si]
push cx^mov cx, 16
b1:shl ax, 1
jc b2 ;bitul e 1
inc word ptr [bx][di]
b2:loop b1^inc di
add si, 2^pop cx
loop b0^pop bp
ret 6^p1 endp
;procedura ce ordoneaza descrescator OCT
p2 proc^mov si, [bx]
reia:mov ok, 0^mov cx, [bx+2] ;in cx nr de
elemente^dec cx
r1:mov al, [si]
cmp al, [si+1]
jge r2^xchg al, [si+1]
mov [si], al^mov ok, 1
r2:inc si
loop r1^cmp ok, 0
jne reia^ret
p2 endp^start:mov ax, data
mov ds, ax
;pregatire apel p1
lea bx, cuv^push bx
mov bx, n^push bx
lea bx, oct^push bx
call p1
;pregatire apel p2
lea bx, oct^mov bloc, bx
mov bx, n^mov [bloc+2], bx
lea bx, bloc^call p2
mov ax, 4c00h
int 21h^cod ends^end start

8.Se considera un sir de cuvinte de la adresa CUV.a)o

proced care gen un sir de octeti la adresa OCT ce
contine nr de biti =0din cuv coresp al sirului CUV.b)o
proced care verifica si afiseaza msg:sir ordonat
crescator ...in bx sa fie 1 in cx lung sir de afisat,in dx
adr sir de afisat in al 40h
title problema
.model small
.stack 100h^data segment
cuv dw 55h, 34h, 2345h
n equ ($-cuv)/type cuv
oct db n dup(?)
bloc dw 2 dup(?)
ok db ?
ord db 'Sir neordonat',13,10,'$'
n1 equ ($-ord)/type ord
cresc db 'Sir ordonat crescator',13,10,'$'
n2 equ ($-cresc)/type cresc
descr db 'Sir ordonat descrescator',13,10,'$'
n3 equ ($-descr)/type descr
data ends^cod segment
assume cs:cod, ds:data
;procedura ce genereaza oct care contine nr de biti
egali cu 0 din cuvintele din CUV, transmitere param
prin stiva
p1 proc^push bp
mov bp, sp
mov si, [bp+8] ;incarca in si adresa CUV
mov cx, [bp+6] ;in cx nr de elemente
mov bx, [bp+4] ;in bx incarca adresa OCT
xor di, di
b0:mov ax, [si]
push cx^mov cx, 16
b1:shl ax, 1^jc b2 ;bitul e 1
inc word ptr [bx][di]
b2:loop b1^inc di
add si, 2^pop cx
loop b0^pop bp
ret 6^p1 endp
;procedura de ordonare pt OCT
p2 proc^mov si, [bx]
mov cx, [bx+2] ;in cx nr de elemente
dec cx^mov ok, 0 ;pp ca e neordonat
push bx^mov al, [si]
cmp al, [si+1]^jge maiMare
push si^push cx
r1:inc si^mov al, [si]
cmp al, [si+1]^jg neordonat
mov ok, 1 ;dc e ordonat crescator
loop r1^pop si
pop cx^cmp ok, 1
je crescator
mov ok, 0 ;pp ca e neordonat
maiMare:inc si
mov al, [si]^cmp al, [si+1]
jl neordonat
mov ok, 1 ;dc e ordonat descrescator
loop maiMare^cmp ok, 1
je descrescator
neordonat:mov cx, n1 ;in cx nr de elemente
mov bx, 1^lea dx, ord
jmp exit
crescator:mov cx, n2 ;in cx nr de elemente
mov bx, 1^lea dx, cresc

jmp exit
descrescator:mov cx, n3 ;in cx nr de elemente
mov bx, 1^lea dx, descr
exit:mov ah, 40h^int 21h
mov ah, 01h^int 21h
pop bx^ret
p2 endp
start:mov ax, data^mov ds, ax
;pregatire apel p1^lea bx, cuv
push bx^mov bx, n
push bx^lea bx, oct
push bx^call p1
;pregatire apel p2
lea bx, oct^mov bloc, bx
mov bx, n^mov [bloc+2], bx
lea bx, bloc^call p2
mov ah, 01h^int 21h
mov ax, 4c00h^int 21h
cod ends^end start

9.Se citeste de la tst un sir de caractere

a)o Mi care primeste adresa unui sir de car , nr de el
ale sirului si returneaza car cu codul ascii cel mai
mare sip oz in care apare
Title problema
.model small
.stack 100h
extrn _citire:near
extrn _sir
extrn _nr_elem
public _main
.data
max db ?
locmax dw 30 dup(?)
min db ?
locmin dw 30 dup(?)
.code
returneaza macro adr,nr_ele
mov bx,adr ^ mov cx,nr_ele
push bx ^ push cx ^ call minmax
mov al,max ^ mov cx,nr_ele ^ push si
push di ^ xor si,si ^ xor di,di
buclamax:cmp al,bx[si]
jne nimik ^ mov locmax[di],si
inc di ^ nimik: inc si
loop buclamax ^ mov al,min ^ mov cx,nr_ele
xor si,si ^ xor di,di
buclamin:cmp al,bx[si]
jne nimik1 ^ mov locmin[di],si
inc di ^ nimik1:inc si
loop buclamin ^ pop di
pop si ^ endm
minmax proc
push bp ^ mov bp,sp ^ mov cx,[bp+4]
mov bx,[bp+6] ^ ;caracterul ascii cel mai mare
push si ^ xor si,si
mare:mov al,bx[si] ^ cmp al,bx[si+1]
jnl nimik2 ^ xchg al,bx[si+1] ^ mov bx[si],al
nimik2: inc si ^ loop
mare
;max se afla in al
mov max,al ^ xor si,si
mic:mov al,bx[si] ^ cmp al,bx[si+1]
jl nimik3 ^ xchg al,bx[si+1] ^ mov bx[si],al
nimik3: inc si ^ loop
mic
;min se afla in al
mov min,al ^ pop si
ret
minmax ^ endp
start: mov ax,@data
mov ds,ax ^ _main proc
call near ptr _citire
lea bx,_sir ^ returneaza bx,_nr_elem
mov ax,4c00h ^ int 21h ^ ret
_main endp ^ end start
//9.cpp
#include <stdio.h>
#include <string.h>
char sir[30];
int nr_elem;
void citire(){
printf("Introduceti sirul"); scanf("%s",sir);
nr_elem = strlen(sir);}

10.Se citeste de la tst un sir de cuvinte se cere sa se

afiseze nr de cuv din sir care au k biti egali cu 0
a)o MI (adr unui sir de cuv,nr de el ale sirului,val k)
returneaza un cuv ce cont nr de cuv din sir care au
exact k biti egali cu 0
title problema
.model small
.stack 100h
extrn _citire:near
extrn _sir
extrn _nr_elem
extrn _k
public _main
.data
Cuv dw ?
.code
Returneaza macro adr,nr,k1
mov bx,adr ^ mov cx,nr ^ push si
xor si,si ^ bucla:mov dx,bx[si]
call determinacuv
;in ax se gaseste nr de biti 0
cmp ax,k1 ^ jne nimik2
inc cuv ^ nimik2: add si,2
loop bucla
pop si ^ endm
determinacuv proc
;DETERMINA NR DE BITI 0
push cx ^ mov cx,16
xor ax,ax ^ bucla1:shr dx,1
jc nimik ^ inc ax
nimik:loop bucla1
pop cx ^ ret
determinacuv endp
afiseaza proc
mov bx,1 ^ mov cx,2 ^ mov ax,'0'
add cuv,ax ^ lea dx,cuv ^ mov ah,40h
int 21h ^ ret
afiseaza endp
_main proc
call near ptr _citire ^
lea bx,_sir
returneaza bx,_nr_elem,_k
call afiseaza ^ mov ax,4c00h ^ int 21h
ret ^ _main endp ^ end
//10.cpp
#include <stdio.h>
int sir[50];
int nr_elem,k;
void citire(){int i;
printf("Dati k"); scanf("%d",&k);
printf("Dati nr_elem"); scanf("%d",&nr_elem);
for (i=0;i<nr_elem;i++){printf("elem[%d]
",i); scanf("%d",&sir[i]);}}

11.Se citesc de la tst 2 siruri de dublu-cuv,se

cere sa se afis sirul de cuv care rep nr de bitzi
egali din dublu`cuv coresp celor 2 siruri.
a)o MI (numele celor 2 siruri, nr de el , numele
sirului rezultat).MI apeleaza o proced in ASM
care det nr de bitzi egali din 2 dublu-cuv.
title problema
.mode small
.stack 100h
extrn _citire:near
extrn _sir1
extrn _nsir1
extrn _sir2
extrn _nsir2
public _main
.data
rez1 dw 30 dup(?)
nrmax dw ?
nrmin dw ?
d1 dd ?
d2 dd ?
sir db 5 dup(?)
.code
returneaza macro nume1,nume2,nr1,nr2,rez
;pt determinarea minimului
push ax ^ push dx
mov ax,nr1 ^ mov dx,nr2
cmp ax,dx ^ jg s ^ mov nrmin,ax
mov nrmax,dx
s: mov nrmin,dx ^ mov nrmax,ax
pop ax ^ pop dx ^ push cx
push si ^ push bx ^
xor si,si
mov cx,nrmin
bucla:lea bx,nume1
mov ax,bx[si] ^ mov dx,bx[si+2]
lea bx,d1 ^ mov word ptr bx[si],ax
mov word ptr bx[si+2],dx
lea bx,nume2 ^ mov ax,bx[si]
mov dx,bx[si+2] ^ lea bx,d2
mov word ptr bx[si],ax
mov word ptr bx[si+2],dx
call determina ^ add si,4
loop bucla
pop bx ^ pop si ^ pop cx
endm
determina proc
;cele 2 dublu cuvinte sunt puse in d1,d2
push ax ^ push dx ^ push bx
push si ^ push cx ^ xor si,si
mov nrmax,si ^ mov cx,2
bucla1: lea bx,d1
mov ax,word ptr bx[si]
lea bx,d2 ^ mov dx,word ptr bx[si]
;in ax cuv din primul dublu cuv si in dx din al 2lea
push cx ^ mov cx,16
bucla2:shr ax,1
jc salt ^ jmp salt1
salt: shr dx,1
jnc nimik3 ^ inc nrmax
jmp nimik3
salt1: shr dx,1
jc nimik3 ^ inc nrmax
nimik3:loop bucla2
pop cx ^ add si,2

loop bucla1
pop cx ^ pop si ^ pop bx
pop dx ^ pop ax ^ ret
determina endp
afisare proc
;conversie in zecimal
lea si,sir;sirul rezultat
mov ax,rez1 ^ mov dx,0
mov bl,10 ^ mov bh,0
repeta: div bx
;restul in ax, catul in dl
add dl,'0' ^ mov [si],dl ^ inc si
mov dx,0 ^ cmp ax,0
jne repeat ^ mov byte ptr [si],0
;inverseaza
push cx ^ push ax
push si ^ push bx ^ xor si,si
mov cx,5 ^ lea bx,sir
bucla4:mov ah,0
mov al,bx[si] ^ push ax
inc si ^ loop bucla4
mov cx,5 ^ xor si,si
bucla5: pop ax
mov bx[si],al ^ inc si
loop bucla5
mov bx,1 ^ lea dx,sir
mov cx,5 ^ mov ah,40h ^ int 21h
pop bx ^ pop si ^ pop ax
pop cx ^ ret
afisare endp
_main proc
call near ptr _citire
returneaza _sir1,_sir2,_nsir1,_nsir2,rez1
call afisare
mov ax,4c00h
int 21h ^ ret
_main endp
end

12.Se citesc de la tst un sir de dublu-cuv,sa se

afis nr de octeti din sir care au tetrada inferioara
egala cu tetr superioara.
b)o MI (adr unui sir de dublu-cuv , nr de el)=un
cuv ce contine nr de octeti din sir care au tetr inf
egala cu sup.MI apeleaza o proc care verifica
daca un octet are cele 2 tetr egale.
title problema
.model small
.stack 100h
extrn _nr_elem
extrn _citire:near
extrn _sir
public _main
.data
nroct dw ?
a db 10 dup(?)
.code
returneaza macro
adr,nr
push bx ^ push si ^
push ax
mov bx,adr ^ mov cx,nr ^ xor si,si
bucla: push cx
mov ah,0 ^ mov cx,4
bucla1: mov al,byte ptr bx[si]
call detegal ^ inc si
loop bucla1
pop cx ^ loop bucla
;in ax se va gasii numarul
mov ax,nroct ^ pop ax
pop si ^ pop bx
endm
detegal proc
push ax ^ push dx ^ push cx
push bx
;octetul este in al
mov ah,al ^ ror al,4 ^ cmp al,ah
jne nimik ^ inc nroct
nimik: pop bx
pop cx ^ pop dx ^ pop ax
ret
detegal endp
afisare proc
push dx ^ push bx ^ push cx
push ax ^ push di ^
push si
lea dx,nroct ^ mov cx,1
mov bx,1 ^ mov ah,40h
int 21h ^ pop si ^ pop di
pop ax ^ pop cx ^ pop bx
pop dx ^ ret
afisare endp
_main proc
mov ax,0 ^ add ax,'0'
mov nroct,ax ^ push bx
call near ptr _citire ^ call afisare
lea bx,_sir
returneaza bx,_nr_elem
call afisare ^ pop bx
mov ax,4c00h ^ int 21h ^ret
_main endp
end

//c.cpp
#include <stdio.h>
long int sir1[30];
long int sir2[30];
int nsir1;
int nsir2;
void citire(){ int i;
printf("Dati numarul de elem din sirul 1");
scanf("%d",&nsir1);
for (i=0;i<nsir1;i++){ printf("sir1[%d]",i);
scanf("%ld",&sir1[i]); }
printf("Dati numarul de elem din sirul 2");
scanf("%d",&nsir2);
for (i=0;i<nsir2;i++){
printf("sir2[%d]",i);
scanf("%ld",&sir2[i]);}}

//pb.pp
#include <stdio.h>
long int sir[30];
int nr_elem;

void citire(){int i;
printf("Numarul de elemente:");
scanf("%d",&nr_elem);
for (i=0;i<nr_elem;i++){
printf("elem[%d]:",i); scanf("%ld",&sir[i]);}}