Probleme rezolvate

1. Implementarea unei structuri de tip for în limbaj de asamblare. Pseudocod:
for i=0 -> n-1 do
eax=eax+1;
ebx=ebx-5;
end for
Varianta 1

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
n db 5
.code
start:

    mov edi,n
mov esi,0
et_for:
inc eax
sub ebx,5
inc esi
cmp esi, edi
jbe et_for

    ;apel functie exit
    push 0
    call exit
end start

Varianta 2

 .386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
n db 5
.code
start:
mov ecx,n
et_loop:
inc eax
sub ebx,5
loop et_loop

    ;apel functie exit
    push 0
    call exit
end start

2. Să se determine minimul şi maximul dintr-un şir de numere fără semn reprezentate pe octet şi să se scrie valorile găsite în memorie.

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
sir db 10,21,3,14,2,22,11
lgsir dd $-sir
min db 0
max db 0
   
.code
start:
   
    mov ax, 0 ; al-minim, ah-maxim
   
    mov esi, 0
    mov ecx, lgsir
    mov al, sir[esi]
    mov ah, sir[esi]

    et_loop:
    cmp al, sir[esi]
    JB cmp_max
    mov al, sir[esi]
    cmp_max:
    cmp ah, sir[esi]
    JA urmator
    mov ah, sir[esi]
    urmator:
    inc esi   
    loop et_loop
   
    mov min, al
    mov max, ah
   
    ;apel functie exit
    push 0
    call exit
end start

Probleme propuse

1. Să se determine minimul şi maximul dintr-un şir de numere cu semn reprezentate pe cuvânt şi să se scrie valorile găsite în memorie.

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
sir dw -10,21,-3,14,2,-22,11
lgsir dd $-sir
min dw 0
max dw 0
   
.code
start:
   
    mov eax, 0
    mov ebx, 0
    ; ax-minim, bx-maxim
   
    mov esi, 0
    mov ecx, lgsir
    mov ax, sir[esi]
    mov bx, sir[esi]
    ;mov esp, 0
    ;mov esi, 0

    ;lup:
    ;push dword ptr sir[esi]
    ;inc esi
    ;loop lup

    ;inc esi
   
    et_loop:
    cmp sir[esi],ax
    JGE cmp_max
    mov ax, sir[esi]
    cmp_max:
    cmp sir[esi],bx
    JLE urmator
    mov bx, sir[esi]
    urmator:
    inc esi   
    loop et_loop
   
    mov min, ax
    mov max, bx
   
   
    ;apel functie exit
    push 0
    call exit
end start

Varianta 2

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
sir dw 10,21,3,14,2,-22,11
lgsir dd $-sir
min dw 0
max dw 0
   
.code
start:
   
    mov eax, 0
    mov ebx, 0; ax-minim, bx-maxim
   
    mov esi, 0
    mov ecx, lgsir
    mov ax, sir[esi]
    mov bx, sir[esi]

    et_loop:
    cmp ax, sir[esi]
    JL cmp_max
    mov ax, sir[esi]
    cmp_max:
    cmp bx, sir[esi]
    JG urmator
    mov bx, sir[esi]
    urmator:
    inc esi  
    loop et_loop
   
    mov min, ax
    mov max, bx
   
    ;apel functie exit
    push 0
    call exit
end start

2. Să se scrie un program pentru calculul sumei unui şir de numere întregi reprezentate pe octet.

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
sir db 1,-2,3,4,5
n db $-sir
suma db 0
   
.code
start:
    mov esi,0
    mov edx,0
    mov dl,n
    mov eax,0
    eticheta:
    add al,sir[esi]
    inc esi
    cmp esi,edx
    JB eticheta
   
    ;apel functie exit
    push 0
    call exit
end start

3. Să se scrie un program care numără câţi biţi de 1 sunt într-un număr întreg reprezentat pe cuvânt, păstrat în memorie. Se va utiliza instrucţiunea de deplasare logică shr, urmată de verificarea valorii regăsite în flag-ul CF.

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
n dw 1580
.code
start:
    mov ax,n
    mov ebx,0
   
    eticheta:
    ;clc
    shr ax,1
    jnc next
    ;JNE next
    inc ebx
    next:
    cmp ax,0
    JNE eticheta
   
    ;apel functie exit
    push 0
    call exit
end start

4.  Să se implementeze un program care caută un string s1 în alt string s2. În caz că s1 se regăseşte, registrul EAX va conţine poziţia din s2 unde s-a găsit s1. Altfel, EAX va conţine -1 (0FFFFFFFh).

Probleme rezolvate

1.S a se scrie un program care copiaz a un sir de valori din locat, ii consecutive de memorie in alta locatie inn ordine invers a.

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
sir1 dw 1,2,3
sir2 dw 0,0,0
.code
start:
   
    lea esi, sir1
    lea edi, sir2
   
    ;iau din primul sir si pun in stiva
    push word ptr[esi]
    add esi, 2
    push word ptr[esi]
    add esi, 2
    push word ptr[esi]
   
    ;scot de pe stiva si pun in al doilea sir
    pop word ptr[edi]
    add edi, 2
    pop word ptr[edi]
    add edi, 2
    pop word ptr[edi]
   
    ;apel functie exit
    push 0
    call exit
end start

2. S a se scrie un program pentru adunarea a dou a matrici bidimensionale.

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
m1 db 1,2,3
   db 4,5,6
m2 db 7,8,9
   db 10,11,12       
.code
start:
    mov eax, 0 ;in ax se vor pastra sumele elementelor de pe aceeasi
                  ;pozitie
   
    mov esi, 0 ;pentru parcurgerea liniilor
    mov ebx, 0 ;pentru parcurgerea coloanelor   
   
    ;suma prima linie
    add al, m1[ebx][esi]
    add al, m2[ebx][esi]
    mov m1[ebx][esi], al ;rezultatul se pastreaza in matricea m1
   
    mov al, 0
    inc esi
    add al, m1[ebx][esi]
    add al, m2[ebx][esi]
    mov m1[ebx][esi], al

    mov al, 0
    inc esi
    add al, m1[ebx][esi]
    add al, m2[ebx][esi]
    mov m1[ebx][esi], al

    ;suma a doua linie
    mov al, 0
    mov esi, 0
    ;bx se aduna cu 3
    add ebx, 3
    add al, m1[ebx][esi]
    add al, m2[ebx][esi]
    mov m1[ebx][esi], al

    mov al, 0
    inc esi
    add al, m1[ebx][esi]
    add al, m2[ebx][esi]
    mov m1[ebx][esi], al

    mov al, 0
    inc esi
    add al, m1[ebx][esi]
    add al, m2[ebx][esi]
    mov m1[ebx][esi], al
   
   
    ;apel functie exit
    push 0
    call exit
end start

Probleme propuse

