2.1 VozackaKat.-Rjesenje

#include<iostream>
#include <tuple>
using namespace std;
/*
1. BROJ I VRSTA PARAMETARA MORAJU BITI IDENTICNI KAO U PRIMJERIMA. U SUPROTNOM SE RAD NECE BODOVATI
2. STAVITE KOMENTAR NA DIJELOVE CODE-A KOJE NE BUDETE IMPLEMENTIRALI
3. KREIRAJTE .DOC FAJL SA VAŠIM BROJEM INDEKSA ( NPR. IB160061.DOC BEZ IMENA I PREZIMENA), TE NA KRAJU ISPITA U NJEGA KOPIRAJTE RJEŠENJA VAŠIH ZADATAKA. NE PREDAVATI .TXT ILI .CPP FAJLOVE
4. TOKOM IZRADE ISPITA NIJE DOZVOLJENO KORIŠTENJE HELP-A
5. TOKOM IZRADE ISPITA MOGU BITI POKRENUTA SAMO TRI PROGRAMA: PDF READER (ISPITNI ZADACI), MS VISUAL STUDIO, MS WORD (U KOJI CETE KOPIRATI VAŠA RJEŠENJA)
6. BEZ OBZIRA NA TO DA LI SU ISPITNI ZADACI URAÐENI, SVI STUDENTI KOJI SU PRISTUPILI ISPITU MORAJU PREDATI SVOJ RAD
*/
//narednu liniju code-a ignorisite, osim u slucaju da vam bude predstavljala smetnje u radu
#pragma warning(disable:4996)


enum VrstaAktivnosti { Poligon, Gradska, Nocna, Parkiranje };
const char * vrstaAktivnostiChar[] = { "Poligon", "Gradska", "Nocna", "Parkiranje" };

enum Kategorija { A, B, C, D, E };
const char * kategorijaChar[] = { "A", "B", "C", "D", "E" };
const int maxKategorija = 5;

struct Datum {
    int * _dan, *_mjesec, *_godina;
    void Unos(int d, int m, int g) {
        _dan = new int(d);
        _mjesec = new int(m);
        _godina = new int(g);
    }
    void Ispis()
    {
        cout << *_dan << "/" << *_mjesec << "/" << *_godina << endl;
    }
    void Dealociraj()
    {
        if (_dan != nullptr && _mjesec != nullptr && _godina != nullptr)
        {
            delete _dan;
            _dan = nullptr;

            delete _mjesec;
            _mjesec = nullptr;

            delete _godina;
            _godina = nullptr;
        }
    }
};
bool istiDatum(Datum datumIzvrsenja, Datum datumPolaganja)
{
    if (*datumIzvrsenja._dan == *datumPolaganja._dan && *datumIzvrsenja._mjesec == *datumPolaganja._mjesec && *datumIzvrsenja._godina == *datumPolaganja._godina)
        return true;
    return false;
}

