Novità

RicercaLunghetteNET

Visto l'interessamento al riguardo (ho ricevuto 43 email e non scherzo) procedo con la spiegazione. Dobbiamo iniziare con una semplice domanda.

Che cosa da vita al ritardo di una lunghetta?

Badate bene, ho parlato di lunghetta e non di estratto,ambo, terno ecc...

Sappiamo perfettamente che il ritardo di un estratto, per esempio, è dato dalla non uscita del numero per tot estrazioni. Ma se i numeri fossero due? Cosa decreta il ritardo per estratto di due numeri?

Questa è la domanda che mi sono posto. Iniziamo ad escludere l'ipotesi sbagliata attraverso un esempio pratico.

Prendiamo in esempio la lunghetta formata da 5 numeri : 6.17.25.68.84 con ritardo 44 per estratto (la lunghetta è stata scelta casualmente)
La prima è unica domanda che mi sono posto è stata...il ritardo 44 è dato dalla media matematica dei ritardi? ASSOLUTAMENTE NO! (potete fare tutte le prove al riguardo)


Ma allora questo benedetto ritardo da cosa è dato? Analizziamo la lunghetta in estratti.

il numero 6 ha ritardo 52
il numero 17 ha ritardo 50
il numero 25 ha ritardo 107
il numero 68 ha ritardo 44
il numero 84 ha ritardo 45

la media matematica = (52+50+107+44+45)/5 = 298/5 = 59,6 (non è questo il ritardo)

Però aspetta un secondo... il 68 ha ritardo 44 che è proprio il ritardo della lunghetta. Che coincidenza. Va beh proviamo con un'altra lunghetta.

Formazione : 17.23.25.35.78 Ritardo : 50

il numero 17 ha ritardo 50
il numero 23 ha ritardo 70
il numero 25 ha ritardo 107
il numero 35 ha ritardo 63
il numero 78 ha ritardo 200


Mmm.. la lunghetta ha ritardo 50. Il numero 17 ha ritardo 50 che guarda caso è come nel primo caso il ritardo più basso tra quelli presenti.

Risposta trovata.

Il ritardo di una lunghetta è dato dal valore del ritardo minore dei numeri presenti in lunghetta per sorte ricercata. Quindi per estratto sarà l'estratto con il ritardo minore, per ambo sarà l'ambo con il ritardo minore.. e cosi via.

Ma allora qui rilevare le lunghette più ritardatarie diventa "molto semplice".
 
Considerando che il software è stato scritto in vb.net e comprendendo che molti di voi non hanno dimestichezza (se non assoluta ignoranza) del linguaggio, procederò con uno script in spaziometria in modo tale da parlare "la stessa lingua".
 
Entriamo nel vivo della programmazione. Ci sono molteplici modi per giungere al risultato, ma io ho deciso di utilizzare una via mediana (ne troppo semplice, ne troppo complessa) in modo tale da ripassare anche alcuni concetti "avanzati". Proviamo a scrivere il codice per ricercare le lunghette di classe 5 più in ritardo per estratto. Prima di tutto cosa ci serve? Ci servirà una classe (ricordate parliamo di spaziometria non di vb.net) che immagazzinerà la lunghetta ed il suo ritardo.

Codice: 
Class clsLunghetta
   Private mSNumeri
   Private mRitardo
   Public Property Let sNumeri(Value)
      mSNumeri = Value
   End Property
   Public Property Get sNumeri()
      sNumeri = mSNumeri
   End Property
   Public Property Let Ritardo(Value)
      mRitardo = Value
   End Property
   Public Property Get Ritardo()
      Ritardo = mRitardo
   End Property
End Class

Piccola nota al riguardo : Voi in spazioscript siete abituati ad utilizzare variabili di tipo Variant. Per chi non lo sapesse in VB6, una "variant" è un tipo di dato che può contenere qualsiasi tipo di dato, inclusi numeri, stringhe, date, array, oggetti e persino altre varianti. È un tipo di dato versatile che può adattarsi al tipo di dati assegnato ad esso durante l'esecuzione. Ed è per tale motivo che voi dichiarate semplicemente in questo modo