1. S a se scrie un program care calculeaz a media unui sir de numere intregi din memorie.
Numerele sunt de tip octet. Media va memorat a ca valoare i ntreaga i ntr-o variabil a de tip octet.

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
sir db 1,2,3,4,4 ;sirul
cat db 0 ;catul mediei
restul db 0 ;restul mediei
.code
start:

    lea esi,sir ;trebuie copiat sirul in esi pentru a-l parcurge
    mov eax,0 ;initialiarea registrului pentru suma cu 0

    add al,[esi] ;adaugarea primului element in registrul suma
    add esi,1 ;referirea la urmatorul element
    add al,[esi]
    add esi,1
    add al,[esi]
    add esi,1
    add al,[esi]
    add esi,1
    add al,[esi]
   
    mov ecx,5 ;initializarea registrului ecx (cl) cu 5 - 5 elemente in sir
    mov edx,eax ;salvarea sumei in edx
   
    div cl ;impartirea lui al la cl (5) pentru a calcula media
    ;in AL (bitii 1,2 de la dreapta) - catul, in AH (bitii 3,4 de la dreapta) - restul
    mov cat,al ;cat contine catul mediei aritmetice
    mov restul,ah ;restul contine restul mediei aritmetice
   
    ;apel functie exit
    push 0
    call exit
end start

2. S a se scrie un program care i nsumeaz a salariile unor angajati. Datele referitoare la
angajati se p astreaz a i ntr-un tablou de i nregistr ari.
Exemplu tablou de ^inregistr ari:

1 ANGAJAT struct
2 nume DB 20 dup(0)
3 salariu DW 0
4 ANGAJAT ends
5
6 nrAngajati DW 4
7 angajati ANGAJAT {"georgescu", 100}, {"pop", 100},
8 {"popescu", 300}, {"ionescu", 450}

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
;structura ANGAJAT cu doua campuri, nume (de 20 de ori cate un bit) si salariu (2 biti)
ANGAJAT struct
nume DB 20 dup(0)
salariu DW 0
ANGAJAT ends

;declararea unui vector de tip ANGAJAT
nrAngajati DW 4
angajati ANGAJAT {"georgescu", 1}, {"pop", 1},
{"popescu", 3}, {"ionescu", 4}
.code
start:
    lea esi,angajati ;mutam vectorul de tip ANGAJAT in esi
    mov eax,0 ;registru pentru suma salariilor
   
    add ax,word ptr[esi+20] ;se aduna primul salariu (pentru referirea la salariu se aduna 20 de biti (se sare peste
    ;cei pentru nume))
    add esi,22 ;trecerea la al doilea element al vectorului (se sare peste 20 de biti pt nume si inca 2 pentru
    ;salariu)
    add ax,word ptr[esi+20] ;se aduna pe ax pentru a fi de aceeasi lungime (ax - 16 biti, salariu - 16 biti)
    add esi,22
    add ax,word ptr[esi+20]
    add esi,22
    add ax,word ptr[esi+20]
   
    ;suma se pastreaza in eax
    ;apel functie exit
    push 0
    call exit
end start

3. Folosind doar instructiunile push si pop, scrieti un program care roteste registrii
EAX, EBX, ECX si EDX (valoarea din EAX merge in EBX, din EBX i n ECX, din ECX i n
EDX iar din EDX in EAX).

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data

.code
start:
    mov eax,1 ;initializarae registrilor
    mov ebx,2
    mov ecx,3
    mov edx,4
   
    push eax
    push ebx
    push ecx
    push edx
   
    pop eax
    pop edx
    pop ecx
    pop ebx
   
    ;apel functie exit
    push 0
    call exit
end start

4. Intr-un sir de 2n - 1 elemente se g asesc i ntr-o ordine aleatoare toate numerele de
la 1 la n, de dou a ori fi ecare, mai putin un num ar k care se g aseste o singur a dat a.
Scrieti un program care g aseste num arul k. 

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
sir db 1,2,1,3,4,3,5,5,6,6,4
lung DB $-sir ;punem lungimea sirului sir in variabila lung
i db 2 ;variabila pentru inmultire/impartire cu 2 (formula sumei primelor n nr nat)
.code
start:

    mov eax,0
    mov ebx,0
    mov cl,lung ;lungimea sirului in cl
    mov edx,0
    lea esi,sir
   
    eticheta:
    add al, [esi+ebx] ;suma elementelor din sir va fi in AL (EAX)
    inc bl ;indicele pentru parcurgerea sirului
    cmp bl,cl ;conditia de continuare (indicele < lungimea)
    jb eticheta ;jump la eticheta daca bl<cl
   
    mov ebx,0
    inc cl ;pentru calculul sumei de la 1 la n
    push eax
    mov eax,ecx
    div i ;se calculeaza de fapt pana la n, impartire cu 2
   
    mov ecx,eax ;formula pt suma primelor n nr nat (dar luata de 2 ori, nu se mai face impartirea la 2)
    add ecx, 1
    mul ecx
    mov ecx, 0
    pop ecx
   
    ;in eax avem de 2 ori suma de la 1 la n
    ;in ecx avem suma elementelor din sir
    sub eax, ecx
    ;in eax vom avea diferenta dintre suma de la 1 la n (de 2 ori) si suma el din vector
    ;adica chiar valoarea care apare o singura data in sir
   
   
    ;apel functie exit
    push 0
    call exit
end start

Adunarea a două matrici, scăderea a două matrici, afisarea unei matrici, calculul mediei aritmetice a elementelor unei matrici + clasă de test pentru medie

Main.java

package ro.utcluj.poo.lab3matrix;

public class Main {

    public static void main(String[] args) {
        Matrice a1,a2,a3;
        int[][] p=new int[][] {{1,2},{3,4}};
        int[][] pp=new int[][] {{1,2},{3,4}};
        a1=new Matrice(2, 2, p);
        a2=new Matrice(2,2,pp);
        a3=a1.add(a2);
        a1.Afisare();
        a2.Afisare();
        a3.Afisare();
   
        System.out.println(a1.Medie());
        System.out.println(a2.Medie());
        System.out.println(a3.Medie());
    }

}

Matrice.java

package ro.utcluj.poo.lab3matrix;

public class Matrice {
    private int[][] a;
    private int n,m;
    public Matrice(int n, int m, int[][] a)
    {
        this.a = new int[n][m];
        int i,j;
        for(i=0;i<n;i++)
            for(j=0;j<m;j++)
                this.a[i][j] = a[i][j];
        //this.a=a;
        this.n=n;
        this.m=m;
    }
   
    public void Afisare()
    {
        int i,j;
        for(i=0;i<n;i++)
            {for(j=0;j<m;j++)
                System.out.print(a[i][j]+" ");
            System.out.println();
            }      
    }
   
    public Matrice add(Matrice mm)
    {
        Matrice x;
        x=new Matrice(this.n,this.m,this.a);
        int i,j;
        x.n=this.n;
        x.m=this.m;
        for(i=0;i<this.n;i++)
            for(j=0;j<this.m;j++)
                x.a[i][j]=mm.a[i][j]+this.a[i][j];
        return x;
    }
   
    public Matrice scadere(Matrice mm)
    {
        Matrice x;
        x=new Matrice(this.n,this.m,this.a);
        int i,j;
        x.n=this.n;
        x.m=this.m;
        for(i=0;i<this.n;i++)
            for(j=0;j<this.m;j++)
                x.a[i][j]=-mm.a[i][j]+this.a[i][j];
        return x;
    }
   
    public double Medie()
    {
        int i,j;
        double s=0;
        for(i=0;i<this.n;i++)
            for(j=0;j<this.m;j++)
                s=s+this.a[i][j];
        double m;
        m=s/(this.n*this.m);
        return m;
    }

   
   
    public static void main(String[] args) {
        // TODO Auto-generated method stub

    }

}

MatriceTest.java

package ro.utcluj.poo.lab3matrix;

import static org.testng.Assert.assertEquals;

import org.testng.annotations.Test;

public class MatriceTest {

