Initial Query

Rewrite this function in C. You can assume that the input is a 2d matrix correctly formatted. Call it rref(int** matrix, int rows, int cols, int graphlen) where the size is matrix[rows][cols]. Return an int** of used_for_row. def rref(matrix, graphlen): PH = 16 extra = 0 col = 0 pivots = [] used_for_row = [set([i]) for i in range(matrix.shape[0])] matrix = matrix%PH while col+extra < matrix.shape[1]-1 and col < matrix.shape[0]: if matrix[col,col+extra] == 0: if np.all(matrix[:,col] == 0): extra += 1 continue other = np.argwhere(matrix[:,col+extra] != 0).flatten()[-1] if other < col: extra += 1 continue matrix[col], matrix[other] = list(matrix[other]), list(matrix[col]) used_for_row[col], used_for_row[other] = used_for_row[other], used_for_row[col] pivots.append(col+extra) pivot = matrix[col,col+extra] if col+extra < graphlen: assert np.abs(pivot) == 1 or np.abs(pivot) == PH-1 else: assert np.abs(pivot) == 2 or np.abs(pivot) == PH-2 pivot //= 2 matrix[col] *= pivot matrix[col] %= PH others = np.argwhere(matrix[:,col+extra]).flatten() for i in others: if i == col: continue used_for_row[i] |= used_for_row[col] if col < graphlen: matrix[i] -= matrix[col]*matrix[i,col+extra] else: while matrix[i,col+extra] != 0: matrix[i] = (matrix[i]-matrix[col])%PH matrix[i] %= PH col += 1 matrix = np.array(matrix)%PH return [sorted(x) for x in used_for_row]

LLM Generation

Query

Rewrite this function in C. You can assume that the input is a 2d matrix correctly formatted. Call it rref(int** matrix, int rows, int cols, int graphlen) where the size is matrix[rows][cols]. Return an int** of used_for_row. def rref(matrix, graphlen): PH = 16 extra = 0 col = 0 pivots = [] used_for_row = [set([i]) for i in range(matrix.shape[0])] matrix = matrix%PH while col+extra < matrix.shape[1]-1 and col < matrix.shape[0]: if matrix[col,col+extra] == 0: if np.all(matrix[:,col] == 0): extra += 1 continue other = np.argwhere(matrix[:,col+extra] != 0).flatten()[-1] if other < col: extra += 1 continue matrix[col], matrix[other] = list(matrix[other]), list(matrix[col]) used_for_row[col], used_for_row[other] = used_for_row[other], used_for_row[col] pivots.append(col+extra) pivot = matrix[col,col+extra] if col+extra < graphlen: assert np.abs(pivot) == 1 or np.abs(pivot) == PH-1 else: assert np.abs(pivot) == 2 or np.abs(pivot) == PH-2 pivot //= 2 matrix[col] *= pivot matrix[col] %= PH others = np.argwhere(matrix[:,col+extra]).flatten() for i in others: if i == col: continue used_for_row[i] |= used_for_row[col] if col < graphlen: matrix[i] -= matrix[col]*matrix[i,col+extra] else: while matrix[i,col+extra] != 0: matrix[i] = (matrix[i]-matrix[col])%PH matrix[i] %= PH col += 1 matrix = np.array(matrix)%PH return [sorted(x) for x in used_for_row]

Output

To solve this problem, we need to convert a given Python function that performs row reduction on a matrix modulo 16 into an equivalent C function. The function also tracks which rows are used in the reduction process for each row. The solution involves handling dynamic memory allocation, matrix operations, and set unions in C. ### Approach 1. **Matrix Initialization and Modulus Application**: The matrix is first converted to its values modulo 16. This ensures all elements are within the range [0, 15]. 2. **Row Reduction Process**: The main loop processes each column to form a Reduced Row Echelon Form (RREF). This involves finding pivot elements, swapping rows if necessary, and eliminating entries below and above the pivot. 3. **Tracking Used Rows**: For each row, we maintain a dynamically allocated array to track which rows contribute to its reduction. This involves merging sorted arrays to handle unions efficiently. 4. **Handling Special Cases**: Depending on the position relative to a given `graphlen`, different pivot handling strategies are applied, including division by 2 for certain columns. 5. **Termination and Cleanup**: The resulting arrays are terminated with -1 to indicate the end of the list of used rows. ### Solution Code 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
#include <stdlib.h>
#include <string.h>

