Помогите пожалуйста написать программу

 #include  
#include  
#include  
 
using namespace std; 
 
// Функция для создания динамической матрицы из случайных чисел 
int** createMatrix(int rows, int cols) { 
    int** matrix = new int*[rows]; 
    for (int i = 0; i < rows; i++) { 
        matrix[i] = new int[cols]; 
        for (int j = 0; j < cols; j++) { 
            matrix[i][j] = rand() % 100; // случайное число от 0 до 99 
        } 
    } 
    return matrix; 
} 
 
// Функция для вывода матрицы на экран 
void printMatrix(int** matrix, int rows, int cols) { 
    for (int i = 0; i < rows; i++) { 
        for (int j = 0; j < cols; j++) { 
            cout << matrix[i][j] << " "; 
        } 
        cout << endl; 
    } 
} 
 
// Функция для обработки матрицы (например, можно сложить все элементы матрицы) 
void processMatrix(int** matrix, int rows, int cols) { 
    int sum = 0; 
    for (int i = 0; i < rows; i++) { 
        for (int j = 0; j < cols; j++) { 
            sum += matrix[i][j]; 
        } 
    } 
    cout << "Сумма всех элементов матрицы: " << sum << endl; 
} 
 
// Функция для удаления динамической матрицы 
void deleteMatrix(int** matrix, int rows) { 
    for (int i = 0; i < rows; i++) { 
        delete[] matrix[i]; 
    } 
    delete[] matrix; 
} 
 
int main() { 
    srand(time(0)); // установим seed для генератора случайных чисел 
 
    int rows, cols; 
    cout << "Введите количество строк матрицы: "; 
    cin >> rows; 
    cout << "Введите количество столбцов матрицы: "; 
    cin >> cols; 
 
    int** matrix = createMatrix(rows, cols); // создаем матрицу 
    cout << "Исходная матрица:" << endl; 
    printMatrix(matrix, rows, cols); // выводим исходную матрицу 
 
    cout << "Результат обработки матрицы:" << endl; 
    processMatrix(matrix, rows, cols); // обрабатываем матрицу 
 
    deleteMatrix(matrix, rows); // удаляем матрицу 
 
    return 0; 
} 
 

 #include 
#include 
#include 
#include 

using namespace std;
using T = long;
using S = long long;

size_t input(const char* msg) {
    size_t value = 0;
    while (!value) {
        cout << msg;
        cin >> value;
        cin.ignore(0x1000, '\n');
    }
    return value;
}

T* create_vector(size_t n) {
    return new(nothrow) T[n];
}

T* destroy(T* p) {
    if (!p) {
        delete[] p;
        p = nullptr;
    }
    return p;
}

T** create_matrix(size_t n, size_t m) {
    T** mx = nullptr;
    if ((mx = new(nothrow) T*[n]) != nullptr) {
        for (size_t i = 0; i < n; ++i) {
            if ((mx[i] = create_vector(m)) == nullptr) {
                for (size_t j = 0; j < i; ++j) delete[] mx[i];
                mx = nullptr;
                break;
            }
        }
    }
    return mx;
}

T** destroy(T** p, size_t n) {
    if (p != nullptr) {
        for (size_t i = 0; i < n; ++i) p[i] = destroy(p[i]);
        p = nullptr;
    }
    return p;
}

void random_fill(T* p, size_t n, T a, T b) {
    if (b < a) swap(a, b);
    uniform_int_distribution uid(a, b);
    mt19937 gen{ random_device()() };
    for (size_t i = 0; i < n; ++i) p[i] = uid(gen);
}

void random_fill(T** p, size_t n, size_t m, T a, T b) {
    for (size_t i = 0; i < n; ++i) random_fill(p[i], m, a, b);
}

void show(T* p, size_t n, streamsize w) {
    for (size_t i = 0; i < n; ++i) cout << ' ' << setw(w) << p[i];
    puts(""); 
}

void show(T** p, size_t n, size_t m, streamsize w) {
    for (size_t i = 0; i < n; ++i) show(p[i], m, w);
    puts("");
}

S pattern(T** p, size_t n, size_t j) {
    S s = 0;
    auto fn = [](T x) { return x < 0 && x % 2 != 0; };
    for (size_t i = 0; i < n; ++i) if (fn(p[i][j])) s += abs(p[i][j]);
    return s;
}

bool cmp(T** p, size_t n, size_t i, size_t j) {
    return pattern(p, n, i) > pattern(p, n, j);
}

bool isneg(T** p, size_t n, size_t j) {
    for (size_t i = 0; i < n; ++i) if (p[i][j] < 0) return 1;
    return 0; 
}

S colsum(T** p, size_t n, size_t j) {
    S s = 0;
    for (size_t i = 0; i < n; ++i) s += p[i][j];
    return s;
}

void colswap(T** p, size_t n, size_t i, size_t j) {
    for (size_t k = 0; k < n; ++k) swap(p[k][i], p[k][j]);
}

void usort(T** p, size_t n, size_t m) {
    for (size_t i = 0; i < m - 1; ++i) {
        size_t k = i;
        for (size_t j = i + 1; j < m; ++j) if (cmp(p, n, j, k)) k = j;
        colswap(p, n, i, k);
    }
}

void findsum(T** p, size_t n, size_t m, streamsize w) {
    for (size_t j = 0; j < m; ++j) {
        S s = 0;
        auto flag = false;
        if (isneg(p, n, j)) {
            if (!flag) flag = !flag;
            for (size_t i = 0; i < n; ++i) s += p[i][j];
        }
        cout << ' ' << setw(w);
        if (flag) cout << s;
        else cout << "";
    }
    puts("");
}

int main() {
    auto n = input("rows: ");
    auto m = input("cols: ");
    T** mx = nullptr;
    if ((mx = create_matrix(n, m)) == nullptr) return 0;
    random_fill(mx, n, m, -9, 9);
    show(mx, n, m, 4);
    usort(mx, n, m);
    show(mx, n, m, 4);
    findsum(mx, n, m, 4);
    mx = destroy(mx, n);
}