Трећа вежба¶

#include <random>

#include "EksponencijalnaFunkcija.h"
#include "Funkcija.h"
#include "KvadratnaFunkcija.h"

int main() {
    auto funkcije = new Funkcija*[2019];

    std::random_device rd;
    std::mt19937 mt(rd());
    std::uniform_real_distribution<double> dist(-100, 100);

    int i = 0;
    for (int j = 0; j < 673; j++) {
        funkcije[i++] = new Funkcija(dist(mt), dist(mt));
        funkcije[i++] = new KvadratnaFunkcija(dist(mt), dist(mt));
        funkcije[i++] = new EksponencijalnaFunkcija(dist(mt), dist(mt));
    }

    i = 0;
    for (int j = 1; j < 2019; j++) {
        if (funkcije[j]->Calculate(12) < funkcije[i]->Calculate(12)) {
            i = j;
        }
    }

    funkcije[i]->PrikaziFunkciju();

    delete[] funkcije;

    return 0;
}

#ifndef FUNKCIJA_H
#define FUNKCIJA_H


class Funkcija {
protected:
    double k, n;
    char* naziv;

public:
    Funkcija();

    Funkcija(double k, double n);

    virtual double Calculate(double x);

    virtual ~Funkcija();

    virtual void PrikaziFunkciju();
};


#endif

#include "Funkcija.h"

#include <iostream>

Funkcija::Funkcija() {
    k = 1;
    n = 0;
    naziv = new char[]{"Linearna funkcija"};
}

Funkcija::Funkcija(double k, double n) {
    this->k = k;
    this->n = n;
    naziv = new char[]{"Linearna funkcija"};
}

double Funkcija::Calculate(double x) {
    return k * x + n;
}

Funkcija::~Funkcija() {
    delete[] naziv;
}

void Funkcija::PrikaziFunkciju() {
    std::cout << naziv << ": " << k << "x + " << n << std::endl;
}

#ifndef KVADRATNAFUNKCIJA_H
#define KVADRATNAFUNKCIJA_H
#include "Funkcija.h"


class KvadratnaFunkcija : public Funkcija {
public:
    KvadratnaFunkcija();

    KvadratnaFunkcija(double k, double n);

    double Calculate(double x) override;

    void PrikaziFunkciju() override;

    ~KvadratnaFunkcija() override;
};


#endif

#include "KvadratnaFunkcija.h"

#include <cmath>
#include <iostream>

KvadratnaFunkcija::KvadratnaFunkcija() {
    naziv = new char[]{"Kvadratna funkcija"};
}

KvadratnaFunkcija::KvadratnaFunkcija(double k, double n) : Funkcija(k, n) {
    naziv = new char[]{"Kvadratna funkcija"};
}

double KvadratnaFunkcija::Calculate(double x) {
    return std::pow(x + n, k);
}

void KvadratnaFunkcija::PrikaziFunkciju() {
    std::cout << naziv << ": (x + " << n << ")^" << k << std::endl;
}

KvadratnaFunkcija::~KvadratnaFunkcija() {
    delete[] naziv;
}

#ifndef EKSPONENCIJALNAFUNKCIJA_H
#define EKSPONENCIJALNAFUNKCIJA_H
#include "Funkcija.h"


class EksponencijalnaFunkcija : public Funkcija {
public:
    EksponencijalnaFunkcija();

    EksponencijalnaFunkcija(double k, double n);

    double Calculate(double x) override;

    void PrikaziFunkciju() override;

    ~EksponencijalnaFunkcija() override;
};


#endif

#include "EksponencijalnaFunkcija.h"

#include <cmath>
#include <iostream>

EksponencijalnaFunkcija::EksponencijalnaFunkcija() {
    naziv = new char[]{"Eksponencijalna funkcija"};
}

EksponencijalnaFunkcija::EksponencijalnaFunkcija(double k, double n) : Funkcija(k, n) {
    naziv = new char[]{"Eksponencijalna funkcija"};
}

