Newsgroup: it.comp.lang.visual-basic
Titolo: [?] Sequenza casuale senza ripetizioni

Ciao a tutti e buon anno da Amadeus,
avrei bisogno ottenere una sequenza casuale di tutti i numeri da 1 fino a
10. Ho provato con la funzione Rnd:
Dim sequenza(10)
For x= 1 To 10
sequenza(x)=Int((10 * Rnd) + 1)
Next x
ma non funge al mio scopo perche' ottengo si una matrice di 10 numeri
compresi tra 1 e 10, ma con dei doppioni che invece non dovrebbero esserci.
Sono sicuro di essermi spiegato  da cani, come al solito !
Se comunque qualcuno sa aiutarmi sarei molto grato, senno grazie lo stesso
per avermi letto fin qui.
Ciao Amadeus

 compresi tra 1 e 10, ma con dei doppioni che invece non dovrebbero
esserci.
Devi escludere i doppioni. Ti ci vorrà qualche tentativo in più,
ma se veramente ti serve solo fino a 10, dovrebbe andare.
Attenzione: se usi limiti molto maggiori, i tempi potrebbero
peggiorare. Intorno a 10000 ci mette anche un secondo per
riempire la matrice.
___________________________
      Dim Sequenza(10) As Integer
      Dim Test As Integer
      Dim GiaUscito(10) As Boolean
      Dim Accettati As Integer
      Do Until Accettati = 10
            Test = Int((10 * Rnd) + 1)
            If Not (GiaUscito(Test)) Then
                  GiaUscito(Test) = True
                  Sequenza(Accettati) = Test
                  Debug.Print Test
                  Accettati = Accettati + 1
            End If
      Loop
___________________________
Bye, G.
--
---------------------------------------------
    Le risposte alle tue domande le trovi
    sul Sito Comune di questo NewsGroup:
 
http://www.murialdo.it/it_lang_vb
       ... e nell'help in linea !
---------------------------------------------
Real E-address: 
gaet...@hotmail.com

10. Ho provato con la funzione Rnd:
la sequenza secondo me va bene ma ad ogni ciclo devi verificare se il numero
prodotto e gia stato dato quindi inserirei nel tuo ciclo una altro annidato
di verifica dei numeri prodotti e se il numero e' gia presente ne riprendo
il ciclo primario.
Ciao Stefano

>10. Ho provato con la funzione Rnd:
proverei con un subdolo ma funzionalissimo trucco che funzionerebbe anche
con 100000 numeri
prima riempi la matrice con numeri consecutivi 1,2,3,4,5....100000
e poi ... LI SCAMBI A CASO!
ovvero scambi l'elemento matrice[rnd*100000] con matrice[rnd*100000]
piu' scambi fai, piu' saranno mescolati, ma ogni volta non devi
ricontrollare tutti i gia' "usciti" (che con 100000 numeri sarebbe assurdo)
ditemi che ne pensate.

>per avermi letto fin qui.
Riempi un vettore con i numeri da 1 a n.
Produci un numero casuale da 1 a n.
Prendi come estratto l'elemento corrispondente nel vettore.
Scambia l'ultimo elemento con quello appena estratto.
decrementa n di 1
produci un nuovo numero casuale, etc.
Antonio




 ___________________________
Attento che Array(10) e' costituito da 11 elementi da 0 a 10 quindi il
codice qui sopra riempie i primi 10 (da 0 a 9) e l'11mo (10) e' sempre zero.
A parte quanto sopra, vedrei meglio una coppia di array di cui il primo
andrebbe popolato di valori casuali con un semplice ciclo:
For i=LBound(ValoriCasuali) To UBound(ValoriCasuali)
    Let ValoriCasuali(i)=Rnd
Next
mentre il secondo verrebbe popolato con la posizione occupata da tali valori
nel vettore mediante ordinamento.
Per fare velocemente un esempio piazziamo in un Form due ListBox di cui solo
la prima ha la proprieta' Sorted=True (e solo la prima e' necessaria, la
seconda serve per mostrare il risultato) ed un CommandButton con il codice
seguente:
Private Sub Command1_Click()
  Const iInf% = 1
  Const iSup% = 10
  Dim i%
  Call List2.Clear
  With List1
    Call .Clear
    Call Randomize
    For i = iInf To iSup
      Call .AddItem(Rnd)
      Let .ItemData(.NewIndex) = i
    Next
    For i = 0 To .ListCount - 1
      Call List2.AddItem(.ItemData(i))
    Next
  End With
