Spaziometria - ritardi di rigo

[skygirl]

LuigiB bellissimo script grazie, mi piace moltissimo l'opzione che ha inserito nel menù a tendina relativamente alle istruzioni, è un'ottima cosa che tutti gli script dovrebbero avere, uno script chiaro è uno strumento di analisi perfetto

un saluto

 

[LuigiB]

ciao Sky .. grazie ..

 

[Joe91]

Ciao Luigi.

Buon giorno a tutte//i.

Mi permetto di dissentire ... in parte.

Il tuo script ha innegabili pregi ed è meritevole dei complimenti ricevuti,

tuttavia alcuni problemini li ha o li presenta.

E' lento.

Incompleto ... per evitare di esssere, ancora più lento.

In pratica, interrompe il conteggio ad 80, per evitare di consumare ulteriori risorse.

Mentre ... i ritardi di rigo crescono in maniera quasi esponenziale ... fino al massimo possibile.

Questo succede, per la mancanza di occasioni, in cui avere anche solo "una" possibilità di cadere.

Un esempio:

Se il ritardo normalmente non raggiunge le 210 estrazioni,

è molto improbabile che, un numero, cada nel rigo 210.

Dunque ... il ritardo del rigo 210 ... cresce all'infinito.

Ne consegue che il resoconto del tuo script pur essendo ordinato in seconda colonna,

nella prima (colonna) elenca quasi ... in ordine inverso,

i ritardi di rigo come se fossero altrettante possibilità di gioco.

Ovvero li trasforma in opportunità di gioco.

Il miglior caso ad 80 / il secondo a 79 / il terzo a 78 ... ecc.

Quasi-quasi eliminando (riducendo) l'alea.

Dove questo 80/79/78/77... ecc. perde la capacità d'essere, dato statistico,

diventa risultato di scelte "piuttosto dirette" di chi ha redatto lo script.

Ovvero del limite "80".

La proposta attuale ... riferirebbe, preferibile, il caso in cui

il Ritardo di Rigo sarebbe di 530 Estrazioni con 17 presenze.

In sintesi questo ipotetico "miglior numero" uscirebbe 17 volte in 5249 estrazioni.

Così stando le cose, sembrerebbe che, si sia caduti, noi, nel costruendo "trappolone".

Chiedo naturalmente venia ... sapendo che tu capisci, lo spirito, con cui ho scritto,

terminando questa critica (quasi pura). Anche se ho già elencato in parte delle soluzioni,

secondo me utili a migliorare il risultato già raggiunto,

occorrerebbe ... che NON ci fosse un "indice di convenienza"

inteso come "rapporto lineare puro" perchè

NON c'è proporzione e linearità "nelle possibiità reali".

Piuttosto invece, penso, potrebbe essere utile che esso considerasse anche il livello

(ovvero) le differenti di "occasioni di caduta"

che diminuiscono drasticamente con l'aumentare del ritardo di rigo.

Ora "capisco" che taluni possano giustamente pensare/asserire:

ma allora perchè invece di "criticare" non agisci. Questo è Giusto!

Ma questo è anche-anche un pochino complicato.

Dunque ... dico subito: Io individuerei come caso esemplare ed esplicativo

Il ritardo di rigo 15 ... (con 36 Estrazioni di Ritardo di Rigo all'estrazione dell' 11/08/2016)

e 562 cadute nei 5249 concorsi avvenuti per la ruota di FIRENZE.

Come è scritto, per un colpo, poi eventualmente, il Rigo rimane, la Ruota anche,

... degli Estratti che di tanto in tanto, vi transitano, qualcuno cadrà.

Ora ... questa possibilità è concessa al 27.

Vedrò in seguito di motivare meglio, questa mia scelta ed indicazione, confidando

venga confermata sia dal calcolo elettronico ... che, per chi di turno... dal responso.

Cordiali saluti.

 

[LuigiB]

Ciao Joe , ci mancherebbe che io non accetti le critiche ...
E' un po' lento ciò dipende dal fatto che per ogni estrazione deve ricalcolare i l tab analitico e questo lo fa attraverso la funzione preposta ,come sai si tratta di un 'operazione abbastanza pesante ,ineffetti si potrebbe evitare facendo in modo che lo script si calcoli da solo il suo tabellone analitico cosi che ad ogni nuova estrazione analizzata lo possa aggiornare e non ricalcolare (la cosa che mi fa dubbi è che il tutto poi sarebbe comunque in vbscript quindi lento per definizione tuttavia la minor quantita di operazioni dovrebbe dare lo stesso piu velocita volendo si potrebbe poi compilare lo script per guadagnare ancora) .
Questo naturalmente richiede un maggiore sforzo di scrittura codice nello script per fargli fare da solo cio che attualmente fa la funzione GeneraAnalitico.

Il fatto che gestisca solo 80 righe si puo cambiare molto facilmente nel codice ci sono una serie di preimpostazione di valori proprio a inizio script, è chiaro che mettendolo a 200 diventa molto molto lento per i motivi suddetti , io l'ho messo ad 80 anche per via del discorso che fai tu , da certe righe in su i ritardi sono matematici ..raramente quelle righe contengono numeri e se non li contengono di certo non si possono sfaldare dando luogo a ritardi che si incrementano ad ogni colpo.. avrai notato che nel codice questa cosa sebbene remmata io l'avevo gestita .. in pratica non conteggiavo i ritardi dele righe vuote poi l'ho remmata perche cosi facendo non venivano i risultati mostrati con l'esempio di Genova a ritardo 1050 col rigo 65 .. certo secondo me era molto piu logico e giusto contare solo i ritardi delle righe che in quel momento potevano sfaldarsi perche contenenti numeri , e ti dirò visto il tipo di gioco di estratto secco bisognava anche gestire i ritardi
per le righe con un numero , con due numeri , con tre e fino a 5 .. in pratica ogni riga poteva avere 5 ritardi differenti a noi interessava il ritardo relativo alla presenza di un solo numero per supportare il gioco con una statistica piu precisa.

