Прва вежба¶

#include "Klasa.h"

Klasa::Klasa() {

}

Klasa::~Klasa() {

}

void Klasa::Metod1() {

}

bool Klasa::Metod2(int a) {
    return a > 10
}

#ifndef SKUP_H
#define SKUP_H


class Skup {
private:
    int brElemenata;
    int *elementi;

public:
    Skup();

    Skup(int brElemenata);

    ~Skup();

    int BrElemenata() const {
        return brElemenata;
    }

    int UkloniDuplikate();

    bool Pripada(int element);

    void Uredi();

    void Ucitaj();

    void Prikazi();
};


#endif

#include <iostream>
#include "Skup.h"

Skup::Skup() {
    brElemenata = 0;
    elementi = nullptr;
}

Skup::Skup(int brElemenata) {
    this->brElemenata = brElemenata;
    this->elementi = new int[brElemenata];
}

Skup::~Skup() {
    delete[] elementi;
}

int Skup::UkloniDuplikate() {
    int stariBr = brElemenata;
    for (int i = 0; i < brElemenata; i++) {
        for (int j = brElemenata - 1; j > i; j--) {
            if (elementi[i] == elementi[j]) {
                for (int k = j; k < brElemenata - 1; k++) {
                    elementi[k] = elementi[k + 1];
                }
                brElemenata--;
            }
        }
    }

    return stariBr - brElemenata;
}

bool Skup::Pripada(int element) {
    for (int i = 0; i < brElemenata; i++) {
        if (element == elementi[i]) {
            return true;
        }
    }

    return false;
}

void Skup::Uredi() {
    for (int i = 0; i < brElemenata - 1; i++) {
        for (int j = i + 1; j < brElemenata; j++) {
            if (elementi[j] > elementi[i]) {
                int pom = elementi[j];
                elementi[j] = elementi[i];
                elementi[i] = pom;
            }
        }
    }
}

void Skup::Ucitaj() {
    for (int i = 0; i < brElemenata; i++) {
        std::cin >> elementi[i];
    }
}

void Skup::Prikazi() {
    for (int i = 0; i < brElemenata; i++) {
        std::cout << elementi[i] << " ";
    }
    std::cout << std::endl;
}

#include <iostream>
#include "Skup.h"

int main() {
    auto skup1 = new Skup(10);
    skup1->Ucitaj();

    std::cout << "Element 5 " << (skup1->Pripada(5) ? "" : "ne ") << "pripada skupu." << std::endl;
    std::cout << "Element 24 " << (skup1->Pripada(24) ? "" : "ne ") << "pripada skupu." << std::endl;
    std::cout << "Element -3 " << (skup1->Pripada(-3) ? "" : "ne ") << "pripada skupu." << std::endl;

    auto skup2 = new Skup(5);

    skup2->Ucitaj();
    std::cout << "Br. elementa: " << skup2->BrElemenata() << std::endl;
    skup2->Prikazi();
    skup2->UkloniDuplikate();
    std::cout << "Br. elementa: " << skup2->BrElemenata() << std::endl;
    skup2->Prikazi();
    skup2->Uredi();
    skup2->Prikazi();

    delete skup1;
    delete skup2;

    return 0;
}

#ifndef STUDENT_H
#define STUDENT_H

class Student {
private:
    char *ime;
    char *prezime;
    int brojIndeksa;
    int maksimalanBrojIspita;
    int brojPolozenihIspita;
    int *ocene;

public:
    Student(int maksimalanBrojIspita);

    ~Student();

    int BrojIndeksa() const {
        return brojIndeksa;
    }

    int BrojPolozenihIspita() const {
        return brojPolozenihIspita;
    }

    bool DodajOcenu(int ocena);

    void UcitajPodatke();

    void IspisiPodatke();

    void IspisiOcene();

    void PromeniImeIPrezime(char *novoIme, char *novoPrezime);
};


#endif

#include <iostream>
#include "Student.h"

Student::Student(int maksimalanBrojIspita) {
    this->maksimalanBrojIspita = maksimalanBrojIspita;
    this->ocene = new int[maksimalanBrojIspita];
    this->ime = new char[50];
    this->prezime = new char[50];
}

Student::~Student() {
    delete[] ocene;
    delete[] ime;
    delete[] prezime;
}

bool Student::DodajOcenu(int novaOcena) {
    if (novaOcena < 5 || novaOcena > 10) {
        return false;
    }

    ocene[brojPolozenihIspita++] = novaOcena;
    return true;
}

void Student::UcitajPodatke() {
    std::cin >> ime;
    std::cin >> prezime;
    std::cin >> brojIndeksa;
}