bool min30Dana(Datum _datumIzvrsenja, Datum datumPolaganja)
{
    int dani_datumIzvrsenja = *_datumIzvrsenja._dan + (*_datumIzvrsenja._mjesec * 30) + (*_datumIzvrsenja._godina * 365);
    int dani_datumPolaganja = *datumPolaganja._dan + (*datumPolaganja._mjesec * 30) + (*datumPolaganja._godina * 365);
    int rezultat = dani_datumPolaganja - dani_datumIzvrsenja;

    if (rezultat >= 30)
        return true;
    return false;
}
struct Aktivnost {
    unique_ptr<VrstaAktivnosti> _vrsta;
    Datum _datumIzvrsenja;
    char * _komentar;
    int _ocjena; // 1 - 5
    void Unos(VrstaAktivnosti vrsta, Datum * datum, int ocjena, const char * komentar)
    {
        _vrsta = make_unique<VrstaAktivnosti>(vrsta);
        _datumIzvrsenja.Unos(*datum->_dan, *datum->_mjesec, *datum->_godina);
        _ocjena = ocjena;
        int size = strlen(komentar) + 1;
        _komentar = new char[size];
        strcpy_s(_komentar, size, komentar);
    }
    void Ispis() {
        cout << *_vrsta << " " << _ocjena << " " << _komentar;
        _datumIzvrsenja.Ispis();
        cout << endl;
    }
    void Dealociraj()
    {
        if (_datumIzvrsenja._dan != nullptr && _datumIzvrsenja._mjesec != nullptr && _datumIzvrsenja._godina != nullptr)
        {
            _datumIzvrsenja.Dealociraj();
        }

        delete[] _komentar; _komentar = nullptr;

        _vrsta.reset();
    }
};
struct VozackaKategorija {
    Datum * _datumPolaganja;//datum koji ce se evidentirati kao datum polaganja kategorije tj. kada su ispunjene sve aktivnosti/obaveze
    Kategorija _kategorija;
    Aktivnost * _listaIzvrsenihAktivnosti;
    int _trenutnoIzvrsenihAktivnosti;
    void Unos(Kategorija kategorija) {
        _listaIzvrsenihAktivnosti = nullptr;
        _trenutnoIzvrsenihAktivnosti = 0;
        _datumPolaganja = nullptr;
        _kategorija = kategorija;
    }
    void Dealociraj() {
        if (_datumPolaganja != nullptr)
        {
            _datumPolaganja->Dealociraj();
            delete[] _datumPolaganja;
            _datumPolaganja = nullptr;
        }

        if (_listaIzvrsenihAktivnosti != nullptr)
        {
            for (size_t i = 0; i < _trenutnoIzvrsenihAktivnosti; i++)
            {
                _listaIzvrsenihAktivnosti[i].Dealociraj();
            }
        }

        delete[] _listaIzvrsenihAktivnosti;
        _listaIzvrsenihAktivnosti = nullptr;
    }
    void Ispis() {
        if (_datumPolaganja != nullptr)
            _datumPolaganja->Ispis();
        cout << _kategorija << endl;
        for (size_t i = 0; i < _trenutnoIzvrsenihAktivnosti; i++)
            _listaIzvrsenihAktivnosti[i].Ispis();
    }

    /*Na osnovu vrijednosti primljenog parametra osigurati dodavanje novoizvrsene aktivnosti za potrebe stjecanja odredjene vozacke kategorije.
    Broj aktivnosti nije ogranicen.

    Identicna aktivnost se moze dodati jedino u slucaju kada je prethodna (identivna aktivnost po vrsti i datumu izvrsenja) imala ocjenu manju od 3.

    Uspjesnom aktivnoscu se smatraju one aktivnosti koje imaju ocjenu vecu od 2,

    a svaka naredna identicna aktivnost, bez obzira da li je uspjesna ili ne, moze biti dodana jedino ako je proslo najmanje 30 dana od izvrsenja prethodne.

    Onemoguciti dodavanje aktivnosti uspjesno polozenoj kategoriji.*/
    bool DodajIzvrsenuAktivnost(VrstaAktivnosti vrsta, Datum * datumPolaganja, int ocjena, const char * napomena)
    {
        if (_datumPolaganja != nullptr)
        {
            return false;
        }

        for (int i = 0; i < _trenutnoIzvrsenihAktivnosti; i++)
        {
            if (*_listaIzvrsenihAktivnosti[i]._vrsta == vrsta && istiDatum(_listaIzvrsenihAktivnosti[i]._datumIzvrsenja, *datumPolaganja)) //je li se radi o identicnoj aktivnosti
            {
                if (!_listaIzvrsenihAktivnosti[i]._ocjena < 3) // je li nadjena identicna aktivnost imala ocjenu manju od 3
                {
                    return false;
                }
            }
            if (*_listaIzvrsenihAktivnosti[i]._vrsta == vrsta)
            {
                if (!min30Dana(_listaIzvrsenihAktivnosti[i]._datumIzvrsenja, *datumPolaganja))
                {
                    return false;
                }
            }
        }


        //dodaj

        Aktivnost * temp = new Aktivnost[_trenutnoIzvrsenihAktivnosti + 1];
        for (int i = 0; i < _trenutnoIzvrsenihAktivnosti; i++)
        {
            temp[i].Unos(*_listaIzvrsenihAktivnosti[i]._vrsta, &_listaIzvrsenihAktivnosti[i]._datumIzvrsenja,
                _listaIzvrsenihAktivnosti[i]._ocjena, _listaIzvrsenihAktivnosti[i]._komentar);
        }
        temp[_trenutnoIzvrsenihAktivnosti].Unos(vrsta, datumPolaganja, ocjena, napomena);
        for (int i = 0; i < _trenutnoIzvrsenihAktivnosti; i++)
        {
            _listaIzvrsenihAktivnosti[i].Dealociraj();
        }
        delete[] _listaIzvrsenihAktivnosti;
        _listaIzvrsenihAktivnosti = temp;
        _trenutnoIzvrsenihAktivnosti++;
        return true;
    }

