[OOP] 1. KOLOKVIJ - 21.11.2017. (A)

// 1. Kreirajte klasu koja predstavlja ventil.Svaki ventil može u sekundi propustiti određen
// maksimalan broj litara vode i biti otvoren određeni postotak.Pružiti konstruktore
// (podrazumijevani i parametarski).Pružiti javno sučelje za otvaranje i zatvaranje ventila u
// potpunosti, ali i postavljanje na određeni postotak.Kroz javno sučelje omogućiti provjeru
// trenutne otvorenosti ventila te provjeru maksimalnog protoka.Omogućiti usporedbu dvaju
// ventila, veći je onaj koji trenutno propušta veću količinu vode.Kao test klase potrebno je
// napraviti polje ventila s nasumično generiranim protokom u intervalu[1, 20] litara / sekundi i
// postotkom otvorenosti[0.0, 1.0].Ako ovo polje predstavlja sustav spojen na spremnik s
// tekućinom i kroz sve ventile se istovremeno pusti 8479 litara tekućine, napišite kod koji računa
// i ispisuje koliko dugo će trajati istjecanje tekućine.

#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

// ---------------------------------------

class Ventil {
    friend bool operator< (const Ventil&, const Ventil&);
    friend bool operator> (const Ventil&, const Ventil&);
private:
    double mKolicinaVode;
    double mOtvorenost;
public:
    Ventil();
    Ventil(double, double);
    void Otvori();
    void Zatvori();
    void setOtvorenost(double);
    int getProtok() const;
    double getOtvorenost() const;
};

// ---------------------------------------

Ventil::Ventil() : mKolicinaVode(0.0), mOtvorenost(0.0) {}

Ventil::Ventil(double KolicinaVode, double Otvorenost) : mKolicinaVode(KolicinaVode), mOtvorenost(Otvorenost) {}

void Ventil::Otvori() {
    mOtvorenost = 1.0;
}

void Ventil::Zatvori() {
    mOtvorenost = 0.0;
}

void Ventil::setOtvorenost(double postotak) {
    mOtvorenost = postotak;
}

int Ventil::getProtok() const {
    return mKolicinaVode * mOtvorenost;;
}

double Ventil::getOtvorenost() const {
    return mOtvorenost;
}

// ---------------------------------------

bool operator< (const Ventil& lhs, const Ventil& rhs) {
    return lhs.getProtok() < rhs.getProtok();
}

bool operator>(const Ventil& lhs, const Ventil& rhs) {
    return operator<(rhs, lhs);
}

// ---------------------------------------

double IstjecanjeTekucine(Ventil** polje, int n, int spremnik) {
    double zbroj = 0;
    for (int i = 0; i < n; i++) {
        zbroj += polje[i]->getProtok();
    }

    return spremnik / zbroj / 60;
}

// ---------------------------------------

int main() {
    std::srand((unsigned int)std::time(0));
    Ventil* polje[5];
    for (int i = 0; i < 5; i++) {
        double protok = 1 + (double)rand() * 19 / (double)RAND_MAX;
        double otvorenost = (double)rand() / (double)RAND_MAX;
        polje[i] = new Ventil(protok / otvorenost, otvorenost);
    }

    cout << IstjecanjeTekucine(polje, 5, 8479) << endl;

    for (int i = 0; i < 5; i++) {
        delete polje[i];
    }

    return 0;
}

// 2. Kreirajte klasu koja predstavlja bateriju, s maksimalnim kapacitetom i trenutno dostupnim
// kapacitetom u mAh.Definirajte podrazumijevani i parametarski konstruktor tako da svaka
// nova baterija dolazi potpuno napunjena.Omogućite dohvaćanje maksimalnog kapaciteta, te
// umanjenje trenutno dostupnog kapaciteta baterije za predanu vrijednost.Kroz javno sučelje
// klase omogućite računanje trenutnog stanja baterije u postotcima.Omogućite i provjeru je li
// bateriju potrebno puniti(jest ako je ispod 15 % ).Omogućite ispis baterije u obliku : cout <<
// battery; gdje je izlaz : „Battery : [max.kapacitet]mAh[posto] % remaining.“ Napišite prijateljsku
// funkciju koja računa vrijeme potrebno za punjenje baterije.Funkcija kao argument(uz druge
// nužne argumente) prima jakost struje punjača u miliAmperima, a vraća broj sati koji je
// potreban da se baterija napuni.Uzmite da je gubitak kod punjenja 20 % .U glavnoj funkciji
// kreirati bateriju, ispisati ju, isprazniti ju po volji i ispisati koliko će biti potrebno da se napuni.

#include <iostream>

using namespace std;

// ---------------------------------------

