usi alternativi di sort()...

[ileilex]

ciao a tutti!

ho una matrice del genere:

4,4,2,1,3,2,3,2,1,1,4,3,2,2
4,3,2,2,3,1,4,3,1,1,4,2,2,1
2,1,1,3,3,3,2,4,1,4,1,3,2,3
1,2,4,1,3,1,3,2,2,2,1,1,3,3
4,3,4,3,1,4,3,4,4,4,2,4,2,1
3,3,3,4,1,4,0,2,1,4,3,2,2,2
4,4,1,3,3,3,0,2,4,4,2,1,2,4
1,3,1,3,3,3,0,2,4,3,2,3,3,4
3,3,4,1,4,3,0,2,1,4,1,3,1,3
4,0,4,2,4,2,2,3,2,4,1,3,2,2
3,0,4,1,3,3,1,1,2,1,1,1,1,2
1,2,3,1,4,1,2,3,3,3,4,4,0,4
4,1,1,1,2,4,3,4,1,1,2,1,0,4
1,2,4,1,2,1,3,4,4,4,4,3,4,4

e vorrei che gli zeri presenti nella matrice occupassero nell'ambito della medesima colonna le prime righe, facendo scalare gli elementi delle righe superiori più in basso.

Secondo voi é possibile usare il metodo sort()? Ovvero é possibile dire a sort "metti prima gli 0 e poi tutto il resto, senza differenziare tra i valori != da zero"?

grazie!

[crescenzo]

beh io farei diversamente userei un'altra matrice e con un ciclo scorrerei la prima controllando i valori se sono == a 0 li inserisco nella nuova matrice...poi alla fine farei la cosa contraria con un'altro ciclo scorrerei sempre la prima matrice e inserirei nella nuova solo i valori !=0 e quindi avrei ottenutop una matrice con i primi valori ==0 e poi gli altri

ma il fatto delle righe nn l'ho mi capito...

[ileilex]

grazie crescenzo per la tua risposta!
il problema é che gli 0 devono rimanere nella stessa colonna e vorrei evitare un codice troppo complicato...
nell'attesa io ho provato a fare questo:

public function gravity (){

   for (i=0; i<SIZE; i++){
   for (j=0; j<SIZE; j++){
    if(griglia[i][j]==0){

    griglia[i].sort(compare);
    }

function compare(a, b){   
    if(griglia[i][j]==0){
       griglia[i][j]=a;
        }
      if(griglia[i][j]!=0){
       griglia[i][j]=b;
        }
    
    return -1;
    } 

tuttavia non mi da i risultati sperati! gli 0 non vanno in cima alla colonna ma si sparpagliano in modo apparentemente casuale lungo la colonna...saro' sulla strada giusta?

[and80]

Non vorrei sbagliarmi, non usando assiduamente il sort(), ma questa funzione serve solo ad ordinare, secondo una tipologia specifica di ordinamento, un array.
Mentre per mettere gli 0 davanti potresti scrivere una funzione del genere:

// FP9+AS3
var a:Array = [3,3,3,4,1,4,0,2,1,4,3,2,2,2];
a.forEach(foreach);
function foreach (e:*, i:uint, a:Array) {
    if (e == 0) {
        a.splice(0, 0, a.splice(i, 1));
    }
}
trace(a); // 0,3,3,3,4,1,4,2,1,4,3,2,2,2 

[ileilex]

ciao and80! grazie per il tuo consiglio!
ho provato a implementarlo e potrebbe essere un'alternativa sicuramente valida... a parte un problema: al posto di mettermi in cima alla colonna (o al vettore generico) gli 0, mi mette dei valori "undefined" che corrispondono in linea di massima a quelli che dovrebbero precedere gli 0...

Ti posto la mia implementazione, qualora il problema fosse dovuto ad un errore di svista...

public function gravity (){
    for (i=0; i<SIZE; i++){
    for (j=0; j<SIZE; j++){
    griglia[i].forEach(foreach); 
        }
        }
                          }

function foreach (e:*, i:uint, griglia:Array) { 
        if (e == 0) { 
            griglia.splice(0, 0, griglia.splice(i, 1)); 
                   } 
        } 

non ti posto postare un trace, perché non riesce a farlo essendoci alcuni valori undefined.

[and80]

Attenzione, perchè il forEach esegue già un ciclo sull'array a cui viene passato, tu già ne stai eseguendo due nidificati - che immagino abbiano dell'altro codice - in più esegui un forEach e praticamente stai nidificando tre cicli.
Se provi il codice del mio esempio, dovresti facilmente capire come agisce lo stesso, dai un'occhiata alla descrizione della guida riguardo alla funzione splice(), ti dovrebbe apparire tutto più chiaro.

[ileilex]

in effetti era necessario un solo ciclo for aggiuntivo, in modo che considerasse le singole colonne della matrice e non la matrice intera! grazie ancora!

resto cmq in attesa di eventuali delucidazioni sul sort per prossimi utilizzi...

[and80]

Per il sort sostanzialmente non c'è nulla di più di quanto ci sia scritto nella guida, esiste inoltre la funzione sortOn che gestisce anche gli array con elementi che hanno più di una proprietà, per cui li gestisce in base a determinate caratteristiche degli stessi, la guida dice "Ordina gli elementi di un array in base a uno o più campi dell'array".
Ma in ogni caso con entrambi otterrai solo il fatto di ordinarli e non di spostare un determinato elemento all'inizio, lasciando inalterati gli altri.

Array.sort()
Array.sortOn()