Novità

Spaziometria o uno script possono rilevare la 10ina + in ritardo x A su tutte?

Il max ritardo storico di un ambo su due ruote a me risulta essere di 3086.
Per agevolare le prove con i vostri script le ruote sono ca.ro.
A dopo:)

con il mio script

CA..RO Max rit. storico...3086 / Max rit.attuale... 355....comb...35.78


corrisponde a tutte 3

compreso spaziometria valori massimi
 
Ultima modifica di un moderatore:
per una terzina , avrei questi dati con ritardostoricoturbo per la sorte dell'ambo

BA..VE Max rit. storico...1250....comb...27.71.72

ci vogliono circa 23 minuti, una eternità per elaborare tutte le 45 coppie di ruote e per i 117480 terni.

praticamente una eternità, con lo scritp posizionato su valori massimi storici, tenendo conto per l'uso a salire
delle combinazioni superiori(quartine,cinquine)

se qualcuno vuole dare solo conferma

spaziometria quadra con questo dato con ricerca a ruote unite nella statistica veloce, mentre in quella tabellone valori massimi ricerca veloce non figura questa combinazione ne tanto meno il ritardo!!!!

mentre togliendo il flag di spunta della ricerca veloce, quindi facendo
la statistica in modo profondo, corrispondono tutti i dati ed appare come la terzina più ritardataria su queste 2 ruote BA-VE 27 71 72

okey chiuso il problema della mancata corrispondenza-
tra script vari e programma spaziometria.
 
Ultima modifica di un moderatore:
ragazzi buonasera a tutti , pensavate che mi fossi scordato di voi ? No ...come potrei.. solo che non ho piu tempo per dedicarmi a questo progetto e devo dire la verità non voglio farmi assorbire piu come prima. mi fa piacere tuttavia intervenire in questo interessante thread (non lo farò in altri ) per salutare Joe ,Legend , Claudio gil altri che sono intervenuti ..e complimentarmi con Beppignello per il suo darsi da fare e per il suo computer direi alquanto veloce .. lo hai preso dal CNR ?
Avendo visto il thread mi è venuto in mente uno script che ineffetti non assolve proprio a quello che volete fare voi , serve per dare la lunghetta piu ritardata per una data sorte su date ruote , è interessante l'algorimo che mi è venuto in mente per cercare di essere il piu efficiente possibile .. pero sinceramente lo script l'ho fatto un'oretta ieri e una'altra oretta oggi non so se funziona provatelo e fatemi sapere .. se funziona spiego l'algoritmo ...tra l'altro se funziona potrebbe essere teoricamente usato come base (anche se è abbastanza complesso) per ottenere il vostro scopo ovvero lo storico del ritardo di una lunghetta di classe K su N ruote ..
ciao a tutti

Codice:
vedere post successivo
 
Ultima modifica di un moderatore:
Ciao Luigi :)
Un abbraccio;)
è un piacere grandissimo leggerti perché Vuol dire che è tutto ok :)
Ciao prof. :)
Appena provo lo script ti faccio sapere.
Un saluto a tutti :)
 
ciao Legend anche per me venire a salutarvi , copia daccapo lo script che ho fatto una piccola modifica ..


