Differences
This shows you the differences between two versions of the page.
|
poo:laboratoare:01 [2025/10/05 19:09] george.tudor1906 [Problema 3] |
poo:laboratoare:01 [2025/10/05 22:04] (current) carmen.odubasteanu [Problema 8] |
||
|---|---|---|---|
| Line 10: | Line 10: | ||
| Creați un proiect Java nou, apoi creați un fișier sursă simplu numit **Prob1.java**. | Creați un proiect Java nou, apoi creați un fișier sursă simplu numit **Prob1.java**. | ||
| - | **1.** În acest fișier scrieți o clasă numită **Test** care conține metoda **//main//** și afișează în consolă mesajul "//Test Java//". Rulați programul și verificați apariția mesajului în fereastra Run | + | **1.** În acest fișier scrieți o clasă numită **Test** care conține metoda ''main'' și afișează în consolă mesajul "//Test Java//". Rulați programul și verificați apariția mesajului în fereastra Run. |
| <code java> | <code java> | ||
| Line 20: | Line 20: | ||
| </code> | </code> | ||
| - | **2.** Adăugați modificatorul **//public//** în fața declarației clasei Test și încercați din nou să rulați. Observați eroarea raportată de IDE și apoi rezolvați-o făcând ca numele fișierului și numele clasei publice să coincidă. Puteți alege fie să redenumiți fișierul în Test.java, fie să redenumiți clasa în Prob1. Recompilați și rulați din nou pentru a confirma că problema este rezolvată și că mesajul este afișat corect. | + | **2.** Adăugați modificatorul ''public'' în fața declarației clasei Test și încercați din nou să rulați. Observați eroarea raportată de IDE și apoi rezolvați-o făcând ca numele fișierului și numele clasei publice să coincidă. Puteți alege fie să redenumiți fișierul în Test.java, fie să redenumiți clasa în Prob1. Recompilați și rulați din nou pentru a confirma că problema este rezolvată și că mesajul este afișat corect. |
| Line 31: | Line 31: | ||
| ====Problema 2==== | ====Problema 2==== | ||
| - | Scrieți un program în fișierul **Prob2.java** care definește o clasă **Prob2** și o //**__metodă nestatică__**// numită //printInt//, ce primește un număr întreg și îl afișează la consolă. În metoda //main//, creați **un obiect** al clasei Prob2 (adică **o instanță** a clasei) și apelați metoda nestatică //printInt// de mai multe ori, folosind valori constante (de pildă 42, 7 + 5, 3 * 10). | + | Scrieți un program în fișierul **Prob2.java** care definește o clasă **Prob2** și o //**__metodă nestatică__**// numită ''printInt'', ce primește un număr întreg și îl afișează la consolă. În metoda ''main'', creați **un obiect** al clasei Prob2 (adică **o instanță** a clasei) și apelați metoda nestatică ''printInt'' de mai multe ori, folosind valori constante (de pildă 42, 7 + 5, 3 * 10). |
| <note warning> | <note warning> | ||
| Line 52: | Line 52: | ||
| ====Problema 3==== | ====Problema 3==== | ||
| Creați un fișier numit **Prob3.java** în care scrieți două clase: | Creați un fișier numit **Prob3.java** în care scrieți două clase: | ||
| - | * //public class Prob3//, care conține metoda //main// | + | * ''public class Prob3'', care conține metoda ''main'' |
| - | * //class Printer//, în care definiți o __//**metodă nestatică**//__ printInt(int x) care afișează valoarea primită ca parametru. | + | * ''class Printer'', în care definiți o __//**metodă nestatică**//__ ''printInt(int x)'' care afișează valoarea primită ca parametru. |
| - | În main apelați direct metoda astfel: //Printer.printInt(42);//, apoi rulați programul și verificați rezultatul în consolă. | + | În ''main'' apelați metoda ''printInt'' folosind o instanță a clasei Printer, ca în exemplul de la problema precedentă. |
| - | Acum adăugați modificatorul //public// și la clasa Printer, încercați să compilați și observați eroarea. Pentru a corecta, păstrați o singură clasă publică pe fișier: lăsați Prob3 publică în Prob3.java și mutați Printer într-un fișier separat numit **Printer.java**, unde o puteți declara public. Compilați din nou și rulați Prob3. | + | Acum adăugați modificatorul ''public'' și la clasa Printer, încercați să compilați și observați eroarea. Pentru a corecta, păstrați o singură clasă publică pe fișier: lăsați Prob3 publică în Prob3.java și mutați Printer într-un fișier separat numit **Printer.java**, unde o puteți declara public. Compilați din nou și rulați Prob3. |
| - | Opțional, adăugați și în Printer o metodă //main// minimală care apelează //printInt//, apoi rulați-o separat pentru a confirma că ambele clase se pot executa independent când au propriul fișier. | + | Opțional, adăugați și în Printer o metodă ''main'' minimală care apelează ''printInt'', apoi rulați-o separat pentru a confirma că ambele clase se pot executa independent când au propriul fișier. |
| Line 70: | Line 70: | ||
| ====Problema 4==== | ====Problema 4==== | ||
| - | Să se scrie un program pentru afișarea tuturor argumentelor primite în linia de comandă. | + | Scrieți un program în fișierul **Prob4.java** care afișează toate argumentele primite în linia de comandă. |
| + | |||
| + | În metoda ''main'', parcurgeți vectorul ''args'' și afișați, pentru fiecare element, indicele și valoarea lui, pe câte o linie separată. Dacă programul este rulat fără argumente, afișați un mesaj clar, de tipul "Nu s-au primit argumente.". | ||
| + | |||
| + | Pentru testare, rulați programul de mai multe ori: fără argumente, cu un singur argument și apoi cu mai multe (ex.: Ana are mere). Observați cum se modifică lungimea vectorului args și ordinea elementelor afișate. | ||
| <note tip> | <note tip> | ||
| Line 76: | Line 80: | ||
| Argumentele se pot transmite astfel: | Argumentele se pot transmite astfel: | ||
| - | * daca programul se ruleaza dintr-un IDE, se vor urma instructiunile de la începutul laboratorului; | + | * dacă programul se rulează dintr-un IDE, se vor urma instrucțiunile de la începutul laboratorului; |
| - | * daca programul se ruleaza din linia de comandă: ''java numeprogram arg1 arg2 arg3'' | + | * dacăprogramul se rulează din linia de comandă: ''java numeprogram arg1 arg2 arg3'' |
| </note> | </note> | ||
| ====Problema 5==== | ====Problema 5==== | ||
| - | Să se realizeze o clasă care cuprinde o metodă recursivă (nestatica) care calculează puterea întreagă a unui numar întreg și o metodă pentru afișarea rezultatului funcției, alături de rezultatul funcției statice ''Math.pow(baza, exp)'' pentru a se putea valida. Clasa va conține un **//main//** în care se vor testa cele două metode definite anterior. | + | Scrieți în fișierul **Prob5.java** o clasă **Prob5** care conține o __//**metodă nestatică**//__ ''powInt(int baza, int exp)'' ce calculează recursiv puterea întreagă pentru exponenți pozitivi. În ''main'' alegeți câteva perechi constante de valori pentru bază și exponent (de exemplu 3^4, 2^10, 5^0), apelați metoda voastră și afișați rezultatul în consolă. |
| - | <note important> | + | Pentru validare, afișați alături rezultatul returnat de ''Math.pow(baza, exp)''. Comparati rezultatele si afisati rezultatul comparatiei, afisand mesajul "egale" sau "diferite". Păstrați bazele și exponenții suficient de mici încât rezultatul să nu depășească limitele tipului întreg pe care îl folosiți; dacă apare un rezultat "ciudat", cel mai probabil s-a produs **overflow**. |
| - | <color red>**IMPORTANT!**</color> | + | |
| - | O **//metodă statică//** a unei clase se apelează prin: | ||
| - | ''NumeClasă.numeMetodăStatică(...)'' | ||
| - | ''Math.pow(...);'' | ||
| - | </note> | ||
| + | ====Problema 6==== | ||
| + | În fișierul **Prob6.java** scrieți o clasă **Prob6** care conține o __//**metodă nestatică**//__ ''isPrime(int n)'' ce întoarce true dacă n este număr prim și false în caz contrar. | ||
| + | În metoda ''main'' parcurgeți toate numerele întregi de la 1 la 20 și afișați pentru fiecare un mesaj clar, de forma "n prim" sau "n nu e prim". | ||
| - | ====Problema 6==== | + | **Considerați numărul 1 ca fiind număr prim.** |
| - | Să se implementeze o clasă cu două metode: | + | |
| - | * o metodă (nestatica) de tip ''boolean'' care verifică dacă un număr întreg dat este prim; | + | |
| - | * metoda ''main'' care verifică metoda anterioară pentru toate numerele naturale mai mici ca $20$. | + | |
| ====Problema 7==== | ====Problema 7==== | ||
| - | Să se scrie un program pentru verificarea ipotezei lui Goldbach pentru primele n numere pare, prin afișarea tuturor sumelor de două numere prime prin care poate fi exprimat un număr par. Variabila n poate fi inițializată cu o valoare constantă. | + | **Ipoteza lui Goldbach** spune că orice număr par se poate scrie ca sumă a două numere prime. |
| - | **Ipoteza lui Goldbach:** orice nr par poate fi descompus ca sumă de cel puțin o pereche de două numere prime. Se consideră $1$ ca fiind număr prim. | + | Exemple: 4 = 2 + 2, 6 = 3 + 3, 8 = 3 + 5, 10 = 3 + 7 sau 5 + 5. |
| - | Pentru afișarea unei expresii de forma ''a = b + c'' se va scrie: | + | Scrieți în fișierul **Prob7.java** un program care verifică ipoteza lui Goldbach pentru primele n numere pare. Refolosiți funcția ''isPrime(int)'' din **problema anterioară**. |
| + | |||
| + | Pentru fiecare număr par p, afișați exact forma p = a + b (o singură dată fiecare pereche, fără simetrice repetate). | ||
| + | |||
| + | Considerați numărul 1 prim și mențineți n (valoare constantă în cod) suficient de mic pentru a verifica rapid. | ||
| + | |||
| + | <note tip> | ||
| + | <color green>**Observație**</color> | ||
| + | |||
| + | Pentru afișarea unei expresii de forma ''p = a + b'' se va scrie: | ||
| <code java> | <code java> | ||
| - | System.out.println(a + " = " + b + " + " + c); | + | System.out.println(p + " = " + a + " + " + b); |
| </code> | </code> | ||
| - | unde ''a'', ''b'', ''c'' sunt variabile numerice de orice tip (''short'', ''int'', ''long'', ''float'', ''double''). | + | unde ''p'', ''a'', ''b'' sunt variabile numerice de orice tip (''short'', ''int'', ''long'', ''float'', ''double''). |
| + | </note> | ||
| + | |||
| ====Problema 8==== | ====Problema 8==== | ||
| - | Să se scrie un program pentru ordonarea unui vector de numere și căutarea binară în acest vector, folosind metodele statice **//sort()//** și **//binarySearch()//** din clasa **//Arrays//**. Vectorul va conține numere generate aleator folosind metoda statică **//random()//** din clasa //**Math**//, cu rezultat de tip //**double**//. | + | În acest exercițiu veți lucra cu vectori și cu două metode utile din clasa **Arrays**: ''Arrays.sort'' pentru ordonare și ''Arrays.binarySearch'' pentru căutare rapidă într-un tablou deja sortat. Ideea este simplă: mai întâi puneți elementele într-un tablou, le ordonați crescător, apoi căutați o cheie și interpretați poziția returnată de funcția de căutare. |
| + | |||
| + | Creați fișierul **Prob8.java** și, în metoda ''main'', **creați** un tablou de ''int'' de dimensiune fixă (de exemplu n = 12). **Populați-l** cu valori pseudo-aleatoare într-un interval mic. **Afișați** conținutul inițial al tabloului, apoi **apelați** ''java.util.Arrays.sort(tab)'' pentru a-l ordona și **afișați** din nou rezultatul, ca să se vadă efectul sortării. | ||
| + | |||
| + | După sortare, **alegeți** o cheie pentru test. Cel mai comod este să alegeți o valoare despre care știți sigur că există în tablou, de exemplu elementul din mijloc după sortare; în felul acesta ''Arrays.binarySearch(tab, cheie)'' vă va întoarce un indice valid (>= 0), iar apoi veți **afișa** un mesaj clar care indică poziția găsită. **Testați** apoi și un caz în care cheia nu există (de exemplu o valoare mai mare decât toate elementele din tablou) și **observați** ce returnează funcția. | ||
| + | |||
| + | |||
| + | <note tip> | ||
| + | <color green>**Observație**</color> | ||
| + | |||
| + | Metoda ''Math.random()'' întoarce un ''double'' în intervalul **[0.0, 1.0)**, adică poate fi 0.0, dar este întotdeauna mai mic decât 1.0. Pentru a obține un întreg într-un interval dorit, **înmulțiți rezultatul cu lățimea intervalului** și apoi **faceți conversia la int**. | ||
| + | |||
| + | De exemplu, valori întregi între 0 și 99 generați astfel: | ||
| + | <code java> | ||
| + | int x = (int) (Math.random() * 100); // 0..99 | ||
| + | </code> | ||
| + | |||
| + | Observați ordinea: mai întâi se înmulțește, abia apoi se face conversia la int. Dacă ați scrie ''(int) Math.random() * 100'', conversia s-ar face înainte (rezultând mereu 0) și ați obține doar 0. | ||
| + | |||
| + | Dacă vreți un interval general [min, max] inclusiv, folosiți formula: | ||
| + | <code java> | ||
| + | int min = 10, max = 20; | ||
| + | int y = min + (int) (Math.random() * (max - min + 1)); // 10..20 | ||
| + | </code> | ||
| + | |||
| + | </note> | ||
| + | |||
| + | |||
| + | |||
| + | |||
