PROGRAMMA SPAZIOMETRIA

[LuigiB]

Alt !

La funzione non finisce certo li ... magari provate ad intuire ciò che faremo ma limitatevi a scrivere il codice richiesto.

Correggi e inserisci i Dim per le variabili che usi e soprattutto non valorizzare nRitDiLiv ... non ci siamo ancora arrivati

 

[Joe91]

Ciao Luigi ....

Secondo me c'è "un nocciolo" ... al centro della questione.

Se non si spiega o si intuisce cosa esso sia e cosa rappresenti, ovvero ... come considerarlo,

ad uno script funzionante ... si può arrivare solo per tentativi e/o dietro le tue istruzioni (se non si parte ... per la tangente).

Scriviamo una piccola regola: il RITARDO DI LIVELLO è semplicissimo.

E' un RITARDO che si inizia a contare dopo un determinato evento.

Ovvero per quanto banale possa sembrare ... da "quando inizia".

Poi come tutti i ritardi (correnti) è tale da un certo numero di estrazioni

(per quante esse siano: zero / uno / trentuno / cento ...)

Dicendolo essere un valore finito ed attuale ... diciamo 10 per semplicità.

Chiaro e facile intuire che ... è iniziato 10 estrazioni orsono.

Esattamente come diremo che il ritardo del numero "X" nella ruota "Y" è 10.

Ma questo inizio ... in genere ... non lo conosciamo ... ed "è quello" che dobbiamo calcolare.

Supponiamo fosse iniziato "una Estrazione dopo" ... ora sarebbe solo 9 e quella dopo ancora 8 ...

poi 7 fino al minimo di zero se fosse appena estratto.

Ora se fosse "10" alla estrazione 9010 chiaro che è iniziato alla 9000 ...

Sapendo solo che "è presente" alla 9010 ... si deve retrocedere ...alla 9009 poi alla 9008 poi alla 9007

verificando di volta in volta "se inizia" ... e s'arriva alla 9000.

Avendo contato queste "10 Estrazioni" in cui "questo ritardo" è presente.

Diciamo che il ritardo attuale (RDL) è 10.

Quindi retrocedendo ... possiamo conteggiare il suo valore attuale.

Qui si confluisce in quanto hai scritto ... si retrocede nel numero di estrazioni (vero zero) e

ad ogni retrocessione aumenta di una unità il "Ritardo di Livello" ...

fino a quando non è il suo "inizio" e dunque si è calcolato il valore numerico

con cui si rappresenta il suo ritardo attuale.

 

[LuigiB]

ciao Joe come avevo detto all'inizio il ritardo di livello è il numero di estrazioni durante le quali un numero rimane in compagnia degli stessi numeri se ra in compagnia oppure il numero di estrazioni che rimane da solo se era solo.
Quindi noi dobbiamo contare queste estrazioni

siamo partiti dall'ultimo ritardo conosciuto del numero .
abbiamo visto quanti numeri sono allo stesso ritardo al punto 0 ovvero all0estrazione di ricerca.

ora dobbiamo contare per quante estrazioni permane la condizione della stessa quantita di numeri
insieme al numero che cerchiamo noi.

Per farlo si fa un ciclo decrescente che parte dall'estrazione di ricerca -1 e che va verso 1.
Ad ogni iterazione si ricalcola il vettore dei ritardi , si decrementa di un unita il ritardo iniziale
si conta quanti sono i numeri a questo ritardo.
Se la quantita di numeri p uguale a quella memorizzata al punto 0 allora si incrementa il valore nRitLiv, senno si esce dal ciclo

al termine del ciclo si valorizza il risultato della funzione.

vediamo di completare la funzione con queste indicazioni

 

[i legend]

Function RitSincDiLiv(NumAnalizzato,Ruota,IdEstr,nRetLivello)
    ' NumAnalizzato : numero da analizzare lo passa l'utente
    ' Ruota         : passata dall'utente
    ' IdEstrazione  : inizio ricerca passato dall'utente
    ' nRetLivello   : lo valorizza questa funzione è il livello a cui appartiene NumAnalizzato
    Dim nRitDiLiv
    Dim aRit(90)
    Dim ritNum
    Dim qNumRit
    '============================================
    ' qui devi scrivere il tuo codice
    Call GetRitardoEstratti(aRit,Ruota,IdEstr)
    ritNum = GetRitNum(aRit,NumAnalizzato)
    qNumRit = GetQNumAlRit(aRit,ritNum)
    '============================================
    ' la funzione torna il ritardo di livello di un numero su una ruota
    RitSincDiLiv = nRitDiLiv