Codice:
Option Explicit
Class clsCombinazione
    Private m_UltEstUscita
    Private m_Key
    Private m_aNum
    Private m_Classe
    Private m_Index
    Sub Class_Initialize
        ' codice
    End Sub
    Sub Class_Terminate
        ' codice
    End Sub
    Public Property Get Index
        Index = m_Index
    End Property
    Public Property Let Index(NewValue)
        m_Index = NewValue
    End Property
    Public Property Get Classe
        Classe = m_Classe
    End Property
    Public Property Let Classe(NewValue)
        m_Classe = NewValue
    End Property
    Public Property Get Key
        Key = m_Key
    End Property
    Public Property Let Key(NewValue)
        m_Key = NewValue
    End Property
    Public Property Get aNum
        aNum = m_aNum
    End Property
    Public Property Let aNum(NewValue)
        m_aNum = NewValue
    End Property
    Public Property Get UltEstUscita
        UltEstUscita = m_UltEstUscita
    End Property
    Public Property Let UltEstUscita(NewValue)
        m_UltEstUscita = NewValue
    End Property
    Function GetStringaNum
        GetStringaNum = StringaNumeri(m_aNum,,True)
    End Function
    
    Function AlimentaCollLunghetta(CollLunghette,CollCombBase,nClasseLung)
        Dim abNum,nClasseTmp
        Dim n
        ReDim aCol(0)
        Dim sKey,cItem
        Dim bFound,bNonAdatta
        Dim aNum
        Dim nNumIni,nNumAggiunto
        Dim sRadice
        
        nClasseTmp = m_Classe
        abNum = ArrayNumeriToBool(m_aNum)
        nNumIni = 0
        sRadice = StringaNumeri(m_aNum,,True)
        Do While nNumIni < 90
            nNumIni = nNumIni + 1
            Do While nClasseTmp < nClasseLung
                bFound = False
                Call Messaggio("Analisi radice " & sRadice)
                bNonAdatta = True
                For n = nNumIni To 90
                    If abNum(n) = False Then
                        nNumAggiunto = n
                        abNum(n) = True
                        nClasseTmp = nClasseTmp + 1
                        'ReDim aNum(nClasseTmp)
                        Call ArrayBNumToArrayNum(abNum,aNum)
                        Call InitSviluppoIntegrale(aNum,m_Classe)
                        bNonAdatta = False
                        Do While GetCombSviluppo(aCol)
                            sKey = "k" & StringaNumeri(aCol,,True)
                            If GetItemCollection(CollCombBase,sKey,cItem) Then
                                If cItem.Index > m_Index Then
                                    bNonAdatta = True
                                    abNum(n) = False
                                    nClasseTmp = nClasseTmp - 1
                                    Exit Do
                                End If
                            End If
                        Loop
                        If bNonAdatta = False Then Exit For
                    End If
                Next
                If bNonAdatta Then Exit Do
            Loop
            If nClasseTmp = nClasseLung Then
                Dim clsL
                Set clsL = New clsCombinazione
                clsL.aNum = aNum
                clsL.Classe = nClasseLung
                clsL.UltEstUscita = m_UltEstUscita
                sKey = "k" & StringaNumeri(aNum,,True)
                On Error Resume Next
                Call AddItemColl(CollLunghette,clsL,sKey)
                nNumIni = nNumAggiunto
                abNum(nNumAggiunto) = False
                nClasseTmp = nClasseTmp - 1
            Else
                nNumIni = 90
            End If
        Loop
    End Function
End Class
Sub Main
    Dim collCombBase,CollLunghette,nSorte,aRuote,Ini,fin,sMsg,nMoltip
    Dim nCicloTeo,nRitMax,nClasseLunghetta,nRuoteSel,nCombBaseTrov,nLunghetteDaTrov
    Dim clsComb
    Dim i
    nSorte = ScegliEsito
    nClasseLunghetta = ScegliClassseLunghetta
    nRuoteSel = SelRuote(aRuote)
    
    nLunghetteDaTrov = 3
    
    
    ReDim Preserve aRuote(nRuoteSel)
    nCicloTeo = CicloTeorico(nClasseLunghetta,nSorte,UBound(aRuote))
    nMoltip = 25
    sMsg = "Inserire il ritardo massimo ipotizzato per la sorte voluta nella lunghetta" & vbCrLf
    sMsg = sMsg & "Il valore mostrato è il CicloTeorico per la sorte di " & nSorte
    sMsg = sMsg & " su " & nClasseLunghetta & " numeri su " & nRuoteSel & " ruote moltiplicato per " & nMoltip
    nRitMax = Int(InputBox(sMsg,,nCicloTeo * nMoltip))
    fin = EstrazioneFin
    Ini = fin - nRitMax
    If Ini <= 0 Then Ini = 1
    
    
    
    Call AlimentaCollCombUscite(collCombBase,nSorte,aRuote,Ini,fin)
    Call OrdinaItemCollection(collCombBase,"UltEstUscita","Key",,1)
    i = 0
    For Each clsComb In collCombBase
        i = i + 1
        clsComb.Index = i
    Next
    nCombBaseTrov = collCombBase.count
    Call Scrivi("Le combinazioni base (uscite nel periodo analizzato) di classe " & nSorte & " sono " & nCombBaseTrov)
    
    
    
    Set CollLunghette = GetNewCollection
    i = 0
    For Each clsComb In collCombBase
        Call clsComb.AlimentaCollLunghetta(CollLunghette,collCombBase,nClasseLunghetta)
        'Call Scrivi(clsComb.GetStringaNum & " -- " & clsComb.UltEstUscita)
        If CollLunghette.count >= nLunghetteDaTrov Then Exit For
        i = i + 1
        'If i > 1000 Then Exit For
        Call AvanzamentoElab(1,nCombBaseTrov,i)
        If ScriptInterrotto Then Exit For
    Next
    For Each clsComb In CollLunghette
        Call Scrivi(clsComb.GetStringaNum & " -- " & clsComb.UltEstUscita & " - Rit " & RitardoCombinazioneTurbo(aRuote,clsComb.aNum,nSorte,fin))
    Next