Nell'analisi delle giocate , per individuare il numero da giocare attualmente viene scelto il rigo contenete nello spazio ruota un solo numero , tale rigo è quello con l'indice di convenienza piu alto, un suo senso dalle prove empiriche pare averlo , usando la progressione ho visto che non si va mai in perdita certo non vale la pena di stare 2/3 mesi per vincere 30 euro ... ahahah ..
ma questo era ovvio ancora prima di fare lo script poco ma sicuro ..

Ciao

 

[Joe91]

No Title

Ciao Luigi ...

Vedo che avevi capito benissimo ... il senso di quell' 80 che ho virgolettato.

Pertanto è tutto giusto quanto scrivi.

Dunque tralasciamo "la questione tempo" ... che si risolve come dici anche e solo a livello di script.

(Come vedi elaboro fino a 250 di RDR ((tre volte tanto 80) / in metà della metà del tempo))

Un problema ... di razionalità e difficoltà nella gestione del rendiconto ...

è quello che elenchi nell'ultima parte del tuo messaggio.

Ma "qui": "ratio" e "rendiconto" paiono aspetti marginali rispetto al "trovare" qualcosa da giocare.

Tralascierei anche questo, e se sei daccordo,

riporterei "alla centralità" della trattazione il "ritardo di rigo".

Cordiali saluti.

 

[Joe91]

No Title

Allego dunque

l'immagine di un confronto tra le 2 differnti soluzioni adottate.

Sostanzialmente si "autoconfermano" vicendevolmente

In tutto tranne per il conteggio delle "Presenze".

Occorre capirne la causa ANCHE con il confronto ottenibile da altri eventuali algoritmi.

Anche se Luigi ha già ipotizzato le ragioni di un possibile "perchè".

Faccio notare che ho escluso la Nazionale ... ma sono elencate,

verticalmente solo 9 RUOTE ... perchè come ha scritto Luigi

Venezia attualmente non offre "possibilità di gioco".

 

[LuigiB]

allora Joe visto che la nostra è una fucina di idee per il lotto intanto ecco qui uno script che dimostra come agire sull'aspetto velocità creando il tab analitico in modo dinamico.
Dalle mie prove risulta essere quasi 4 volte piu veloce ..
il prossimo step è inserirlo nello script di analisi , per ora lo mostro separato per far capire meglio a tutti ... cioè a tuti quelli che sono interessati all'aspetto codice ..
a me sembra funzionare.. se adotti la tu perizia per confermarmelo Joe mi faresti felice

ciao

Option Explicit
Dim aEstrTA
Sub Main
    ' questo esempio dimostra la creazioen del tabellone analitico in modo dinamico aggiornandolo
    ' ad ogni estrazione e non ricalcolandolo daccapo come avverrebeb se usassimo la funzione genera analitico
    Dim Ini,Fin,k
    Dim TipoAlgoritmo ' 0 = interno ,1 usa la funzione preposta GeneraAnaliticoTurbo
    Dim nTimerStart
    
    nTimerStart = Timer
    
    Ini = EstrazioneIni
    Fin = EstrazioneFin
    TipoAlgoritmo = ScegliAlgoritmo
    If TipoAlgoritmo = 0 Then
        InitTabAnalitico Ini,Fin
        For k = Ini To Fin
            Call AggiornaTabAna(k)
            Call AvanzamentoElab(Ini,Fin,k)
        Next
    Else
        For k = Ini To Fin
            Call GeneraAnaliticoTurbo(k)
            Call AvanzamentoElab(Ini,Fin,k)
        Next
        InitTabAnalitico Fin,Fin

    End If
    
    Scrivi "Secondi : " & Timer - nTimerStart
    Scrivi
    
    
    OutputTabAnalitico(Fin)
End Sub
Function ScegliAlgoritmo
    Dim aV
    aV = Array ("Getito dallo script" ,"Funzione GeneraAnaliticoTurbo")
    ScegliAlgoritmo = ScegliOpzioneMenu ( aV , 0)
End Function
Sub AggiornaTabAna(idEstr)
    Dim k,r,e,i
    Dim aNum,aBNum,nElim,nLimite
    nLimite = idEstr - 230
    For r = 1 To 12
        If r <> 11 Then
            Call GetArrayNumeriRuota(idEstr,r,aNum)
            If aNum(1) > 0 Then
                aBNum = ArrayNumeriToBool(aNum)
                nElim = 0
                ' k = idEstr To idEstr -230 Step -1
                k = idEstr
                For e = 1 To 5
                    aEstrTA(k,r,e) = aNum(e)
                Next
                Do While nElim < 5 And k >= nLimite
                    k = k - 1
                    For e = 1 To 5
                        If aBNum(aEstrTA(k,r,e)) Then
                            aEstrTA(k,r,e) = 0
                            nElim = nElim + 1
                            'If nElim = 5 Then Exit For
                        End If
                    Next
                Loop
            End If
            'Next
        End If
    Next
End Sub
Sub OutputTabAnalitico(idEstr)
    Dim k,r,e,i
    Dim sRiga,pRiga,s
    Dim nLenRiga
    nLenRiga =(3 * 5 * 11) + 35
    sRiga = Space(nLenRiga)
    pRiga = 35
    For r = 1 To 12
        If r <> 11 Then
            Call MidX(sRiga,NomeRuota(r),pRiga)
            pRiga = pRiga + 15
        End If
    Next
    Call Scrivi(sRiga,True)
    For k = 230 To 0 Step - 1
        i = idEstr - k
        sRiga = Space(nLenRiga)
        pRiga = 35
        For r = 1 To 12
            If r <> 11 Then
                For e = 1 To 5
                    If aEstrTA(i,r,e) > 0 Then
                        s = Format2(aEstrTA(i,r,e))
                    Else
                        s = "--"
                    End If
                    Call MidX(sRiga,s,pRiga)
                    If e = 5 Then
                        Call MidX(sRiga,"|",pRiga + 2)
                    Else
                        Call MidX(sRiga,".",pRiga + 2)
                    End If
                    pRiga = pRiga + 3
                Next
            End If
        Next
        Call MidX(sRiga,GetInfoEstrazione(i),1)
        Call MidX(sRiga," - R " & FormatSpace(k,3,True) & " |",25)
        Call Scrivi(sRiga)
        'Call Scrivi( GetInfoEstrazione (i) & " - R " & FormatSpace(k ,3,True) & " |" & sRiga)
    Next
