Novità

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

ragazzi buona Pasqua a tutti ..
nel frattempo chi mi puo verificare se queste sono le combinazioni piu ritardate nel periodo analizzato che si vede nell'immagine stessa
Ciao






 
ciao LuigiB

aggiornato a questa sera


5 numeri a Tutte Rit.86 ---- n. 14.8.77.33.49 okey è uguale


per 15 numeri per terno ho queste:

Rit.85 ---- n. 14.16.33.67.83.72.71.47.18.49.85.23.68.56.9
Rit.87 ---- n. 16.23.34.47.49.8.7.72.29.33.14.67.25.22.77
Rit.93 ---- n. 14.16.33.67.83.72.71.18.49.21.85.23.47.9.56



per 15 numeri ad ambo

0016 / 0016 13655 7.8.19.23.30.38.41.62.63.72.73.80.82.88.89
0016 / 0016 13623 7.8.16.19.23.30.38.41.62.72.73.80.82.88.89
0016 / 0016 13616 7.8.19.23.38.41.62.63.72.73.77.80.82.88.89
0016 / 0016 13579 7.8.19.30.33.41.42.59.62.63.73.80.82.88.89
0016 / 0016 13549 7.8.19.33.41.42.59.62.63.73.77.80.82.88.89
0016 / 0016 13535 7.8.16.19.23.27.30.38.41.62.72.73.80.88.89
0016 / 0016 13525 7.8.16.19.30.33.41.42.59.62.73.80.82.88.89
 
Ultima modifica di un moderatore:
Permutazioni(NumeroNumeri, nClasse, Optional bSenzaRipet As Boolean = True) As Long

LuigiB per cortesia per calcolare le permutazioni senza ripetizione cosa devo mettere dopo la nclasse, perché ho provato ma calcola sempre il totale delle permutazioni possobili.

grazie per una eventuale risposta
 
ecco un esempio di permutazioni sia senza sia con ripetizioni.
Lo script elabora le permutazioni dei prim 10 numeri naturali
a me rislta che i valori delle colonen totali senza ripetizioni differiscano da quelli con...

Codice:
Option Explicit
Sub Main
    Dim aColonne
    Dim k , y , sBuf
    Dim nClasse
    ReDim aNumeri (10)
    
    For k = 1 To 10
        aNumeri (k) = k
    Next
    
    nClasse = 2
    
    Scrivi "Senza ripetizioni"
    Scrivi Permutazioni ( 10 ,nClasse)
    aColonne = SviluppoPermutazioni ( aNumeri ,nClasse)
    Call ScriviColonne ( aColonne , nClasse)
    
    
    Scrivi
    Scrivi "Con ripetizioni"
    Scrivi Permutazioni ( 10 ,2,False)
    aColonne = SviluppoPermutazioni ( aNumeri ,nClasse, False)
    Call ScriviColonne ( aColonne , nClasse)
    

    
    
End Sub

Sub ScriviColonne (aColonne, nClasse)
    Dim k , y , sbuf
    
    For k = 1 To UBound(aColonne)
        sbuf = FormattaStringa( k , "0000")& ") "
        For y = 1 To nClasse
            sbuf = sbuf & Format2(aColonne(k ,y)) & "."
        Next
        Call Scrivi ( RimuoviLastChr( sbuf , "."))
    Next
End Sub
 
Buona Pasqua a Tutti/e , ai mitici Scripters intervenut,i a cominciare dal grandissimo LuigiB, e a tutti gli altri che ci leggeranno! :)
 
Ultima modifica:
Beppignello;n1966676 ha scritto:
ciao LuigiB

aggiornato a questa sera


5 numeri a Tutte Rit.86 ---- n. 14.8.77.33.49 okey è uguale


per 15 numeri per terno ho queste:

Rit.85 ---- n. 14.16.33.67.83.72.71.47.18.49.85.23.68.56.9
Rit.87 ---- n. 16.23.34.47.49.8.7.72.29.33.14.67.25.22.77
Rit.93 ---- n. 14.16.33.67.83.72.71.18.49.21.85.23.47.9.56



per 15 numeri ad ambo