  @Test
  public void Medie() {
      Matrice a1=new Matrice(2,2,new int[][] {{1,2},{3,4}});
      assertEquals(a1.Medie(),2.5,0.01);
    //throw new RuntimeException("Test not implemented");
  }
}

Surse de tensiune continua

Redresor cu filtru

D1 1 2 di
D2 1 0 di
D3 3 0 di
D4 3 2 di
C1 2 0 1m
R1 2 0 100
Vin 1 3 sin(0 10 50k 0 0)
.model di D
.model di D tt=1e-9  //  tt transit time

Redresor cu filtru

D1 1 2 di
D2 0 1 di
D3 0 3 di
D4 3 2 di
C1 2 0 30m
R1 2 0 100
Vin 1 3 sin(0 10 50 0 0)
.model di D
.model di D tt=1e-9

Cu afisarea curentului i(vin) pe grafic

Redresor cu filtru

D1 1 2 di
D2 0 1 di
D3 0 3 di
D4 3 2 di
C1 2 0 30m
R1 2 0 10
Vin 1 3 sin(0 10 50 0 0)
.model di D
.model di D tt=1e-9

Stabilizator parametric cu dioda Zener

D1 1 2 di
D2 0 1 di
D3 0 3 di
D4 3 2 di
C1 2 0 1m
Rb 2 out 30
D5 out 0 zener
Rs 0 out 100
Vin 1 3 sin(0 10 50 0 0)
.model di D tt=1e-9
.model zener D bv=5.6

Stabilizator parametric cu dioda Zener

D1 1 2 di
D2 0 1 di
D3 0 3 di
D4 3 2 di
C1 2 0 10m
Rb 2 out 30
D5 out 0 zener
Rs 0 out 100
Vin 1 3 sin(0 10 50 0 0)
.model di D tt=1e-9
.model zener D bv=5.6

Stabilizator cu reactie fara amplificator de eroare (sursa cu tranzistor)

D1 1 2 di
D2 0 1 di
D3 0 3 di
D4 3 2 di
C1 2 0 1m
Rb 2 vz 400
D5 0 vz zener
Rs 0 out 100
Q1 2 vz out tranz
Vin 1 3 sin(0 10 50 0 0)
.model di D tt=1e-9
.model zener D bv=5.6
.model tranz NPN tr=1e-9 tf=1e-9

Stabilizator cu reactie fara amplificator de eroare (sursa cu tranzistor)

D1 1 2 di
D2 0 1 di
D3 0 3 di
D4 3 2 di
C1 2 0 1m
Rb 2 vz 50
D5 0 vz zener
Rs 0 out 100
Q1 2 vz out tranz
Vin 1 3 sin(0 10 50 0 0)
.model di D tt=1e-9
.model zener D bv=5.6
.model tranz NPN tr=1e-9 tf=1e-9

//Prob 1 : primul grafic f(x) - cu rosu; Ln - cu verde; graficul al doilea - eroarea

X =.; X[i_, n_] := -1 + 2 i/n;
l[i_, n_, x_] :=
  Product[If[i == j, 1, (x - X[j, n])/(X[i, n] - X[j, n])], {j, 0,
    n}];
L[f_, n_, x_] := Sum[f[X[i, n]]*l[i, n, x], {i, 0, n}];
n = 15; f[x_] := Sin[Pi * x];
Plot[Evaluate[{f[x], L[f, n, x]}], {x, -1, 1},
 PlotStyle -> {RGBColor[1, 0, 0], RGBColor[0, 1, 0]}]
Plot[Evaluate[Abs[f[x] - L[f, n, x]]], {x, -1, 1}, PlotRange -> All]

//Prob 2 : primul grafic f(x) - cu rosu; Ln - cu verde; graficul al doilea - eroarea

X =.; X[i_, n_] := -1 + 2 i/n;
l[i_, n_, x_] :=
  Product[If[i == j, 1, (x - X[j, n])/(X[i, n] - X[j, n])], {j, 0,
    n}];
L[f_, n_, x_] := Sum[f[X[i, n]]*l[i, n, x], {i, 0, n}];
n = 15; f[x_] := 1/(1 + 25*x^2);
Plot[Evaluate[{f[x], L[f, n, x]}], {x, -1, 1},
 PlotStyle -> {RGBColor[1, 0, 0], RGBColor[0, 1, 0]}]
Plot[Evaluate[Abs[f[x] - L[f, n, x]]], {x, -1, 1}, PlotRange -> All]

//Prob 3 : primul grafic f(x) - cu rosu; Ln - cu verde; graficul al doilea - eroarea

X =.; X[i_, n_] := Cos[(2 i + 1)*Pi/(2 n + 2)];
l[i_, n_, x_] :=
  Product[If[i == j, 1, (x - X[j, n])/(X[i, n] - X[j, n])], {j, 0,
    n}];
L[f_, n_, x_] := Sum[f[X[i, n]]*l[i, n, x], {i, 0, n}];
n = 15; f[x_] := 1/(1 + 25*x^2);
Plot[Evaluate[{f[x], L[f, n, x]}], {x, -1, 1},
 PlotStyle -> {RGBColor[1, 0, 0], RGBColor[0, 1, 0]}]
Plot[Evaluate[Abs[f[x] - L[f, n, x]]], {x, -1, 1}, PlotRange -> All]

//Prob 4.2 : primul grafic f(x) - cu rosu; Ln - cu verde; graficul al doilea - eroarea

X =.; X[i_, n_] := -1 + 2 i/n;
l[i_, n_, x_] :=
  Product[If[i == j, 1, (x - X[j, n])/(X[i, n] - X[j, n])], {j, 0,
    n}];
L[f_, n_, x_] := Sum[f[X[i, n]]*l[i, n, x], {i, 0, n}];
n = 20; f[x_] := Abs[x];
Plot[Evaluate[{f[x], L[f, n, x]}], {x, -1, 1},
 PlotStyle -> {RGBColor[1, 0, 0], RGBColor[0, 1, 0]},
 PlotRange -> All]
Plot[Evaluate[Abs[f[x] - L[f, n, x]]], {x, -1, 1}, PlotRange -> All]

//Prob 4.3 : primul grafic f(x) - cu rosu; Ln - cu verde; graficul al doilea - eroarea

X =.; X[i_, n_] := Cos[(2 i + 1)*Pi/(2 n + 2)];
l[i_, n_, x_] :=
  Product[If[i == j, 1, (x - X[j, n])/(X[i, n] - X[j, n])], {j, 0,
    n}];
L[f_, n_, x_] := Sum[f[X[i, n]]*l[i, n, x], {i, 0, n}];
n = 20; f[x_] := Abs[x];
Plot[Evaluate[{f[x], L[f, n, x]}], {x, -1, 1},
 PlotStyle -> {RGBColor[1, 0, 0], RGBColor[0, 1, 0]}]
Plot[Evaluate[Abs[f[x] - L[f, n, x]]], {x, -1, 1}, PlotRange -> All]

//Prob 5 : primul grafic f(x) - cu rosu; Ln - cu verde; graficul al doilea - eroarea

X =.; X[i_, n_] := -1 + 2 i/n;
l[i_, n_, x_] :=
  Product[If[i == j, 1, (x - X[j, n])/(X[i, n] - X[j, n])], {j, 0,
    n}];