#define PH 16

int mod_ph(int value) {
    int mod = value % PH;
    return mod < 0 ? mod + PH : mod;
}

int* merge_sorted_arrays(int* a, int a_size, int* b, int b_size, int* new_size) {
    int* result = malloc((a_size + b_size) * sizeof(int));
    int i = 0, j = 0, k = 0;
    while (i < a_size && j < b_size) {
        if (a[i] < b[j]) {
            result[k++] = a[i++];
        } else if (b[j] < a[i]) {
            result[k++] = b[j++];
        } else {
            result[k++] = a[i++];
            j++;
        }
    }
    while (i < a_size) {
        result[k++] = a[i++];
    }
    while (j < b_size) {
        result[k++] = b[j++];
    }
    *new_size = k;
    return realloc(result, k * sizeof(int));
}

int** rref(int** matrix, int rows, int cols, int graphlen) {
    int** used_for_row = (int**)malloc(rows * sizeof(int*));
    int* used_for_row_sizes = (int*)malloc(rows * sizeof(int));
    for (int i = 0; i < rows; i++) {
        used_for_row[i] = malloc(sizeof(int));
        used_for_row[i][0] = i;
        used_for_row_sizes[i] = 1;
    }

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            matrix[i][j] = mod_ph(matrix[i][j]);
        }
    }

    int extra = 0;
    int col = 0;

    while (col + extra < cols - 1 && col < rows) {
        int current_col = col + extra;

        if (matrix[col][current_col] == 0) {
            int all_zero = 1;
            for (int i = 0; i < rows; i++) {
                if (matrix[i][current_col] != 0) {
                    all_zero = 0;
                    break;
                }
            }
            if (all_zero) {
                extra++;
                continue;
            }

            int other = -1;
            for (int i = rows - 1; i >= 0; i--) {
                if (matrix[i][current_col] != 0) {
                    other = i;
                    break;
                }
            }

            if (other < col) {
                extra++;
                continue;
            }

            int* temp_row = matrix[col];
            matrix[col] = matrix[other];
            matrix[other] = temp_row;

            int* temp_used = used_for_row[col];
            used_for_row[col] = used_for_row[other];
            used_for_row[other] = temp_used;

            int temp_size = used_for_row_sizes[col];
            used_for_row_sizes[col] = used_for_row_sizes[other];
            used_for_row_sizes[other] = temp_size;
        }

        int pivot = matrix[col][current_col];
        if (current_col >= graphlen) {
            pivot /= 2;
        }

        for (int j = 0; j < cols; j++) {
            matrix[col][j] = mod_ph(matrix[col][j] * pivot);
        }

        int* others = malloc(rows * sizeof(int));
        int num_others = 0;
        for (int i = 0; i < rows; i++) {
            if (matrix[i][current_col] != 0) {
                others[num_others++] = i;
            }
        }

        for (int k = 0; k < num_others; k++) {
            int i = others[k];
            if (i == col) continue;

            int new_size;
            int* merged = merge_sorted_arrays(used_for_row[i], used_for_row_sizes[i], used_for_row[col], used_for_row_sizes[col], &new_size);
            free(used_for_row[i]);
            used_for_row[i] = merged;
            used_for_row_sizes[i] = new_size;

            if (col < graphlen) {
                int factor = matrix[i][current_col];
                for (int j = 0; j < cols; j++) {
                    matrix[i][j] = mod_ph(matrix[i][j] - factor * matrix[col][j]);
                }
            } else {
                int factor = matrix[i][current_col] / matrix[col][current_col];
                for (int j = 0; j < cols; j++) {
                    matrix[i][j] = mod_ph(matrix[i][j] - factor * matrix[col][j]);
                }
            }
        }

        free(others);
        col++;
    }

    for (int i = 0; i < rows; i++) {
        int* new_row = realloc(used_for_row[i], (used_for_row_sizes[i] + 1) * sizeof(int));
        new_row[used_for_row_sizes[i]] = -1;
        used_for_row[i] = new_row;
    }

    free(used_for_row_sizes);
    return used_for_row;
}
### Explanation 1. **Modulus Handling**: The `mod_ph` function ensures all matrix elements are within the range [0, 15]. 2. **Row Swapping and Pivot Selection**: The code handles zero pivots by swapping rows and ensuring non-zero pivots are used. 3. **Dynamic Array Merging**: The `merge_sorted_arrays` function efficiently merges two sorted arrays to track which rows contribute to each row's reduction. 4. **Termination**: Each row's used rows list is terminated with -1 to facilitate easy traversal by the caller. This approach efficiently handles the matrix operations and dynamic memory management required to replicate the Python functionality in C.

