Ordinare array

[Claudio Vituzzi]

Ho un array di questo tipo (tutto su dbm)

*Il numero tra parentesi è un numero ID
*Time è la funzioni di perl e unix che rappresenta i secondi dal 1970...

(1) => time
(2) => time
(3) => time...
etc...

Come faccio ad ordinare Le chiavi in base all'ordine decrescente dei Valori?
(Con un file bello grosso che prestazioni in termini di velocità ho?)



+

Avrei bisogno poi di suddividere in pagine da 10 IDs ciascuna e poter sfogliare queste pagine:

Io pensavo di:

1) leggere tutto il file DBM e fare il sort da me richiesto che va in @SORTED
2) a pagina zero prendere i primi 10 valori di SORTED [ da 0 a 9 ... ]
3) a pagina 1 prendere i seguenti (1x10) valori di... [ da 9 a 19 di @SORTED ]
3) a pagina 2 prendere i seguenti (2x10) valori di... [ da 20 a 29 di ... ]
4) etc...

Ho molte difficolta a buttare giù le righe in PERL...non so adoperare bene le funzioni su array

Chi si offre?

Grazie mille!

[shishii]

bisogna chiarire alcune cose.

puoi postare il codice che viene usato per inserire i dati nel DBM?

trattandosi di un array che ha per valori gli output di time è lecito ritenere che i dati nel DBM siano in maniera naturale in ordine crescente di tempo?

si può verificare che due time siano uguali?

[Claudio Vituzzi]

Cercherò di spiegarmi meglio anche se il concetto è semplice:

Il file "time.dbm" contiene la coppia CHIAVE => VALORE formata da:

CHIAVE(numero ID univoco ++) => VALORE(valore di ritorno della funzione "time" NON sempre consecutiva*)

*Avvolte può venir modificato il valore di alcune chiavi con ID precedenti al valore dell ID attuale

quindi per scrivere i valori vado con:

$ID ++;
   dbmopen(%HASH, "time.dbm" , 0644) || die "Can't open!\n";
    $HASH{$ID} = time;
   dbmclose{%HASH}

e per leggere faro:

dbmopen(%HASH, "time.dbm" , 0644) || die "Can't open!\n";
   %NEW_HASH = %HASH; # ottengo il contenuto del file...
dbmclose;

ora devo fare in modo che in @SORT_ARRAY ci siano i valori ID di $NEW_HASH ma ordinati in base ai valori "crescenti" di $NEW_HASH

per farvi capire:

 $SORT_ARRAY[3]; # contiene: 01233
 $SORT_ARRAY[1]; # contiene: 01234
 $SORT_ARRAY[5]; # contiene: 01235

etc...

Infine avrei bisogno di splittare l'array in gruppi di 10 valori...in parole povere di far vedere in più pagine 10 IDs dell'array alla volta...una specie di "Paginazione" dell'array...

Credo che il concetto di quello che ho bisogno sia ben chiaro!

Grazie a tutti

[Claudio Vituzzi]

In parole povere:

    # Ordino...
   my @ARRAY = sort { $HASH{$b} <=> $HASH{$a} } keys %HASH; undef %HASH;

    # Divido in pagine da 10...

    my $Current_page; # es: 0
    my $k = 0;

     CICLO:
     do
     {

       $k++
       $Current_ID = ( ( ($Current_page * (10-1) ) + $k )/1 );
       $value = $ARRAY[$Current_ID];
       push ( @DIECI_IDS , $value );

       last CICLO if $DIECI_IDS = 10; # se @DIECI_IDS contiene 10 valori lascia il CICLO

     } while();

ma non ne riesco a venire a capo...

[Claudio Vituzzi]

Ancora meglio...

    # Ordino...
   my @SORTED_ARRAY = sort { $HASH{$b} <=> $HASH{$a} } keys %HASH; undef %HASH;

    # Divido in pagine da 10...

    my $Current_page = 1 unless $Current_page;
    my $start = (($Current_page * 10)-1);
    my $end   = (($Current_page * 10)-10);
    my $total_page = int($SORTED_ARRAY / 10);
    my $page_prev = $Current_page - 1;
    my $page_next = $Current_page + 1;

    my @DIECI_IDS = $SORTED_ARRAY[$start .. $end]; # e' possibile??

mi date una mano?

[Claudio Vituzzi]

Alla fine ci dovrei essere arrivato da solo:

    # Ordino...
   my @SORTED_ARRAY = sort { $HASH{$b} <=> $HASH{$a} } keys %HASH; undef %HASH;

    # Divido in pagine da 10...

    my $Current_page = 1 unless $Current_page;
    my $start = (($Current_page * 10)-1);
    my $end   = (($Current_page * 10)-10);
    my $total_page = int($SORTED_ARRAY / 10);
    my $page_prev = $Current_page - 1;
    my $page_next = $Current_page + 1;
    my @DIECI_IDS;
    push ( @DIECI_IDS , $SORTED_ARRAY[$start .. $end] );

E' giusta la sintassi?

[shishii]

Originariamente inviato da Claudio Vituzzi
Alla fine ci dovrei essere arrivato da solo:

    # Ordino...
   my @SORTED_ARRAY = sort { $HASH{$b} <=> $HASH{$a} } keys %HASH; undef %HASH;
    # non capisco "undef %HASH", così perdi il suo contenuto
    # non ti serve più?

    # Divido in pagine da 10...

    my $Current_page = 1 unless $Current_page;
    # "unless $Current_page" serve solo se questo codice
    # è inserito all'interno di un ciclo, altrimenti basta
    # $Current_page=1;
    my $start = (($Current_page * 10)-1);
    my $end   = (($Current_page * 10)-10);
