// STEFANESCU ANDREEA, SERIA B, GRUPA 1067
// BILET NR. 17 - CLASA TEMPLATE MULTIME

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iostream.h>
#include <conio.h>
#define maxx 50

template <class element> class multime  
{
public:
	multime <element> operator+(multime <element>); // se reunesc doua multimi
	multime <element> operator*(multime <element>); // se intersecteaza doua multimi
	multime <element> operator-(multime <element>); // se face diferenta simetrica intre doua multimi
	multime <element> operator<(multime <element>); // se verifica apartenenta unei multimi la cealalta multime

	int operator+(element); // se adauga un element la o multime
	int operator-(int);     // se extrage un element dintr-o multime
	int operator*(element); //se verifica apartenenta unui element la o multime
	
	multime(int); //constructor de multime vida
	multime();

	multime(multime <element> &); //constructor de copiere
	
	friend ostream& operator<<(ostream&,multime <element>&); //operatii de iesire
	friend istream& operator>>(istream&,multime <element> &); //operatii de intrare

	void sortare(); // sorteaza crescator elementele unei multimi
	void afisare(); //se afiseaza continutul unei multimi

	~multime();  //destructor
	

private:
	element *pv; // pointer la primul element al multimii
	int nr_elem; // cardinalul multimii
	int index;
};


template <class element> multime <element>::multime()
{
	pv=new element[maxx];
	nr_elem=maxx;
	index=0;
}

/////////////////////////////////////////////////////////////////////////
////////////////////   CONSTRUCTOR DE COPIERE   /////////////////////////
/////////////////////////////////////////////////////////////////////////
template <class element> multime <element>::multime(multime <element> &v)
{
    int max,i;
	
	max=v.nr_elem;
	pv=new element[max];
	nr_elem=max;
	index=v.index;
	for (i=0;i<index;i++)
		pv[i]=v.pv[i];	
}

///////////////////////////////////////////////////////////////////
/////////////////   CONSTRUCTOR DE MULTIME VIDA   /////////////////
///////////////////////////////////////////////////////////////////
template <class element> multime <element>::multime(int i)
{
	nr_elem=i;
	pv=new element[nr_elem];
	index=0;
}

//////////////////////////////////////////////////////
//////////////////   DESTRUCTOR   ////////////////////
template <class element> multime <element>::~multime()
{
	delete[] pv;
}

 
/////////////////////////////////////////////////////////////////////
///////////   ADAUGAREA UNUI ELEMENT IN MULTIME   ///////////////////
/////////////////////////////////////////////////////////////////////

template <class element> int multime <element>::operator+(element val)
{ 
	int er=0;
	if(index==nr_elem) 
		{ 
	     cout<<"Nu mai e loc in multime!!!";
	     return 0;
		}
	else
		for (int i=0;i<nr_elem;i++)
		{
		
			if (pv[i]==val) 
				{ 
				 er=1;
				 cout<<"Multimea contine deja aceasta valoare!";
				 return 0;
				}
		}
			if (!er)
				{ 
				 pv[index]=val;
				 index++;
				 return 1;
				}
return 0;
} 

////////////////////////////////////////////////////////////////
//////////   EXTRAGEREA UNUI ELEMENT DIN MULTIME   /////////////
////////////////////////////////////////////////////////////////

template <class element> int multime <element>::operator-(int i)
{
	if(i<0 && i>index) return 0;
	else 
	{ 
		for (int j=i;j<index;j++)
		    pv[j]=pv[j+1];
		index--;
        return 1;
	}
}

//////////////////////////////////////////////////////////////////////
///////////////   APARTENENTA UNUI ELEMENT LA O MULTIME   ////////////
//////////////////////////////////////////////////////////////////////

template <class element> int multime <element>::operator*(element val)
{ 
	int er=0;
		for (int i=0;i<nr_elem;i++)
		{
		
			if (pv[i]==val) 
				{
				 er=1;
				 cout<<"Multimea contine aceasta valoare!";
				 return 1;
				}
		}
		
		if (!er)
				{
				cout<<"Multimea nu contine aceasta valoare!";
				return 0;
				}
return 0;
} 

//////////////////////////////////////////////////////////////////////
///////////////   APARTENENTA UNEI MULTIMI LA O MULTIME   ////////////
//////////////////////////////////////////////////////////////////////

template <class element> multime <element> multime <element>::operator<(multime <element> v)
{ 
	bool vb;
	bool er=true;
	int i=0;
		while (i<index)
			{
			vb=false;
			for (int j=0;j<v.index;j++)
					if (v.pv[i]==pv[j]) 
							vb=true;
			i++;
			if (!vb) 
				er=false;
			}
		
		if (!er)
				{
				cout<<"Prima multime nu este inclusa in cea de-a doua !";
				return 0;
				}
		else
				{
				cout<<"Prima multime este inclusa in cea de-a doua !";
				return 1;
				}
} 