    //koristeci neki od obradjenih algoritama, po ocjeni sortirati aktivnosti u okviru odredjene kategorije
    void Sortiraj()
    {
        int minI;
        for (int i = 0; i < _trenutnoIzvrsenihAktivnosti; i++)
        {
            minI = i;
            for (int j = i + 1; j < _trenutnoIzvrsenihAktivnosti; j++)
            {
                if (_listaIzvrsenihAktivnosti[j]._ocjena < _listaIzvrsenihAktivnosti[minI]._ocjena)
                    minI = j;
            }
            swap(_listaIzvrsenihAktivnosti[i], _listaIzvrsenihAktivnosti[minI]);
            cout << "Soritano: " << _listaIzvrsenihAktivnosti[i]._ocjena << endl;
        }
    }
    /*Stjecanje kategorije zahtijeva uspjesnu realizaciju svih planiranih aktivnosti, a one se za jedan povecavaju sa svakom novom kategorijom, npr.
A: 1 x poligon, 1 x gradska, 1 x nocna, 1 x parkiranje;
B: 2 x poligon, 2 x gradska, 2 x nocna, 2 x parkiranje; i td...

Funkcija vraca false u slucaju da:
su kandidatu u listu aktivnosti evidentirane tri negativno ocijenjene identicne vrste aktivnosti
(npr. tri negativne ocjene iz gradske voznje), onda se ta kategorija ne moze smatrati uspjesno polozenom

,te ukoliko nedostaje bilo koja od aktivnosti zahtijevanih u okviru te kategorije.

Ukoliko je kandidat uspjesno realizovao sve aktivnost, datum polaganja se postavlja na datum posljednje uspjesno realizovane aktivnosti*/
    bool DaLiJePolozena()
    {
        int brojacNegativnihOcjenaPoligon = 0;
        int brojacNegativnihOcjenaGradska = 0;
        int brojacNegativnihOcjenaNocna = 0;
        int brojacNegativnihOcjenaParkiranje = 0;
        Datum datumPolaganja;
        for (int i = 0; i < _trenutnoIzvrsenihAktivnosti; i++)
        {
            if (*_listaIzvrsenihAktivnosti[i]._vrsta == Poligon && _listaIzvrsenihAktivnosti[i]._ocjena <= 2)
                brojacNegativnihOcjenaPoligon++;
            if (*_listaIzvrsenihAktivnosti[i]._vrsta == Gradska && _listaIzvrsenihAktivnosti[i]._ocjena <= 2)
                brojacNegativnihOcjenaGradska++;
            if (*_listaIzvrsenihAktivnosti[i]._vrsta == Nocna && _listaIzvrsenihAktivnosti[i]._ocjena <= 2)
                brojacNegativnihOcjenaNocna++;
            if (*_listaIzvrsenihAktivnosti[i]._vrsta == Parkiranje && _listaIzvrsenihAktivnosti[i]._ocjena <= 2)
                brojacNegativnihOcjenaParkiranje++;

            datumPolaganja = _listaIzvrsenihAktivnosti[i]._datumIzvrsenja;
        }
        if (brojacNegativnihOcjenaPoligon >= 3 || brojacNegativnihOcjenaPoligon == 0)
        {
            return false;
        }
        if (brojacNegativnihOcjenaGradska >= 3 || brojacNegativnihOcjenaGradska == 0)
        {
            return false;
        }
        if (brojacNegativnihOcjenaNocna >= 3 || brojacNegativnihOcjenaNocna == 0)
        {
            return false;
        }
        if (brojacNegativnihOcjenaParkiranje >= 3 || brojacNegativnihOcjenaParkiranje == 0)
        {
            return false;
        }
        _datumPolaganja = new Datum;
        _datumPolaganja->Unos(*datumPolaganja._dan, *datumPolaganja._mjesec, *datumPolaganja._godina);
        return true;
    }