Extract Code

I extracted the following code from that output: 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
#include <stdlib.h>
#include <string.h>

#define PH 16

int mod_ph(int value) {
    int mod = value % PH;
    return mod < 0 ? mod + PH : mod;
}

int* merge_sorted_arrays(int* a, int a_size, int* b, int b_size, int* new_size) {
    int* result = malloc((a_size + b_size) * sizeof(int));
    int i = 0, j = 0, k = 0;
    while (i < a_size && j < b_size) {
        if (a[i] < b[j]) {
            result[k++] = a[i++];
        } else if (b[j] < a[i]) {
            result[k++] = b[j++];
        } else {
            result[k++] = a[i++];
            j++;
        }
    }
    while (i < a_size) {
        result[k++] = a[i++];
    }
    while (j < b_size) {
        result[k++] = b[j++];
    }
    *new_size = k;
    return realloc(result, k * sizeof(int));
}

int** rref(int** matrix, int rows, int cols, int graphlen) {
    int** used_for_row = (int**)malloc(rows * sizeof(int*));
    int* used_for_row_sizes = (int*)malloc(rows * sizeof(int));
    for (int i = 0; i < rows; i++) {
        used_for_row[i] = malloc(sizeof(int));
        used_for_row[i][0] = i;
        used_for_row_sizes[i] = 1;
    }

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            matrix[i][j] = mod_ph(matrix[i][j]);
        }
    }

    int extra = 0;
    int col = 0;

    while (col + extra < cols - 1 && col < rows) {
        int current_col = col + extra;

        if (matrix[col][current_col] == 0) {
            int all_zero = 1;
            for (int i = 0; i < rows; i++) {
                if (matrix[i][current_col] != 0) {
                    all_zero = 0;
                    break;
                }
            }
            if (all_zero) {
                extra++;
                continue;
            }

            int other = -1;
            for (int i = rows - 1; i >= 0; i--) {
                if (matrix[i][current_col] != 0) {
                    other = i;
                    break;
                }
            }

            if (other < col) {
                extra++;
                continue;
            }

            int* temp_row = matrix[col];
            matrix[col] = matrix[other];
            matrix[other] = temp_row;

            int* temp_used = used_for_row[col];
            used_for_row[col] = used_for_row[other];
            used_for_row[other] = temp_used;

            int temp_size = used_for_row_sizes[col];
            used_for_row_sizes[col] = used_for_row_sizes[other];
            used_for_row_sizes[other] = temp_size;
        }

        int pivot = matrix[col][current_col];
        if (current_col >= graphlen) {
            pivot /= 2;
        }

        for (int j = 0; j < cols; j++) {
            matrix[col][j] = mod_ph(matrix[col][j] * pivot);
        }

        int* others = malloc(rows * sizeof(int));
        int num_others = 0;
        for (int i = 0; i < rows; i++) {
            if (matrix[i][current_col] != 0) {
                others[num_others++] = i;
            }
        }

        for (int k = 0; k < num_others; k++) {
            int i = others[k];
            if (i == col) continue;

            int new_size;
            int* merged = merge_sorted_arrays(used_for_row[i], used_for_row_sizes[i], used_for_row[col], used_for_row_sizes[col], &new_size);
            free(used_for_row[i]);
            used_for_row[i] = merged;
            used_for_row_sizes[i] = new_size;

            if (col < graphlen) {
                int factor = matrix[i][current_col];
                for (int j = 0; j < cols; j++) {
                    matrix[i][j] = mod_ph(matrix[i][j] - factor * matrix[col][j]);
                }
            } else {
                int factor = matrix[i][current_col] / matrix[col][current_col];
                for (int j = 0; j < cols; j++) {
                    matrix[i][j] = mod_ph(matrix[i][j] - factor * matrix[col][j]);
                }
            }
        }

        free(others);
        col++;
    }

    for (int i = 0; i < rows; i++) {
        int* new_row = realloc(used_for_row[i], (used_for_row_sizes[i] + 1) * sizeof(int));
        new_row[used_for_row_sizes[i]] = -1;
        used_for_row[i] = new_row;
    }

    free(used_for_row_sizes);
    return used_for_row;
}

