Novità

Intelligenza artificiale e lotto 🤖🎱📈📉🎯

ciao saturno, ottimale come ho scritto sopra sarebbe riuscire ad automatizzare la ricerca della terzina per ambo residua a fq0 dopo ciascun ciclo di 178 estrazioni con successiva verifica del relativo sfaldamento in ambo su TT e/o NZ appuntandosi sempre dinamicamente il numero massimo teorico di colpi di attesa. Per esempio se a partire da gennaio 2011 dopo le prime 178 estrazioni ci fosse stata la terzina XYZ a fq0 x ambo su TT dopo quanti colpi la stessa sfaldò almeno 2 punti su TT e/o NZ? 5, 8 , 9 ? Bene... ripetere l'analisi per ogni ciclo di 178 estrazioni da lì per tutto il periodo temporale successivo fino ai nostri giorni per verificare il valore teoricamente stabile di sfaldamento di un siffatto tipo di ricerca riduzionale dinamica... Se arrivassimo alla pindarica conclusione che il tempo teorico, mai certo, di attesa fosse ad esempio di 9 estrazioni si potrebbe circoscrivere sempre di + il comportamento teorico dei due 2 punti in teorica uscita nella terzina più attuale residua e sarebbe forse anche possibile cercare di identificarne la ruota teoricamente favorita ad accoglierla in questo lasso di tempo ipotetico.
 
SatuRno17 ha scritto:
Ciao Lotto_Tom,
credo di aver capito, domani provo a fare una ricerca per stabilire la media colpi. 🤗👋👍
Clicca per espandere...

Ottimo :), io intanto ho sguinzagliato... Mistral che per adesso mi sta davvero piacevolmente sorprendendo...


🤠

(ProgettoAIxLotto) C:\Users\ProgettoAIxLotto\Desktop\ProgettoAIxLotto\AILOTTOPROJECT-FULL-BUT-ONLY-ESSENTIAL\AILottoProject\archivio>python xrilevarecolpomassimoteoricopersfaldamentodiamboinclasse3suTTeNZ-piuveloce-elaborainparalleloconbarradiavanzamentoconpiustampedidebug4.py

Progresso totale: 0%| | 0/660 [00:00<?, ?it/s]

Inizio analisi ruota BA con 60 cicliInizio analisi ciclo 0 per ruota BA
Terzine con frequenza 0 per ambo trovate: 115704
Ruota BA, Ciclo 0 completato.: 0%| | 1/660 [00:31<5:45:55, 31.50s/it]
Ruota BA, Ciclo 0 completato. Progresso: 1/660
Inizio analisi ciclo 1 per ruota BA
Terzine con frequenza 0 per ambo trovate: 115714

No Mistral non ci siamo... lo script dovrebbe analizzare in simultanea per il ciclo 0 BA, CA , FI ecc fino a NZ e rilevare le terzine con frequenza 0 considerando tutte le ruote "unite" per lo stesso ciclo 0 e poi analizzare quanti colpi di attesa ci vogliono per la terzina residuale a fq 0. Come sta operando adesso non va bene perchè analizza per ogni ciclo una ruota alla volta...


LeChat Logo


Grazie per la spiegazione dettagliata. Ora è chiaro che dobbiamo analizzare tutte le ruote simultaneamente per ogni ciclo e rilevare le terzine con frequenza 0 considerando tutte le ruote "unite" per lo stesso ciclo. Successivamente, dobbiamo analizzare quanti colpi di attesa ci vogliono per la terzina residuale a frequenza 0.

Nuovo Approccio​

  1. Lettura dei Dati:
    • Leggere i dati delle estrazioni da tutti i file delle ruote.
  2. Suddivisione in Cicli:
    • Suddividere le estrazioni in cicli di 178 estrazioni ciascuno per tutte le ruote.
  3. Analisi Simultanea delle Ruote per Ogni Ciclo:
    • Per ogni ciclo, analizzare tutte le ruote simultaneamente e rilevare le terzine con frequenza 0 considerando tutte le ruote "unite".
  4. Calcolo del Colpo di Sfaldamento:
    • Per ogni terzina residuale, calcolare il numero di colpi di attesa necessari per sfaldare un ambo.