End Sub
Sub InitTabAnalitico(Inizio,Fine)
    Dim k,r,e,i
    ReDim aEstrTA(Fine,12,5)
    Call GeneraAnaliticoTurbo(Inizio)
    For k = 230 To 0 Step - 1
        i = Inizio - k
        For r = 1 To 12
            If r <> 11 Then
                For e = 1 To 5
                    aEstrTA(i,r,e) = CInt(TabelloneAnaliticoTurbo(k,r,e))
                Next
            End If
        Next
    Next
End Sub

 

[Joe91]

Mhmhmhm ... Si

Tuttavia scrisse DeGregori:

"Tra il bufalo e locomotiva,

la differenza salta agli occhi:

La locomotiva ha la strada segnata.

Il bufalo può scartare di lato ...

... col mio nome firmai,

e il mio nome era Bufalo Bill"

Che lottologicamente si legge:

Non calcolo il Tabellone Analitico.

Comunque sia, si anche così ... é più veloce.

Non per mancanza di volontà ma per la difficoltà intrinseca

del controllare elaborati a questo liìvello di complessità ...

... riservo di verificare alcune cose "meglio" se ci riesco.

Comunque penso sia utile provare a completare secondo quanto hai scritto.

Se i risultati di questa tua nuova versione saranno uguali

essa sarà sicuramente giusta e se più veloce anche migliore e completa.

BRAVO

 

[LuigiB]

un altro sistema ancora piu veloce e adatto a come si sono messe le cose potrebbe essere quello di tralasiciare il tab Analitico e calcolare semplicemente i ritardi dei numeri.
Poi considerare quei numeri che al tale ritardo sono soli e non in compagnia.
Da ritardo di riga diventerebbe "ritardo del ritardo quando il numero è da solo"
Dico dato a come si sono messe le cose perche cosi facendo automaticamente sarebbe come contare solo le "righe piene" e il famoso ritardo 1050 non sarebbe di 1050 ...

 

[Joe91]

Come detto ho controllato ancora con una terzo ... ed altro programma.

Con questo si conferma ESATTO anche il "Ritardo Storico 60" (qui, nella colonna RitardoMax).

Mentre il programma citato elenca 562 PRESENZE.

Quindi anch'esso pone maggiore accento "sul rigo"

lasciando in subordine gli altri soggetti indifferentemente siano essi Estratti / Ambi ecc.

Quindi se cade un Ambo ... i 2 numeri protempore presenti nel rigo paiono

da intendersi conteggiati come 2 Estratti Caduti.

Anche la differenza (562-542) pare doversi attribuire alla presenza di 20 Ambi.

...........................

Possiamo dunque procedere ad un passaggio successivo:

Dal mio script : 591+604+562+..... / 10 E' la presenza media nelle 10 ruote.

(Dallo script di Luigi sarebbero i numeri nel rettangolo verde 542+614+574+...+600 / 9.

Abbiamo detto mancare Venezia).

Questa Media è caratteristica per questo Rigo.

Ed ogni "Rigo" ha una sua media caratteristica.

11) ... 800

12) ... 737

13) ... 670

14) ... 660

Eccoci dunque al poter formulare "ad occhio" il pronostico che s'era detto

basato su un "Ritardo di Rigo" elevato nel suo contesto ...

supportato dall'ulteriore mancanza di presenze nel lunghissimo periodo.

Di bello c'è ... che tutto quanto qui s'è assunto forfettariamente .... può essere calcolato.

 

[Joe91]

Ok ... Luigi.

Si, quasi.

Quando cade un numero (e sono solo 5)

se ha il ritardo idoneo "azzera" quel determinato rigo.

 

[i legend]

Ciao joe ,l uigi. Al rigo 15 Milano è prossimo allo storico . 11 colpi. In più i numer sono 3. Sarebbe utile valutare il rit anche per tre numeri per estratto ed ambo . Bravissimi ciao a tutti . Tempo fa sfruttai Ritsincdiliv scegliendo il livello è ne calcoli gli storici. Ma non era velocissimo.

 

[Joe91]

Ciao I legend.

Vero anche questo ... ho scelto ed evidenziato, un rigo ... meritevole d'attenzione.

 

[Joe91]

Buona sera a tutte/i.

Ho scritto:

562 cadute nei 5249 concorsi avvenuti per la ruota di FIRENZE

e ... tutto quanto qui s'è assunto forfettariamente ... può essere calcolato.

Quindi contando gli estratti sul rigo 15 abbiamo una sequenza:

1.2.2.1.1.3.2.2.3.0

Sommati 17

1.7 Mediati

Ma avevamo detto che potremmo calcolarli essere

TEORICAMENTE 2.1214 per ogni ruota

Quindi 2.1214 / 18 * 5249 = 619 Estratti Teorici

Mancano all'appello 57.

Ed è lo scompenso che s'era evidenziato sommariamente.

 

[LuigiB]