End Function
Sub GetRitardoEstratti(aRit,Ruota,IdEstr)
    Dim Num
    For Num = 1 To 90
        aRit(Num) = EstrattoRitardoTurbo(Ruota,Num,1,IdEstr)
    Next
End Sub
Function GetRitNum(aRit,Num)
    GetRitNum = aRit(Num)
End Function
Function GetQNumAlRit(aRit,nRitCercato)
    Dim idR,Pres
    Pres = 0
    For idR = 1 To UBound(aRit)
        If aRit(idR) = nRitCercato Then
            Pres = Pres + 1
        End If
    Next
    GetQNumAlRit = Pres
End Function

Ciao
Si prosegue?
Scusate ma connettersi al sito e scrivere un messaggio è un impresa anche dal pc

 

[LuigiB]

bravissimo Legend !
Ora si continua con la funzione , la spiegazione l'ho data sopra ma quello che ti/vi chiedo adesso
è solo implementare questo altro pezzetto , la parte sxcritta in rosso e sottolineata

ora dobbiamo contare per quante estrazioni permane la condizione della stessa quantita di numeri
insieme al numero che cerchiamo noi.

Per farlo si fa un ciclo decrescente che parte dall'estrazione di ricerca -1 e che va verso 1.

 

[Joe91]

bravissimo Legend !
Ora si continua con la funzione , la spiegazione l'ho data sopra ma quello che ti/vi chiedo adesso
è solo implementare questo altro pezzetto , la parte sxcritta in rosso e sottolineata

ora dobbiamo contare per quante estrazioni permane la condizione della stessa quantita di numeri
insieme al numero che cerchiamo noi.

Per farlo si fa un ciclo decrescente che parte dall'estrazione di ricerca -1 e che va verso 1.

Buona sera a tutte/i.

Questo mio nuovo aggiornamento è necessariamente molto simile a quello di ILegend.

Contempla la nuova richiesta di Luigi ed integra alcune istruzioni utili per il controllo del funzionamento.

I dati PROVVISORI controllati sono quelli del Ritatrdo corrente della coppia sincrona milanese

facente capo al 71 come evidenziato da Silop al messaggio 530.

