Faculty

[PLA] 7 noiembrie - Lab 5

2014-11-10T10:45:00.001-08:00

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).

[PLA] 4 noiembrie - Lab 4

2014-11-04T00:53:00.001-08:00

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

[POO] 28 octombrie - Lab 4 - Lucru cu Matrici

2014-10-28T15:02:00.004-07:00

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");
}
}

[CAN] 23 octombrie - Lab 3

2014-10-23T04:46:00.000-07:00

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

[CN] 20 octombrie - Lab 2

2014-10-20T04:41:00.000-07:00

//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]]

[PLA] 17 octombrie - Lab 3

2014-10-17T01:16:00.000-07:00

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

[CAN] 16 octombrie - Lab 2

2014-10-16T00:44:00.000-07:00

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

[POO] 14 octombrie - Lab 2 - Suma 2 la n

2014-10-14T23:48:00.000-07:00

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);
}
}

[CN] 13 octombrie - Lab 1

2014-10-13T15:44:00.000-07:00

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]]

[PLA] 10 octombrie - Lab 2

2014-10-10T01:15:00.000-07:00

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

[CAN] 9 octombrie - Lab 1

2014-10-09T15:46:00.000-07:00

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)

Laborator 13 - Test Backtracking (27 mai)

2014-05-27T04:07:00.002-07:00

Laborator 12 - Backtracking (20 mai)

2014-05-26T22:38:00.000-07:00

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.

Laborator 11 - Backtracking (13 mai)

2014-05-13T01:11:00.001-07:00

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;
}

Laborator 10 - Reprezentarea si traversarea grafurilor + Algoritmi pentru prelucrarea grafurilor (6 mai)

2014-05-06T01:35:00.001-07:00

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

Laborator 9 - Test Liste, Arbori, Tabele de dispersie (29 aprilie)

2014-04-29T11:00:00.000-07:00

Laborator 8 - Reprezentarea si traversarea grafurilor (15 aprilie)

2014-04-15T01:34:00.002-07:00

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;
}

Lucrările 6 şi 7 VHDL - Domeniul secvenţial. Procese (6), Instrucţiuni secvenţiale (7) (8 aprilie)

2014-04-13T00:29:00.002-07:00

Numărător - Active HDL

library    IEEE;
use IEEE.STD_LOGIC_1164.all;
use IEEE.STD_LOGIC_UNSIGNED.all;

entity ent_numarator is
    Port (CLK: in STD_LOGIC;
    R:in STD_LOGIC;
    L:in std_logic;
    INPUT: std_logic_vector (3 downto 0);
    Q:out STD_LOGIC_VECTOR (3 downto 0));
end ent_numarator;