End Sub
Sub AlimentaCollCombUscite(coll,nSorteCerc,aRuote,Ini,Fin)
    Dim idEstr,r,k,nCombSvil,sKey
    Dim clsComb
    ReDim aColonne(0)
    ReDim aNum(0)
    ReDim aCol(0)
    nCombSvil = Combinazioni(5,nSorteCerc)
    Set coll = GetNewCollection
    For idEstr = Ini To Fin
        For r = 1 To UBound(aRuote)
            Call GetArrayNumeriRuota(idEstr,aRuote(r),aNum)
            Call OrdinaMatrice(aNum,1)
            Call InitSviluppoIntegrale(aNum,nSorteCerc)
            Do While GetCombSviluppo(aCol)
                sKey = "k" & StringaNumeri(aCol,,True)
                Call GetClsComb(coll,sKey,clsComb,aCol,nSorteCerc)
                clsComb.UltEstUscita = idEstr
            Loop
        Next
        Call AvanzamentoElab(Ini,Fin,idEstr)
        If ScriptInterrotto Then Exit For
    Next
End Sub
Function GetClsComb(coll,sKey,clsComb,aCol,nClasse)
    On Error Resume Next
    Set clsComb = coll(sKey)
    If Err <> 0 Then
        Err.Clear
        Set clsComb = New clsCombinazione
        clsComb.Key = sKey
        clsComb.aNum = aCol
        clsComb.Classe = nClasse
        Call coll.Add(clsComb,sKey)
        GetClsComb = False
    Else
        GetClsComb = True
    End If
End Function
Function ScegliClassseLunghetta
    Dim aVoci(30)
    Dim k,i
    For k = 2 To(2 - 1) + UBound(aVoci)
        i = i + 1
        aVoci(i) = k
    Next
    k = ScegliOpzioneMenu(aVoci,5,"Classe lunghetta")
    ScegliClassseLunghetta = Int(aVoci(k))
End Function
Function GetItemCollection(Coll,sKey,cItem)
    On Error Resume Next
    Set cItem = Coll(sKey)
    If Err <> 0 Then
        Err.Clear
        GetItemCollection = False
    Else
        GetItemCollection = True
    End If
End Function
Function SelRuote(aRuote)
    Dim t,k,bTutte
    
    bTutte = False
    t = ScegliRuote(aRuote)
    
    For k = 1 To t
        If aRuote(k) = TT_ Then
            bTutte = True
            Exit For
        End If
    Next
    
    If bTutte Then
        ReDim aRuote(10)
        For k = 1 To 10
            aRuote(k) = k
        Next
        SelRuote = 10
    Else
        SelRuote = t
    End If
End Function
 
Ultima modifica di un moderatore:
ciao LuigiB

con il mio script per lunghette da 11 numeri e sorte 2 tutte
ottengo questo risultato:

Ritardo Freq. Combinazione Lunghetta
0027 / 0027 7295 38.41.43.48.53.60.70.73.82.83.88
0023 / 0023 7108 1.7.18.19.38.41.43.54.82.88.89


Totale Combinazioni....2
Tempo elaborazione..9:17:19 PM : 9:18:24 PM


-----------------------------------------------------


con il tuo script, che confermo funziona si ottiene quanto segue:

lasciando i dati dei ritardi proposti in automatico


Le combinazioni base (uscite nel periodo analizzato) di classe 2 sono 2449

