Newsgroup: it.comp.lang.perl
Titolo: valori random univoci.

Salve.
Ho questo ciclo 
for ($i = 0; $i <= 500; $i++) {
	$sn = "@files[int(rand($#files))]";
essendo eseguito per 500 volte puo' capitare che la 
funziona rand() mi dia dei valori uguali.
Vorrei fare in modo di avere dei valori sempre diversi fino
alla fine del ciclo.
Come posso fare?
Grazie.

,
scriveva:

Un modo semplice, ma non particolarmente efficiente (e non particolarmente
verificato), potrebbe essere:
   for ($i = 0; $i <= 500; $i++) {
       $ind = int(rand($#files));
       $sn = @files[$ind];
       splice @files, $ind, 1;
   }
Con un po' di pazienza si può pensare a qualcosa di meglio, ma il principio
di eliminare quello che hai già preso resta valido.
Ci sono anche un paio di pacchetti per effettuare delle permutazioni, se è
questo che intendi fare: List::Permutor e Algorithm::Permute. Vedi anche
perldoc -q permute.
Ciao.



Salve,
  Il modo classico di sopprimere i duplicati da una sequenza utilizza 
un hash:
my $i = 0;
my %hash = ()
while ($i < 500) {
  my $tmp = $files[rand($#files)]; # cf nota 1
  next if exist $hash{$tmp};
  $files_schelti{$tmp} = 1;
  $i++;
}
 my @the_files = keys %hash;
Nota 1:
  Attenzione a non confondere $array[n] con @array[n]. La prima
espressione è uno scalare (l'elemento in posizione n+1 nell'array
@array). La seconda è un vettore di un solo elemento, tale elemento
essendo anche questa volta l'elemento in posizione n+1 nell'array @array. 
E' per questo che sei stato costretto ad utilizzare le virgolette per
ottenere un elemento e non sempre 1 :)
Spero di essere stato utile....
-- 
Leo "TheHobbit"
One Ring to rule them all, One Ring to find them,
One Ring to bring them all and in the darknes bind them
In the land of Mordor where the Shadow lie.

   $files_schelti{$tmp} = 1;
  #cavolo è tardi... sostituisci la linea qui sopra con:
     $hash{$tmp} = 1;


 un hash:
 
La funzione splice citata da Giovanni non e' utile allo scopo? 

La funzione splice citata da Giovanni non e' utile allo scopo? 
"Ci sono molti modi per cuocere un uovo". Non ho verificato il codice che
ho pubblicato[1], ma splice di per sé funziona certamente. Ed ha un certo
costo, in termini di elaborazione. Spuntare in un hash gli elementi già
selezionati può ugualmente funzionare (in teoria, a differenza di
un'eliminazione fisica dagli elementi da cui scegliere, non c'è la certezza
che il ciclo termini, ma possiamo comunque avere una certa confidenza
pratica nel fatto che prima o poi terminerà), ed ha un suo, altro, costo.
Sono sicuro che si possono trovare anche altri sistemi, ed ho una certa
confidenza che alcuni possano essere anche più efficienti.
Ciao.
[1] Di cui comunque correggo la riga:
       $sn = @files[$ind];
con:
       $sn = $files[$ind];
per il motivo spiegato bene da TheHobbit. O anche:
       $sn =  splice @files, $ind, 1;
dato che splice ritorna, in contesto scalare, l'ultimo elemento (in questo
caso, l'unico) rimosso.

msan wrote:


Prova con numeri grossi :)
int(rand(100000000));
***************************************
messaggio inviato tramite HostSearch.it
---------------------------------------
---> 
http://www.hostsearch.it/newsgroup
***************************************