Problema di trasformazione da una matrice ad un array

[youngz]

Salve, visto che è abbastanza lungo il testo del programma spedirei via pm a chi è interessato ad aiutarmi.
Inizio a spiegare il problema , io ho una matrice dalla quale devo ricavare un percorso lineare (un array) solo che dopo essermi scervellato un bel po' non ho ancora trovato una soluzione, quindi speravo che qualcuno mi possa spiegare cosa c'è che non va.

[oronze]

piuttosto che inviare il codice in mp, spiega bene come deve essere qusto array lineare...
5, 3, 4, 8, 9
2, 78, 95
1, 0, 0, 25

deve diventare 5, 3, 4, 8, 9, 2, 78, 95, 1, 0, 0, 25
oppure 5, 2, 1, 3, 78, ......
oppure in un altro modo?

[youngz]

ok, dato un array così:

E E E A E E
E E B C E E
E D F E E E
E K E E E E
E L M N E E
E E E T E E

deve diventare T N M L K D F B C A

spero di essere stato chiaro, deve leggere dal basso verso l'alto e seguire il percorso creato dalle lettere diverse da E

Questo è quello che ho provato a fare io:

	int colonna = 0;
	int riga = n_row-1;
	int adiacenti;
	boolean destra = false;
	boolean sinistra = false;
	boolean alto = false;
	boolean basso = false;
	boolean inizio = true;
	int indice = 1;
	do{
		adiacenti=0;
		if( !(M[riga][colonna] instanceof Empty) ){
			if( (colonna<(n_col-1)) && !( M[riga][colonna+1] instanceof Empty) ){		//confronto con casella più a destra
				adiacenti++;
				destra=!destra;
			}
			if( (colonna!=0) && !(M[riga][colonna-1] instanceof Empty ) ){		//confronto con casella più a sinistra
				adiacenti++;
				sinistra = !sinistra;
			}
			if( (riga!=0) && !(M[riga-1][colonna]  instanceof Empty ) ){		//confronto con casella più in alto
				adiacenti++;
				alto = !alto;
			}
			if( riga<(n_row-1) && !(M[riga+1][colonna] instanceof Empty) ){		//confronto con casella più in basso
				adiacenti++;
				basso = !basso;
			}
			if(adiacenti==1){		//siamo in presenza dell'ultima casella o della prima
					board[0] = M[riga][colonna];
					inizio = false;
					break;
			}
			else
				destra=sinistra=alto=basso=false;
		 }
		 colonna++;
		if(colonna==n_col){
			colonna=0;
			riga--;
		}
	}while(inizio);

	
	
	for(int w=0;w<n_row;w++){
		System.out.println("");
		for(int e=0;e<n_col;e++)
			System.out.print(M[w][e]+"\t");
	}
	
System.out.println("\n\n\n\n\n\n\n\n");
	
	do{
		if(destra){
			while(!(M[riga][colonna] instanceof Empty)){
				System.out.println(M[riga][colonna]+"; d");
				colonna++;
				board[indice++]=M[riga][colonna];
			}
			colonna--;
		}
		if(sinistra){
			while(!(M[riga][colonna] instanceof Empty)){
				System.out.println(M[riga][colonna]+"; s");
				colonna--;
				board[indice++]=M[riga][colonna];
			}
			colonna++;
		}
		if(alto){
			while(!(M[riga][colonna] instanceof Empty)){
				System.out.println(M[riga][colonna]+"; a");
				riga--;
				board[indice++]=M[riga][colonna];
			}	
			riga++;
		}
		if(basso){
			while(!(M[riga][colonna] instanceof Empty)){
				System.out.println(M[riga][colonna]+"; b");
				riga++;
				board[indice++]=M[riga][colonna];
			}
			riga--;
		}

		
		if( colonna<(n_col-1) && !( M[riga][colonna+1] instanceof Empty) )	{
			colonna++;
			destra=!destra;
		}
		if( (colonna!=0) && !(M[riga][colonna-1] instanceof Empty ) )	{
			colonna--;
			sinistra = !sinistra;
		}
		if( (riga!=0) && !(M[riga-1][colonna]  instanceof Empty) )	{
			riga--;
			alto = !alto;
		}
		if( riga<(n_row-1) && !(M[riga+1][colonna] instanceof Empty ) ){
			riga++;
			basso = !basso;
		}
	}while(indice<r);

