//Utilizzare l'ereditarietā  per realizzare una classe CodaPerPrimiGradiAlti che implementa una coda di prioritā di Marinai, in cui i marinai che entrano sono serviti in base al loro ruolo (da marinaio semplice ad ammiraglio) e, a paritā  di grado, nel consueto ordine (FIFO). 

enum GRADO { SEMPLICE=0,  
         MACCHINISTA,CAPITANO,
         AMMIRAGLIO};

class Marinaio
{
private:
  string nome;
  GRADO grado;
public:
  Marinaio(const string& s, GRADO g):nome(s),grado(g){}
  string getNome() const{return nome;}
  GRADO getGrado()const {return grado;}
  bool operator==(const
               Marinaio& M)
    { return (nome==M.nome && grado == M.grado); }
};

--------------------------------------------------------------

Utilizzare l'ereditarietā  per realizzare la classe CodaConFurbi che implementa una coda di persone in cui, dopo ogni estrazione, ogni furbo guadagna una posizione a scapito di chi (prima dell'estrazione) lo precede e non č furbo. Si supponga che la classe persona abbia un metodo che consenta di sapere se uno č furbo o meno. Note: Un furbo non supera un altro furbo; č possibile utilizzare le librerie STL. 

class Persona{
friend ostream& operator<<(ostream& o, const Persona& P)
   {
     o<<"Nome "<<P.getNome()<< "Furbo" << P.getFurbo()<<endl;
     return o;
   }
private:
    string nome;
    bool furbo;
public:
    Persona(const string & n, bool f):nome(n),furbo(f){}
    string getNome()const {return nome;}
    bool getFurbo() const{return furbo;}
};

----------------------------------------------------
SIMULAZIONE DI LABORATORIO DEL 20/5/2016

//FILE TriplaNumeri.h

#ifndef TriplaNumeri_H_
#define TriplaNumeri_H_

#include <iostream>
#include <string>

using namespace std;


    #include <algorithm>
    #include <cmath>
    #include <vector>
    
class TriplaNumeri
{
private:
    int num1;
    int num2;
    int num3;
    
public:
    TriplaNumeri(int _num1 = 0, int _num2 = 0, int _num3 = 0) : num1(_num1), num2(_num2), num3(_num3) {}

    int getNum1() const { return num1; }
    void setNum1(int v) { num1 = v; }

    int getNum2() const { return num2; }
    void setNum2(int v) { num2 = v; }

    int getNum3() const { return num3; }
    void setNum3(int v) { num3 = v; }

    

    bool operator==(const TriplaNumeri& right) const { return num1 == right.num1 && num2 == right.num2 && num3 == right.num3; }

friend ostream& operator<<(ostream& out, const TriplaNumeri& x) { return out << "[" << x.num1 << ", " << x.num2 << ", " << x.num3 << "]"; }
};

#endif
-----------------------------------------------
//FILE CalcolatriceAvanzata.h

#ifndef CalcolatriceAvanzata_H
#define CalcolatriceAvanzata_H

#include "TriplaNumeri.h"

#include <cstdlib>
#include <iostream>
#include <list>
#include <vector>

using namespace std;

/*
    Questa classe contiene una lista di triple di numeri. Ogni tripla e` caratterizzata dalle seguenti informazioni:

    - num1: il primo numero della tripla (int);

    - num2: il secondo numero della tripla (int);

    - num3: il terzo numero della tripla (int).
    
    Implementare nel file CalcolatriceAvanzata.cpp i metodi della classe CalcolatriceAvanzata.
    
*/
class CalcolatriceAvanzata   
{
private:
    list<TriplaNumeri> numeri;

public:
    // DESCRIZIONE NEL FILE .cpp
    int metodo1();

    // DESCRIZIONE NEL FILE .cpp
    int metodo2();

    // DESCRIZIONE NEL FILE .cpp
    int metodo3();

    // DESCRIZIONE NEL FILE .cpp
    int metodo4();
    
    inline bool aggiungi(TriplaNumeri c) {numeri.push_back(c); return true;}
    
};
#endif


--------------------------------------------------------
FILE CALCOLATRICE AVANZATA.cpp