Ciao a tutti , nonostante l'avvicinarsi del ferragosto qui su Lottoced si lavora lo stesso..
Come sapete io sono piu focalizzato sull'aspetto codice che sull'aspetto delle statistiche dove c'è chi è piu competente di me.
Quindi il mio scopo era cercare di velocizzare lo script precedente-
A tale scopo ho implementato la soluzione della creazioene dinamica del tab analitico
e come promesso e dopo aver verificato oro posto il nuovo script
lo script ineffetti diventa piu veloce di 3 volte e piu tuttavia rimane sempre alle 80 righe.
settoo script lo posto solo per completezza infatti ingloba lo script di esempio postato in preced
Oltre a detto script ne posto ancora un altro , questo secondo e nuovo script i ritardi di rigo li calcola in tut'altro modo , infatti è sempre tre volte piu veloce ma questa volta calcola 250 righe
di piu non è certo necessario...

Buon ferragosto a tutti !

primo script

Option Explicit
Dim cIdRit,cIdRitMax,cIdFreq    
Dim aEstrTA

Sub Main
    
    
    Select Case ScegliProcedura
    Case 0
        ScriviIstruzioni
    Case 1
        VisualizzaProgressione
    Case 2
        Call Analisi(True)
    Case 3
        Call Analisi(False)

    End Select

    

    
End Sub
Sub InitTabAnalitico(Inizio,Fine)
    Dim k,r,e,i
    ReDim aEstrTA(Fine,12,5)
    Call GeneraAnaliticoTurbo(Inizio)
    For k = 230 To 0 Step - 1
        i = Inizio - k
        For r = 1 To 12
            If r <> 11 Then
                For e = 1 To 5
                    aEstrTA(i,r,e) = TabelloneAnaliticoTurbo(k,r,e)
                Next
            End If
        Next
    Next
End Sub

Sub AggiornaTabAna(idEstr)
    Dim k,r,e,i
    Dim aNum,aBNum,nElim,nLimite
    nLimite = idEstr - 230
    For r = 1 To 12
        If r <> 11 Then
            Call GetArrayNumeriRuota(idEstr,r,aNum)
            If aNum(1) > 0 Then
                aBNum = ArrayNumeriToBool(aNum)
                nElim = 0
                ' k = idEstr To idEstr -230 Step -1
                k = idEstr
                For e = 1 To 5
                    aEstrTA(k,r,e) = aNum(e)
                Next
                Do While nElim < 5 And k >= nLimite
                    k = k - 1
                    For e = 1 To 5
                        If aBNum(aEstrTA(k,r,e)) Then
                            aEstrTA(k,r,e) = 0
                            nElim = nElim + 1
                            'If nElim = 5 Then Exit For
                        End If
                    Next
                Loop
            End If
            'Next
        End If
    Next
End Sub