Codice Aggiornato​

Ecco il codice aggiornato che segue il nuovo approccio:


Codice: 
import itertools
import os
from concurrent.futures import ThreadPoolExecutor, as_completed
import time
from tqdm import tqdm

# Funzione per leggere i dati delle estrazioni da un file di testo
def leggi_estrazioni(file_path):
    with open(file_path, 'r') as file:
        estrazioni = [list(map(int, line.strip().split('.'))) for line in file]
    return estrazioni

# Funzione per verificare se una terzina ha frequenza 0 per ambo in un ciclo considerando tutte le ruote
def has_zero_frequency_for_ambo(terzina, ciclo_ruote):
    for ciclo in ciclo_ruote:
        for estrazione in ciclo:
            if set(terzina).issubset(estrazione):
                return False
    return True

# Funzione per calcolare il colpo di sfaldamento per una terzina
def calcola_colpo_sfaldamento(terzina, estrazioni_ruote):
    colpo = 0
    for estrazioni in estrazioni_ruote:
        if all(all(num not in estrazione for estrazione in ruota) for num in terzina):
            colpo += 1
        else:
            break
    return colpo

# Leggi i dati delle estrazioni da tutti i file
ruote = ['BA', 'CA', 'FI', 'GE', 'MI', 'NA', 'PA', 'RO', 'TO', 'VE', 'NZ']
estrazioni = {ruota: leggi_estrazioni(f'estrazioni-{ruota}.txt') for ruota in ruote}

# Genera tutte le possibili terzine
all_numbers = set(range(1, 91))  # Numeri del lotto vanno da 1 a 90
terzine = list(itertools.combinations(all_numbers, 3))

# Suddividi le estrazioni in cicli di 178
def suddividi_in_cicli(estrazioni):
    for i in range(0, len(estrazioni), 178):
        yield estrazioni[i:i+178]

# Analizza ogni ciclo considerando tutte le ruote simultaneamente
max_colpo_teorico = 0

def analizza_ciclo(ciclo_index, cicli_ruote, terzine, pbar):
    global max_colpo_teorico
    print(f"Inizio analisi ciclo {ciclo_index}")
    terzine_zero_frequency = [terzina for terzina in terzine if has_zero_frequency_for_ambo(terzina, cicli_ruote)]
    print(f"Terzine con frequenza 0 per ambo trovate: {len(terzine_zero_frequency)}")
    for terzina in terzine_zero_frequency:
        colpo = calcola_colpo_sfaldamento(terzina, [estrazioni[ruota][ciclo_index*178:] for ruota in ruote])
        if colpo > max_colpo_teorico:
            max_colpo_teorico = colpo
    pbar.update(1)
    pbar.set_description(f"Ciclo {ciclo_index} completato.")
    print(f"Ciclo {ciclo_index} completato. Progresso: {pbar.n}/{pbar.total}")
    return max_colpo_teorico

# Analizza tutti i cicli considerando tutte le ruote simultaneamente
start_time = time.time()
total_cicli = 60  # 60 cicli per ogni ruota
cicli_ruote = [list(suddividi_in_cicli(estrazioni[ruota])) for ruota in ruote]
with tqdm(total=total_cicli, desc="Progresso totale") as pbar:
    with ThreadPoolExecutor() as executor:
        futures = [executor.submit(analizza_ciclo, i, [ciclo[i] for ciclo in cicli_ruote], terzine, pbar) for i in range(total_cicli)]
        for future in as_completed(futures):
            future.result()

end_time = time.time()
print(f"Il colpo massimo teorico del relativo sfaldamento è: {max_colpo_teorico}")
print(f"Tempo totale di esecuzione: {end_time - start_time} secondi")

Spiegazione delle Modifiche​

  1. Lettura dei Dati:
    • Leggiamo i dati delle estrazioni da tutti i file delle ruote.
  2. Suddivisione in Cicli:
    • Suddividiamo le estrazioni in cicli di 178 estrazioni ciascuno per tutte le ruote.
  3. Analisi Simultanea delle Ruote per Ogni Ciclo:
    • Per ogni ciclo, analizziamo tutte le ruote simultaneamente e rileviamo le terzine con frequenza 0 considerando tutte le ruote "unite".
  4. Calcolo del Colpo di Sfaldamento:
    • Per ogni terzina residuale, calcoliamo il numero di colpi di attesa necessari per sfaldare un ambo.
  5. Stampe di Debug Aggiuntive:
    • Aggiunte stampe di debug all'inizio e alla fine dell'analisi di ciascun ciclo.
    • Aggiunte stampe di debug per mostrare il numero di terzine con frequenza 0 per ambo trovate.

