Show page

Differences

This shows you the differences between two versions of the page.

--- poo:laboratoare:03 [2018/07/03 16:04]
mihai.nan [Problema 6]
+++ poo:laboratoare:03 [2020/10/20 11:33] (current)
carmen.odubasteanu [Problema 1]
@@ Line 2: / Line 2: @@
 ====Problema 1====
-Definiti o clasa **//Fractie//** care modeleaza lucrul cu fractiile. Membrii acestei clase sunt:
+Definiți o clasă **//Fractie//** care modelează lucrul cu fracțiile. Membrii acestei clase sunt:
-  * doua atribuite de tip **//double//** pentru numaratorul fractiei, respectiv numitorul ei;
+  * două atribuite de tip **//int//** pentru numărătorul fracției, respectiv numitorul ei;
-  * constructorul cu doi parametri de tip //**double**//, pentru setarea celor doua parti ale fractiei (numarator si numitor);
+  * constructorul cu doi parametri de tip //**int**//, pentru setarea celor două parți ale fracției (numărător și numitor);
-  * un constructor fără parametri care apeleaza constructorul anterior;
+  * un constructor fără parametri care apelează constructorul anterior;
-  * o metoda, cu un **singur** parametru, de calcul a sumei a doua fractii;
+  * o metodă, cu un **singur** parametru, de calcul a sumei a două fracții;
-  * o metoda **//toString//** uzitata pentru afisarea pe ecran a valorii fractiei;
+  * o metodă **//toString//** uzitată pentru afișarea pe ecran a valorii fracției;
-  * o metoda **//equals//**, cu un parametru de tip **//Object//**, care va returna **//true//** daca fractiile sunt egale, respectiv **//false//** in sens contrar;
+  * o metodă **//equals//**, cu un parametru de tip **//Object//**, care va returna **//true//** dacă fracțiile sunt egale, respectiv **//false//** în sens contrar;
-  * o metoda **//main//** pentru testarea functionalitatii clasei.
+  * o metodă **//main//** pentru testarea funcționalității clasei.
-<note important>Consultati exemplul prezentat la curs pentru numere complexe!</note>
+<note important>Consultați exemplul prezentat la curs pentru numere complexe!</note>
@@ Line 17: / Line 17: @@
 ====Problema 2====
