---

1


#include <iostream>
//1

using namespace std;

int main() {
    int n;

    cout << "Введите размерность матриц n: ";
    cin >> n;

    int matrix1[n][n], matrix2[n][n], result[n][n];

    cout<<"Первая матрица"<<endl;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
         matrix1[i][j]=rand()%20-10;
         cout << matrix1[i][j] << " ";
        }
        cout<<endl;
    }
    cout<<endl;

     cout<<"Вторая матрица"<<endl;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
         matrix2[i][j]=rand()%20-10;
         cout << matrix2[i][j] << " ";
        }
        cout<<endl;
    }
    cout<<endl;

    //заполнение результ матрицы нулями
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            result[i][j] = 0;
        }
    }

    //перемножение матриц
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            for (int k = 0; k < n; k++) {
                result[i][j] += matrix1[i][k] * matrix2[k][j];
            }
        }
    }

    cout << "Результат перемножения матриц:" << endl;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cout << result[i][j] << " ";
        }
        cout << endl;
    }

    return 0;
}


2


#include <iostream>
#include <cmath>
//2
using namespace std;

//функция для метода трапеций
double trapez(double (*func)(double), double a, double b, int n) {
    double h = (b - a) / n;
    double integral = 0.5 * (func(a) + func(b));

    for (int i = 1; i < n; ++i) {
        integral += func(a + i * h);
    }

    integral *= h;
    return integral;
}

//рекурсивно методом трапеций
double trapezRecursive(double (*func)(double), double a, double b, int n) {
    if (n == 1) {
        return 0.5 * (func(a) + func(b)) * (b - a);
    } else {
        double h = (b - a) / n;
        return trapezRecursive(func, a, b - h, n - 1) + func(a + (n - 1) * h) * h;
    }
}

//функция для метода прямоугольников (левый)
double rectan(double (*func)(double), double a, double b, int n) {
    double h = (b - a) / n;
    double integral = 0;

    for (int i = 0; i < n; ++i) {
        integral += func(a + i * h) * h;
    }

    return integral;
}

//рекурсивно методом прямоугольников
double rectanRecursive(double (*func)(double), double a, double b, int n) {
    if (n == 1) {
        return func(a) * (b - a);
    } else {
        double h = (b - a) / n;
        return rectanRecursive(func, a, b - h, n - 1) + func(a + (n - 1) * h) * h;
    }
}

//пример функции для интегрирования
double myFunction(double x) {
    return x * x;
}

int main() {
    double a = 0; //начало интервала
    double b = 1; //конец интервала
    int n = 100; //количество делений

    cout << "Метод трапеций (итеративно): " << trapez(myFunction, a, b, n) << endl;
    cout << "Метод трапеций (рекурсивно): " << trapezRecursive(myFunction, a, b, n) << endl;
    cout << "Метод прямоугольников (итеративно): " << rectan(myFunction, a, b, n) << endl;
    cout << "Метод прямоугольников (рекурсивно): " << rectanRecursive(myFunction, a, b, n) << endl;

    return 0;
}


3


#include <iostream>
//3
using namespace std;

int main() {
    const int n=3;
    const int rows = n;
    const int cols = n;

    int matrixA[rows][cols];
    for (int i = 0; i < rows; i++){
        for(int j = 0; j < cols; j++){
         matrixA[i][j]=rand()%200-100;
         cout << matrixA[i][j] << " ";
        }
        cout<<endl;
    }
    cout << endl;

    int matrixB[rows][cols];

    //процесс копирования с использованием буферной переменной
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            //использую временную переменную для хранения значения
            int buffer = matrixA[i][j];
            matrixB[i][j] = buffer;
        }
    }

    cout << "Содержимое матрицы B после копирования:\n";
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            cout << matrixB[i][j] << " ";
        }
        cout << endl;
    }

    return 0;
}


4

#include <iostream>
//4
using namespace std;

void quickSort(int arr[], int low, int high) {
    if (low < high) {
        //опорный элемент
        int pivot = arr[high];
        int i = (low - 1);

        for (int j = low; j < high; j++) {
            //если меньше или равен опорному
            if (arr[j] < pivot) {
                i++; //увеличиваем индекс меньшего элемента
                swap(arr[i], arr[j]); //меняем местами
            }
        }
        swap(arr[i + 1], arr[high]); //меняем местами опорный элемент
        int pi = i + 1; //индекс опорного элемента

        //рекурсивно сортируем элементы до и после разбиения
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

int main() {
    int SIZE;
    cout << "Введите размерность массива n: ";
    cin>>SIZE;
    int arr[SIZE];
    cout << "Массив до сортировки: ";
    for (int i = 0; i < SIZE; i++){
        arr[i]=rand()%200-100;
        cout << arr[i] << " ";}
    cout << endl;

    quickSort(arr, 0, SIZE - 1);

    cout << "Массив после сортировки: ";
    for (int i = 0; i < SIZE; i++)
        cout << arr[i] << " ";
    cout << endl;

    return 0;
}


5


#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
//5
//функция для получения i-го бита числа
bool getBit(int num, int i) {
    return (num >> i) & 1;
}

//функция поразрядной сортировки
void radixSort(vector<int>& arr) {
    //находим максимально возможное значение для определения длины (битов)
    int maxValue = *max_element(arr.begin(), arr.end());
    int numBits = sizeof(int) * 8; //число бит в int
    //сортируем поразрядно от младших бит до старших
    for (int i = 0; i < numBits; i++) {
        vector<int> zeros; //для хранения чисел с текущим битом 0
        vector<int> ones; //для хранения чисел с текущим битом 1
        
        //разделяем массив на два: с 0 и 1 в текущем битовом разряде
        for (int num : arr) {
            if (getBit(num, i)) {
                ones.push_back(num);
            } else {
                zeros.push_back(num);
            }
        }
        
        //объединяем два массива
        arr.clear();
        arr.insert(arr.end(), zeros.begin(), zeros.end());
        arr.insert(arr.end(), ones.begin(), ones.end());
    }
}

int main() {
    int n;

    cout << "Введите размерность массива n: ";
    cin >> n;
    
    vector<int> arr;
    for(int i=0;i<n;i++)
        arr.push_back(rand()%100);

    radixSort(arr);

    cout << "Отсортированный массив: ";
    for (int num : arr) {
        cout << num << " ";
    }
    cout << endl;

    return 0;
}