Sub Analisi(bEseguiAnalisi)
    Dim Ini,Fin,idEstr,nRit,nRuota,nDaFare,nFatte,p,n,k,nSfald,bValida,sNum,bMostraSoloRigheConNimeri,sTmp
    
    Dim cMaxRigo,cSorte
    
    Dim nCapitaleImpegnato,nTotVincita,nIndiceConvMin,nPostaIniziale,nPercGuadagno,nPrimaEstrGioco,nColpiProgressione
    Dim nNumInGioc,nRuotaInGioc,nRetIC,nIdProg,nGiocateTot,bSuperataProg,nMassimaEspos,nVincitaParz,nRetIdRigo,nRetRitRigo
    ReDim aPoste(0)
    ReDim aRetRigheProgr(0)
    Dim aBNumEstrSucc
    Dim t
    
        
    
    cIdRit = 0
    cIdRitMax = 1
    cIdFreq = 3
    cMaxRigo = 80
    cSorte = 1
    nIdProg = 0
    nGiocateTot = 0
    bSuperataProg = False
    
    
    
    
    Ini = EstrazioneIni
    Fin = EstrazioneFin
    nDaFare = Fin -(Ini - 1)
    
    If bEseguiAnalisi Then
        nColpiProgressione = CInt(InputBox("Inserire la quantita di colpi potenziali per la progressione","Colpi progressione",90))
        nIndiceConvMin = CInt(InputBox("Inserire un valore intero per l'indice di convenienza minimo al quale la giocata viene eseguita","IcMin",5))
        nPostaIniziale = CInt(InputBox("Inserire la posta per la prima giocata","Posta",1))
        nPercGuadagno = CInt(InputBox("Inserire la percentuale di guadagno minima per calcolare la progressione","Percentuale guadagno",10))
        nPrimaEstrGioco = CInt(InputBox("Inserire la prima estrazione dalla quale iniziare a giocare deve essere un numero compreso tra Inizio e fine Range","Prima estr giocabile",Fin - 100))
        
        If VerificaParametriGioco(Ini,Fin,nPrimaEstrGioco,nPercGuadagno,nPostaIniziale,nIndiceConvMin,nColpiProgressione) = False Then Exit Sub
        
        Call GetVettoreProgressione(1,1,1,nColpiProgressione,aPoste,aRetRigheProgr,1,1,0,nPercGuadagno,nPostaIniziale)
    End If
        
    
    ReDim abRuote(12)
    If ScegliRuote(Nothing,abRuote) <= 0 Then
        MsgBox "Ruote non selezionate",vbCritical
        Exit Sub
    End If
    t = Timer
    Call InitTabAnalitico(Ini,Fin)
    
    ReDim aRitPerRigo(cMaxRigo,12,3)
    
    For idEstr = Ini To Fin - 1
        ReDim aNum(5)
        'Call GeneraAnaliticoTurbo(idEstr)
        Call AggiornaTabAna(idEstr)
        nFatte = nFatte + 1
        
        ' blocco analisi giocate ==============================
        If bEseguiAnalisi Then

            If idEstr >= nPrimaEstrGioco And bSuperataProg = False Then
                If GetNumeroDaGiocare(idEstr,aRitPerRigo,nFatte,nIndiceConvMin,nNumInGioc,nRuotaInGioc,nRetIC,nRetIdRigo,nRetRitRigo) Then
                    nIdProg = nIdProg + 1
                    If nIdProg <= nColpiProgressione Then
                        nGiocateTot = nGiocateTot + 1
                        sTmp = FormatSpace(nGiocateTot,5) & " - "
                        sTmp = sTmp & GetInfoEstrazione(idEstr) & " Num : " & Format2(nNumInGioc) & " "
                        sTmp = sTmp & SiglaRuota(nRuotaInGioc)
                        sTmp = sTmp & " I.C. : " & FormatSpace(nRetIC,5,True)
                        sTmp = sTmp & " Rigo : " & FormatSpace(nRetIdRigo,5,True)
                        sTmp = sTmp & " Ritardo : " & FormatSpace(nRetRitRigo,5,True)
                        sTmp = sTmp & " Costo : " & aPoste(nIdProg)
                        
                        Call Scrivi(sTmp)
                        nCapitaleImpegnato = GetCapitaleImpegnato(nIdProg,aRetRigheProgr)
                        If nCapitaleImpegnato > nMassimaEspos Then nMassimaEspos = nCapitaleImpegnato
                        
                        If VerificaGiocata(idEstr + 1,nNumInGioc,nRuotaInGioc) Then
                            nVincitaParz = GetVincitaNetta(nIdProg,aRetRigheProgr)
                            nTotVincita = nTotVincita + nVincitaParz
                            sTmp = "VINCENTE ! Vinti : " & nVincitaParz
                            sTmp = sTmp & " Max Esposizione : " & nMassimaEspos
                            sTmp = sTmp & " Esposizione corrente : " & nCapitaleImpegnato
                            sTmp = sTmp & " TotVincita : " & nTotVincita
                                                        
                            Call Scrivi(sTmp,True,,vbYellow,vbRed)
                            nIdProg = 0
                        End If
                    Else
                        Scrivi "Superati i limiti della progressione impostata. Termine analisi"
                        bSuperataProg = True
                    End If
                End If
            End If
        End If
        '======================================================
        For nRuota = 1 To 12
            If nRuota <> 11 And abRuote(nRuota) Then
                Call GetArrayNumeriRuota(idEstr + 1,nRuota,aNum)
                'ReDim aBNumEstrSucc(90)
                'For p = 1 To 5
                '    aBNumEstrSucc(aNum(p)) = True
                'Next
                aBNumEstrSucc = ArrayNumeriToBool(aNum)

                For nRit = 0 To cMaxRigo
                    nSfald = 0
                    'bValida = False
                    For p = 1 To 5
                        'n = TabelloneAnaliticoTurbo(nRit,nRuota,p)
                        n = TabelloneAnaliticoInterno(idEstr,nRit,nRuota,p)

                        'If n >0 Then bValida = True
                        If n > 0 Then
                            If aBNumEstrSucc(n) Then
                                nSfald = nSfald + 1
                            End If
                        End If
                    Next
                    'If bValida Then
                        If nSfald >= cSorte Then
                            If aRitPerRigo(nRit,nRuota,cIdRit) > aRitPerRigo(nRit,nRuota,cIdRitMax) Then
                                aRitPerRigo(nRit,nRuota,cIdRitMax) = aRitPerRigo(nRit,nRuota,cIdRit)
                            End If
                            aRitPerRigo(nRit,nRuota,cIdRit) = 0
                            aRitPerRigo(nRit,nRuota,cIdFreq) = aRitPerRigo(nRit,nRuota,cIdFreq) + 1
                        Else
                            aRitPerRigo(nRit,nRuota,cIdRit) = aRitPerRigo(nRit,nRuota,cIdRit) + 1
                        End If
                    'End If
                    If ScriptInterrotto Then Exit For
                Next
            End If
            
            If ScriptInterrotto Then Exit For
        Next
        
        
        
        Call AvanzamentoElab(1,nDaFare,nFatte)
        If ScriptInterrotto Then Exit For

    Next
    
    If bEseguiAnalisi Then
        Call Scrivi
        Call Scrivi("Giocate eseguite    : " & nGiocateTot)
        Call Scrivi("Massima esposizione : " & nMassimaEspos)
        Call Scrivi("Vincita netta       : " & nTotVincita)
        Call Scrivi

        
    End If

    
    ReDim aV(7)
    aV(1) = "Rigo"
    aV(2) = "Ritardo"
    aV(3) = "RitardoMax"
    aV(4) = "Frequenza"
    aV(5) = "Ruota"
    aV(6) = "NumPresRigoAttuale"
    aV(7) = "IndiceConv"

    'Call GeneraAnaliticoTurbo(Fin)
    Call AggiornaTabAna(Fin)

    
    Messaggio "Creazione tabella"
    If MsgBox("Mostrare solo le righe  alla cui posizione nel tab analitico sono effettivamente presenti dei numeri ?",vbQuestion + vbYesNo) = vbYes Then
        bMostraSoloRigheConNimeri = True
    End If
    DoEventsEx
    
    Call InitTabella(aV)
    For nRuota = 1 To 12
        If nRuota <> 11 And abRuote(nRuota) Then
            For k = 0 To cMaxRigo
                aV(1) = k
                aV(2) = aRitPerRigo(k,nRuota,cIdRit)
                aV(3) = aRitPerRigo(k,nRuota,cIdRitMax)
                aV(4) = aRitPerRigo(k,nRuota,cIdFreq)
                aV(5) = NomeRuota(nRuota)
                
                sNum = ""
                For p = 1 To 5
                    'n = TabelloneAnaliticoTurbo(k,nRuota,p)
                    n = TabelloneAnaliticoInterno(Fin,k,nRuota,p)

                    sNum = Iif(n > 0,sNum & n & ".",sNum)
                Next
                sNum = RimuoviLastChr(sNum,".")
                bValida = False
                If bMostraSoloRigheConNimeri Then
                    If sNum <> "" Then bValida = True
                Else
                    bValida = True
                End If
                If bValida Then
                    aV(6) = sNum
                    aV(7) = Round(Dividi(aRitPerRigo(k,nRuota,cIdRit),Dividi(nFatte,aRitPerRigo(k,nRuota,cIdFreq))),3)

                    Call AddRigaTabella(aV)
                End If
            Next
        End If
    Next        
    
    
    Call Scrivi("Inizio : " & GetInfoEstrazione(Ini))
    Call Scrivi("Fine   : " & GetInfoEstrazione(Fin))


    Call CreaTabella(2)
    
    Call Scrivi(Timer - t)