0016 / 0016 13655 7.8.19.23.30.38.41.62.63.72.73.80.82.88.89
0016 / 0016 13623 7.8.16.19.23.30.38.41.62.72.73.80.82.88.89
0016 / 0016 13616 7.8.19.23.38.41.62.63.72.73.77.80.82.88.89
0016 / 0016 13579 7.8.19.30.33.41.42.59.62.63.73.80.82.88.89
0016 / 0016 13549 7.8.19.33.41.42.59.62.63.73.77.80.82.88.89
0016 / 0016 13535 7.8.16.19.23.27.30.38.41.62.72.73.80.88.89
0016 / 0016 13525 7.8.16.19.30.33.41.42.59.62.73.80.82.88.89

Ciao, sono uno degli ultimi iscritti ed in ritardo per gli auguri di Buona Pasqua, ma auguro a tutto il Forum ed al grande Luigi B una Buona Pasquetta.

Totalmente ignorante nella programmazione contemporanea, ( provengo dal vecchio ed ormai obsoleto GW-BASIC)

Sintetizzo e vengo al dunque, i dati in mio possesso hanno una discrepanza sul file ( 15 numeri x terno )

Dopo la data del 26/03/2016 la quindicina x terno più ritardata a tutte le ruote marca un R/C di 124 estrazioni !

Considerando le 11 ruote ( Nazionale-Inclusa) il ritardo attuale è di 109 estrazioni.

Se dovesse servire per un eventuale controllo metto i dati, ancora un plauso al Grande Luigi B per quanto ha messo a disposizione gratuitamente per gli appassionati del Lotto ( software che supera di gran lunga le aspettative dei programmi a pagamento )

Ciao, Nikor.
 
Grazie per la info

Vorrei solo sapere qual'e, sarebbe più corretto scriverla, almeno per un controllo

quant'è il tempo di elaborazione per ottenerla, circa?



Il tuo messaggio e' arrivato lo stesso
 
Ultima modifica di un moderatore:
ragazzi buona pasquetta a tutti , in saluto e un ringraziamento a Nikor per le parole spese sul programma :-).
Se posti le lunghette che dici con il riferimento della data alla quale sono elaborate penso possa essere utile., stiamo cercando di trovare un algorimo veloce per la ricerca ddelle lunghette e un riscontro è sempre utile.

Buona Pasquetta a tutti .. niente gita oggi qui piove :-)
 
Ciao Luigi ...

colgo l'occasione per l'augurio di una Buona Pasquetta,

aggiungendo che tutto permettendo, domani,

(su questo PC Spaziometria non funziona più e non ho altri mezzi efficienti)

controllerò e riferirirò sulla correttezza di quanto hai postato.

:) Cordiali saluti
 
Rit.124 ---- n. 07.23.49.85.41.8.51.89.82.17.47.30.33.88
---10:18:38 AM : 11:04:08 AM Lunghetta N.14 / 15...MaxMin.10 Per Terno
Rit.97 ---- n. 19.30.73.25.22.33.2.55.67.83.42.69.59.80.72
Rit.105 ---- n. 25.38.55.30.85.31.51.89.77.87.33.28.65.80.7
---10:18:38 AM : 11:08:05 AM Lunghetta N.15 / 15...MaxMin.10 Per Terno

attualmente sono arrivato a far elaborare 10000 lunghette in 3 minuti

e questi sono i risultati, sia di ritardo che di tempo impiegato

circa 4 minuti per elaborare 1 classe, qualsiasi
circa 46 minuti per elaborare tutte le lunghette da classe 3 a classe 15

il massimo riscontrato attualmente è 105.

se il 124 a cui si riferisce nikor non è quella di classe 14, e non 15,
devo purtroppo far un'altra elaborazione più profonda, con conseguente ulteriore impiego di tempo.

buona giornata.
 
Ultima modifica di un moderatore:
Per il Grande Luigi B, sono io che devo ringraziare Te!
Posto le 3 lunghette al momento più ritardate per terno a tutte (Nazionale-esclusa)

Range 130 estrazioni dal 30/05/2015 al 26/03/2016:

10-11-14-18-22-38-47-49-51-60-65-77-81-85-89 (124)
07-08-14-27-30-31-33-47-49-51-55-77-82-85-89 (124)
08-24-27-30-32-33-47-49-55-60-71-77-85-88-89 (122)

L'algoritmo usato credo sia del tipo deterministico che sfoglia tutte le possibili quindicine che si formano con i 90 numeri, mi era stato regalato da un amico tanti anni fa e non avrei la minima idea con quale linguaggio sia stato scritto, non vorrei scrivere cavolate ma mi pare che abbia a che fare con il vecchio QBasic visto che gira in ambiente Dos.

Buon pranzo a Tutti, Nikor.
 
Beppignello;n1966908 ha scritto:
Rit.124 ---- n. 07.23.49.85.41.8.51.89.82.17.47.30.33.88
---10:18:38 AM : 11:04:08 AM Lunghetta N.14 / 15...MaxMin.10 Per Terno
Rit.97 ---- n. 19.30.73.25.22.33.2.55.67.83.42.69.59.80.72
Rit.105 ---- n. 25.38.55.30.85.31.51.89.77.87.33.28.65.80.7
---10:18:38 AM : 11:08:05 AM Lunghetta N.15 / 15...MaxMin.10 Per Terno

attualmente sono arrivato a far elaborare 10000 lunghette in 3 minuti

e questi sono i risultati, sia di ritardo che di tempo impiegato

circa 4 minuti per elaborare 1 classe, qualsiasi
circa 46 minuti per elaborare tutte le lunghette da classe 3 a classe 15

il massimo riscontrato attualmente è 105.

se il 124 a cui si riferisce nikor non è quella di classe 14, e non 15,
devo purtroppo far un'altra elaborazione più profonda, con conseguente ulteriore impiego di tempo.

buona giornata.


x Beppignello : Ciao, le tue elaborazioni sono in modalità integrale o random? Da quanto scrivi mi parrebbe la seconda... ma ti chiedo conferma ;) GRAZIE

x Nikor : Benvenuto e complimenti per il tuo apporto davvero interessante. Potresti postare il codice anche se gira in ambiente dos? Forse potrebbe essere un ottimo spunto per i nostri super scripters per vedere di farne una versione per spaziometria. GRAZIE . I tuoi risultati comunque mi sembrano eccellenti. Complimenti!

Buona Pasquetta Everyone :)
 
x lottotom , no io sto lavorando sull'integrale, dalla classe 3 a salire a classe superiori, con tutti gli abbinamenti possibili.
2 parametri sono le varianti di velocità.

1) ritardo minimo
2) range, per includere o parzializzare di n.elementi di classe inferiore, per salire alla classe superiore.

faccio un esempio: 117480 terzine possibili, quante ne devo usare per salire alla classe superiore, cioè le quartine?
tutti i 117480, oppure ne parzializzo solo un tot. delle più ritardatarie, ma quante dei 117480 vanno usate?

da qui la velocità e profondità dell'esame!

poiché si passa dopo la prima creazione dei primi terni 117480, (situazione integrale) ad una situazione di
permutazioni, che è più dispendiosa in termini di tempo e di elaborazioni,(aggiungendo numero alle lunghette), le permutazioni sono maggior numero rispetto all'integrale senza ripetizione, è necessaria una sorta di filtro range del numero delle colonne integrale da usare per mantenere una specie di velocità.

Nel caso non riuscissi ad ottenere, il valore valido, è naturale che ho sbagliato qualcosa, nell'analisi e
nel funzionamento dello script.



x Nikor
non ci hai detto quante tempo hai impiegato ad ottenere quelle 3 quindicine più ritartadarie.

questo mi permetterebbe di capire subito, se sto perdendo tempo e sto combattendo con i mulini a vento.
in altro parole, ho già analizzato male il problema, e non ne verrò a capo di nulla.
 
Ultima modifica di un moderatore:
nella nuova versione di spaziometria ho potenziato la gestione dello sviluppo dei sistemi integrali.
ora per esempio è possibilesviluppare piu sistemi in parallelo (prima si poteva sviluppare un solo integrale ala volta) come in questo esempio