L[f_, n_, x_] := Sum[f[X[i, n]]*l[i, n, x], {i, 0, n}];
n = 3; f[x_] := x^3 + 2 x^2 - 17 x + 23;
Plot[Evaluate[{f[x], L[f, n, x]}], {x, -1, 1},
 PlotStyle -> {RGBColor[1, 0, 0], RGBColor[0, 1, 0]},
 PlotRange -> All]
Plot[Evaluate[Abs[f[x] - L[f, n, x]]], {x, -1, 1}, PlotRange -> All]
Simplify[L[f, n, x]]

X =.; X[i_, n_] := -1 + 2 i/n;
l[i_, n_, x_] :=
  Product[If[i == j, 1, (x - X[j, n])/(X[i, n] - X[j, n])], {j, 0,
    n}];
L[f_, n_, x_] := Sum[f[X[i, n]]*l[i, n, x], {i, 0, n}];
n = 3; f[x_] := x^3 + 3 x^2 - 2 x + 20;
Plot[Evaluate[{f[x], L[f, n, x]}], {x, -1, 1},
 PlotStyle -> {RGBColor[1, 0, 0], RGBColor[0, 1, 0]},
 PlotRange -> All]
Plot[Evaluate[Abs[f[x] - L[f, n, x]]], {x, -1, 1}, PlotRange -> All]
Simplify[L[f, n, x]]

X =.; X[i_, n_] := Cos[(2 i + 1)*Pi/(2 n + 2)];
l[i_, n_, x_] :=
  Product[If[i == j, 1, (x - X[j, n])/(X[i, n] - X[j, n])], {j, 0,
    n}];
L[f_, n_, x_] := Sum[f[X[i, n]]*l[i, n, x], {i, 0, n}];
n = 3; f[x_] := x^3 + 3 x^2 - 2 x + 20;
Plot[Evaluate[{f[x], L[f, n, x]}], {x, -1, 1},
 PlotStyle -> {RGBColor[1, 0, 0], RGBColor[0, 1, 0]}]
Plot[Evaluate[Abs[f[x] - L[f, n, x]]], {x, -1, 1}, PlotRange -> All]
Simplify[L[f, n, x]]

X = {1, 2, 3, 4, 5, 6}; f[x_] := x^5; n = Length[X] - 1;
t = Table[0., {i, 1, n + 1}, {j, 1, n + 1}];
For[i = 1, i <= n + 1, i++, t[[i, 1]] = f[X[[i]]];]; MatrixForm[t];
For[j = 2, j <= n + 1, j++,
 For[i = 1, i <= n + 2 - j, i++,
  t[[i, j]] = (t[[i + 1, j - 1]] - t[[i, j - 1]])/(X[[j + i - 1]] -
       X[[i]]);]]
MatrixForm[t]

X = {-1, -1/2, 0, 1/2, 1} ; f[x_] := Sin[Pi*x]; n = Length[X] - 1;
t = Table[0., {i, 1, n + 1}, {j, 1, n + 1}];
For[i = 1, i <= n + 1, i++, t[[i, 1]] = f[X[[i]]];]; MatrixForm[t];
For[j = 2, j <= n + 1, j++,
 For[i = 1, i <= n + 2 - j, i++,
  t[[i, j]] = (t[[i + 1, j - 1]] - t[[i, j - 1]])/(X[[j + i - 1]] -
       X[[i]]);]]
MatrixForm[t]

Newt[f_, x_, n_] :=
  f[X[[1]]] +
   Sum[Product[(x - X[[j]]), {j, 1, i}]*t[[1, i + 1]], {i, 1, n}];
Simplify[Newt[f, x, n]]

X =.; X[i_, n_] := -1 + 2 i/n;
l[i_, n_, x_] :=
  Product[If[i == j, 1, (x - X[j, n])/(X[i, n] - X[j, n])], {j, 0,
    n}];

L[f_, n_, x_] := Sum[f[X[i, n]]*l[i, n, x], {i, 0, n}];
n = 4; f[x_] := Sin[Pi*x];
Simplify[L[f, n, x]]

Ex1 - Expresia EAX = 7EAX - 2EBX - EBX/8 folosind instrucţiuni de deplasare

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data

.code
start:
    ;initializez pe eax si ebx cu valori oarecare
    mov eax, 2
    mov ebx, 12
   
    ;pastrez vechea valoare a lui eax in edx
    mov edx, eax

    ;eax*7 = eax*8 - aex
    ;eax*8 = eax << 3 (eax deplasat aritmetic la stanga cu 3 pozitii)
    mov ecx, 3
    sal eax, cl
   
    ;eax=eax*7
    sub eax, edx
   
    ;pastrez vechea valoare a lui ebx in edx
    mov edx, ebx
   
    ;ebx*2
    sal ebx, 1

    ;eax = eax-ebx*2
    sub eax, ebx
   
    mov ebx, edx
    ;ebx/8 = ebx >> 3 (deplasare la dreapta cu 3 pozitii)
    sar ebx, cl
   
    sub eax, ebx
   
    ;apel functie exit
    push 0
    call exit
end start

Problemă propusă. Expresia EAX = 7EAX - 2EBX - EBX/8 folosind instrucţiuni aritmetice

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data

.code
start:
    ;initializez pe eax si ebx cu valori oarecare
    mov eax, 2
    mov ebx, 12
   
mov cl,7
mul cl
mov edx,eax
mov eax,ebx
mov cl,2
mul cl
sub edx,eax
mov eax,ebx
mov cl,8
div cl
sub edx,eax
mov eax,edx
   
    ;apel functie exit
    push 0
    call exit
end start

Ex2 - Să se scrie un program în LA care generează un întreg reprezentabil pe octet şi îl pune în locaţia de memorie rez după formula: rez=AL*num1 + num2*AL + BL. rez, num1 şi num 2 sunt valori reprezentate pe octet, aflate în memorie

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
NUM1 DB 10
NUM2 DB 5
REZ DB 0

.code
start:
    ;initializam pe eax cu 0
    mov eax, 0
   
    ;in al si bl punem niste valori oarecare
    mov al, 2
    mov bl, 4
   
    ;pastram vechea valoare a lui al pe stiva
    push eax
   
    mov ecx, 0
    mov cl, NUM2
    ;al*NUM2
    mul cl
       
    add REZ, bl
    add REZ, al
   
    ;luam de pe stiva vechea valoare a lui al
    pop eax
    mov cl, NUM1
    ;al*NUM1
    mul cl
   
    add REZ, al
    mov dl,rez
   
    ;apel functie exit
    push 0
    call exit
end start

Varianta II. Ex2 - Să se scrie un program în LA care generează un întreg reprezentabil pe octet şi îl pune în locaţia de memorie rez după formula: rez=AL*num1 + num2*AL + BL. rez, num1 şi num 2 sunt valori reprezentate pe octet, aflate în memorie.

.386
.model flat,stdcall
includelib msvcrt.lib
extern exit:proc
public start
.data
NUM1 DB 10
NUM2 DB 5
REZ DB 0
.code
start:
mov eax,0
mov al,2
mov bl,4
mov ecx,eax
mul num1
mov rez,al
mov eax,ecx
mul num2
add rez,al
add rez,bl
mov dl,rez
push 0
call exit
end start

Problemă propusă. Să se scrie un program în LA care generează un întreg reprezentabil pe cuvânt şi îl pune în locaţia de memorie rez după formula: rez = AX * num1 + num2 * (AX + BX). rez, num1, num2 sunt valori reprezentate pe cuvânt, aflate în memorie.