Dim Mionumero

e non

Dim Mionumero as Integer

Specifico questo perchè all'interno della classe abbiamo sNumeri che verrà gestito come tipo stringa e non come array numerico (solo per comodità per carità)

Proseguiamo:

All'interno del Sub Main cosa avremo ?

Codice: 
Sub Main
   Dim Lunghette() : Dim QuantitaLunghette 'Array che conterrà le lunghette è la rispettiva quantità
   Dim aRuote,aRuoteSel,aPosizioni 'utili al rilevamento del ritardo
   Dim k,q,y ' variabili cicli for
   Dim RitardoEstratti(90) 'array contenente i ritardi dei 90 nuemri per estratto
   Dim Lunghetta(5) 'Array che conterrà i numeri della singola lunghetta
End sub

Ora nasce il primo problema. LuigiB ha sempre detto una cosa giustissima. Anzi direi sacrosanta. Qual è il problema nel rilevamento delle lunghette? Lo sviluppo? Nah .. il calcolo del ritardo.
Sviluppare tutte le 5ine senza effettuare alcuna ricerca richiede in media 6 secondi. Ma se proviamo a calcolarne il ritardo? I tempi salgono esponenzialmente. (Per alcune classi di sviluppo parliamo di giorni anche più).
Qui ci viene in aiuto la scoperta precedente:

Il ritardo di una lunghetta è dato dal valore del ritardo minore dei numeri presenti in lunghetta per sorte ricercata. Quindi per estratto sarà l'estratto con il ritardo minore, per ambo sarà l'ambo con il ritardo minore.. e cosi via.

Da ciò ne scaturisce che se noi calcolassimo il ritardo dei singoli estratti, avremmo già i ritardi di ogni singola lunghetta.
 
Come calcoliamo il ritardo degli estratti? Attraverso la pappa già pronta di LuigiB è un gioco da ragazzi.

Codice: 
   nColonneTot = InitSviluppoIntegrale(aNumeri,1)
   ' ciclo che continua fiono a quando le colonne non finiscono
   Do While GetCombSviluppo(aCol)
      Call RitardoCombinazione...Ecc. Ecc
   Loop

Ma fin quando si tratta di estratti il rilevamento è rapido.. sono solo 90 numeri. Ma se parliamo di ambi ? (4005 combinazioni) O addirittura terni? (117.480 combinazioni).
Non è che ci voglia una vita..però perdiamo magari 10 minuti di tempo nell'attesa di rilevare le lunghette in 2 secondi. Qui allora ci serve qualcosa di più veloce.

Ora ciò che sto per spiegare può sembrare abbastanza complicato ma non lo è affatto. Se avete dubbi chiedete.
Anche se utilizzando ciò che offre spaziometria già basta per il rilevamento dei ritardi degli estratti, scriverò comunque la procedura "veloce". Così entrerete nell'ottica del ragionamento e magari nella stesura del codice per ambi o terni.


Dichiariamo una procedura che si chiamarà CalcolaRitardiEstratti ed avrà come parametri l'array che conterrà i ritardi degli estratti, le ruote scelte e le posizioni

Codice: 
Sub CalcolaRitardiEstratti(RitardoEstratti,aRuote,aPosizioni)

End Sub
 