////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////   REUNIUNEA A DOUA MULTIMI   //////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////

template <class element> multime <element> multime <element>::operator+(multime <element> v)
{
 int max;
 bool vb;
 int i,j;	
 int k;	
	
    max=index+v.index;
	multime <element> rez(max);
	for (i=0;i<index;i++)
		rez.pv[i]=pv[i];
	i=0;
	rez.index=index;
	k=index;
	while(i<v.index)
		{
		vb=true;
		for (j=0;j<index;j++)
			if (v.pv[i]==rez.pv[j]) vb=false;
		if (vb)
			{
			rez.pv[k]=v.pv[i];
			k++;
			
			}
		i++;
		}
	rez.index=k;
return rez;
}


////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////   INTERSECTIA A DOUA MULTIMI   ////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////

template <class element> multime <element> multime <element>::operator*(multime <element> v)
{
	multime <element> rez;
	int i=0,k=0,l=0;
	bool vb=true;
	while (i<index)
	{
		for(int j=0;j<v.index;j++)
			if (pv[i]==v.pv[j]) vb=false;
			if (!vb) 
			{
				rez.pv[k]=pv[i];
				k++;
			}
		i++;
		vb=true;
	}
	rez.index=k;
return rez;
}

////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////   DIFERENTA A DOUA MULTIMI   //////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////

template <class element> multime <element> multime <element>::operator-(multime <element> v)
{
	multime <element> rez;
	int i=0,k=0,l=0;
	bool vb=true;
	while (i<index)
	{
		for(int j=0;j<v.index;j++)
			if (pv[i]==v.pv[j]) vb=false;
			if (vb) 
			{
				rez.pv[k]=pv[i];
				k++;
			}
		vb=true;
		i++;
	}
	rez.index=k;
return rez;
}

//////////////////////////////////////////////////////////
///////////////   SE SORTEAZA O MULTIME   ////////////////
//////////////////////////////////////////////////////////

template <class element> void multime <element>::sortare()
{
	int i,j;
	element aux;
	for (i=0;i<index-1;i++)
		for (j=i;j<index;j++)
			if (pv[i]>pv[j])
			{ aux=pv[i];
			  pv[i]=pv[j];
			  pv[j]=aux;
			}
}

//////////////////////////////////////////////////////////
///////   SE AFISEAZA ELEMENTELE UNEI MULTIMI   //////////
//////////////////////////////////////////////////////////

template <class element> void multime <element>::afisare()
{
	int i;	
	if (index==0) 
		cout<<"Multimea vida!!!";
	else 
		for (i=0;i<index;i++) 
			cout<<pv[i]<<endl;
	
}