double EksponencijalnaFunkcija::Calculate(double x) {
    return std::pow(k, x + n);
}

void EksponencijalnaFunkcija::PrikaziFunkciju() {
    std::cout << naziv << ": " << k << "^(x + " << n << ")" << std::endl;
}

EksponencijalnaFunkcija::~EksponencijalnaFunkcija() {
    delete[] naziv;
}

#include <fstream>
#include <random>

#include "Figura.h"
#include "Kvadrat.h"
#include "Pravougaonik.h"

int main() {
    auto figure = new Figura*[2018];

    std::random_device rd;
    std::mt19937 mt(rd());
    std::uniform_real_distribution<double> dist(-100, 100);

    int i = 0;
    for (int j = 0; j < 1009; j++) {
        figure[i++] = new Kvadrat(dist(mt));
        figure[i++] = new Pravougaonik(dist(mt), dist(mt));
    }

    for (int j = 0; j < 2018; j++) {
        figure[j]->Prikazi();
    }

    for (int j = 0; j < 2017; j++) {
        for (int k = j + 1; k < 2018; k++) {
            if (figure[j]->Povrsina() > figure[k]->Povrsina()) {
                auto tmp = figure[j];
                figure[j] = figure[k];
                figure[k] = tmp;
            }
        }
    }

    std::ofstream out("figure.txt");
    for (int j = 0; j < 2018; j++) {
        out << figure[j]->Povrsina() << std::endl;
    }

    out.close();

    delete[] figure;

    return 0;
}

#ifndef FIGURA_H
#define FIGURA_H


class Figura {
protected:
    int brStranica;
    double *stranice;

public:
    Figura();

    Figura(int brStranica, double *stranice);

    virtual double Povrsina();

    virtual void Prikazi();

    virtual ~Figura();
};


#endif

#include "Figura.h"

#include <iostream>

Figura::Figura() {
    brStranica = 0;
    stranice = nullptr;
}

Figura::Figura(int brStranica, double *stranice) {
    this->brStranica = brStranica;
    this->stranice = stranice;
}

double Figura::Povrsina() {
    return 0;
}

void Figura::Prikazi() {
    std::cout << "[" << brStranica << "]: ";
    for (int i = 0; i < brStranica; i++) {
        std::cout << stranice[i] << " ";
    }
    std::cout << std::endl;
}

Figura::~Figura() {
    delete[] stranice;
}

#ifndef KVADRAT_H
#define KVADRAT_H
#include "Figura.h"


class Kvadrat : public Figura {
public:
    Kvadrat();

    Kvadrat(double a);

    double Povrsina() override;

    void Prikazi() override;

    ~Kvadrat() override;
};


#endif

#include "Kvadrat.h"

#include <iostream>

Kvadrat::Kvadrat() : Figura(4, new double[4]) {

}

Kvadrat::Kvadrat(double a) : Figura(4, new double[4]) {
    stranice[0] = stranice[1] = stranice[2] = stranice[3] = a;
}

double Kvadrat::Povrsina() {
    return stranice[0] * stranice[0];
}

void Kvadrat::Prikazi() {
    std::cout << "Kvadrat: a = " << stranice[0] << std::endl;
}

Kvadrat::~Kvadrat() {
    delete[] stranice;
}

#ifndef PRAVOUGAONIK_H
#define PRAVOUGAONIK_H
#include "Figura.h"


class Pravougaonik : public Figura {
public:
    Pravougaonik();

    Pravougaonik(double a, double b);

    double Povrsina() override;

    void Prikazi() override;

    ~Pravougaonik() override;
};


#endif

#include "Pravougaonik.h"

#include <iostream>

Pravougaonik::Pravougaonik() : Figura(4, new double[4]) {

}

Pravougaonik::Pravougaonik(double a, double b) : Figura(4, new double[4]) {
    stranice[0] = stranice[2] = a;
    stranice[1] = stranice[3] = b;
}