Esecuzione e Monitoraggio​

Con queste modifiche, dovresti vedere aggiornamenti più frequenti della barra di progresso e delle stampe di log che ti mostrano il progresso corrente. Questo ti aiuterà a monitorare l'avanzamento dello script e a stimare quanto tempo ci vorrà per completare l'analisi.

Se hai ulteriori domande o hai bisogno di assistenza, fammi sapere!
 
Ultima modifica:
Questa nuova AI sembra molto interessante ! 👏
Comunque da una analisi super veloce sempre utilizzando il codice di prima, ho visto che in due mesi (feb e marzo 2011), nessuna terzina ha toccato il ritardo 178.
 
SatuRno17 ha scritto:
Questa nuova AI sembra molto interessante ! 👏
Comunque da una analisi super veloce sempre utilizzando il codice di prima, ho visto che in due mesi (feb e marzo 2011), nessuna terzina ha toccato il ritardo 178.
Clicca per espandere...

Ariottimo :), ad ogni modo se il ritardo massimo oscilla diciamo in una forchetta temporale tra 170 e 180 estrazioni a noi interessa relativamente... è come se le onde alzassero o abbassassero la nostra boa (terzina target) a fq 0 x ambo su TUTTE. La nostra boa la riusciamo facilmente a rilevare nella condizione più attuale possibile di volta in volta abbassando o alzando l'ampiezza temporale di rilevamento... Quello che ci interessa maggiormente è cercare di capire quando una terzina boa con siffatto comportamento frequenziale sfalda a tutte almeno 2 dei suoi punti come ho cercato di spiegare sopra.
 
Se lo script in python che ti ha fornito l'AI funziona correttamente siamo già sulla buona strada. Il qbasic che uso è un po' lento ad analizzare ogni volta l'integrale delle terzine. Dunque in questo caso l'AI sarebbe molto utile per abbattere i tempi !😄
 
SatuRno17 ha scritto:
Se lo script in python che ti ha fornito l'AI funziona correttamente siamo già sulla buona strada. Il qbasic che uso è un po' lento ad analizzare ogni volta l'integrale delle terzine. Dunque in questo caso l'AI sarebbe molto utile per abbattere i tempi !😄
Clicca per espandere...

Purtroppo forse ho sopravvalutato Mistral o non ho trovato ancora il modo di esprimermi al meglio con lui... perchè per adesso, per restare in tema di boe..., purtroppo siamo ancora in alto mare... 🥴😅
 
lotto_tom75 ha scritto:
Purtroppo forse ho sopravvalutato Mistral o non ho trovato ancora il modo di esprimermi al meglio con lui... perchè per adesso, per restare in tema di boe..., purtroppo siamo ancora in alto mare... 🥴😅
Clicca per espandere...
Eh infatti avevo qualche dubbio... perché quelle poche volte che ho chiesto aiuto a chatgpt mi ha creato solo pasticci 😂. Comunque domani ci provo lo stesso anche se l'elaborazione richiederà qualche tempo in più e vi farò sapere.
 
SatuRno17 ha scritto:
Eh infatti avevo qualche dubbio... perché quelle poche volte che ho chiesto aiuto a chatgpt mi ha creato solo pasticci 😂. Comunque domani ci provo lo stesso anche se l'elaborazione richiederà qualche tempo in più e vi farò sapere.
Clicca per espandere...

Adesso provo grazie al mitico google notebook lm (AI fenomenale per riassunti e non solo) a passare la patata bollente ad altra AI tipo claude.. e vediamo se almeno lui capisce cosa vogliamo ottenere... :)

Ecco il magistrale riassunto del mitico Google NoteBook LLM dandogli in pasto la mia chat con mistral. 😱🤩

