Allora... per prima cosa un invito alla clemenza, perché sto sondando un terreno del quale non so nulla, e lo faccio poggiando su basi non certo solide. Diciamo che il mio è un gesto di coraggio.
Ho letto un po' di cose sulla questione dei grafi e di come organizzare la loro analisi. M'è sembrato di capire che un primo passo che occorre fare per ottenere quel che mi serve (ma potrei sbagliarmi) consiste nel realizzare una "matrice d'adiacenza" da usare poi nell'algoritmo d'analisi. Dunque ho cercato di informarmi su cosa fosse questa sconosciuta "matrice d'adiacenza" e ne è emerso che è una specie di tabellina. Nella sua forma più semplice (che credo sia quella che mi serve) l'ho ottenuta così:
#include <stdio.h>
#include <stdlib.h>
#define QR 3 // quantita' delle righe (nella matrice dei colori)
#define QC 4 // quantita' delle colonne (nella matrice dei colori)
char mc[QR][QC] = { // mc = matrice dei colori
{'G','G','B','B'},
{'R','G','B','R'},
{'R','B','B','B'},
};
int ma[QR*QC][QR*QC] = {{0},{0}}; // ma = matrice d'adiacenza
void esplora_adiacenze( int ra, int rc, int cc );
void print_mc( void );
void print_ma( void );
int main() {
int r, c;
// analizza uno per uno i caratteri presenti nella matrice dei
// colori, al fine di compilare una matrice delle adiacenze
for( r=0; r<QR; ++r )
for( c=0; c<QC; ++c )
esplora_adiacenze( r*QC+c, r, c );
print_mc(); // mostra la matrice dei colori
printf( "\n" );
print_ma(); // mostra la matrice d'adiacenza
return 0;
}
/*==============================================================================
ra = riga nella matrice d'adiacenza
ca = colonna nella matrice d'adiacenza
rc = riga nella matrice dei colori
cc = colonna nella matrice dei colori
La funzione prende in considerazione un carattere della matrice dei colori e lo
confronta con tutti gli altri caratteri della stessa matrice, inserendo i
risultati dei confronti nella riga della matrice d'adiacenza che corrisponde al
numero d'ordine del carattere nella matrice dei colori ottenuto seguendo questo
schema:
1 2 3 4
5 6 7 8
9 10 11 12
==============================================================================*/
void esplora_adiacenze( int ra, int rc, int cc ) {
int r, c, ca; // r = contatore righe; c = contatore colonne
for( ca=0, r=0; r<QR; ++r ) {
for( c=0; c<QC; ++c, ++ca ) {
ma[ra][ca] = // l'adiacenza e' verificata se...
(mc[r][c]==mc[rc][cc]) && // i colori sono uguali e...
(((r==rc)&&(c==cc-1||c==cc+1)) || // condividono l'ascissa o...
((c==cc)&&(r==rc-1||r==rc+1))); // condividono l'ordinata
}
}
}
/*==============================================================================
Visualizza la matrice dei colori.
==============================================================================*/
void print_mc( void ) {
const char bv[4] = {179,'\n','Allora... per prima cosa un invito alla clemenza, perché sto sondando un terreno del quale non so nulla, e lo faccio poggiando su basi non certo solide. Diciamo che il mio è un gesto di coraggio.
Ho letto un po' di cose sulla questione dei grafi e di come organizzare la loro analisi. M'è sembrato di capire che un primo passo che occorre fare per ottenere quel che mi serve (ma potrei sbagliarmi) consiste nel realizzare una "matrice d'adiacenza" da usare poi nell'algoritmo d'analisi. Dunque ho cercato di informarmi su cosa fosse questa sconosciuta "matrice d'adiacenza" e ne è emerso che è una specie di tabellina. Nella sua forma più semplice (che credo sia quella che mi serve) l'ho ottenuta così:
#include <stdio.h>
#include <stdlib.h>
#define QR 3 // quantita' delle righe (nella matrice dei colori)
#define QC 4 // quantita' delle colonne (nella matrice dei colori)
char mc[QR][QC] = { // mc = matrice dei colori
{'G','G','B','B'},
{'R','G','B','R'},
{'R','B','B','B'},
};
int ma[QR*QC][QR*QC] = {{0},{0}}; // ma = matrice d'adiacenza
void esplora_adiacenze( int ra, int rc, int cc );
void print_mc( void );
void print_ma( void );
int main() {
int r, c;
// analizza uno per uno i caratteri presenti nella matrice dei
// colori, al fine di compilare una matrice delle adiacenze
for( r=0; r<QR; ++r )
for( c=0; c<QC; ++c )
esplora_adiacenze( r*QC+c, r, c );
print_mc(); // mostra la matrice dei colori
printf( "\n" );
print_ma(); // mostra la matrice d'adiacenza
return 0;
}
/*==============================================================================
ra = riga nella matrice d'adiacenza
ca = colonna nella matrice d'adiacenza
rc = riga nella matrice dei colori
cc = colonna nella matrice dei colori
La funzione prende in considerazione un carattere della matrice dei colori e lo
confronta con tutti gli altri caratteri della stessa matrice, inserendo i
risultati dei confronti nella riga della matrice d'adiacenza che corrisponde al
numero d'ordine del carattere nella matrice dei colori ottenuto seguendo questo
schema:
1 2 3 4
5 6 7 8
9 10 11 12
==============================================================================*/
void esplora_adiacenze( int ra, int rc, int cc ) {
int r, c, ca; // r = contatore righe; c = contatore colonne
for( ca=0, r=0; r<QR; ++r ) {
for( c=0; c<QC; ++c, ++ca ) {
ma[ra][ca] = // l'adiacenza e' verificata se...
(mc[r][c]==mc[rc][cc]) && // i colori sono uguali e...
(((r==rc)&&(c==cc-1||c==cc+1)) || // condividono l'ascissa o...
((c==cc)&&(r==rc-1||r==rc+1))); // condividono l'ordinata
}
}
}
/*==============================================================================
Visualizza la matrice dei colori.
==============================================================================*/
void print_mc( void ) {
const char bv[4] = {179,'\n','{parsed_message}','{parsed_message}'}; // bv = barra verticale;
int r, c, i;
printf( " " );
for( i=0; i<QC; ++i )
printf( " %c ", 'A'+i );
printf( "\n" );
for( r=0; r<QR; ++r ) {
printf( " " );
for( i=0; i<QC; ++i )
printf( "%c%c%c%c", r!=0?(i!=0?197:195):(i!=0?194:218),196,196,196 );
printf( "%c\n", r==0?191:180 );
printf( " %c ", '1'+r );
for( c=0; c<QC; ++c )
printf( "%c %c %s", 179, mc[r][c], c<QC-1?"":bv );
}
printf( " " );
for( i=0; i<QC; ++i )
printf( "%c%c%c%c", r!=0?(i!=0?193:192):(i!=0?194:218),196,196,196 );
printf( "%c\n", r==0?191:217 );
}
/*==============================================================================
Visualizza la matrice d'adiacenza.
==============================================================================*/
void print_ma( void ) {
const char bv[4] = {179,'\n','{parsed_message}','{parsed_message}'}; // bv = barra verticale;
int r, c, i;
printf( " " );
for( i=0; i<QR*QC; ++i )
printf( " %c%c ", 'A'+(i%QC), '1'+(i/QC) );
printf( "\n" );
for( r=0; r<QR*QC; ++r ) {
printf( " " );
for( i=0; i<QR*QC; ++i )
printf( "%c%c%c%c", r!=0?(i!=0?197:195):(i!=0?194:218),196,196,196 );
printf( "%c\n", r==0?191:180 );
printf( " %c%c ", 'A'+(r%QC), '1'+(r/QC) );
for( c=0; c<QR*QC; ++c )
printf( "%c %c %s", 179, ma[r][c]?254:' ', c<QR*QC-1?"":bv );
}
printf( " " );
for( i=0; i<QR*QC; ++i )
printf( "%c%c%c%c", r!=0?(i!=0?193:192):(i!=0?194:218),196,196,196 );
printf( "%c\n", r==0?191:217 );
}
Per non perderci troppo tempo ho temporaneamente usato delle variabili globali, ma non è importante. Quel che vorrei sapere è: è corretto quel che ho fatto? Serve davvero o è un "vicolo cieco"?
P.S. print_mc() e print_ma() sono irrilevanti nel contesto del discorso: mi son servite solo per vedere cosa stavo facendo.','Allora... per prima cosa un invito alla clemenza, perché sto sondando un terreno del quale non so nulla, e lo faccio poggiando su basi non certo solide. Diciamo che il mio è un gesto di coraggio.
Ho letto un po' di cose sulla questione dei grafi e di come organizzare la loro analisi. M'è sembrato di capire che un primo passo che occorre fare per ottenere quel che mi serve (ma potrei sbagliarmi) consiste nel realizzare una "matrice d'adiacenza" da usare poi nell'algoritmo d'analisi. Dunque ho cercato di informarmi su cosa fosse questa sconosciuta "matrice d'adiacenza" e ne è emerso che è una specie di tabellina. Nella sua forma più semplice (che credo sia quella che mi serve) l'ho ottenuta così:
#include <stdio.h>
#include <stdlib.h>
#define QR 3 // quantita' delle righe (nella matrice dei colori)
#define QC 4 // quantita' delle colonne (nella matrice dei colori)
char mc[QR][QC] = { // mc = matrice dei colori
{'G','G','B','B'},
{'R','G','B','R'},
{'R','B','B','B'},
};
int ma[QR*QC][QR*QC] = {{0},{0}}; // ma = matrice d'adiacenza
void esplora_adiacenze( int ra, int rc, int cc );
void print_mc( void );
void print_ma( void );
int main() {
int r, c;
// analizza uno per uno i caratteri presenti nella matrice dei
// colori, al fine di compilare una matrice delle adiacenze
for( r=0; r<QR; ++r )
for( c=0; c<QC; ++c )
esplora_adiacenze( r*QC+c, r, c );
print_mc(); // mostra la matrice dei colori
printf( "\n" );
print_ma(); // mostra la matrice d'adiacenza
return 0;
}
/*==============================================================================
ra = riga nella matrice d'adiacenza
ca = colonna nella matrice d'adiacenza
rc = riga nella matrice dei colori
cc = colonna nella matrice dei colori
La funzione prende in considerazione un carattere della matrice dei colori e lo
confronta con tutti gli altri caratteri della stessa matrice, inserendo i
risultati dei confronti nella riga della matrice d'adiacenza che corrisponde al
numero d'ordine del carattere nella matrice dei colori ottenuto seguendo questo
schema:
1 2 3 4
5 6 7 8
9 10 11 12
==============================================================================*/
void esplora_adiacenze( int ra, int rc, int cc ) {
int r, c, ca; // r = contatore righe; c = contatore colonne
for( ca=0, r=0; r<QR; ++r ) {
for( c=0; c<QC; ++c, ++ca ) {
ma[ra][ca] = // l'adiacenza e' verificata se...
(mc[r][c]==mc[rc][cc]) && // i colori sono uguali e...
(((r==rc)&&(c==cc-1||c==cc+1)) || // condividono l'ascissa o...
((c==cc)&&(r==rc-1||r==rc+1))); // condividono l'ordinata
}
}
}
/*==============================================================================
Visualizza la matrice dei colori.
==============================================================================*/
void print_mc( void ) {
const char bv[4] = {179,'\n','{parsed_message}','{parsed_message}'}; // bv = barra verticale;
int r, c, i;
printf( " " );
for( i=0; i<QC; ++i )
printf( " %c ", 'A'+i );
printf( "\n" );
for( r=0; r<QR; ++r ) {
printf( " " );
for( i=0; i<QC; ++i )
printf( "%c%c%c%c", r!=0?(i!=0?197:195):(i!=0?194:218),196,196,196 );
printf( "%c\n", r==0?191:180 );
printf( " %c ", '1'+r );
for( c=0; c<QC; ++c )
printf( "%c %c %s", 179, mc[r][c], c<QC-1?"":bv );
}
printf( " " );
for( i=0; i<QC; ++i )
printf( "%c%c%c%c", r!=0?(i!=0?193:192):(i!=0?194:218),196,196,196 );
printf( "%c\n", r==0?191:217 );
}
/*==============================================================================
Visualizza la matrice d'adiacenza.
==============================================================================*/
void print_ma( void ) {
const char bv[4] = {179,'\n','{parsed_message}','{parsed_message}'}; // bv = barra verticale;
int r, c, i;
printf( " " );
for( i=0; i<QR*QC; ++i )
printf( " %c%c ", 'A'+(i%QC), '1'+(i/QC) );
printf( "\n" );
for( r=0; r<QR*QC; ++r ) {
printf( " " );
for( i=0; i<QR*QC; ++i )
printf( "%c%c%c%c", r!=0?(i!=0?197:195):(i!=0?194:218),196,196,196 );
printf( "%c\n", r==0?191:180 );
printf( " %c%c ", 'A'+(r%QC), '1'+(r/QC) );
for( c=0; c<QR*QC; ++c )
printf( "%c %c %s", 179, ma[r][c]?254:' ', c<QR*QC-1?"":bv );
}
printf( " " );
for( i=0; i<QR*QC; ++i )
printf( "%c%c%c%c", r!=0?(i!=0?193:192):(i!=0?194:218),196,196,196 );
printf( "%c\n", r==0?191:217 );
}
Per non perderci troppo tempo ho temporaneamente usato delle variabili globali, ma non è importante. Quel che vorrei sapere è: è corretto quel che ho fatto? Serve davvero o è un "vicolo cieco"?
P.S. print_mc() e print_ma() sono irrilevanti nel contesto del discorso: mi son servite solo per vedere cosa stavo facendo.'}; // bv = barra verticale;
int r, c, i;
printf( " " );
for( i=0; i<QC; ++i )
printf( " %c ", 'A'+i );
printf( "\n" );
for( r=0; r<QR; ++r ) {
printf( " " );
for( i=0; i<QC; ++i )
printf( "%c%c%c%c", r!=0?(i!=0?197:195):(i!=0?194:218),196,196,196 );
printf( "%c\n", r==0?191:180 );
printf( " %c ", '1'+r );
for( c=0; c<QC; ++c )
printf( "%c %c %s", 179, mc[r][c], c<QC-1?"":bv );
}
printf( " " );
for( i=0; i<QC; ++i )
printf( "%c%c%c%c", r!=0?(i!=0?193:192):(i!=0?194:218),196,196,196 );
printf( "%c\n", r==0?191:217 );
}
/*==============================================================================
Visualizza la matrice d'adiacenza.
==============================================================================*/
void print_ma( void ) {
const char bv[4] = {179,'\n','Allora... per prima cosa un invito alla clemenza, perché sto sondando un terreno del quale non so nulla, e lo faccio poggiando su basi non certo solide. Diciamo che il mio è un gesto di coraggio.
Ho letto un po' di cose sulla questione dei grafi e di come organizzare la loro analisi. M'è sembrato di capire che un primo passo che occorre fare per ottenere quel che mi serve (ma potrei sbagliarmi) consiste nel realizzare una "matrice d'adiacenza" da usare poi nell'algoritmo d'analisi. Dunque ho cercato di informarmi su cosa fosse questa sconosciuta "matrice d'adiacenza" e ne è emerso che è una specie di tabellina. Nella sua forma più semplice (che credo sia quella che mi serve) l'ho ottenuta così:
#include <stdio.h>
#include <stdlib.h>
#define QR 3 // quantita' delle righe (nella matrice dei colori)
#define QC 4 // quantita' delle colonne (nella matrice dei colori)
char mc[QR][QC] = { // mc = matrice dei colori
{'G','G','B','B'},
{'R','G','B','R'},
{'R','B','B','B'},
};
int ma[QR*QC][QR*QC] = {{0},{0}}; // ma = matrice d'adiacenza
void esplora_adiacenze( int ra, int rc, int cc );
void print_mc( void );
void print_ma( void );
int main() {
int r, c;
// analizza uno per uno i caratteri presenti nella matrice dei
// colori, al fine di compilare una matrice delle adiacenze
for( r=0; r<QR; ++r )
for( c=0; c<QC; ++c )
esplora_adiacenze( r*QC+c, r, c );
print_mc(); // mostra la matrice dei colori
printf( "\n" );
print_ma(); // mostra la matrice d'adiacenza
return 0;
}
/*==============================================================================
ra = riga nella matrice d'adiacenza
ca = colonna nella matrice d'adiacenza
rc = riga nella matrice dei colori
cc = colonna nella matrice dei colori
La funzione prende in considerazione un carattere della matrice dei colori e lo
confronta con tutti gli altri caratteri della stessa matrice, inserendo i
risultati dei confronti nella riga della matrice d'adiacenza che corrisponde al
numero d'ordine del carattere nella matrice dei colori ottenuto seguendo questo
schema:
1 2 3 4
5 6 7 8
9 10 11 12
==============================================================================*/
void esplora_adiacenze( int ra, int rc, int cc ) {
int r, c, ca; // r = contatore righe; c = contatore colonne
for( ca=0, r=0; r<QR; ++r ) {
for( c=0; c<QC; ++c, ++ca ) {
ma[ra][ca] = // l'adiacenza e' verificata se...
(mc[r][c]==mc[rc][cc]) && // i colori sono uguali e...
(((r==rc)&&(c==cc-1||c==cc+1)) || // condividono l'ascissa o...
((c==cc)&&(r==rc-1||r==rc+1))); // condividono l'ordinata
}
}
}
/*==============================================================================
Visualizza la matrice dei colori.
==============================================================================*/
void print_mc( void ) {
const char bv[4] = {179,'\n','{parsed_message}','{parsed_message}'}; // bv = barra verticale;
int r, c, i;
printf( " " );
for( i=0; i<QC; ++i )
printf( " %c ", 'A'+i );
printf( "\n" );
for( r=0; r<QR; ++r ) {
printf( " " );
for( i=0; i<QC; ++i )
printf( "%c%c%c%c", r!=0?(i!=0?197:195):(i!=0?194:218),196,196,196 );
printf( "%c\n", r==0?191:180 );
printf( " %c ", '1'+r );
for( c=0; c<QC; ++c )
printf( "%c %c %s", 179, mc[r][c], c<QC-1?"":bv );
}
printf( " " );
for( i=0; i<QC; ++i )
printf( "%c%c%c%c", r!=0?(i!=0?193:192):(i!=0?194:218),196,196,196 );
printf( "%c\n", r==0?191:217 );
}
/*==============================================================================
Visualizza la matrice d'adiacenza.
==============================================================================*/
void print_ma( void ) {
const char bv[4] = {179,'\n','{parsed_message}','{parsed_message}'}; // bv = barra verticale;
int r, c, i;
printf( " " );
for( i=0; i<QR*QC; ++i )
printf( " %c%c ", 'A'+(i%QC), '1'+(i/QC) );
printf( "\n" );
for( r=0; r<QR*QC; ++r ) {
printf( " " );
for( i=0; i<QR*QC; ++i )
printf( "%c%c%c%c", r!=0?(i!=0?197:195):(i!=0?194:218),196,196,196 );
printf( "%c\n", r==0?191:180 );
printf( " %c%c ", 'A'+(r%QC), '1'+(r/QC) );
for( c=0; c<QR*QC; ++c )
printf( "%c %c %s", 179, ma[r][c]?254:' ', c<QR*QC-1?"":bv );
}
printf( " " );
for( i=0; i<QR*QC; ++i )
printf( "%c%c%c%c", r!=0?(i!=0?193:192):(i!=0?194:218),196,196,196 );
printf( "%c\n", r==0?191:217 );
}
Per non perderci troppo tempo ho temporaneamente usato delle variabili globali, ma non è importante. Quel che vorrei sapere è: è corretto quel che ho fatto? Serve davvero o è un "vicolo cieco"?
P.S. print_mc() e print_ma() sono irrilevanti nel contesto del discorso: mi son servite solo per vedere cosa stavo facendo.','Allora... per prima cosa un invito alla clemenza, perché sto sondando un terreno del quale non so nulla, e lo faccio poggiando su basi non certo solide. Diciamo che il mio è un gesto di coraggio.
Ho letto un po' di cose sulla questione dei grafi e di come organizzare la loro analisi. M'è sembrato di capire che un primo passo che occorre fare per ottenere quel che mi serve (ma potrei sbagliarmi) consiste nel realizzare una "matrice d'adiacenza" da usare poi nell'algoritmo d'analisi. Dunque ho cercato di informarmi su cosa fosse questa sconosciuta "matrice d'adiacenza" e ne è emerso che è una specie di tabellina. Nella sua forma più semplice (che credo sia quella che mi serve) l'ho ottenuta così:
#include <stdio.h>
#include <stdlib.h>
#define QR 3 // quantita' delle righe (nella matrice dei colori)
#define QC 4 // quantita' delle colonne (nella matrice dei colori)
char mc[QR][QC] = { // mc = matrice dei colori
{'G','G','B','B'},
{'R','G','B','R'},
{'R','B','B','B'},
};
int ma[QR*QC][QR*QC] = {{0},{0}}; // ma = matrice d'adiacenza
void esplora_adiacenze( int ra, int rc, int cc );
void print_mc( void );
void print_ma( void );
int main() {
int r, c;
// analizza uno per uno i caratteri presenti nella matrice dei
// colori, al fine di compilare una matrice delle adiacenze
for( r=0; r<QR; ++r )
for( c=0; c<QC; ++c )
esplora_adiacenze( r*QC+c, r, c );
print_mc(); // mostra la matrice dei colori
printf( "\n" );
print_ma(); // mostra la matrice d'adiacenza
return 0;
}
/*==============================================================================
ra = riga nella matrice d'adiacenza
ca = colonna nella matrice d'adiacenza
rc = riga nella matrice dei colori
cc = colonna nella matrice dei colori
La funzione prende in considerazione un carattere della matrice dei colori e lo
confronta con tutti gli altri caratteri della stessa matrice, inserendo i
risultati dei confronti nella riga della matrice d'adiacenza che corrisponde al
numero d'ordine del carattere nella matrice dei colori ottenuto seguendo questo
schema:
1 2 3 4
5 6 7 8
9 10 11 12
==============================================================================*/
void esplora_adiacenze( int ra, int rc, int cc ) {
int r, c, ca; // r = contatore righe; c = contatore colonne
for( ca=0, r=0; r<QR; ++r ) {
for( c=0; c<QC; ++c, ++ca ) {
ma[ra][ca] = // l'adiacenza e' verificata se...
(mc[r][c]==mc[rc][cc]) && // i colori sono uguali e...
(((r==rc)&&(c==cc-1||c==cc+1)) || // condividono l'ascissa o...
((c==cc)&&(r==rc-1||r==rc+1))); // condividono l'ordinata
}
}
}
/*==============================================================================
Visualizza la matrice dei colori.
==============================================================================*/
void print_mc( void ) {
const char bv[4] = {179,'\n','{parsed_message}','{parsed_message}'}; // bv = barra verticale;
int r, c, i;
printf( " " );
for( i=0; i<QC; ++i )
printf( " %c ", 'A'+i );
printf( "\n" );
for( r=0; r<QR; ++r ) {
printf( " " );
for( i=0; i<QC; ++i )
printf( "%c%c%c%c", r!=0?(i!=0?197:195):(i!=0?194:218),196,196,196 );
printf( "%c\n", r==0?191:180 );
printf( " %c ", '1'+r );
for( c=0; c<QC; ++c )
printf( "%c %c %s", 179, mc[r][c], c<QC-1?"":bv );
}
printf( " " );
for( i=0; i<QC; ++i )
printf( "%c%c%c%c", r!=0?(i!=0?193:192):(i!=0?194:218),196,196,196 );
printf( "%c\n", r==0?191:217 );
}
/*==============================================================================
Visualizza la matrice d'adiacenza.
==============================================================================*/
void print_ma( void ) {
const char bv[4] = {179,'\n','{parsed_message}','{parsed_message}'}; // bv = barra verticale;
int r, c, i;
printf( " " );
for( i=0; i<QR*QC; ++i )
printf( " %c%c ", 'A'+(i%QC), '1'+(i/QC) );
printf( "\n" );
for( r=0; r<QR*QC; ++r ) {
printf( " " );
for( i=0; i<QR*QC; ++i )
printf( "%c%c%c%c", r!=0?(i!=0?197:195):(i!=0?194:218),196,196,196 );
printf( "%c\n", r==0?191:180 );
printf( " %c%c ", 'A'+(r%QC), '1'+(r/QC) );
for( c=0; c<QR*QC; ++c )
printf( "%c %c %s", 179, ma[r][c]?254:' ', c<QR*QC-1?"":bv );
}
printf( " " );
for( i=0; i<QR*QC; ++i )
printf( "%c%c%c%c", r!=0?(i!=0?193:192):(i!=0?194:218),196,196,196 );
printf( "%c\n", r==0?191:217 );
}
Per non perderci troppo tempo ho temporaneamente usato delle variabili globali, ma non è importante. Quel che vorrei sapere è: è corretto quel che ho fatto? Serve davvero o è un "vicolo cieco"?
P.S. print_mc() e print_ma() sono irrilevanti nel contesto del discorso: mi son servite solo per vedere cosa stavo facendo.'}; // bv = barra verticale;
int r, c, i;
printf( " " );
for( i=0; i<QR*QC; ++i )
printf( " %c%c ", 'A'+(i%QC), '1'+(i/QC) );
printf( "\n" );
for( r=0; r<QR*QC; ++r ) {
printf( " " );
for( i=0; i<QR*QC; ++i )
printf( "%c%c%c%c", r!=0?(i!=0?197:195):(i!=0?194:218),196,196,196 );
printf( "%c\n", r==0?191:180 );
printf( " %c%c ", 'A'+(r%QC), '1'+(r/QC) );
for( c=0; c<QR*QC; ++c )
printf( "%c %c %s", 179, ma[r][c]?254:' ', c<QR*QC-1?"":bv );
}
printf( " " );
for( i=0; i<QR*QC; ++i )
printf( "%c%c%c%c", r!=0?(i!=0?193:192):(i!=0?194:218),196,196,196 );
printf( "%c\n", r==0?191:217 );
}
Per non perderci troppo tempo ho temporaneamente usato delle variabili globali, ma non è importante. Quel che vorrei sapere è: è corretto quel che ho fatto? Serve davvero o è un "vicolo cieco"?
P.S. print_mc() e print_ma() sono irrilevanti nel contesto del discorso: mi son servite solo per vedere cosa stavo facendo.
ATTENZIONE! Sono un hobbista e l'affidabilità delle mie conoscenze informatiche è molto limitata. Non prendere come esempio il codice che scrivo, perché non ho alcuna formazione accademica e rischieresti di apprendere pratiche controproducenti.