Vectori.

Matrici 31

Cap. 3
Vectori. Matrici

1. Se citeşte de la tastatură un număr natural N; se instanţiază un

vector de N numere întregi. Să se completeze acest vector cu numere
aleatoare în gama 0..N-1, cu condiţia ca fiecare număr din această
gamă să apară o singură dată.
Algoritm: vom iniţializa vectorul cu numerele 0,1, .., N-1, date în
această ordine. Apoi, aceste numere iniţiale, le vom comuta, poziţiile
de comutare fiind generate aleator.
import [Link].*;
import [Link].*;
class InitNumAleatoare
{
public static void main(String args[])
{
int N;
String s = [Link]("N=");
N = [Link](s);
int a[] = new int [N];
int i;
//se initializeaza vectorul cu numerele 0,1,...,N-1, in aceasta ordine:
for(i=0;i<[Link];i++)
a[i] = i;
Random r = new Random();
//se repeta de N ori:
for(i=0;i<N;i++){
//se genereaza doua numere aleatoare n1 si n2:
int n1 = [Link](N);
int n2 = [Link](N);
//se comuta variabilele a[n1] si a[n2]:
int aux = a[n1];
a[n1] = a[n2];
a[n2] = aux;
}
//Afisare vector generat:
for (i=0;i<N;i++)
[Link](a[i]);
[Link](0);
32 Vectori. Matrici

}
}

2. Se citeşte de la tastatură un număr natural N; se instanţiază un