architecture arh_numarator of ent_numarator is
begin
process(CLK)
variable intQ:std_logic_vector(3 downto 0);
    begin
        if (clk'event and R='1') then
            intQ:="0000";
        elsif (clk'event and clk='1') then
            if(intQ="1111") then
                intQ:="0000";
            else
                intQ:=intQ+'1';
            end if;
        elsif (clk'event and L='1') then
            intQ:=INPUT;
        end if;
    Q<=intQ;
end process;
end arh_numarator;

Numărător - Xilinx

library    IEEE;
use IEEE.STD_LOGIC_1164.all;
use IEEE.STD_LOGIC_UNSIGNED.all;

entity ent_numarator is
    Port (CLK: in STD_LOGIC;
    R:in STD_LOGIC;
    L:in std_logic;
    INPUT: std_logic_vector (3 downto 0);
    Q:out STD_LOGIC_VECTOR (3 downto 0));
end ent_numarator;

architecture arh_numarator of ent_numarator is
begin
process(CLK)
variable intQ:std_logic_vector(3 downto 0);
    begin
        if (clk='1' and clk'event) then
            if(r='1') then
                intQ:="0000";
            elsif (l='1') then
            intQ:=INPUT;
            else intQ:=intQ+'1';
            end if;
        end if;

    Q<=intQ;
end process;
end arh_numarator;

NET "D(3)" LOC = T5;
NET "D(2)" LOC = V8;
NET "D(1)" LOC = U8;
NET "D(0)" LOC = N8;
NET "Reset" LOC = T9;
NET "Load" LOC = T10;
NET "Q(3)" LOC = T11;
NET "Q(2)" LOC = R11;
NET "Q(1)" LOC = N11;
NET "Q(0)" LOC = M11;
NET "CLK" LOC = B8;

Divizor de frecvenţă - nefuncţional (un led se aprinde o dată pe secundă)

library IEEE;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;

entity numarator is
    port (CLK:in STD_LOGIC;
    CLK1:out STD_LOGIC);
end;

architecture arh1 of numarator is
begin
process(CLK)
    variable K:STD_LOGIC:='0';
    variable X:INTEGER RANGE 0 to 100_000_000;
    begin
        --if (CLK'EVENT and CLK='1') then
        --    X:=X+1;
        --end if;

        --if (X=99_999_999) then
        --    K:='1';
        --    X:=0;
        --else K:='0';
        --    X:=X+1;
        --end if;


        CLK1<=CLK;
    end process;
end arh1;

Reclamă luminoasă - inexistent

Laborator 7 - Tabele de dispersie (8 aprilie)

2014-04-08T01:29:00.001-07:00

Test dupa vacanta: liste, arbori, tabele de dispersie

Se citesc dintr-un fisier cuvinte. Fiecare cuvant citit se va insera intr-o tabela de dispersie. Sa se afiseze cuvintele din fisier in ordine lexico-grafica crescatoare si frecventa lor de aparitie.

Terminare problema + adaugare functie de stergere a cuvintelor care apar o singura data

#include <stdio.h>
#include <stdlib.h>
#include<string.h>
#define M 27
typedef struct nod{
    char cuv[20]; // cheia
    int fr; // frecventa cuvantului
    struct nod *st,*dr;
    } nod;

int f(char cuv[20])
{
    return cuv[0]-'a';
}

nod* construire(nod *p, char cuv[20])
{
    if(p==NULL)
    {
        p=(nod *)malloc(sizeof(nod));
        p->st=p->dr=NULL;
        p->fr=1;
        strcpy(p->cuv,cuv);
    }
    else if(strcmp(p->cuv,cuv)>0)
            p->st=construire(p->st,cuv);
    else if(strcmp(p->cuv,cuv)<0)
            p->dr=construire(p->dr,cuv);
    else if(strcmp(p->cuv,cuv)==0)
            p->fr++;
    return p;
}

void adaug_tabela(nod *ht[],char cuv[20])
{
    int i=f(cuv);
    ht[i]=construire(ht[i],cuv);
}

void afisIN(nod *r, int nivel)
{
    if(r)
    {
        afisIN(r->dr,nivel+1);
        int i=0;
        for(i=0; i<nivel; i++)
            printf(" ");
        printf("%s ",r->cuv);
        printf("%d\n",r->fr);
        afisIN(r->st,nivel+1);
    }
}

void afis(nod *ht[])
{
    int i=0;
    for(i=0; i<M; i++)
    {
        nod *rad=ht[i];
        afisIN(rad,0);
    }
}

int main()
{
    FILE *f;
    int i;
    char a[20];
    f=fopen("date.txt","r");
    nod* ht[M];
    for(i=0; i<M; i++)        ht[i]=0;
    while(!feof(f))
    {
        fscanf(f,"%s",a);
        adaug_tabela(ht,a);
    }
    afis(ht);
    printf("Apasati o tasta pentru terminare");
    getch();
    return 0;
}

Pro's version

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

typedef struct nodtype
{
    char key[20];
    int fv;
    struct nodtype *st,*dr;
}nod;

int dispersie(char s[])
{
    return (s[0]-'a');
}

void inserare(char x[],nod **rad)
{
    nod *p,*q;
    p=(nod *)malloc(sizeof(nod));
    p->st=0;
    p->dr=0;
    p->fv=1;
    strcpy(p->key,x);
    q=*rad;

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

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

int main()
{
    int n,N=27;
    FILE *f;
    f=fopen("in.txt","r");
    char s[20];
    int i,k;

    nod *ht[N];

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

    fscanf(f,"%d\n",&n);

    for (i=0;i<n;i++)
    {
        fgets(s,20,f);
        k=dispersie(s);
        inserare(s,&ht[k]);
    }

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

    return 0;
}

Conspect: REPREZENTAREA ŞI TRAVERSAREA GRAFURILOR

Laborator 6 - Arbori binari de cautare (1 aprilie)

2014-04-01T01:32:00.003-07:00

Din fisier se citesc cuvinte (siruri de caractere, cu fscanf). Să se scrie un program care creează un arbore de căutare, care conţine în noduri cuvintele şi frecvenţa lor de apariţie. Să se afişeze apoi cuvintele în ordine lexicografică crescătoare şi frecvenţa lor de apariţie (parcurgere in inordine, S < R < D).

#include <stdio.h> // functia de cautare pt cresterea frecventei
#include <stdlib.h>
typedef struct tip_nod
{
int f;
char s[20];
struct tip_nod *st, *dr;
} nod;
nod *rad;
void inserare_nerecursiva(char s[])
{
nod *p,*q;
int n;
n=sizeof (nod);
p=(nod*)malloc(n);
strcpy(p->s,s);
p->st=0;
p->dr=0;
if (rad==0)
{
rad=p;
return;
}
q=rad;
for ( ; ; )
{
if (strcmp(s,q->s)<0)
{
if (q->st==0)
{
q->st=p;
return;
}
else q=q->st;
}
else if (strcmp(s,q->s)>0)
{
if (q->dr==0)
{
q->dr=p;
return;
}
else q=q->dr;
}
else
{
p->f++;
free (p);
return;
}
}
}

void inordine(nod *p, int nivel)
{
int i;
if (p!=0)
{
inordine(p->st,nivel+1);
//for(i=0; i<=nivel; i++) printf(" ");
printf("%s %d\n",p->s,p->f);
inordine(p->dr,nivel+1);
}
}
int main()
{
FILE *f;
f=fopen("date.txt","r");
char s[20];
while(!feof(f))
{
fscanf(f,"%s",s);
inserare_nerecursiva(s);
}
inordine(rad,0);
printf("\nApasati o tasta pentru terminare");
getch();
return 0;
}

Functia sterge_nod

TIP_NOD *stergere_nod(TIP_NOD *rad,int key)
{
    TIP_NOD *p,*tata_p;/* p este nodul de sters, iar tata_p este tatal lui */
    TIP_NOD *nod_inlocuire,*tata_nod_inlocuire;/*nodul care il va inlocui pe p si tatal sau */
    int directie; /*stg=1;dr=2*/
    if(rad==0) return 0; /*arborele este vid */
    p=rad;
    tata_p=0; /* cautare nod cu cheia key */
    while((p!=0)&&(p->cheie!=key))
    {
        if (key<p->cheie)
        {
            /*cautare in stanga */
            tata_p=p;
            p=p->stg;
            directie=1;
        }
        else
        {
            /*cautare in dreapta */
            tata_p=p;
            p=p->dr;
            directie=2;
        }
    }
    if(p==0)
    {
        printf("\n NU EXISTA NOD CU CHEIA=%d\n",key);
        return rad;
    }      /* s-a gasit nodul p de cheie key */
    if(p->stg==0)
        nod_inlocuire=p->dr; /* nodul de sters p nu are fiu sting */
    else if(p->dr==0) nod_inlocuire=p->stg;   /*nodul de sters p nu are fiu drept*/
    else
    {
        /* nodul de sters p are fiu stang si fiu drept */
        tata_nod_inlocuire=p;
        nod_inlocuire=p->dr;        /* se cauta in subarborele drept*/
        while(nod_inlocuire->stg!=0)
        {
            tata_nod_inlocuire=nod_inlocuire;
            nod_inlocuire=nod_inlocuire->stg;
        }
        if(tata_nod_inlocuire!=p)
        {
            tata_nod_inlocuire->stg=nod_inlocuire->dr;
            nod_inlocuire->dr=p->dr;
        }
        nod_inlocuire->stg=p->stg;
    }
    free(p);
    printf("\nNodul de cheie=%d a fost sters!\n",key);
    if(tata_p==0)
        return nod_inlocuire; /*s-a sters chiar radacina initiala */
    else
    {
        if (directie==1)
            tata_p->stg=nod_inlocuire;
        else tata_p->dr=nod_inlocuire;
        return rad;
    }
}

Tema: tabele de dispersie, probl 3.1 si 3.4

3.1 De la tastatură se citesc cuvinte ( şiruri de caractere ). Să se scrie un program care creează un arbore de căutare, care conţine în noduri cuvintele şi frecvenţa lor de apariţie. Să se afişeze apoi cuvintele în ordine lexicografică crescătoare şi frecvenţa lor de apariţie.

3.4 Se consideră două liste liniare simplu înlănţuite cu câmpurile de informaţie utilă conţinând numere întregi. Să se construiască o listă care conţine reuniunea celor două liste şi în care elementele sunt ordonate crescător. Se va folosi o structură intermediară de tip arbore de căutare. Elementele comune vor apare a o singură dată.

#include <stdio.h>
#include <stdlib.h>
typedef struct nodlista
{
int x;
struct nod *urm;
} nod;

typedef struct nodarbore
{
int x;
struct nod *st,*dr;
} nodarbore;

void inserare_lista(int x,nod **prim, nod **ultim)
{
nod *p;
p=(nod *)malloc(sizeof(nod));
p->x=x;
p->urm=NULL;

if (*prim)
{
(*ultim)->urm=p;
(*ultim)=p;
}
else
{
(*prim)=p;
(*ultim)=p;
}
}

void afisare(nod *prim)
{
for (prim=prim; prim!=NULL; prim=prim->urm)
printf("%d ",prim->x);
printf("\n");
}

void creare_arbore(nodarbore **rad,int x)
{
nodarbore *p,*q;
p=(nodarbore *)malloc(sizeof(nodarbore));
p->x=x;
p->st=NULL;
p->dr=NULL;
q=(*rad);

for (;;)
{
if (*rad)
{
if (x<q->x)
{
if (q->st==NULL)
{
q->st=p;
return;
}
else
q=q->st;
}
else if (x>q->x)
{
if (q->dr==NULL)
{
q->dr=p;
return;
}
else
q=q->dr;
}
else
return;
}
else
{
(*rad)=p;
return;
}
}
}

void arbore(nod *prim1,nod *prim2,nodarbore **rad)
{
nod *p;
for (p=prim1; p!=0; p=p->urm)
creare_arbore(rad,p->x);

for (p=prim2; p!=0; p=p->urm)
creare_arbore(rad,p->x);
}

nod* lista_noua(nodarbore *a,nod **prim, nod **ultim)
{
nod *p=NULL,*q;
if (a)
{
p=(nod *)malloc(sizeof(nod));
p->x=a->x;
p->urm=NULL;
q=lista_noua(a->st,prim,ultim);

inserare_lista(a->x,prim,ultim);

q=lista_noua(a->dr,prim,ultim);
}
return p;
}

void preordine(nodarbore *p, int nivel)
{
int i;
if (p!=0)
{
for(i=0; i<=nivel; i++)
printf(" ");
printf("%2d\n",p->x);
preordine(p->st,nivel+1);
preordine(p->dr,nivel+1);
}
}

int main()
{
int n,m,i,a;
nod *prim1=0,*ultim1=0,*prim2=0,*ultim2=0,*prim=0,*ultim=0;
FILE *f;

f=fopen("date.txt","r");
fscanf(f,"%d %d",&n,&m);
for (i=1; i<=n; i++)
{
fscanf(f,"%d",&a);
inserare_lista(a,&prim1,&ultim2);
}

for (i=1; i<=m; i++)
{
fscanf(f,"%d",&a);
inserare_lista(a,&prim2,&ultim2);
}

afisare(prim1);
afisare(prim2);
printf("\nNoua lista\n");

nodarbore *rad=NULL;
arbore(prim1,prim2,&rad);

//preordine(rad,0);
lista_noua(rad,&prim,&ultim);
afisare(prim);
return 0;

}

Fisier date.txt

4 5
1 5 3 7
2 6 3 9 7

Lucrările 4 şi 5 VHDL - Operatori. Tipuri de date (4), Atribute (5) (25 martie)

2014-03-31T08:01:00.002-07:00

Pachet valuta

package Myp is
type Valuta is range 0 to INTEGER'HIGH
units ban;
        RON=100 ban;
        USD=324 ban;
        EUR=440 ban;
        GBP=569 ban;
    end units;
end Myp;
-- Folosim package Myp pentru architecture
use Myp.all;

entity E is
    port(S: out Valuta);
end E;
--    architecture
architecture A of E is
signal X,Y,Z:Valuta;
begin
    X<=10 RON;
    Y<=10 USD;
    Z<=X+Y;
end A;

Registru de deplasare

entity Registru is
    port(CLK : in bit;
    SIN : in bit;
    Q: out bit_vector(3 downto 0));
end Registru;
-- Arhitectura registru de deplasare
architecture Deplasare of Registru is
begin
    process
    variable a:bit_vector(3 downto 0):= "0000";
    begin
       if (CLK='1' and CLK'EVENT) then
           a:=a sll 1;
           a(0):= SIN;
           Q<=a;
       end if;
       wait on CLK;
    end process;
end Deplasare;

Registru M3rin cu 2 clock-uri

entity Registru is
    port(SIN:in bit;
    CLKR:in bit;
    CLKL:in bit;
    Q: out bit_vector (3 downto 0));
end Registru;

architecture Gunners of Registru is
begin
    process
    variable a:bit_vector (3 downto 0):="0000";
    begin
       if (CLKL='1'and CLKL'EVENT) then
           a:=a srl 1;
           a(3):=SIN;
           Q<=a;
       end if;
       if (CLKR='1'and CLKR'EVENT) then
           a:=a sll 1;
           a(0):=SIN;
           Q<=a;
       end if;
       wait on CLKL,CLKR;
    end process;
end Gunners;

Registru stânga-dreapta în funcţie de un semnal j

entity Registru is
    port(CLK : in bit;
    SIN : in bit;
    j : in bit;
    Q: out bit_vector(3 downto 0));
end Registru;

architecture Deplasare of Registru is
begin
    process
    variable a:bit_vector(3 downto 0):= "0000";
    begin
       if (CLK='1' and (CLK'EVENT and j='1')) then
           a:=a srl 1;
           a(3):= SIN;
           Q<=a;
       end if;
       if (CLK='1' and (CLK'EVENT and j='0')) then
           a:=a sll 1;
           a(0):= SIN;
           Q<=a;
       end if;
       wait on CLK;
    end process;
end Deplasare;

Unitate aritmetico-logică

library ieee;
use ieee.std_logic_1164.all;
entity UAL is
    port(A,B:in bit_vector(3 downto 0);
    S:in bit_vector(2 downto 0);
    REZ:out bit_vector(3 downto 0));
end UAL;

library ieee;
use ieee.std_logic_1164.all;
architecture MUX of UAL is
begin
    process
    begin
       case S is
           --when "000" => REZ<=std_logic_vector(integer(A)+integer(B));
           --when "001" => REZ<=A-B;
           when "010" => REZ<=A and B;
           when "011" => REZ<=A or B;
           when "100" => REZ<=not A;
           when "101" => REZ<=A srl 1;
                          --REZ<=AA;
           when others => null;
       end case;
       wait on A,B;
    end process;
end MUX;

--library ieee;
--use ieee.std_logic_1164.all;
--entity MUX_8_1 is
--   port(
    --S:in bit_vector(2 downto 1);
    --I1:in bit_vector(3 downto 0);
    --I2:in bit_vector(3 downto 0);
    --I3:in bit_vector(3 downto 0);
--   I4:in bit_vector(3 downto 0);
    --I5:in bit_vector(3 downto 0);
    --I6:in bit_vector(3 downto 0);
    --REZ:out bit_vector(3 downto 0));
--end MUX_8_1;

Laborator 5 - Arbori (25 martie)

2014-03-25T02:36:00.000-07:00

Afisarea arborelui in modul DRS (rotit cu 90 de grade spre stanga, nivelul se numara de la stanga la dreapta)

void inordine2(nod *r, int nivel)
{
    if(r)
    {
        inordine2(r->dr,nivel+1);
        int i=0;
        for(i=0;i<nivel;i++)
            printf(" ");
        printf("%c",r->ch);
        inordine2(r->st,nivel+1);
    }
}

Construire, afisare, inaltime si nr de frunze

#include <stdio.h>
#include <stdlib.h>
typedef struct tip_nod
{
char ch;
struct tip_nod *st, *dr;
} nod;

void inordine_DRS(nod *r, int nivel)
{
if(r)
{
inordine_DRS(r->dr,nivel+1);
int i=0;
for(i=0; i<nivel; i++)
printf(" ");
printf("%c\n",r->ch);
inordine_DRS(r->st,nivel+1);
}
}

nod* construire()
{
nod *p;
int n;
char c;
n=sizeof(nod);
printf("Cititi: ");
fflush(stdin);
scanf("%c",&c);
if(c=='*')
return 0;
else
{
p=(nod *)malloc(n);
p->ch=c;
p->st=construire();
p->dr=construire();
}
return p;
}

int nr_frunze2(nod *p)
{
int nr=0;
if(p==NULL) return 0;
else if (p->st==NULL && p->dr==NULL)
return 1;
else nr=nr_frunze2(p->st)+nr_frunze2(p->dr);
return nr;
}

void inaltime3(nod *p, int *h)
{
if(p==0)
*h=0;
else
{
int h1=0;
inaltime3(p->st,&h1);
int h2=0;
inaltime3(p->dr,&h2);
if(h1>h2)
*h=h1+1;
else *h=h2+1;
}
}

int main()
{
nod *r;
r=construire();
inordine_DRS(r,0);
int hmax=0,nr=0;
nr=nr_frunze2(r);
inaltime3(r,&hmax);
printf("\nInaltime: %d\nNr frunze: %d",hmax,nr);
printf("\nApasati o tasta pentru terminare");
getch();
return 0;
}

Să se scrie o funcţie care determină înălţimea unui arbore binar.

void inaltime3(nod *p, int *h)
{
if(p==0)
*h=0;
else
{
int h1=0;
inaltime3(p->st,&h1);
int h2=0;
inaltime3(p->dr,&h2);
if(h1>h2)
*h=h1+1;
else *h=h2+1;
}
}

Să se scrie o funcţie care determină numărul de frunze ale unui arbore binar.

int nr_frunze2(nod *p)
{
int nr=0;
if(p==NULL) return 0;
else if (p->st==NULL && p->dr==NULL)
return 1;
else nr=nr_frunze2(p->st)+nr_frunze2(p->dr);
return nr;
}

Lucrarea 3 VHDL - Semnale. Parametri generici. Constante (18 martie)

2014-03-23T17:18:00.003-07:00

Memorie ROM (ieşirea pe un bit)

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;
entity rom is
    port (A:in std_logic_vector(3 downto 0);
    C:out std_logic);
end rom;

architecture Arch of rom is
signal Harta:std_logic_vector (15 downto 0):="0110100110101010";
begin
    C<=Harta(CONV_INTEGER(A));
end Arch;

Xilinx

NET "A(3)" LOC=T5;
NET "A(2)" LOC=V8;
NET "A(1)" LOC=U8;
NET "A(0)" LOC=N8;
NET "C" LOC=U16;

Memorie ROM (ieşirea pe doi biţi)

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;
entity rom is
    port (A:in std_logic_vector(3 downto 0);
    C:out std_logic_vector(1 downto 0));
end rom;

architecture Arch of rom is
type MM is array(15 downto 0) of std_logic_vector (1 downto 0);
signal Harta:MM:=("00","01","11","10","11","11","11","00","01","10","01","11","10","11","11","11");
begin
    C<=Harta(CONV_INTEGER(A));
end Arch;

Memorie RAM (ieşirea pe doi biţi)

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;

entity RAM is
    port (WE:in std_logic;
    A:in std_logic_vector (3 downto 0);
    DIN:in std_logic_vector (1 downto 0);
    C:out std_logic_vector (1 downto 0));
end RAM;

architecture Arch of RAM is
type MM is array (15 downto 0) of std_logic_vector(1 downto 0);
signal Harta:MM:=("00","01","10","11","00","01","10","11","00","01","10","11","00","01","10","11");
begin
    process
    begin
       if (WE='0') then
           C<=Harta(CONV_INTEGER(A));
       end if;
       if(WE='1') then
           Harta(CONV_INTEGER(A))<=DIN;
       end if;
    wait on WE,A,DIN;
    end process;
end Arch;

Laborator 4 - Liste circulare dublu inlantuite (18 martie)

2014-03-18T02:15:00.001-07:00

Din fisier se citesc, caracter cu caracter, n caractere; să se creeze o listă dublu înlănţuită, care să conţină în noduri caracterele distincte şi frecvenţa lor de apariţie. Lista va fi ordonată alfabetic. Se vor afişa caracterele şi frecvenţa lor de apariţie a) în ordine alfabetică crescătoare şi b) în ordine alfabetică descrescătoare.

#include <stdio.h>
#include <stdlib.h>
typedef struct nodtype
{
    char s[20];
    int a;
    struct nodtype *urm;
    struct nodtype *prec;
} nod;

void adaug(nod **prim,nod **ultim,char s[])
{
    nod *p;
    p=(nod *)malloc(sizeof(nod));
    strcpy(p->s,s);
    p->urm=NULL;
    p->prec=NULL;
    p->a=1;

    if (!(*prim))
    {
        (*prim)=p;
        (*ultim)=p;
        return 0;
    }
    else
    {
        if (!(*prim)->urm)
        {
            if (strcmp(p->s,(*prim)->s)<0)
            {
                p->urm=(*prim);
                (*ultim)=(*prim);
                (*prim)=p;
                (*ultim)->prec=p;
                return 0;
            }
            else
            {
                if (strcmp(p->s,(*prim)->s)>0)
                {
                    p->prec=(*prim);
                    (*prim)->urm=p;
                    (*ultim)=p;
                    return 0;
                }
                else
                {
                    (*prim)->a=(*prim)->a+1;
                    return 0;
                }
            }
        }
    }

    nod *q;
    q=(nod *)malloc(sizeof(nod));
    q=(*prim);

    if (strcmp(p->s,q->s)<0)
    {
        p->urm=(*prim);
        (*prim)->prec=p;
        (*prim)=p;
        return 0;
    }

    while (strcmp(p->s,(q->urm)->s)>0)
    {
        q=q->urm;
        if (!q->urm)
            break;
    }
    if (!q)
    {
        p->prec=(*ultim);
        (*ultim)->urm=p;
        (*ultim)=p;
        return 0;
    }
    if (q->urm && strcmp(p->s,(q->urm)->s)==0)
    {
        (q->urm)->a=(q->urm)->a+1;
        return 0;
    }

    if (strcmp(p->s,q->s)==0)
        q->a=q->a+1;
    else
    {
        if (q!=(*ultim))
        {
            p->urm=q->urm;
            p->prec=q;
            (q->urm)->prec=p;
            q->urm=p;
        }
        else
        {
            p->prec=(*ultim);
            (*ultim)->urm=p;
            (*ultim)=p;
        }
    }
}

void afisare(nod *prim)
{
    while (prim)
    {
        printf("%s - %d\n",prim->s,prim->a);
        prim=prim->urm;
    }
    printf("\n");
}

int main()
{
    char s[20];
    FILE *f;
    nod *prim,*ultim;
    prim=(nod *)malloc(sizeof(nod));
    ultim=(nod *)malloc(sizeof(nod));
    prim=NULL;
    ultim=NULL;

    f=fopen("in.txt","r");

    while (!feof(f))
    {
        fscanf(f,"%s",s);
        adaug(&prim,&ultim,s);
    }
    afisare(prim);
    printf("\nTastati o tasta pentru terminare");
    getch();
    return 0;
}

Fisier in.txt

sepcile
rosii
u
u
haide
haide
u
u
sepcile
u
u
u
rosii
stadion
noi
universitatea

Laborator 3 - Liste circulare simplu inlantuite (11 martie)

2014-03-11T02:27:00.004-07:00

De la tastatură se citeşte numărul n şi numele a n copii. Să se simuleze următorul joc: cei n copii stau într-un cerc. Începând cu un anumit copil, se numără copiii în sensul acelor de ceasornic. Fiecare al n-lea copil iese din cerc. Câştigă ultimul copil rămas în joc.

#include <stdio.h>
#include <stdlib.h>
typedef struct n
{
char nume[20];
struct n *urm;
} nod;
void adaugare(nod **prim, nod **ultim, char nume[])
{
nod*p;
p=(nod*)malloc(sizeof(nod));
strcpy(p->nume,nume);
if((*prim)==NULL)
{
*prim=p;
*ultim=p;
(*prim)->urm=p;
(*ultim)->urm=p;
}
else
{
p->urm=(*ultim)->urm;
(*ultim)->urm=p;
*ultim=p;
}
}
void afisare(nod *prim, nod *ultim)
{
nod *p;
p=prim;
do
{
printf("%s | ",p->nume);
p=p->urm;
}
while(p!=prim);
printf("\n\n");
}
void joc(nod **prim, nod **ultim, int n)
{
int i=1;
nod *q=*prim,*p;
while(*prim!=*ultim)
{
for(i=1;i<=n-1;i++)
{
q=q->urm;
}
p=q->urm;
// if(p!=*prim && p!=*ultim)
q->urm=p->urm;
if(p==*prim)
{
// (*ultim)->urm=p->urm;
*prim=p->urm;
}
if(p==*ultim)
{
*ultim=q;
// (*ultim)->urm=prim;
}
afisare(*prim,*ultim);
}
}
int main()
{
nod *prim=NULL, *ultim=NULL, *p;
int i,n;
printf("n=");
scanf("%d",&n);
char nume[20];
printf("Cititi cele %d nume\n",n);
for(i=1;i<=n;i++)
{
printf("%d. ",i);
scanf("%s",nume);
adaugare(&prim,&ultim,nume);
}
afisare(prim,ultim);
joc(&prim,&ultim,n);
printf("\nTastati o tasta pentru terminare");
getch();
return 0;
}

Varianta 2

typedef struct n
{
char nume[20];
struct n *urm;
} nod;
typedef struct
{nod *prim;
nod *ultim;
int lungime;
}lista;
void adaugare(lista *l);
void afisare(lista *l);
void joc(lista *l, int n);

----------------------------------

#include <stdio.h>
#include <stdlib.h>
typedef struct n
{
    char nume[20];
    struct n *urm;
} nod;

typedef struct l
{
    nod *prim;
    nod *ultim;
    int lungime;
} lista;

void adaugare(lista *l,char nume[])
{
    nod*p;
    p=(nod*)malloc(sizeof(nod));
    strcpy(p->nume,nume);
    if((*prim)==NULL)
    {
        *prim=p;
        *ultim=p;
        (*prim)->urm=p;
        (*ultim)->urm=p;
    }
    else
    {
        p->urm=(*ultim)->urm;
        (*ultim)->urm=p;
        *ultim=p;
    }
}

void afisare(lista *l)
{
    nod *p;
    p=prim;
    do
    {
        printf("%s | ",p->nume);
        p=p->urm;
    }
    while(p!=prim);
    printf("\n\n");
}

void joc(lista *l, int n)
{
    int i=1;
    nod *q=*prim,*p;
    while(*prim!=*ultim)
    {
        for(i=1; i<=n-1; i++)
        {
            q=q->urm;
        }
        p=q->urm;
        //   if(p!=*prim && p!=*ultim)
        q->urm=p->urm;
        if(p==*prim)
        {
            // (*ultim)->urm=p->urm;
            *prim=p->urm;
        }
        if(p==*ultim)
        {
            *ultim=q;
            // (*ultim)->urm=prim;
        }
        afisare(*prim,*ultim);
    }
}

int main()
{
    nod *prim=NULL, *ultim=NULL, *p;
    int i,n;
    lista *l;
    printf("n=");
    scanf("%d",&n);
    char nume[20];
    printf("Cititi cele %d nume\n",n);
    for(i=1; i<=n; i++)
    {
        printf("%d. ",i);
        scanf("%s",nume);
        adaugare(&l,nume);
    }
    afisare(l);
    joc(&l,n);
    printf("\nTastati o tasta pentru terminare");
    getch();
    return 0;
}

TEMA
Să se conceapă o stuctură dinamică eficientă pentru reprezentarea matricelor rare. Să se scrie operaţii de calcul a sumei a două matrice rare. Afisarea se va face in forma naturală.

#include <stdio.h>
#include <stdlib.h>
typedef struct nod
{
int i,j,val;
struct nod *urm;
}nod;

typedef struct
{
int nrl;
int nrc;
nod *prim;
nod *ultim;
int nrelem;
}matrice;

void citire(nod **p)
{
(*p)=NULL;
nod *x;
int i,n;
int linie,coloana,valoare;
printf("Nr. de valori diferite de 0: ");
scanf("%d",&n);
printf("Cititi linie, coloana, valoare:\n");
for(i=1;i<=n;i++)
{
scanf("%d",&linie);
scanf("%d",&coloana);
scanf("%d",&valoare);
x=(nod*)malloc(sizeof(nod));
x->i=linie;;
x->j=coloana;
x->val=valoare;
x->urm=(*p);
(*p)=x;
}
}

void maxim(nod *a, nod *b, int *imax, int *jmax)
{
*imax=*jmax=0;
int i;
while(a)
{
if(a->i > *imax)
*imax=a->i;
if(a->j > *jmax)
*jmax=a->j;
a=a->urm;
}
while(b)
{
if(b->i > *imax)
*imax=b->i;
if(b->j > *jmax)
*jmax=b->j;
b=b->urm;
}
}

void afisare(nod*p)
{
printf("\n");
if(p==NULL)
{
printf("Lista goala");
exit(1);
}

while(p!=0)
{
printf("%d ",p->i);
printf("%d ",p->j);
printf("%d\n",p->val);
p=p->urm;
}
printf("\n");
}

nod* cautare(nod *s,int i,int j)
{
while(s)
{
if(s->i==i && s->j==j)
return s;
else s=s->urm;
}
return 0;
}

void suma(nod *a, nod *b, nod **s)
{
nod *x;
*s=NULL;
while(a)
{
if(cautare(b,a->i,a->j))
{ x=(nod*)malloc(sizeof(nod));
x->i=a->i;
x->j=a->i;
x->val=a->val+b->val;
x->urm=(*s);
(*s)=x;
}
else
{
x=(nod*)malloc(sizeof(nod));
x->i=a->i;
x->j=a->i;
x->val=a->val;
x->urm=(*s);
(*s)=x;
}
a=a->urm;
}

while(b)
{
if(cautare(a,b->i,b->j)==0 && cautare(*s,b->i,b->j)==0)
{
x=(nod*)malloc(sizeof(nod));
x->i=b->i;
x->j=b->i;
x->val=b->val;
x->urm=(*s);
(*s)=x;
}
b=b->urm;
}

}

void afisare_matrice(nod *s,int imax, int jmax)
{
int i,j;
nod *p;
for(i=1;i<=imax;i++)
{
for(j=1;j<=jmax;j++)
{
p=cautare(s,i,j);
if(p)
printf("%d ",p->val);
else printf("%d ",0);
}
printf("\n");
}
}

int main()
{
int n;
int imax,jmax;
int i,j;
nod *a,*b,*s,*p;
printf("Prima matrice\n");
citire(&a);
printf("A doua matrice\n");
citire(&b);
suma(a,b,&s);
printf("Lista a\n");
afisare(a);
printf("Lista b\n");
afisare(b);
printf("Lista suma\n");
afisare(s);
maxim(a,b,&imax,&jmax);
printf("Nr de linii: %d\nNr de coloane: %d\n\n",imax,jmax);
afisare_matrice(s,imax,jmax);

printf("\n\nTastati o tasta pentru terminarea programului");
getch();
return 0;
}

Varianta 2 (cam nefunctional)

#include <stdio.h>
#include <stdlib.h>
typedef struct nod
{
int i,j,val;
struct nod *urm;
}nod;

typedef struct
{
int nrl;
int nrc;
nod *prim;
nod *ultim;
int nrelem;
}matrice;

void adaug(matrice *m,int l,int c,int v)
{
nod *p;
p=(nod *)malloc(sizeof(nod));
p->i=l;
p->j=c;
p->val=v;
if(m->prim==0)
{
m->prim=m->ultim=p;
}
else
{
m->ultim->urm=p;
m->ultim=p;
}
p->urm=0;
}

int val(matrice *m,int i, int j)
{
while(m->prim)
{
if(m->prim->i==i && m->prim->j==j)
return m->prim->val;
else m->prim=m->prim->urm;
}
return 0;
}

void adun(matrice *d,matrice *m1, matrice *m2)
{
int i,j,suma;
for(i=1;i<=m1->nrl;i++)
{
for(j=1;j<=m1->nrc;j++)
{
suma=val(m1,i,j)+val(m2,i,j);
if(suma!=0)
adaug(d,i,j,suma);
}
//printf("\n");
}
}

void afisare_matrice(matrice *d)
{
int i,j,suma;
for(i=1;i<=d->nrl;i++)
{
for(j=1;j<=d->nrc;j++)
printf(" %d",val(d,i,j));
printf("\n");
}
}

int main()
{
matrice m1,m2,m3;
int n,i,v,l,c;
m1.prim=m1.ultim=m2.prim=m2.ultim=NULL;
printf("Matricea 1\nNr. linii:");
scanf("%d",&m1.nrl);
printf("Nr. coloane: ");
scanf("%d",&m1.nrc);
printf("Nr. de elemente diferite de 0: ");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
printf("Linia: ");
scanf("%d",&l);
printf("Coloana: ");
scanf("%d",&c);
printf("Valoare: ");
scanf("%d",&v);
adaug(&m1,l,c,v);
}
printf("\nMatricea 2\nNr. linii:");
scanf("%d",&m2.nrl);
printf("Nr. coloane: ");
scanf("%d",&m2.nrc);
printf("Nr. de elemente diferite de 0: ");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
printf("Linia: ");
scanf("%d",&l);
printf("Coloana: ");
scanf("%d",&c);
printf("Valoare: ");
scanf("%d",&v);
adaug(&m2,l,c,v);
}
printf("DDDDDD");
adun(&m3,&m2,&m1);
printf("DDDDDD");
printf("%d %d\n",m3->nrl,m3->nrc);
getch();
afisare_matrice(&m3);

printf("\n\nTastati o tasta pentru terminarea programului");
getch();
return 0;
}