# qui ritengo che i criteri di calcolo di start ed end
# debbano essere invertiti. Infatti dopo il sort iniziale
# trovi all'indice 0 dell'array il valore più alto
    my $total_page = int($SORTED_ARRAY / 10);
# va modificato in:
# my $total_page = int(scalar(@SORTED_ARRAY) / 10);
# $total_page++ if (scalar(@SORTED_ARRAY) % 10 != 0);
    my $page_prev = $Current_page - 1;
    my $page_next = $Current_page + 1;
    my @DIECI_IDS;
    push ( @DIECI_IDS , $SORTED_ARRAY[$start .. $end] );
# va modificato in:
# @DIECI_IDS = @SORTED_ARRAY[$start .. $end];

E' giusta la sintassi?

suggerimenti in mezzo al codice.

[Claudio Vituzzi]

Mi servono delle ultime spiegazioni...

    # Ordino...
   my @SORTED_ARRAY = sort { $HASH{$b} <=> $HASH{$a} } keys %HASH;
   undef %HASH; # Libero la memoria...

    # Divido in pagine da $rows...
    # $Current_page è il valore della pagina corrente ed arriva tramite cgi->param();

    my $rows = 10;
    if (!$Current_page) {$Current_page = 1};
    my $end = (($Current_page * $rows)-1);
    my $start   = (($Current_page * $rows)-$rows);
    my $total_page = int( scalar(@SORTED_ARRAY) / $rows );
          $total_page++ if ( scalar(@SORTED_ARRAY) % 10 != 0); # ? mi sipeghi meglio?
    my $page_prev = $Current_page - 1;
    if ($Current_page <= 1) {$page_prev = 1}; # Giusto?
    my $page_next = $Current_page + 1;
    if ($Current_page =>  $total_page) {$page_next =  $total_page}; # Giusto?
    my @DIECI_IDS;
    @DIECI_IDS = @SORTED_ARRAY[$start .. $end];
    undef @SORTED_ARRAY; # Libero la memoria...

[Claudio Vituzzi]

ancora meglio...

# Ordino...
my @SORTED_ARRAY = sort { $HASH{$b} <=> $HASH{$a} } keys %HASH;
undef %HASH; # Libero la memoria...

# Divido in pagine da $rows...
# $Current_page è il valore della pagina corrente ed arriva tramite cgi->param();

my $rows = 10;
if (!$Current_page) {$Current_page = 1};
my $end = (($Current_page * $rows)-1);
my $start   = (($Current_page * $rows)-$rows);
my $total_page = int( scalar(@SORTED_ARRAY) / $rows );
$total_page++ if ( scalar(@SORTED_ARRAY) % 10 != 0); # ? mi sipeghi meglio?
my $page_prev = $Current_page - 1;
if ($Current_page <= 1) { undef $page_prev };
my $page_next = $Current_page + 1;
if ($Current_page =>  $total_page) { undef $page_next };
my @DIECI_IDS;
@DIECI_IDS = @SORTED_ARRAY[$start .. $end];
undef @SORTED_ARRAY; # Libero la memoria...

...

print @DIECI_IDS;

if ($page_prev) { ... ".cgi?Current_page="."$page_prev" } else { ... # non mostrare la freccia "prev" };
if ($page_next) { ... ".cgi?Current_page="."$page_next" } else { ... # non mostrare la freccia "next" };

[shishii]

Originariamente inviato da Claudio Vituzzi
ancora meglio...

# Ordino...
my @SORTED_ARRAY = sort { $HASH{$b} <=> $HASH{$a} } keys %HASH;
undef %HASH; # Libero la memoria...

## ho capito... ti bastano gli indici dell'hash

# Divido in pagine da $rows...
# $Current_page è il valore della pagina corrente ed arriva tramite cgi->param();

my $rows = 10;
if (!$Current_page) {$Current_page = 1};
my $end = (($Current_page * $rows)-1);
my $start   = (($Current_page * $rows)-$rows);
my $total_page = int( scalar(@SORTED_ARRAY) / $rows );
$total_page++ if ( scalar(@SORTED_ARRAY) % $rows != 0); # ? mi sipeghi meglio?

## ammettiamo che hai 34 record, se fai solo:
## my $total_page = int( scalar(@SORTED_ARRAY) / $rows );
## avrai un numero di pagine di 3, che è sbagliato
## perchè in realtà le pagine sono 4, 3 con 10 record ed 1
## con 4
## per ottenere il risultato giusto incrementi di uno il totale
## se il numero di record non è un multiplo esatto di 10

my $page_prev = $Current_page - 1;
if ($Current_page <= 1) { undef $page_prev };
## questa è una esagerazione... sprechi più risorse a 
##fare undef che lasciare fino alla fine dell'esecuzione 
## dello script la variabile
my $page_next = $Current_page + 1;
if ($Current_page =>  $total_page) { undef $page_next };
## vedi sopra e inoltre c'è un errore di sintassi
## si scrive >= e non =>
my @DIECI_IDS;
@DIECI_IDS = @SORTED_ARRAY[$start .. $end];
undef @SORTED_ARRAY; # Libero la memoria...

...

print @DIECI_IDS;

if ($page_prev) { ... ".cgi?Current_page="."$page_prev" } else { ... # non mostrare la freccia "prev" };
if ($page_next) { ... ".cgi?Current_page="."$page_next" } else { ... # non mostrare la freccia "next" };