void Student::IspisiPodatke() {
    std::cout << ime << std::endl
              << prezime << std::endl
              << brojIndeksa << std::endl
              << brojPolozenihIspita << "/" << maksimalanBrojIspita << std::endl;
}

void Student::IspisiOcene() {
    auto sortiraneOcene = new int[brojPolozenihIspita];

    for (int i = 0; i < brojPolozenihIspita; i++) {
        sortiraneOcene[i] = ocene[i];
    }

    for (int i = 0; i < brojPolozenihIspita; i++) {
        for (int j = i + 1; j < brojPolozenihIspita; j++) {
            if (sortiraneOcene[j] > sortiraneOcene[i]) {
                int pom = sortiraneOcene[j];
                sortiraneOcene[j] = sortiraneOcene[i];
                sortiraneOcene[i] = pom;
            }
        }
    }

    for (int i = 0; i < brojPolozenihIspita; i++) {
        std::cout << sortiraneOcene[i] << " ";
    }

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

void Student::PromeniImeIPrezime(char *novoIme, char *novoPrezime) {
    ime = novoIme;
    prezime = novoPrezime;
}

#include <iostream>
#include "Student.h"

int main() {
    auto student1 = Student(43);
    student1.UcitajPodatke();
    student1.DodajOcenu(7);
    student1.DodajOcenu(5);
    student1.DodajOcenu(3);
    student1.DodajOcenu(10);

    auto student2 = new Student(46);
    student2->UcitajPodatke();
    student2->IspisiPodatke();
    student2->PromeniImeIPrezime(new char[]{"Milica"}, new char[]{"Micic"});
    std::cout << student2->BrojIndeksa() << std::endl;
    student2->DodajOcenu(6);
    student2->DodajOcenu(2);
    student2->DodajOcenu(10);
    student2->DodajOcenu(88);
    student2->DodajOcenu(5);
    student2->DodajOcenu(7);
    student2->IspisiPodatke();
    student2->IspisiOcene();
    std::cout << student2->BrojPolozenihIspita() << std::endl;

    delete student2;

    return 0;
}

#ifndef POLIGON_H
#define POLIGON_H

#include <tuple>

class Poligon {
private:
    int n;
    double *x, *y;

public:
    Poligon();

    Poligon(int n);

    ~Poligon();

    int BrojTemena() {
        return n;
    }

    double Obim();

    void Ucitaj();

    std::tuple<int, int, int, int> NajudaljenijeTacke();

    void Prikaz();

    void UkloniTeme();
};

#endif

#include <cmath>
#include <iostream>
#include "Poligon.h"

Poligon::Poligon() {
    n = 0;
    x = nullptr;
    y = nullptr;
}

Poligon::Poligon(int n) {
    this->n = n;
    x = new double[n];
    y = new double[n];
}

Poligon::~Poligon() {
    delete[] x;
    delete[] y;
}

double Poligon::Obim() {
    double obim = 0;
    for (int i = 0; i < n; i++) {
        obim += sqrt(pow(x[(i + 1) % n] - x[i], 2) + pow(y[(i + 1) % n] - y[i], 2));
    }
    return obim;
}

void Poligon::Ucitaj() {
    for (int i = 0; i < n; i++) {
        std::cin >> x[i] >> y[i];
    }
}

std::tuple<int, int, int, int> Poligon::NajudaljenijeTacke() {
    int i1 = 0, i2 = 0;
    double max = 0;
    for (int i = 0; i < n; i++) {
        double d = sqrt(pow(x[(i + 1) % n] - x[i], 2) + pow(y[(i + 1) % n] - y[i], 2));
        if (d > max) {
            max = d;
            i1 = (i + 1) % n;
            i2 = i;
        }
    }
    return {x[i1], y[i1], x[i2], y[i2]};
}

void Poligon::Prikaz() {
    for (int i = 0; i < n; i++) {
        std::cout << "(" << x[i] << ", " << y[i] << ")" << std::endl;
    }
}

void Poligon::UkloniTeme() {
    auto newX = new double[n - 1];
    auto newY = new double[n - 1];

    for (int i = 0; i < n - 1; i++) {
        newX[i] = x[i];
        newY[i] = y[i];
    }

    delete[] x;
    delete[] y;

    n--;

    x = newX;
    y = newY;
}

#include <iostream>
#include "Poligon.h"

int main() {
    auto poligon1 = Poligon(7);
    poligon1.Ucitaj();
    std::cout << poligon1.Obim() << std::endl;

    auto poligon2 = new Poligon(9);
    poligon2->Ucitaj();
    auto tacka = poligon2->NajudaljenijeTacke();
    double x1 = std::get<0>(tacka);
    double y1 = std::get<1>(tacka);
    double x2 = std::get<2>(tacka);
    double y2 = std::get<3>(tacka);
    std::cout << "(" << x1 << ", " << y1 << "); (" << x2 << ", " << y2 << ")" << std::endl;
    std::cout << poligon2->BrojTemena() << std::endl;
    poligon2->Prikaz();
    poligon2->UkloniTeme();
    std::cout << poligon2->BrojTemena() << std::endl;
    poligon2->Prikaz();

    delete poligon2;

    return 0;
}

#ifndef IMAGE_H
#define IMAGE_H


class Image {
private:
    short **data;
    char *location;
    int size;
public:
    Image();

    Image(int size);

    ~Image();

    int Dimension() const {
        return size;
    }

    void Invert();

    void Load();

    void Print();

    bool Crop(int newSize);
};


#endif

#include <iostream>
#include "Image.h"

Image::Image() {
    size = 0;
    location = nullptr;
    data = nullptr;
}

Image::Image(int size) {
    this->size = size;
    location = new char[size];
    data = new short*[size];
    for (int i = 0; i < size; i++) {
        data[i] = new short[size];
    }
}

Image::~Image() {
    delete[] location;
    for (int i = 0; i < size; i++) {
        delete[] data[i];
    }
    delete[] data;
}

void Image::Invert() {
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; ++j) {
            data[i][j] = data[i][j] == 0 ? 1 : 0;
        }
    }
}