double Pravougaonik::Povrsina() {
    return stranice[0] * stranice[1];
}

void Pravougaonik::Prikazi() {
    std::cout << "Pravougaonik: a = " << stranice[0] << ", b = " << stranice[1] << std::endl;
}

Pravougaonik::~Pravougaonik() {
    delete[] stranice;
}

#include <iostream>
#include <fstream>
#include <random>
#include <sstream>

#include "PointCity.h"

int main() {
    std::ifstream file("LV3Zad3.txt");

    if (!file.is_open()) {
        std::cout << "File not found!" << std::endl;
        return 1;
    }

    int count = 0;
    std::string line;


    while (std::getline(file, line)) {
        if (!line.empty())
            count++;
    }

    file.clear();
    file.seekg(0, std::ios::beg);

    auto cities = new PointCity*[count];

    std::random_device rd;
    std::mt19937 mt(rd());
    std::uniform_int_distribution<int> dist(-100, 100);

    int i = 0;
    while (std::getline(file, line)) {
        if (line.empty()) {
            continue;
        }

        std::istringstream iss(line);
        std::string country, city, population;

        std::getline(iss, city, '\t');
        std::getline(iss, country, '\t');
        std::getline(iss, population, '\t');

        int popNum = 0;

        for (int j = 0; j < population.length(); j++) {
            if (population[j] == '[') {
                break;
            }

            if (std::isdigit(population[j])) {
                popNum *= 10;
                popNum += population[j] - '0';
                std::cout << population[j];
            }
        }

        cities[i++] = new PointCity(city.data(), country.data(), popNum, dist(mt), dist(mt));
    }

    file.close();

    for (int j = 0; j < count - 1; j++) {
        for (int k = j + 1; k < count; k++) {
            if (cities[j]->Population() < cities[k]->Population()) {
                auto temp = cities[j];
                cities[j] = cities[k];
                cities[k] = temp;
            }
        }
    }

    std::ofstream outFile("LV3Zad3Out.txt");

    for (int j = 0; j < count; j++) {
        outFile << *cities[j];
    }

    out.close();

    delete[] cities;

    return 0;
}

#ifndef POINT_H
#define POINT_H


class Point {
protected:
    double x;
    double y;

public:
    Point();

    Point(double x, double y);

    double Distance(Point p);

    virtual void PrintData();

    virtual ~Point();
};


#endif

#include "Point.h"

#include <cmath>
#include <iostream>

Point::Point() {
    this->x = 0;
    this->y = 0;
}

Point::Point(double x, double y) {
    this->x = x;
    this->y = y;
}

double Point::Distance(Point p) {
    return sqrt(pow(this->x - p.x, 2) + pow(this->y - p.y, 2));
}

void Point::PrintData() {
    std::cout << "(" << x << ", " << y << ") ";
}

Point::~Point() = default;

#ifndef POINTCITY_H
#define POINTCITY_H
#include <iosfwd>
#include <bits/char_traits.h>

#include "Point.h"


class PointCity : public Point {
private:
    char *cityName;
    char *countryName;
    int population;

public:
    PointCity();

    PointCity(char *cityName, char *countryName, int population, double x, double y);

    void PrintData() override;

    int Population();

    friend std::ostream &operator<<(std::ostream &os, const PointCity &pc);

    ~PointCity() override;
};


#endif

#include "PointCity.h"

#include <cstring>
#include <iostream>

PointCity::PointCity() {
    this->cityName = nullptr;
    this->countryName = nullptr;
    this->population = 0;
}

PointCity::PointCity(char *cityName, char *countryName, int population, double x, double y) : Point(x, y) {
    this->cityName = new char[strlen(cityName) + 1];
    this->countryName = new char[strlen(countryName) + 1];
    strcpy(this->cityName, cityName);
    strcpy(this->countryName, countryName);
    this->population = population;
}