Run Code Interpreter

Running the following program: 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
#include <stdlib.h>
#include <string.h>

#define PH 16

int mod_ph(int value) {
    int mod = value % PH;
    return mod < 0 ? mod + PH : mod;
}

int* merge_sorted_arrays(int* a, int a_size, int* b, int b_size, int* new_size) {
    int* result = malloc((a_size + b_size) * sizeof(int));
    int i = 0, j = 0, k = 0;
    while (i < a_size && j < b_size) {
        if (a[i] < b[j]) {
            result[k++] = a[i++];
        } else if (b[j] < a[i]) {
            result[k++] = b[j++];
        } else {
            result[k++] = a[i++];
            j++;
        }
    }
    while (i < a_size) {
        result[k++] = a[i++];
    }
    while (j < b_size) {
        result[k++] = b[j++];
    }
    *new_size = k;
    return realloc(result, k * sizeof(int));
}

int** rref(int** matrix, int rows, int cols, int graphlen) {
    int** used_for_row = (int**)malloc(rows * sizeof(int*));
    int* used_for_row_sizes = (int*)malloc(rows * sizeof(int));
    for (int i = 0; i < rows; i++) {
        used_for_row[i] = malloc(sizeof(int));
        used_for_row[i][0] = i;
        used_for_row_sizes[i] = 1;
    }

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            matrix[i][j] = mod_ph(matrix[i][j]);
        }
    }

    int extra = 0;
    int col = 0;

    while (col + extra < cols - 1 && col < rows) {
        int current_col = col + extra;

        if (matrix[col][current_col] == 0) {
            int all_zero = 1;
            for (int i = 0; i < rows; i++) {
                if (matrix[i][current_col] != 0) {
                    all_zero = 0;
                    break;
                }
            }
            if (all_zero) {
                extra++;
                continue;
            }

            int other = -1;
            for (int i = rows - 1; i >= 0; i--) {
                if (matrix[i][current_col] != 0) {
                    other = i;
                    break;
                }
            }

            if (other < col) {
                extra++;
                continue;
            }

            int* temp_row = matrix[col];
            matrix[col] = matrix[other];
            matrix[other] = temp_row;

            int* temp_used = used_for_row[col];
            used_for_row[col] = used_for_row[other];
            used_for_row[other] = temp_used;

            int temp_size = used_for_row_sizes[col];
            used_for_row_sizes[col] = used_for_row_sizes[other];
            used_for_row_sizes[other] = temp_size;
        }

        int pivot = matrix[col][current_col];
        if (current_col >= graphlen) {
            pivot /= 2;
        }

        for (int j = 0; j < cols; j++) {
            matrix[col][j] = mod_ph(matrix[col][j] * pivot);
        }

        int* others = malloc(rows * sizeof(int));
        int num_others = 0;
        for (int i = 0; i < rows; i++) {
            if (matrix[i][current_col] != 0) {
                others[num_others++] = i;
            }
        }

        for (int k = 0; k < num_others; k++) {
            int i = others[k];
            if (i == col) continue;

            int new_size;
            int* merged = merge_sorted_arrays(used_for_row[i], used_for_row_sizes[i], used_for_row[col], used_for_row_sizes[col], &new_size);
            free(used_for_row[i]);
            used_for_row[i] = merged;
            used_for_row_sizes[i] = new_size;

            if (col < graphlen) {
                int factor = matrix[i][current_col];
                for (int j = 0; j < cols; j++) {
                    matrix[i][j] = mod_ph(matrix[i][j] - factor * matrix[col][j]);
                }
            } else {
                int factor = matrix[i][current_col] / matrix[col][current_col];
                for (int j = 0; j < cols; j++) {
                    matrix[i][j] = mod_ph(matrix[i][j] - factor * matrix[col][j]);
                }
            }
        }

        free(others);
        col++;
    }

    for (int i = 0; i < rows; i++) {
        int* new_row = realloc(used_for_row[i], (used_for_row_sizes[i] + 1) * sizeof(int));
        new_row[used_for_row_sizes[i]] = -1;
        used_for_row[i] = new_row;
    }

    free(used_for_row_sizes);
    return used_for_row;
}



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

