Novità

Come impostare in un array x una elaborazione di tipo random dei valori fissi?

lotto_tom75

lotto_tom75

Advanced Premium Member
Come riportato nell'esempio sottostante vorrei che l'elaborazione di tipo random sottostante mi elaborasse un array numerico con 5 valori fissi sempre uguali e i restanti scelti da tabella "colorata".

Codice: 
QuantitaNumeriScelti = ScegliNumeri(Av)

aFissi = Array(0,Av(1),Av(2),Av(3),Av(4),Av(5))

Valorestringa = StringaNumeri(aFissi,,True)

'prova sviluppo di tipo random

Dim Valoreinizioelaborazione,Valorefineelaborazione,Classe,nSorte
Valoreinizioelaborazione = 1
Valorefineelaborazione = 500000 'es:  500000 colonne

Classe = 21
Sorte = 2

For i = Valoreinizioelaborazione To Valorefineelaborazione

Call GetColonnaCasuale(Classe,aRetCol,Av)

In sostanza l'array da elaborare dovrebbe avere sempre
Av(1),Av(2),Av(3),Av(4),Av(5) come fissi scelti da una tabella x scegliere i fissi

+

Av(6),Av(7),Av(8),Av(9),Av(10),Av(11),Av(12),Av(13),Av(14),Av(15),Av(16),Av(17),Av(18),Av(19),Av(20),Av(21) scelti da una tabella x scegliere i numeri a girare...


Questo per poter abbattere anche a livello di sviluppo e di analisi (con 5 fissi) il muro della classe 20 insormontabile a livello di sviluppo integrale e per velocizzare altri tipi di analisi "sonda" anche per classi inferiori a 20.

Grazie a chi raccoglierà questo mio S.O.S :)
 
Ultima modifica:
Devi accoppiare una prima array Avf dei numerifissi in classe5 con una seconda Avv nella classe differenza rispetto alla classe ultima che vuoo ottenere.
Spero di aver interpretato bene il tio pensiero.
Ciao
 
claudio8 ha scritto:
Devi accoppiare una prima array Avf dei numerifissi in classe5 con una seconda Avv nella classe differenza rispetto alla classe ultima che vuoo ottenere.
Spero di aver interpretato bene il tio pensiero.
Ciao
Clicca per espandere...

Grazie per la dritta claudio :)

Io per adesso ho provato ad accoppiare i due array con array_push in questo modo sottostante... ma purtroppo non funzia... (non credo di aver fatto la classe differenza...) :unsure:



Codice: 
QuantitaNumeriScelti = ScegliNumeri(Av)


aFissi = Array(0,Av(1),Av(2),Av(3),Av(4),Av(5))

Valorestringa = StringaNumeri(aFissi,,True)

'prova sviluppo di tipo random

Dim Valoreinizioelaborazione,Valorefineelaborazione,Classe,nSorte
Valoreinizioelaborazione = 1
Valorefineelaborazione = 500000 'es: 500000 colonne

Classe = 21
Sorte = 2

Dim ar1,ar2,x
'ar1 = Array("0.")
ar2 = array_push(Av,Valorestringa)
Dim nuovastringa
'Call Scrivi("ar2 è ok? " & ar2(0) & ar2(1))
Dim vs,idx
vs = ""
For idx = 0 To UBound(ar2)
vs = vs & CStr(ar2(idx))
Next

Dim vettorediverifica

Call SplitByChar(vs,".",vettorediverifica)


For i = Valoreinizioelaborazione To Valorefineelaborazione

Call GetColonnaCasuale(Classe,aRetCol,ar2)

Da una ulteriore verifica con scrittura in output penso che il problema risieda solo... in questa riga:

Codice: 
Call GetColonnaCasuale(Classe,aRetCol,ar2)

Ovvero nel non riuscire a dirgli... "tieni fissi i 5 e testa in modo random tutti gli altri scelti dalla prima tabella" perchè per quanto riguarda l'array numerico di base sembra che me lo carichi correttamente...
 
Ultima modifica:
claudio8 ha scritto:
Devi accoppiare una prima array Avf dei numerifissi in classe5 con una seconda Avv nella classe differenza rispetto alla classe ultima che vuoo ottenere.
Spero di aver interpretato bene il tio pensiero.
Ciao
Clicca per espandere...

Dunque claudio credo di esserci quasi riuscito... :D

Solo che non mi si azzera di volta in volta l'array "ibrido" della formazione "ibrida" formata con i casuali della classe "differenza" voluta e i fissi decisi...

Per azzerare un array non bastava fare...

Codice: 
Redim  nomearray(0)

???

:unsure: ?


Codice: 
Dim Classedifferenza
Classedifferenza = 2 'Classe-UBound(aFissi)

For i = Valoreinizioelaborazione To Valorefineelaborazione

'prima di ogni elaborazione inizializzo array formazione ibrida
ReDim aRetCol(0)

Call GetColonnaCasuale(Classedifferenza,aRetColintermedio,aLunghette)  ' genera i restanti numeri rispetto i numeri fissi

Call Scrivi (" pezzo con elementi casuali " & StringaNumeri(aRetColintermedio))

'Dim nuovoarrayxgenerarelunghetteconifissivoluti

aRetCol = array_push(Av,StringaNumeri(aRetColintermedio))

Call Scrivi (" pezzo con elementi casuali e fissi " & StringaNumeri(aRetCol))  ' verifica formazione generata con i fissi voluti più gli altri elementi a girare...

Ecco un esempio disastroso... di output relativo al mancato azzeramento dell'array ad ogni passaggio... ??

pezzo con elementi casuali 8.71
pezzo con elementi casuali e fissi 17.22.50.51.84.8.71 <<< va bene solo qui! infatti ci sono 5 fissi e 2 casuali (7)

Da qui in già aretcol dovrebbe tornare con zero elementi per poter ricostruire la classe "ibrida" di 7 dell'esempio ecc... invece mi aggiunge sempre in più i due elementi della nuova classe "differenza" random ad ogni passaggio... ?

pezzo con elementi casuali 16.35
pezzo con elementi casuali e fissi 17.22.50.51.84.8.71.16.35
pezzo con elementi casuali 52.83
pezzo con elementi casuali e fissi 17.22.50.51.84.8.71.16.35.52.83
pezzo con elementi casuali 30.51
pezzo con elementi casuali e fissi 17.22.50.51.84.8.71.16.35.52.83.30.51
pezzo con elementi casuali 28.87
pezzo con elementi casuali e fissi 17.22.50.51.84.8.71.16.35.52.83.30.51.28.87
pezzo con elementi casuali 47.73
pezzo con elementi casuali e fissi 17.22.50.51.84.8.71.16.35.52.83.30.51.28.87.47.73
pezzo con elementi casuali 53.88
pezzo con elementi casuali e fissi 17.22.50.51.84.8.71.16.35.52.83.30.51.28.87.47.73.53.88
pezzo con elementi casuali 44.46
pezzo con elementi casuali e fissi 17.22.50.51.84.8.71.16.35.52.83.30.51.28.87.47.73.53.88.44.46
 
