Лабораторна робота №10

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <stdexcept>

using namespace std;

// Шаблонна функція для сортування масиву
template <typename T>
void sortArray(T* arr, int size) {
    sort(arr, arr + size);
}

// Шаблонна функція для пошуку рядка за шаблоном
bool matchesPattern(const string& str, const string& pattern) {
    size_t strLen = str.size();
    size_t patLen = pattern.size();

    // Динамічне програмування для зберігання результатів
    vector<vector<bool>> dp(strLen + 1, vector<bool>(patLen + 1, false));
    dp[0][0] = true; // Порожній шаблон збігається з порожнім рядком

    // Обробка шаблону, що містить зірочки
    for (size_t j = 1; j <= patLen; ++j) {
        if (pattern[j - 1] == '*') {
            dp[0][j] = dp[0][j - 1];
        }
    }

    // Заповнення таблиці dp
    for (size_t i = 1; i <= strLen; ++i) {
        for (size_t j = 1; j <= patLen; ++j) {
            if (pattern[j - 1] == '?' || pattern[j - 1] == str[i - 1]) {
                dp[i][j] = dp[i - 1][j - 1];
            } else if (pattern[j - 1] == '*') {
                dp[i][j] = dp[i][j - 1] || dp[i - 1][j];
            }
        }
    }

    return dp[strLen][patLen];
}

// Шаблонна функція для операцій над матрицями
template <typename T>
class Matrix {
private:
    vector<vector<T>> data;
    int rows;
    int cols;

public:
    Matrix(int r, int c) : rows(r), cols(c) {
        data.resize(r, vector<T>(c));
    }

    void setValue(int r, int c, T value) {
        data[r][c] = value;
    }

    T getValue(int r, int c) const {
        return data[r][c];
    }

    int getRows() const {
        return rows;
    }

    int getCols() const {
        return cols;
    }

    // Додавання матриць
    Matrix operator+(const Matrix& other) {
        if (rows != other.rows || cols != other.cols) {
            throw invalid_argument("Розміри матриць не співпадають для додавання.");
        }
        Matrix result(rows, cols);
        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < cols; ++j) {
                result.setValue(i, j, data[i][j] + other.getValue(i, j));
            }
        }
        return result;
    }

    // Віднімання матриць
    Matrix operator-(const Matrix& other) {
        if (rows != other.rows || cols != other.cols) {
            throw invalid_argument("Розміри матриць не співпадають для віднімання.");
        }
        Matrix result(rows, cols);
        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < cols; ++j) {
                result.setValue(i, j, data[i][j] - other.getValue(i, j));
            }
        }
        return result;
    }

    // Множення матриць
    Matrix operator*(const Matrix& other) {
        if (cols != other.rows) {
            throw invalid_argument("Кількість стовпців першої матриці повинна дорівнювати кількості рядків другої матриці.");
        }
        Matrix result(rows, other.cols);
        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < other.cols; ++j) {
                for (int k = 0; k < cols; ++k) {
                    result.setValue(i, j, result.getValue(i, j) + data[i][k] * other.getValue(k, j));
                }
            }
        }
        return result;
    }
};

// Функція для демонстрації
int main() {
    // Демонстрація сортування
    int arr[] = {5, 2, 9, 1, 5, 6};
    int size = sizeof(arr) / sizeof(arr[0]);
    sortArray(arr, size);
    cout << "Відсортований масив: ";
    for (int i = 0; i < size; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    // Демонстрація пошуку за шаблоном
    string str = "hello";
    string pattern = "h?llo";
    cout << "Рядок " << (matchesPattern(str, pattern) ? "збігається" : "не збігається") << " з шаблоном." << endl;

    // Демонстрація матричних операцій
    Matrix<int> mat1(2, 2);
    mat1.setValue(0, 0, 1);
    mat1.setValue(0, 1, 2);
    mat1.setValue(1, 0, 3);
    mat1.setValue(1, 1, 4);

    Matrix<int> mat2(2, 2);
    mat2.setValue(0, 0, 5);
    mat2.setValue(0, 1, 6);
    mat2.setValue(1, 0, 7);
    mat2.setValue(1, 1, 8);

    Matrix<int> sum = mat1 + mat2;
    cout << "Сума матриць:\n";
    for (int i = 0; i < sum.getRows(); ++i) {
        for (int j = 0; j < sum.getCols(); ++j) {
            cout << sum.getValue(i, j) << " ";
        }
        cout << endl;
    }

    return 0;
}