Formatação saida utilizando matriz

Olá, estou trabalhando em um projeto que o objetivo é fazer um nonograma. Estou usando o seguinte arquivo: `6 7

3
2 1 1
1 6
2 5 1
1 6
1 3

1 4
2 1 4
2 1 4
2 1 4
1 4
2 1 1
1 1

. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
onde, Primeira parte: Dimensão da matriz: 6 linhas por 7 colunas.
Segunda parte: Cabeçalho das linhas: cada linha apresenta a quantidade de números em uma linha seguido
dos números.
Terceira Parte: Cabeçalho das colunas: cada linha representa uma coluna, e apresenta a quantidade de
números seguido dos números.
Quarta parte: A matriz

O problema é que quando o codigo é compilado, esses numeros que são as “dicas” do nonograma, saem desconfigurados, a intenção é que ficassem acima das letras que indicam os argumentos das colunas e ao lado das letras que indicam os argumentos das linhas. Codigo: `#include “nonograma.h”
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void FreeNonograma(Nonograma* nonograma) {
for (int i = 0; i < nonograma->linhas; ++i) {
free(nonograma->matriz[i]);
}
free(nonograma->matriz);
free(nonograma->dicasLin);
free(nonograma->dicasCol);
}

void SalvarEmArquivo(const Nonograma* nonograma, const char* arquivo) {
FILE* file = fopen(arquivo, “w”);
if (file == NULL) {
fprintf(stderr, “Erro ao abrir o arquivo %s para salvar\n”, arquivo);
exit(EXIT_FAILURE);
}

fprintf(file, “%d %d\n”, nonograma->linhas, nonograma->colunas);

for (int i = 0; i < nonograma->linhas; ++i) {
for (int j = 0; j < nonograma->colunas; ++j) {
fprintf(file, “%c “, nonograma->matriz[i][j]);
}
fprintf(file, “\n”);
}

fclose(file);
printf(“Nonograma salvo com sucesso em %s!\n”, arquivo);
}

int JogoCompleto(const Nonograma* nonograma) {
for (int i = 0; i < nonograma->linhas; ++i) {
for (int j = 0; j < nonograma->colunas; ++j) {
if (nonograma->matriz[i][j] == ‘.’)
return 0;
}
}
return 1;
}

Nonograma ReadNonograma(const char* arquivo) {
FILE* file = fopen(arquivo, “r”);
if (file == NULL) {
fprintf(stderr, “Erro ao abrir o arquivo %s\n”, arquivo);
exit(EXIT_FAILURE);
}

Nonograma nonograma;

fscanf(file, “%d %d”, &nonograma.linhas, &nonograma.colunas);

nonograma.matriz = malloc(nonograma.linhas * sizeof(char*));
for (int i = 0; i < nonograma.linhas; ++i) {
nonograma.matriz[i] = malloc(nonograma.colunas * sizeof(char));
}

nonograma.dicasLin = malloc(nonograma.linhas * sizeof(int));
for (int i = 0; i < nonograma.linhas; ++i) {
fscanf(file, “%d”, &nonograma.dicasLin[i]);
}

nonograma.dicasCol = malloc(nonograma.colunas * sizeof(int));
for (int i = 0; i < nonograma.colunas; ++i) {
fscanf(file, “%d”, &nonograma.dicasCol[i]);
}

for (int i = 0; i < nonograma.linhas; ++i) {
for (int j = 0; j < nonograma.colunas; ++j) {
fscanf(file, ” %c”, &nonograma.matriz[i][j]);
}
}

fclose(file);

return nonograma;
}

void ImprimirNonograma(const Nonograma* nonograma) {
// Imprime dicas superiores
printf(” “);
for (int i = 0; i < nonograma->colunas; ++i) {
printf(“%c “, ‘A’ + i);
}
printf(“\n”);

// Imprime dicas laterais e valores da matriz
for (int i = 0; i < nonograma->linhas; ++i) {
printf(“%c “, ‘A’ + i);
for (int j = 0; j < nonograma->colunas; ++j) {
printf(“%c “, nonograma->matriz[i][j]);
}
printf(“\n”);
}
}

int main(int argc, char* argv[]) {
if (argc != 2) {
printf(“Uso: %s <arquivo_nonograma>\n”, argv[0]);
return 1;
}

const char* filename = argv[1];

Nonograma nonograma = ReadNonograma(filename);

printf(“\nBem-vindo ao Nonograma!\n”);

char comando[20];
char argumento[3];
char entrada[100];

while (strcmp(comando, “sair”) != 0) {
ImprimirNonograma(&nonograma);
printf(“\nDigite um comando: “);
if (fgets(entrada, sizeof(entrada), stdin) == NULL) {
printf(“Erro ao ler a entrada.\n”);
break;
}

// Remover o caractere de nova linha, se presente
entrada[strcspn(entrada, “\n”)] = ‘\0’;

sscanf(entrada, “%s %s”, comando, argumento);

if (strcmp(comando, “sair”) == 0) {
break;
}

int linhas = argumento[0] – ‘A’;
int colunas = argumento[1] – ‘A’;

if (strcmp(comando, “x”) == 0 || strcmp(comando, “-“) == 0 || strcmp(comando, “.”) == 0) {
nonograma.matriz[linhas][colunas] = comando[0];
} else if (strcmp(comando, “salvar”) == 0) {
char filename[50];
sscanf(entrada + 6, “%s”, filename);
SalvarEmArquivo(&nonograma, filename);
} else {
printf(“Comando inválido. Tente novamente.\n”);
}

getchar(); // Consumir o caractere de nova linha no buffer
}

if (JogoCompleto(&nonograma)) {
printf(“Parabéns, você concluiu o jogo!\n”);
} else {
printf(“Jogo encerrado.\n”);
}

FreeNonograma(&nonograma);

return 0;
}