Ultima modifica:
Ho provato e riprovato come si vede qui sotto ad azzerare lo stramaledetto array "ibrido" relativo alla formazione che comprende 5 fissi e due dinamici dell'esempio... ma nulla... continua a formare formazioni progressivamente sempre + lunghe aggiungendo ogni volta al vecchio "filamento" i due nuovi elementi random...

I'm going crazy :sick: ???

Codice: 
QuantitaNumeriScelti = ScegliNumeri(Av)

Dim iv
Scrivi "verifica contenuto av "
For iv = 0 To UBound(Av)
'Scrivi Av(iv)
Next


aFissi = Array(0,Av(1),Av(2),Av(3),Av(4),Av(5))

Valorestringa = StringaNumeri(aFissi,,True)

'prova sviluppo di tipo random

Dim Valoreinizioelaborazione,Valorefineelaborazione,Classe,nSorte
Valoreinizioelaborazione = 1
Valorefineelaborazione = 500000 'es: 10 milioni di colonne



Dim ar1,ar2,x
'ar1 = Array("0.")
ar2 = array_push(aLunghette,StringaNumeri(aFissi))
Dim nuovastringa
'Call Scrivi("ar2 è ok? " & ar2(0) & ar2(1))
Dim vs,idx
vs = ""
For idx = 0 To UBound(ar2)
vs = vs & CStr(ar2(idx))

'Scrivi vs

Next

Dim vettorediverifica

Call SplitByChar(vs,".",vettorediverifica)

Dim ix
For ix = 0 To UBound(vettorediverifica)
'Scrivi vettorediverifica(ix)
Next

Dim aRetColintermedio

Dim Classedifferenza
Classedifferenza = 2 'Classe-UBound(aFissi)

For i = Valoreinizioelaborazione To Valorefineelaborazione

'prima di ogni elaborazione inizializzo array formazione ibrida
ReDim aRetCol(0)
ReDim aRetColintermedio(0)
Call Pulisci(aRetCol)
Call Pulisci(aRetColintermedio)
'Call Pulisci(aRetColOK)

Dim Stringacasuali,Stringaformazionefull


Call GetColonnaCasuale(Classedifferenza,aRetColintermedio,aLunghette) ' genera i restanti numeri rispetto i numeri fissi

Stringacasuali = StringaNumeri(aRetColintermedio)

'Call Scrivi(" pezzo con elementi casuali " & Stringacasuali)

'Dim nuovoarrayxgenerarelunghetteconifissivoluti

aRetCol = array_push(Av,Stringacasuali)

Stringaformazionefull = StringaNumeri(aRetCol)

Dim aRetColOK

Call SplitByChar(Stringaformazionefull,".",aRetColOK)

Call Scrivi ("Adesso aretcolOK è " & StringaNumeri(aRetColOK)) 

'Call Scrivi(" pezzo con elementi casuali e fissi " & Stringaformazionefull) ' verifica formazione generata con i fissi voluti più gli altri elementi a girare...

'azzero tutto...


Call Pulisci(aRetCol)
Call Pulisci(aRetColintermedio)



Call Messaggio("R: " & i & " N.F.(i): " & Av(0) & "-" & Av(1) & "-" & Av(2) & "-" & Av(3) & "-" & Av(4) & "-" & Av(5) & " C: " & nClasse & " L.R.T. " & Valorefineelaborazione & " V: " & collLunghette. count & " sorte " & Sorte)

i = i + 1
ReDim aRuoteTmp(1)
'For k = 1 To RuoteSelezionate


'Dim aRuoteTmp
Dim RetRit1,RetRitMax,RetIncrRitMax,RetFreq

aRuoteTmp(1) = 2
Call StatisticaFormazioneTurbo(aRetColOK,aRuoteTmp,Sorte,RetRit1,RetRitMax,RetIncrRitMax,RetFreq)

Call Scrivi (" formazione creata e analizzata ad ogni passaggio " & Stringaformazionefull ) 

'azzero stringhe

Stringacasuali=""
Stringaformazionefull="" 
Call Pulisci(aRetCol)
Call Pulisci(aRetColintermedio)
Call Pulisci(aRetColOK)

Call SplitByChar(Stringaformazionefull,".",aRetColOK)

Call Scrivi (" formazione risultante dopo azzeramento stringhe ad ogni passaggio " & Stringaformazionefull ) 

Call Scrivi ("Adesso dopo azzeramento stringhe aretcolOK è " & StringaNumeri(aRetColOK)) 

End Sub


Function Pulisci(A)
Dim i,u
u = UBound(A)
For i = 0 To u
A(i) = 0
Next
ReDim A(u)
End Function
 
Ciao Tom.

Se inserisci lo script completo (anche in posta) che vedo un tantino arzigogolato, posso capire il tutto, diversamente fermati alla specifica richiesta se con le indicazioni sottostanti non risolvi.