Codice:
Option Explicit
Sub Main
    
    
    Dim aNumeri , aCol , aSubCol
    Dim clsSvil , clsSvil2
    Dim nClasseSvil , nClasseSubSvil
    Dim i , ii
    
    
    Set clsSvil = GetMotoreSviluppoIntegrale     
    Set clsSvil2 = GetMotoreSviluppoIntegrale     
    
    nClasseSvil = 3
    nClasseSubSvil = 2
    
    aNumeri = GetANumeri
    Call clsSvil.InitSviluppoIntegrale(aNumeri ,nClasseSvil)
    Do While clsSvil.GetCombSviluppo(aCol)
        i = i +1
        Call Scrivi (FormattaStringa(i , "0000") & ") "  & StringaNumeri (aCol ))
        Call clsSvil2.InitSviluppoIntegrale(aCol ,nClasseSubSvil)
        ii =0
        Do While clsSvil2.GetCombSviluppo(aSubCol)
            ii = ii +1
            Call Scrivi (" ---> " & FormattaStringa(ii , "0000") & ") "  & StringaNumeri (aSubCol ))

        Loop
        
        If i > 10 Then Exit Do
    Loop
    
End Sub
 
nello sviluppo degli integrlai è anche possibile ottenere lo sviluppo ridotto (non riduce pero come i sistem jolla ..attenzione ...) come in questo script che sviluppa terzine a garanzia ambo

Codice:
Option Explicit
Sub Main
    
    
    Dim aNumeri , aCol , aSubCol
    Dim clsSvil , clsSvil2
    Dim nClasseSvil , nClasseSubSvil
    Dim i , ii
    
    
    Set clsSvil = GetMotoreSviluppoIntegrale     
    Set clsSvil2 = GetMotoreSviluppoIntegrale     
    
    nClasseSvil = 3
    nClasseSubSvil = 2
    
    aNumeri = GetANumeri
    Call clsSvil.InitSviluppoIntegrale(aNumeri ,nClasseSvil)
    Do While clsSvil.GetCombSviluppoRid(aCol ,2)
        i = i +1
        Call Scrivi (FormattaStringa(i , "0000") & ") "  & StringaNumeri (aCol ))
        Call clsSvil2.InitSviluppoIntegrale(aCol ,nClasseSubSvil)
        ii =0
        Do While clsSvil2.GetCombSviluppo(aSubCol)
            ii = ii +1
            Call Scrivi (" ---> " & FormattaStringa(ii , "0000") & ") "  & StringaNumeri (aSubCol ))

        Loop
        
        
    Loop
    
End Sub
 
joe , non so che problema puo esserti capitato ma non dipende di sicro da spaziometria...
 
Nikor se hai esperienze di basic gli script non differiscono poi molto .. grazie pure da parte mia per i l contributo.
 
l'algoritmo al quale ho lavorato io , non è deterministico quindi non so se sia proprio preciso ...
da testare ...


Codice:
Option Explicit
Class clsCombinazione
    Private m_UltEstUscita
    Private m_Key
    Private m_aNum
    Private m_Classe
    Private m_Index
    Private m_aBNum     
    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 IsNumeroPresente(N)
        IsNumeroPresente = m_aBNum(N)
        
        
    End Function
    
    Sub RefreshABnum
        ReDim m_abnum(90)
        Dim k
        
        For k = 1 To 90
            m_abnum(k) = False
        Next
        For k = 1 To UBound(m_aNum)
            m_abnum(m_aNum(k)) = True
        Next
    End Sub