void PointCity::PrintData() {
    std::cout << "(" << x << ", " << y << ")\t" << cityName << "\t" << countryName << "\t" << population << "\t" << std::endl;
}

int PointCity::Population() {
    return population;
}

std::ostream &operator<<(std::ostream &os, const PointCity &pc) {
    os << pc.cityName << "\t" << pc.countryName << "\t" << pc.population << std::endl;
    return os;
}

PointCity::~PointCity() {
    delete[] this->cityName;
    delete[] this->countryName;
}

#include <iostream>
#include <random>

#include "Buffer.h"
#include "QueueBuffer.h"
#include "OrderedBuffer.h"

int main() {
    Buffer *buf1, *buf2, *buf3;

    buf1 = new Buffer(10);
    buf2 = new QueueBuffer(10);
    buf3 = new OrderedBuffer(10);

    std::random_device rd;
    std::mt19937 mt(rd());
    std::uniform_int_distribution<int> dist(-100, 100);

    for (int i = 1; i <= 2018; i++) {
        for (int j = 0; j < 3; j++) {
            buf1->Push(dist(mt));
            buf2->Push(dist(mt));
            buf3->Push(dist(mt));
        }

        for (int j = 0; j < 2; j++) {
            buf1->Pop();
            buf2->Pop();
            buf3->Pop();
        }

        if (i % 50 == 0) {
            buf1->Clear();
            buf2->Clear();
            buf3->Clear();
        }

        if (i % 100 == 0) {
            buf1->Print();
            buf2->Print();
            buf3->Print();
            std::cout << std::endl;
        }
    }

    delete buf1;
    delete buf2;
    delete buf3;

    return 0;
}

#ifndef BUFFER_H
#define BUFFER_H


class Buffer {
protected:
    int size;
    int count;
    int *data;

public:
    Buffer(int size);

    ~Buffer();

    virtual bool Push(int value);

    virtual int Pop();

    virtual void Clear();

    void Print();
};


#endif

#include "Buffer.h"

#include <iostream>

Buffer::Buffer(int size) {
    this->size = size;
    this->count = 0;
    this->data = new int[size];
}

Buffer::~Buffer() {
    delete[] this->data;
}

bool Buffer::Push(int value) {
    if (this->count == this->size) {
        return false;
    }

    this->data[this->count++] = value;

    return true;
}

int Buffer::Pop() {
    if (this->count == 0) {
        return 0;
    }

    int value = this->data[0];
    this->count--;

    for (int i = 0; i < this->count; i++) {
        this->data[i] = this->data[i + 1];
    }

    return value;
}

void Buffer::Clear() {
    this->count = 0;
}

void Buffer::Print() {
    for (int i = 0; i < this->count; i++) {
        std::cout << this->data[i] << " ";
    }

    std::cout << std::endl;
}

#ifndef QUEUEBUFFER_H
#define QUEUEBUFFER_H
#include "Buffer.h"


class QueueBuffer : public Buffer {
public:
    QueueBuffer(int size);

    bool Push(int value) override;

    int Pop() override;

    void Clear() override;
};


#endif

#include "QueueBuffer.h"

QueueBuffer::QueueBuffer(int size) : Buffer(size) {}

bool QueueBuffer::Push(int value) {
    if (this->count == this->size) {
        return false;
    }

    this->data[this->count++] = value;

    return true;
}

int QueueBuffer::Pop() {
    if (this->count == 0) {
        return 0;
    }

    if (this->count == 1) {
        return this->data[--this->count];
    }

    int value = this->data[this->count - 2];
    this->data[this->count - 2] = this->data[this->count - 1];
    this->count--;

    return value;
}

void QueueBuffer::Clear() {
    this->count = 0;
}

#ifndef ORDEREDBUFFER_H
#define ORDEREDBUFFER_H
#include "Buffer.h"


class OrderedBuffer : public Buffer {
public:
    OrderedBuffer(int size);

    bool Push(int value) override;

    int Pop() override;

    void Clear() override;
};


#endif