    /*Funkcija vraca prosjecnu ocjenu svih uspjesno realizovanih aktivnosti koja u nazivu ili opisu sadrze vrijednost primljenog parametra.
    Ukoliko smatrate da je potrebno, mozete dodati i druge parametre za potrebe implementacije ove funkcije*/
    float PretragaRekrzivno(const char * napomena, int &suma, int & brojac, int &i, float & prosjek)
    {
        if (i == _trenutnoIzvrsenihAktivnosti)
        {
            if (brojac == 0)
                return 0;
            else
            {
                prosjek = suma / brojac;
                return prosjek;
            }
        }
        else
        {
            if ((strstr(_listaIzvrsenihAktivnosti[i]._komentar, napomena) != nullptr) && (_listaIzvrsenihAktivnosti[i]._ocjena > 2))
            {
                suma += _listaIzvrsenihAktivnosti[i]._ocjena;
                brojac++;
            }
        }
        i++;
        return PretragaRekrzivno(napomena, suma, brojac, i, prosjek);
    }
};

struct Kandidat {
    char * _imePrezime;
    shared_ptr<VozackaKategorija> _kategorije[maxKategorija];
    int _trenutnoKategorija;
    void Unos(const char * imePrezime) {
        int size = strlen(imePrezime) + 1;
        _imePrezime = new char[size];
        strcpy_s(_imePrezime, size, imePrezime);
        _trenutnoKategorija = 0;
    }
    void Dealociraj() {
        if (_imePrezime != nullptr)
        {
            delete[] _imePrezime; _imePrezime = nullptr;
        }
        for (size_t i = 0; i < _trenutnoKategorija; i++)
        {
            //_kategorije[i].reset();

            if (_kategorije[i] != nullptr)
            {
                _kategorije[i]->Dealociraj();
            }
        }
    }
    void Ispis() {
        cout << _imePrezime << endl;
        for (size_t i = 0; i < _trenutnoKategorija; i++)
            _kategorije[i]->Ispis();
    }
    /*
    Pretpostavka je da se kategorije moraju polagati po redoslijedu tj. ne smije se dozvoliti dodavanje kategorije C ukoliko prethodno nisu uspjesno
    polozene kategorije B i C. Za provjeru ispunjenosti preduslova dodavanja nove kategorije, unutar funkcije DodajKategoriju, kreirati lambda funkciju.
    */
    bool DodajKategoriju(VozackaKategorija kategorija)
    {
        auto lambda = [&]()
        {
            int rezultat = 0;
            if (_trenutnoKategorija == 0)
            {
                return true;
            }
            else
            {
                //ne valja racunanje prethodnih kategorija
                for (int i = 0; i < _trenutnoKategorija; i++)
                {
                    rezultat += _kategorije[i]->_kategorija + 1;
                }
                if (rezultat < kategorija._kategorija + 1)
                {
                    return false;
                }
                return true;
            }
        };
        if (lambda() == true)
        {
            //dodaj kategoriju
            _kategorije[_trenutnoKategorija] = make_shared<VozackaKategorija>();
            _kategorije[_trenutnoKategorija]->Unos(kategorija._kategorija);
            _kategorije[_trenutnoKategorija]->_datumPolaganja = new Datum();
            if (kategorija._datumPolaganja != nullptr)
            {
                _kategorije[_trenutnoKategorija]->_datumPolaganja->Unos(*kategorija._datumPolaganja->_dan, *kategorija._datumPolaganja->_mjesec,
                    *kategorija._datumPolaganja->_godina);
            }
            if (kategorija._datumPolaganja != nullptr)
            {
                kategorija._datumPolaganja->Dealociraj();
                delete[] kategorija._datumPolaganja;
                kategorija._datumPolaganja = nullptr;
            }
            _kategorije[_trenutnoKategorija]->_trenutnoIzvrsenihAktivnosti = kategorija._trenutnoIzvrsenihAktivnosti;
            _kategorije[_trenutnoKategorija]->_listaIzvrsenihAktivnosti = new Aktivnost[_kategorije[_trenutnoKategorija]->_trenutnoIzvrsenihAktivnosti];
            for (int i = 0; i < _kategorije[_trenutnoKategorija]->_trenutnoIzvrsenihAktivnosti; i++)
            {
                _kategorije[_trenutnoKategorija]->_listaIzvrsenihAktivnosti->Unos(*kategorija._listaIzvrsenihAktivnosti[i]._vrsta,
                    &kategorija._listaIzvrsenihAktivnosti[i]._datumIzvrsenja,
                    kategorija._listaIzvrsenihAktivnosti[i]._ocjena, kategorija._listaIzvrsenihAktivnosti[i]._komentar);
            }
             _trenutnoKategorija++;
            return true;
        }
        return false;
    }