End Sub
Function GetCapitaleImpegnato(nIdProg,aRigheProgr)

    ReDim aV(0)
    Call SplitByChar(aRigheProgr(nIdProg),"|",aV)
    GetCapitaleImpegnato = CDbl(Trim(aV(4)))
    
End Function

Function GetVincitaNetta(nIdProg,aRigheProgr)

    ReDim aV(0)
    Call SplitByChar(aRigheProgr(nIdProg),"|",aV)
    GetVincitaNetta = CDbl(Trim(aV(7)))
    
End Function

Function VerificaGiocata(idEstr,nNumGiocato,nRuota)
    Dim k
    ReDim aNum(0)
    Dim aBNum
    Dim bRet
    
    bRet = False
    Call GetArrayNumeriRuota(idEstr,nRuota,aNum)
    aBNum = ArrayNumeriToBool(aNum)

    'For k = 1 To 5
'        If aNum(k) = nNumGiocato Then
'            bRet = True
'            Exit For
'        End If
'    Next
'    VerificaGiocata = bRet

    VerificaGiocata = aBNum(nNumGiocato)
End Function


Function GetNumeroDaGiocare(idEstr,aRitPerRigo,nFatte,nIndiceConvMin,nRetNumInGioc,nRetRuotaInGioc,nRetIC,nRetIdRigo,nRetRitRigo)

    Dim k,p,nQ,n,nIc,nRuota,nIndiceConvTrov,nNumDaGioc
    
    nIndiceConvTrov = nIndiceConvMin
    nRetNumInGioc = 0
    nRetRuotaInGioc = 0
    nRetIC = 0
    nRetIdRigo = 0
    nRetRitRigo = 0

    
    For k = LBound(aRitPerRigo) To UBound(aRitPerRigo)
        For nRuota = 1 To 12
            If nRuota <> 11 Then
                nIc = Round(Dividi(aRitPerRigo(k,nRuota,cIdRit),Dividi(nFatte,aRitPerRigo(k,nRuota,cIdFreq))),3)
                If nIc >= nIndiceConvTrov Then
                    nQ = 0
                    nNumDaGioc = 0
                    For p = 1 To 5
                        'n = TabelloneAnaliticoTurbo(k,nRuota,p)
                        n = TabelloneAnaliticoInterno(idEstr,k,nRuota,p)

                        If n > 0 Then
                            nNumDaGioc = n
                            nQ = nQ + 1
                            If nQ > 1 Then Exit For
                        End If
                    Next
                    If nQ = 1 Then
                        nRetNumInGioc = nNumDaGioc
                        nRetRuotaInGioc = nRuota
                        nIndiceConvTrov = nIc
                        nRetIC = nIndiceConvTrov
                        nRetIdRigo = k
                        nRetRitRigo = aRitPerRigo(k,nRuota,cIdRit)
                    End If
                End If
            End If
        Next

    Next
    
    GetNumeroDaGiocare = nRetNumInGioc > 0
    
    
End Function

Function ScegliProcedura()
    Dim aVoci
    
    aVoci = Array("Istruzioni","Visualizza progressione","Analisi + statistica","Solo statistica")
    ScegliProcedura = ScegliOpzioneMenu(aVoci,0)
End Function
Sub ScriviIstruzioni
    Dim sTesto
    
    sTesto = "Lo script analizza i ritardi di rigo del tabellone analitico all'interno del range impostato" & vbCrLf
    sTesto = sTesto & "nel programma." & vbCrLf
    sTesto = sTesto & "Possono essere analizzate tutte le ruote ma non si puo scegliere la ruota TUTTE" & vbCrLf
    
    sTesto = sTesto & "Un rigo del tabellone analitico si sfalda se all'estrazione successiva sulla stessa  ruota esce" & vbCrLf
    sTesto = sTesto & "uno dei numeri in esso contenuti" & vbCrLf
    
    Call Scrivi(sTesto)
    
    sTesto = "Al termine dell'analisi verra mostrata una tabella con la situazione attuale ovvero quella che" & vbCrLf
    sTesto = sTesto & "si configura nel momento dell'estrazione identificata come fine range analizzato." & vbCrLf
    
    Call Scrivi(sTesto)
    
    
    sTesto = "E' anche possibile analizzare la strategia di gioco indicando da quale estrazione all'interno del" & vbCrLf
    sTesto = sTesto & "range analizzato iniziare a giocare." & vbCrLf
    sTesto = sTesto & "A tale scopo bisogna fornire i parametri per il calcolo della progressione da applicare." & vbCrLf
    sTesto = sTesto & "Indicando un valore minimo per l' INDICE DI CONVENIENZA lo script giochera il numero" & vbCrLf
    sTesto = sTesto & "presente nel rigo con l'indice di convenienza piu alto maggiore o uguale al minimo previsto." & vbCrLf
    sTesto = sTesto & "N.B verranno considerati e giocate solo le righe del Tab analitico nel cui spazio si trovi un solo numero." & vbCrLf
    sTesto = sTesto & "Ovvero verra giocato il rigo con indice di convenienza piu alto in cui sia presente un solo numero." & vbCrLf
    sTesto = sTesto & "Se durante l'analisi delle giocate si superano i colpi previsti dalla progressione il gioco sarà interrotto con perdita." & vbCrLf
    sTesto = sTesto & "e verrà interrotta l'analisi sulle giocate mentre la statistica continuera fino alla fine." & vbCrLf
    

    Call Scrivi(sTesto)
    
    

    sTesto = "Per cercare di non andare in perdita è opportuno impostare un congruo numero di colpi per la progressione" & vbCrLf
    sTesto = sTesto & "da usare. Questo prevede di avere a disposizione un discreto capitale da investire per ricavare somme" & vbCrLf
    sTesto = sTesto & "modeste per non dire irrisorie in confronto al capitale esposto al rischio." & vbCrLf
    

    Call Scrivi(sTesto,True,,,vbRed)
    
    

    


    