Provo a darti alcuni suggerimenti utili anche x chi vuole approfondire questo argomento.
( sappiate che non ho particolari lauree ma quando spesso mi trovo in difficoltà vado a cercarmi le soluzioni nell'help del programma dove trovo anche il link alla "Documentazione ufficiale di VBScript)

premessa
- le array(x) sono matrici ad unica dimensione ed a base 0 cioè possono contenere (x) valori più il valore in posizione 0 quindi un totale di x+1 valori,
con Dim la si dimensiona ad un valore fisso, con ReDim la si rende a dimensione variabile.

- se vuoi solo ridimensionare una array -> usa redim nomearray( ) cambiando il valore nella parentesi
- se vuoi ridimensionarla mantenendo i valori esistenti devi usare il redim Preverse nomearray.... ( nel caso la ampli, si incrementano le posizioni utilizzabili, in caso di diminuizione si riducono le posizioni mantenendo solo i valori sino alla posizione specificata, i restanti valori vengono perduti).

Riguardo alle modifiche dei contenuti della array:
- se vuoi svuotare una array ( che sia fissa o variabile) dei valori contenuti e riempirla dei nuovi valori, devi azzerare i suoi valori ciclando le posiz e dando ad esse il valore desiderato o =0
for x = 1 to ubound(nome array)
nomearray(x)=0
next
(la base 0 non ha alcun valore, se non è mai stata utilizzata nel costrutto precedente, personalmente la utilizzo x inserire i titoli della array o della matrice);
oppure,
con Erase su matrice numerica fissa vengono impostati = 0 tutti gli elementi interni, mentre su matrice dinamica
l'Istruzione Erase rende disponibile la memoria utilizzata dalle matrici, però prima che il programma faccia di nuovo riferimento alla matrice dinamica, bisogna dichiarare di nuovo le dimensioni della variabile matrice utilizzando l'istruzione ReDim.
Spero di essere stato esaustivo per la soluzione della tua impasse.
Saluti.

Ps: vi ricordo che nel costruire le funzioni di ordinamento matrici, Luigi escluse l'elemento "0" quindi vi consiglio di non usarlo per dati o valori eventualmente da ordinare.
 
claudio8 ha scritto:
Ciao Tom.

Se inserisci lo script completo (anche in posta) che vedo un tantino arzigogolato, posso capire il tutto, diversamente fermati alla specifica richiesta se con le indicazioni sottostanti non risolvi.

Provo a darti alcuni suggerimenti utili anche x chi vuole approfondire questo argomento.
( sappiate che non ho particolari lauree ma quando spesso mi trovo in difficoltà vado a cercarmi le soluzioni nell'help del programma dove trovo anche il link alla "Documentazione ufficiale di VBScript)

premessa
- le array(x) sono matrici ad unica dimensione ed a base 0 cioè possono contenere (x) valori più il valore in posizione 0 quindi un totale di x+1 valori,
con Dim la si dimensiona ad un valore fisso, con ReDim la si rende a dimensione variabile.

- se vuoi solo ridimensionare una array -> usa redim nomearray( ) cambiando il valore nella parentesi
- se vuoi ridimensionarla mantenendo i valori esistenti devi usare il redim Preverse nomearray.... ( nel caso la ampli, si incrementano le posizioni utilizzabili, in caso di diminuizione si riducono le posizioni mantenendo solo i valori sino alla posizione specificata, i restanti valori vengono perduti).

Riguardo alle modifiche dei contenuti della array:
- se vuoi svuotare una array ( che sia fissa o variabile) dei valori contenuti e riempirla dei nuovi valori, devi azzerare i suoi valori ciclando le posiz e dando ad esse il valore desiderato o =0
for x = 1 to ubound(nome array)
nomearray(x)=0
next
(la base 0 non ha alcun valore, se non è mai stata utilizzata nel costrutto precedente, personalmente la utilizzo x inserire i titoli della array o della matrice);
oppure,
con Erase su matrice numerica fissa vengono impostati = 0 tutti gli elementi interni, mentre su matrice dinamica
l'Istruzione Erase rende disponibile la memoria utilizzata dalle matrici, però prima che il programma faccia di nuovo riferimento alla matrice dinamica, bisogna dichiarare di nuovo le dimensioni della variabile matrice utilizzando l'istruzione ReDim.
Spero di essere stato esaustivo per la soluzione della tua impasse.
Saluti.

Ps: vi ricordo che nel costruire le funzioni di ordinamento matrici, Luigi escluse l'elemento "0" quindi vi consiglio di non usarlo per dati o valori eventualmente da ordinare.
Clicca per espandere...

Grazie claudio, questi modi credo di averli già provati (anche se sicuramente male...) tutti ma senza risultato sperato :(

Ti posto qui sotto l'intera SUB relativa al problema... (lo script intero è lunghissimo, working in progress e apporterebbe comunque solo ulteriore confusione)

Codice: 
Sub AnalisiLunghetteFromSceglinumeriConNumeriFissi(Inizio,Fine,aRuote,Sorte,idFiltro,qIncr,bPrimaEstrFissa,nDistanza)
Dim nTotLunghette
Dim k,sChrSep,nClasse,sNumReal

'----------------------------

   Dim aNumeri,aFissi ', nClasse,nSorte,RetRit1,RetRitMax,RetIncrRitMax,RetFreq
   'Dim k,i
   Dim RuoteSelezionate,QuantitaNumeriScelti
   Dim MS,aRetCol
   ReDim aFissi(7)
   Dim i
   Dim numfissoagirare,numfissoagirare2,numfissoagirare3,numfissoagirare4,numfissoagirare5,numfissoagirare6,numfissoagirare7,numfissoagirare8,numfissoagirare9,numfissoagirare10
   Dim numfissoagirare11,numfissoagirare12,numfissoagirare13,numfissoagirare14,numfissoagirare15,numfissoagirare16,numfissoagirare17,numfissoagirare18,numfissoagirare19,numfissoagirare20

   ReDim aLunghette(0)
   Dim clsL,collLunghette,FiltroEsaminato

   Dim Valorestringa

   ReDim aRetCol(0)
   ReDim aRetColintermedio(0)
   Dim Stringacasuali,Stringaformazionefull

   Stringacasuali=""
   Stringaformazionefull=""

Call Pulisci(aRetCol)
Call Pulisci(aRetColintermedio)

'Chiedi quanti numeri fissi si desidera avere nelle formazioni elaborate (max 7)
Dim quantinumfissi
quantinumfissi = CInt(InputBox("quanti numeri fissi a girare vuoi? [Max 20 num. fissi]: ",,5))

Set collLunghette = GetNewCollection
FiltroEsaminato = ScriviFiltro(idFiltro)
sChrSep = " "

Call ScegliNumeri(aLunghette)

nClasse = CInt(InputBox(" classe sviluppo ",,7))


Dim Modalitadisviluppo
Modalitadisviluppo = 1 'CInt(InputBox(" modalità di  sviluppo? Integrale (0) o Random (1) ",,1))


Dim aN,Av,aNum


' MODALITA'  SVILUPPO DI TIPO INTEGRALE...

If Modalitadisviluppo = 0 Then

Call Scrivi ("in questa versione la modalità integrale è disattivata")


'-------------------- FINE MODALITA' SVILUPPO DI TIPO INTEGRALE ----------------------

Else If Modalitadisviluppo = 1 Then

' MODALITA' SVILUPPO DI TIPO RANDOM.... ---------------------------------------------------

Select Case quantinumfissi


Case 5 'iniziamo la sperimentazione con lo sviluppo random di 5 FISSI

'ReDim aRetCol(0)
'ReDim aRetColintermedio(0)


Call Messaggio("hai scelto 5 num. fissi")

QuantitaNumeriScelti = ScegliNumeri(Av)

Dim iv
Scrivi "verifica contenuto av "
For iv = 0 To UBound(Av)
'Scrivi Av(iv)
Next


aFissi = Array(0,Av(1),Av(2),Av(3),Av(4),Av(5))',Av(6),Av(7),Av(8),Av(9),Av(10),Av(11),Av(12),Av(13))

Valorestringa = StringaNumeri(aFissi,,True)

'prova sviluppo di tipo random

Dim Valoreinizioelaborazione,Valorefineelaborazione,Classe,nSorte
Valoreinizioelaborazione = 1
Valorefineelaborazione = 500000 'es: 10 milioni di colonne
'Classe = 19
'nSorte = 2

Dim ar1,ar2,x
'ar1 = Array("0.")
ar2 = array_push(aLunghette,StringaNumeri(aFissi))
Dim nuovastringa
'Call Scrivi("ar2 è ok? " & ar2(0) & ar2(1))
Dim vs,idx
vs = ""
For idx = 0 To UBound(ar2)
vs = vs & CStr(ar2(idx))

'Scrivi vs

Next

Dim vettorediverifica

Call SplitByChar(vs,".",vettorediverifica)

Dim ix
For ix = 0 To UBound(vettorediverifica)
'Scrivi vettorediverifica(ix)
Next

'Dim aRetColintermedio

Dim Classedifferenza
Classedifferenza = 2 'Classe-UBound(aFissi)

For i = Valoreinizioelaborazione To Valorefineelaborazione

'prima di ogni elaborazione inizializzo array formazione ibrida

'ReDim aRetCol(0)
'ReDim aRetColintermedio(0)
Call Pulisci(aRetCol)
Call Pulisci(aRetColintermedio)
'Call Pulisci(aRetColOK)

'Dim Stringacasuali,Stringaformazionefull

Scrivi

Scrivi "------------- prima di getcolonnacasuale ------------------------"
Call Scrivi ("Adesso aretcolOK è " & StringaNumeri(aRetCol))
Call Scrivi ("Adesso aretcol è " & StringaNumeri(aRetCol))
Call Scrivi ("Adesso aretcolintermedio  è " & StringaNumeri(aRetColintermedio))
Call Scrivi ("Adesso stringacasuali è " & Stringacasuali)
Call Scrivi ("Adesso stringaformazionefull è " & Stringaformazionefull)

Scrivi "------------- ------------------------------------------- ------------------------"

Scrivi

Call GetColonnaCasuale(Classedifferenza,aRetColintermedio,aLunghette) ' genera i restanti numeri rispetto i numeri fissi

Stringacasuali = StringaNumeri(aRetColintermedio)

'Call Scrivi(" pezzo con elementi casuali " & Stringacasuali)

'Dim nuovoarrayxgenerarelunghetteconifissivoluti

aRetCol = array_push(Av,Stringacasuali)

Stringaformazionefull = StringaNumeri(aRetCol)

Dim aRetColOK

Call SplitByChar(Stringaformazionefull,".",aRetColOK)

Scrivi

Scrivi "------------- dopo creazione aRetColOK  ------------------------"
Call Scrivi ("Adesso aretcolOK è " & StringaNumeri(aRetColOK))
Call Scrivi ("Adesso aretcol è " & StringaNumeri(aRetCol))
Call Scrivi ("Adesso aretcolintermedio  è " & StringaNumeri(aRetColintermedio))
Call Scrivi ("Adesso stringacasuali " & Stringacasuali)
Call Scrivi ("Adesso stringaformazionefull è " & Stringaformazionefull)
Scrivi "------------- ------------------------------------------- ------------------------"

Scrivi


'Call Scrivi ("Adesso aretcolOK è " & StringaNumeri(aRetColOK))

'Call Scrivi(" pezzo con elementi casuali e fissi " & Stringaformazionefull) ' verifica formazione generata con i fissi voluti più gli altri elementi a girare...

'azzero stringhe...


'Call Pulisci(aRetCol)
'Call Pulisci(aRetColintermedio)


'aRetCol = Array(nuovoarrayxgenerarelunghetteconifissivoluti)

'Do While GetCombSviluppo(aRetCol)

Call Messaggio("R: " & i & " N.F.(i): " & Av(0) & "-" & Av(1) & "-" & Av(2) & "-" & Av(3) & "-" & Av(4) & "-" & Av(5) & " C: " & nClasse & " L.R.T. " & Valorefineelaborazione & " V: " & collLunghette. count & " sorte " & Sorte)

i = i + 1
ReDim aRuoteTmp(1)
'For k = 1 To RuoteSelezionate


'Dim aRuoteTmp
Dim RetRit1,RetRitMax,RetIncrRitMax,RetFreq

aRuoteTmp(1) = 2
Call StatisticaFormazioneTurbo(aRetColOK,aRuoteTmp,Sorte,RetRit1,RetRitMax,RetIncrRitMax,RetFreq)

Call Scrivi (" formazione creata e analizzata ad ogni passaggio " & StringaNumeri(aRetColOK) )

'azzero stringhe

Stringacasuali=""
Stringaformazionefull=""
Call Pulisci(aRetCol)
Call Pulisci(aRetColintermedio)
Call Pulisci(aRetColOK)

Call SplitByChar(Stringaformazionefull,".",aRetColOK)

Call Scrivi (" formazione risultante dopo azzeramento stringhe ad ogni passaggio " & Stringaformazionefull )
Call Scrivi ("Adesso dopo azzeramento stringhe aretcolOK è " & StringaNumeri(aRetColOK))
Call Scrivi ("Adesso dopo azzeramento stringacasuali è " & Stringacasuali)

Dim Diff
Diff = RetRitMax - RetRit1
Dim rapportoRARS
'rapportoRARS = RetRit1/RetRitMax

'Next ' x ruote...


'If ScriptInterrotto Then Exit Do
k = k + 1
Set clsL = New clsLunghetta
Call clsL.Init(aRetCol,sChrSep,Inizio,Fine,aRuote,Sorte)
If clsL.IsCondizioneRispettata(idFiltro,qIncr) Then
Call clsL.EseguiStatistica
collLunghette.Add clsL
End If
If k Mod 50 = 0 Then
Call Messaggio("Riga: " & k & " valide " & collLunghette. count & " num fisso: " & numfissoagirare)
If collLunghette.count > 0 Then
Call Messaggio("Trovata!")
End If
'DoEventsEx
'Call AvanzamentoElab(1,aRetCol,k)
'If ScriptInterrotto Then Exit Do
End If
'Loop
'Set MS = Nothing

Call AvanzamentoElab(1,Valorefineelaborazione,i)

If ScriptInterrotto Then Exit For

'dopo aver analizzato ogni formazione "ibrida" formata da fissi e casuali la debbo azzerrare...

'ReDim aRetCol(0)

ReDim aRetCol(0)
ReDim aRetColintermedio(0)
Call Pulisci(aRetCol)
Call Pulisci(aRetColintermedio)
Stringacasuali=""
Stringaformazionefull=""

Next ' x valore eleborazione...


Call Scrivi
Call Scrivi("Tempo trascorso " & TempoTrascorso)

End Select

'--------------------- FINE MODALITA' SVILUPPO DI TIPO RANDOM -------------------------

End If
End If

'----------------------------blocco report finale uguale per tutti i casi----------------------------

Call Scrivi
Call Scrivi("Elaborazione effettuata con archivio lotto aggiornato all'estrazione del: " & giorno(EstrazioneFin) & "-" & Mese(EstrazioneFin) & "-" & Anno(EstrazioneFin))
Call Scrivi


Scrivi "Range analisi         : " & GetInfoEstrazione(Inizio) & " - " & GetInfoEstrazione(Fine)
Scrivi "Filtro Esaminato      : " & FiltroEsaminato
Scrivi "Classe di sviluppo    : " & nClasse
Scrivi "Numero(i) fisso(i) scelto(i) : " & Valorestringa
Scrivi "Lunghette Totali In Esame : " & nTotLunghette
Scrivi "Lunghette esaminate   : " & i & " Valide : " & collLunghette.count
Scrivi "Sorte                 : " & NomeSorte(Sorte)
Scrivi "Ruote                 : " & StringaRuote(aRuote)
Scrivi "Numero Minimo IncrRit : " & Format2(qIncr)
Scrivi
Scrivi FormatSpace("Lunghette ordinate per incremento ritardo max",75),True,True,RGB(25,89,76),vbWhite

Call Scrivi
If collLunghette.count > 0 Then
Call OrdinaItemCollection(collLunghette,"IncrRitMax",,,- 1)
For Each clsL In collLunghette
If nDistanza = 0 Then
Call Scrivi("Numeri Formazione     : " & clsL.LunghettaString)
Else
sNumReal = clsL.TrasformaArrayNumVirToNumReal(nDistanza,bPrimaEstrFissa)
Call Scrivi("Numeri Formazione     : " & clsL.LunghettaString & "   " & "Numeri Verifica   : " & sNumReal)
End If
Call Scrivi("Ritardo               : " & clsL.Ritardo)
Call Scrivi("RitMax                : " & clsL.RitardoMax)
Call Scrivi("Freq                  : " & clsL.Frequenza)
Call Scrivi("IncrRitMx             : " & clsL.IncrRitMax)
Call Scrivi("IncrRitMaxSto         : " & clsL.IncrRitMaxSto)
Call Scrivi("strIncrementi         : " & clsL.strIncRitMaxSto)
Call Scrivi("Numero Incrementi     : " & clsL.iNumIncrementi)
Call clsL.DisegnaGraficoIncrRitMax
Next
Else
Scrivi "Nessuna lunghetta rispetta le condizioni"
Scrivi "Lunghette esaminate " & nTotLunghette
End If

Scrivi
Scrivi("Tempo trascorso: " & TempoTrascorso)
End Sub

Guarda se riesci tu ad azzerare lo stramaledettissimo array dinamico "ibrido".
Sicuramente, come al mio solito sto annegando in una bacinella d'acqua..., ma per adesso non riesco proprio a uscirne... ?????


Questo sottostante è un pezzo dell'ultimo OUTPUT descrittivo del problema...
In carattere barrato ti ho riportato gli elementi che non dovrebbero esserci...

Archivio : Archivio lotto
verifica contenuto av

------------- prima di getcolonnacasuale ------------------------
Adesso aretcolOK è
Adesso aretcol è
Adesso aretcolintermedio è
Adesso stringacasuali è
Adesso stringaformazionefull è
------------- ------------------------------------------- ------------------------


------------- dopo creazione aRetColOK ------------------------
Adesso aretcolOK è 17.22.50.51.84.30.87
Adesso aretcol è 17.22.50.51.84.30.87
Adesso aretcolintermedio è 30.87
Adesso stringacasuali 30.87
Adesso stringaformazionefull è 17.22.50.51.84.30.87 fin qui... OK
------------- ------------------------------------------- ------------------------

formazione creata e analizzata ad ogni passaggio 17.22.50.51.84.30.87
formazione risultante dopo azzeramento stringhe ad ogni passaggio
Adesso dopo azzeramento stringhe aretcolOK è
Adesso dopo azzeramento stringacasuali è

------------- prima di getcolonnacasuale ------------------------
Adesso aretcolOK è
Adesso aretcol è
Adesso aretcolintermedio è
Adesso stringacasuali è
Adesso stringaformazionefull è
------------- ------------------------------------------- ------------------------


------------- dopo creazione aRetColOK ------------------------
Adesso aretcolOK è 17.22.50.51.84.30.87.46.48
Adesso aretcol è 17.22.50.51.84.30.87.46.48
Adesso aretcolintermedio è 46.48
Adesso stringacasuali 46.48
Adesso stringaformazionefull è 17.22.50.51.84.30.87.46.48
------------- ------------------------------------------- ------------------------

formazione creata e analizzata ad ogni passaggio 17.22.50.51.84.30.87.46.48
formazione risultante dopo azzeramento stringhe ad ogni passaggio
Adesso dopo azzeramento stringhe aretcolOK è
Adesso dopo azzeramento stringacasuali è

------------- prima di getcolonnacasuale ------------------------
Adesso aretcolOK è
Adesso aretcol è
Adesso aretcolintermedio è
Adesso stringacasuali è
Adesso stringaformazionefull è
------------- ------------------------------------------- ------------------------


------------- dopo creazione aRetColOK ------------------------
Adesso aretcolOK è 17.22.50.51.84.30.87.46.48.18.58
Adesso aretcol è 17.22.50.51.84.30.87.46.48.18.58
Adesso aretcolintermedio è 18.58
Adesso stringacasuali 18.58
Adesso stringaformazionefull è 17.22.50.51.84.30.87.46.48.18.58
------------- ------------------------------------------- ------------------------

formazione creata e analizzata ad ogni passaggio 17.22.50.51.84.30.87.46.48.18.58
formazione risultante dopo azzeramento stringhe ad ogni passaggio
Adesso dopo azzeramento stringhe aretcolOK è
Adesso dopo azzeramento stringacasuali è

------------- prima di getcolonnacasuale ------------------------
Adesso aretcolOK è
Adesso aretcol è
Adesso aretcolintermedio è
Adesso stringacasuali è
Adesso stringaformazionefull è
------------- ------------------------------------------- ------------------------


------------- dopo creazione aRetColOK ------------------------
Adesso aretcolOK è 17.22.50.51.84.30.87.46.48.18.58.6.55
Adesso aretcol è 17.22.50.51.84.30.87.46.48.18.58.6.55
Adesso aretcolintermedio è 6.55
Adesso stringacasuali 6.55
Adesso stringaformazionefull è 17.22.50.51.84.30.87.46.48.18.58.6.55
------------- ------------------------------------------- ------------------------

Nell'esempio soprastante in sostanza la classe anzichè restare di 7 elementi con i 5 fissi e i due random a girare... arriva ad essere di 13 elementi e continua a crescere ad ogni pasaggio di due elementi (quelli della classe differenza random) alla volta....
 
Ultima modifica:
Allora:
la variabile " aretcolOK" che era 17.22.50.51.84.30.87 dopo le ulteriori elaborazioni diventa 17.22.50.51.84.30.87.46.48.18.58.6.55 quindi presumo che si ridimensiona automaticamente aggiungendo gli altri numeri casuali.
La questione sta nel modo in cui dimensioni la prima variabile di accorpamento dei fissi con i casuali che dici chiamarsi " aretcolOK" si ridimensioni seguendo una variabile e non un numero specifico.

quindi scrivimi come dimensioni questa variabile.

usando il ReDim aretcolOK(variabile qualsiasi) la sua dimensione si adatta al nuovo valore di" qualsiasi" e quindi ti accetta insieme ai vecchi anche i nuovi aggiunti.

spero di aver intuito il probelma che comunque non è visibile definire senza conoscere il modo in cui dimensioni le variabili.
Prova ad usare una dimensione fissa della variabile del 1° accorpamento, quindi la svuoti de valori oltre ai primi 5fissi con Redim reverse aretcolOK(5) e dopo aver fatto la "casualita" degli altri valori, riporti con Redim reverse aretcolOK( 7) e la tua array con terra i 5 fissi + i 2 nuovi ricavati casualmente
ciao

Correzione:
E' stato erroneamente scritto "Redim reverse" ma va scritto "ReDim Preserve".
 
Ultima modifica:
" quindi scrivimi come dimensioni questa variabile. "

La dimensionavo con redim aretcolOK(0) in effetti...

Ma dopo quanto mi hai spiegato tu claudio ho provato a ridimensionare i vari array con dimensione fissa ma l'output è sempre lo stesso...

Probabilmente perchè non ho capito nè applicato questo tuo consiglio ulteriore

" Prova ad usare una dimensione fissa della variabile del 1° accorpamento, quindi la svuoti de valori oltre ai primi 5fissi con Redim reverse aretcolOK(5) e dopo aver fatto la "casualita" degli altri valori, riporti con Redim reverse aretcolOK( 7) "

Infatti...

Ho provato a scrivere redim reverse sia attaccato che staccato ma non mi si evidenzia come comando... di svuotamento array a dimensione fissa...

Codice: 
Sub AnalisiLunghetteFromSceglinumeriConNumeriFissi(Inizio,Fine,aRuote,Sorte,idFiltro,qIncr,bPrimaEstrFissa,nDistanza)
Dim nTotLunghette
Dim k,sChrSep,nClasse,sNumReal

'----------------------------

   Dim aNumeri,aFissi ', nClasse,nSorte,RetRit1,RetRitMax,RetIncrRitMax,RetFreq
   'Dim k,i
   Dim RuoteSelezionate,QuantitaNumeriScelti
   Dim MS,aRetCol
   ReDim aFissi(7)
   Dim i
   Dim numfissoagirare,numfissoagirare2,numfissoagirare3,numfissoagirare4,numfissoagirare5,numfissoagirare6,numfissoagirare7,numfissoagirare8,numfissoagirare9,numfissoagirare10
   Dim numfissoagirare11,numfissoagirare12,numfissoagirare13,numfissoagirare14,numfissoagirare15,numfissoagirare16,numfissoagirare17,numfissoagirare18,numfissoagirare19,numfissoagirare20

   ReDim aLunghette(0)
   Dim clsL,collLunghette,FiltroEsaminato

   Dim Valorestringa

   ReDim aRetCol(7)
   ReDim aRetColintermedio(2)
   ReDim aRetColOk(7)
   Dim Stringacasuali,Stringaformazionefull

   Stringacasuali=""
   Stringaformazionefull=""

Call Pulisci(aRetCol)
Call Pulisci(aRetColintermedio)

'Chiedi quanti numeri fissi si desidera avere nelle formazioni elaborate (max 7)
Dim quantinumfissi
quantinumfissi = CInt(InputBox("quanti numeri fissi a girare vuoi? [Max 20 num. fissi]: ",,5))

Set collLunghette = GetNewCollection
FiltroEsaminato = ScriviFiltro(idFiltro)
sChrSep = " "

Call ScegliNumeri(aLunghette)

nClasse = CInt(InputBox(" classe sviluppo ",,7))


Dim Modalitadisviluppo
Modalitadisviluppo = 1 'CInt(InputBox(" modalità di  sviluppo? Integrale (0) o Random (1) ",,1))


Dim aN,Av,aNum


' MODALITA'  SVILUPPO DI TIPO INTEGRALE...

If Modalitadisviluppo = 0 Then

Call Scrivi ("in questa versione la modalità integrale è disattivata")


'-------------------- FINE MODALITA' SVILUPPO DI TIPO INTEGRALE ----------------------

Else If Modalitadisviluppo = 1 Then

' MODALITA' SVILUPPO DI TIPO RANDOM.... ---------------------------------------------------

Select Case quantinumfissi


Case 5 'iniziamo la sperimentazione con lo sviluppo random di 5 FISSI

'ReDim aRetCol(0)
'ReDim aRetColintermedio(0)


Call Messaggio("hai scelto 5 num. fissi")

QuantitaNumeriScelti = ScegliNumeri(Av)

Dim iv
Scrivi "verifica contenuto av "
For iv = 0 To UBound(Av)
'Scrivi Av(iv)
Next


aFissi = Array(0,Av(1),Av(2),Av(3),Av(4),Av(5))',Av(6),Av(7),Av(8),Av(9),Av(10),Av(11),Av(12),Av(13))

Valorestringa = StringaNumeri(aFissi,,True)

'prova sviluppo di tipo random

Dim Valoreinizioelaborazione,Valorefineelaborazione,Classe,nSorte
Valoreinizioelaborazione = 1
Valorefineelaborazione = 500000 'es: 10 milioni di colonne
'Classe = 19
'nSorte = 2

Dim ar1,ar2,x
'ar1 = Array("0.")
ar2 = array_push(aLunghette,StringaNumeri(aFissi))
Dim nuovastringa
'Call Scrivi("ar2 è ok? " & ar2(0) & ar2(1))
Dim vs,idx
vs = ""
For idx = 0 To UBound(ar2)
vs = vs & CStr(ar2(idx))

'Scrivi vs

Next

Dim vettorediverifica

Call SplitByChar(vs,".",vettorediverifica)

Dim ix
For ix = 0 To UBound(vettorediverifica)
'Scrivi vettorediverifica(ix)
Next

'Dim aRetColintermedio

Dim Classedifferenza
Classedifferenza = 2 'Classe-UBound(aFissi)

For i = Valoreinizioelaborazione To Valorefineelaborazione

'prima di ogni elaborazione inizializzo array formazione ibrida

'ReDim aRetCol(0)
'ReDim aRetColintermedio(0)
Call Pulisci(aRetCol)
Call Pulisci(aRetColintermedio)
'Call Pulisci(aRetColOK)

'Dim Stringacasuali,Stringaformazionefull

Scrivi

Scrivi "------------- prima di getcolonnacasuale ------------------------"
Call Scrivi ("Adesso aretcolOK è " & StringaNumeri(aRetCol))
Call Scrivi ("Adesso aretcol è " & StringaNumeri(aRetCol))
Call Scrivi ("Adesso aretcolintermedio  è " & StringaNumeri(aRetColintermedio))
Call Scrivi ("Adesso stringacasuali è " & Stringacasuali)
Call Scrivi ("Adesso stringaformazionefull è " & Stringaformazionefull)

Scrivi "------------- ------------------------------------------- ------------------------"

Scrivi

Call GetColonnaCasuale(Classedifferenza,aRetColintermedio,aLunghette) ' genera i restanti numeri rispetto i numeri fissi

Stringacasuali = StringaNumeri(aRetColintermedio)

'Call Scrivi(" pezzo con elementi casuali " & Stringacasuali)

'Dim nuovoarrayxgenerarelunghetteconifissivoluti

aRetCol = array_push(Av,Stringacasuali)

Stringaformazionefull = StringaNumeri(aRetCol)

'Dim aRetColOk

Call SplitByChar(Stringaformazionefull,".",aRetColOk)

Scrivi

Scrivi "------------- dopo creazione aRetColOK  ------------------------"
Call Scrivi ("Adesso aretcolOK è " & StringaNumeri(aRetColOk))
Call Scrivi ("Adesso aretcol è " & StringaNumeri(aRetCol))
Call Scrivi ("Adesso aretcolintermedio  è " & StringaNumeri(aRetColintermedio))
Call Scrivi ("Adesso stringacasuali " & Stringacasuali)
Call Scrivi ("Adesso stringaformazionefull è " & Stringaformazionefull)
Scrivi "------------- ------------------------------------------- ------------------------"

Scrivi


'Call Scrivi ("Adesso aretcolOK è " & StringaNumeri(aRetColOK))

'Call Scrivi(" pezzo con elementi casuali e fissi " & Stringaformazionefull) ' verifica formazione generata con i fissi voluti più gli altri elementi a girare...

'azzero stringhe...


'Call Pulisci(aRetCol)
'Call Pulisci(aRetColintermedio)


'aRetCol = Array(nuovoarrayxgenerarelunghetteconifissivoluti)

'Do While GetCombSviluppo(aRetCol)

Call Messaggio("R: " & i & " N.F.(i): " & Av(0) & "-" & Av(1) & "-" & Av(2) & "-" & Av(3) & "-" & Av(4) & "-" & Av(5) & " C: " & nClasse & " L.R.T. " & Valorefineelaborazione & " V: " & collLunghette. count & " sorte " & Sorte)

i = i + 1
ReDim aRuoteTmp(1)
'For k = 1 To RuoteSelezionate


'Dim aRuoteTmp
Dim RetRit1,RetRitMax,RetIncrRitMax,RetFreq

aRuoteTmp(1) = 2
Call StatisticaFormazioneTurbo(aRetColOk,aRuoteTmp,Sorte,RetRit1,RetRitMax,RetIncrRitMax,RetFreq)

Call Scrivi (" formazione creata e analizzata ad ogni passaggio " & StringaNumeri(aRetColOk) )

'azzero stringhe

Stringacasuali=""
Stringaformazionefull=""
Call Pulisci(aRetCol)
Call Pulisci(aRetColintermedio)
Call Pulisci(aRetColOk)

Call SplitByChar(Stringaformazionefull,".",aRetColOk)

'ReDim reverse aRetCol(7)

Call Scrivi (" formazione risultante dopo azzeramento stringhe ad ogni passaggio " & Stringaformazionefull )
Call Scrivi ("Adesso dopo azzeramento stringhe aretcolOK è " & StringaNumeri(aRetColOk))
Call Scrivi ("Adesso dopo azzeramento stringacasuali è " & Stringacasuali)

Dim Diff
Diff = RetRitMax - RetRit1
Dim rapportoRARS
'rapportoRARS = RetRit1/RetRitMax

'Next ' x ruote...


'If ScriptInterrotto Then Exit Do
k = k + 1
Set clsL = New clsLunghetta
Call clsL.Init(aRetCol,sChrSep,Inizio,Fine,aRuote,Sorte)
If clsL.IsCondizioneRispettata(idFiltro,qIncr) Then
Call clsL.EseguiStatistica
collLunghette.Add clsL
End If
If k Mod 50 = 0 Then
Call Messaggio("Riga: " & k & " valide " & collLunghette. count & " num fisso: " & numfissoagirare)
If collLunghette.count > 0 Then
Call Messaggio("Trovata!")
End If
'DoEventsEx
'Call AvanzamentoElab(1,aRetCol,k)
'If ScriptInterrotto Then Exit Do
End If
'Loop
'Set MS = Nothing

Call AvanzamentoElab(1,Valorefineelaborazione,i)

If ScriptInterrotto Then Exit For

'dopo aver analizzato ogni formazione "ibrida" formata da fissi e casuali la debbo azzerrare...

'ReDim aRetCol(0)

ReDim aRetCol(7)
ReDim aRetColintermedio(2)
Call Pulisci(aRetCol)
Call Pulisci(aRetColintermedio)
ReDim aRetColOk(7)
Call Pulisci(aRetColOk)
Stringacasuali=""
Stringaformazionefull=""

Next ' x valore eleborazione...


Call Scrivi
Call Scrivi("Tempo trascorso " & TempoTrascorso)

End Select

'--------------------- FINE MODALITA' SVILUPPO DI TIPO RANDOM -------------------------

End If
End If

'----------------------------blocco report finale uguale per tutti i casi----------------------------

Call Scrivi
Call Scrivi("Elaborazione effettuata con archivio lotto aggiornato all'estrazione del: " & giorno(EstrazioneFin) & "-" & Mese(EstrazioneFin) & "-" & Anno(EstrazioneFin))
Call Scrivi


Scrivi "Range analisi         : " & GetInfoEstrazione(Inizio) & " - " & GetInfoEstrazione(Fine)
Scrivi "Filtro Esaminato      : " & FiltroEsaminato
Scrivi "Classe di sviluppo    : " & nClasse
Scrivi "Numero(i) fisso(i) scelto(i) : " & Valorestringa
Scrivi "Lunghette Totali In Esame : " & nTotLunghette
Scrivi "Lunghette esaminate   : " & i & " Valide : " & collLunghette.count
Scrivi "Sorte                 : " & NomeSorte(Sorte)
Scrivi "Ruote                 : " & StringaRuote(aRuote)
Scrivi "Numero Minimo IncrRit : " & Format2(qIncr)
Scrivi
Scrivi FormatSpace("Lunghette ordinate per incremento ritardo max",75),True,True,RGB(25,89,76),vbWhite

Call Scrivi
If collLunghette.count > 0 Then
Call OrdinaItemCollection(collLunghette,"IncrRitMax",,,- 1)
For Each clsL In collLunghette
If nDistanza = 0 Then
Call Scrivi("Numeri Formazione     : " & clsL.LunghettaString)
Else
sNumReal = clsL.TrasformaArrayNumVirToNumReal(nDistanza,bPrimaEstrFissa)
Call Scrivi("Numeri Formazione     : " & clsL.LunghettaString & "   " & "Numeri Verifica   : " & sNumReal)
End If
Call Scrivi("Ritardo               : " & clsL.Ritardo)
Call Scrivi("RitMax                : " & clsL.RitardoMax)
Call Scrivi("Freq                  : " & clsL.Frequenza)
Call Scrivi("IncrRitMx             : " & clsL.IncrRitMax)
Call Scrivi("IncrRitMaxSto         : " & clsL.IncrRitMaxSto)
Call Scrivi("strIncrementi         : " & clsL.strIncRitMaxSto)
Call Scrivi("Numero Incrementi     : " & clsL.iNumIncrementi)
Call clsL.DisegnaGraficoIncrRitMax
Next
Else
Scrivi "Nessuna lunghetta rispetta le condizioni"
Scrivi "Lunghette esaminate " & nTotLunghette
End If

Scrivi
Scrivi("Tempo trascorso: " & TempoTrascorso)
End Sub

Ciao
 
claudio8 ha scritto:
Preverse non reverse scusa.
Guarda bene nella guida Vbscript che trovi nella finestra a tendina dell'help.
Clicca per espandere...

Ciao Claudio,
sarà il caldo... ma
neanche con:

Preverse,
Redim Preverse
RedimPreverse
Dim Pre Verse
Dim Preverse
call preverse
call pre verse
ecc...

Non mi appare nulla evidenziato come comando nè tanto meno la finestra a tendina dell'help... o_O:unsure: Io ho la versione 1.6.34 di spazio.
 
Dunque caro claudio, dai e dai forse ce l'ho fatta! ???

Come riporta questo ultimo output di test

In pratica anagrammando... più e più volte il tuo... " Preverse" è venuto fuori qualcosa di teoricamente logico e sopratutto evidenziabile da codice:

ovvero...

PRESERVE

e con questo code:

Codice: 
ReDim Preserve aFissi(5)

aFissi = Array (0,Av(1),Av(2),Av(3),Av(4),Av(5))


e questo altro my code ?

Codice: 
Call Scrivi ("fissi c5: " & StringaNumeri(aFissi))
Call Scrivi ("random c2: " & Stringacasuali)
Call Scrivi ("fissi + random c7: " & StringaNumeri(aRetCol))

'Adesso devo  rimuovere da Av la Stringacasuali e lasciare solo i 5 fissi... in modo che si possa aggiungere al
' successivo passaggio un'altra coppia di casuali...

Scrivi
Call Scrivi ("adesso Av è " & StringaNumeri(Av))
Scrivi

'cancello av e lo ripopolo con afissi

ReDim Av(5)

Dim c

ReDim Av(5)
For  c = 1 To UBound(Av)
Av(c) = 0
Next

Av = array_push(Av, StringaNumeri(aFissi))

Rimuginato alle 00:54 di notte... forse, come da output sottostante, ci sono riuscito! ??


Archivio : Archivio lotto
fissi c5: 1.2.3.4.5
random c2: 34.84
fissi + random c7: 1.2.3.4.5.34.84

adesso Av è 1.2.3.4.5.34.84

fissi c5: 1.2.3.4.5
random c2: 29.75
fissi + random c7: 1.2.3.4.5.29.75

adesso Av è 1.2.3.4.5.29.75

fissi c5: 1.2.3.4.5
random c2: 32.69
fissi + random c7: 1.2.3.4.5.32.69

adesso Av è 1.2.3.4.5.32.69

fissi c5: 1.2.3.4.5
random c2: 41.64
fissi + random c7: 1.2.3.4.5.41.64

adesso Av è 1.2.3.4.5.41.64

Adesso infatti la classe finale sembra mantenere 7 elementi e presenta sempre 5 fissi e 2 random...

Forse lo chiamerò... ? random development engine with fixed sets without class limits ovvero motore di sviluppo random con fissi voluti senza limiti di classe ?????

Grazie di nuovo per le dritte claudio ??
 
Ultima modifica:
Ti ho abbozzato uno script x l'uso del "ReDim Preserve "
Codice: 
Sub Main
    ' Scegliere solo 5 fissi ed a piacere i numeri per la casualità (evitando di riscegliere i fissi)'
    '
    '
    Dim aV,i,x,casuali,aVcasuali,aretcol,array_push,Stringa,Classe
    Dim NewArray,myArray
    Call ScegliNumeri(aV)
    Call ScegliNumeri(aVcasuali)
    Scrivi "Numeri fissi scelti (5) "
    For i = 1 To UBound(aV)
        Scrivi aV(i) & " ",,False
    Next
    Scrivi
    Scrivi
    Scrivi "Numeri scelti per la casualità (quantità a piacere) "
    For i = 1 To UBound(aVcasuali)
        Scrivi aVcasuali(i) & " ",,False
    Next
    Scrivi
    Scrivi
    Classe = 2
    ReDim casuali(2)
    Call GetColonnaCasuale(Classe,casuali,aVcasuali)
    Call Scrivi(" Primi numeri casuali " & StringaNumeri(casuali,,True),False)
    If ScriptInterrotto Then Exit Sub
    ReDim aretcolOK(7) ' dimensione fissa della variabile del 1° accorpamento, 5 per i fissi + 2 per variabili dal costrutto di "casualità"
    aretcolOK(1) = aV(1)
    aretcolOK(2) = aV(2)
    aretcolOK(3) = aV(3)
    aretcolOK(4) = aV(4)
    aretcolOK(5) = aV(5)
    aretcolOK(6) = casuali(1)
    aretcolOK(7) = casuali(2)
    Scrivi " Elenco dei 7 numeri ",False
    For x = 1 To UBound(aretcolOK)
        Scrivi aretcolOK(x) & " ",,False
    Next
    Scrivi
    Scrivi
    ReDim Preserve aretcolOK(5) ' la matrice/monodimensionale si riduce al valore di 5 posizioni,le ultime 2 posizioni vengono eliminate.
    Scrivi " Elenco dei soli primi 5 numeri (i fissi) dopo il ReDim Preserve aretcolOK(5) ",False
    For x = 1 To UBound(aretcolOK)
        Scrivi aretcolOK(x) & " ",,False
    Next
    Scrivi
    Scrivi
    ReDim Preserve aretcolOK(7) ' ridimensiono la array dinuovo a 7 preservando i 5 vecchi valori
    Call GetColonnaCasuale(Classe,casuali,aVcasuali)' rielaboro altri2 2
    Call Scrivi(" Nuovi numeri casuali " & StringaNumeri(casuali,,True))
    aretcolOK(6) = casuali(1)
    aretcolOK(7) = casuali(2)
    Scrivi " Elenco dei vecchi 5 fissi + 2 nuovi = 7 numeri ",False
    For x = 1 To UBound(aretcolOK)
        Scrivi aretcolOK(x) & " ",,False
    Next
    Scrivi
    Scrivi
     Scrivi "script by Claudio8", False
End Sub

Ciao
 
Al comando Help, oltre alle funzioni di Spazioscript, trovi anche Documentazione ufficiale VbScript
E' la guida di vbscript e ci trovi tutte le indicazioni delle "paroline magiche" in ambiente vbscript.

HELP TOM.JPG
Buona lettura.
ciao
 
Devi accedere o registrarti per poter rispondere.

Ultima estrazione Lotto

  • Estrazione del lotto
    martedì 14 gennaio 2025
    Bari
    41
    25
    12
    73
    55
    Cagliari
    54
    20
    48
    32
    67
    Firenze
    75
    23
    68
    10
    38
    Genova
    33
    27
    81
    70
    64
    Milano
    68
    01
    64
    86
    87
    Napoli
    47
    75
    45
    10
    21
    Palermo
    55
    86
    33
    53
    70
    Roma
    88
    78
    61
    06
    07
    Torino
    76
    08
    23
    61
    82
    Venezia
    25
    15
    49
    21
    81
    Nazionale
    70
    10
    32
    78
    07
    Estrazione Simbolotto
    Bari
    07
    14
    28
    45
    31
    Archivio estrazioni lotto Ritardi top 15 Frequenze top 15

Ultimi Messaggi

Indietro
Alto