    //Funkcija GetNajboljuKategoriju  vraca par koji sadrzi oznaku i prosjecnu ocjenu (uspjesno okoncanih aktivnosti) kategorije sa najvecim prosjekom
    pair <Kategorija, float> GetNajboljuKategoriju()
    {
        float prosjek = 0;
        Kategorija kategorija;
        int suma = 0;
        int brojacUspkesnihOcjena = 0;
        float maxProsjek = 0;
        pair <Kategorija, float> rezultat;

        for (int i = 0; i < _trenutnoKategorija; i++)
        {
            for (int j = 0; j < _kategorije[i]->_trenutnoIzvrsenihAktivnosti; j++)
            {
                if (_kategorije[i]->_listaIzvrsenihAktivnosti[j]._ocjena > 2)
                {
                    brojacUspkesnihOcjena++;
                    suma += _kategorije[i]->_listaIzvrsenihAktivnosti[j]._ocjena;
                }
            }
            prosjek = suma / brojacUspkesnihOcjena;
            if (maxProsjek < prosjek)
            {
                maxProsjek = prosjek;
                kategorija = _kategorije[i]->_kategorija;
            }
        }
        rezultat = make_pair(kategorija, maxProsjek);
        return rezultat;
    }
};

void main() {

    //BROJ I VRSTA PARAMETARA MORAJU BITI IDENTICNI KAO U PRIMJERIMA
    //STAVITE KOMENTAR NA DIJELOVE CODE-A KOJE NE BUDETE IMPLEMENTIRALI
    Datum datumPolaganja1, datumPolaganja2, datumPolaganja3, datumPolaganja4;
    datumPolaganja1.Unos(10, 6, 2018);
    datumPolaganja2.Unos(18, 6, 2018);
    datumPolaganja3.Unos(22, 3, 2018);
    datumPolaganja4.Unos(28, 7, 2018);

    VozackaKategorija kategorijaA, kategorijaB, kategorijaC;
    kategorijaA.Unos(A);

    /*Na osnovu vrijednosti primljenog parametra osigurati dodavanje novoizvrsene aktivnosti za potrebe stjecanja odredjene vozacke kategorije. Broj aktivnosti nije ogranicen.
    Identicna aktivnost se moze dodati jedino u slucaju kada je prethodna (identivna aktivnost po vrsti i datumu izvrsenja) imala ocjenu manju od 3.
    Uspjesnom aktivnoscu se smatraju one aktivnosti koje imaju ocjenu vecu od 2, a svaka naredna identicna aktivnost, bez obzira da li je uspjesna ili ne,
    moze biti dodana jedino ako je proslo najmanje 30 dana od izvrsenja prethodne. Onemoguciti dodavanje aktivnosti uspjesno polozenoj kategoriji.*/
    if (kategorijaA.DodajIzvrsenuAktivnost(Poligon, &datumPolaganja1, 3, "izuzetno dobra orijentacija"))
        cout << "Aktivnost uspjesno dodana!" << endl;
    if (kategorijaA.DodajIzvrsenuAktivnost(Gradska, &datumPolaganja1, 2, "nesigurnost u raskrsnicama"))
        cout << "Aktivnost uspjesno dodana!" << endl;
    if (kategorijaA.DodajIzvrsenuAktivnost(Gradska, &datumPolaganja2, 4, "raskrsnice savladane"))//datum?
        cout << "Aktivnost uspjesno dodana!" << endl;
    if (kategorijaA.DodajIzvrsenuAktivnost(Gradska, &datumPolaganja4, 4, "raskrsnice savladane"))
        cout << "Aktivnost uspjesno dodana!" << endl;


    //koristeci neki od obradjenih algoritama, po ocjeni sortirati aktivnosti u okviru odredjene kategorije
    kategorijaA.Sortiraj();


    /*Stjecanje kategorije zahtijeva uspjesnu realizaciju svih planiranih aktivnosti, a one se za jedan povecavaju sa svakom novom kategorijom, npr.
    A: 1 x poligon, 1 x gradska, 1 x nocna, 1 x parkiranje;
    B: 2 x poligon, 2 x gradska, 2 x nocna, 2 x parkiranje; i td...
    Funkcija vraca false u slucaju da: su kandidatu u listu aktivnosti evidentirane tri negativno ocijenjene identicne vrste aktivnosti
    (npr. tri negativne ocjene iz gradske voznje), onda se ta kategorija ne moze smatrati uspjesno polozenom
    ,te ukoliko nedostaje bilo koja od aktivnosti zahtijevanih u okviru te kategorije. Ukoliko je kandidat uspjesno realizovao sve aktivnost,
    datum polaganja se postavlja na datum posljednje uspjesno realizovane aktivnosti*/
    if (kategorijaA.DaLiJePolozena())
        kategorijaA.Ispis();

    /*Funkcija vraca prosjecnu ocjenu svih uspjesno realizovanih aktivnosti koja u nazivu ili opisu sadrze vrijednost primljenog parametra.
    Ukoliko smatrate da je potrebno, mozete dodati i druge parametre za potrebe implementacije ove funkcije*/
    int suma = 0, brojac = 0, i = 0;
    float prosjek1 = 0;
    cout << "Prosjecna ocjena za kategoriju A -> " << kategorijaA.PretragaRekrzivno("nesigurno", suma, brojac, i, prosjek1) << endl;

    //ispisuje sve dostupne podatke o kategoriji
    kategorijaA.Ispis();

    Kandidat jasmin;
    jasmin.Unos("Jasmin Azemovic");

    /*
    Pretpostavka je da se kategorije moraju polagati po redoslijedu tj. ne smije se dozvoliti dodavanje kategorije C ukoliko prethodno nisu uspjesno
    polozene kategorije B i C. Za provjeru ispunjenosti preduslova dodavanja nove kategorije, unutar funkcije DodajKategoriju, kreirati lambda funkciju.
    */
    kategorijaC.Unos(C);
    kategorijaB.Unos(B);
    if (jasmin.DodajKategoriju(kategorijaA))
        cout << "Kategorija uspjesno dodan!" << endl;
    if (jasmin.DodajKategoriju(kategorijaC))
        cout << "Kategorija uspjesno dodan!" << endl;
    if (jasmin.DodajKategoriju(kategorijaB))
        cout << "Kategorija uspjesno dodan!" << endl;

    float prosjek = 0;
    Kategorija kategorija;
    //Funkcija GetNajboljuKategoriju  vraca par koji sadrzi oznaku i prosjecnu ocjenu (uspjesno okoncanih aktivnosti) kategorije sa najvecim prosjekom
    tie(kategorija, prosjek) = jasmin.GetNajboljuKategoriju();
    cout << "Najbolji rezultat od " << prosjek << " je ostvaren tokom polaganja kategorije " << kategorija << endl;


    datumPolaganja1.Dealociraj(), datumPolaganja2.Dealociraj(), datumPolaganja3.Dealociraj(), datumPolaganja4.Dealociraj();
    kategorijaA.Dealociraj(), kategorijaB.Dealociraj(), kategorijaC.Dealociraj();
    jasmin.Dealociraj();

    system("pause");
}