Newsgroup: it.hobby.enigmi
Titolo: [[[OT] Il lotto e il buon Samaritani

Ciao a tutti,
scusate se sono del tutto OT, ma ho ritenuto giusto chiedere anche a voi
lumi su un dibattito di questi giorni apparso su it.hobby.scacchi.
Si trattava di un discorso sul lotto (infatti anche su it.hobby.scacchi era
OT).
La storia è questa (vissuta da lurker):
Tale Ciccioscacchi (bonario quanto intrusivo lottologo e scacchista), viene
attaccato a più riprese su it.hobby.lotto perchè lui le sue previsioni le
regala mentre altri su quel NG le vendono: morale, flame di ogni tipo,
attacchi infiniti ecc...
Qui però non voglio entrare in quel dibattito tra idealisti e speculatori.
Sta di fatto che il succitato Ciccioscacchi apre un OT su it.hobby.scacchi
su quel problema, e trova una certa solidarietà. Senonchè l'OT si allunga:
"che cavolo di previsioni fate voi lottologi, se le estrazioni tra loro sono
indipendenti?" Segue difesa di Ciccioscacchi alla lottologia, gli attacchi
si moltiplicano, qualcuno rinnova la richiesta di discutere nel NG apposito
(il tutto in OT, ribadisco).
Comunque qualche scacchista tira fuori questo link, di Adam Atkinson:
http://www.mistral.co.uk/ghira/lotto/index.html
Una serie di argomentazioni feroci contro le teorie dei ritardisti. Apriti
cielo! Io ci ho sempre creduto alla teoria dei ritardi! Leggo tutto, e tutto
d'un fiato.
Tra le altre cose smonta anche la formula del matematico Samaritani, la
quale vuole, a detta dei ritardisti (tra cui Leontino Gorgia), che esista un
tetto invalicabile per il ritardo di un numero su una ruota. La formula è un
logaritmo che è funzione del numero di estrazioni della storia del lotto
(circa 6000). Eccola:
log_q(1/(50*6000)) = 220.6
Il valore 220.6 è considerato dai ritardisti il massimo ritardo teorico di
un numero su una ruota.
In effetti questo ritardo non è mai stato raggiunto.
Visto che io se non tocco con mano non credo, ho scritto un programmino che
simula le 6000 estrazioni e controlla il massimo ritardo raggiunto tra i 90
numeri.
Praticamente sfondo sempre il tetto del Samaritani! Quindi è vero (cioè: i
ritardisti sbagliano)! Mentre qualcuno dice di giocare il ritardatario
quando esso tocca le 150 estrazioni di ritardo (si sfalderà sicuramente
entro 10 o 15 colpi, dicono), il mio programma tocca spesso le 300
estrazioni, e talvolta le 500!
Mi sembra inutile dire che i ritardisti, senza l'appoggio di questa formula,
si attaccano al tram.
A meno che non ho sbagliato qualcosa nel programma...
Però, come può esserci un divario così ampio? Perchè la storia del lotto dà
ragione al Samaritani, mentre una simulazione al computer lo smentisce
praticamente sempre?
Ciao a tutti,
Francesco
--
************************
Per risposte personali, elimina 'Raspu'.

#include "Francesco Di Matteo.h"
[...]

Beh, secondo me, potrebbe esserci qlcs di vero nella teoria di Atkinson,
ma anche qlcs di sbagliato nel tuo programma... perche non mandi il
sorgente della tua simulazione?
Cmq sia, 220 estrazioni di ritardo non sono mai state raggiunte, sebbene
sia un evento probabile.
Tu conta che la probabilita' che esca un determinato numero al lotto
(esclusi bari e traffici) e' di, grosso modo, e correggetemi se sbaglio, e'
di 1/90 + 1/89 + 1/88 + 1/87 + 1/86. 
---
Blackstorm
*Vicario d'Armi di idf*
Tittums e' il nostro gatto, ed ha le dimensioni di un rotolo di soldini.
Inarcava la schiena e bestemmiava come uno studente in medicina.
(Jerome Klapka Jerome)
E da oggi anche su ICQ! UIN 116647346 (nick: blacks)          

 
...direi che e' 5/90.
;-)
CiaO,
Massimo

#include "MassimoM.h"

Appunto... l'avvevo scritto, poi ho cambiato idea... :((((((((((


Blackstorm
*Vicario d'Armi di idf*
ha chiesto il sorgente...
dunque...
E' scritto in Lingo per Director (sic!). Commenti all'uopo.
Nota: Lingo non manipola array, bensì liste: le istruzioni getAt, setAt,
addAt ecc.. cmq sono piuttosto intuitive.
1° handler: creo quattro liste di 90 elementi
repeat with v=1 to 90
    addAt numeri, v, v -- contiene i 90 numeri, nell'ordine
    addAt numeriurna, v, v -- idem, per effettuare l'estrazione
    addAt ritardi, v, 0 -- tutti i ritardi dei 90 numeri vengono posti a 0
    addAt estratti, v, 0 -- tutti gli estratti vengono posti a 0
  end repeat
2° handler
  repeat with c=1 to 6000 -- le 6000 estrazioni
    put c into field "n_estra" -- visualizza il 
n.ro
 estrazione
    repeat with d=1 to 1 -- una ruota (si può cambiare)
      repeat with e=1 to 5 -- i 5 numeri da estrarre
        set h to count(numeriurna) -- conta gli elementi nell'urna
        set g to random(h) -- ecco l'estratto
        setAt estratti, g, 1 -- pone 1 nella lista degli estratti
        deleteAt numeriurna, g -- l'estratto viene tolto dall'urna
      end repeat
      numeriurna = numeri.duplicate( ) -- ripristina i 90 numeriurna
    end repeat
    repeat with g=1 to 90 -- analisi dell'estrazione
      if getAt(estratti,g)=1 then -- se il numero g è stato estratto...
        setat ritardi, g, 0 -- ...pone il suo ritardo a 0...
      else -- ...altrimenti...
        set q to getAt(ritardi,g) -- ... prende l'attuale ritardo...
        setat ritardi, g, (q+1) -- ... e lo incrementa di 1
      end if
      setat estratti, g, 0 -- in ogni caso, azzera la lista degli estratti
    end repeat
    trovamax = ritardi.duplicate( ) -- duplica la lista ritardi in una lista
temporanea
    sort trovamax -- la ordina
    set j to getLast(trovamax) -- prende l'ultimo valore
    if j > value(the text of field "max_rit") then -- se è > del max ritardo
trovato..
       put j into field "max_rit"  -- lo visualizza.
    end if
  end repeat
end
Saluti, Francesco


 
---
Blackstorm
*Vicario d'Armi di idf*
Tittums e' il nostro gatto, ed ha le dimensioni di un rotolo di soldini.


 
Ho provato anch'io a fare un programma. Il mio simula 30 gruppi di 100000
estrazioni ma smette appena un numero presenta un ritardo superiore a
220. Questo un risultato:
Estrazione=59725 Estratto=4 Ritardo=222
Estrazione=25911 Estratto=39 Ritardo=229
Estrazione=64375 Estratto=8 Ritardo=242
Estrazione=390 Estratto=19 Ritardo=232
Estrazione=7234 Estratto=66 Ritardo=233
Estrazione=15936 Estratto=48 Ritardo=238
Estrazione=79215 Estratto=2 Ritardo=252
100000 estrazioni raggiunte!
Estrazione=24031 Estratto=55 Ritardo=226
Estrazione=44139 Estratto=21 Ritardo=225
Estrazione=73754 Estratto=28 Ritardo=251
Estrazione=13485 Estratto=70 Ritardo=253
Estrazione=36233 Estratto=62 Ritardo=225
Estrazione=74668 Estratto=23 Ritardo=244
Estrazione=15124 Estratto=30 Ritardo=279
Estrazione=67021 Estratto=32 Ritardo=222
Estrazione=12729 Estratto=90 Ritardo=260
Estrazione=3585 Estratto=73 Ritardo=227
Estrazione=32355 Estratto=55 Ritardo=230
Estrazione=29990 Estratto=6 Ritardo=242
Estrazione=62450 Estratto=35 Ritardo=227
Estrazione=17480 Estratto=30 Ritardo=243
100000 estrazioni raggiunte!
Estrazione=26661 Estratto=22 Ritardo=238
Estrazione=2272 Estratto=29 Ritardo=221
Estrazione=53882 Estratto=89 Ritardo=227
Estrazione=38949 Estratto=5 Ritardo=226
Estrazione=21538 Estratto=52 Ritardo=274
Estrazione=8106 Estratto=21 Ritardo=223
Estrazione=43969 Estratto=24 Ritardo=238
Estrazione=5175 Estratto=76 Ritardo=231                                         
Si va da un massimo di 100000 senza aver raggiunto il limite  ad un
minimo di 390!  Sembererebbe quindi che, come sempre quando c'e' di
mezzo il lotto quello che conta e' il culo!
Uso il generatore Random drand48 del C che per sequenze brevi come
queste dovrebbe essere abbastanza credibile.
Il programma l'ho buttato giu' in qualche minuto quindi puo' essere che
ci sia qualche baco, comunque lo appendo qui sotto.
Ciao,
      GianPiero
-------------------------------------------------------
#include <stdio.h>
#include <math.h>
#include <time.h>
#define MAX 100000
#define TOT 30 
int main()
{
int i,j,l,k;
int num,maxrit;
int rit[91];
srand48(time(NULL));
for(k=0;k<=TOT;k++)
{  for (i=1;i<=90;i++)
     rit[i]=0;
   maxrit=0;
 
   for (i=0;i<=MAX;i++)
   { for (j=1;j<=90;j++)
        rit[j]++;
     for (l=1;l<=5;l++)
     {  do
          num=drand48()*90+1;
        while(rit[num]==0);
        if (maxrit<(rit[num]-1))
          maxrit=rit[num]-1;
        rit[num]=0;
     }
     if (maxrit>220)
     {  printf("Estrazione=%d Estratto=%d Ritardo=%d\n",i,num,maxrit);	 
        break;
     }
   }
   if(i>MAX)
     printf("%d estrazioni raggiunte!\n",MAX);
}   
}

estrazioni, e talvolta le 500!
Bada pero` che il tuo programma difficilmente puo` dare estrazioni
veramente casuali: col pc vengono generati numeri _pseudo-casuali_.
-- 
Ci sentiamo  |  Remigio Zedda  || Attenzione! campo "From:" alterato
ciao Remigio |                 ||==> E-mail: 
remi...@tiscalinet.it
-------------|      ..si` d'accordo.. ma con la Deb e` un'altra cosa!
/* Linux 2.2.17 su Debian GNU/Linux 2.2 Potato */

 220.
Già, però bisogna dire che su 100.000 estrazioni il valore teorico è
sicuramente più alto di 220 (la formula è funzione del numero di estrazioni
avvenute).
Cmq i tuoi risultati si discostano parecchio dai miei. Forse dipende
effettivamente dalla funzione random...
Ciao


 
Ho fatto un'altra prova, forse piu' simile a quella che hai fatto te,
300 gruppi di 6000 estrazioni per vedere il massimo ritardo, e questo e'
il risultato.
Tentativo=7 Massimo Ritardo=223
Tentativo=8 Massimo Ritardo=238
Tentativo=22 Massimo Ritardo=227
Tentativo=43 Massimo Ritardo=238
Tentativo=63 Massimo Ritardo=237
Tentativo=86 Massimo Ritardo=224
Tentativo=116 Massimo Ritardo=233
Tentativo=126 Massimo Ritardo=260
Tentativo=128 Massimo Ritardo=233
Tentativo=130 Massimo Ritardo=246
Tentativo=149 Massimo Ritardo=228
Tentativo=158 Massimo Ritardo=221
Tentativo=161 Massimo Ritardo=221
Tentativo=165 Massimo Ritardo=245
Tentativo=177 Massimo Ritardo=237
Tentativo=185 Massimo Ritardo=226
Tentativo=209 Massimo Ritardo=224
Tentativo=214 Massimo Ritardo=227
Tentativo=233 Massimo Ritardo=235
Tentativo=241 Massimo Ritardo=246
Tentativo=252 Massimo Ritardo=231
Tentativo=260 Massimo Ritardo=229
Superati 220= 7.33% Massimo dei ritardi massimi=260   
In altri tentativi si va sempre dalle parti del 6-9% ma comunque raramente
si ottengono ritardi superiori al 400.
Puo' essere che il problema sia la funzione random (va bene, pseudo-random)
sono stati scritti fior di libri su come dovrebbe essere fatta una
buona RANDOM. Ovviamente c'e' sempre la possibilita' che ci sia un baco
nel mio programma, non l'ho controllato piu' di tanto, cosa comunque
difficile quando il risultato e', per definizione, casuale.
Comunque sia il risultato e' sempre quello che non si puo' fare
affidamento sui ritardi, come previsto.
Ciao,
     GianPiero

 Beh, secondo me, potrebbe esserci qlcs di vero nella teoria di Atkinson,
(il mio news server in UK non ha piu' i.h.e.)
Cosa sarebbe la "teoria di Atkinson"? La mia pagina web e' molto
chiaramente anti-ritardista. La formula di Samaritani, sebbene
non del tutto balordo, non ha assolutamente il significato
che i ritardisti le vogliono attribrure, e non aiuta a vincere
piu' spesso giocando al lotto.