vector de N numere întregi. Să se completeze acest vector cu numere
aleatoare în gama 0..N-1, cu condiţia ca fiecare număr din această
gamă să apară o singură dată. (Problema anterioară, dar un alt
algoritm: vom introduce pe rind în vector, cate un număr aleator, cu
condiţia ca să fie diferit de numerele anterioare introduse).
import [Link].*;
class Aleatoare
{
public static void main(String args[])
{
final int N=10;
int a[]=new int[N];
Random r=new Random();
int i;
int nr;
for(i=0;i<N;i++){
for(;;){
nr=[Link](N);//intre 0 si (N-1)
//a mai fost generat?
//cautare liniara:
boolean estePrezent=false;
for(int j=0;j<i;j++)
if(nr==a[j]){
estePrezent=true;
break;}
if(estePrezent==false){
a[i]=nr;
break;
}
}//for;;
}//for i
//afisare:
for(i=0;i<N;i++)
[Link](a[i]+" ");
[Link]("\n");
}//main
Vectori. Matrici 33

3. Se citesc de la tastatură doi vectori a şi b, ce au aceeaşi

dimensiune (dimensiunea lor comună, N, este cunoscută). Să se
afişeze dacă vectorul b este o permutare a vectorului a.
import [Link].*;
import [Link].*;
class SuntPermutari
{
public static void main(String args[])
{
int N;
String s = [Link]("N=");
N = [Link](s);
int a[] = new int [N];
int b[] = new int [N];
int i;
for(i=0;i<N;i++)
a[i]=[Link]([Link]("a["+i+"]="));
for(i=0;i<N;i++)
b[i]=[Link]([Link]("b["+i+"]="));
//sortam cei doi vectori:
[Link](a);
[Link](b);
//comparam cei doi vectori:
boolean suntPerm=true;
for(i=0;i<N;i++)
if(a[i]!=b[i]){
suntPerm=false;
break;
}
if(suntPerm)[Link]("sunt");
else [Link]("nu sunt");
}
}

4. În clasa System, care face parte din pachetul [Link], este

definită metoda: currentTimeMillis() cu semnătura:
public static long int currentTimeMillis().
34 Vectori. Matrici

Această metodă returnează valoarea timpului sistemului, în

milisecunde.
Se generează N= 100000 numere întregi aleatoare, în gama 0...9999,
care se memorează în vectorul a. Folosind metoda
currentTimeMillis(), să se calculeze durata sortării în ordine
crescătoare a vectorului a. Se va sorta vectorul mai întâi cu metoda
[Link](), şi apoi acelaşi vector cu metoda de sortare prin
interschimbare.
import [Link].*;
import [Link].*;
class DurataSortare
{
public static void main(String args[])
{
final int N=100000;
final int GAMA=1000;
int a[] = new int [N];
Random r=new Random();
int i;
for(i=0;i<N;i++)
a[i]=[Link](GAMA);
//salvam vectorul a:
int b[] = new int [N];
for(i=0;i<N;i++)
b[i]=a[i];
long t1=[Link]();
[Link](a);
long t2=[Link]();
[Link](t2-t1);
//Acelasi vector sortat prin interschimbare:
long t3=[Link]();
sortare(b);
long t4=[Link]();
[Link]("sortare interschimbare : "+(t4-t3));
}
private static void sortare(int a[])
{
for(int i=0;i<[Link]-1;i++)
for(int j=i+1;j<[Link];j++)
if(a[i]>a[j]){
Vectori. Matrici 35

int aux=a[i];
a[i]=a[j];
a[j]=aux;
}
}
}

5. Să se scrie o aplicaţie ce foloseşte o metodă ce are doi parametrii:

un vector de numere întregi a , şi un parametru de tip caracter denumit
sens, ce poate avea două valori: ‘s’ (stânga) şi ‘d’ (dreapta). În metodă
se rotesc în vectorul a toate elementele, cu o poziţie, spre stânga sau
spre dreapta, după valoarea parametrului sens.
Exemplu:
a={1,2,30} şi sens=’d’. După execuţia metodei avem: a={30, 1, 2}
class Rotire
{
public static void main(String args[])
{
int a[]={1,2,30};
rotire(a,'d');
for(int i=0;i<[Link];i++)
[Link](a[i]+" ");
}
private static void rotire(int a[],char sens)
{
int N=[Link];//dimensiune vector a[]
if(sens=='s'){
int aux=a[0];
for(int i=0;i<N-1;i++)
a[i]=a[i+1];
a[N-1]=aux;
}
else if(sens=='d'){
int aux=a[N-1];
for(int i=N-2;i>=0;i--)
a[i+1]=a[i];
a[0]=aux;
}
}
}
36 Vectori. Matrici

6. Scrieţi o aplicaţie în care se implementează algoritmul de căutare

binară a prezenţei unui număr x citit de la tastatură într-un vector
sortat crescător.
class CautareBinara
{
public static void main(String args[])
{
int a[]={1,5,7,9,12,30};
int x=1;
//Este prezent x in vectorul a[] ?
if(estePrezent(x,a,0,[Link]-1))[Link]("Este prezent.");
else [Link]("Nu este prezent.");
}

private static boolean estePrezent(int x,int a[],int s,int d)

{
if(s==d){
if(x==a[s])return true;else return false;}
if(d-s==1){
if((x==a[s])||(x==a[d]))return true; else return false;}
int m;
m=(s+d)/2;
if(x==a[m])return true;
else if(x<a[m])return estePrezent(x,a,s,m-1);
else return estePrezent(x,a,m+1,d);
}//estePrezent
}

7. Scrieţi o aplicaţie Java în care se implementeză algoritmul de

sortare prin metoda selecţiei maximului.
import [Link].*;
class SelectieMaxim{
public static void main(String args[]){
final int N=5;
int A[]=new int[N];
int i;
//citire vector A[]:
for(i=0;i<N;i++)
A[i]=[Link]([Link]("nr="));
Vectori. Matrici 37

ordonareCresc(A,N);
[Link]("Numerele sortate crescator: ");
for(i=0;i<N;i++)
[Link](A[i]);
}//main
private static void ordonareCresc(int A[], int nA)
//trebuie oblig. ca parametru dat si nA, pt. ca metoda se va apela
// recursiv pt. mai putine elemente.
{
if(nA==1)return;//un singur element, este implicit ordonat!
int poz=getPozMax(A,nA);//indexul maximului
if(poz!=nA-1){//daca este chiar pe ultima poz., nu avem ce comuta!
//comut elementul de pe utima poz. din A cu maximul gasit:
int temp=A[nA-1];
A[nA-1]=A[poz];
A[poz]=temp;}
//ordoneaza recursiv portiunea din vectorul A[]
// ce are doar nA-1 componente:
ordonareCresc(A,nA-1);
}//ordonareCresc
private static int getPozMax(int A[], int nA)
{
int max=A[0];
int pozMax=0;
for(int i=1;i<nA;i++)
if(A[i]>max){
max=A[i];
pozMax=i;}
return pozMax;
}
}

8. Scrieţi o aplicaţie Java în care se implementeză algoritmul de

interclasare a doi vectori sortaţi crescător.
class Interclasare
{
public static void main(String args[]){
//Se dau doi vectori A[] si B[], fiecare ordonat crescator. Sa obtinem
// vectorul C, ordonat crescator, ce cuprinde toate elementele din
//primii doi vectori.
38 Vectori. Matrici

int A[]={1,10,200};
int B[]={5, 6, 7, 22, 33,4090};
int nA=[Link];//nr. de elemente din A
int nB=[Link];
int C[]=new int[nA+nB];
//Algoritmul de interclasare:
//Indexul initial in fiecare din cele 3 multimi:
//indexA=indexB=indexC=0 (se pleaca de la 0)
//Comparam pe A[ indexA] cu B[indexB].
//Pe cel mai mic, il copiem in multimea C.
//Modificam corespunzator indecsii: incrementam indexul multimii C
// si indexul din multimea din care a fost elementul ce s-a copiat.
//Se repeta apoi acest procedeu., pana se termina una din multimi.
int indexA=0;
int indexB=0;
int indexC=0;
int i;
while((indexA<nA)&&(indexB<nB)){
if(A[indexA]<=B[indexB]){
C[indexC]=A[indexA];
indexA++;}
else{
C[indexC]=B[indexB];
indexB++;}
//in ambele cazuri, cresc indexC:
indexC++;
}
//Una din multimile A , B - s-a terminat. Adaug la sfarsitul lui C
// restul elementelor din multimea ce nu s-a terminat:
if(indexA==nA)//s-a terminat A:
for(i=indexB;i<nB;i++)//cele ramase in B:
C[indexC+i-indexB]=B[i];
else if(indexB==nB)//s-a terminat B:
for(i=indexA;i<nA;i++)//cele ramase in A:
C[indexC+i-indexA]=A[i];
//Afisarea multimii A:
for(i=0;i<nA;i++)
[Link](A[i]+" ");
[Link]();
//Afisarea multimii B:
Vectori. Matrici 39

for(i=0;i<nB;i++)
[Link](B[i]+" ");
[Link]();
//Afisarea multimii C:
for(i=0;i<nA+nB;i++)
[Link](C[i]+" ");
}
}

9. Folosind clasa Vector, implementaţi următorul algoritm:

se repetă
citim un număr real
îl memorăm într-un obiect de tip Vector
se afişează mesajul: “Dati un alt numar? [d/n] ”
se citeşte răspunsul la acest mesaj
până când răspunsul este ‘n’
Se vor afişa în final numerele memorate în obiectul Vector
import [Link].*;
import [Link].*;
class VectorDinamic
{
public static void main(String args[])
{
Vector v=new Vector();
double nr;
for(;;){
nr=[Link]([Link]("nr.="));
[Link](new Double(nr));
String raspuns=
[Link]("Dati un alt numar? [d/n]: ");
if([Link](0)=='n')break;
}
afisareVector(v);
//Modificam primul numar introdus anterior in Vector:
[Link](0,new Double(7.5));
[Link]("Vectorul modificat: ");
afisareVector(v);
[Link]();
}
private static void afisareVector(Vector v)
40 Vectori. Matrici

{
int n=[Link]();// dimensiunea obiectului Vector:
for(int i=0;i<n;i++){
Double obiectCrt=(Double)[Link](i);
//fara operatorul cast (Double): eroare, caci metoda get()
//returneaza un obiect de tipul Object
[Link]([Link]());
//dintr-un obiect Double se extrage valoarea lui numerica de tipul
//double, cu metoda doubleValue()
}//for
}
}

10. Să se scrie o aplicaţie Java în care se implementeză algoritmul de

sortare rapidă (quicksort) a unui vector de numere întregi. Vectorul va
fi iniţializat cu N numere aleatoare.
import [Link].*;
class QuickSort
{
public static void main(String args[])
{
final int GAMA=100;
Random r=new Random();
final int N=10;
int a[]=new int[N];
int i;
for(i=0;i<N;i++)
a[i]=[Link](GAMA);
[Link]("Vector nesortat:");
for(i=0;i<N;i++)
[Link](a[i]);
qsort(a,0,N-1);
[Link]("Vector sortat:");
for(i=0;i<N;i++)
[Link](a[i]);
}

private static void qsort(int a[],int st, int dr)

{
if(st<dr){
Vectori. Matrici 41

int p=getPivot(a,st,dr);
qsort(a,st,p-1);
qsort(a,p+1,dr);
}
//cand st=dr se iese din metoda
}

private static int getPivot(int a[],int st, int dr)

{
int i,j,di,dj;
int aux;
//Se parcurge vectorul din ambele capete:
i=st;
di=0;//pasul de avansare din capul stanga
j=dr;
dj=1;//pasul de avansare din capul dreapta
while(i<j){
if(a[i]>a[j]){ //daca nu sunt in ordine
aux=a[i]; a[i]=a[j]; a[j]=aux; //comutare elemente
//comutam si pasii:
aux=di; di=dj; dj=aux;
}//if
i=i+di;
j=j-dj;
}//end while
return i;
}
}//end class

11. Să se scrie o aplicaţie Java în care se implementeză algoritmul de

sortare bubblesort a unui vector de numere întregi.
class Sortare
{
public static void main(String args[])
{
int a[]={1,7,6,5,10,4,3,2,9,8};
int i;
bubbleSort(a);
//afisare:
for(i=0;i<[Link];i++)
42 Vectori. Matrici

[Link](a[i]);
}
private static void bubbleSort(int a[])
{
int dim=[Link];
int i;
boolean suntInv;
for(;;){
suntInv=false;
for(i=0;i<dim-1;i++)
if(a[i]>a[i+1]){
int aux=a[i];
a[i]=a[i+1];
a[i+1]=aux;
suntInv=true;
}
if(suntInv==false)break;
}
}
}

12. Se citesc două mulţimi de numere întregi, (în fiecare mulţime,

numerele sunt diferite), în doi vectori A şi B. Să se calculeze
reuniunea celor două mulţimi.
class Reuniune
{
public static void main(String args[]){
int A[]={1,10,2};
int B[]={5, 6, 7, 2, 10};
int nA=[Link];//nr. de elemente din A
int nB=[Link];
int i;
int C[]=new int[nA+nB];//vectorul reuniune
//Copiem pe A in C:
for(i=0;i<nA;i++)
C[i]=A[i];
//Adaugam in C[] toate elementele din B[], care
// nu sunt si in A[]:
int iC=nA;//index in multimea C
for(i=0;i<nB;i++)
Vectori. Matrici 43

if(estePrezent(B[i],A)==false){
C[iC]=B[i];
iC++;
}
int nC=iC;//numarul de elemente din C[]
//Afisare A[]:
for(i=0;i<nA;i++)
[Link](A[i]+" ");
[Link]();
//Afisarea multimii B:
for(i=0;i<nB;i++)
[Link](B[i]+" ");
[Link]();
//Afisarea multimii C:
for(i=0;i<nC;i++)
[Link](C[i]+" ");
}
private static boolean estePrezent(int x,int a[])
{
for(int i=0;i<[Link];i++)
if(a[i]==x)return true;
return false;
}
}

13. Se citeşte un număr natural N. Se citeşte un vector a de N numere

întregi. Se citeşte un număr natural S. Să se afişeze toate posibilităţile
de a scrie pe S ca sumă de numere luate din vectorul a (pot fi luate 1,
2, …N numere din vector).
import [Link].*;
class ToatePosibilitatile
{
private static int N;
private static int S;
private static int X[]=new int[100];//X[k] este din multimea {0,1}
//X[i]=1 daca se ia in grupa pe a[i]. Daca nu se ia: X[i]=0 .
//Vectorul X are N elemente (am dat o dimensiune acoperitoare)
private static int a[]=new int[100];
public static void main(String args[])
{
44 Vectori. Matrici

S=[Link]([Link]("S="));
N=[Link]([Link]("N="));
int i;
for(i=0;i<N;i++)
a[i]=[Link]([Link]("nr.="));
int nrElemente;
for(nrElemente=1;nrElemente<=N;nrElemente++)
back(0,nrElemente);//generam toate grupele de nrElemente luate
//din multimea a[] (combinari)
}
private static void back(int k,int nrElemente)
{
//construieste pe X[k]:
int i;
if(k==N)afisare();
else for(i=0;i<=1;i++){
X[k]=i;
if(valid(k,nrElemente)==true)
back(k+1,nrElemente);
}
}
private static boolean valid(int k, int nrElemente)
{
//Calculeaza cate elemente au fost luate si suma elementelor
// a[i] corespunzatoare:
int contor=0;
int suma=0;
int i;
for(i=0;i<=k;i++)
if(X[i]==1){
contor++;
suma=suma+a[i];}
if(contor>nrElemente)return false;
if(suma>S)return false;
if(k==N-1){//s-a completat vectorul X[]
if(suma!=S)return false;
if(contor!=nrElemente)return false;}
return true;
}
private static void afisare()
Vectori. Matrici 45

{
for(int i=0;i<N;i++)
if(X[i]==1)[Link](a[i]+" ");
[Link]();
}
}//end class

14. Să se construiască clasa Punct ce are ca variabile de instanţă două

numere întregi x şi y – coordonatele unui punct în plan, şi ca metode:
‐ Constructorul ce face iniţializările;
‐ Metoda getX() ce returnează valoarea coordonatei x
‐ Metoda getY() ce returnează valoarea coordonatei y
‐ Metoda distanţa() ce are ca parametru un Punct p şi care
returnează distanţa dintre punctul curent (referit prin cuvântul cheie
this) şi punctual p.
‐ Metoda suntEgale() ce are ca parametru un Punct p şi care
returnează true dacă punctul curent este egal cu p, şi false în caz
contrar.
Folosind clasa Punct, citim de la tastatură N obiecte Punct (N
cunoscut), şi le memorăm într-un vector. Să se afişeze:
a. Sunt toate punctele diferite între ele?
b. Câte puncte sunt situate pe prima bisectoare (x=y)?
c. Care este cea mai mare distanţă dintre două puncte din vector?
import [Link].*;
class Punct
{
private int x;//coordonata x a punctului
private int y;
public Punct(int x0, int y0)
{
x=x0;
y=y0;
}
public int getX()
{
return x;
}
public int getY()
{
return y;
46 Vectori. Matrici

}
public double distanta(Punct p)
{
return [Link]((x-p.x)*(x-p.x)+(y-p.y)*(y-p.y));
}
public boolean suntEgale(Punct p)
{
if((x==p.x)&&(y==p.y))return true;
else return false;
}
}

class VectorDePuncte
{
public static void main (String args[])
{
int N;//numarul de puncte
N=[Link]([Link]("N="));
Punct p[]=new Punct[N];//vectorul de obiecte Punct (clasa de baza)
int i;
for(i=0;i<N;i++){
int x=[Link]([Link]("x="));
int y=[Link]([Link]("y="));
p[i]=new Punct(x,y);
}//for
//Sunt toate punctele diferite?
[Link]("Sunt toate diferite="+suntDiferite(p));
//Numarul de puncte de pe prima bisectoare:
[Link]("Nr. puncte pe prima
bisectoare="+catePeBisectoare(p));
//Distanta maxima intre doua puncte:
[Link]("Distanta maxima="+distMaxima(p));
}
private static boolean suntDiferite(Punct p[])
{
for(int i=0;i<[Link]-1;i++)
for(int j=i+1;j<[Link];j++)
if(p[i].suntEgale(p[j])==true)return false;
return true;
}
Vectori. Matrici 47

private static int catePeBisectoare(Punct p[])

{
int contor=0;
for(int i=0;i<[Link];i++)
if(p[i].getX()==p[i].getY())contor++;
return contor;
}
private static double distMaxima(Punct p[])
{
double maxim=0;//initializare distanta maxima
//Formam toate perechile de puncte:
for(int i=0;i<[Link]-1;i++)
for(int j=i+1;j<[Link];j++){
double d=p[i].distanta(p[j]);//distanta intre punctele i si j
if(d>maxim)maxim=d;}
return maxim;
}

15. Să se construiască clasa Complex ce are ca variabile de instanţe

private, numerele întregi re şi im ce reprezintă partea reală şi partea
imaginară a unui număr complex. Ca metode:
‐ constructorul, ce face iniţializările;
‐ metoda modul(), ce returnează modulul numărului complex;
‐ metoda suntEgale(), ce are ca parametru un număr complex c,
şi care returnează true dacă numărul complex curent (cel pentru care
se apelează această metodă) este egal cu numărul complex c;
‐ metoda suma(), ce are ca parametru un număr complex c şi în
care se adună la numărul complex curent, numărul complex c
(rezultatul se depune tot în numărul complex curent);
‐ metoda afisare(), în care se afişează numărul complex.
Folosind clasa Complex, citim de la tastatură, într-un vector, N
numere complexe (N - cunoscut).
a. să se afişeze care este numărul ce are cel mai mare modul;
b. să se afişeze suma celor N numere complexe;
c. să se afişeze dacă cele N numere complexe sunt toate diferite
între ele.
import [Link].*;
class Complex
48 Vectori. Matrici

{
private int re;//partea reala a numarului complex
private int im;
public Complex(int x, int y)
{
re=x;
im=y;
}
public int getRe()
{
return re;
}
public int getIm()
{
return im;
}
public double modul()
{
return [Link](re*re+im*im);
}
public boolean suntEgale(Complex c)
{
if((re==[Link])&&(im==[Link]))return true;
else return false;
}
public void suma(Complex c)
{
re=re+[Link];
im=im+[Link];
}
}

class VectorDeComplexe
{
public static void main (String args[])
{
int N;//numarul de numere complexe
N=[Link]([Link]("N="));
Complex c[]=new Complex[N];//vectorul de obiecte Complex
Vectori. Matrici 49

int i;
for(i=0;i<N;i++){
int x=[Link]([Link]("x="));
int y=[Link]([Link]("y="));
c[i]=new Complex(x,y);
}//for
//Numarul ce are cel mai mare modul:
int index=calculIndexNrMaxModul(c);
[Link]("Numarul ce are modulul maxim : ");
[Link]("re="+c[index].getRe()+" im="
+c[index].getIm());
//Suma celor N numere complexe:
Complex suma=calculSuma(c);
[Link]("suma este: re="+[Link]()+" im="
+[Link]());
//Sunt toate numerele complexe diferite?
[Link]("Sunt toate diferite="+suntDiferite(c));
}
private static int calculIndexNrMaxModul(Complex c[])
{
int indexMax=0;
double modulMax=c[0].modul();
for(int i=1;i<[Link];i++){
double modulCrt=c[i].modul();
if(modulCrt>modulMax){
indexMax=i;
modulMax=modulCrt;}
}
return indexMax;
}
private static Complex calculSuma(Complex c[])
{
Complex rezultat=new Complex(0,0);
for(int i=0;i<[Link];i++)
[Link](c[i]);
return rezultat;
}
private static boolean suntDiferite(Complex c[])
{
for(int i=0;i<[Link]-1;i++)
50 Vectori. Matrici

for(int j=i+1;j<[Link];j++)
if(c[i].suntEgale(c[j])==true)return false;
return true;
}
}

16. Se citeşte de la tastatură o matrice de numere întregi, de

dimensiuni cunoscute (numărul de linii şi numărul de coloane citite
anterior). Să se calculeze şi afişeze dacă matricea are toate numerele
egale între ele.
import [Link].*;
class MatriceSuntEgale
{
public static void main(String args[])
{
int nL;//numar linii matrice
nL=[Link]([Link]("nr. linii="));
int nC;//numar coloane matrice
nC=[Link](
[Link]("nr. coloane="));
int a[][]=new int[nL][nC];
//citire matrice:
int i,j;
for(i=0;i<nL;i++)
for(j=0;j<nC;j++)
a[i][j]=[Link]([Link]("nr="));
boolean egale=suntToateEgale(a);
if(egale==true)[Link]("Sunt toate numerele egale.");
else [Link]("Nu sunt toate egale");
}
private static boolean suntToateEgale(int a[][])
{
for(int i=0;i<[Link];i++)
for(int j=0;j<a[0].length;j++)
if(a[i][j]!=a[0][0])return false;
return true;
}
}
Vectori. Matrici 51

17. Se dă o matrice de numere întregi. Să se calculeze şi afişeze dacă

în acestă matrice există cel puţin două linii egale între ele.
class MatriceLiniiEgale
{
public static void main(String args[])
{
int a[][]={{1,2,3,4,5},
{0,1,0,0,0},
{1,2,3,4,5},
{1,1,1,1,1}};
//Comparam liniile matricii, doua cate doua:
int nL=[Link];//numarul de linii
int nC=a[0].length;//numarul de coloane
int i,j;
for(i=0;i<nL-1;i++)
for(j=i+1;j<nL;j++)
//compara linia i cu linia j:
if(suntEgale(a[i],a[j])){
[Link]("Are linii egale intre ele");
return;
}
[Link]("Nu are linii egale intre ele") ;
}
private static boolean suntEgale(int linie1[], int linie2[])
{
//Se compara doi vectori pentru egalitatea lor:
for(int i=0;i<[Link];i++)
if(linie1[i]!=linie2[i])return false;
return true;
}
}

18. Se dă o matrice de numere întregi.. Să se calculeze şi afişeze dacă

în acestă matrice există cel puţin o linie care să aibă toate elementele
egale între ele.
class MatriceLinieConstanta
{
public static void main(String args[])
{
int a[][]={{1,2,3,4,5},
52 Vectori. Matrici

{0,0,0,0,0},
{1,2,3,4,5},
{1,1,1,0,1}};
//Parcurgem toate liniile matricii:
int nL=[Link];//numarul de linii
for(int i=0;i<nL;i++)
//are linia curenta i, toate elementele egale?
if(areToateEgale(a[i])){
[Link]("Are.");
return;
}
[Link]("Nu are.");
}
private static boolean areToateEgale(int linie[])
{
//Se compara toate elementele vectorului, cu primul:
for(int i=1;i<[Link];i++)
if(linie[i]!=linie[0])return false;
return true;
}
}

19. Se citeşte un număr natural N. Se iniţializează o matrice pătrată de

dimensiune N, cu numere aleatoare în gama 1...100. Să se calculeze
câte numere prime sunt în matrice.
import [Link].*;
import [Link].*;
class CatePrimeInMatrice
{
public static void main(String args[])
{ final int GAMA=100;
int N=[Link]([Link]("N="));
int a[][]=new int[N][N];
Random r=new Random();
//Initializam matricea:
int i,j;
for(i=0;i<N;i++)
for(j=0;j<N;j++)
a[i][j]=1+[Link](GAMA);
//Afisarea matricii:
Vectori. Matrici 53

for(i=0;i<N;i++){
for(j=0;j<N;j++)
[Link](a[i][j]+" ");
[Link]();
}
int totalNrPrime=cateNrPrime(a);
[Link]("numarul de nr. prime = "+totalNrPrime);
}
private static int cateNrPrime(int a[][])
{
int contor=0;
for(int i=0;i<[Link];i++)
for(int j=0;j<a[0].length;j++)
if(estePrim(a[i][j]))contor++;
return contor;
}
private static boolean estePrim(int nr)
{
for(int i=2;i<=[Link](nr);i++)
if(nr%i==0)return false;
return true;
}
}

20. Se citeşte un număr natural N. Se iniţializează o matrice pătrată de

dimensiune N, cu numere aleatoare în gama 1...100. Să se afişeze dacă
toate numerele din matrice sunt diferite între ele sau nu.
import [Link].*;
import [Link].*;
class MatriceSuntDiferite
{
public static void main(String args[])
{ final int GAMA=100;
int N=[Link]([Link]("N="));
int a[][]=new int[N][N];
Random r=new Random();
//Initializam matricea:
int i,j;
for(i=0;i<N;i++)
for(j=0;j<N;j++)
54 Vectori. Matrici

a[i][j]=1+[Link](GAMA);
//Afisarea matricii:
for(i=0;i<N;i++){
for(j=0;j<N;j++)
[Link](a[i][j]+" ");
[Link]();
}
boolean sunt=suntDiferiteInMatrice(a);
[Link]("sunt diferite = "+sunt);
}
private static boolean suntDiferiteInMatrice(int a[][])
{
int nL=[Link];//numar linii
int nC=a[0].length;//numar coloane (in aceasta problema nC=nL)
int i,j,lin,col;
//Are prima linie toate elem. diferite?
if(suntDiferiteInVector(a[0])==false)return false;
//Prima linie are toate elementele diferite.
//Parcurg restul liniilor:
for(i=1;i<nL;i++){
//are linia i toate elementele diferite intre ele?
if(suntDiferiteInVector(a[i])==false)return false;
//Elem. liniei i mai apar in liniile 0,1,i-1?
for(j=0;j<nC;j++)
//Parcurg liniile 0,1,..,i-1:
for(lin=0;lin<i;lin++)
for(col=0;col<nC;col++)
if(a[i][j]==a[lin][col])return false;
}
return true;
}
private static boolean suntDiferiteInVector(int v[])
{
for(int i=0;i<[Link]-1;i++)
for(int j=i+1;j<[Link];j++)
if(v[i]==v[j])return false;
return true;
}
}
Vectori. Matrici 55

21. Se citeşte de la tastatură o matrice de numere întregi, de

dimensiuni cunoscute (numărul de linii şi numărul de coloane citite
anterior). Se citesc în variabilel l1 şi l2, numerele a două linii din
matrice. Să se comute în matrice aceste linii.
import [Link].*;
class ComutaDouaColoane
{
public static void main(String args[])
{
int nL;//numar linii matrice
nL=[Link]([Link]("nr. linii="));
int nC;//numar coloane matrice
nC=[Link]([Link]("nr. col.="));
int a[][]=new int[nL][nC];
//citire matrice:
int i,j;
for(i=0;i<nL;i++)
for(j=0;j<nC;j++)
a[i][j]=[Link]([Link]("nr="));
//Citeste numerele celor doua linii:
int l1;
l1=[Link]([Link]("l1="));
int l2;
l2=[Link]([Link]("l2="));
comutare(a,l1,l2);
//Afisare matrice dupa comutare:
[Link]();
for(i=0;i<nL;i++)
{
for(j=0;j<nC;j++)
[Link](a[i][j]+" ");
[Link]();
}
}
public static void comutare(int a[][],int l1,int l2)
{
int aux;
int i;
for (i=0;i<a[0].length;i++)
{
56 Vectori. Matrici

aux=a[l1][i];
a[l1][i]=a[l2][i];
a[l2][i]=aux;
}
}
}

22. Se citeşte un număr natural N, impar. Să se construiască o matrice

pătrat magic de ordinul N, după următorul algoritm:
-Punem primul număr (1) în matrice, la mijlocul ultimei linii. (deci
poziţia iniţială este: linia=N-1, coloana=N/2)
-Punem în ordine numerele 2,3,...,N*N în matrice, calculând astfel
poziţia următoare, în care vom scrie numărul la care am ajuns:
Poziţia următoare: dreapta jos cu o linie, faţă de poziţia curentă.
Dacă această nouă poziţie a trecut de ultima line, trecem pe prima
linie (linia 0). Dacă a trecut de ultima coloană, trecem pe coloana 0,
Daca această nouă poziţie calculată este deja ocupată, ne deplasăm în
celula de deasupra celei în care s-a introdus numărul anterior (aceasta
sigur nu este ocupată)
import [Link].*;
class ConstruiestePatratMagic
{
public static void main(String args[])
{
int N;
for(;;){
N=[Link]([Link]
("N (impar)= "));
if(N%2==1)break;
}
int a[][]=new int[N][N];
int i,j,linCrt,colCrt;
//Umplem matricea cu 0: (nici un numar din gama 1..N*N nu a fost
//introdus)
for(i=0;i<N;i++)
for(j=0;j<N;j++)
a[i][j]=0;
//Punem primul numar (1) in matrice, la mijlocul ultimei linii:
linCrt=N-1;
colCrt=N/2;
Vectori. Matrici 57

a[linCrt][colCrt]=1;
//Punem in ordine numerele 2,3,...,N*N in matrice, calculand
//conform algoritmului pozitiile pe care le punem in matrice:
for(int nr=2; nr<=N*N;nr++)
{
//Pozitia curenta este coltul dreapta jos?
if((linCrt==N-1)&&(colCrt==N-1))linCrt=N-2;//trecem pe
//penultima linie
else{
//Calculam pozitia pe care scriem pe nr:
//Salvam linia si coloana curenta (pentru cazul in care pozitia
// ce o vom calcula, este deja ocupata):
int linAnt=linCrt;
int colAnt=colCrt;
//Pozitia urmatoare: dreapta jos cu o linie, fata de pozitia
//curenta:
linCrt=linCrt+1;
colCrt=colCrt+1;
//Noua pozitie a depasit granitele matricii?
if (linCrt==N)linCrt=0;//prima linie
if (colCrt==N)colCrt=0;//prima coloana
//Pozitia calculata este ocupata?
if(a[linCrt][colCrt]!=0){
//Este ocupata. Ne deplasam in celula de deasupra celei
// in care s-a introdus numarul anterior:
// (aceasta sigur nu este ocupata)
linCrt=linAnt-1;
colCrt=colAnt;}
}//else
a[linCrt][colCrt]=nr;
}//for
//Afisarea matricii patrat magic:
for(i=0;i<N;i++){
for(j=0;j<N;j++)
[Link](a[i][j]+" ");
[Link]();
}
}
}