Matrix C

/*
cc std=c11 -Wall -Werror -pedantic matrix.c -o matrix
*/


#include <stdio.h>
#include <string.h>
#include <inttypes.h>

const int minN = 2;
const int maxN = 25;

#define FORMAT_PRId32FIXED "%-11"PRId32

int matrix_read(int n, int32_t matrix[n][n]) {
    for (int row = 0; row < n; ++row) {
        for (int col = 0; col < n; ++col) {
            int32_t val = 0;
            int ret = scanf("%"SCNd32, &val);
            if (ret != 1)
                return -1;
            else
                matrix[row][col] = val;

        }
    }
    return 0;
}

void matrix_print(int n, int32_t matrix[n][n]) {
    for (int row = 0; row < n; ++row) {
        for (int col = 0; col < n-1; ++col) {
            printf(FORMAT_PRId32FIXED" ", matrix[row][col]);
        }
        printf(FORMAT_PRId32FIXED, matrix[row][n-1]);
        printf("\n");
    }
}


int matrix_positive_below_main_diagonal(int n, int32_t matrix[n][n], int32_t array[(n*(n-1))/2]) {
    int num_elems = 0;
    for (int row = 1; row < n; ++row) {
        for (int col = 0; col < row; ++col) {
            int32_t val = matrix[row][col];
            if (val > 0) {
                array[num_elems] = val;
                ++num_elems;
            }
        }
    }
    return num_elems;
}

void matrix_zero_negative(int n, int32_t matrix[n][n]) {
    for (int row = 0; row < n; ++row) {
        for (int col = 0; col < n; ++col) {
            int32_t *val = &matrix[row][col];
            if (*val < 0) {
                *val = 0;
            }
        }
    }
}

void array_print(int n, int32_t array[n]) {
    if (n <= 0) {
        return;
    }
    for (int i = 0; i < n - 1; ++i) {
        printf("%"PRId32", ", array[i]);
    }
    printf("%"PRId32, array[n-1]);
    printf("\n");
}

int main(int argc, char *argv[]) {
    (void)(argc);
    (void)(argv);
    int N = 0;
    int ret;
    ret = scanf("%d", &N);
    if (ret != 1 || (minN > N || N > maxN)) {
        return -1;
    }
    int32_t A[N][N];
    ret = matrix_read(N, A);
    if (ret != 0) {
        return -1;
    }

    int32_t array[(N*(N-1))/2];
    int num_positive_below_main_diagonal =
            matrix_positive_below_main_diagonal(N, A, array);

    int B[num_positive_below_main_diagonal];
    memcpy(B, array, num_positive_below_main_diagonal * sizeof(B[0]));
    //printf("B:\n");
    //array_print(num_positive_below_main_diagonal, B);
    matrix_zero_negative(N, A);
    //printf("A:\n");
    matrix_print(N, A);
    return 0;
}