Compilazione fallita Stanza degli specchi

Ho tentato di risolvere il problema “Stanza degli specchi”. La mia soluzione (che forse non è la migliore) viene compilata e risolve i casi di prova quando la testo sul mio computer, ma quando provo ad inviarla mi dà “compilazione fallita”.

Codice:

typedef enum {
SOPRA = 0,
DESTRA = 1,
SOTTO = 2,
SINISTRA = 3
} parete_t; // lato (usato anche per indicare la direzione)

typedef struct {
	parete_t lato;
	int posizione;
} foro_t; // posizione di partenza laser

typedef struct{
	int r;
	int c;
	parete_t direzione;
} pos_t; // posizione attuale laser

int My_RIGHE_, My_COLONNE_;
char specchi[100000][100000];

void inizia(int N, int M) {
	// inizializzazione righe, colonne e vettore specchi
	My_RIGHE_=N;
	My_COLONNE_=M;
	for(int i=0; i<My_RIGHE_; i++){
		for(int j=0; j<My_COLONNE_; j++){
			specchi[i][j]='0';
		}
	}
}

void aggiungi(int r, int c, char diagonale) {
	// aggiungi uno specchio
	specchi[r][c]=diagonale;
}

pos_t sposta(pos_t partenza){ //sposta il raggio laser di casella in casella
	pos_t arrivo;
	if(specchi[partenza.r][partenza.c]=='0'){//se la casella di partenza non contiene uno specchio prosegue dritto
		switch(partenza.direzione){
			case SOPRA:
				arrivo.r=partenza.r-1;
				arrivo.c=partenza.c;
				break;
			case SOTTO:
				arrivo.r=partenza.r+1;
				arrivo.c=partenza.c;
				break;
			case DESTRA:
				arrivo.r=partenza.r;
				arrivo.c=partenza.c+1;
				break;
			case SINISTRA:
				arrivo.r=partenza.r;
				arrivo.c=partenza.c-1;
				break;
		}
		arrivo.direzione=partenza.direzione;
	}else{
		if(specchi[partenza.r][partenza.c]=='/'){ //se la casella di partenza contiene uno specchio /
			switch(partenza.direzione){
				case SOPRA:
					arrivo.r=partenza.r;
					arrivo.c=partenza.c+1;
					arrivo.direzione=DESTRA;
					break;
				case SOTTO:
					arrivo.r=partenza.r;
					arrivo.c=partenza.c-1;
					arrivo.direzione=SINISTRA;
					break;
				case DESTRA:
					arrivo.r=partenza.r-1;
					arrivo.c=partenza.c;
					arrivo.direzione=SOPRA;
					break;
				case SINISTRA:
					arrivo.r=partenza.r+1;
					arrivo.c=partenza.c;
					arrivo.direzione=SOTTO;
					break;
			}
		}else{
			switch(partenza.direzione){ //se la casella di partenza contiene uno specchio \
				case SOPRA:
					arrivo.r=partenza.r;
					arrivo.c=partenza.c-11;
					arrivo.direzione=SINISTRA;
					break;
				case SOTTO:
					arrivo.r=partenza.r;
					arrivo.c=partenza.c+1;
					arrivo.direzione=DESTRA;
					break;
				case DESTRA:
					arrivo.r=partenza.r+1;
					arrivo.c=partenza.c;
					arrivo.direzione=SOTTO;
					break;
				case SINISTRA:
					arrivo.r=partenza.r-1;
					arrivo.c=partenza.c;
					arrivo.direzione=SOPRA;
					break;
			}
		}
	}
	//if(arrivo.r<0) arrivo.r=0;       INUTILE
	//if(arrivo.r>R-1) arrivo.r=R-1;
	//if(arrivo.c<0) arrivo.c=0;
	//if(arrivo.c>C-1) arrivo.c=C-1;
	return arrivo;
}

foro_t calcola(foro_t ingresso) {
	// calcola il punto di uscita del raggio
	foro_t uscita;
	pos_t partenza;
	switch(ingresso.lato){ //trasforma foro_t ingresso in pos_t partenza per poterla utilizzare in sposta
		case SOPRA:
			partenza.r=0;
			partenza.c=ingresso.posizione;
			partenza.direzione=SOTTO;
			break;
		case SOTTO:
			partenza.r=My_RIGHE_-1;
			partenza.c=ingresso.posizione;
			partenza.direzione=SOPRA;
			break;
		case DESTRA:
			partenza.r=ingresso.posizione;
			partenza.c=My_COLONNE_-1;
			partenza.direzione=SINISTRA;
			break;
		case SINISTRA:
			partenza.r=ingresso.posizione;
			partenza.c=0;
			partenza.direzione=DESTRA;
			break;
	}
	while(!((partenza.r<0&&partenza.direzione==SOPRA)||(partenza.r>My_RIGHE_-1&&partenza.direzione==SOTTO)||(partenza.c<0&&partenza.direzione==SINISTRA)||(partenza.c>My_COLONNE_-1&&partenza.direzione==DESTRA))){
		partenza=sposta(partenza); //mentre il laser è ancora all'interno della griglia chiama sposta, poi esce
	}
	if(partenza.direzione==SOPRA||partenza.direzione==SOTTO){ //converte pos_t partenza (contenente la posizione attuale (esterna) del laser in foro_t uscita per restituirla
		uscita.lato=partenza.direzione;
		uscita.posizione=partenza.c;
	}else{
		uscita.lato=partenza.direzione;
		uscita.posizione=partenza.r;
	}
	return uscita;
}

Errore di compilazione:

grader.cpp: In function 'int main()':
grader.cpp:50:27: warning: ignoring return value of 'ssize_t read(int, void*, size_t)', declared with attribute warn_unused_result [-Wunused-result]
  read(STDIN_FILENO, &N, 4);
                           ^
grader.cpp:51:27: warning: ignoring return value of 'ssize_t read(int, void*, size_t)', declared with attribute warn_unused_result [-Wunused-result]
  read(STDIN_FILENO, &M, 4);
                           ^
grader.cpp:52:27: warning: ignoring return value of 'ssize_t read(int, void*, size_t)', declared with attribute warn_unused_result [-Wunused-result]
  read(STDIN_FILENO, &Q, 4);
                           ^
/tmp/ccq8O3kd.o: In function `inizia(int, int)':
specchi.cpp:(.text+0x4): relocation truncated to fit: R_X86_64_PC32 against symbol `My_RIGHE_' defined in .bss section in /tmp/ccq8O3kd.o
specchi.cpp:(.text+0xa): relocation truncated to fit: R_X86_64_PC32 against symbol `My_COLONNE_' defined in .bss section in /tmp/ccq8O3kd.o
/tmp/ccq8O3kd.o: In function `calcola(

Grazie in anticipo.

Il tipo di dato char pesa 1byte e hai dichiarato una matrice di 100000 * 100000 occupando ben 10000000000 byte. Questo numero brutto converitito in GB fanno circa 10 GB.
Hai usato giusto un pochino troppa memora :roll_eyes:

Grazie mille!
Non avevo proprio pensato a una cosa del genere…

1 Mi Piace