finaly_hueta

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <pthread.h>
#include <string.h>

#define ROWS 4
#define COLS 5

struct ThreadResult {
    int count;
    int indexes[6];
};

struct ThreadInfo {
    int matrix[ROWS][COLS];
    int deltaX;
    int deltaY;
    int currentIndexI;
    int currentIndexJ;
    struct ThreadResult result;
};

void fill_matrix(int array[ROWS][COLS]) {
    srand(time(NULL));
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            array[i][j] = 1 + rand() % 3;
        }
    }
}

void print_matrix(int array[ROWS][COLS]) {
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%d ", array[i][j]);
        }
        printf("\n");
    }
}

void *get_values(void *info_) {
    struct ThreadInfo *info = (struct ThreadInfo *) info_;
    struct ThreadResult *result = (struct ThreadResult *) malloc(sizeof(struct ThreadResult));
    result->count = 0;
    // Вот отсюда можно выкинуть вычисление уголочка из этой точки в отдельный поток
    int k = 0;
    int lengthOfHorizontal = 0; // Сюда сохраняем длину повторящихся символов в строке
    int i = info->currentIndexI;
    int j = info->currentIndexJ;
    while (0 < j + k && j + k < COLS && info->matrix[i][j + k] == info->matrix[i][j]) {
        lengthOfHorizontal++;
        // Или вот отсюда можно запускать потоки, проверяющие вертикальные линии на совпадение с элементом matrix[i][j]
        // Нижний цикл выкинуть в отдельный поток
        int l = 0;
        int lengthOfVertical = 0; // Сюда сохраняем длину повторяющихся символов в столбце
        while (0 < i + l && i + l < ROWS && info->matrix[i + l][j + k] == info->matrix[i][j + k]) {
            lengthOfVertical++;
            l += info->deltaX;
        }
        if (lengthOfHorizontal + lengthOfVertical > result->count) {
            result->indexes[0] = i;
            result->indexes[1] = j;
            result->indexes[2] = i;
            result->indexes[3] = j + k;
            result->indexes[4] = i + l - 1 * info->deltaX;
            result->indexes[5] = j + k;
            result->count = lengthOfHorizontal + lengthOfVertical;
//                    coords = {i, j, i, j + k, i + l - 1, j + k};
        }
        k += info->deltaY;
    }
    return (void *) result;
}

void find_g(int matrix[ROWS][COLS]) {
    int maxCount = 0;
    int coords[] = {0, 0, 0, 0, 0, 0};
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            struct ThreadInfo first, second, third, fourth;
            struct ThreadResult *result1, *result2, *result3, *result4;
            memcpy(first.matrix, matrix, ROWS * COLS * sizeof(int));
            memcpy(second.matrix, matrix, ROWS * COLS * sizeof(int));
            memcpy(third.matrix, matrix, ROWS * COLS * sizeof(int));
            memcpy(fourth.matrix, matrix, ROWS * COLS * sizeof(int));
            first.deltaX = 1;
            first.deltaY = -1;
            first.currentIndexI = i;
            first.currentIndexJ = j;

            second.deltaX = -1;
            second.deltaY = -1;
            second.currentIndexI = i;
            second.currentIndexJ = j;

            third.deltaX = -1;
            third.deltaY = 1;
            third.currentIndexI = i;
            third.currentIndexJ = j;

            fourth.deltaX = 1;
            fourth.deltaY = 1;
            fourth.currentIndexI = i;
            fourth.currentIndexJ = j;

            pthread_t thread1, thread2, thread3, thread4;
            pthread_create(&thread1, NULL, &get_values, &first);
            pthread_create(&thread2, NULL, &get_values, &second);
            pthread_create(&thread3, NULL, &get_values, &third);
            pthread_create(&thread4, NULL, &get_values, &fourth);
            pthread_join(thread1, (void **) &result1);
            pthread_join(thread2, (void **) &result2);
            pthread_join(thread3, (void **) &result3);
            pthread_join(thread4, (void **) &result4);
//            for (int i = 0; i < 6; i++) {
//                printf("%d ", first.result.indexes[i]);
//            }
//            printf("\n");
            if (result1->count > maxCount) {
                maxCount = result1->count;
                memcpy(coords, result1->indexes, sizeof(result1->indexes));
            }
            if (result2->count > maxCount) {
                maxCount = result2->count;
                memcpy(coords, result2->indexes, sizeof(result2->indexes));
            }
            if (result3->count > maxCount) {
                maxCount = result3->count;
                memcpy(coords, result3->indexes, sizeof(result3->indexes));
            }
            if (result4->count > maxCount) {
                maxCount = result4->count;
                memcpy(coords, result4->indexes, sizeof(result4->indexes));
            }
        }
    }
    for (int i = 0; i < 6; i++) {
        printf("%d ", coords[i]);
    }
}

int main() {
//    printf("Hello, World!\n");
    int arr[ROWS][COLS] = {{0, 2, 0, 2, 0},
                           {0, 1, 1, 1, 0},
                           {2, 0, 2, 1, 1},
                           {0, 2, 0, 1, 1}};
//    fill_matrix(arr);
    print_matrix(arr);
    find_g(arr);
    return 0;
}