.386
.model flat,stdcall
includelib msvcrt.lib
extern exit:proc
public start
.data
rez dw 0
num1 dw 10
num2 dw 5
.code
start:
mov ax,2
mov bx,4
mov cx,ax
mul num1
mov rez,ax
add cx,bx
mov ax,cx
mul num2
add rez,ax
mov dx,rez
push 0
call exit
end start 

Dioda permite trecere curentului doar într-un singur sens (nu trec alternanţele negative, în acest caz). În AIM-Spice se trece întâi nodul de la + al diodei. Tensiune de prag - până la o anumită tensiune, dioda nu se deschide.

Redresor monoalternanta
D1 1 2 dioda
.model dioda D
R1 2 0 100
Vin 1 0 sin(0 10 1k 0 0)

Redresor dublu alternanta
D1 1 2 di
D2 0 1 di
D3 0 3 di
R1 2 0 100
D4 3 2 di
Vin 1 3 sin(0 10 1k 0 0)
.model di D

Redresor dublu alternanta azi 16.10
D1 1 2 di
D2 0 1 di
D3 0 3 di
R1 2 0 100
D4 3 2 di
Vin 1 3 sin(0 10 1k 0 0)
.model di D

Sa se calculeze suma 2^0+2^1+...+2^n

package ro.utcluj.poo.lab02;
import java.math.BigInteger;
public class Suma2n {
public static void main(String[] args) {
// TODO Auto-generated method stub
BigInteger s,p,c;
/*s=new BigInteger("2");
c=new BigInteger("-1");
s = s.pow(64);
s = s.add(c);
System.out.println(s.toString());*/
p=new BigInteger("1");
c=new BigInteger("2");
s=new BigInteger("0");
int i,n;
n=63;
for(i=0;i<=n;i++)
{
s=s.add(p);
p=p.multiply(c);
//System.out.println(s.longValue());
}
System.out.println(s.longValue());
}
}

Cu functie si test

package ro.utcluj.poo.lab02;
import java.math.BigInteger;
public class Suma2n {
public int putere(double n){
int s,p,c;
int i;
s=0;
p=1;
c=2;
for(i=0;i<=n;i++)
{
s=s+p;
p=p*c;
}
return s;
}
public static void main(String[] args) {
}
}

Test

package ro.utcluj.poo.lab02;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import org.testng.annotations.BeforeMethod;
import static org.testng.Assert.*;
public class Suma2nTest {
Suma2n main;
@BeforeClass
public void init(){
main = new Suma2n();
}
@DataProvider
public Object[][] valoriDeTest(){
return new Double[][]{
{2.0, 7.0, 0.001},
{3.0,15.0, 0.01},
{4.0,31.0,0.01}
};
}

@Test(dataProvider = "valoriDeTest")
public void get(double input, double expected, double precision) {
double result = main.putere(input);
assertEquals(result, expected,precision);
}
}

Să se afişeze termenii 1-30 ai şirurilor recurente x(k)=(n+1)x(k-1)-1 pentru valorile 1-10 ale lui n şi eroarea de calcul pentru fiecare termen.

For[n = 1, n < 11, n++,
 v = Table[0, {i, 1, 30}];
 x = N[1/n, 50];
 For[k = 1, k < 31, k++,
   x = (n + 1)*x - 1;
   v[[k]] = x;]
  Print["n=", n, " val rec ", MatrixForm[N[v]], " erorile ",
   MatrixForm[Abs[v - 1/n]]]]

Să se afişeze termenii 1-30 ai şirului dat de Integrala de la 0 la 1 din x^n/(x+5)

j = NIntegrate[1/(x + 5), {x, 0, 1}];
N[j]
x =.;
For[n = 1, n < 31, n++,
 j = 1/n - 5 j;
 Print["n=", n, " val.rec ", j, " eroare ",
  Abs[j - NIntegrate[x^n/(x + 5), {x, 0, 1}]]]]
N[log[1.2], 10]

Să se aproximeze funcţia Sinus pentru un x dat folosind Polinomul lui Taylor. Să se afişeze valoarea calculată cu Taylor şi valoarea corectă Sin[x]

x = N[\[Pi]/4 + 40*\[Pi]];
While[x > 2 Pi,
 x = x - 2 Pi;]
While[x < 0,
 x = x + 2 Pi;]
s = 0;
t = x;
k = 1;
While[Abs[t] > 10^(-15),
 s = s + t;
 t = -x^2/(2 k)/(2 k + 1)*t;
 k = k + 1;]
Print["x=", N[x, 20], " aprox. ", N[s, 20], " val.corecta ", Sin[x]]

Ex1

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
var1 DB 10,2,3,14
var2 DW 15,6,7,8
var3 DD 1020A0h, 011223344h, 01A2B3C4Dh
var4 equ 10
var5 DB '1', '2', "abc"
var6 DB 4 DUP(5)

.code
start:
    mov eax, 0
    mov al, var1
    mov ah, 11
    mov ebx, 0
    mov bx, var2
    mov ecx, var3
    mov edx, var4
    add ecx, edx
    mov dl, var5
    mov dh, var6
   
    ;terminarea programului
    push 0
    call exit
end start

Model

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem biblioteci, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
;aici declaram date
sir db 1,2,3
.code
start:
    ;aici se scrie codul
    mov si,0
    mov bx,0
    mov ax, sir[bx+si+1]

    ;terminarea programului
    push 0
    call exit
end start

Reguli
1. Primul rând este întotdeauna un comentariu
2. Se scrie o singură componentă pe linie
select C1 - Shift+F1 - Help
C1 in (nod) out (nod)
3. Nu se speciufică unitatea de măsură (doar multipli sau submultipli)
4. Nodul de la masă se notează întotdeauna cu 0
5. Ordinea componentelor este arbitrară
6. * sau ! la începutul rândului îl transformă în comentariu
7. Nu se lasă spaţiu la începutul rândului
8. Prima poziţie pe rând este piesa (elementul de circuit)

RC trece jos
R1 in out 1k
C1 out 0 470n
!Vin in 0 dc 5 sin(0 5 200 0 0)
Vin in 0 dc 5 pulse(0 5 0 0.01e-3 0.01e-3 0.2e-3 0.4e-3)

RC trece jos
R1 in out 1k
C1 out 0 4,7n
!Vin in 0 dc 5 sin(0 5 200 0 0)
Vin in 0 dc 5 pulse(0 5 0 0.01e-4 0.01e-4 0.2e-4 0.4e-4)

RC trece sus
C1 in out 2500n
R1 out 0 1k
!Vin in 0 dc 5 sin(0 5 10k 0 0)
Vin in 0 dc 5 pulse(0 5 0 0.01e-3 0.01e-3 0.2e-2 0.4e-2)

Un labirint este codificat printr-o matrice de   elemente ale cărui culoare sunt reprezentate prin elemente egale cu 1, situate în poziţii consecutive pe o aceeaşi linie sau coloană, celelalte elemente fiind 0. O persoană se găseşte în poziţia (i, j) din interiorul labirintului. Se cere afişarea tuturor traseelor de ieşire din labirint care nu trec de mai multe ori prin acelaşi loc.
De fapt, se consideră intrarea prin punctul (1,1) şi ieşirea prin punctul (n,m).

#include <stdio.h>
#include <stdlib.h>

typedef struct punct
{
    int l,c;
}pct;

int a[100][100];