template <class element> ostream& operator<<(ostream& s,multime <element> &v)
{
	v.afisare();
	return s;
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////   SE INCARCA ELEMENTELE IN MULTIME   //////////////////
/////////////////////////////////////////////////////////////////////////////

template <class element> istream& operator>>(istream &s,multime <element> &v)
{	
	int n;
	element x;
	cout<<"Dati numarul de elemente al multimii: ";
	cin>>n;
	for(int i=0;i<n;i++)
	{
		cout<<"Elementul "<<i+1<<" este: ";
		cin>>x;
		(v+x);
	}

return s;
}



/////////////////////////////////////////////////////////////////////////////////////
/////////////////   PARTICULARIZARE PENTRU O MULTIME DE PERSOANE   //////////////////
/////////////////////////////////////////////////////////////////////////////////////


class persoana
{
	   int varsta;
	   char nume[20];
       float salariu;

	   friend class multime;
   	   friend ostream &operator<<(ostream &,persoana &); //operatii de iesire
       friend istream &operator>>(istream &,persoana &); //operatii de intrare	

public:
	 
      bool operator>(persoana &);
	  bool operator==(persoana &);
      
	  persoana (int v=0,float s=0,char n[20]="Anonim")
	  {  
		   strcpy(nume,n);
		   varsta=v;
		   salariu=s;
	  }
};

///////////////////////////////////////////////
///   SE AFISEAZA ELEMENTELE UNEI MULTIMI   ///
///////////////////////////////////////////////

ostream &operator<<(ostream &k,persoana &p)
{      cout<<"\n";
	   k<<p.nume;
	   cout<<" are varsta ";
	   k<<p.varsta;
	   cout<<" si salariul ";
	   k<<p.salariu;
	   return k;
}

//////////////////////////////////////////////
////  SE INCARCA ELEMENTELE UNEI MULTIMI  ////
//////////////////////////////////////////////

istream &operator>>(istream &k,persoana &p)
{      cout<<"\n";
	   cout<<"Introduceti numele persoanei:";
	   k>>p.nume;
	   cout<<"Introduceti varsta persoanei:";
	   k>>p.varsta;
	   cout<<"Introduceti salariul persoanei:";
	   k>>p.salariu;
	   cout<<"\n";
	   return k;
}

bool persoana::operator==(persoana &p)
{
	if (strcmp(nume,p.nume)<=0)
		if (p.salariu==salariu)
			if(p.varsta==varsta) 
				return true;

	return false;
}


bool persoana::operator>(persoana &p)
{  
	if ((varsta>=18)&&(varsta<=35)&&(p.varsta>=18)&&(p.varsta<=35))
		{if (varsta>p.varsta) return true;}
	else
		{if(salariu>p.salariu) return true;}
	return false;
}

void meniu()
{   
	system("cls");
	cout<<"\n         BILET NR. 17 - CLASA TEMPLATE MULTIME\n";
	cout<<"\n1) Testare pe multime de numere";
	cout<<"\n2) Testare pe multime de persoane";
	cout<<"\n3) Iesire\n";
	cout<<"\nDati optiunea:";
}

void submeniu1()
{   
	system("cls");
	cout<<"\n         TESTARE PE MULTIME DE NUMERE \n";
	cout<<"\n1) Introducere elemente in cele doua multimi";
	cout<<"\n2) Sortarea celor doua multimi";
	cout<<"\n3) Testarea apartenentei primei multimi la cea de-a doua";
	cout<<"\n4) Reuniunea celor doua multimi";
	cout<<"\n5) Intersectia celor doua multimi";
	cout<<"\n6) Diferenta simetrica dintre cele doua multimi";
	cout<<"\n7) Adaugarea unui element in prima multime";
	cout<<"\n8) Extragerea unui element din prima multime";
	cout<<"\n9) Testarea apartenentei unui element la prima multime";
	cout<<"\n10) Iesire\n";
	cout<<"\nDati optiunea:";
}

void submeniu2()
{   
	system("cls");
	cout<<"\n         TESTARE PE MULTIME DE PERSOANE \n";
	cout<<"\n1) Introducere elemente in cele doua multimi";
	cout<<"\n2) Sortarea celor doua multimi";
	cout<<"\n3) Testarea apartenentei primei multimi la cea de-a doua";
	cout<<"\n4) Reuniunea celor doua multimi";
	cout<<"\n5) Intersectia celor doua multimi";
	cout<<"\n6) Diferenta simetrica dintre cele doua multimi";
	cout<<"\n7) Adaugarea unui element in prima multime";
	cout<<"\n8) Extragerea unui element din prima multime";
	cout<<"\n9) Testarea apartenentei unui element la prima multime";
	cout<<"\n10) Iesire\n";
	cout<<"\nDati optiunea:";
}

void main()
{ 
	multime <int> t(20),x(20);
	int val;
	int i;
	int opt,opt1,opt2;

	multime <persoana> v1(6),v2(6);
	persoana val1;
	
	meniu();
	cin>>opt;

	while (opt!=3)
	{
		
		switch(opt)
		{
		 case 1: submeniu1();
				 cin>>opt1;
				 while (opt1!=10)
				 {
					 switch(opt1)
					 {
					 case 1:		
								system("cls");
								cin>>t;
								cout<<"Multimea este:\n";
								t.afisare();

								cin>>x;
								cout<<"Multimea este:\n";
								x.afisare();
								getch();
								break;

					 case 2:
								system("cls");
							/// SE SORTEAZA ELEMENTELE MULTIMII t SI SE AFISEAZA REZULTATUL ///
								t.sortare();
								cout<<"Multimea sortata este:\n";
								t.afisare();

	
							/// SE SORTEAZA ELEMENTELE MULTIMII x SI SE AFISEAZA REZULTATUL ///
								x.sortare();
								cout<<"Multimea sortata este:\n";
								x.afisare();
								getch();
								break;

					 case 3:   
							/// SE TESTEAZA APARTENENTA MULTIMII t LA MULTIMEA x ///
								(t<x);
								cout<<"\n\n\n\n\n";
								break;

					 case 4:
								system("cls");
							/// SE REUNESTE MULTIMEA t CU MULTIMEA x ///
								cout<<"\nCele doua multimi se reunesc !\n";
								cout<<"Multimea devine:\n";
								(t+x).afisare();
								getch();
								break;

					 case 5:	
								system("cls");
							/// SE INTERSECTEAZA MULTIMEA t CU MULTIMEA x ///
								cout<<"\nCele doua multimi se intersecteaza !\n";
								cout<<"Multimea devine:\n";
								(t*x).afisare();
								getch();
								break;

					 case 6:
								system("cls");
							/// SE FACE DIFERENTA SIMETRICA DINTRE MULTIMEA t SI MULTIMEA x ///
								cout<<"\nSe face diferenta celor doua multimi !\n";
								cout<<"Multimea devine:\n";
								(t-x).afisare();
								getch();
								break;

					 case 7:
								system("cls");
							/// SE ADAUGA ELEMENTUL val IN MULTIMEA t ///
								cout<<"\nDati elementul pe care doriti sa-l inserati in prima multime:";
								cin>>val;
								(t+val);
								cout<<"\nMultimea devine:\n";
								t.afisare();
								getch();
								break;

					 case 8:
								system("cls");
							/// SE EXTRAGE DIN MULTIMEA t ELEMENTUL DE PE POZITIA i ///
								cout<<"\nDati pozitia elementului pe care doriti sa-l stergeti din prima multime:";
								cin>>i;
								(t-i);
								cout<<"\nMultimea devine:\n";
								t.afisare();
								getch();
								break;

					 case 9:
								system("cls");
							/// SE VERIFICA APARTENENTA ELEMENTULUI val LA MULTIMEA t ///
								cout<<"\nDati elementul pe care doriti sa-l cautati in multime:";
								cin>>val;
								(t*val);
								cout<<"\n\n\n\n\n";
								break;

					 }

				system("cls");
				submeniu1();
				cin>>opt1;
				}
							
		break;

    case 2:
				submeniu2();
			    cin>>opt2;
				while (opt2!=10)
				{
				   switch(opt2)
					 {
					 case 1:	
								system("cls");
								cin>>v1;
								cout<<"\n Persoanele sunt:";
								v1.afisare();

								cin>>v2;
								cout<<"\n Persoanele sunt:";
								v2.afisare();
								getch();
								break;

					 case 2:
								system("cls");	
							/// SE SORTEAZA ELEMENTELE MULTIMII v1 SI SE AFISEAZA REZULTATUL ///
								v1.sortare();
								cout<<"\n\n  Persoanele sortate crescator sunt";
								v1.afisare();


							/// SE SORTEAZA ELEMENTELE MULTIMII v2 SI SE AFISEAZA REZULTATUL ///
								v2.sortare();
								cout<<"\n\n  Persoanele sortate crescator sunt";
								v2.afisare();
								getch();
								break;

					 case 3:
								system("cls");
						 	/// SE TESTEAZA APARTENENTA MULTIMII v1 LA MULTIMEA v2 ///
								(v1<v2);
								cout<<"\n\n\n\n\n";
								break;

					 case 4:
								system("cls");
						 	/// SE REUNESTE MULTIMEA v1 CU MULTIMEA v2 ///
								cout<<"\nCele doua multimi se reunesc !\n";
								cout<<"Multimea devine:\n";
								(v1+v2).afisare();
								getch();
								break;

					 case 5:
								system("cls");
	  					    /// SE INTERSECTEAZA MULTIMEA v1 CU MULTIMEA v2 ///
								cout<<"\nCele doua multimi se intersecteaza !\n";
								cout<<"Multimea devine:\n";
								(v1*v2).afisare();
								getch();
								break;

					 case 6:
								system("cls");
							/// SE FACE DIFERENTA SIMETRICA DINTRE MULTIMEA v1 SI MULTIMEA v2 ///
								cout<<"\nSe face diferenta celor doua multimi !\n";
								cout<<"Multimea devine:\n";
								(v1-v2).afisare();
								getch();
								break;

					 case 7:
								system("cls");
							/// SE ADAUGA ELEMENTUL val IN MULTIMEA v1 ///
								cout<<"\nDati elementul pe care doriti sa-l inserati in prima multime:";
								cin>>val1;
								(v1+val1);
								cout<<"\nMultimea devine:\n";
								v1.afisare();
								getch();
								break;

					 case 8:
								system("cls");
						 	/// SE EXTRAGE DIN MULTIMEA v1 ELEMENTUL DE PE POZITIA i ///
								cout<<"\nDati pozitia elementului pe care doriti sa-l stergeti din prima multime:";
								cin>>i;
								(v1-i);
								cout<<"\nMultimea devine:\n";
								v1.afisare();
								getch();
								break;

					 case 9:	
								system("cls");
							/// SE VERIFICA APARTENENTA ELEMENTULUI val LA MULTIMEA v1 ///
								cout<<"\nDati elementul pe care doriti sa-l cautati in multime:";
								cin>>val1;
								(v1*val1);
							    cout<<"\n\n\n\n\n";
								break;
				   }
				system("cls");
				submeniu2();
				cin>>opt2;
				}
		break;
		}
	system("cls");
	meniu();
	cin>>opt;
}
}