🤖 Sintesi dell'Obiettivo in Python per la Ricerca Riduzionale Predittiva

L'obiettivo è creare uno script in Python che analizzi un archivio di estrazioni del Lotto per identificare il colpo massimo teorico necessario per lo sfaldamento di un ambo in una terzina. L'analisi deve seguire una logica riduzionale predittiva, basata sul concetto di terzina residuale.
Ecco i passaggi principali dello script:
●
Lettura dei dati: Lo script leggerà i dati delle estrazioni del Lotto da 11 file di testo, uno per ciascuna ruota. Ogni file contiene le estrazioni in ordine cronologico, con l'estrazione più recente in cima al file12.
●
Analisi dinamica dei cicli: Lo script analizzerà le estrazioni in cicli dinamici, la cui ampiezza sarà determinata dal rilevamento della prima terzina residuale a frequenza 0 per ambo su tutte le ruote unite.34
●
Identificazione della terzina residuale: Per ogni ciclo, lo script identificherà l'unica terzina che non ha sortito alcun ambo su tutte le ruote in quel ciclo. Questa terzina sarà definita terzina residuale.35
●
Calcolo del colpo di sfaldamento: Per ogni terzina residuale, lo script calcolerà il numero di colpi necessari affinché la terzina sortisca un ambo su una qualsiasi delle ruote.67
●
Calcolo del colpo massimo teorico: Lo script terrà traccia del colpo massimo rilevato tra tutte le terzine residuali analizzate. Questo valore rappresenterà il colpo massimo teorico per lo sfaldamento di un ambo in una terzina residuale su tutte le ruote unite.8
●
Stampa dei risultati: Per ogni ciclo, lo script stamperà:
○
Il numero del ciclo
○
La terzina residuale identificata
○
Il ritardo della terzina residuale (numero di estrazioni in cui la terzina non è uscita)
○
Il colpo di sfaldamento della terzina residuale
●
Stampa del colpo massimo teorico: Al termine dell'analisi di tutti i cicli, lo script stamperà il colpo massimo teorico rilevato.
L'obiettivo finale è quello di stabilire, seppur in modo teorico e non certo, un limite di sfaldamento per ambo in terzina su tutte le ruote.9
Note:
●
La ricerca si basa su un'osservazione empirica: nel range delle ultime 178 estrazioni rimane in media solo 1 terzina a frequenza 0 per ambo su tutte le ruote unite.5
●
Lo script deve essere ottimizzato per gestire un dataset di grandi dimensioni, possibilmente sfruttando il parallelismo.

Spero che questa sintesi sia chiara e comprensibile per un'altra AI. Se hai ulteriori domande o dubbi, non esitare a chiedere!
 
x SatuRno17 e

lotto_tom75​

Bene ci siamo ora interroga Susanna e fatti fare una manovra finanziaria per rimanere in gioco per 4 5 estrazioni con un utile minimo . Naturalmente si entra in gioco quando le terzine sono almeno 4 dato che per la formula del decadimento radioattivo al valore 140 dovrebbero essecene 3, qualcosa . SatuRno 17 potrei avere il tuo script delle terzine ? 🙂 🙂 🙂 🙂
 
@genios Io non uso più script in spaziometria ma utilizzo il qbasic. Non so quindi come girerà su spaziometria. Ho modificato il nome delle funzioni affinché siano uguali a quelle dello spazioscript ma "Print" andrebbe sostituito con "Scrivi".

Comunque ecco il codice:
Codice: 
Dim numeri(1 To 90) As Integer
Dim combinazione(1 To 3) As Integer
Dim Shared Tutte(1 To 10) As Integer
Dim Shared terz As Integer
Dim Shared esf As Integer
For u = 1 To 10
    Tutte(u) = u
Next
For x = 1 To 90
    numeri(x) = x
Next x
Open "rit140.txt" For Output As #1             'questo si può cancellare
For esf = 230 To 240                                       'qui va il range di estrazioni da analizzare
    Print esf                                                         'esf è quindi l'ultima estrazione considerata
    Print #1, Mid$(aDate(esf), 1, 10)
    SistemaIntegrale numeri(), combinazione(), 1, 3, 3       'questa è la sub per generare l'integrale
    Print #1, "+------------------------------------------+"
