#include <iostream>
#include <string>
#include <fstream>
#include <vector>
#include <array>
#include <ctime>
#include <random>

void print(const std::vector<int>& v) {
    std::cout << "[ ";
    for (auto i : v) {
        std::cout << i << " ";
    }
    std::cout << "]\n";
}
float sum(const std::vector<float>& v) {
    float sum = 0;
    for (auto i : v) {
        sum += i;
    }
    return sum;
}
float average(const std::vector<float>& v) {
    float sum1 = sum(v);
    float average = 0;
    return average = sum1 / v.size();
}
std::array<float, 2> minmax(const std::vector<float>& v) {
    std::array<float, 2> minmax;
    float max = std::numeric_limits<float>::min();
    float min = std::numeric_limits<float>::max();
    for (auto i : v) {
        if (i > max) {
            max = i;
        }
        if (i < min) {
            min = i;
        }
    }
    minmax[0] = min;
    minmax[1] = max;
    return minmax;
}
void zad1() {
    //Referencja powinna byc stala poniewaz funkcje sluza do analizy tablicy a nie zmiany jej parametrow.
    std::cout << "Ilosc liczb typu float: " << std::endl;
    int n = 0;
    std::cin >> n;
    std::vector<float>v;
    for (int i = 0; i < n; ++i) {
        float value = 0;
        std::cout << "Podaj float nr " << i + 1 << ": " << std::endl;
        std::cin >> value;
        v.push_back(value);
    }
    std::array<float, 2> minmaxfinal = minmax(v);
    std::cout << "\nSuma: " << sum(v) << "\nSrednia: " << average(v);
    std::cout << "\nNajmniejszy wyraz: " << minmaxfinal[0] << "\nNajwiekszy wyraz: " << minmaxfinal[1] << '\n';
}
bool equals(std::vector<int>& v1, std::vector<int>& v2) {
    //Argumenty funkcji najkorzystniej przekazywac w tym przypadku przez referencje zwykla,
    //poniewaz aby uzyskac porownanie w kazdych warunkach potrzebne jest dodanie elementow do wektora.
    //Wynik zwracany przez referencje nie jest tutaj poprawny, dlatego nie uzylem jej w tym przykladzie.
    int size = 0;
    if (v1.size() >= v2.size()) {
        size = v1.size();
        if (v1.size() != v2.size()) {
            int difference = v1.size() - v2.size();
            for (int i = 0; i < difference; ++i) {
                v2.push_back(0);
            }
        }
    }
    else {
        size = v2.size();
        int difference = v2.size() - v1.size();
        for (int i = 0; i < difference; ++i) {
            v1.push_back(0);
        }
    }
    bool equals = true;
    for (int i = 0; i < size; i++) {
        if (v1[i] != v2[i]) {
            equals = false;
            break;
        }
    }
    return equals;
}
std::vector<int> add(std::vector<int>& v1, std::vector<int>& v2) {
    //Argumenty funkcji najkorzystniej przekazywac w tym przypadku przez referencje zwykla,
    //poniewaz aby uzyskac porownanie w kazdych warunkach potrzebne jest dodanie elementow do wektora.
    //Wynik zwracany jest wektorem, dlatego nie moglem uzyc referencji przy zwrocie.
    std::vector<int> addedVec;
    int size = 0;
    if (v1.size() >= v2.size()) {
        size = v1.size();
        if (v1.size() != v2.size()) {
            int difference = v1.size() - v2.size();
            for (int i = 0; i < difference; ++i) {
                v2.push_back(0);
            }
        }
    }
    else {
        size = v2.size();
        int difference = v2.size() - v1.size();
        for (int i = 0; i < difference; ++i) {
            v1.push_back(0);
        }

    }
    for (int i = 0; i < size; ++i) {
        int value = v1[i] + v2[i];
        addedVec.push_back(value);
    }
    return addedVec;
}
std::vector<int> subtract(std::vector<int>& v1, std::vector<int>& v2) {
    //Argumenty funkcji najkorzystniej przekazywac w tym przypadku przez referencje zwykla,
    //poniewaz aby uzyskac porownanie w kazdych warunkach potrzebne jest dodanie elementow do wektora.
    //Wynik zwracany jest wektorem, dlatego nie moglem uzyc referencji przy zwrocie.
    std::vector<int> subbedVec;
    int size = 0;
    if (v1.size() >= v2.size()) {
        size = v1.size();
        if (v1.size() != v2.size()) {
            int difference = v1.size() - v2.size();
            for (int i = 0; i < difference; ++i) {
                v2.push_back(0);
            }
        }
    }
    else {
        size = v2.size();
        int difference = v2.size() - v1.size();
        for (int i = 0; i < difference; ++i) {
            v1.push_back(0);
        }

    }
    for (int i = 0; i < size; ++i) {
        int value = v1[i] - v2[i];
        subbedVec.push_back(value);
    }
    return subbedVec;
}
std::vector<int> multiply(const std::vector<int>& v, int scale) {
    //Argumenty funkcji najkorzystniej przekazywac w tym przypadku przez referencje stala,
    //poniewaz wystarczy tutaj pomnozyc kazdy wyraz wektora przez skalar.
    //Wynik zwracany jest wektorem, dlatego nie moglem uzyc referencji przy zwrocie.
    std::vector<int> multipliedVec;
    for (auto i : v) {
        multipliedVec.push_back(i*scale);
    }
    return multipliedVec;
}
std::vector<int> vecGen(int dim) {
    std::vector<int> vecGen;
    for (int i = 0; i < dim; ++i) {
        vecGen.push_back((rand() % 2000) - 1000);
    }
    return vecGen;
}
void zad2() {
    std::cout << "Podaj kolejno liczbe wymiarow wektora oraz wartosc skalara: \n";
    int n = 0, scale = 0;
    std::cin >> n >> scale;
    using vecInt = std::vector<int>;
    //a
    vecInt a = vecGen(n);
    std::cout << "a: " << equals(a, a) << '\n';
    //b
    vecInt b1 = vecGen(n);
    vecInt b2 = vecGen(n);
    std::cout << "b: " << equals(b1, b2) << '\n';
    //c
    vecInt c1 = vecGen(n);
    vecInt c2 = vecGen(n);
    vecInt added = add(c1, c2);
    print(added);
    //d
    vecInt d = vecGen(n);
    vecInt multiplied = multiply(d, scale);
    print(multiplied);
}
void writeVector(const std::vector<int>& vec, const std::string& fileName) {
    std::ofstream save;
    save.open(fileName);
    if (save) {
        for (int i = 0; i < vec.size(); ++i) {
            save << vec[i] << ' ';
        }

        std::cout << "Plik zapisano pomyslnie.\n";
    }
    save.close();
}
void zad3() {
    int n = 100;
    std::vector<int> v = vecGen(n);
    std::string fileName = "Zadanie 3.txt";
    writeVector(v, fileName);
    //Tak, liczby sa bez problemu widoczne.
}
std::vector<int> readVector(const std::string& fileName) {
    std::ifstream read(fileName);
    std::vector<int> buffer;
    if (read) {
        int value;
        while (read >> value) {
            buffer.push_back(value);
        }
    }
    return buffer;
}
void zad4() {
    std::string fileName = "Zadanie 3.txt";
    print(readVector(fileName));
}
std::vector<int> bubbleSort(std::vector<int>& v) {
    for (int i = 0; i < (v.size() - 1); ++i) {
        for (int j = 0; j < (v.size() - 1); ++j) {
            if (v[j] > v[j + 1]) {
                std::swap(v[j], v[j + 1]);
            }
        }
    }
    return v;
}
void zad5() {
    //Wygenerowany wektor moze byc bez problemu przekazany do sortowania jako referencja,
    //a po posortowaniu jako stala referencja, poniewaz nie bedzie on juz nigdzie zmieniany.
    int n = 5;
    std::string name = "Zadanie 5.txt";
    std::vector<int> v = bubbleSort(vecGen(n));
    writeVector(v, name);
    print(readVector(name));
}
int randomInt(int min, int max) {
    static std::default_random_engine e{};
    std::uniform_int_distribution<int>d(min, max);
    return d(e);
}
std::vector<std::vector<int>> createMatrix(int col, int row) {
    std::vector<std::vector<int>> matrix;
    matrix.resize(row, std::vector<int>(col, 0));
    return matrix;
}
void printMatrix(const std::vector<std::vector<int>>& matrix) {
    for (int i = 0; i < matrix[0].size(); ++i) {
        for (int j = 0; j < matrix.size(); ++j) {
            std::cout << matrix[j][i] << " ";
        }
        std::cout << std::endl;
    }
    std::cout << '\n';
}
std::vector<std::vector<int>> randomMatrix(int col, int row, int min, int max) {
    std::vector<std::vector<int>> randomMatrix;
    randomMatrix.resize(row, std::vector<int>(col));
    for (int i = 0; i < row; ++i) {
        for (int j = 0; j < col; ++j) {
            randomMatrix[i][j] = randomInt(min, max);
        }
    }
    return randomMatrix;
}
void zad6() {
    //Macierz moze byc przekazywana przez stala referencje w funkcji print.
    using intMatrix = std::vector<std::vector<int>>;
    int col = 3, row = 7;

    intMatrix matrixZero;
    matrixZero.resize(row, std::vector<int>(col));
    matrixZero = createMatrix(col, row);
    printMatrix(matrixZero);

    int min = 10, max = 100;
    intMatrix matrixRandom;
    matrixRandom.resize(row, std::vector<int>(col));
    matrixRandom = randomMatrix(col, row, min, max);
    printMatrix(matrixRandom);
}
std::vector<std::vector<int>> addMatrix(const std::vector<std::vector<int>>& add1, const std::vector<std::vector<int>>& add2) {
    std::vector<std::vector<int>> C;
    C.resize(add1.size(), std::vector<int>(add1[0].size()));
    for (int i = 0; i < add1.size(); ++i) {
        for (int j = 0; j < add1[0].size(); ++j) {
            C[i][j] = add1[i][j] + add2[i][j];
        }
    }
    return C;
}
std::vector<std::vector<int>> subtractMatrix(const std::vector<std::vector<int>>& add1, const std::vector<std::vector<int>>& add2) {
    std::vector<std::vector<int>> C;
    C.resize(add1.size(), std::vector<int>(add1[0].size()));
    for (int i = 0; i < add1.size(); ++i) {
        for (int j = 0; j < add1[0].size(); ++j) {
            C[i][j] = add1[i][j] - add2[i][j];
        }
    }
    return C;
}
void zad7() {
    std::cout << "Podaj wymiary macierzy: \n";
    int row = 0, col = 0;
    std::cin >> row >> col;
    printMatrix(addMatrix(randomMatrix(row, col, -16, -4), randomMatrix(row, col, -16, -4)));
    printMatrix(subtractMatrix(randomMatrix(row, col, -16, -4), randomMatrix(row, col, -16, -4)));
}
std::vector<std::vector<int>> multiplyMatrix(std::vector<std::vector<int>>& A, std::vector<std::vector<int>>& B) {
    std::vector<int>multiColumn;
    std::vector<std::vector<int>>multiRow;
    for (int row = 0; row < A.size(); ++row) {
        for (int col = 0; col < B[0].size(); ++col) {
            int temp = 0;
            for (int add = 0; add < A[0].size(); ++add) {// or B
                temp += A[row][add] * B[add][col];
            }
            multiColumn.push_back(temp);
        }
        multiRow.push_back(multiColumn);
        multiColumn.clear();
    }
    return multiRow;
}
void printAlt(const std::vector<std::vector<int>>& matrix) {
    for (int i = 0; i < matrix.size(); ++i) {
        for (int j = 0; j < matrix[0].size(); ++j) {
            std::cout << matrix[i][j] << " ";
        }
        std::cout << std::endl;
    }
    std::cout << '\n';
}
void zad8() {
    std::cout << "Podaj wymiary m, n i p macierzy => m x n & n x p: ";
    int m = 0, n = 0, p = 0;
    std::cin >> m >> n >> p;
    using intMatrix = std::vector<std::vector<int>>;
    intMatrix A = randomMatrix(n, m, 1, 14);
    intMatrix B = randomMatrix(p, n, 1, 14);
    printAlt(A);
    printAlt(B);
    std::cout << "\nPomnozona macierz: \n";
    printAlt(multiplyMatrix(A, B));

}
double inv(double x) {
    return x = 1 / x;
}
double inv_square(double x) {
    return 1 / std::pow(x, 2);
}
void printMatrixDouble(const std::vector<std::vector<double>>& matrix) {
    for (int i = 0; i < matrix[0].size(); ++i) {
        for (int j = 0; j < matrix.size(); ++j) {
            std::cout << matrix[j][i] << " ";
        }
        std::cout << std::endl;
    }
    std::cout << '\n';
}
void forEach(std::vector<std::vector<double>> m, double(&fun)(double)) {
    double temp = 0;
    for (int col = 0; col < m.size(); col++) {
        for (int row = 0; row < m[0].size(); row++) {
            temp = m[col][row];
            m[col][row] = fun(temp);
        }
    }
    printMatrixDouble(m);
}
void zad9() {
    std::vector<std::vector<double>> m = { {1.2,4.25},{2.1,5.6},{3.3,6.55} };
    printMatrixDouble(m);
    forEach(m, sqrt);
    forEach(m, inv);
    forEach(m, inv_square);
}
int main() {
    srand(time(NULL));
    std::string endCond;
    do {
        std::cout << "Wybierz numer zadania od 1 do 9 lub 0 aby wyjsc: " << std::endl;
        unsigned short wybor = 0;
        bool check = false;
        while (check == false) {
            std::cin >> wybor;
            if (wybor < 0 || wybor>9) {
                std::cout << "Niepoprawny wybor, sprobuj ponownie.\n";
                check = false;
            }
            else {
                check = true;
            }
        }
        switch (wybor) {
        case 1: {
            std::cout << "Zadanie 1\n";
            zad1();
            break;
        }
        case 2: {
            std::cout << "Zadanie 2\n";
            zad2();
            break;
        }
        case 3: {
            std::cout << "Zadanie 3\n";
            zad3();
            break;
        }
        case 4: {
            std::cout << "Zadanie 4\n";
            zad4();
            break;
        }
        case 5: {
            std::cout << "Zadanie 5\n";
            zad5();
            break;
        }
        case 6: {
            std::cout << "Zadanie 6\n";
            zad6();
            break;
        }
        case 7: {
            std::cout << "Zadanie 7\n";
            zad7();
            break;
        }
        case 8: {
            std::cout << "Zadanie 8\n";
            zad8();
            break;
        }
        case 9: {
            std::cout << "Zadanie 9\n";
            zad9();
            break;
        }
        case 0: {
            break;
        }
        }
        std::cout << "Chcesz zakonczyc program? (tak/nie)\n";
        std::cin >> endCond;
    } while (endCond != "tak");
}