int valid (pct p[100],int k)
{
    if (a[p[k].l][p[k].c]==1)
        return 1;
    else
        return 0;
}

void afis(pct p[100],int k,int n,int m)
{
    int i,j;
    for (i=1;i<=n;i++)
    {
        for (j=1;j<=m;j++)
            printf("%d ",a[i][j]);
        printf("\n");
    }
    printf("\n");
}

void back(int k,pct p[100],int n,int m)
{
    int x,pi[]={0,1,0,-1},pj[]={-1,0,1,0};
    for (x=0;x<=3;x++)
    {
        p[k].c=p[k-1].c+pi[x];
        p[k].l=p[k-1].l+pj[x];
        if (valid(p,k))
        {
            a[p[k].l][p[k].c]=2;
            if (p[k].c==m && p[k].l==n)
            {
                afis(p,k,n,m);
            }
            else
            {
                back(k+1,p,n,m);
            }
            a[p[k].l][p[k].c]=1;
        }
    }

}

int main()
{
    FILE *f;
    int i,j,n,m;
    pct p[100];
    f=fopen("in.txt","r");
    fscanf(f,"%d %d",&n,&m);
    for (i=1;i<=n;i++)
        for (j=1;j<=m;j++)
            fscanf(f,"%d",&a[i][j]);
    for (i=0;i<=m+1;i++)
    {
        a[0][i]=0;
        a[n+1][i]=0;
    }
    for (i=0;i<=n+1;i++)
    {
        a[0][i]=0;
        a[m+1][i]=0;
    }
    for (i=0;i<=n*m;i++)
    {
        p[i].c=0;
        p[i].l=0;
    }
    p[1].c=1;
    p[1].l=1;
    a[1][1]=2;
    back(2,p,n,m);
    return 0;
}

in.txt

5 6
1 0 0 1 0 0
1 1 0 1 0 0
1 1 1 0 0 0
0 1 1 1 0 1
0 0 1 1 1 1

Colorarea grafurilor. Fiind dat un graf neorientat G =(X, Γ) unde X este mulţimea formată din n noduri, iar Γ este mulţimea muchiilor şi un număr de m culori, se cere să se determine toate colorările posibile ale nodurilor grafului folosind cele m culori, astfel încât oricare două noduri adiacente să fie colorate în mod diferit.

#include <stdio.h>
#include <stdlib.h>

int valid(int k,int x[],int a[100][100])
{
    int i;
    for (i=1; i<k; i++)
        if (a[i][k]==1 && x[i]==x[k])
            return 0;
    return 1;
}

void afis(int x[],int n)
{
    int i;
    for (i=1; i<=n; i++)
    {
        printf("%d - %d ",i,x[i]);
    }
    printf("\n");
}

void back(int k,int c,int n,int m,int x[],int a[100][100])
{
    int i;
    for (i=1; i<=c; i++)
    {
        x[k]=i;
        if (valid(k,x,a))
        {
            if (k==n)
                afis(x,k);
            else
                back(k+1,c,n,m,x,a);
        }
    }
}

int main()
{
    int a[100][100],n,m,c,i,j,x[100];
    FILE *f;
    f=fopen("in.txt","r");
    fscanf(f,"%d %d %d",&n,&m,&c);
    for (i=1; i<=n; i++)
        for (j=1; j<=m; j++)
            fscanf(f,"%d",&a[i][j]);

    back(1,c,n,m,x,a);
    return 0;
}

in.txt

5 5 3
0 1 0 0 1
1 0 1 1 0
0 1 0 1 0
0 1 1 0 1
1 0 0 1 0

Fiind date o tablă de şah de dimensiune   pătrate şi un cal plasat în pătratul din stânga sus al tablei, să se afişeze toate posibilităţile de mutare a calului astfel încât să treacă o singură dată prin fiecare pătrat al tablei.

Problema celor n regine

#include <stdio.h>
#include <stdlib.h>
int r[10],nr=0,n;
void afisare()
{
    int i,j;
    nr++;
    for(i=1; i<n+1; i++)
    {
        for(j=1; j<n+1; j++)
            if(r[i]==j)
                printf("1");
            else printf(".");
        printf("\n");
    }
    printf("\n");
}
int verif(int i)
{
    int j;
    for(j=1; j<i; j++)
        if(r[i]==r[j])
            return 0;
    for(j=1; j<i; j++)
        if(abs(r[i]-r[j])==abs(i-j))
            return 0;
    return 1;
}

void back(int i)
{
    int j;
    for(j=1; j<=n; j++)
    {
        r[i]=j;
        if(verif(i))
            if(i==n)
                afisare();
            else back(i+1);
    }
}

int main()
{
    printf("n=");
    scanf("%d",&n); // n global
    back(1);
    printf("%d solutii",nr);
    printf("\nApasati o tasta pentru terminare");
    getch();
    return 0;
}

Se consideră o mulţime formată din n elemente numere întregi. Să se genereze toate submulţimile acestei mulţimi având proprietatea că suma elementelor lor este egală cu S.

#include <stdio.h>
#include <stdlib.h>
int x[100],n,s,a[100];

void afisare(int n)
{
    int i;
    for(i=1; i<=n; i++)
        printf("%d+",a[x[i]]);
    printf("\b");
    printf("\n");
}

void back(int i, int s)
{
    int j,sr;
    for(j=x[i-1]+1; j<=n; j++)
    {
        x[i]=j;
        sr=s-a[x[i]];
        if(sr==0)
            afisare(i);
        else if(sr)
            back(i+1,sr);
    }
}

int main()
{
    int i;
    printf("n=");
    scanf("%d",&n);
    printf("s=");
    scanf("%d",&s);
    for(i=1; i<=n; i++)
        a[i]=i; // sau citirea elementelor vectorului
    back(1,s);
    printf("\nApasati o tasta pentru terminare");
    getch();
    return 0;
}

Aranjarea pe o tabla de sah n*n a m cai

#include <stdio.h>
#include <stdlib.h>
typedef struct punct{
    int i,j;
    }punct;
punct sol[100];
int x[100],n,m,a[100];

void afisare()
{
    int i;

}

int verif(int k)
{
    int i,j;

}

void back(int k)
{int j;
for(j=1;j<=n;j++)
    {r[k]=j;
    if(verif(k))
        if(i==n)
            afisare();
        else back(k+1);
    }
}

int main()
{
    printf("n=");
    scanf("%d",&n);
    printf("m=");
    scanf("%d",&m);
    back(1);
    printf("\nApasati o tasta pentru terminare");
    getch();
    return 0;
}

Explorarea în lărgime

#include <stdio.h>
#include <stdlib.h>

typedef struct Nod{
    int cheie;
    struct Nod *urm;
    } nod;

void adauga_coada(nod **prim, int s)
{
    nod*p=NULL;
    p=(nod*)malloc(sizeof(nod));
    p->cheie=s;
    p->urm=NULL;

    if(*prim==NULL)
        *prim=p;
    else
    {
    nod*q=NULL;
    q=*prim;
    while(q->urm!=NULL)
        q=q->urm;
    q->urm=p;
    p->urm=NULL;
    }
}

void sterge_coada(nod **prim)
{
    nod*p=*prim;
    (*prim)=(*prim)->urm;
    free(p);
}