int main() {

int arr0[] = {1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
int arr1[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -10};
int arr2[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -20};
int arr3[] = {0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, -20};
int arr4[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -11};
int arr5[] = {0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0};
int arr6[] = {0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0};
int arr7[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, -30};
int arr8[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
int arr9[] = {0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, 0, -20};
int arr10[] = {1, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
int arr11[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
int arr12[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -11};
int arr13[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -14};
int arr14[] = {0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -10};
int arr15[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, -30};
int arr16[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -10};
int arr17[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -10};
int arr18[] = {0, 0, 0, -1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -11};
int arr19[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -13};
int arr20[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -11};
int arr21[] = {0, 0, 0, 0, -1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -10};
int arr22[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, -20};
int arr23[] = {0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -10};
int arr24[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -11};
int arr25[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -13};
int arr26[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
int arr27[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -13};
int arr28[] = {0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
int arr29[] = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
int arr30[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
int arr31[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -11};
int arr32[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, -10};
int arr33[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -13};
int arr34[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -11};
int arr35[] = {0, 0, 1, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -9};
int arr36[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, -20};
int arr37[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, -40};
int arr38[] = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
int* arr[] = {arr0, arr1, arr2, arr3, arr4, arr5, arr6, arr7, arr8, arr9, arr10, arr11, arr12, arr13, arr14, arr15, arr16, arr17, arr18, arr19, arr20, arr21, arr22, arr23, arr24, arr25, arr26, arr27, arr28, arr29, arr30, arr31, arr32, arr33, arr34, arr35, arr36, arr37, arr38};
int** got = rref(arr, 39, 49, 37);


int answer = got[3][0]+got[3][1]+got[3][2]+got[3][3]+got[3][4]+got[3][5]+got[3][6];
int expected = 146;
if (answer != expected) {
    printf("Wrong answer; got %d instead of %d.\n", answer, expected);
    exit(1);
}
printf("All tests passed\n");
}
And got the output: All tests passed

Substring Evaluation

Testing if the previous output contains the string All tests passed: True