-Un produs este caracterizat prin nume (**//String//**), pret (//**double**//) si cantitate (**//int//**). Un magazin are un nume (//**String**//) si contine 3 produse. Creati clasele **//Produs//** si //**Magazin**// corespunzatoare specificatiilor de mai sus. In fiecare clasa, implementati constructorul potrivit, astfel incat caracteristicile instantelor sa fie setate la crearea acestora.
+Un produs este caracterizat prin nume (**//String//**), preț (//**double**//) și cantitate (**//int//**).
-\par
+Un magazin are un nume (//**String**//) și conține 3 produse.
-Clasa //**Produs**// contine o metoda //**toString**//, care va returna un //**String**// sub forma **"Produs nume_produs pret_produs cantitate"** si o metoda **//getTotalProdus//** care va returna un **//double//**, produsul dintre cantitate si pret. Clasa //**Magazin**// contine o metoda //**toString**// care afiseaza toate componentele magazinului (va apela metoda //**toString**// pentru fiecare produs) si o metoda //**getTotalMagazin**// care va calcula suma totalurilor produselor si o va returna. Creati, intr-o metoda //**main**//, un obiect de tip //**Magazin**//, uzitand obiecte anonime in cadrul instantierii.
+Creați clasele **//Produs//** și //**Magazin**// corespunzătoare specificațiilor de mai sus. În fiecare clasă, implementați constructorul potrivit, astfel încât caracteristicile instanțelor să fie setate la crearea acestora.
+Clasa //**Produs**// conține o metodă //**toString**//, care va returna un //**String**// sub forma **"Produs <nume_produs> <preț_produs> <cantitate>"** și o metodă **//getTotalProdus//** care va returna un **//double//**, produsul dintre cantitate și preț. Clasa //**Magazin**// conține o metodă //**toString**// care va returna String-ul corespondent tuturor componentelor magazinului și o metodă //**getTotalMagazin**// care va calcula suma totalurilor produselor și o va returna.
+Creați, într-o metodă //**main**//, un obiect de tip //**Magazin**//, uzitând obiecte anonime în cadrul instanțierii.
 <note tip>
@@ Line 28: / Line 30: @@
 ====Problema 3====
-Sa se defineasca o clasa **//MyQueue//** care sa descrie o structura de date de tip coada.
+Să se definească o clasă **//MyQueue//** care să descrie o structură de date de tip coadă.
 Datele clasei (private):
-  * un obiect de tip **//MyArray//** (clasa inclusa in arhiva laboratorului);
+  * un obiect de tip **//MyArray//** (clasa inclusă în arhiva laboratorului);
-  * o constanta (//**Infinit**//) avand valoarea 9500;
+  * o constantă (//**Infinit**//) având valoarea $9500$;
-  * indicele primului element din coada;
+  * indicele primului element din coadă;
-  * indicele ultimului element din coada;
+  * indicele ultimului element din coadă;
-  * numarul de elemente din coada.
+  * numărul de elemente din coada.
 Constructorul clasei:
-  * constructor fara parametri care se ocupa de initializarile membrilor.
+  * constructor fără parametri care se ocupă de inițializările membrilor.
 Metodele clasei:
-  * **//int getSize()//** = are ca rezultat numarul de elemente din coada;
+  * **//int getSize()//** = are ca rezultat numărul de elemente din coadă;
-  * **//void enqueue(int value)//** = adauga o valoare in coada;
+  * **//void enqueue(int value)//** = adaugă o valoare în coadă;
-  * **//int dequeue()//** = intoarce primul element din coada si il elimina, incrementand indicele corespunzator, fara a elimina efectiv elementul din obiectul de tip **//MyArray//** (//**Infinit**// - coada vida);
+  * **//int dequeue()//** = întoarce primul element din coadă și îl elimină, incrementând indicele corespunzător, fără a elimina efectiv elementul din obiectul de tip **//MyArray//** (//**Infinit**// - coada vidă);
-  * **//boolean isEmpty()//** = verifica daca este vida coada;
+  * **//boolean isEmpty()//** = verifică dacă este vidă coada;
-  * **//String toString()//** = afisarea elementelor din structura de date.
+  * **//String toString()//** = String cu elementele din structura de date.
-Pentru verificare, se va folosi clasa **//TestBonus//** din arhiva laboratorului.
+Pentru verificare, se va folosi clasa de mai jos.
+<code java>
+class MyArray {
+    private int v[];
+    private int size;
+    public MyArray() {
+        this(100);
+    }
+    public MyArray(int length) {
+        size = 0;
+        v = new int[length];
+    }
+    public int get(int poz) {
+        if(poz < size) {
+            return v[poz];
+        } else {
+            return -1;
+        }
+    }
+    public void set(int pos, int value) {
+        v[pos] = value;
+        size++;
+    }
+    public int getSize() {
+        return size;
+    }
+}
+class Test {
+    public static void main(String args[]) {
+        MyQueue queue = new MyQueue();
+        queue.enqueue(7);
+        queue.enqueue(8);
+        queue.enqueue(10);
+        queue.enqueue(-1);
+        queue.enqueue(2);
+        System.out.println(queue);
+        System.out.println(queue.dequeue());
+        System.out.println(queue.getSize());
+        System.out.println(queue);
+        queue.enqueue(9);
+        queue.enqueue(queue.dequeue());
+        queue.enqueue(11);
+        queue.enqueue(22);
+        System.out.println(queue);
+        while(!queue.isEmpty()) {
+            System.out.print(queue.dequeue() + " ");
+        }
+        System.out.println("");
+        System.out.println(queue);
+    }
+}
+</code>
 ====Problema 4====
-Definiti o clasa **//Numar//** care are ca membru un numar intreg si contine metodele descrise mai jos. Implementati metodele astfel incat fiecare metoda sa efectueze o singura adunare.
+Definiți o clasă **//Numar//** care are ca membru un număr întreg și conține metodele descrise mai jos. Implementați metodele astfel încât fiecare metodă să efectueze o singură adunare.
-Instantiati un obiect de tip **//Numar//** in metoda //**main**// si apelati metodele implementate.
+Instanțiați un obiect de tip **//Numar//** în metoda //**main**// și apelați metodele implementate.
-Ce principiu POO este evidentiat in acest exercitiu?
+Ce principiu POO este evidențiat în acest exercițiu?
 <note important><code java>
 //returneaza suma dintre nr (membrul clasei) si a
@@ Line 65: / Line 126: @@
 ====Problema 5====
-Sa se implementeze ierarhia de clase descrisa prin urmatoarea diagrama:
+Implementați clasa **//Punct//** care definește un punct din spațiul 2D.
-{{:poo:laboratoare:clase1.png|}}
-Clasa **//Schedule//** contine o metoda care calculeaza durata calatoriei in minute. Stiind algoritmul de calcul al pretului unui bilet de calatorie, sa se implementeze o metoda, in clasa **//Train//**, care calculeaza pretul unui bilet. Valoarea unui bilet este egala cu **//X * durata_calatoriei//**, unde $X$ este egal cu $1$ pentru cursele interne si $2$ pentru cursele internationale. Clasa **//Route//** va contine un constructor cu 2 parametri si o metoda care primeste ca parametru un obiect de tip **//Route//** si verifica daca sunt de tip tur - retur cele doua rute, rezultatul fiind de tip **//boolean//**. Clasa **//ClockTime//** contine o metoda, cu un parametru de tip **//ClockTime//**, si compara doua momente de timp, rezultatul fiind un //**int**//.
-Adaugati o metoda //**main**// pentru testarea claselor implementate, utilizand exemplele oferite. Definiti un constructor potrivit pentru instantierea unui obiect de tip //**Train**//, in care sa apelati constructorii definiti in clasele //**Route**//, //**Schedule**// si //**ClockTime**//.
-<code>
-[local] [origin (departure)] -> [destination (arrival)]
-true Bucuresti Nord (9:35) -> Constanta (12:02)
-true Bucuresti Nord (5:45) -> Iasi (12:49)
-false Bucuresti Nord (23:45) -> Sofia (17:00)
-</code>
-====Problema 6====
-Implementati clasa **//Punct//** care defineste un punct din spatiul 2D.
 **Datele clasei (private):**
-  * doua nr. intregi reprezentand cele doua coordonate ale punctului.
+  * două nr. întregi reprezentând cele două coordonate ale punctului.
 **Conctructorul clasei:**
-  * un constructor fara parametri care instantiaza punctul ''O(0, 0)''.
+  * un constructor fără parametri care instanțiază punctul ''O(0, 0)''.
 **Metodele clasei:**
-  * ''int getX()'' = intoarce abscisa punctului;
+  * ''int getX()'' = întoarce abscisa punctului;
   * ''void setX(int x)'' = seteaza abscisa punctului;
-  * ''int getY()'' = intoarce ordonata punctului;
+  * ''int getY()'' = întoarce ordonata punctului;
-  * ''void setY(int y)'' = seteaza ordonata punctului;
+  * ''void setY(int y)'' = setează ordonata punctului;
-  * ''String toString()'' = returneaza un String de forma \textit{(x, y)};
+  * ''String toString()'' = returnează un String de forma ''(x, y)'';
-  * ''double distance(int, int)'' = calculeaza distanta dintre 2 puncte;
+  * ''double distance(int, int)'' = calculează distanța dintre 2 puncte;
-  * ''double distance(Punct p1)'' = calculeaza distanta dintre 2 puncte.
+  * ''double distance(Punct p1)'' = calculează distanța dintre 2 puncte.
-Creati o clasa **//Test//**, in acelasi pachet cu clasa **//Punct//**, care contine o metoda **//main//** care calculeaza distanta dintre punctele ''A(1, 2)'' si ''B(-1, 3)''.
+Creați o clasă **//Test//**, în același pachet cu clasa **//Punct//**, care conține o metodă **//main//** care calculează distanța dintre punctele ''A(1, 2)'' si ''B(-1, 3)''.
-Puteti accesa datele clasei //**Punct**// in metoda //**main**// din clasa //**Test**//?
+Puteți accesa datele clasei //**Punct**// în metoda //**main**// din clasa //**Test**//?
-====Problema 7====
+====Problema 6====
+Să se definească o clasă **//Graph//** care să descrie un graf ponderat orientat care are nodurile numerotate de la $1$.
-Sa se defineasca o clasa **//Graph//** care sa descrie un graf ponderat orientat care are nodurile numerotate de la 0.
 **Datele clasei (private):**
-  * o matrice cu componente de tip int (matricea costurilor);
+  * o matrice cu componente de tip int (matricea costurilor) - matrice;
-  * o constanta (**//Infinit//**) avand valoarea 9500;
+  * o constantă (**//Infinit//**) având valoarea 9500;
-  * numarul de noduri.
+  * numărul de noduri - n .
 **Constructorul clasei:**
-  * constructor cu un parametru intreg (numarul de noduri din graf)
+  * constructor cu un parametru întreg (numărul de noduri din graf)
 **Metodele clasei:**
-  * ''int getSize()'' = are ca rezultat numarul de noduri din graf;
+  * ''int getSize()'' = are ca rezultat numărul de noduri din graf;
-  * ''void addArc(int v, int w, int cost)'' = adauga un arc la graf (intre v si w, avand costul cost);
+  * ''void addArc(int v, int w, int cost)'' = adaugă un arc la graf (între $v$ și $w$, având costul $cost$);
-  * ''boolean isArc(int v, int w)'' = verifica daca exista arc intre v si w in graf;
+  * ''boolean isArc(int v, int w)'' = verifică dacă există arc între $v$ și $w$ în graf;
-  * ''toString()'' = afisarea grafului (se va alege o varianta intuitiva de afisare a grafului);
+  * ''toString()'' = afișarea grafului (se va alege o variantă intuitivă de afișare a grafului);
-  * ''int[][] floydWarshall()'' = implementarea algoritmului \textit{Floyd - Warshall} pentru determinarea drumurilor de cost minim in graf;
+  * ''int[][] floydWarshall()'' = implementarea algoritmului \textit{Floyd - Warshall} pentru determinarea drumurilor de cost minim în graf;
-  * ''void main(String[])'' = metoda main pentru testarea functionalitatii clasei implementate.
+  * ''void main(String[])'' = metoda main pentru testarea functionalității clasei implementate.
-Pentru verificare, se va crea graful din figura de mai jos. Se va afisa graful, uzitand metoda **//toString//** implementata, si se va determina distanta minima dintre doua noduri folosind algoritmul **Floyd - Warshall**.
+Pentru verificare, se va crea graful din figura de mai jos. Se va afișa graful, uzitând metoda **//toString//** implementată, și se va determina distanța minimă dintre două noduri folosind algoritmul **Floyd - Warshall**.
+Folosiți scheletul de mai jos:
+{{ :poo:laboratoare:graf.png |}}
 <code java>
-public int[][] floydWarshall() {
+class Graph {
-	int result[][];
+    //....
-	result = new int[this.nrVarfuri][this.nrVarfuri];
-	int k, i, j;
+    public int[][] floydWarshall() {
-	for(i = 1; i <= this.nrVarfuri; i++) {
+		int result[][];
-		for(j = 1; j <= this.nrVarfuri; j++) {
+		result = new int[n+1][n+1];
-			if(i == j) {
+		int k, i, j;
-				result[i][j] = 0;
+		for(i = 1; i <= n; i++) {
-			} else if(this.isArc(i, j)) {
+			for(j = 1; j <= n; j++) {
-				result[i][j] = this.matrice[i][j];
+				if(i == j) {
-			} else {
+					result[i][j] = 0;
-				result[i][j] = Infinit;
+				} else if(isArc(i, j)) {
+					result[i][j] = matrice[i][j];
+				} else {
+					result[i][j] = Infinit;
+				}
 			}
 		}
-	}
+		for(k = 1; k <= n; k++) {
-	for(k = 1; k <= this.nrVarfuri; k++) {
+			for(i = 1; i <= n; i++) {
-		for(i = 1; i <= this.nrVarfuri; i++) {
+				for(j = 1; j <= n; j++) {
-			for(j = 1; j <= this.nrVarfuri; j++) {
+					int dist;
-				int dist;
+					dist = result[i][k] + result[k][j];
-				dist = result[i][k] + result[k][j];
+					if(result[i][j] > dist) {
-				if(result[i][j] > dist) {
+						result[i][j] = dist;
-					result[i][j] = dist;
+					}
 				}
 			}
 		}
+		return result;
+	}
+	public static void main(String args[]) {
+		Graph g = new Graph(4);
+		g.addArc(1, 3, 2);
+		g.addArc(1, 2, 3);
+		g.addArc(2, 4, 6);
+		g.addArc(2, 3, 2);
+		System.out.println(g);
+		System.out.println("Floyd-Warshall");
+		int [][] my_matrix = g.floydWarshall();
+		System.out.println("distanta minima dintre nodurile 1 si 4 este "+ my_matrix[1][4]); // rezultat - 9
 	}
-	return result;
 }
+</code>
+====Problema 7====
+Să se implementeze ierarhia de clase descrisă prin următoarea diagramă:
+{{:poo:laboratoare:clase1.png|}}
+Clasa **//Schedule//** conține o metodă care calculează durata călătoriei în minute. Știind algoritmul de calcul al prețului unui bilet de călătorie, să se implementeze o metodă, în clasa **//Train//**, care calculează prețul unui bilet. Valoarea unui bilet este egală cu **//X * durata_călătoriei//**, unde $X$ este egal cu $1$ pentru cursele interne și $2$ pentru cursele internaționale. Clasa **//Route//** va conține un constructor cu $2$ parametri și o metodă care primește ca parametru un obiect de tip **//Route//** și verifică dacă sunt de tip tur - retur cele două rute, rezultatul fiind de tip **//boolean//**. Clasa **//ClockTime//** conține o metodă, cu un parametru de tip **//ClockTime//**, și compară două momente de timp, rezultatul fiind un //**int**//.
+Adaugați o metodă //**main**// pentru testarea claselor implementate, utilizând exemplele oferite. Definiți un constructor potrivit pentru instanțierea unui obiect de tip //**Train**//, în care să apelați constructorii definiți în clasele //**Route**//, //**Schedule**// și //**ClockTime**//.
+<code>
+[local] [origin (departure)] -> [destination (arrival)]
+true Bucuresti Nord (9:35) -> Constanta (12:02)
+true Bucuresti Nord (5:45) -> Iasi (12:49)
+false Bucuresti Nord (23:45) -> Sofia (17:00)
 </code>

Cursuri

Laboratoare

Breviare

poo/laboratoare/03.1530623046.txt.gz · Last modified: 2018/07/03 16:04 by mihai.nan

Show page Old revisions

Media Manager Back to top