void largime(int a[][20],int n, int s)
{
    nod *prim=NULL;
    int viz[20];
    int i;
    for(i=0;i<n;i++)
        viz[i]=0;
    viz[s]=1;
    printf("%d ",s);
    adauga_coada(&prim,s);
    while(prim!=NULL)
    {
        int v=prim->cheie;
        int w=0;
        for(w=0;w<n;w++)
        {
            if(a[v][w]==1 && viz[w]==0)
            {
                viz[w]=1;
                printf("%d ",w);
                adauga_coada(&prim,w);
            }
        }
        sterge_coada(&prim);
    }
}

int main()
{
    int n,a[20][20],i,j,ok=1;
    FILE *f;
    f=fopen("date.txt","r");
    fscanf(f,"%d",&n);
    for(i=0;i<n;i++)
        for(j=0;j<n;j++)
        a[i][j]=0;
    while(ok>0)
    {
        ok=fscanf(f,"%d,%d ",&i,&j);
        a[i][j]=a[j][i]=1;
    }
    printf("Nod de start: ");
    int p;
    scanf("%d",&p);
    largime(a,n,p);
    printf("\nApasati o tasta pentru iesire");
    getch();
    return 0;
}

date.txt

8
0,1 0,2 0,3
1,3 1,5 1,6
2,3 2,4
6,7

Explorarea în adâncime

#include <stdio.h>
#include <stdlib.h>

typedef struct Nod
{
    int cheie;
    struct Nod *urm;
} nod;

void adauga_stiva(nod **vf, int x)
{
    nod*p;
    p=(nod*)malloc(sizeof(nod));
    p->cheie=x;
    p->urm=*vf;
    *vf=p;
}

void sterge_stiva(nod **vf)
{
    nod *x;
    x=(*vf);
    (*vf)=(*vf)->urm;
    free(x);
}

void adancime(int a[][20],int n, int s)
{
    nod *prim=NULL;
    int viz[20];
    int i,w,v;
    for(i=0; i<n; i++)
        viz[i]=0;
    viz[s]=1;
    printf("%d ",s);
    adauga_stiva(&prim,s);
    while(prim!=NULL)
    {
        v=prim->cheie;
        w=0;
        for(w=0;w<n;w++)
        {
            if(a[v][w]==1 && viz[w]==0)
                break;
        }
        if(w<n)
        {
            viz[w]=1;
            printf("%d ",w);
            adauga_stiva(&prim,w);
        }
        else sterge_stiva(&prim);
    }
}

int main()
{
    int n,a[20][20],i,j,ok=1;
    FILE *f;
    f=fopen("date.txt","r");
    fscanf(f,"%d",&n);
    for(i=0; i<n; i++)
        for(j=0; j<n; j++)
            a[i][j]=0;
    while(ok>0)
    {
        ok=fscanf(f,"%d,%d ",&i,&j);
        a[i][j]=a[j][i]=1;
    }
    printf("Nod de start: ");
    int p;
    scanf("%d",&p);
    adancime(a,n,p);
    printf("\nApasati o tasta pentru iesire");
    getch();
    return 0;
}

date.txt

8
0,1 0,2 0,3
1,3 1,5 1,6
2,3 2,4
6,7

Algoritmul lui Dijkstra. Algoritmul lui Dijkstra este o metodă de a stabili drumul de cost minim de la un nod de start la oricare altul dintr-un graf.

#include <stdio.h>
#include <stdlib.h>
void dijkstra (int n,int a[][100])
{
    int tata[n],cost[n][n],dist[n],s[n],i,j,pas,k,q,minim;
    for (i=1;i<=n;i++)
        for (j=1;j<=n;j++)
            if (i==j)
                cost[i][j]=0;
            else
                if (a[i][j])
                    cost[i][j]=a[i][j];
                else
                    cost[i][j]=100000;
    for (i=1;i<=n;i++)
    {
        s[i]=0;
        dist[i]=cost[1][i];
        if (dist[i]<100000)
            tata[i]=1;
        else
            tata[i]=0;
    }
    s[1]=1;
    tata[1]=0;
    for (i=1;i<n;i++)
    {
        minim=100000;
        for (q=1;q<=n;q++)
            if (dist[q]<minim && dist[q])
            {
                minim=dist[q];
                k=q;
            }

        if (k==100000)
            return;
        s[k]=1;
        for (j=1;j<=n;j++)
            if (s[j]==0 && dist[k]+cost[k][j]<dist[j])
            {
                dist[j]=dist[k]+cost[k][j];
                tata[j]=k;
            }
    }
    for (i=2;i<=n;i++)
        printf("%d - %d\n",dist[i],tata[i]);
}

int main()
{
    int a[100][100],n,m,i,x,y,c,j;
    FILE *f;
    f=fopen("date.txt","r");

    fscanf(f,"%d %d\n",&n,&m);
    for (i=0;i<m;i++)
    {
        fscanf(f,"%d %d %d\n",&x,&y,&c);
        a[x][y]=c;
    }
    dijkstra(n,a);
    return 0;
}

date.txt

10 8
1 2 9
1 3 1
1 4 3
1 7 9
3 5 2
3 6 5
4 7 5
5 2 4
5 6 1
6 7 1
8 4 1
8 6 4
8 7 2

Program - algoritm de explorare in largime
functie, declarare matrice, citire arce, construire matrice, apelare functie de exploorare in largime

void largime(int a[][100],int n,int s)
{
    int viz[n],coada[n],i,k=0,j,ct;
    coada[0]=s;
    for (i=1;i<=n;i++)
        viz[i]=0;
    viz[k]=1;
    k++;

    while (k<n)
    {
        ct=0;
        for (i=ct;i<k;i++)
        {
            for (j=1;j<=n;j++)
                if (a[coada[i]][j] && viz[j]==0)
                {
                    viz[j]=1;
                    coada[k]=j;
                    k++;
                }
            ct++;
        }
    }
    for (i=0;i<n;i++)
        printf("%d ",coada[i]);
    printf("\n");
}

Conspect ALGORITMI PENTRU PRELUCRAREA GRAFURILOR

si primul algoritm (Algoritmul lui Dijkstra)

void dijkstra (int n,int a[][100])
{
    int tata[n],cost[n][n],dist[n],s[n],i,j,pas,k,q,minim;
    for (i=1;i<=n;i++)
        for (j=1;j<=n;j++)
            if (i==j)
                cost[i][j]=0;
            else
                if (a[i][j])
                    cost[i][j]=a[i][j];
                else
                    cost[i][j]=100000;
    for (i=1;i<=n;i++)
    {
        s[i]=0;
        dist[i]=cost[1][i];
        if (dist[i]<100000)
            tata[i]=1;
        else
            tata[i]=0;
    }
    s[1]=1;
    tata[1]=0;
    for (i=1;i<n;i++)
    {
        minim=100000;
        for (q=1;q<=n;q++)
            if (dist[q]<minim && dist[q])
            {
                minim=dist[q];
                k=q;
            }

        if (k==100000)
            return;
        s[k]=1;
        for (j=1;j<=n;j++)
            if (s[j]==0 && dist[k]+cost[k][j]<dist[j])
            {
                dist[j]=dist[k]+cost[k][j];
                tata[j]=k;
            }
    }
    for (i=2;i<=n;i++)
        printf("%d - %d\n",dist[i],tata[i]);

}

Main

int main()
{
    int a[100][100],n,m,i,x,y,c,j;
    FILE *f;
    f=fopen("in.txt","r");

    fscanf(f,"%d %d\n",&n,&m);
    for (i=0;i<m;i++)
    {
        fscanf(f,"%d %d %d\n",&x,&y,&c);
        a[x][y]=c;
    }

    largime(a,n,1);

    dijkstra(n,a);
    return 0;
}