End Class
Sub Main
    Dim collCombBase,CollLunghette,collLungTrov,nSorte,aRuote,Ini,fin,sMsg,nMoltip
    Dim nCicloTeo,nRitMax,nClasseLunghetta,nRuoteSel,nLunghetteDaTrov,nCombBaseTrov
    Dim clsComb,clsCombTmp,clsLunghette,TipoMetodo
    Dim cItem,cItemNew,sKey,nTrovate
    Dim i,nTrov,nIndexMax,bFound,k,nIniTmp
    Dim TimeStart
    
    
    TipoMetodo = 2
    
    
    nTrov = 0
    nSorte = ScegliEsito
    nClasseLunghetta = ScegliClassseLunghetta
    nRuoteSel = SelRuote(aRuote)
    nLunghetteDaTrov = Int(InputBox("Lunghette da trovare","Quantità lunghette",1))
    ReDim Preserve aRuote(nRuoteSel)
    nCicloTeo = CicloTeorico(nClasseLunghetta,nSorte,UBound(aRuote))
    nMoltip = 30
    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
    
    TimeStart = Timer
    Call Messaggio("Individua le combinazioni di classe " & nSorte & " uscite nel periodo")
    Call AlimentaCollCombUscite(collCombBase,nSorte,aRuote,Ini,fin)
    nCombBaseTrov = collCombBase.count
    Call Messaggio("Ordinamento per ritardo delle combinazioni trovate " & nCombBaseTrov)
    Call OrdinaItemCollection(collCombBase,"UltEstUscita","Key",,1)
    Call Messaggio("Imposta posizioni classifica ritardi")
    Call ImpostaPosizioni(collCombBase,nIndexMax)
    
    
    sMsg = "Le combinazioni base di classe " & nSorte
    sMsg = sMsg & " (uscite nel periodo analizzato di " & nRitMax & " estrazioni) "
    sMsg = sMsg & " sono " & nCombBaseTrov
    sMsg = sMsg & " sulle ruote " & StringaRuote(aRuote)    
    Call Scrivi(sMsg)
    Call Scrivi
    
    
    Set collLungTrov = GetNewCollection
    
    i = 0
    nTrovate = 0
    For Each clsComb In collCombBase
        i = i + 1    
    
        
        Call Messaggio("Radice " & clsComb.GetStringaNum & " Pos " & clsComb.Index & "/" & nIndexMax & " (" & i & "/" & nCombBaseTrov & ")")
        If TipoMetodo = 1 Then
            bFound = InitCercaLunghetta(collCombBase,clsComb,nSorte,nClasseLunghetta,CollLunghette,collLungTrov)
        ElseIf TipoMetodo = 2 Then
            bFound = InitCercaLunghetta2(collCombBase,clsComb,nSorte,nClasseLunghetta,CollLunghette,collLungTrov)
            
        End If
        If bFound Then nTrovate = nTrovate + 1
        'If collLungTrov.count >= nLunghetteDaTrov Then Exit For
        If nTrovate >= nLunghetteDaTrov Then Exit For
            

        
        Call AvanzamentoElab(1,nCombBaseTrov,i)
        If ScriptInterrotto Then Exit For
    Next
    For Each clsComb In collLungTrov
        Call Scrivi(clsComb.GetStringaNum & " -- " & clsComb.UltEstUscita & " - Rit " & RitardoCombinazioneTurbo(aRuote,clsComb.aNum,nSorte,fin))
    Next
    
    Call Scrivi("Tempo di elaborazione : " & FormattaSecondi(Timer - TimeStart))