02.07.12.22.28.29.38.39.41.55.88 -- 9115 - Rit 20 02.07.12.21.22.28.29.38.39.55.88 -- 9115 - Rit 20 02.07.12.21.29.38.39.55.72.76.90 -- 9116 - Rit 19

come vedi le due lunghette che trova l'altro script, sono con ritardo superiore.

--------------------------------------------------------------------------

comunque, vorrei solo sapere perché nella sezione Tabellone - Valori Massimi elaborando, con ricerca veloce spuntato, e senza lo spunto perché i valori cambiano e non corrispondono. quella senza lo spunto, diciamo ricerca profonda mi sembra corretta e corrispondente ai dati reali.
 
Ultima modifica di un moderatore:
Ciao luigi copiato e lanciato lo script.
Premetto che non l ho ancora studiato ci sono dele formazioni mancanti.
Ho provato le cinquina per sorte ambo.
La più ritardata ha un rit di 82 .
Lo script invece rileva un massimo di 67.
Cmq è turbo;)
Come sempre bravissimo:)
Fatemi sapere casomai sono io che ho sbagliato qualcosa.
A dopo;)
 
Codice:
per errori, tolto!

ciao
 
Ultima modifica di un moderatore:
ciao Legend , grazie per i complimenti tuttavia immeritati e a Beppignello per la prova svolta.
Diciamo che mentre l'algoritmo classico svolge un approccio che si dice Top - Down io per velocizzare le cose ho impostato invece al contrario seguendo quella che in gercgo si chiama
soluzione bottom - up .. ovvero invece di partire da tuttte le n combinazioni possibili e analizzarle una ad una ho fatto il contrario sono partito dalle combinazioni uscite lette dalle estrazioni.
Ma ripeto evidentemente c'è qualcosa che non va nel ragionamento .. ci devo pensare.. perche mi pareva filasse...:-)
 
Buona sera tutte/i,

Intervengo anch'io soprattutto per introdurre un saluto a Luigi.

Non ho potuto seguire bene ... tutta l'evoluzione ... tuttavia mi permetto questa osservazione:

A livello di descrizione ... potrebbe parere che sia "una cinquina" in 45 combinazioni (10 ruote a coppie) ...

mentre è diverso il ritardo di una cinquina in una ruota ed una altra cinquina in un'altra.

Esattamente come avviene lanciando due dadi ... il ritardo per un solo numero diminusce

(rispetto a quello di un solo dado) ...

Mentre invece per due "numeri diffrenti" (uno per ogni dado)

(che in descrizione sono identici ovvero un numero per ogni dado

ed anche ... il ritardo di un numero in due dadi) ...

... può essere casualmente e coincidentemente molto elevato.

Quasi ... come quello di un singolo numero in un singolo dado.

Ove qui evidentemente "cinquina" può indicare genericamente una sola cinquina per due ruote

o due cinquine ... diverse ...una per ognuna delle 2 ruote ... dando origine a risultati molto diversi.

Luigi, si ... il tuo ragionamento, porta al risultato di una ulteriore statistica.

Veloce si ... ma ancora più lontana ...e direi completamente diversa dalle due che ho cercato di esporre.

:) Cordiali saluti
 
Ultima modifica:
[TABLE="border: 0, cellpadding: 0, cellspacing: 0, width: 832"]
[TR]
[TD]
LOGOSILOP.gif
[/TD]
[/TR]
[TR]
[TD]ho aggiornato SPMT vers. 1.5.76 e relativo plug in SVP vers. 1.0.55[/TD]
[/TR]
[TR]
[TD]Ciao LuigiB ,[/TD]
[/TR]
[TR]
[TD]scrivo solo per un veloce saluto.[/TD]
[/TR]
[TR]
[TD]
stickman.gif
[/TD]
[/TR]
[TR]
[TD]Buona notte a tutti.[/TD]
[/TR]
[TR]
[TD]A presto [/TD]
[/TR]
[TR]
[TD]Silop ;) ;) ;)[/TD]
[/TR]
[/TABLE]
 
