Problema 2/ Laborator 9

(2 la puterea n)
2 ^n ={ 1 , n=0
{ 2 *2 ^( n-1) , n>0
.model small
.stack
sablon struc
_bp dw ?
_cs_ip dw ?
_n dw ?
sablon ends
.data
n dw 7
rez dd ?
.code
putere proc near
push bp ;salvare bp
mov bp, sp ;initializare cu varful stivei
pushf ;salvare indicatori
push bx
mov bx, word ptr [bp]._n ; preluc. param.
cmp bx, 0 ;conditia de oprire
jne rec
mov ax, 1 ;0!=1
mov dx, 0
jmp stop
rec:dec bx ;termenul urmator
push bx ;transferul parametrului
call near ptr putere ; rez in DX:AX
add sp, 2
mul word ptr [bp]._2
stop:pop bx ;refacerea registrului bx
popf ;refacere indicatori
pop bp
retn
putere endp
afis proc near
push ax ;salvarea registrelor
push bx
push cx
push dx
mov dx, word ptr rez+2 ;preluare din rez
mov ax, word ptr rez
mov cx, 0 ;initializarea contorului
mov bx, 10
next:div bx
push dx
mov dx, 0
inc cx
cmp ax, 0
jne next
print:pop dx ;preluare din stiva
add dl, 30h ;conversie la codul ASCII
mov ah, 02h
int 21h ;afisare
loop print
pop dx ;refacerea registrelor
pop cx
pop bx
pop ax
retn
afis endp

start:
mov ax, @data
mov ds, ax
mov ax, n
push ax ;transferul parametrului prin stiva
call near ptr putere ;DX:AX<--rezultatul
add sp, 2
mov word ptr rez+2, dx
mov word ptr rez, ax
call near ptr afis ;afisarea rezultatului
mov ah, 4ch ;revenire DOS
int 21h
end start

Problema 3/ Laborator 9
(cel de-al n-lea nr Fibonacci)
fibo(n)= { 0, n=0
{ 1, n=1
{ fibo(n-1)+fibo(n-2),n>1
.model small
.stack
sablon struc
_bp dw ?
_ip dw ?
_n dw ?
sablon ends
.data
n dw 7
rez dd ?
.code
fibo proc near
push bp
mov bp,sp
pushf
push bx
mov bx,word ptr [bp]._n
cmp bx,0
jne n1
mov ax,0
jmp stop
n1: cmp bx,1
jne rec
mov ax,1
jmp stop
rec: dec bx
push bx
call near ptr fibo
add sp,2
push ax
dec bx
push bx
call near ptr fibo
add sp,2
pop bx
add ax,bx
stop: pop bx
popf
pop bp
retn
fibo endp
afis proc near
push ax ;salvarea registrelor
push bx
push cx
push dx
mov dx, word ptr rez+2
mov ax, word ptr rez
mov cx, 0
mov bx, 10

next:div bx
push dx
mov dx, 0
inc cx
cmp ax, 0
jne next
print:pop dx
add dl, 30h
mov ah, 02h
int 21h
loop print
pop dx
pop cx
pop bx
pop ax
retn
afis endp
start:
mov ax, @data
mov ds,ax
mov ax,n
push ax
call near ptr fibo
add sp,2
mov word ptr rez,ax
mov word ptr rez+2,0
call near ptr afis
mov ah,4ch
int 21h
end start

Problema 4/ Laborator 9
(combinari de n luate cate k)

Cnk = { 1, n=k
{ 1, k=0
k1
k
{ Cn 1 + Cn 1 ,in rest
.model small
.stack
sablon struc
_bp dw ?
_ip dw ?
_n dw ?
_k dw ?
sablon ends
.data
n dw 3
k dw 2
rez dw ?
.code
comb proc near
push bp
mov bp,sp
pushf
push bx
push dx
push cx
mov bx, word ptr [bp]._n
mov dx, word ptr [bp]._k
cmp bx,dx
jne k0
mov ax,1
jmp stop
k0:cmp dx,0
jne rec
mov ax,1
jmp stop
rec:dec bx
push dx
push bx
call near ptr comb
add sp,4
mov cx,ax
dec dx
push dx
push bx
call near ptr comb
add sp,4
add ax,cx
stop: pop cx
pop dx
pop bx
popf
pop bp
retn
comb endp

afis proc near

push ax
push bx
push cx
push dx
mov dx,word ptr rez+2
mov ax,word ptr rez
mov cx,0
mov bx,10
next:div bx
push dx
mov dx,0
inc cx
cmp ax,0
jne next
print: pop dx
add dl,30h
mov ah,02h
int 21h
loop print
pop dx
pop cx
pop bx
pop ax
retn
afis endp
start: mov ax,@data
mov ds,ax
mov bx,k
push bx
mov bx,n
push bx
call near ptr comb
add sp,4
mov word ptr rez,ax
call near ptr afis
mov ah,4Ch
int 21h
end start

Problema 1/ Laborator 10
(suma cifrelor unui numar)
sumac(n)= { 0, n=0
{ n%10+sumac(n/10). n>0
MODULUL ASAMBLARE
.model small
public _sumac
.stack
sablon struc
_bp dw ?
_ip dw ?
_n dw ?
sablon ends
.code
_sumac proc near
push bp
mov bp,sp
pushf
push dx
push bx
mov ax, word ptr[bp]._n
cmp ax,0
jne rec
mov ax,0
jmp stop
rec: mov dx,0
mov bx,10
div bx
push ax
call near ptr _sumac
add sp,2
add ax,dx
stop: pop bx
pop dx
popf
pop bp
retn
_sumac endp
end
MODULUL C
#include <stdio.h>
#include<canio.h>
extern int sumac(int a)
void main (){
int n,sum;
printf(n=);
scanf(%d,&n);
sum=sumac(n);
printf(sumac=%d,sum);
getch();
}

Problema 2/Laborator 10
(cel mai mare divizor comun)
cmmdc(a,b)= { a, b=0
{ cmmdc(b,a%b), b>0
MODULUL ASAMBLARE
.model small
public _cmmdc
.stack
sablon struc
_bp dw ?
_ip dw ?
_a dw ?
_b dw ?
sablon ends
.code
_cmmdc proc near
push bp
mov bp,sp
push dx
push bx
push cx
mov bx,[bp]._a
mov dx,[bp]._b
cmp dx,0
jne rec
mov ax,bx
jmp stop
rec: mov cx,dx
mov ax,dx
mov dx,0
div cx
push dx
mov dx,[bp]._b
push cx
call near ptr _cmmdc
add sp,4
stop: pop cx
pop bx
pop dx
pop bp
retn
_cmmdc endp
end
MODULUL C
#include <stdio.h>
#include <conio.h>
extern int cmmdc(int,int);
void main(){
int a,b,rez;
printf("a=");scanf("%d",&a);
printf("b=");scanf("%d",&b);
rez=cmmdc(a,b);
printf("cmmdc=%d",rez);
getch();
}

stop: popf
pop bx
pop di
pop si
pop bp
retn
_cauta endp

Problema 3/ Laborator 10
(cautarea binara)
Cauta(s,d,val)= { 0, s>d
{ 1, a[m]=val, unde m=(s+d)/2
{ cauta(s,m-1,val), a[m]>val
{ cauta(m+1,d,val), a[m]<val
MODULUL ASAMBLARE
.model small
public _cauta
.stack
sablon struc
_bp dw ?
_cs_ip dw ?
_s dw ?
_d dw ?
_val dw ?
_tab dw ?
sablon ends
.code
_cauta proc near
push bp
mov bp,sp
push si
push di
push bx
pushf
mov si, word ptr [bp]._s
mov di, word ptr [bp]._d
cmp si,di
jle gasit
mov ax,0
jmp stop
gasit: add si,di
shr si,1
mov bx,word ptr [bp]._tab
mov bx,bx[si]
cmp bx, word ptr [bp]._val
jne rec1
mov ax,1
jmp stop
rec1: cmp bx, word ptr [bp]._val
jl rec2
push word ptr [bp]._tab
push word ptr [bp]._val
sub si,2
push si
push word ptr [bp]._s
call near ptr _cauta
add sp,8
jmp stop
rec2: push word ptr [bp]._tab
push word ptr [bp]._val
push word ptr [bp]._d
add si,2
push si
call near ptr _cauta
add sp,8

end
MODULUL C
# include <stdio.h>
# include <conio.h>
extern int cauta (int s, int d, int val, int tab[]);
int main(){
int tab[10]={3,6,7,10,11,20,214};
int val, c;
printf ("Introduceti valoarea cautata=");
scanf("%d",&val);
c=cauta(0,12,val,tab);
printf("%d",c);
getch();
}

Problema 4/ Laborator 10

(suma elementelor unui vector)

sumas(i)= { a[0], i=0
{ a[i]+sumas(i-1), i>0
MODULUL ASAMBLARE
.model small
public _sumas
.stack
sablon struc
_bp dw ?
_ip dw ?
_i dw ?
_tab dw ?
sablon ends
.code
_sumas proc near
push bp
push bp,sp
pushf
push di
push si
push bx
mov ax, word ptr[bp]._i
mov bx, word ptr[bp]._tab
cmp si,0
jne rec
mov ax, word ptr bx[0]
jmp stop
rec: mov di,si
dec di
push dx
push di
call near ptr _sumas
add sp, 4
add si, si
add ax, word ptr bx[si]
stop: pop bx
pop si
pop di
popf
pop bp
retn
`
_sumas endp
end
MODULUL C
#include <stdio.h>
#include <canio.h>
extern int sumas { int, int[]};
void main (){
int i,sum,v[6]={7,5,6,8,1,2};
i=6;
sum=sumas(i,v);
printf(sumas%d, sum);
getch();
}

Problema 11/ Laboratorul 10

(numarul de aparitii a unei valorii intr-un sir)

.model small
.stack
.data
sablon struc
_bp dw ?
_ip dw ?
_x db ?
sablon ends
v db 'ana are mere'
vlen dw $-v
.code
nr_aparitii proc
push bp
mov bp, sp
push cx
mov cx, vlen
mov ax, 0
push bx
mov bl, [bp]._x
push si
mov si, 0
count:cmp bl, v[si]
jne continue
inc ax
continue:
inc si
loop count
final_nra: pop si
pop bx
pop cx
pop bp
retn
nr_aparitii endp
start:
mov ax, @data
mov ds, ax
push 'a'
call nr_aparitii
add sp, 2
mov ah, 4ch
int 21h
end start

Problema 8/ Laborator 10
(polinomul Cebisev de speta I)

T n(x ) = { 1, n=0
{ x, n=1;
{ 2*

T n2 ( x ) - T n1 ( x )

MODULUL ASAMBLARE
.modell small
public _Cebisev
.stack
sablon struc
_bp dw ?
_ip dw ?
_n dw ?
_x dw ?
sablon ends
.code
_Cebisev proc near
push bp
mov bp,sp
push bx
push dx
pushf
push cx
mov bx,word ptr[bp]._x
mov dx,word ptr[bp]._n
cmp dx,0
jne n1
mov ax,1
jmp stop
n1:cmp dx,1
jne rec
mov ax,bx
jmp stop
rec:dec dx
push bx
push dx
call near ptr _Cebisev
add sp,4
mov cx,ax
dec dx
push bx
push dx
call near ptr _Cebisev
add sp,4
shl ax,1
sub ax,cx
stop:pop cx
popf
pop dx
pop bx
pop bp
retn
_Cebisev endp
end

MODULUL C

#include <stdio.h>
#include <conio.h>
extern int Cebisev(int,int);
void main(){
int n,x,c;
printf ("n=");scanf ("%d",&n);
printf ("x=");scanf ("%d",&x);
c= Cebisev(n,x);
printf("c=%d",c);
getch();
}

Problema 9/Laborator 10

(valoarea functiei Ackermann)

A(m,n)= { n+1, m=0
{ A(m-1,1),n=0
{ A(m-1,A(m,n-1)),in rest
MODULUL ASAMBLARE
.model small
public_Ackermann
.stack
sabon struc
_bp dw ?
_ip dw ?
_n dw ?
_m dw ?
soblon ends
.code
_Ackermann proc near
push bp
mov bp,sp
push dx
push bx
mov dx,word ptr[bp]._n
mov bx,word ptr[bp]._n
cmp bx,0
jne rec1
mov ax,dx
inc ax
jmp stop
rec1: cmp dx,0
jne rec2
dec bx
push bx
mov ax,1
push ax
call near ptr_Ackermann
add sp,4
jmp stop
rec2: dec dx
push bx
push dx
call near ptr_Ackermann
add sp,4
dec bx
push bx
push ax
call near ptr_Ackermann
add sp,4
stop: pop bx
pop dx
pop bp
retn
_Ackermann endp
end

MODULUL C

#include<conio.h>
#include<stdio.h>
extern int Ackermann(int,int);
void main(){
int m,n,a;
printf("m=");
scanf("%d",&m);
printf("n=");
scanf("%d",&n);
a=Ackermann(n,m);
printf("a=%d",a);
getch();
}