Next
Close #1
Sub SistemaIntegrale (array() As Integer, combinazione() As Integer, inizio As Integer, lunghezza As Integer, k As Integer)
    If k = 0 Then
        rit = 0
        For es = esf To 1 Step -1
            If Verificaesito(combinazione(), Tutte(), es, 2, 0, 0, 0) Then
                If rit > 177 Then
                    terz = terz + 1
                    Print #1, combinazione(1); combinazione(2); combinazione(3),
                    Print #1, "RIT : "; rit
                End If
                Exit For
            Else
                rit = rit + 1
            End If
        Next es
        Exit Sub
    End If

    For i = inizio To UBound(array)
        combinazione(lunghezza - k + 1) = array(i)
        SistemaIntegrale array(), combinazione(), i + 1, lunghezza, k - 1
    Next i
End Sub
 
Allora come anticipato l'elaborazione è molto, molto lenta. Forse è il caso di riprendere a scrivere in VBnet....
Questa analisi va da marzo ad agosto 2024, 23 casi, ovvero 23 terzine che avevano superato ritardo 150. La media colpi è risultata circa 15.

Codice: 
01.03.2024     12 34 84  RIT:  163  C:  20
+--------------------------------------------------------+
02.03.2024      7 42 57  RIT:  161  C:  41
+--------------------------------------------------------+
05.04.2024     23 32 62  RIT:  159  C:  3
05.04.2024     23 38 53  RIT:  154  C:  24
+--------------------------------------------------------+
16.04.2024     17 28 77  RIT:  151  C:  9
+--------------------------------------------------------+
18.04.2024     50 62 77  RIT:  151  C:  10
+--------------------------------------------------------+
26.04.2024      7 33 42  RIT:  151  C:  11
+--------------------------------------------------------+
29.04.2024     51 69 72  RIT:  151  C:  31
+--------------------------------------------------------+
07.05.2024     23 33 53  RIT:  151  C:  5
+--------------------------------------------------------+
10.05.2024     12 16 34  RIT:  152  C:  10
+--------------------------------------------------------+
16.05.2024     22 25 63  RIT:  151  C:  4
+--------------------------------------------------------+
25.05.2024      3 83 84  RIT:  151  C:  15
+--------------------------------------------------------+
01.06.2024      7 42 89  RIT:  151  C:  19
+--------------------------------------------------------+
11.06.2024     21 38 53  RIT:  151  C:  16
+--------------------------------------------------------+
20.06.2024      7  9 42  RIT:  151  C:  6
+--------------------------------------------------------+
16.07.2024     44 50 55  RIT:  151  C:  5
+--------------------------------------------------------+
18.07.2024     21 53 64  RIT:  151  C:  15
+--------------------------------------------------------+
23.07.2024     34 36 48  RIT:  151  C:  1
+--------------------------------------------------------+
03.08.2024     46 48 64  RIT:  151  C:  2
+--------------------------------------------------------+
13.08.2024     15 22 45  RIT:  151  C:  30
+--------------------------------------------------------+
16.08.2024      8 54 77  RIT:  151  C:  29
+--------------------------------------------------------+
20.08.2024     50 52 77  RIT:  151  C:  30
+--------------------------------------------------------+
22.08.2024     38 59 77  RIT:  151  C:  10
+--------------------------------------------------------+

Ho dimenticato di scrivere che l'analisi è stata fatta senza considerare la ruota NZ.
 
Ultima modifica:
ciao genios e ciao saturno, genios mi spiace ma sono allergico alle "progressioni" e non riesco nemmeno a farle o a gestirle.. con o senza AI. Per quanto riguarda la teorica unica terzina "residua" rilevabile in cicli più o meno ampi di 160-190 estrazioni ca forse potrebbe essere interessante vedere se qualcuna è rilevabile analizzando la situazione all'estrazione n. estrazione finale-colpomassimo teorico rilevato per adesso da Saturno sui 23 casi che se ho ben capito ha raggiunto addirittura i 41 colpi... (quindi addio progressione anche per gli amanti del genere...) . In sostanza potrebbe essere interessante cercare una terzina residua a fq0 su TT o su TTeNZ unite all'estrazione n. 10554-41 = 10513 e vedere se non ha ancora sfaldato... Ad ogni modo vi anticipo che il fatto che il colpo massimo teorico sia 41 e il fatto che non sia riuscito a parlare con nessuna AI in modo produttivo al riguardo mi sta facendo passare la voglia di approfondire la cosa... 🫠
 