ciao Silop , un grande saluto a te.
Per Joe , il ragionamento sul quale si basa lo script è stato questo.
Per evitare di analaizzare tutte le possibili combinazioni di classse K per sorte X (cioè le lunghette volute) come fare ?
Ho pensato: se leggo l'archivo delle estrazioni sulle ruote in esame e creo una lista delle combinazioni di sorte X prodotte dalle cinquine uscite nel periodo analizzato e successivamene ordino questa lista in modo che la combinazione di classe X con maggior ritardo si trovi all'indice 1 e quella con meno ritardo si trovi all'ultima posizione della lista, poi posso leggere la lista dalla prima all'ultima posizione e per ogni combinazione di base letta lancio una routine che prova ad aggiungere a questa numeri fino a far crescere la classe al valre voluto , naturalemte ogni volta che aggiunge un numero verifica le nuove combinazioni di base (quelle di sorte X) che si verrebebro a creare con l'agginta del numero suddetto e se queste si trovano ad una posizione superiore (indice prossimo ad 1) rispetto alla combinazione analizzata
in quel momento allora il numero puo essere aggiunto facendo crescere la classe , non appena invece la presenza del nuovo numero va a provocare la presenza di una delle nuove combinazioni di base ad un valore piu alto della lista delel combinazioni allora il numero non si puo aggiungere e se ne deve provare un altro.
Il tutto ripetuto fino a raggingere la classe voluta ovvero la dimensione della lunghetta.
Se la combinazione analizzata non ha prodotto la lunghetta si passa a quella successiva , in pratica la lunghetta ha una radice che ha un ritardo per la sorte x e poi altri numeri che producono subcolonen di classe x tutte con ritardo superiore.Se la comb di base analizzata in quel momento non ha le giuste caratteristiche cioè non ha dato la lunghetta mi sposto alla successiva della lista delel combinazioni
In pratica dalle estrazioni analizzate si ricavano tutte le combinazioni uscite di sorte X cioe la sorte per cui si vule la lunghetta e da queste tento di ricacavare la lunghetta agiungendo un numero alla volta ..solo che c'è qualcosa che non va .. probabilmente la sequenza con cui si aggiungono i numeri produce risultati differenti impedendo l'individuazione corretta del ritardo piu alto .. ci devo pensare su ..vedremo quando avro tempo ...
 
Ultima modifica di un moderatore:
Beppignello;n1965039 ha scritto:
x silop (probabilmente la differenza sta in questo):

il ritardo storico conseguito
si può dividere in 2 modi:

1) il ritardo più alto
2) il ritardo più alto - ma ottenuto dall'ultima uscita , cioè il tempo intercorso tra ultima precedente uscita e la nuova uscita.

il 726
di luigi nel caso del 01 90 è rilevato dalla differenza tra l'uscita
5691 del 02/02/1980 e 6418 del 08/01/1994
====================================== [TABLE="border: 0, cellpadding: 0, cellspacing: 0, width: 832"]
[TR]
[TD]
LOGOSILOP.gif
[/TD]
[/TR]
[TR]
[TD]ho aggiornato SPMT vers. 1.5.76 e relativo plug in SVP vers. 1.0.55[/TD]
[/TR]
[TR]
[TD]Ciao Beppignello ,[/TD]
[/TR]
[TR]
[TD]se il ritardo massimo storico dell'ambo 1.90 è di 726 estrazioni[/TD]
[/TR]
[TR]
[TD]TO..VE Massimo ritardo registrato...726 ambo 1.90 att. 77[/TD]
[/TR]
[TR]
[TD]ed è calcolato bene (luigi)[/TD]
[/TR]
[TR]
[TD]ma il valore 807[/TD]
[/TR]
[TR]
[TD]TO..VE Massimo ritardo registrato...807 ambo 1.90 att. 77[/TD]
[/TR]
[TR]
[TD]come si calcola tra le due ruote unite ?[/TD]
[/TR]
[TR]
[TD]Non riesco a comprendere, grazie per la risposta.[/TD]
[/TR]
[TR]
[TD]
stickman.gif
[/TD]
[/TR]
[TR]
[TD]Buona notte a tutti.[/TD]
[/TR]
[TR]
[TD]A presto [/TD]
[/TR]
[TR]
[TD]Silop ;) ;) ;)[/TD]
[/TR]
[/TABLE]
 
per silop

questo è quello integrale, normale,
può servire per seriestoricoturbo per sapere il massimo storico di una combinazione
può servire per ritardocombinazioneturbo per sapere il massimo attuale di una combinazione

