C++ KOLOS

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

#define MATRIX struct matrix
#define POINT struct point
#define TRUE 1
#define FALSE 0
#define MAXMINERROR -1;
#define OUTOFRANGEERROR -2;
#define NUMFORMATERROR -3;

MATRIX {
    int w,h;
    int** e;
};

POINT {
    int x,y;
};

MATRIX createRandomMatrix(int, int);
void displayMatrix(MATRIX);
int* findLargest(MATRIX);
int* findLargestRow(MATRIX);
int* findLargestColumn(MATRIX);
MATRIX cut(POINT, POINT, MATRIX);
void save(MATRIX);

int main()
{
    srand(time(0));

    MATRIX m = createRandomMatrix(5, 4);
    displayMatrix(m);

    int* l = findLargest(m);
    int* lR = findLargestRow(m);
    int* lC = findLargestColumn(m);
    printf("\nLargest: %d [%d][%d]\n\n", l[0], l[1], l[2]);
    printf("Largest row number %d  (val. %d)\n", lR[1], lR[0]);
    printf("Largest column number %d  (val. %d)\n\n", lC[1], lC[0]);

    POINT a, b;
    printf("Podaj p. A wyciecia macierzy: ");
    scanf("%d;%d", &a.x, &a.y);
    printf("Podaj p. B wyciecia macierzy: ");
    scanf("%d;%d", &b.x, &b.y);

    MATRIX n = cut(a, b, m);

    printf("\n\n");
    displayMatrix(n);
    printf("\n\n");

    return 0;
}

MATRIX createRandomMatrix(int w, int h) {
    MATRIX m;
    m.w = w;
    m.h = h;
    m.e = malloc(sizeof(int) * w);
    for (int i = 0 ; i < w ; i++)
        m.e[i] = malloc(sizeof(int) * h);
    for (int x = 0 ; x < w ; x++){
        for (int y = 0 ; y < h ; y++){
            m.e[x][y] = rand() % 10;
        }
    }
    return m;
}

void displayMatrix(MATRIX m) {
    for (int x = 0 ; x < m.w ; x++){
        for (int y = 0 ; y < m.h ; y++){
            printf("%d ", m.e[x][y]);
        }
        printf("\n");
    }
}

int* findLargest(MATRIX m) {

    int largest = m.e[0][0], i = 0, j = 0;
    for (int x = 0 ; x < m.w ; x++){
        for (int y = 0 ; y < m.h ; y++){
            if (m.e[x][y] > largest){
                largest = m.e[x][y];
                i = x;
                j = y;
            }
        }
    }

    int* res = malloc(sizeof(int) * 3);
    res[0] = largest;
    res[1] = i;
    res[2] = j;
    return res;
}

int* findLargestRow(MATRIX m) {

    int sum = 0, largest, largestRow;
    short f = TRUE;

    for (int x = 0 ; x < m.w ; x++){

        for (int y = 0 ; y < m.h ; y++){
            sum += m.e[x][y];
        }

        if (f == TRUE){
            largest = sum;
            largestRow = x;
            f = FALSE;
        }
        else {
            if (sum > largest){
                largest = sum;
                largestRow = x;
            }
        }

        sum = 0;

    }

    int* res = malloc(sizeof(int) * 2);
    res[0] = largest;
    res[1] = largestRow;

    return res;
}

int* findLargestColumn(MATRIX m) {

    int sum = 0, largest, largestRow;
    short f = TRUE;

    for (int x = 0 ; x < m.h ; x++){

        for (int y = 0 ; y < m.w ; y++){
            sum += m.e[y][x];
        }

        if (f == TRUE){
            largest = sum;
            largestRow = x;
            f = FALSE;
        }
        else {
            if (sum > largest){
                largest = sum;
                largestRow = x;
            }
        }

        sum = 0;

    }

    int* res = malloc(sizeof(int) * 2);
    res[0] = largest;
    res[1] = largestRow;

    return res;
}

MATRIX cut(POINT a, POINT b, MATRIX m) {

    MATRIX n;
    if (a.x < 0 || a.y < 0 || b.x < 0 || b.y < 0){
        n.w = NUMFORMATERROR;
        return n;
    }
    if (a.x > b.x && a.y > b.y){
        n.w = MAXMINERROR;
        return n;
    }
    if (a.x > m.w || a.y > m.h || b.x > m.w || b.y > m.h){
        n.w = OUTOFRANGEERROR;
        return n;
    }

    n.w = b.x - a.x + 1;
    n.h = b.y - a.y + 1;
    n.e = malloc(sizeof(int) * n.w);
    for (int i = 0 ; i < n.w ; i++)
        n.e[i] = malloc(sizeof(int) * n.h);

    int i = 0, j = 0; // x, y
    for (int x = a.x ; x < b.x + 1 ; x++){
        for (int y = a.y ; y < b.y + 1 ; y++){
            n.e[i][j] = m.e[x][y];
            j++;
        }
        i++;
        j = 0;
    }

    return n;
}