End Sub
Sub VisualizzaProgressione

    Dim nPostaIniziale,nPercGuadagno,nColpiProgressione,k
    ReDim aPoste(0)
    ReDim aRetRigheProgr(0)
    

    
    
    
    
    
    
    
    nColpiProgressione = CInt(InputBox("Inserire la quantita di colpi potenziali per la progressione","Colpi progressione",5))
    nPostaIniziale = CInt(InputBox("Inserire la posta per la prima giocata","Posta",1))
    nPercGuadagno = CInt(InputBox("Inserire la percentuale di guadagno minima per calcolare la progressione","Percentuale guadagno",10))
    
    If nColpiProgressione > 0 And nPostaIniziale > 0 And nPercGuadagno > 0 Then
        Call GetVettoreProgressione(1,1,1,nColpiProgressione,aPoste,aRetRigheProgr,1,1,0,nPercGuadagno,nPostaIniziale)
        
        For k = 0 To UBound(aRetRigheProgr)
            Call Scrivi(aRetRigheProgr(k))
        Next
    Else
        MsgBox "Parametri non validi",vbCritical
    End If

End Sub

Function VerificaParametriGioco(Ini,Fin,nPrimaEstrGioco,nPercGuadagno,nPostaIniziale,nIndiceConvMin,nColpiProgressione)
    Dim sMsg
    
    sMsg = ""
    If nPrimaEstrGioco < Ini Or nPrimaEstrGioco > Fin Then
        sMsg = "Prima estrazione di gioco non valida"
            
    End If
    If nPercGuadagno <= 0 Or nPercGuadagno > 100 Then
        sMsg = "Percentuale di guadagno sul capitale impiegato non valida"
    End If
    If nPostaIniziale <= 0 Then
        sMsg = "Posta iniziale non valida"
    End If
    If nIndiceConvMin <= 0 Then
        sMsg = "Indice convenienza minimo non valido"
    End If
    If nColpiProgressione <= 0 Then
        sMsg = "Impostare il numero di colpi per la progressione"
    End If

    If sMsg <> "" Then
        MsgBox sMsg,vbCritical
    Else
        VerificaParametriGioco = True
    End If
    

End Function

Function TabelloneAnaliticoInterno(IdEstr,Rit,nRuota,nPos)

    Dim i
    
    i = IdEstr - Rit
    TabelloneAnaliticoInterno = aEstrTA(i,nRuota,nPos)
    
End Function

secondo script

Option Explicit
Sub Main
    Dim Ini,Fin
    Dim r,k,e,n,nRit,nSfald,bMostraSoloRigheConNumeri,cMaxRigo,sNum,bValida
    ReDim aRt(1)
    ReDim aNumRuota(5)
    Dim aBNumRuota
    Dim t
    Dim cIdRit,cIdRitMax,cIdFreq
    Dim nFatte
    cMaxRigo = 250
    cIdRit = 0
    cIdRitMax = 1
    cIdFreq = 2
    t = Timer
    ReDim aRitPerRigo(cMaxRigo,12,2)
    Ini = EstrazioneIni
    Fin = EstrazioneFin
    nFatte = Fin -(Ini)
    For r = 1 To 12
        If r <> 11 Then
            ReDim aN(90)
            aRt(1) = r
            Call GetRitardoEstratti(aRt,Ini - 1,aN)
            For k = Ini To Fin - 1
                ReDim aTa(cMaxRigo,5)
                
                Call GetArrayNumeriRuota(k,r,aNumRuota)
                If aNumRuota(1) > 0 Then
                    aBNumRuota = ArrayNumeriToBool(aNumRuota)
                    For n = 1 To 90
                        If aBNumRuota(n) Then
                            aN(n) = 0
                        Else
                            aN(n) = aN(n) + 1
                        End If
                        If aN(n) <= cMaxRigo Then
                            If aTa(aN(n),0) < 5 Then
                                aTa(aN(n),0) = aTa(aN(n),0) + 1
                                aTa(aN(n),aTa(aN(n),0)) = n
                                
                            End If
                        End If
                    Next
                    For nRit = 0 To cMaxRigo
                        If aTa(nRit,0) > 0 Then
                            nSfald = 0
                            Call GetArrayNumeriRuota(k + 1,r,aNumRuota)
                            aBNumRuota = ArrayNumeriToBool(aNumRuota)
                            For e = 1 To aTa(nRit,0)
                                If aBNumRuota(aTa(nRit,e)) Then
                                    nSfald = nSfald + 1
                                    Exit For
                                End If
                            Next
                            If nSfald > 0 Then
                                If aRitPerRigo(nRit,r,cIdRit) > aRitPerRigo(nRit,r,cIdRitMax) Then
                                    aRitPerRigo(nRit,r,cIdRitMax) = aRitPerRigo(nRit,r,cIdRit)
                                End If
                                aRitPerRigo(nRit,r,cIdRit) = 0
                                aRitPerRigo(nRit,r,cIdFreq) = aRitPerRigo(nRit,r,cIdFreq) + 1
                            Else
                                aRitPerRigo(nRit,r,cIdRit) = aRitPerRigo(nRit,r,cIdRit) + 1
                            End If
                        Else
                            aRitPerRigo(nRit,r,cIdRit) = aRitPerRigo(nRit,r,cIdRit) + 1
                        End If
                    Next
                End If
            Next
        End If
        Call AvanzamentoElab(1,12,r)
    Next
    ReDim aV(7)
    aV(1) = "Rigo"
    aV(2) = "Ritardo"
    aV(3) = "RitardoMax"
    aV(4) = "Frequenza"
    aV(5) = "Ruota"
    aV(6) = "NumPresRigoAttuale"
    aV(7) = "IndiceConv"
    Call GeneraAnaliticoTurbo(Fin)
    Messaggio "Creazione tabella"
    If MsgBox("Mostrare solo le righe  alla cui posizione nel tab analitico sono effettivamente presenti dei numeri ?",vbQuestion + vbYesNo) = vbYes Then
        bMostraSoloRigheConNumeri = True
    End If
    DoEventsEx
    Call InitTabella(aV)
    For r = 1 To 12
        If r <> 11 Then
            For k = 0 To cMaxRigo
                aV(1) = k
                aV(2) = aRitPerRigo(k,r,cIdRit)
                aV(3) = aRitPerRigo(k,r,cIdRitMax)
                aV(4) = aRitPerRigo(k,r,cIdFreq)
                aV(5) = NomeRuota(r)
                sNum = ""
                For e = 1 To 5
                    n = TabelloneAnaliticoTurbo(k,r,e)
                    sNum = Iif(n > 0,sNum & n & ".",sNum)
                Next
                sNum = RimuoviLastChr(sNum,".")
                bValida = False
                If bMostraSoloRigheConNumeri Then
                    If sNum <> "" Then bValida = True
                Else
                    bValida = True
                End If
                If bValida Then
                    aV(6) = sNum
                    aV(7) = Round(Dividi(aRitPerRigo(k,r,cIdRit),Dividi(nFatte,aRitPerRigo(k,r,cIdFreq))),3)
                    Call AddRigaTabella(aV)
                End If
            Next
        End If
    Next
    Call Scrivi("Inizio : " & GetInfoEstrazione(Ini))
    Call Scrivi("Fine   : " & GetInfoEstrazione(Fin))
    Call CreaTabella(2)
    Scrivi Timer - t