Sub Main
Dim NumAnalizzato
Dim Ruota
Dim IdEstr
Dim nRetLivello
NumAnalizzato = 71
Ruota = MI_
IdEst = 9053
Scrivi "Valore Controllo = Ritardo  = " & RitSincDiLiv(NumAnalizzato,Ruota,IdEstr,nRetLivello)
End Sub
Function RitSincDiLiv(NumAnalizzato,Ruota,IdEstr,nRetLivello)
' NumAnalizzato : numero da analizzare lo passa l'utente
' Ruota            : passata dall'utente
' IdEstrazione  : inizio ricerca passato dall'utente
' nRetLivello   : valorizza in questa funzione è Ritardo Corrente di  livello  del Numero
Dim nRitDiLiv
Dim aRit(90)
Dim ritNum
Dim Ini,Fin,Es
Dim qNumRit
'============================================
' qui devi scrivere il tuo codice
Call GetRitardoEstratti(aRit,Ruota,IdEstr)
ritNum = GetRitardoNumero(aRit,NumAnalizzato)
qNumRit = GetQNumAlRit(aRit,ritNum)
Ini = IdEstr - ritNum : Fin = IdEstr - 1 'Campo Esistenza
Scrivi "Da " &  Ini & " al " & Fin & " Ritardo " & ritNum & " Isocroni " & qNumRit
For Es = Fin To Ini Step - 1
nRitDiLiv = nRitDiLiv + 1
Next
'============================================
' la funzione torna il ritardo di livello di un numero su una ruota
RitSincDiLiv = ritNum '<<<< DATO PROVVISORIO VALIDO SOLO PER DEBUG.
End Function
Sub GetRitardoEstratti(aRit,Ruota,idEstr)
Dim N
'Rit(1) dovra' contenere il ritardo del numero 1 sulla Ruota Ruota all'estrazione IdEstr
'aRit(90) dovra' contenere il ritardo del numero 90 sulla Ruota Ruota all'estrazione IdEstr
'le posizioni dalla 2 alla 89 seguono lo stesso concetto..
For N = 1 To 90
aRit(N) = EstrattoRitardoTurbo(Ruota,N,1,idEstr)
Next
End Sub
Function GetRitardoNumero(aRit,NumCerc)
'E' una funzione che  ...[con i parametri dell'array aRit
'cioè quelli calcolati con la funzione GetRitardoEstratti(aRit,Ruota,idEstr)] ...
'ritorna il ritardo di un determinato numero.
GetRitardoNumero = aRit(NumCerc)
End Function
Function GetQNumAlRit(aRit,nRitCercato)
'E'  una funzione che torna la QUANTITA' di numeri ad un dato ritardo.
Dim N,K
For N = 1 To 90
If aRit(N) = nRitCercato Then K = K + 1
Next
GetQNumAlRit = K
End Function

Buona lettura.

 

[i legend]

Option Explicit
Sub Main
    Dim idestr
    Dim NumAnalizzato
    Dim Ruota
    Dim RitNum
    Dim Pres
    Dim nRitDiLiv,Rit
    Dim nRetLivello
    idestr = EstrazioneFin
    NumAnalizzato = 41
    For Ruota=1 To 10 'Ruota = BA_
    Rit= EstrattoRitardoTurbo(Ruota,NumAnalizzato,1,EstrazioneFin)
    nRitDiLiv = RitSincDiLiv(NumAnalizzato,Ruota,idestr,nRetLivello)
    Scrivi NumAnalizzato & " _>" & SiglaRuota(Ruota) & "   RitC=" & format2(Rit )&"  RSL: "&Format2(nRitDiLiv)
 Next
End Sub
Function RitSincDiLiv(NumAnalizzato,Ruota,IdEstr,nRetLivello)
    ' NumAnalizzato : numero da analizzare lo passa l'utente
    ' Ruota         : passata dall'utente
    ' IdEstrazione  : inizio ricerca passato dall'utente
    ' nRetLivello   : lo valorizza questa funzione è il livello a cui appartiene NumAnalizzato
    Dim nRitDiLiv
    Dim aRit(90)
    Dim ritNum,ritNum1
    Dim qNumRit,qNumRit1
    Dim Estr
    '============================================
    ' qui devi scrivere il tuo codice
    Call GetRitardoEstratti(aRit,Ruota,IdEstr)
    ritNum = GetRitNum(aRit,NumAnalizzato)
    qNumRit = GetQNumAlRit(aRit,ritNum)
    ritNum1 = ritNum
    nRitDiLiv=0
    For Estr = IdEstr - 1 To 1 Step - 1
        Call GetRitardoEstratti(aRit,Ruota,Estr)
        ritNum1 = ritNum1 - 1
        qNumRit1 = GetQNumAlRit(aRit,ritNum1)
        If qNumRit1 = qNumRit Then
            nRitDiLiv = nRitDiLiv + 1
        Else
            Exit For
        End If
    Next
    '============================================
    ' la funzione torna il ritardo di livello di un numero su una ruota
    RitSincDiLiv = nRitDiLiv
End Function
Sub GetRitardoEstratti(aRit,Ruota,IdEstr)
    Dim Num
    For Num = 1 To 90
        aRit(Num) = EstrattoRitardoTurbo(Ruota,Num,1,IdEstr)
    Next
End Sub
Function GetRitNum(aRit,Num)
    GetRitNum = aRit(Num)
End Function
Function GetQNumAlRit(aRit,nRitCercato)
    Dim idR,Pres
    Pres = 0
    For idR = 1 To UBound(aRit)
        If aRit(idR) = nRitCercato Then
            Pres = Pres + 1
        End If
    Next
    GetQNumAlRit = Pres
End Function

Ciao a tutti come al solito joe fa in due righe quello che io se lci riesco lo faccio in 20
Joe ti ammiro
Con il ciclo che faccio mi trovo un rls -1 rispetto spaziometria devo guardare dove sbaglio, ciao a tutti anche se dopo joe posto la mia
per essere corretto ed imparare

 

[Joe91]

Ciao controllo ...

ma da quel che lrggo il tuo script è gia completo!

Buona serata.

ps.: non è etto che sbagli

 

[LuigiB]

ottimo ! Bravi tutti e due , Joe si è attenuto alla mia richiesta di scrivere solo il ciclo anche se si è avvataggiato scrivendo gia la linea che incrementa la variabile nRitDiLiv , Legend invece ha preso le mie istruzioni alla lettera ed ha fatto piu del richiesto , in questi casi se uno ha fatto bene rimane solo da fargli i complimenti,
L'erroe del +-1 forse dipende dal resto del tuo script infatti nel mio test con la mia sub main i risultati sono identici,
Ora ti manca di valorizzare il parametro che ritorna il livello del numero , inoltre alcune righe si possono comprimere anche se per chiarezza di lettura vanno bene anche cosi .
ad esempio la funzione GetRitNum non servirebbe .. si puo usare direttamente l'array e cosi altre cose .. solo che ho dovuto seguire esigenze di spiegazione.



host immagini

 

[LuigiB]

spero che da questo esempio che riguarda un caso specifico avrete capito come crearsi degli strumenti (sub e function) poi aiuti nello scopo finale...
Mike non so se ci hai seguito .. ti è chiaro ora che lo script è stato completamente sviluppato grazie a Joe e Legend ?

 

[Mike58]

Si Vi ho seguito, anche se non ho partecipato, purtroppo con gli script (fatti a pezzi) con tante funzioni vado un po' in confusione, comunque vedrò di sperimentare da me il tutto,

Bravo per stimolo a i legend in questo è una potenza.

Grazie a te e joe .

 

[i legend]

Ciao Luigi ,Grazie
Ciao Mike ,Grazie
Ora provo a verificare dove sbaglio e se riesco a comprimere il codice.
NretLivello non ho capito cos'è,Mi spiace se mi spieghi cerco di ricavarlo.....
Ciao Joe Grazie
ciao a tutti

P,s: Sarebbe bello alla fine vedere lo sviluppo con il codice ottimizzato
al massimo.E da qui grazie a voi che imparo e mi migliore, grazie di cuore

 

[Joe91]

Salutando e rirngraziando tutte/i ...

La soluzione che avevo ipotizzato perchè più consona ed utile allo sfruttare tutto il lavoro preparatorio

era quella che consiste nell' utilizzarlo ... reiteratamente.

Come ha accennato Luigi essa sarà un poco più lenta, di uno script (ben orientato/ottimizzato)

ma è molto comoda e con questa soluzione si ottiene il risultato, senza dover scrivere altro codice.

Praticamente è un copia incolla, delle "tre linee" che sono già al centro, dello script e della funzione.

Dunque utilizzo questa "terna di istruzioni" per avere "la quantità" di numeri sincroni,

così da poterli utilizzare "come riferimento".

Poi ...cambiando SOLO il numero di estrazione ... controllo ... dove questa QUANTITA' di sincroni cambia.

In sintesi si è "trovato" il "Ritardo di Livello" ... ovvero

il Ritardo Corrente in cui è avvenuta questa "mutazione di quantità". Il cambio di livello.

Ecco lo script ... con una Sub Main per poter controllare ... gli stessi esempi già descritti precedentemente:

Ho riportato anche la grafica di riferimento che Silop ci aveva gentilmente fornito.

Sub Main
Dim NumAnalizzato
Dim Ruota
Dim IdEstr
Dim nRetLivello
NumAnalizzato = 71
Ruota = MI_
IdEst = 9053
Scrivi "RitDiLiv = " & RitSincDiLiv(NumAnalizzato,Ruota,IdEstr,nRetLivello)  
End Sub
Function RitSincDiLiv(NumAnalizzato,Ruota,IdEstr,nRetLivello)
' NumAnalizzato : numero da analizzare lo passa l'utente
' Ruota         : passata dall'utente
' IdEstrazione  : inizio ricerca passato dall'utente
' nRetLivello   : valorizza in questa funzione è Ritardo Corrente di  livello  del Numero
Dim nRitDiLiv
Dim aRit(90)
Dim RitNum
Dim Ini,Fin,Es
Dim qNumRit

'Terna Istruzioni
'============================================
Call GetRitardoEstratti(aRit,Ruota,IdEstr)
RitNum = GetRitardoNumero(aRit,NumAnalizzato)
qNumRit = GetQNumAlRit(aRit,RitNum)
'============================================

Scrivi "Data Rif = " & DataEstrazione (IdEstr)
Scrivi "Numero   = " & NumAnalizzato
Scrivi "Ruota    = " & NomeRuota (Ruota)
Scrivi "Ritardo  = " & RitNum
Scrivi "Sincroni = " & qNumRit

Ini = IdEstr - RitNum : Fin = IdEstr - 1 'Campo Esistenza

For Es = Fin To Ini Step - 1

nRitDiLiv = nRitDiLiv + 1

'============================================
Call GetRitardoEstratti(aRit,Ruota,Es)
RitNum = GetRitardoNumero(aRit,NumAnalizzato)
If qNumRit <> GetQNumAlRit(aRit,RitNum) Then RitSincDiLiv = nRitDiLiv : Exit For
'============================================

Next

' la funzione torna il ritardo di livello di un numero su una ruota
' RitSincDiLiv = ritNum '<<<< DATO PROVVISORIO VALIDO SOLO PER DEBUG.
End Function
    
Sub GetRitardoEstratti(aRit,Ruota,idEstr)
Dim N
'Rit(1) dovra' contenere il ritardo del numero 1 sulla Ruota Ruota all'estrazione IdEstr
'aRit(90) dovra' contenere il ritardo del numero 90 sulla Ruota Ruota all'estrazione IdEstr
'le posizioni dalla 2 alla 89 seguono lo stesso concetto..
For N = 1 To 90
aRit(N) = EstrattoRitardoTurbo(Ruota,N,1,idEstr)
Next
End Sub
Function GetRitardoNumero(aRit,NumCerc)
'E' una funzione che  ...[con i parametri dell'array aRit
'cioè quelli calcolati con la funzione GetRitardoEstratti(aRit,Ruota,idEstr)] ...
'ritorna il ritardo di un determinato numero.
GetRitardoNumero = aRit(NumCerc)
End Function
Function GetQNumAlRit(aRit,nRitCercato)
'E'  una funzione che torna la QUANTITA' di numeri ad un dato ritardo.
Dim N,K
For N = 1 To 90
If aRit(N) = nRitCercato Then K = K + 1
Next
GetQNumAlRit = K
End Function

 

[Joe91]

Buon giorno a tutte/i.

Lo script/funzione che ho presentato al messaggio precedente (#577) esegue il suo calcolo ... benone ...

ma necessita di qualche aggiustamento.

Prima di tutto si sarà notato che "l'uscita" ... non è per così dire ... in versione classica.

Cioè non esce al termine della funzione ... Ma, dopo un If-intermedio, va all' "Exit For"

Ne deriva e consegue che se non ci sono variazioni nel numero di numeri ... il valore di "RL" NON viene attribuito.

Questo è giusto per certi versi.

Cioè è intrinseco al corretto funzionamento ... ed è sbagliato per altri versi ... cioè ... "non attribuisce" il valore.

Dico subito che "la versione" di calcolo adottata da Spaziometria/Luigi e qui di seguito proposta secondo me è preferibile.

Ritenendo anche giusto demandare poi allo script che la utilizza questa funzione decidere come comportarsi.

Aggiungo inoltre che, questa anomalia, si verifica quando ci sono 5 Sincroni,

cioè c'è tutta una Cinquina Sincrona, che accumula ritardo.

Dicevo che da un lato si può intendere che non ci siano livelli intermedi differenti... ma,

secondo me, come accennato è più giusto ritenere che vi sia un "ritardo di livello" coincidente

con il ritardo corrente di tutta la Cinquina Sincrona.

Così, ritengo anch'io che nell' eventualità di una mancata "uscita laterale" ...

si sia in presenza di una cinquina sincrona con 5 estrattti a ritardo con RL = RC

Vediamo all'opera lo script non ancora corretto ... ed un esempio di quanto ho descritto.

Naturalmente sarà sufficiente uscire dopo aver trovato 5 estratti a ritardo ed aver imposto : RL = RC.

Ed è ... la correzione che apporterò
_

 

[LuigiB]

Bravo joe dal cellulare non vedo l allegato tuttaviavlectuevosservazini sono corrette. Nella versione fatta da noi e opportuno uscire dal ciclo anche se il ritardo decrementato arriva sottozero. In veritacil famoso ciclo fecrescente si dovrebbe fare con un ciclo do checusi il ritardo come iteratore finche ė maggiore uguale a 0

 

[LuigiB]

aggiungendo delle considerazioni che non ho scritto prima col cellulare devo dire che la funzione fatta da noi non soffre il problema solo perche una cinquina sincrona si trova solo nelle ultimissime estrazioni quindi teoricamente il ritardo che viene decrementato non farebbe in tempo ad arrivare sotto 0 prche sarebebro finite prima le estrazioni , pero usare un ciclo do sul ritardo decrementato
rende chiaro che il problema è comunque gestito...

 

[i legend]

Do wihle estr>0
Call getritardoestratti (arit,ruota,estr)
Ritnum1=ritnum1-1
Qnumrit1=getnumalrit (arit,ritnum1)
If qnumrit1=qnumrit Then
Nritdiliv=Nritdiliv +1
Else
Edit do
End if
Estr=estr-1
Loop
Nretlivello=qnumrit
Ritsincdiliv=Nritdiliv


Con il cellulare a me funziona

 

[Joe91]

Ok ... penso siano giuste le considerazioni di Luigi ed anche quelle di ilegend.

Dicevo che considerare il ritardo di livello della cinquina_sincrona ... come ritardo corrente

e viceversa, implica che se questi ritardi sono rapportati (messi in rapporto) come spesso è RL/RC ...

avranno necessariamente come risultato "1" e quindi dovrà essere compito, dello script,

che utilizza questa nuova-funzione includere/escludere/selezionare questi livelli appartenenti alle cinquine-sincrone.

Riprendendo e richiamando la stessa tabella già utilizzata ... si vede appunto che utilizza questo rapporto RL/RC ...

ma non include i valori "uguali ad uno".

Per essere più corretti, questi rapporti erano "proposti" quando maggiori dell' 80% e minori del 100%.

In sintesi escludendo tutte le cinquine-sincrone. E così si vovrà (?!?!) fare negli script ...

che si calcolaranno, autonomamente una tabella, come quella che Mike aveva postato nei primi messaggi.

Con questa nuova istruzione ... questa statistica, diventerà semplicissima da calcolarsi.

Altra buona notizia, penso si sia in prossimità di questo traguardo ...

che sarà raggiungibile con tempi megliori di quelli previsti.

Quindi una tabella come questa :

----------------------------------------------
Ruota         Numeri     RSL      RC    RSL/RC
----------------------------------------------
Torino    47.15.26.73    17      18      0.944    

Napoli    5.44.15.46     11      12      0.917    

Cagliari  86             33      37      0.892    

Genova    63.71.29.27    8       9       0.889    

Venezia   39             54      63      0.857    

Milano    80             33      39      0.846    

Torino    60             53      63      0.841    

Roma      54.88.20       14      17      0.824    

Nazionale 23             49      60      0.817    

Roma      21.81.64       17      21      0.810    

----------------------------------------------
Aggiornamento al 15.09.2015    RSL/RC >= 0.800
----------------------------------------------
Elaborato in 67.9 Secondi.

sarà realizzabile, con poche istruzioni ... in una manciata di secondi.

Cordiali saluti.

 

[Joe91]

Ciao Luigi ,Grazie
Ciao Mike ,Grazie
Ora provo a verificare dove sbaglio e se riesco a comprimere il codice.
nRitLivello non ho capito cos'è,Mi spiace se mi spieghi cerco di ricavarlo.....
Ciao Joe Grazie
ciao a tutti

P,s: Sarebbe bello alla fine vedere lo sviluppo con il codice ottimizzato
al massimo.E da qui grazie a voi che imparo e mi migliore, grazie di cuore

Ciao come vedi ... uno script dedicato ti può pemettere di trovare il

miglior rapporto Ritardo di Livello / Ritardo Corrente.

In alternativa si fa a mano studiando i tabelloni analitici.

Qindi individuato il livello, la ruota ed i ritardi osservi ... che, per esempio ... sono 4 numeri.

Premendo la freccia (che ho indicato) "17 volte" osservi che il ritardo corrente "dei 4 numeri" diminuisce.

Essi "scendono" mentre si ricompilano i tabelloni analitici precedenti ... fino ad un concorso ... in cui ...

... questi 4 numeri, diventano 5.

Rovesciando il ragionamento, per il verso giusto, C'era una volta ... una cinquina sincrona che

estratta 18 concorsi orsono ... ha perso, subito, al primo colpo uno dei suoi lottroni ...

Poi sono trascorse "altre 17 Estrazioni" ma degli stessi 4 Numeri rimasti ...

nessuno è più stato estratto. Sono "intatti" da 17 estrazioni.
_




Si sa che ... diventeranno 3 o 2 o 1 o nessuno, poco per volta, o tutto in un estrazione ...

Questo è ignoto, nel come e nel quando.

Ma ci sono cose... più probabili di altre.

Per ora hanno brillato di questa luce.

 

[i legend]

Ciao a tutti
*joe sei un grande
Un grazie anche a luigi che invoglia a crescere i novellino come me.anche se a livelli molto superficiali onestamente pochi mesi fa non avrei pensato di poter scrivere due righe in croce.grazie.