SatuRno17 ha scritto:
@genios Io non uso più script in spaziometria ma utilizzo il qbasic. Non so quindi come girerà su spaziometria. Ho modificato il nome delle funzioni affinché siano uguali a quelle dello spazioscript ma "Print" andrebbe sostituito con "Scrivi".

Comunque ecco il codice:
Codice: 
Dim numeri(1 To 90) As Integer
Dim combinazione(1 To 3) As Integer
Dim Shared Tutte(1 To 10) As Integer
Dim Shared terz As Integer
Dim Shared esf As Integer
For u = 1 To 10
    Tutte(u) = u
Next
For x = 1 To 90
    numeri(x) = x
Next x
Open "rit140.txt" For Output As #1             'questo si può cancellare
For esf = 230 To 240                                       'qui va il range di estrazioni da analizzare
    Print esf                                                         'esf è quindi l'ultima estrazione considerata
    Print #1, Mid$(aDate(esf), 1, 10)
    SistemaIntegrale numeri(), combinazione(), 1, 3, 3       'questa è la sub per generare l'integrale
    Print #1, "+------------------------------------------+"
Next
Close #1
Sub SistemaIntegrale (array() As Integer, combinazione() As Integer, inizio As Integer, lunghezza As Integer, k As Integer)
    If k = 0 Then
        rit = 0
        For es = esf To 1 Step -1
            If Verificaesito(combinazione(), Tutte(), es, 2, 0, 0, 0) Then
                If rit > 177 Then
                    terz = terz + 1
                    Print #1, combinazione(1); combinazione(2); combinazione(3),
                    Print #1, "RIT : "; rit
                End If
                Exit For
            Else
                rit = rit + 1
            End If
        Next es
        Exit Sub
    End If

    For i = inizio To UBound(array)
        combinazione(lunghezza - k + 1) = array(i)
        SistemaIntegrale array(), combinazione(), i + 1, lunghezza, k - 1
    Next i
End Sub
Clicca per espandere...
Ciao SatuRno CONOSCEVO gbasic poi me lo so dimenticato vorrei "rispolverallo" lo impari con gli"script" fatti da altri da piccole cose in su ci sono delle lezioni con chiavette USB,OD ALTRO, GRAZIE.
 
Alien. ha scritto:
Ciao SatuRno CONOSCEVO gbasic poi me lo so dimenticato vorrei "rispolverallo" lo impari con gli"script" fatti da altri da piccole cose in su ci sono delle lezioni con chiavette USB,OD ALTRO, GRAZIE.
Clicca per espandere...
Ciao Alien, qbasic è un linguaggio molto semplice e bello ma per il lotto ormai è obsoleto. Infatti come vedi per fare queste operazioni è molto lento e poi non può aggiornare l'archivio e quindi ogni estrazione la devo aggiungere a mano. Infatti avevo iniziato a provare VBnet ma ancora non lo so usare bene.
 
Devi accedere o registrarti per poter rispondere.

Ultima estrazione Lotto

  • Estrazione del lotto
    martedì 03 dicembre 2024
    Bari
    38
    26
    58
    36
    65
    Cagliari
    71
    68
    61
    41
    89
    Firenze
    52
    65
    73
    03
    50
    Genova
    37
    41
    70
    40
    06
    Milano
    62
    28
    70
    06
    39
    Napoli
    25
    50
    49
    60
    52
    Palermo
    06
    55
    68
    11
    86
    Roma
    12
    23
    16
    14
    63
    Torino
    16
    06
    44
    14
    88
    Venezia
    07
    67
    01
    38
    89
    Nazionale
    67
    27
    38
    57
    19
    Estrazione Simbolotto
    Venezia
    42
    15
    08
    05
    32
    Archivio estrazioni lotto Ritardi top 15 Frequenze top 15

Ultimi Messaggi

Indietro
Alto