#include "CalcolatriceAvanzata.h"

/*
Sia (A,B,C) la prima tripla nella lista e sia S=A+B+C.
Restituire il numero primo piu` grande tra i numeri primi minori di S.
Un numero P e` primo se e` > 1 ed e` divisibile solo per 1 e per P.

Se non sono presenti triple di numeri o se non esiste nessun primo minore di S, restituire -1.
            
*/
bool primo(int n)
{
  //Controllo Superfluo
  if(n<=1)
    return false;
  for(int i=2; i<=n/2; i++)
     if(n%i==0)
        return false;
  return true;
}

int CalcolatriceAvanzata::metodo1()
{
if(numeri.empty())
    return -1;
int S = numeri.front().getNum1()+numeri.front().getNum2()+numeri.front().getNum3();
for(int i = S-1; i>1; i--)
   if(primo(i))
      return i;
return -1;      
}

/*
Sia N il numero piu` grande  di cinque cifre costruibile concatenando cinque num1 della lista.
Sia M il numero piu` piccolo di cinque cifre costruibile concatenando cinque num2 della lista.
(Si assuma che num1 e num2 siano sempre compresi tra 0 e 9.)
Restituire N-M.

Se la lista ha meno di 5 elementi restituire -1.

Esempio:
Sia la lista di triple composta da (1,2,3) (2,3,4) (7,7,9) (4,5,3) (8,1,2) (1,1,1).
N = 87421
M = 11235
            
*/
int CalcolatriceAvanzata::metodo2()
{
   if(numeri.size()<5)
       return -1;
   list<int> LN;
   list<int> LM;
   for(list<TriplaNumeri>::const_iterator it = numeri.begin(); it!= numeri.end(); it++)
        {
         LN.push_back(it->getNum1());
         LM.push_back(it->getNum2());
        }
   LN.sort();
   LN.reverse();
   LM.sort();
   int N=0, M=0;
   list<int>::iterator itN=LN.begin();
   list<int>::iterator itM=LM.begin();
   for(unsigned i =0; i< 5; i++, itN++, itM++)
      {
       N=N*10+*itN;
       M=M*10+*itM;
      }
    return N-M;
   
}

/*
Sia LD la lista di triple duplicate.
Una tripla e` considerata duplicata se i primi due numeri sono uguali.
Sia M1 la media dei num1 degli elementi in LD.
Sia M2 la media dei num2 degli elementi in LD.
(Per le medie si usi la divisione intera.)
Restituire M1 - M2.

Se la lista e` vuota o non ha duplicati restituire -1.

Esempio:
(2,1,4) (2,1,6) (4,3,7) (4,3,7) (3,4,8) (5,6,2) (6,5,2)
Le triple duplicate sono (2,1,_) e (4,3,_).
La media dei num1 e` pari a 3.
La media dei num2 e` pari a 2.
Quindi il metodo deve restituire 1.
            
*/

bool duplicata(const TriplaNumeri& T, const list<TriplaNumeri>& N)
{
   int cont=0;
   for( list<TriplaNumeri>::const_iterator it=N.begin(); it!=N.end(); it++)
   {
      if(it->getNum1()==T.getNum1() && it->getNum2() == T.getNum2())
         cont++;
   }
   return (cont >1);
}

bool presente(const TriplaNumeri& T, const list<TriplaNumeri>& L)
{

   for( list<TriplaNumeri>::const_iterator it=L.begin(); it!=L.end(); it++)
      if(it->getNum1()==T.getNum1() && it->getNum2() == T.getNum2())
         return true;
   return false;
}

int CalcolatriceAvanzata::metodo3()
{
if(numeri.empty())
    return -1;
list<TriplaNumeri> L;
for(list<TriplaNumeri>::const_iterator it = numeri.begin(); it!= numeri.end(); it++)
   {
   if(duplicata(*it,numeri) && !presente(*it,L)) 
       L.push_back(*it);
   }
if(L.empty())
   return -1;
int M1=0;
int M2=0;
for( list<TriplaNumeri>::const_iterator it=L.begin(); it!=L.end(); it++)
    {
       M1+=it->getNum1();
       M2+=it->getNum2();
    } 
    M1/=L.size();
    M2/=L.size();
 return M1-M2;   
}