class Baterija {
    friend std::ostream& operator<< (std::ostream&, const Baterija&);
    friend double VrijemePunjenja(Baterija& , double);
private:
    double mMaxKapacitet;
    double mTrenutniKapacitet;
public:
    Baterija();
    Baterija(double);
    void Potrosnja(double);
    double getMaxKapacitet() const;
    int getPostotak() const;
    void Provjera() const;
};

// ---------------------------------------

Baterija::Baterija() : mMaxKapacitet(0.0), mTrenutniKapacitet(0.0) {}

Baterija::Baterija(double MaxKapacitet) : mMaxKapacitet(MaxKapacitet), mTrenutniKapacitet(MaxKapacitet) {}

void Baterija::Potrosnja(double kapacitet) {
    mTrenutniKapacitet -= kapacitet;

    if (mTrenutniKapacitet < 0) {
        mTrenutniKapacitet = 0;
    }
}

double Baterija::getMaxKapacitet() const {
    return mMaxKapacitet;
}

int Baterija::getPostotak() const {
    return (mTrenutniKapacitet / mMaxKapacitet) * 100;
}

void Baterija::Provjera() const {
    if (this->getPostotak() < 15) {
        cout << "Baterija prazna! Potrebno napuniti. Postotak: " << this->getPostotak() << "%" << endl;
    }
}

// ---------------------------------------

std::ostream& operator<< (std::ostream& OutputStream, const Baterija& rhs)
{
    OutputStream << "Battery: " << rhs.mTrenutniKapacitet << "mAh, " << rhs.getPostotak() << "% remaining.";
    return OutputStream;
}

// ---------------------------------------

double VrijemePunjenja(Baterija& baterija, double punjac) {
        return 1.2 * (baterija.mMaxKapacitet - baterija.mTrenutniKapacitet) / punjac;
}

// ---------------------------------------

int main() {
    Baterija N(3000);

    cout << N << endl;
    N.Potrosnja(2700);
    cout << N << endl;
    N.Provjera();
    cout << VrijemePunjenja(N, 2000) << " sati je potrebno da se baterija napuni." << endl;

    return 0;
}

// 3. Napišite klasu koja predstavlja lozinku i čuva ju u obliku stringa.Omogućiti kreiranje lozinke
// parametarskim konstruktorom, usporedbu jednakosti dviju lozinki te metodu koja sadržaj
// lozinke vraća u obliku stringa, ali skrivenog sadržaja(npr: "****", gdje broj zvjezdica odgovara
// duljini lozinke).Kreirajte sučelje(interface) koje sadrži metodu za generiranje objekta lozinke
// na temelju predanog stringa.Kreirajte konkretnu klasu koja implementira ranije sučelje, a
// predstavlja generator zasoljene lozinke s atributom za potreban broj znakova za soljenje.
// Omogućiti njegovo postavljanje kod stvaranja objekta.Lozinka se "soli" tako da se na kraj
// njenog sadržaja dodaju nasumični znakovi(u rasponu 'a' - 'z').Kao test klase potrebno je
// napraviti jedan objekt klase lozinka parametarskim konstruktorom te drugi objekt korištenjem
// konkretnog generatora preko pokazivača koji je tipa sučelja i stringa koji je unesen s konzole.
// Ako su dvije kreirane lozinke jednake, potrebno je zapisati jednu od njih u obliku skrivenog
// stringa u tekstualnu datoteku s vašim prezimenom.

#include <iostream>
#include <fstream>
#include <cstdlib>
#include <ctime>
#include <string>

using namespace std;

// ---------------------------------------

class Password {
    friend bool operator== (const Password&, const Password&);
private:
    string mPass;
public:
    Password(string);
    string toString() const;
};

// ---------------------------------------

Password::Password(string Pass) : mPass(Pass) {}

string Password::toString() const {
    return string(mPass.length(), '*');
}

// ---------------------------------------

bool operator== (const Password& lhs, const Password& rhs)
{
    return lhs.mPass == rhs.mPass;
}

// ---------------------------------------

class IGenerator {
public:
    virtual Password& GeneratePassword(string) = 0;
};

// ---------------------------------------

class PasswordGenerator : public IGenerator {
private:
    int mSol;
public:
    PasswordGenerator(int);
    virtual Password& GeneratePassword(string);
};

// ---------------------------------------

PasswordGenerator::PasswordGenerator(int Sol) : mSol(Sol) {}

Password& PasswordGenerator::GeneratePassword(string password) {
    std::srand((unsigned int)std::time(0));
    Password *pass = new Password(password + string(mSol, 'a' + rand() * ('z' - 'a')  / RAND_MAX));

    return *pass;
}

// ---------------------------------------

int main() {
    Password A("kolokviji");

    IGenerator *p = new PasswordGenerator(5);
    string str;
    getline(cin, str);
    Password B = p->GeneratePassword(str);

    if (A == B) {
        ofstream output("prezime.txt");
        output << A.toString() << "\n";
        output.close();
    }

    return 0;
}