void Image::Load() {
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            std::cin >> data[i][j];
        }
    }
}

void Image::Print() {
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            std::cout << data[i][j] << " ";
        }
        std::cout << std::endl;
    }
}

bool Image::Crop(int newSize) {
    if (newSize > size) {
        return false;
    }

    auto **newData = new short*[newSize];
    for (int i = 0; i < newSize; i++) {
        newData[i] = new short[newSize];
    }

    for (int i = 0; i < newSize; i++) {
        for (int j = 0; j < newSize; j++) {
            newData[i][j] = data[i][j];
        }
    }

    for (int i = 0; i < size; i++) {
        delete[] data[i];
    }

    delete[] data;

    data = newData;
    size = newSize;

    return true;
}

#include <iostream>
#include "Image.h"

int main() {
    auto image1 = Image(10);
    image1.Load();
    image1.Invert();
    image1.Print();

    auto image2 = new Image(5);
    image2->Load();
    std::cout << image2->Dimension() << std::endl;
    image2->Print();
    image2->Crop(10);
    std::cout << image2->Dimension() << std::endl;
    image2->Print();
    image2->Crop(3);
    std::cout << image2->Dimension() << std::endl;
    image2->Print();

    delete image2;

    return 0;
}

#ifndef BUFFER_H
#define BUFFER_H


class Buffer {
private:
    int *data;
    int size;
    int count;
public:
    Buffer();

    Buffer(int size);

    Buffer(Buffer &b);

    ~Buffer();

    int Count() {
        return count;
    }

    bool Push(int value);

    int Pop();

    void Print();

    void Duplicate();

    void ClearFree();
};


#endif

#include <iostream>
#include "Buffer.h"

Buffer::Buffer() {
    size = 0;
    data = nullptr;
    count = 0;
}

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

Buffer::Buffer(Buffer &b) {
    this->size = b.size;
    this->count = b.count;
    this->data = new int[b.count];

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

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

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

    data[count++] = value;
    return true;
}

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

    return data[count--];
}

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

void Buffer::Duplicate() {
    int *newData = new int[size * 2];
    size = size * 2;

    for (int i = 0; i < count; i++) {
        newData[i] = data[i];
    }

    delete[] data;
    data = newData;
}

void Buffer::ClearFree() {
    int *newData = new int[count];
    size = count;
    for (int i = 0; i < count; i++) {
        newData[i] = data[i];
    }

    delete[] data;
    data = newData;
}

#include <iostream>
#include "Buffer.h"

int main() {
    int n, m;
    std::cin >> n >> m;

    auto buf1 = Buffer(n);

    for (int i = 1; i <= n; i++) {
        buf1.Push(i);
    }

    auto buf2 = new Buffer(buf1);

    for (int i = 0; i < m; i++) {
        buf1.Pop();
    }

    std::cout << buf1.Count() << std::endl;
    buf1.Print();

    std::cout << buf2->Count() << std::endl;
    buf2->Print();

    delete buf2;

    return 0;
}

#ifndef VEKTOR_H
#define VEKTOR_H


class Vektor {
private:
    int* vec;
    int n;
public:
    Vektor();
    Vektor(int n);
    ~Vektor();

    void SetElement(int k, int val) {
        vec[k] = val;
    }

    const int GetElement(int k) {
        return vec[k];
    }

    void Sort();
    int ScalarProd(const Vektor &v);
    int IdxAvg() const;
};


#endif