End Sub
Function InitCercaLunghetta(collCombBase,cItemBase,nSorte,nClasseLunghetta,collLunghette,collLungTrov)


    Dim nClasseTmp,nTrovate,nDaFare,nFatte,IndexBase
    Dim aNumSvil,aCol,aColNew,N,sKey,cItem,cItemNew,cItemTmp,bValida,CollTmp
    Set collLunghette = GetNewCollection
    
    
    
    
    IndexBase = cItemBase.Index
    
        nClasseTmp = nSorte + 1
        For N = 1 To 90
            
            aNumSvil = cItemBase.anum
            'If PuntiSuArray(aNumSvil,aN) = 0 Then
            If cItemBase.IsNumeroPresente(N) = False Then
    
                bValida = True
                Call InitSviluppoIntegrale(aNumSvil,nSorte - 1)
                Do While GetCombSviluppo(aCol)
                    aColNew = aCol
                    ReDim Preserve aColNew(nSorte)
                    aColNew(nSorte) = N
                    Call OrdinaMatriceTurbo(aColNew,1)
                    sKey = "k" & StringaNumeri(aColNew,,True)
                    
                    If GetItemCollection(collCombBase,sKey,cItem) Then
                        If cItem.Index > IndexBase Then
                            bValida = False
                            Exit Do
                        End If
                    End If
                Loop
                If bValida Then
                    ReDim Preserve aNumSvil(nClasseTmp)
                    aNumSvil(nClasseTmp) = N
                    Call OrdinaMatriceTurbo(aNumSvil,1)
                    Set cItem = New clsCombinazione
                    cItem.Index = IndexBase
                    cItem.aNum = aNumSvil
                    Call cItem.RefreshABnum
                    'collLunghette.Add cItem
                    sKey = "k" & StringaNumeri(aNumSvil,,True)

                    Call AddItemColl(collLunghette,cItem,sKey)

        
                End If
            End If
            
            
            
            
        Next
        
        Do While nClasseTmp < nClasseLunghetta
            nClasseTmp = nClasseTmp + 1
            Set CollTmp = GetNewCollection
            nTrovate = 0    
            nDaFare = collLunghette.count    
            nFatte = 0
             For Each cItem In collLunghette
                For N = 1 To 90
                    
                    aNumSvil = cItem.aNum
                    'If PuntiSuArray (aNumSvil  , aN) = 0 Then
                    If cItem.IsNumeroPresente(N) = False Then
                        bValida = True
                        Call InitSviluppoIntegrale(aNumSvil,nSorte - 1)
                        Do While GetCombSviluppo(aCol)
                            aColNew = aCol
                            ReDim Preserve aColNew(nSorte)
                            aColNew(nSorte) = N
                            Call OrdinaMatriceTurbo(aColNew,1)
                            sKey = "k" & StringaNumeri(aColNew,,True)
                            
                            If GetItemCollection(collCombBase,sKey,cItemTmp) Then
                                If cItemTmp.Index > IndexBase Then
                                    bValida = False
                                    Exit Do
                                End If
                            End If
                        Loop
                        If bValida Then
                            ReDim Preserve aNumSvil(nClasseTmp)
                            aNumSvil(nClasseTmp) = N
                            Call OrdinaMatriceTurbo(aNumSvil,1)
                            Set cItemNew = New clsCombinazione
                            cItemNew.Index = IndexBase
                            cItemNew.aNum = aNumSvil
                            Call cItemNew.RefreshABnum
                            sKey = "k" & StringaNumeri(aNumSvil,,True)

                            If AddItemColl(CollTmp,cItemNew,sKey) Then
                            
                                nTrovate = nTrovate + 1
                            End If
                        End If

                    End If
                Next
                'nFatte = nFatte + 1
                'Call AvanzamentoElab(1,nDaFare,nFatte)
                If ScriptInterrotto Then Exit Do
            
            Next
            If nTrovate = 0 Then Exit Do
            If ScriptInterrotto Then Exit Do
            Set collLunghette = CollTmp
            
        Loop        
                
        If nTrovate > 0 Then
            For Each cItem In collLunghette
                Set cItemNew = New clsCombinazione
                cItemNew.aNum = cItem.aNum
                cItemNew.Classe = cItem.Classe
                cItemNew.Index = cItem.Index
                cItemNew.UltEstUscita = cItem.UltEstUscita
                
                collLungTrov.Add cItemNew
            Next
            InitCercaLunghetta = True
        End If
        
