Treceți la conținutul principal

bilete cpp

// 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;
}
}

Comentarii

Postări populare de pe acest blog

program principal cpp

#include "clasa.h" #include <stdio.h> #include <conio.h> #include <stdlib.h> #include <string.h> #define DELAY 9000000 void delay() { for(long i=0;i<DELAY;i++); } //constructor cu initializare de la tastatura BigInt::BigInt() {char x; signed char t[400]; int i; printf("\nNumarul cu semn "); do s=getche(); while((s!='+')&&(s!='-')); n=0; do {x=getche(); t[n]=x-'0'; n++; } while((x>='0')&&(x<='9')); n--; for(i=0;i<n;i++) nr[i]=t[n-i-1]; } //constructor cu initializare prin parametri BigInt::BigInt(char semn,signed char numar[],int dim) {int i; s=semn; n=dim; for(i=0;i<n;i++) nr[i]=numar[n-i-1]; } //transform un int negativ in pozitiv int BigInt::Pozitiv(int x) {int a,vb; a=0; vb=0; while(vb==0) if((x+a)==0) vb=1; else a=a+1; x=a; return x; } //constructor dintr-un nr int obisnuit BigInt::BigInt(int x) {int i; if(x>=0) s='+'…

NUMERE PRIME ALGORITM C++

// NUMERE PRIME ALGORITM C++//  reediting from scratch //on this page is just the study for a next algoritm for generating the parime nr series like Fibonnaci or ....if possibile

74111121313417374414124343447 if u know the red part you can generate the orange part
1 0 1 111112222 1 1 23

o aplicatie php localitati romania

//APLICATIA SE REFERA LA BAZA DE DATE SIRUTA

//dragtable.js


/* dragtable v1.0 June 26, 2008 Dan Vanderkam, http://danvk.org/dragtable/ http://code.google.com/p/dragtable/ \Bsortabledraggable\B Instructions: - Download this file - Add <script src="dragtable.js"></script> to your HTML. - Add class="draggable" to any table you might like to reorder. - Drag the headers around to reorder them. This is code was based on: - Stuart Langridge's SortTable (kryogenix.org/code/browser/sorttable) - Mike Hall's draggable class (http://www.brainjar.com/dhtml/drag/) - A discussion of permuting table columns on comp.lang.javascript Licensed under the MIT license. */ // Here's the notice from Mike Hall's draggable script: //***************************************************************************** // Do not remove this notice. // // Copyright 2001 by Mike Hall. // See http…