/*
Sia MAX il numero piu` grande  tra tutti i numeri presenti nella lista.
Sia MIN il numero piu` piccolo tra tutti i numeri presenti nella lista.

Restituire MAX - MIN se MAX e MIN     sono coprimi.
Restituire MIN - MAX se MAX e MIN non sono coprimi.

Si ricorda che due numeri N1 ed N2 sono coprimi se e solo se N1 e N2 non hanno alcun divisore comune eccetto 1 o -1.

Se la lista e` vuota restituire -1.
            
*/

//coprimi e coprimi2 sono 2 versioni alternative per verificare se due numeri sono coprimi.
bool coprimi(int MIN, int MAX)
{
for(int i =2; i<=MAX; i++)
   if(MIN%i==0 && MAX%i==0)
      return false;
      return true;

}
bool coprimi2(int MIN, int MAX)
{
   while(MIN!=0)
    {
        int R = MAX%MIN;
        MAX=MIN;
        MIN=R;
     }
return MAX==1;
}

int CalcolatriceAvanzata::metodo4()
{
if(numeri.empty())
    return -1;
    list<int> tutti;
   for(list<TriplaNumeri>::const_iterator it = numeri.begin(); it!= numeri.end(); it++)
       {
         tutti.push_back(it->getNum1());
         tutti.push_back(it->getNum2());
         tutti.push_back(it->getNum3());
       }
    tutti.sort();
    int MIN=tutti.front();
    int MAX=tutti.back();
    if(coprimi2(MIN,MAX))
       return MAX-MIN;
    return MIN-MAX;
}

----------------------------------------------------------
METODI AGGIUNTIVI
----------------------------------------------------------

Una tripla di numeri (num1,num2,num3) e` speciale se almeno uno tra num1, num2 e num3 e` un elemento della succ
essione di Fibonacci.
Restituire il numero di triple speciali.

Si ricorda che la successione di Fibonacci e` una successione di numeri interi positivi in cui ciascun numero e
` la somma dei due precedenti
e i primi due termini della successione sono 1 e 1.
Ad esempio, i primi numeri della successione di Fibonacci sono: 1,1,2,3,5,8,13,21...

Se non sono presenti triple di numeri, restituire -1.

--------------------------------------------------------------
Date due triple T1=(a1,a2,a3) e T2=(b1,b2,b3) il prodotto T1 tra T2 e` la tripla T3=(c1,c2,c3), dove:
c1 = a2*b3-a3*b2
c2 = a1*b3-a3*b1
c3 = a1*b2-a2*b1

Moltiplicare le prime due triple tra loro; moltiplicare il risultato ottenuto per la tripla successiva e cosi`
via fino alla fine delle triple.
Sia T=(t1,t2,t3) la tripla finale ottenuta, restituire t1+t2+t3.

Se la lista ha meno di 2 elementi restituire -1.

--------------------------------------------------------------
Per ogni tripla T=(num1,num2,num3) sia D il numero di divisori di num3 che sono anche numeri primi.
Restituire la somma di tutti i valori di D.

Si ricorda che un numero e` primo se e` > 1 ed e` divisibile solo per 1 e per se stesso.

Se la lista e` vuota restituire -1.

Esempio:
T1=(1,2,10).
T2=(7,3,9).
T3=(5,6,12).

I divisori di 10 sono: 1,2,5,10. D=2 (2 e 5 sono primi)
I divisori di 9 sono: 1,3,9. D=1 (3 e` primo)
I divisori di 12 sono: 1,2,3,4,6,12. D=2 (2 e 3 sono primi)

Quindi restituire 2+1+2.
----------------------------------------------------------
Una tripla T1=(a1,a2,a3) e` detta straordinaria se per ogni altra tripla T2=(b1,b2,b3) nella lista a1 < b1 opp
ure a2 < b2 oppure a3 < b3.
Restituire il numero di triple straordinarie.

Se la lista e` vuota restituire -1.