è dato per scontato che i tempi sono piuttosto lunghi, per una situazione su tutte le 45 coppie di ruote
come da me calcolato è intorno a 16-17 ore, per una classe 5 e sorte 2, dove si cerca semplicemente
le migliori cinquine attualmente in ritardo.

se si volesse invece gli storici, i tempi di elaborazione sono destinati ad essere ancora più elevati
perché l'istruzione seriestoricoturbo è più gravosa che ritardocombinazioneturbo.


c'è solo un'altra ipotesi per ottenere più velocemente le migliori cinquine in ritardo, ed è quello di elaborare il tutto dalla lettura delle cinquine estratte, facendo in questo modo si leggono solo poco più di 9000 estrazioni, contro le sicure 44Milioni di cinquine del metodo integrale.
questo script l'ho usato solo per controllare l'esatto valore dei ritardi
attuali migliori e trovare una corrispondenza con l'altro script, iper veloce fino alla 11dicina - 12dicina .

oltre lo script è proibitivo, ma per fortuna ci sono le lunghette per ambo nel programma spaziometria, che LuigiB ha provveduto e messo a disposizione.


ciao


Codice:
Option Explicit
Sub Main
 per errori, tolto!
 
Ultima modifica di un moderatore:
Ciao luigi Capito il ragionamento.
Ma in pratica sviluppi le combinazioni dei numeri usciti e li escludi dalle comb integrali?
Perché a noi servono le combinazioni che non sono sortite nell intervallo di ricerca. Giusto?
Ciao:)
Joe forse ho capito cosa vuoi dire. Pensi che sia meglio considerare la somma dei ritardi?
Ciao :)
 
Ciao Luigi.

Ok ... giusto e bene così.

Ineceppibile ed è la stessa soluzione (veloce) che avevo ipotizzato ... mancando la voglia di scriverla.

Unico problema, per la sorte di Ambo in lunghetta da 5 numeri ..con archivio al 15/03/2016,

NON trova : 8.14.33.49.77 con il ritardo di 81 estrazioni (tra un 84 ed un 66 correttamente elencati)

:)
 