End Sub

 

[Joe91]

No Title

Ciao Luigi.

Ho provato questo tuo secondo script.

E' molto migliorato.

Riporto per chi avesse interesse l'immagine di una semplice analisi grafica.

Da quest risulta piuttosto evidente quanto avevamo detto.

All' aumentare del rigo ...

aumenta il valore del ritardo attuale

e le due serie di risultati diventano correlate.

Sono (quasi) amplificazione/compressione l'una dell'altra.

Cordiali saluti.

 

[i legend]

Ciao a tutti Luigi anche senza pc studio i tuoi script che sono eccezionali realmente
Adesso proverò a capire la logica del secondo

Bravissimi.

Joe se ti va anche senza postare lo script ( ....) spiegheresti il ragionamento con cui hai affrontato il problema ?

Ciao e grazie in ogni caso .

P.s

Condivido pienamente quanto scritto da luigi.
L aspetto più interessante è il codice e la logica con cui si affrontano e si trovano le soluzioni.

 

[LuigiB]

ciao Legend .. questo script si basa sui ritardi degli estratti , ad ogni estrazione aggiorna il ritardo dei 90 numeri e colloca ogni numero nella specifica riga del tabellone (quella del suo ritardo)
dopodiche analizza il tabellone per verificare gli sfaldamenti sull'estrazione successiva.

buon ferragostoa tutti

 

[Beppignello]

E' possibile secondo voi, aggiungere qualche colonna in output, con questi dati

Presenze teoriche al ritardo
Presenze riscontrate
Diff

 

[Joe91]

No Title

Ciao Ilegend.

E' esattamente quello che scrive Luigi.

Se lo script funziona, cioè produce risultati esatti e corrispondenti a quelli richiesti / desiderati / auspicati ...

Significa che: problema, soluzione, risultato sono stati correttamente tradotti in un algoritmo risolutivo.

Quindi "il problema" è stato descritto / affrontato / capito ... risolto

Eppoi la soluzione, ovvero l'algoritmo risolutivo, è stato codificato correttamente.

In sintesi l'esecuzione dello script ... fornisce un risultato "corretto".

Quindi la descrizione che Luigi ha scritto nel messaggio precedente ... "nella sostanza"

deve essere identica a tutte quelle delle soluzioni risolutive (e naturalmente) "esatte".

Dunque l'unica differenza può essere sul "come".

Luigi ha codificato secondo lo schema classico appoggiandosi al TabelloneAnalitico.

Io no.

Ma nella sostanza ... sono la stessa cosa.

Solo che alla domanda "quando?" nella risposta

Luigi fa premettere ... sul tabellone analitico ...

Io invece controllo che il lottrone caduto sia "idoneo".

Poi ci sono differenze di calcolo e di interpretazione ma è altro discorso.

Non scendo nel dettaglio perchè non hai Pc per controllare.

Ed un confronto vero e degno di tale appellativo è anche difficile da realizzare.

Ho provato comunque a restringere il confronto al calcolo di una sola ruota, (Firenze)

la velocita di analisi del mio algoritmo è circa 7 volte piu veloce.

3.26 contro 22.8 secondi.

Quindi siamo a circa 7 volte ... Va detto però che io non ho conteggiato lo storico.

Neppure l'indice di equità.

Stimo ... per essi si debba aggiungere 1 secondo.

Cordiali saluti.

PS: x Beppignello. E' quanto ho già tracciato al messaggio #34,

dove c'è già un esempio di calcolo.

scrivendo ... che è tutto "controllabile" attraverso formule e calcoli.