Numbers falling down a matrix - c

Question

I have a N*N matrix full of elements. With a function I can destroy some elements so that they leave an empty space that can be occupied by numbers falling from above. An example of the process:
[1][3][4][5] [1][ ][4][5] [ ][ ][ ][5]
[3][3][3][0]-->[ ][ ][ ][0]-->[ ][ ][4][0]
[3][0][2][1]-->[ ][0][2][1]-->[1][0][2][1]
[2][4][5][3] [2][4][5][3] [2][4][5][3]
In this example only the numbers 1 and 4 fell down. Also when a column is completely empty those filled on the left must move right.
I want to create a function void gravity (game_t * p).
game_t in defined:
typedef struct game{
int n; /*n*n matrix */
int h; /* numbers on matrix go from 0 to h-1*/
int ** board; /*the actual matrix*/
} game_t
I can't think of a good strategy to solve this problem, can you please help me?
edit: this is what I wrote so far:
void gravity(game_t *p) {
int i, j, k;
for (k = 0; k < p->n - 1; k++) {
for (i = p->n - 2; i = 0; i--) {
for (j = p->n - 1; i = 0; i--) {
if (p->board[i - 1][j] == EMPTY) {
p->board[i - 1][j] = p->board[i][j];
p->board[i][j] = EMPTY;
}
}
}
return;
}
This one I wrote doesn't seem very efficient, maybe it should be recursive. For each element of the matrix from the second to last row going right to left I check if the element below is empty and move it there. However I have to check the matrix multiple times (k) because some elements may have to move more than once. `

Answer 1

Ok, as expected: "I know you will not do it, but please provide a minimal reproducible example." Yet again people ask a question and are not even interested in letting others solve their problem. The function you provided doesn't even compile...
Anyway, a solution is provided here along with all the code required to test it. It would have taken much less effort if you just had written all of this in the question with the non working gravity() function.
For the future readers , check out how the allocation done with a single malloc() and some casting, which allows to free everything with a single call to free(). It would be even better to use a single pointer to the data instead of the double pointer, but I understand that teachers around the world still favor the double pointer version. Also the game_set() function is interesting because it's a variadic function.
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <stdarg.h>
const int EMPTY = INT_MIN;
typedef struct game {
int n; /*n*n matrix */
int h; /* numbers on matrix go from 0 to h-1*/
int **board; /*the actual matrix*/
} game_t;
game_t *game_construct(game_t *g, int n, int h)
{
assert(n > 0);
g->n = n;
g->h = h;
g->board = malloc(n * sizeof(int*) + n * n * sizeof(int));
g->board[0] = (int*)((char*)g->board + n * sizeof(int*));
for (int i = 1; i < n; ++i) {
g->board[i] = g->board[i - 1] + n;
}
return g;
}
game_t* game_destruct(game_t* g)
{
free(g->board);
return g;
}
void game_set(game_t* g, ...)
{
va_list argptr;
va_start(argptr, g);
for (int r = 0; r < g->n; ++r) {
for (int c = 0; c < g->n; ++c) {
g->board[r][c] = va_arg(argptr, int);
}
}
}
void game_print(game_t *g)
{
for (int r = 0; r < g->n; ++r) {
for (int c = 0; c < g->n; ++c) {
if (g->board[r][c] == EMPTY) {
printf("[ ]");
}
else {
printf("[%d]", g->board[r][c]);
}
}
printf("\n");
}
printf("\n");
}
void gravity(game_t *g)
{
for (int c = 0; c < g->n; ++c) {
int rf = g->n - 1;
for (int r = rf; r >= 0; --r) {
if (g->board[r][c] != EMPTY) {
g->board[rf--][c] = g->board[r][c];
}
}
while (rf >= 0) {
g->board[rf--][c] = EMPTY;
}
}
}
int main(void)
{
game_t g;
game_construct(&g, 4, 9);
game_set(&g,
1, 3, 4, 5,
3, 3, 3, 0,
3, 0, 2, 1,
2, 4, 5, 3);
game_print(&g);
game_set(&g,
1, EMPTY, 4, 5,
EMPTY, EMPTY, EMPTY, 0,
EMPTY, 0, 2, 1,
2, 4, 5, 3);
game_print(&g);
gravity(&g);
game_print(&g);
game_destruct(&g);
return 0;
}