ciao Legend , piu o meno è cosi provo a spiegare meglio cosi mi aiutate a capire "dove casca l'asino".
Fai finta che uno chieda 5 numeri per ambo su due ruote.
Ora le estrazioni dal 1938 che ne so sono circa 5000.
E' chiaro che la lunghetta che cerchiamo noi non avra certo un ritardo di 5000 come se non fosse mai uscita.
Il suo ciclo teorico sarebbe di 21 estrazioni figuriamoci .. quindi è chiaro che la lunghetta che cerchiamo noi è impernaita su un ambo che è gia uscito da qualche parte infatti in una lunghetta è l'ambo con minor ritardo che determina il ritardo per ambo di tutta la lunghetta poi la stessa lunghetta produce altri ambi ma sono tutti con maggior ritardo rispetto all'ambo "base" su cui si impernia.
Alora cosa ho pensato ?
Dico nel caso dell'esempio che sto facendo il ciclo teorico è 21 noi lo moltiplichiamo arbitrariamente per un valore elevato (io ho usato 25) per ipotizzare entro quante estrazioni fa sarà uscito il famoso ambo base della lunghetta che dobbiamo trovare, a livello teorico la nostra lunghetta dovrebbe essere imperniata su un ambo che non abbia un ritardo maggiore di 525 (21x25).
Eebbene si leggono tutte le 525 estrazioni a ritroso delle due ruote in esame, ogni estrazione produce 10 ambi , due ruote producono 20 ambi , gli ambi possibili con 90 numeri sono 4005 nel nostro caso se fossero usciti tutti ambi diversi avremo 525x20 che darebbe 10500 ovviamente non è possibile quindi parecchi ambi saranno usciti piu di una volta ciò non è importante quello che ho fatto è memorizzare in una collection tutti gli ambi usciti per ogni ambo uscito ho memorizzato l'ultima estrazione nella quale si è presentato.
Dopo aver analizzato le 525 estrazioni disponiamo di una collection contenete tutti gli ambi usciti in questo periodo su quelle due ruote e dato che avevamo memorizzato l'estrazione di uscita possiamo ordinare la collection per questo valore facendo in modo che l'ambo piu vecchio si trovi in cima alla posizione 1 della colection e l'ambo piu recente si trovi all'ultima posizione della colelction,.
Dopo aver fatto questo ordinamento si leggono gli ambi a partire da quello in posizione 1..
E' ovvio che uno di questi ambi sia proprio quello "base" cioè la radice della lunghetta cercata , quindi ad ogni ambo letto dalal collection provo ad aggiungere un numero alla volta , la lunghetta daclasse 2 passa a classe 3 , 4 , 5 ...ogni volta che si aggiunge un numero però oltre all'ambo base (quell odal quale siamo partiti) si avranno anche altri ambi dovuti alla presenza del nuovo numero cioè quello aggiunto, Ognuno di questi nuovi ambi viene cercato nella colelction (la ricerca è veloce perche c'è la chiave ad aiutare) se la posizione del nuovo ambo scaturito è inferiore alla posizione dell'ambo base preso in esame vuol dire che il nuovo ambo è piu vecchio di quello base e quindi la presenza del nuovo numero che abbiamo aggiunto alla lunghetta ci puo stare , al contrario se uno dei nuovi ambi prodotti ha un valore di posizione nella lista degli ambi base piu alto rispetto a quello dell'ambo base attualmente esaminato vuol dire che il nuovo ambo è piu recente di quello base in esame e qundi l'aggiunta del nuovo numero non si puo fare perche verrebbe una lunghetta con minor ritardo rispetto al ritardo dell'ambo base. quindi si prova un nuovo numero dei 90 possibili , se la lunghetta riesce a crescere di classe (da 2 passa a 3) si ripete l'operazione cercando un nuovo nuumero da aggiungere ai 3 che abbiamo individuato e si controlla se la presenza di questo quarto numero non produca ambi con ritardo piu basso rispetto al ritardo dell'ambo base se cosi fosse il numero non si puo aggiungere e se ne prova un altro , se la lunghetta cresce ancora di classe da 3 passa a 4 si ripete il tuitto con la stessa logica e se da 4 cresce e diventa di classe 5 allora eccolo li che la lunghetta è stata individuata , se cosi non è si passa all'ambo base successivo e si ripete il tutto fino a quando non si trova un ambo base al quale è stato possibile aggingere 3 numeri per farlo diventare di classe 5 individuando una lunghetta di 5 numeri per ambo con un ritardo minimo pari a quello sdell'ambo base su cui si impernia,
Il ragionamento purtroppo funziona solo in parte nel senso che è vero che riesce a trovare una lunghetta con le caratteristiche dette solo che questa lungetta non è la piu ritardata in assoluto.
probabilmente la sequenza con la quale vengono aggiunti i numeri all'ambo base per arrivare a clase 5 produce risultati differenti ( ipotizzo che aggiungere prima il numero x e poi il numero y sia diverso che aggiungere prima il numero y e poi quello x) che impediscono di trovare il valore piu alto assoluto.

Riguardo quanto detto da Joe anche io ho capito cio che hai capito tu e ritengo vero che sia meglio giocare una lunghetta che contenga il maggior numero di ambi con ritardo elevato piuttossto che una che abbia il ritardo minimo per ambo elevato.

ciao


.
 
mi sono dimenticato di fare un saluto anche a LottoTom ... che figura ... proprio lui che ha aperto il thread ..
 
Buon giorno a tutti :)

Più tardi nel pomeriggio se riesco a fare quello che ho in mente posto un abbozzo.
Si sono aperte prospettive interessanti nell evoluzione:)
A dopo.
 

Ultima estrazione Lotto

  • Estrazione del lotto
    sabato 23 novembre 2024
    Bari
    33
    80
    86
    52
    25
    Cagliari
    67
    57
    59
    05
    80
    Firenze
    31
    32
    58
    88
    77
    Genova
    40
    39
    23
    36
    81
    Milano
    28
    58
    45
    25
    38
    Napoli
    20
    82
    23
    44
    57
    Palermo
    76
    56
    88
    62
    31
    Roma
    12
    81
    59
    74
    72
    Torino
    46
    53
    72
    45
    23
    Venezia
    04
    12
    42
    64
    20
    Nazionale
    63
    44
    78
    10
    55
    Estrazione Simbolotto
    Torino
    43
    42
    12
    39
    22
Indietro
Alto