Differences

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

Link to this comparison view

poo:laboratoare:03 [2018/07/03 16:04]
mihai.nan [Problema 6]
poo:laboratoare:03 [2018/10/09 18:33] (current)
mihai.nan [Problema 7]
Line 2: Line 2:
  
 ====Problema 1==== ====Problema 1====
-Definiti ​clasa **//​Fractie//​** care modeleaza ​lucrul cu fractiile. Membrii acestei clase sunt: +Definiți ​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 **//​double//​** 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 //​**double**//,​ 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==== ====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 ​clasaimplementati ​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 ​metoda ​//​**toString**//,​ care va returna un //​**String**//​ sub forma **"​Produs nume_produs ​pret_produs ​cantitate"​** ​si metoda ​**//​getTotalProdus//​** care va returna un **//​double//​**,​ produsul dintre cantitate ​si pret. Clasa //​**Magazin**// ​contine ​metoda ​//​**toString**//​ care afiseaza toate componentele ​magazinului ​(va apela metoda //​**toString**//​ pentru fiecare produs) si metoda ​//​**getTotalMagazin**//​ care va calcula suma totalurilor produselor ​si o va returna. ​Creatiintr-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 ​metodă ​//​**toString**//,​ care va returna un //​**String**//​ sub forma **"​Produs ​<nume_produs> <​preț_produs>​ <cantitate>"​** ​și metodă ​**//​getTotalProdus//​** care va returna un **//​double//​**,​ produsul dintre cantitate ​și preț. Clasa //​**Magazin**// ​conține ​metodă ​//​**toString**//​ care va returna String-ul corespondent tuturor componentelor ​magazinului ​și 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> <note tip>
Line 28: Line 30:
  
 ====Problema 3==== ====Problema 3====
-Sa se defineasca ​clasa **//​MyQueue//​** care sa descrie o structura ​de date de tip coada.+Să se definească ​clasă ​**//​MyQueue//​** care să descrie o structură ​de date de tip coadă.
 Datele clasei (private): 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: 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: 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 eliminaincrementand ​indicele ​corespunzatorfara 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ătorfă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==== ====Problema 4====
-Definiti ​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 ​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> <note important><​code java>
 //​returneaza suma dintre nr (membrul clasei) si a //​returneaza suma dintre nr (membrul clasei) si a
Line 65: Line 126:
  
 ====Problema 5==== ====Problema 5====
-Sa se implementeze ierarhia de clase descrisa ​prin urmatoarea diagrama+Să se implementeze ierarhia de clase descrisă ​prin următoarea diagramă
  
 {{:​poo:​laboratoare:​clase1.png|}} {{:​poo:​laboratoare:​clase1.png|}}
  
-Clasa **//​Schedule//​** ​contine ​metoda ​care calculeaza ​durata ​calatoriei in minute. ​Stiind ​algoritmul de calcul al pretului ​unui bilet de calatoriesa se implementeze o metodain 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 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 ​metoda, cu un parametru de tip **//​ClockTime//​**, ​si compara doua momente de timp, rezultatul fiind un //​**int**//​.+Clasa **//​Schedule//​** ​conține ​metodă ​care calculează ​durata ​călătoriei în minute. ​Știind ​algoritmul de calcul al prețului ​unui bilet de călătoriesă 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 $2parametri ​și 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 ​metodă, cu un parametru de tip **//​ClockTime//​**, ​și compară două momente de timp, rezultatul fiind un //​**int**//​.
  
-Adaugati ​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**//​.+Adaugați ​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>​ <​code>​
Line 81: Line 142:
  
 ====Problema 6==== ====Problema 6====
-Implementati ​clasa **//​Punct//​** care defineste ​un punct din spatiul ​2D.+Implementați ​clasa **//​Punct//​** care definește ​un punct din spațiul ​2D.
  
 **Datele clasei (private):​** **Datele clasei (private):​**
-  * doua nr. intregi reprezentand ​cele doua coordonate ale punctului.+  * două nr. întregi reprezentând ​cele două coordonate ale punctului.
  
 **Conctructorul clasei:** **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:** **Metodele clasei:**
-  * ''​int getX()''​ = intoarce ​abscisa punctului;+  * ''​int getX()''​ = întoarce ​abscisa punctului;
   * ''​void setX(int x)''​ = seteaza 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 \textit{(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 ​clasa **//​Test//​**, ​in acelasi ​pachet cu clasa **//​Punct//​**,​ care contine ​metoda ​**//​main//​** care calculeaza distanta ​dintre punctele ''​A(1,​ 2)''​ si ''​B(-1,​ 3)''​.+Creați ​clasă ​**//​Test//​**, ​în același ​pachet cu clasa **//​Punct//​**,​ care conține ​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 7====
  
-Sa se defineasca ​clasa **//​Graph//​** care sa descrie un graf ponderat orientat care are nodurile numerotate de la 0.+Să se definească ​clasă ​**//​Graph//​** care să descrie un graf ponderat orientat care are nodurile numerotate de la $1$.
  
 **Datele clasei (private):​** **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:** **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:** **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 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 si 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//​** ​implementatasi 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> <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>​ </​code>​
poo/laboratoare/03.1530623046.txt.gz · Last modified: 2018/07/03 16:04 by mihai.nan
CC Attribution-Share Alike 3.0 Unported
www.chimeric.de Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0