Dove empty è una sottoclasse di una classe generale di cui è dichiarata board e M e pieno di sottoclassi sempre di quella che è dichiarata board (non so se è chiaro)
R è la lunghezza dell'array (cioè il numero di caselle della matrice non Empty)
n_row e n_col son la grandezza della matrice (per chiarirci è stata dichiarata M[n_row][n_col] e M è la matrice)
Dovrebbe essere tutto.

[oronze]

    public static void main(String[] args) {
        int row=6, col=6;
        Comparable[][] array = new Comparable[row][col];
        array[0][0] = "E";
        array[0][1] = "E";
        array[0][2] = "E";
        array[0][3] = "E";
        array[0][4] = "A";
        array[0][5] = "E";

        array[1][0] = "E";
        array[1][1] = "E";
        array[1][2] = "B";
        array[1][3] = "C";
        array[1][4] = "E";
        array[1][5] = "E";

        array[2][0] = "E";
        array[2][1] = "D";
        array[2][2] = "F";
        array[2][3] = "E";
        array[2][4] = "E";
        array[2][5] = "E";

        array[3][0] = "E";
        array[3][1] = "K";
        array[3][2] = "E";
        array[3][3] = "E";
        array[3][4] = "E";
        array[3][5] = "E";

        array[4][0] = "E";
        array[4][1] = "L";
        array[4][2] = "M";
        array[4][3] = "N";
        array[4][4] = "E";
        array[4][5] = "E";

        array[5][0] = "E";
        array[5][1] = "E";
        array[5][2] = "E";
        array[5][3] = "T";
        array[5][4] = "E";
        array[5][5] = "E";
        
        ArrayList<Comparable> arrLineare = new ArrayList<Comparable>();
        for(int i=array[0].length-1;i>0;i--){
            for(int j=array.length-1;j>0;j--){
                if(!array[i][j].equals("E")) arrLineare.add(array[i][j]);
            }
        }
        for(Comparable c:arrLineare) System.out.print(c+" ");
    } 

poi lo adatti tu alle tue esigenze

[youngz]

Ma così me la prende con la mia logica?E soprattutto funziona anche in caso se le lettere al posto che stringhe son classi?
Non prende la A (ed effettivamente è meglio così visto che nell'array non è affiancata a nessuno nel percorso).

[andbin]

Originariamente inviato da youngz
Ma così me la prende con la mia logica?E soprattutto funziona anche in caso se le lettere al posto che stringhe son classi?

Concettualmente sì ... è come ha detto oronze, anche se ha fatto tutto usando stringhe, il che non ha nulla a che vedere con le tue classi.

Ma il concetto, banale, è quello: fai un doppio ciclo for annidato con gli indici che vanno al contrario (perché vuoi destra->sinistra e basso->alto), se l'elemento non è del tuo tipo Empty, lo aggiungi ad una semplice lista. Tutto qua ... nothing more!!

[youngz]

Si ma intendevo, un array comparable può contenere oggetti e non stringhe o roba simile?
Poi qui mi prende un array "dritto" , spiego:

E E E E A E
E E B C E E
E D F E E E
E K E E E E
E L M N E E
E E E T E E

e nel programma sopra prende TNMLKFDCB invece di TNMLKDFBC

[andbin]

Originariamente inviato da youngz
Si ma intendevo, un array comparable può contenere oggetti e non stringhe o roba simile?

Ma a te non credo proprio che interessi Comparable .... anzi non so nemmeno perché oronze hanno usato Comparable quando poteva semplicemente usare String!!

Hai detto che hai una classe base, da cui derivano Empty e il resto, giusto? Usa quella come tipo della collezione!

[youngz]

Si,quello lo immaginavo, il vero problema è quello che ho scritto sotto, lui deve prendere il percorso non semplicemente dal basso verso l'alto e da sinistra verso destra.. E' quello il difficile

[andbin]

Originariamente inviato da youngz
e nel programma sopra prende TNMLKFDBC invece di TNMLKDFBC

Ah alt!!! Allora non è una banale trasposizione da matrice 2d ad array lineare!!! Ecco quello che dicevi "seguire il percorso creato dalle lettere diverse da E"!! Data una cella non E vuoi proprio cercare quella adiacente a cui passare e così di seguito ....

Quindi è un po' più complesso .... ma non come l'hai fatto tu all'inizio che è allucinante ....
E in tal caso si presuppone (se non specifichi altri requisiti) che esista solo 1 path e basta ... non più ramificazioni.