AntiAbgaryan

/*Задача 1*/
#include <omp.h>
#include <stdio.h>
#include <iostream>
int main()
{
    /*
    int count = 0;
    #pragma omp parallel num_threads(8)
    {
        int i = omp_get_thread_num();
        count++;
        printf_s("Hello world from thread %d\n", i);
    }
    printf_s("All threads in parallel area %d", count);
    */
    using std::cout;
    int count = 0;
    #pragma omp parallel num_threads(8)
    {
        int i = omp_get_thread_num();
        count++;
        #pragma omp critical
        {
        cout << "Hello world from thread " << i << "\n";
        }
    }
    cout << "All threads in parallel area " << count;
    return 0;
}
/*Задача 2*/
#include <omp.h>
#include <stdio.h>

void parallel_area(int);
int main()
{
    parallel_area(3);
    parallel_area(1);

    return 0;
}
void parallel_area(int threads)
{
    #pragma omp parallel num_threads(threads) if(threads>1)
    {
        if (omp_in_parallel())
        {
            #pragma omp single
            {
                printf_s("All threads: %d\n", threads);
            }
            printf_s("Num thread: %d\n", omp_get_thread_num());
        }
    }
}
/*Задача 3*/
#include <omp.h>
#include <ctime>
#include <iostream>
void rand_init()
{
    time_t t;
    time(&t);
    srand((unsigned int)t);
}
int main()
{

    setlocale(LC_ALL, "RU");
    using std::cout;
    int a, b;
    rand_init();
    a = rand();
    b = rand();
    cout << "До входа в параллельную область #1 a = " << a << " b = " << b << "\n";
    #pragma omp parallel num_threads(2) private(a) firstprivate(b)
    {
        #pragma omp critical
        {
            a = rand();
            cout << "Значения  а и b до сложения с номером потока: " << a << " " << b << "\n";
            b += omp_get_thread_num();
            a += omp_get_thread_num();
            cout << "В 1ой параллельной области а = " << a << " b = " << b << " в потоке " << omp_get_thread_num() << " \n";
        }
    }
    cout << "После выхода из 1ой параллельной области a = " << a << " b = " << b << "\n\n";
    cout << "До входа в параллельную область #2 a = " << a << " b = " << b << "\n";
    #pragma omp parallel num_threads(4) private(b) shared(a)
    {
        #pragma omp critical
        {
            b = rand();
            cout << "Значения  а и b до вычитания с номером потока: " << a << " " << b << "\n";
            a -= omp_get_thread_num();
            b -= omp_get_thread_num();
            cout << "Во 2ой параллельной области а = " << a << " b = " << b << " в потоке " << omp_get_thread_num() << " \n";
        }
    }
    cout << "После выхода из 2ой параллельной области a = " << a << " b = " << b << "\n";

    return 0;
}
/*Задача 4*/
#include <omp.h>
#include <iostream>
int main()
{
    int a[10]{ 2,-1,7,3,4,100,-50,10,4,10 };
    int b[10]{ 10,5,4,3,2,1,7,8,9,6 };
    #pragma omp parallel num_threads(2)
    {
        #pragma omp critical
        {
            if (omp_get_thread_num() == 0)
            {
                int min = a[0];
                for (int i = 0; i < 10; i++)
                    if (a[i] < min)
                        min = a[i];
                std::cout << "Min element of array A : " << min << "\n";
            }
            else
            {
                int max = b[0];
                for (int j = 0; j < 10; j++)
                    if (b[j] > max)
                        max = b[j];
                std::cout << "Max element of array B : " << max << "\n";
            }
        }
    }

    return 0;
}
/*Задача 5*/
#include <omp.h>
#include <iostream>
#include <ctime>
void rand_init()
{
    time_t t;
    time(&t);
    srand((unsigned int)t);
}
int** initarray()
{
    int i, j;
    int** d = new int* [6];
    for (i = 0; i < 6; i++)
        d[i] = new int[8];
    for (i = 0; i < 6; i++)
        for (j = 0; j < 8; j++)
            d[i][j] = rand();
    return d;
}
void deletearray(int** d)
{
    for (int i = 0; i < 6; i++)
        delete[]d[i];
    delete[] d;
}
double srarif(int** d)
{
    int sr = 0;
    for (int i = 0; i < 6; i++)
        for (int j = 0; j < 8; j++)
            sr += d[i][j];
    return sr / 48;
}
int getmin(int** d)
{
    int min = d[0][0];
    for (int i = 0; i < 6; i++)
        for (int j = 0; j < 8; j++)
            if (d[i][j] < min)
                min = d[i][j];
    return min;
}
int getmax(int** d)
{
    int max = d[0][0];
    for (int i = 0; i < 6; i++)
        for (int j = 0; j < 8; j++)
            if (d[i][j] > max)
                max = d[i][j];
    return max;
}
int kratno3(int** d)
{
    int k = 0;
    for (int i = 0; i < 6; i++)
        for (int j = 0; j < 8; j++)
            if (d[i][j] % 3 == 0)
                k++;
    return k;
}
void showarray(int** d)
{
    for (int i = 0; i < 6; i++)
    {
        for (int j = 0; j < 8; j++)
            std::cout << d[i][j] << " ";
        std::cout << "\n";
    }
}
int main()
{
    setlocale(LC_ALL, "RU");
    //rand_init();
    int** d = initarray();
    int n;
    showarray(d);
    std::cout << "\n";
    #pragma omp parallel private(n)
    {
        n = omp_get_thread_num();
        #pragma omp sections
        {
            #pragma omp section
            {
                std::cout << "Среднее арифметическое" << srarif(d) << " ,посчитанное потоком " << n << "\n";
            }
            #pragma omp section
            {
                std::cout << "Минимальный и максимальный элементы соответственно: " << getmin(d) << " " << getmax(d)
                    << " ,найденные потоком " << n << "\n";
            }
            #pragma omp section
            {
                std::cout << "Количество элементов в массиве кратных 3: " << kratno3(d)
                    << " ,найденное потоком " << n << "\n";
            }
        }
    }
    deletearray(d);
    return 0;
}
/*Задача 6*/
#include <omp.h>
#include <iostream>
int* initarray(int n)
{
    int* s = new int[n];
    for (int i = 0; i < n; i++)
        std::cin >> s[i];
    return s;
}
int main()
{
    setlocale(LC_ALL, "RU");
    int* a = initarray(10);
    int* b = initarray(10);
    double sr1 = 0, sr2 = 0;
    #pragma omp parallel
    {
        #pragma omp for reduction(+: sr1, sr2)
        for (int i = 0; i < 10; i++)
        {
            sr1 += a[i];
            sr2 += b[i];
        }
        #pragma omp single
        {
            sr1 = sr1 / 10;
            sr2 = sr2 / 10;
            if (sr1 == sr2)
                std::cout << "Среднее арифметическое массива A равно ср. ариф. B\n";
            else
            {
                if(sr1<sr2)
                    std::cout << "Среднее арифметическое массива A меньше ср. ариф. B\n";
                else
                    std::cout << "Среднее арифметическое массива A больше ср. ариф. B\n";
            }
        }
    }
    delete[]a;
    delete[]b;

    return 0;
}
/*Задача 7*/
#include <omp.h>
#include <iostream>
#include <stdio.h>
int main()
{
    setlocale(LC_ALL, "RU");
    int a[12], b[12], c[12];
    using std::cin;
    using std::cout;
    int n;
    #pragma omp parallel num_threads(3)
    {
        #pragma omp single
        {
            printf_s("Всего нитей в 1ой параллельной области: %d\n", omp_get_num_threads());
        }
        #pragma omp for schedule(static, 4)
        for (int i = 0; i < 12; i++)
        {
            a[i] = i;
            b[i] = i + 1;
            n = omp_get_thread_num();
            //cout << "Итерация под номером " << i << " ,выполяемая нитью номером " << n << "\n";
            printf_s("Итерация под номером %d, выполняемая нитью номером %d, элементы массивов А и В: %d %d\n", i, n, a[i], b[i]);
        }
    }
    cout << "\n";
    #pragma omp parallel num_threads(4)
    {
        #pragma omp single
        {
            printf_s("Всего нитей в 2ой параллельной области: %d\n", omp_get_num_threads());
        }
        #pragma omp for schedule(dynamic, 3)
        for (int i = 0; i < 12; i++)
        {
            c[i] = a[i] + b[i];
            n = omp_get_thread_num();
            printf_s("Итерация под номером %d, выполняемая нитью номером %d, элемент массива С: %d\n", i, n, c[i]);
        }
    }

    return 0;
}
/*Задача 8*/
#include <omp.h>
#include <iostream>
#include <ctime>
using std::cin;
using std::cout;
int** init(int n, int m = 1);
void deletee(int**, int n, int m = 1);
int** usualmult(int**, int**, int, int, int);
void show(int**, int n, int m = 1);
int** parallelmult(int**, int**, int, int, int);
int main()
{
    setlocale(LC_ALL, "RU");
    int n1, m1, n2;
    cout << "Введите размерности матрицы: \n";
    cin >> n1 >> m1;
    int** m = init(n1, m1);
    cout << "Введите размерность вектора.\n";
    cout << "Предполгается, что вектор частный случай матрицы, поэтому 2я размерность = 1\n";
    cin >> n2;
    int** v = init(n2);
    if (m1 != n2)
        cout << "Умножение матрицы на вектор невозможно.";
    else
    {
        double seconds, st, end;
        st = omp_get_wtime();
        int** res1 = usualmult(m, v, n1, m1, n2);
        end = omp_get_wtime();
        seconds = end - st;
        cout << "Результат умножения последовательной программы: \n";
        show(res1, n1);
        cout << "Время ее выполнения: " << seconds << " с\n";
        st = omp_get_wtime();
        int** res2 = parallelmult(m, v, n1, m1, n2);
        end = omp_get_wtime();
        seconds = end - st;
        cout << "Результат умножения параллельной программы: \n";
        show(res2, n1);
        cout << "Время ее выполнения: " << seconds << " с\n";
        deletee(res1, n1);
        deletee(res2, n1);
    }
    deletee(m, n1, m1);
    deletee(v, n2);

    return 0;
}
int** init(int n, int m)
{
    int** a = new int* [n];
    for (int i = 0; i < n; i++)
        a[i] = new int[m];
    cout << "Введите матрицу(вектор): \n";
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            cin >> a[i][j];
    return a;
}
void deletee(int**a, int n, int m)
{
    for (int i = 0; i < n; i++)
        delete[]a[i];
    delete[]a;
}
int** usualmult(int** m, int** v, int n1, int m1, int n2)
{
    int i, j, k;
    int** res = new int* [n1];
    for (i = 0; i < n1; i++)
        res[i] = new int[1];
    for (j = 0, i = 0; j < n1; j++, i++)
    {
        res[i][0] = 0;
        for (k = 0; k < m1; k++)
            res[i][0] += m[i][k] * v[k][j - i];
    }
    return res;
}
int** parallelmult(int** m, int** v, int n1, int m1, int n2)
{
    int i, j, k, temp;
    int** res = new int* [n1];
    #pragma omp parallel for
    for (i = 0; i < n1; i++)
        res[i] = new int[1];
    for (j = 0, i = 0; j < n1; j++, i++)
    {
        temp = 0;
        #pragma omp parallel for reduction (+:temp)
        for (k = 0; k < m1; k++)
            temp += m[i][k] * v[k][j - i];
        res[i][0] = temp;
    }
    return res;
}
void show(int** a, int n, int m)
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
            cout << a[i][j] << " ";
        cout << "\n";
    }
}
/*Задача 9*/
#include <omp.h>
#include <iostream>
#include <ctime>
void rand_init()
{
    time_t t;
    time(&t);
    srand((unsigned int)t);
}
int** initarray()
{
    int i, j;
    int** d = new int* [6];
    for (i = 0; i < 6; i++)
        d[i] = new int[8];
    for (i = 0; i < 6; i++)
        for (j = 0; j < 8; j++)
            d[i][j] = rand();
    return d;
}
void showarray(int** d)
{
    for (int i = 0; i < 6; i++)
    {
        for (int j = 0; j < 8; j++)
            std::cout << d[i][j] << " ";
        std::cout << "\n";
    }
}
void deletearray(int** d)
{
    for (int i = 0; i < 6; i++)
        delete[]d[i];
    delete[] d;
}
int main()
{
    int i, j;
    rand_init();
    int** d = initarray();
    showarray(d);
    int min, max;
    max = min = d[0][0];
    #pragma omp parallel for num_threads(3)
    for (i = 0; i < 6; i++)
    {
        for (j = 0; j < 8; j++)
        {
            if (d[i][j] > max)
            {
                #pragma omp critical
                {

                    if (d[i][j] > max)
                        max = d[i][j];
                }
            }
            if (d[i][j] < min)
            {
                #pragma omp critical
                {

                    if (d[i][j] < min)
                        min = d[i][j];
                }
            }
        }
    }
    std::cout << "\n";
    std::cout << "Max and min elements of array: " << max << " " << min;
    deletearray(d);

    return 0;
}
/*Задача 10*/
#include <omp.h>
#include <ctime>
#include <iostream>
void rand_init()
{
    time_t t;
    time(&t);
    srand((unsigned int)t);
}
inline int* initarray()
{
    int* res = new int[30];
    for (int i = 0; i < 30; i++)
        res[i] = rand();
    return res;
}
inline void showarray(int* a)
{
    for (int i = 0; i < 30; i++)
    {
        std::cout << a[i] << " ";
        if (i % 10 == 0 && i!=0)
            std::cout << "\n";
    }
    std::cout << "\n";
}
int main()
{
    rand_init();
    setlocale(LC_ALL, "RU");
    int* a = initarray();
    int i, count = 0;
    showarray(a);
    #pragma omp parallel for num_threads(3)
    for (i = 0; i < 30; i++)
    {
        if (a[i] % 9 == 0)
        {
            #pragma omp atomic
            count++;
        }
    }
    std::cout << "Количество чисел кратных 9 в массиве А: " << count;
    delete[]a;
    return 0;
}
/*Задача 11*/
#include <omp.h>
#include <iostream>
#include <ctime>
void rand_init()
{
    time_t t;
    time(&t);
    srand((unsigned int)t);
}
inline int* initarray(int n)
{
    int* res = new int[n];
    for (int i = 0; i < n; i++)
        res[i] = rand();
    return res;
}
inline void showarray(int* a, int n)
{
    for (int i = 0; i < n; i++)
    {
        std::cout << a[i] << " ";
    }
    std::cout << "\n";
}
int firstmax(int* a, int n)
{
    int i, max = 0;
    for (i = 0; i < n; i++)
    {
        if (a[i] % 7 == 0)
        {
            max = a[i];
            return max;
        }
    }
    return max;
}
int main()
{
    setlocale(LC_ALL, "RU");
    int i, max, n;
    std::cout << "Введите размерность массива: ";
    std::cin >> n;
    rand_init();
    int* a = initarray(n);
    showarray(a, n);
    std::cout << "\n";
    max = firstmax(a, n);
    bool c = true;
    if (max == 0)
    {
        std::cout << "В массиве нет чисел кратных 7!";
        c = false;
    }
    else
    {
        #pragma omp parallel for num_threads(8)
        for (i = 0; i < n; i++)
        {
            if (a[i] > max && a[i] % 7 == 0)
            {
                #pragma omp critical
                {
                    if (a[i] > max && a[i] % 7 == 0)
                        max = a[i];
                }
            }
        }
    }
    if (c)
        std::cout << "Максимальное число кратное 7: " << max;
    delete[]a;
    return 0;
}
/*Задача 12*/
#include <omp.h>
#include <Windows.h>
#include <stdio.h>
int main()
{
    int time;
    #pragma omp parallel num_threads(8) private(time)
    {
        int n = omp_get_thread_num();
        #pragma omp barrier
        {
            switch (n)
            {
            case 0:
                time = 1000;
                break;
            case 1:
                time = 900;
                break;
            case 2:
                time = 800;
                break;
            case 3:
                time = 700;
                break;
            case 4:
                time = 600;
                break;
            case 5:
                time = 500;
                break;
            case 6:
                time = 200;
                break;
            case 7:
                time = 0;
                break;
            }
        }
        Sleep(time);
        #pragma omp critical
        {
            printf_s("Hello World from thread %d\n", n);
        }
    }

    return 0;
}
/*Задача 13*/
#include <omp.h>
#include <cmath>
#include <iostream>
int main()
{
    using std::cin;
    using std::cout;
    setlocale(LC_ALL, "RU");
    int i, n, ch = 0;
    cout << "Введите количество бит: \n";
    cin >> n;
    int* a = new int[n];
    cout << "Введите ваше число в двоичной системе: \n";
    for (i = 0; i < n; i++)
        cin >> a[i];
    #pragma omp parallel for reduction(+:ch)
    for (i = n - 1; i > -1; i--)
    {
        if (a[i] == 1)
            ch += pow(2, n - (i + 1));
    }
    cout << "Десятичное число: " << ch;

    return 0;
}
/*Задача 14*/
#include <omp.h>
#include <iostream>

int main()
{
    setlocale(LC_ALL, "RU");
    int i, n, k = 0, a = 1;
    std::cout << "Введите число, которое хотите возвести в квадрат: ";
    std::cin >> n;
    #pragma omp parallel for reduction (+:k)
    for (i = 0; i < n; i++)
    {
        k += a;
        a += 2;
    }
    std::cout << "Квадрат числа " << n << " равен " << k;

    return 0;
}
/*Задача 15*/
#include <omp.h>
#include <iostream>
int isprime(int n)
{
    for (int i = 2; i <= sqrt(n); i++)
    {
        if (n % i == 0)
            return false;
    }
    return true;
}
int main()
{
    setlocale(LC_ALL, "RU");
    int i, ch1, ch2;
    std::cout << "Введите диапазон: \n";
    std::cin >> ch1 >> ch2;
    #pragma omp parallel for num_threads(8)
    for (i = ch1; i <= ch2; i++)
        if (isprime(i))
            std::cout << i << " ";


    return 0;
}