Buonasera Edoardo_95, complimenti per la velocissima routine.
Senza fraintendimenti permettimi di dire che non mi trovo in accordo su questo:
Edoardo_95 ha scritto:
Il ritardo di una lunghetta è dato dal valore del ritardo minore dei numeri presenti in lunghetta per sorte ricercata. Quindi per estratto sarà l'estratto con il ritardo minore, per ambo sarà l'ambo con il ritardo minore.. e cosi via.
Clicca per espandere...
La mia non vuole essere una critica ci mancherebbe, ma la teoria trova riscontro e vale solo per le sequele in ritardo ( x un solo numero estratto ) mentre per:
Edoardo_95 ha scritto:
per ambo sarà l'ambo con il ritardo minore.. e cosi via.
Clicca per espandere...
Per sorte Ambo & Terno o superiore nelle lunghette ( sarà solo un puro caso se ci sarà presente l'Ambo base più ritardato )
L'argomento lo trattai più di 6 anni fa incappando in una critica di non poco conto, mossa da chi questo tipo di analisi non le sapeva fare... fu dimostrato che solo in qualche sporadico caso " poteva " essere presente l'Ambo o terno più ritardato...
In parole poveve partire da Ambi e Terni ritardati il vantaggio è solo quello di ridurre i tempi di elaborazione, ma la ricerca finale risulterà falsata perchè non troverà la lunghetta più ritardata del momento.
Se serve posso mettere i casi attuali per le singole ruote, mentre è un attimo controllare che dei 3 ambi più ritardati alle 10 ruote nella lunghetta a ritardo attuale non ce n'è presente nemmeno uno.
Mi auspico che questo mio scritto non venga frainteso, purtroppo sono dati di fatto.
Rinnovo ancora i complimenti per la velocità e la bella routine messa a disposizione , grazie
Nikor
 
Ci mancherebbe Nikor il tuo è un commento più che apprezzato. D'altro canto sto navigando nelle "tue acque" ed è anche giusto che come capitano dica la tua. Ma io ho un piccolo vizio. Ciò che dico è sempre comprovato dai fatti. Il ritardo che assume la lunghetta è il ritardo  minimo tra l'estratto/ambo/terno presente nella lunghetta. Rileva qualsiasi lunghetta con qualsiasi ritardo per sorte da estratto a terno in qualsiasi data dall'inizio del lotto. Valuta la lunghetta scomponendola nella sorte cercata (estratto se ritardo per estratto, ambo se ritardo per ambo ecc..) e vedrai che la lu ghetta sempre ed in qualsiasi caso assumerà il ritardo dell'estratto/ambo/terno con il ritardo minore tra tutti quelli presenti nella lunghetta. Certo questo ragionamento vale fino ad una certa classe. Come la classe 5 massima per estratto per ambo la 22 ecc. Fai tutti i controlli che vuoi e vedrai (ma io ho parlato di ritardo minimo attenzione )😃
 
Ultima modifica:
Ciao Edo, forse parliamo della stessa cosa in modi diversi.
Intanto grazie delle risposte educate e gentili con le quali hai interagito non è da tutti.
Nel caso si intenda il valore della sorte minima ( estratto ) compreso in un ambo o terno allora Sì che è il giusto punto di partenza!
Io volevo dire e sfatare il mito che si debba partire da un Ambo per sorte (2) o da un terno per sorte (3) perchè in questo caso si escluderebbero tutte quelle lunghette con il valore attuale più alto, e mi pare di aver capito che anche tu sia d'accordo...
Questa sera se trovo un attimo posto qualche dato di lunghette dove non siano presenti gli ambi a sorte (2) nella lunghetta più ritardata , ce ne sono a bizzeffe mentre il ( 2 x 1 ) inteso come un numeri di coppia è molto frequente.
Buona serata e grazie di Tutto.
Nikor
 
Rieccomi con la prova effettuata:
Ho preso come campionamento la ruota capitolina di Roma che segna il maggior ritardo per ambo.
Roma - Ambo [ 16-42 ] rit.4691
Roma - ( 2 x 1 ) [ 43-89 ] rit.74
Roma - ( 3 x 2 ) [ 12-23-59 ] rit.1455
Roma - ( 3 x 1 ) [ 37-43-89 ] rit. 58
Lunghetta più ritardata da 10 numeri x sorte (2):
01-22-37-51-52-56-57-62-63-69 ; rit. 284
Possiamo notare che l'ambo più ritardato non è presente, e nemmeno un elemento della coppia ambo!
Non sono presenti elementi del ( 3 x 1 ) e nemmeno del ( 3 x 2 )
E' presente un solo elemento del ( 3 x 1 ) con il numero 37!
Significa che la mia tesi, ( partire da un ambo o terno ritardato è falsata ) in effetti lo possiamo vedere.
Significa anche che la tesi di Edoardo_95 è confermata perchè è presente un elemento del ( 3 x 1 )
Possiamo allora scriverlo a chiare lettere che gli Ambi sorte (2) & Terni sorte (3 Base falsano la ricerca!
--------------------------------------------------------------------------------------------------------------------------------------------------
Senza voler andare fuori tema, ne approfitto per dire che anche per i minimi_storici funziona alla stessa maniera, e visto che ci si mette solo qualche istante metto questa verifica:
Ho messo con lo scroll estrazioni il range a ritroso a caso, mi si è fermato all'estrazione del 06/10/2022 in questo lasso di tempo ricerco l'Ambo con il valore di ( minimo_storico ) dove emergono:
43-61 Max. - 28 estrazioni
04-82 Max. - 29 estrazioni
Provo a spingermi alle quartine e nello stesso range vado alla ricerca dei minimi _ storici ( 4 x 2 ) dove emergono queste 2 quartine a ( St = 9 ):
01-27-64-78 Max. - 9
05-19-35-82 Max. - 9 , tutte le altre oltre il valore ( >9)
Si evence che dell'ambo base ( 43-61 ) al minimo (28) non c'è traccia , mentre è prente un solo elemento dell'ambo ( 04-82 ) che aveva segnato un minimo di (29)
Morale della favola riconfermato che nelle sequele a salire di lunghezza gli ambi sono presenti come le mosche bianche...
Spero di aver chiarito il concetto, poi è ovvio che ognuno rimanga sulle proprie idee
Nikor
 
Aaaaah ma tu parli in ottica globale!!! Ora ho capito e ti chiedo scusa ho frainteso. Certo che hai ragione!
Ma non centra nulla con quello che sto dicendo io!

io intendo il ritardo minimo tra tutti gli ambi presenti nella lunghetta e non a livello globale di tutti gli ambi esistenti!

qual è l'ambo con lo stesso ritardo della lunghetta? 37-63 che guarda caso è il ritardo più basso tra tutti gli ambi generabili della lunghetta! Nuovamente confermato ciò che dico
 

Allegati

Caspiterina, mi prenderei a scappelloti da solo! ma come non ci ero arrivato?
Boh... l'età avanza ihihihih.ihih
Hai ragione parti dall'ambo più corto della lunghetta che non centra niente con l'ambo globale ritardato!
Pazienza ho imparato qualcosa di nuovo anche oggi.
Rimane il fatto che possiamo scrivere a chiare lettere che partire da un Ambo o Terno più ritardato la ricerca risulterà falsata. ( credo che almeno qui siamo in sintonia )
Intanto in questo trambusto la decina sforna un Ambo a colpo !!!
Nikor ha scritto:
Lunghetta più ritardata da 10 numeri x sorte (2):
01-22-37-51-52-56-57-62-63-69 ; rit. 284
Clicca per espandere...
Questa sera ( 52-62 ) ruota analizzata era Roma.
--------------------------------
Buona serata Edoardo_95
Nikor
 
Nikor ha scritto:
Caspiterina, mi prenderei a scappelloti da solo! ma come non ci ero arrivato?
Boh... l'età avanza ihihihih.ihih
Hai ragione parti dall'ambo più corto della lunghetta che non centra niente con l'ambo globale ritardato!
Pazienza ho imparato qualcosa di nuovo anche oggi.
Rimane il fatto che possiamo scrivere a chiare lettere che partire da un Ambo o Terno più ritardato la ricerca risulterà falsata. ( credo che almeno qui siamo in sintonia )
Intanto in questo trambusto la decina sforna un Ambo a colpo !!!

Questa sera ( 52-62 ) ruota analizzata era Roma.
--------------------------------
Buona serata Edoardo_95
Nikor
Clicca per espandere...
Assolutamente si! Falsata al 100% senza ombra di dubbio. Sono abbastanza pazzo ma non fino al punto di dire una ca**zat* del genere ahahaahaha.
 
Bene possiamo ritornare alla programmazione pura. Siamo arrivati a questo punto



Codice: 
Class clsLunghetta

   Private mSNumeri

   Private mRitardo

   Public Property Let sNumeri(Value)

      mSNumeri = Value

   End Property

   Public Property Get sNumeri()

      sNumeri = mSNumeri

   End Property

   Public Property Let Ritardo(Value)

      mRitardo = Value

   End Property

   Public Property Get Ritardo()

      Ritardo = mRitardo

   End Property

End Class







Sub Main

   Dim Lunghette() : Dim QuantitaLunghette 'Array che conterrà le lunghette è la rispettiva quantità

   Dim aRuote,aRuoteSel,aPosizioni 'utili al rilevamento del ritardo

   Dim k,q,y ' variabili cicli for

   Dim RitardoEstratti(90) 'array contenente i ritardi dei 90 nuemri per estratto

   Dim Lunghetta(5) 'Array che conterrà i numeri della singola lunghetta







End sub





Sub CalcolaRitardiEstratti(RitardoEstratti,aRuote,aPosizioni)



End Sub





La procedura CalcolaRitardiEstratti rileva il ritardo dei 90 numeri?



Procediamo con una spiegazione in pseudo codice per poi arrivare al codice vero è proprio

All'interno della procedura i passaggi da fare saranno i seguenti :

  1. scorro le estrazioni dalla prima all'ultima
  2. ottengo un array con l'estrazione completa con tutte le ruote e gli estratti
  3. verifico per ogni singola ruote se è stata scelta dall'utente
  4. poichè partiamo dall'estrazione 1 del 1871 sappiamo a priori che alcune ruote non esistevano quindi imposto una variabile boolean che verifica la presenza di estratti sulla ruota se sono esistenti avrà valore true altrimenti false.
  5. procedo con il verificare quali posizioni ha scelto l'utente
  6. se il numero è presente imposto il suo ritardo a -1
  7. uscito dal ciclo delle ruote se la variabile di controllo degli estratti è true incremento di 1 i valori dei ritardi
in questo modo se il numero è presente assumera valore zero altrimenti incrementerà il suo ritardo fin quando non sortisce ritornando a zero.

Bella storia vero? io che l'ho scritto non ci ho capito molto. Andiamo con il codice vero e proprio va :

Codice: 
Sub CalcolaRitardiEstratti(RitardoEstratti,aRuote,aPosizioni)
   Dim IdEstr
   Dim Flag
   Dim Estrazione
   Dim r,e,n
   Dim EstrattoSingolo
   For IdEstr = 1 To EstrazioneFin 'ciclo le estrazioni dalla prima all'ultima
      If GetEstrazioneCompleta(IdEstr,Estrazione) Then 'grazie a questa funzione ottengo un array estrazione(11,5)
         Flag = True ' do per scontato che le'strazione vada bene per qualsiasi ruota
         For r = 1 To 10 ' ciclo le ruote
            If aRuote(r) Then ' se la ruota è stata scelta dall'utente proseguo altrimenti salto. In questo modo i risultati saranno su ruote unite se la scelta delle ruote è superiore a una
               If Estrazione(r,1) = 0 Then ' se il primo estratto della ruota scelta dall'utente è zero vuol dire che la ruota ancora non esisteva. Semplice
                  Flag = False
               Else
                  For e = 1 To 5 ' ciclo le posizioni
                     If aPosizioni(e) Then ' se la posizione è stata scelta dall'utente
                        EstrattoSingolo = Estrazione(r,e) ' mi salvo in una variabile temporanea il valore dell'estratto
                        RitardoEstratti(EstrattoSingolo) = - 1 ' pongo a meno uno il valore del ritardo (RitardoEstratti(90) è dichiarato cosi)
                     End If
                  Next
               End If
            End If
         Next
         If Flag Then
            For n = 1 To 90 ' ciclo i 90 numeri
               RitardoEstratti(n) = RitardoEstratti(n) + 1 ' incremento il valore del ritardo di 1 (quindi se è -1 è sortito ed il ritardo è zero altrimenti aumento il suo ritardo)
            Next
         End If
      End If
   Next
End Sub
 
Quindi arriviamo a questo punto :

Codice: 
Option Explicit
Class clsLunghetta
   Private mSNumeri
   Private mRitardo
   Public Property Let sNumeri(Value)
      mSNumeri = Value
   End Property
   Public Property Get sNumeri()
      sNumeri = mSNumeri
   End Property
   Public Property Let Ritardo(Value)
      mRitardo = Value
   End Property
   Public Property Get Ritardo()
      Ritardo = mRitardo
   End Property
End Class


Sub Main
   Dim Lunghette() : Dim QuantitaLunghette 'Array che conterrà le lunghette è la rispettiva quantità
   Dim aRuote,aRuoteSel,aPosizioni 'utili al rilevamento del ritardo
   Dim k,q,y ' variabili cicli for
   Dim RitardoEstratti(90) 'array contenente i ritardi dei 90 nuemri per estratto
   Dim Lunghetta(5)



End Sub



Sub CalcolaRitardiEstratti(RitardoEstratti,aRuote,aPosizioni)
   Dim IdEstr
   Dim Flag
   Dim Estrazione
   Dim r,e,n
   Dim EstrattoSingolo
   For IdEstr = 1 To EstrazioneFin
      If GetEstrazioneCompleta(IdEstr,Estrazione) Then
         Flag = True
         For r = 1 To 10
            If aRuote(r) Then
               If Estrazione(r,1) = 0 Then
                  Flag = False
               Else
                  For e = 1 To 5
                     If aPosizioni(e) Then
                        EstrattoSingolo = Estrazione(r,e)
                        RitardoEstratti(EstrattoSingolo) = - 1
                     End If
                  Next
               End If
            End If
         Next
         If Flag Then
            For n = 1 To 90
               RitardoEstratti(n) = RitardoEstratti(n) + 1
            Next
         End If
      End If
   Next
End Sub


Se avete notato nella procedura CalcolaRitardiEstratti non passo nessun array numerico ma utilizzo i numeri sortiti stessi. Bene e ora ?

Ora valorizziamo aRuote ed aPosizioni

Ci creiamo una semplice procedura che chiameremo ImpostaParametri ... che fantasia nei nomi...

Dove passeremo :

  1. l'array Lunghette
  2. La quantità di lunghette da ricercare
  3. Un array di ruote che verrà valorizzato in questo modo : Esempio se l'utente sceglie BA + VE

    l'array tornerebbe valorizzato con :

    aRuoteSel (1) = 1
    aRuoteSel (2) = 10
    aRuoteSel (3) = 0
    aRuoteSel (4) = 0
    aRuoteSel (5) = 0
    aRuoteSel (6) = 0
    aRuoteSel (7) = 0
    aRuoteSel (8) = 0
    aRuoteSel (9) = 0
    aRuoteSel (10) = 0
    aRuoteSel (11) = 0
    aRuoteSel (12) = 0
  4. Un array boolean aRuote all'interno della quale verranno impostate a true le ruote scelte
  5. Un array boolean aPosizioni all'interno della quale verranno impostate a true le posizioni scelte
Otterremo una cosa del genere :


Codice: 
Sub ImpostaParametri(Lunghette,QuantitaLunghette,aRuoteSel,aRuote,aPosizioni)
   Dim i,k
   Call ScegliRuote(aRuoteSel,aRuote)
   QuantitaLunghette = InputBox("Scelta quantià","Scegli la quantità delle Lunghette da rilevare (massimo 100)",50)
   ReDim Lunghette(QuantitaLunghette)
   For i = 1 To QuantitaLunghette
      Set Lunghette(i) = New clsLunghetta
   Next
   ReDim aPosizioni(5)
   For k = 1 To 5
      aPosizioni(k) = True
   Next
End Sub
 
questa parte di codice so che provocherà un attacco di panico ad alcuni :

Codice: 
   For i = 1 To QuantitaLunghette
      Set Lunghette(i) = New clsLunghetta
   Next

In ImpostaParametri noi passiamo l'array Lunghette. L'array lunghette deve essere un array di "Classi Lunghette"

quindi una volta impostata la dimensione dell'array con ReDim Lunghette(QuantitaLunghette)

scorro attraverso un ciclo da 1 alla quantita di lunghette scelte ed imposto Lunghette(i) (per gli amici Lunghette di iiii ahah) come una Classe Lunghette che avrà come detto inizialmente la stringa dei numeri ed il ritardo.
 
Lo script inizia a prendere forma e diventa cosi :

Codice: 
Option Explicit
Class clsLunghetta
   Private mSNumeri
   Private mRitardo
   Public Property Let sNumeri(Value)
      mSNumeri = Value
   End Property
   Public Property Get sNumeri()
      sNumeri = mSNumeri
   End Property
   Public Property Let Ritardo(Value)
      mRitardo = Value
   End Property
   Public Property Get Ritardo()
      Ritardo = mRitardo
   End Property
End Class

Sub Main
   Dim Lunghette() : Dim QuantitaLunghette
   Dim aRuote,aRuoteSel,aPosizioni
   Dim k,q,y
   Dim RitardoEstratti(90)
   Dim Lunghetta(5)
   Call ImpostaParametri(Lunghette,QuantitaLunghette,aRuoteSel,aRuote,aPosizioni)
   Call CalcolaRitardiEstratti(RitardoEstratti,aRuote,aPosizioni)

End Sub

Sub ImpostaParametri(Lunghette,QuantitaLunghette,aRuoteSel,aRuote,aPosizioni)
   Dim i,k
   Call ScegliRuote(aRuoteSel,aRuote)
   QuantitaLunghette = InputBox("Scelta quantità","Scegli la quantità delle Lunghette da rilevare (massimo 100)",50)
   ReDim Lunghette(QuantitaLunghette)
   For i = 1 To QuantitaLunghette
      Set Lunghette(i) = New clsLunghetta
   Next
   ReDim aPosizioni(5)
   For k = 1 To 5
      aPosizioni(k) = True
   Next
End Sub

Sub CalcolaRitardiEstratti(RitardoEstratti,aRuote,aPosizioni)
   Dim IdEstr
   Dim Flag
   Dim Estrazione
   Dim r,e,n
   Dim EstrattoSingolo
   For IdEstr = 1 To EstrazioneFin
      If GetEstrazioneCompleta(IdEstr,Estrazione) Then
         Flag = True
         For r = 1 To 10
            If aRuote(r) Then
               If Estrazione(r,1) = 0 Then
                  Flag = False
               Else
                  For e = 1 To 5
                     If aPosizioni(e) Then
                        EstrattoSingolo = Estrazione(r,e)
                        RitardoEstratti(EstrattoSingolo) = - 1
                     End If
                  Next
               End If
            End If
         Next
         If Flag Then
            For n = 1 To 90
               RitardoEstratti(n) = RitardoEstratti(n) + 1
            Next
         End If
      End If
   Next
End Sub
 
Devi accedere o registrarti per poter rispondere.

Ultima estrazione Lotto

  • Estrazione del lotto
    martedì 28 ottobre 2025
    Bari
    71
    36
    81
    10
    35
    Cagliari
    42
    69
    62
    52
    35
    Firenze
    03
    80
    38
    54
    11
    Genova
    88
    41
    18
    07
    45
    Milano
    48
    43
    11
    17
    57
    Napoli
    18
    55
    10
    15
    04
    Palermo
    67
    26
    33
    49
    45
    Roma
    14
    77
    10
    05
    54
    Torino
    79
    87
    42
    55
    40
    Venezia
    62
    18
    85
    74
    01
    Nazionale
    61
    45
    38
    34
    62
    Estrazione Simbolotto
    44
    34
    11
    25
    16
    Archivio estrazioni lotto Ritardi top 15 Frequenze top 15

Ultimi Messaggi

Indietro
Alto