End Function
Function InitCercaLunghetta2(collCombBase,cItemBase,nSorte,nClasseLunghetta,collLunghette,collLungTrov)

    Dim cItemTmp,cItemTmp2,IndexBase,aNumBase,aNumTmp,aColNew
    Dim CollTmp,cItemNew,cItem,sKey,nTrovate
    Dim k,y,i
    Dim nClasseTmp,collLunghetteTmp,aCol,bValida
    
    Set collLunghette = GetNewCollection
    collLunghette.Add cItemBase
    
    IndexBase = cItemBase.Index
    aNumBase = cItemBase.aNum
    nTrovate = 0
    
    
    
    nClasseTmp = nSorte
    Do While nClasseTmp < nClasseLunghetta
        nTrovate = 0
        Set collLunghetteTmp = GetNewCollection
        ReDim abLunghUsate(collCombBase.count)
        For Each cItem In collLunghette
            aNumBase = cItem.aNum
            i = 0
            For Each cItemTmp In collCombBase
                i = i + 1
                If Not abLunghUsate(i) Then
                    abLunghUsate(i) = True
                    If cItemTmp.Index <= IndexBase Then
                        aNumTmp = cItemTmp.aNum
                        If PuntiSuArray(aNumBase,aNumTmp) = nSorte - 1 Then
                            
                            ReDim aB(90)
                            For k = 1 To nSorte
                                aB(aNumTmp(k)) = True
                            Next
                            For k = 1 To UBound(aNumBase)
                                aB(aNumBase(k)) = True
                            Next
                            Call ArrayBNumToArrayNum(aB,aColNew)
                            Call InitSviluppoIntegrale(aColNew,nSorte)
                            bValida = True
                            Do While GetCombSviluppo(aCol)
                                sKey = "k" & StringaNumeri(aCol,,True)
                                If GetItemCollection(collCombBase,sKey,cItemTmp2) Then
                                    If cItemTmp2.Index > IndexBase Then
                                        bValida = False
                                        Exit Do
                                    End If
                                End If
    
                            Loop
                            
                            If bValida Then
                                'abLunghUsate ( i) = True
                                Set cItemNew = New clsCombinazione
                                cItemNew.Index = IndexBase
                                cItemNew.aNum = aColNew
                                Call cItemNew.RefreshABnum
                                sKey = "k" & StringaNumeri(aColNew,,True)
                
                                If AddItemColl(collLunghetteTmp,cItemNew,sKey) Then
                                            
                                    nTrovate = nTrovate + 1
                                End If
                            End If
                        End If
                    Else
                        Exit For     
                    End If
                End If
            Next
            
        Next
        If nTrovate > 0 Then
                Set collLunghette = collLunghetteTmp
                nClasseTmp = nClasseTmp + 1
        Else
                Exit Do
        End If
        
    Loop
    
    If nClasseTmp = nClasseLunghetta Then
        For Each cItem In collLunghette
            Set cItemNew = New clsCombinazione
            cItemNew.aNum = cItem.aNum
            cItemNew.Classe = cItem.Classe
            cItemNew.Index = cItem.Index
            cItemNew.UltEstUscita = cItem.UltEstUscita
            collLungTrov.Add cItemNew
        Next
        InitCercaLunghetta2 = True
    End If
End Function
Sub ImpostaPosizioni(coll,nRetIndexMax)
    Dim i,nLastEstUscita,clsComb
    i = 0
    nLastEstUscita = 0
    For Each clsComb In coll
        If clscomb.UltEstUscita <> nLastEstUscita Then
            i = i + 1
        End If
        nLastEstUscita = clscomb.UltEstUscita
        clsComb.Index = i
    Next
    nRetIndexMax = i
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
        clsComb.RefreshABnum
        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 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
Function FormattaSecondi(s)
    'Questa Function trasforma il numero di secondi passato come parametro in una stringa
    ' passando i secondi si ottengono ore  minuti e secondi  in formato hh:mm:ss
    ' s ---> Numero di secondi da formattare
    ' ritorna una stringa il cui formato è hh:mm:ss (la function non funziona se in totale abbiamo piu di 99 ore )
    Dim hh
    Dim Mm
    Dim Ss
    Dim TimeStr
    hh = s \ 3600
    Mm =(s Mod 3600) \ 60
    Ss = s -((hh * 3600) +(Mm * 60))
    TimeStr = Format2(hh) & ":" & Format2(Mm) & ":" & Format2(Ss)
    FormattaSecondi = TimeStr
End Function
 

Ultima estrazione Lotto

  • Estrazione del lotto
    sabato 26 ottobre 2024
    Bari
    40
    49
    13
    21
    10
    Cagliari
    59
    02
    49
    26
    40
    Firenze
    01
    48
    74
    76
    78
    Genova
    39
    32
    76
    35
    14
    Milano
    86
    59
    85
    36
    17
    Napoli
    34
    11
    65
    47
    86
    Palermo
    35
    90
    44
    87
    85
    Roma
    19
    70
    45
    84
    76
    Torino
    86
    37
    53
    88
    56
    Venezia
    68
    66
    26
    65
    85
    Nazionale
    29
    08
    53
    56
    41
    Estrazione Simbolotto
    30
    07
    29
    22
    24
Indietro
Alto