End Sub
Ciao.
Maurizio

 wrote in message
84u2f8$ggm$1...@fe1.cs.interbusiness.it...
| Ciao a tutti e buon anno da Amadeus,
|
| avrei bisogno ottenere una sequenza casuale di tutti i numeri da 1 fino a
| 10. Ho provato con la funzione Rnd:
|
| Dim sequenza(10)
| For x= 1 To 10
| sequenza(x)=Int((10 * Rnd) + 1)
| Next x
|
| ma non funge al mio scopo perche' ottengo si una matrice di 10 numeri
| compresi tra 1 e 10, ma con dei doppioni che invece non dovrebbero
esserci.
| Sono sicuro di essermi spiegato  da cani, come al solito !
| Se comunque qualcuno sa aiutarmi sarei molto grato, senno grazie lo stesso
| per avermi letto fin qui.
|
| Ciao Amadeus
|
|

>per avermi letto fin qui.
Riempi un vettore con i numeri da 1 a n.





 Next
Il problema era di avere dei numeri interi, in un range definito e senza
ripetizioni. Ho provato il tuo esempio, non mi sembra faccia questo.
Oppure il virus gastrointestinale mi ha attaccato anche l'ultimo neurone...
Mi sento come HAL 9000 quando Dave gli staccava le memorie... :-((
Spiegami meglio, per favore !


 Spiegami meglio, per favore !
    Vettore A       Vettore B
 1) 0,089946930  1)  2
 2) 0,005225778  2)  1
 3) 0,289113300  3) 10
 4) 0,785778300  4)  3
 5) 0,938300600  5)  8
 6) 0,490682500  6)  6
 7) 0,991190500  7)  4
 8) 0,454205000  8)  9
 9) 0,859045700  9)  5
10) 0,200370900 10)  7
Nel Vettore B il 1mo elemento e' 2 in quanto 0,005225778 e' il piu' piccolo
dell'insieme ed occupa la seconda posizione... e cosi' via. E cioe':
A(1 to 10) viene riempito coi numeri casuali per mezzo del ciclo
   Randomize
   For i = 1 To 10
     A(i) = Rnd
   Next
Quindi, per mezzo di un algoritmo di ordinamento a piacer tuo (ne e' stato
postato uno giusto oggi!) si ricava il Vettore B contenente la posizione
degli elementi ordinati di A, ovvero dei "numeri interi, in un range
definito e senza ripetizioni" in un modo che a me sembra piu' efficiente in
quanto non e' sottoposto all'alea della (pseudo)casualita' ma solo a quella
(relativa) dell'efficienza dell'algoritmo di ordinamento.
Ciao.
Maurizio

 (relativa) dell'efficienza dell'algoritmo di ordinamento.
Il funzionamento è impeccabile, infatti anche in caso di due valori random
che (per quanto improbabilmente) siano uguali, la routine di ordinamento
non potrà fare a meno di metterne uno prima dell'altro...
Quanto all'efficienza, nel senso di velocità, non so, si tratta (p. es. con il
QuickSort) di ordinare uno dei vettori e swappare (scusa, pal !) in sincrono
i dati dell'altro. Il programma che avevo proposto, per un array di 10000
elementi, impiegava circa 1 secondo, con il tuo alle prime prove i tempi mi
sembrano molto più lunghi, circa 10-20 volte, ma sicuramente il quicksort
non sarà il più efficiente su un array totalmente disordinato.
Devo proprio decidermi a ritirar fuori qualche libro...
Tu cosa useresti per fare questa funzione su, per esempio, 1000 o 10000
numeri ?


Scusate se mi intrometto ma non capisco la vostra discussione.
Mi sembra che il metodo da me proposto sia di gran lunga piu' veloce, di complessita' O(n).
Lo ripresento.
1. riempo il vettore di n elementi con i numeri da 1 a n.
2. estraggo x = un numero a sorte da 1 a n.
3. uso il valore v(x).
4. inserisco in v(x) il valore v(n).
5. decremento n di 1
6. vado al punto 2 se n > 0
Antonio

Mi sembra che il metodo da me proposto sia di gran lunga piu' veloce, di complessita' O(n).
Vero, l'ho provato.