Lab 8 - prob. 3.2

Să se implementeze algoritmii prezentaţi aferenţi unei tabele de dispersie. Înregistrarea va conţine datele aferente unui student. Cheia va fi numele şi prenumele studentului. Scrieţi în plus
faţă de cele prezentate o funcţie de ştergere a unei înregistrări de cheie dată.
// nu chiar toti studentii sunt gasiti

#include <stdio.h>
#include <stdlib.h>
#include<string.h>
#define M 27
typedef struct Nod{
    char nume[50];
    char facult[50];
    int an;
    struct nod *st,*dr;
    } nod;
int ff(char cuv[])
{
    return cuv[0]-'A';
}
// antete functii tabela
void adaug(nod *ht[],char nume[],char facult[],int an);
void afis(nod *ht[]);
nod* caut(nod *ht[],char nume[]);
void stergere(nod *ht[],char nume[]);
// antete functii arbore
nod* adaug_arbore(nod *r, char nume[],char facult[],int an);
void afisIN(nod *r);
nod* caut_arbore(nod *r,char nume[]);
nod* stergere_arbore(nod *r,char nume[]); // functia lunga din laborator
// functii tabela
void adaug(nod *ht[],char nume[], char facult[],int an)
{
    int i=ff(nume);
    ht[i]=adaug_arbore(ht[i],nume,facult,an);
}
void afis(nod *ht[])
{
    int i=0;
    for(i=0; i<M; i++)
    {
        nod *rad=ht[i];
        afisIN(rad);
    }
}
//functii arbore
nod* caut_arbore(nod *r,char nume[])
{
    nod *p=NULL;
    if(r!=0)
    {
        if(strcmp(nume,r->nume)==0)
            p=r;
        else if(strcmp(nume,r->nume)<0)
            p=caut_arbore(r->st,nume);
        else caut_arbore(r->dr,nume);
    }
    return p;
}
nod* adaug_arbore(nod *p, char nume[50],char facult[50],int an)
{
    if(p==NULL)
    {
        p=(nod *)malloc(sizeof(nod));
        p->st=p->dr=NULL;
        strcpy(p->nume,nume);
        strcpy(p->facult,facult);
        p->an=an;
    }
    else if(strcmp(p->nume,nume)>0)
            p->st=adaug_arbore(p->st,nume,facult,an);
    else if(strcmp(p->nume,nume)<0)
            p->dr=adaug_arbore(p->dr,nume,facult,an);
    else if(strcmp(p->nume,nume)==0)
            return p;
}
void afisIN(nod *r)
{
    if(r)
    {
        afisIN(r->st);
        printf("%s %s %d \n",r->nume,r->facult,r->an);
        afisIN(r->dr);
    }
}
int main()
{
    FILE *f;
    nod *rad=0;
    nod* ht[M];
    int i=0,an;
    char nume[50],facult[50];
    for(i=0; i<M; i++)
        ht[i]=0;
    f=fopen("date.txt","r");
    if(f==NULL)
    {
        printf("error");
        return -1;
    }
    while(!feof(f))
    {
        fscanf(f,"%s %s %d",nume,facult,&an);
        rad=adaug_arbore(rad,nume,facult,an);
        //adaug(ht[ff(nume)],nume,facult,an);
    }
    afisIN(rad);
    //printf("\n\n");
    //afis(ht[i]);
    char nume_cautare[40];
    printf("\nCautare student (nume): ");
    scanf("%s",nume_cautare);
    nod *p=caut_arbore(rad,nume_cautare);
    if(p!=NULL)
    {
        printf("%s %s %d\n",p->nume,p->facult,p->an);
    }
    else printf("Nu exista studentul cu numele introdus\n\n");
    printf("Apasati o tasta pentru terminare");
    getch();
    return 0;
}

Pro's

#include <stdio.h>
#include <stdlib.h>

typedef struct nodtype
{
    char nume[20];
    struct nod *dr,*st;
}nod;

void inserare(char nume[20],nod **rad)
{
    nod *p,*q;
    p=(nod *)malloc(sizeof(nod));
    p->st=NULL;
    p->dr=NULL;
    strcpy(p->nume,nume);
    q=*rad;

    if (*rad)
    {
        for (;;)
        {
            if (strcmp(nume,q->nume)<0)
            {
                if (q->st==0)
                {
                    q->st=p;
                    return;
                }
                else
                    q=q->st;
            }
            else
                if (strcmp(nume,q->nume)>0)
                {
                    if (q->dr==0)
                    {
                        q->dr=p;
                        return;
                    }
                    else
                        q=q->dr;
                }
                else
                {
                    return;
                }
        }
    }
    else
        (*rad)=p;
}

void afisare(nod *rad)
{
    if (rad)
    {
        afisare(rad->st);
        printf("%s\n",rad->nume);
        afisare(rad->dr);
    }
}

nod *cautare(nod *rad,char nume[])
{
    nod *p=NULL;
    if (rad)
    {
        if (!strcmp(rad->nume,nume))
            p=rad;
        else
            if (strcmp(rad->nume,nume)<0)
                p=cautare(rad->st,nume);
            else
                 p=cautare(rad->dr,nume);
    }
    return p;
}

void stergere(nod **rad,char nume[20])
{
    nod *p,*q,*tp,*tq;
    int directie=0;
    p=(*rad);
    tp=0;
    while (p && strcmp(p->nume,nume))
        if (strcmp(p->nume,nume)>0)
        {
            tp=p;
            p=p->st;
            directie=1;
        }
        else
            if (strcmp(p->nume,nume)<0)
            {
                tp=p;
                p=p->dr;
                directie=2;
            }
    if (p==0)
        return 0;
    if (p->st==0)
        q=p->dr;
    else
    {
        if (p->dr==0)
        {
            q=p->st;
        }
        else
        {
            tq=p;
            q=p->dr;
            while (q)
            {
                tq=q;
                q=q->st;
            }
            q->st=p->st;
            if (tq!=p)
            {
                tq->st=q->dr;
                q->dr=p->dr;
            }
        }
    }
    if (p==(*rad))
        (*rad)=q;
    free(p);
    if (tp)
    {
        if (directie==1)
            tp->st=q;
        else
            tp->dr=q;
    }
}

int dispersie(char nume[20])
{
    return (nume[0]-'A');
}

int main()
{
    FILE *f;
    int n,k,i;
    char nume[20];
    f=fopen("in.txt","r");
    fscanf(f,"%d\n",&n);
    nod *ht[27];

    for (i=0;i<27;i++)
        ht[i]=NULL;

    for (i=0;i<n;i++)
    {
        fgets(nume,20,f);
        strcpy(nume+strlen(nume)-2,nume+strlen(nume));
        k=dispersie(nume);
        inserare(nume,&ht[k]);
    }

    for (i=0;i<27;i++)
    {
        afisare(ht[i]);
    }

    /*char caut[20];
    scanf("%s",caut);
    nod *p;
    p=cautare(ht[caut[0]-'A'],caut);
    printf("%s\n",p->nume);
    */
    char sterg[20];
    scanf("%s",sterg);
    stergere(&ht[sterg[0]-'A'],sterg);

    afisare(ht[sterg[0]-'A']);
    return 0;
}