Intelligenza artificiale e lotto 🤖🎱📈📉🎯

[Lottopython]

 

[lotto_tom75]

Thanks to like l8py

Prox forse...

[21:52:55][INFO] Lunghezza sequenza: 5
[21:52:55][INFO] Righe da analizzare: 60
[21:52:55][INFO] Soglia minima: 90.0%


=== CONDIZIONE OTTIMALE TROVATA ===
[21:52:55][INFO] Ruota: FI
[21:52:55][INFO] File binario: b1.txt
[21:52:55][INFO] Pattern analizzato: 00110
[21:52:55][INFO] Occorrenze '0': 0
[21:52:55][INFO] Occorrenze '1': 2
[21:52:55][INFO] Sequenza binaria risultante: 1011111 alias : 0011111 : 31
[21:52:55][INFO] Numero decimale: 95 -> 5 ??
[21:52:55][INFO] =


[21:53:01][INFO] Per b3.txt: 6 split con probabilità >= soglia.
[21:53:01][INFO]
=== CONDIZIONE OTTIMALE TROVATA ===
[21:53:01][INFO] Ruota: PA
[21:53:01][INFO] File binario: b3.txt
[21:53:01][INFO] Pattern analizzato: 11111
[21:53:01][INFO] Occorrenze '0': 0
[21:53:01][INFO] Occorrenze '1': 3
[21:53:01][INFO] Sequenza binaria risultante: 0101010 alias 0101011 : 43
[21:53:01][INFO] Numero decimale: 42


[21:52:59][INFO] Per b2.txt: 6 split con probabilità >= soglia.
[21:52:59][INFO]
=== CONDIZIONE OTTIMALE TROVATA ===
[21:52:59][INFO] Ruota: PA
[21:52:59][INFO] File binario: b2.txt
[21:52:59][INFO] Pattern analizzato: 11000
[21:52:59][INFO] Occorrenze '0': 1
[21:52:59][INFO] Occorrenze '1': 0
[21:52:59][INFO] Sequenza binaria risultante: 0110110 alias 0111110 : 62
[21:52:59][INFO] Numero decimale: 54
[21:52:59][INFO] ================================


[21:53:05][INFO] Per b2.txt: 7 split con probabilità >= soglia.
[21:53:05][INFO]
=== CONDIZIONE OTTIMALE TROVATA ===
[21:53:05][INFO] Ruota: NZ
[21:53:05][INFO] File binario: b2.txt
[21:53:05][INFO] Pattern analizzato: 11111
[21:53:05][INFO] Occorrenze '0': 0
[21:53:05][INFO] Occorrenze '1': 4
[21:53:05][INFO] Sequenza binaria risultante: 0000001
[21:53:05][INFO] Numero decimale: 1
[21:53:05][INFO] ================================
[21:53:07][INFO]



Nessunissima Certezza Solo Pochissima Probabilità

 

[lotto_tom75]

Thanks to like l8py

Prox forse...

[21:52:55][INFO] Lunghezza sequenza: 5
[21:52:55][INFO] Righe da analizzare: 60
[21:52:55][INFO] Soglia minima: 90.0%


=== CONDIZIONE OTTIMALE TROVATA ===
[21:52:55][INFO] Ruota: FI
[21:52:55][INFO] File binario: b1.txt
[21:52:55][INFO] Pattern analizzato: 00110
[21:52:55][INFO] Occorrenze '0': 0
[21:52:55][INFO] Occorrenze '1': 2
[21:52:55][INFO] Sequenza binaria risultante: 1011111 alias : 0011111 : 31
[21:52:55][INFO] Numero decimale: 95 -> 5 ??
[21:52:55][INFO] =


[21:53:01][INFO] Per b3.txt: 6 split con probabilità >= soglia.
[21:53:01][INFO]
=== CONDIZIONE OTTIMALE TROVATA ===
[21:53:01][INFO] Ruota: PA
[21:53:01][INFO] File binario: b3.txt
[21:53:01][INFO] Pattern analizzato: 11111
[21:53:01][INFO] Occorrenze '0': 0
[21:53:01][INFO] Occorrenze '1': 3
[21:53:01][INFO] Sequenza binaria risultante: 0101010 alias 0101011 : 43
[21:53:01][INFO] Numero decimale: 42


[21:52:59][INFO] Per b2.txt: 6 split con probabilità >= soglia.
[21:52:59][INFO]
=== CONDIZIONE OTTIMALE TROVATA ===
[21:52:59][INFO] Ruota: PA
[21:52:59][INFO] File binario: b2.txt
[21:52:59][INFO] Pattern analizzato: 11000
[21:52:59][INFO] Occorrenze '0': 1
[21:52:59][INFO] Occorrenze '1': 0
[21:52:59][INFO] Sequenza binaria risultante: 0110110 alias 0111110 : 62
[21:52:59][INFO] Numero decimale: 54
[21:52:59][INFO] ================================


[21:53:05][INFO] Per b2.txt: 7 split con probabilità >= soglia.
[21:53:05][INFO]
=== CONDIZIONE OTTIMALE TROVATA ===
[21:53:05][INFO] Ruota: NZ
[21:53:05][INFO] File binario: b2.txt
[21:53:05][INFO] Pattern analizzato: 11111
[21:53:05][INFO] Occorrenze '0': 0
[21:53:05][INFO] Occorrenze '1': 4
[21:53:05][INFO] Sequenza binaria risultante: 0000001
[21:53:05][INFO] Numero decimale: 1
[21:53:05][INFO] ================================
[21:53:07][INFO]



Nessunissima Certezza Solo Pochissima Probabilità

Questa sera estrazione per me da dimenticare... ma FI 31 e NZ 1 al 2° colpo seppur fuori posizione...
Io forse ritenterò l'unica rimasta PA anche per domani...

 

[max63]

Sempre un risultato Tom....un bel risultato....Complimenti!

 

[Silvix]

Nonostante sia da ottimizzare e correggere su su molti punti condivido il code dell'ultima versione (script-analisi-0-1-versioneforsefinale-38.py) x i + smanettoni tra di voi In questa versione è stato corretto l'ordinamento di ricerca (dal basso verso l'alto e l'implementazione di un abbozzo di automazione e di ricerca della condizione teoricamente + ottimale). Anche l'interfaccia presenta molti + campi e bottoni rispetto alla soprastante.

import os
import time
from datetime import datetime
from tkinter import Tk, filedialog, Checkbutton, IntVar, Button, Label, Entry, Frame
from collections import Counter, defaultdict
import winsound

class Logger:
    def __init__(self, cartella_output):
        self.start_time = time.time()
        self.log_filename = os.path.join(cartella_output,
                                         f"log_elaborazione_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt")

    def log(self, messaggio):
        with open(self.log_filename, 'a', encoding='utf-8') as f:
            timestamp = datetime.now().strftime('%H:%M:%S')
            f.write(f"[{timestamp}] {messaggio}\n")
        print(messaggio)

    def tempo_totale(self):
        tempo_totale = time.time() - self.start_time
        return f"{tempo_totale:.2f} secondi"

class ReportCasiOttimali:
    def __init__(self, cartella_output):
        self.report_path = os.path.join(cartella_output, "reportcasiottimali.txt")
        with open(self.report_path, 'w', encoding='utf-8') as f:
            f.write("=== Report Casi Ottimali ===\n\n")
        self.casi_trovati = False

    def aggiungi_caso(self, file_estrazioni, file_b, posizione, prob_0, prob_1):
        self.casi_trovati = True
        with open(self.report_path, 'a', encoding='utf-8') as f:
            f.write(f"File estrazioni: {file_estrazioni}\n")
            f.write(f"File binario: {file_b}\n")
            f.write(f"Probabilità '0': {prob_0:.2%}\n")
            f.write(f"Probabilità '1': {prob_1:.2%}\n")
            f.write("-" * 50 + "\n")

    def finalizza_report(self):
        if not self.casi_trovati:
            with open(self.report_path, 'a', encoding='utf-8') as f:
                f.write("Nessun caso ottimale trovato.\n")

class ReportRuote:
    def __init__(self, cartella_output, nome_file):
        self.report_path = os.path.join(cartella_output, nome_file)
        if not os.path.exists(self.report_path):
            with open(self.report_path, 'w', encoding='utf-8') as f:
                f.write(f"=== {nome_file.replace('.txt', '').upper()} ===\n\n")

    def aggiungi_ruota(self, ruota):
        with open(self.report_path, 'a', encoding='utf-8') as f:
            f.write(f"{ruota}\n")

class CarrelloPredizioni:
    def __init__(self):
        self.carrelli = defaultdict(lambda: ['_'] * 7)
        self.ruota_corrente = None

    def set_ruota(self, nome_file_input):
        if nome_file_input.startswith('estrazioni-'):
            self.ruota_corrente = nome_file_input.split('-')[1].split('.')[0]

    def aggiungi_predizione(self, file_origine, posizione, valore):
        file_base = os.path.basename(file_origine)
        parti = file_base.split('-')
        numero_file = ''.join(filter(str.isdigit, parti[0]))
        chiave = f"b{numero_file}"
        try:
            posizione = int(parti[1].split('.')[0])
            if 0 <= posizione < 7:
                self.carrelli[chiave][posizione] = valore
        except (ValueError, IndexError) as e:
            print(f"Errore: {e}")

    def mostra_risultati(self, logger, cartella_output):
        logger.log("\n=== Risultati Finali ===")
        script_dir = os.path.dirname(os.path.abspath(__file__))
        report_path = os.path.join(script_dir, "previsionielaborate.txt")
        numeri_decimali = []
        for chiave in sorted(self.carrelli.keys()):
            sequenza_binaria = ''.join(self.carrelli[chiave])
            numero_decimale = str(int(sequenza_binaria, 2))
            numeri_decimali.append(numero_decimale)
            logger.log(f"{chiave}.txt: {numero_decimale} (binario: {sequenza_binaria} = {int(sequenza_binaria, 2)})")
        with open(report_path, 'a', encoding='utf-8') as report:
            if self.ruota_corrente and numeri_decimali:
                report.write(f"{self.ruota_corrente} {'-'.join(numeri_decimali)}\n")
        logger.log("=====================")
        logger.log(f"Report salvato in: {report_path}")

def decimale_a_binario(decimale):
    return '.'.join(format(int(decimale), '07b'))

def converte_file_decimale(file_decimale, cartella_output, logger):
    colonne = []
    with open(file_decimale, 'r') as file:
        for linea in file:
            valori = linea.strip().split('.')
            for i, valore in enumerate(valori):
                if len(colonne) <= i:
                    colonne.append([])
                colonne[i].append(decimale_a_binario(valore))
    file_binari = []
    for i, colonna in enumerate(colonne):
        nome_file = os.path.join(cartella_output, f"b{i + 1}.txt")
        with open(nome_file, 'w') as file:
            file.write('\n'.join(colonna))
        file_binari.append(nome_file)
        logger.log(f"File binario generato: {nome_file}")
    return file_binari

def split_file_binario(file_binario, cartella_output, logger):
    base_name = os.path.basename(file_binario)
    numero_file = ''.join(filter(str.isdigit, base_name.split('.')[0]))
    with open(file_binario, 'r') as file:
        righe = [line.strip().split('.') for line in file]
        colonne = list(zip(*righe))
    file_splittati = []
    for i, colonna in enumerate(colonne):
        nome_file = os.path.join(cartella_output, f"b{numero_file}-{i}.txt")
        with open(nome_file, 'w') as file:
            file.write('\n'.join(colonna))
        file_splittati.append(nome_file)
        logger.log(f"File splittato generato: {nome_file}")
    return file_splittati

def carica_dati(file_path):
    with open(file_path, 'r') as file:
        # Legge i dati e INVERTE l'ordine per avere i più vecchi in alto durante l'analisi
        dati = [bit for line in file for bit in line.strip().split('.')]
        return dati[::-1]  # <-- Modifica chiave qui

def analizza_file(file_binario, lunghezza_sequenza, carrello, logger, report_ottimali, file_estrazioni,
                  soglia_minima, analisi_automatica):
    posizione = int(os.path.basename(file_binario).split('-')[1].split('.')[0])
    dati = carica_dati(file_binario)  # Dati ora sono invertiti: [vecchio, ..., recente]

    logger.log(f"\nAnalisi pattern per {file_binario}")
    logger.log(f"Posizione bit analizzata: bit{posizione}.txt")
    logger.log(f"Lunghezza sequenza pattern: {lunghezza_sequenza}")

    # Controllo per assicurarsi che la lunghezza del pattern sia valida
    if lunghezza_sequenza <= 0:
        logger.log(f"Lunghezza sequenza pattern non valida: {lunghezza_sequenza}")
        return False

    # Pattern iniziale preso dalla FINE dei dati invertiti (corrisponde ai più RECENTI nel file originale)
    initial_pattern = tuple(dati[-lunghezza_sequenza:])  # <-- Modifica qui

    preceding_bits = []

    # Analizza dal basso (vecchio) verso l'alto (recente) nei dati invertiti
    for i in range(len(dati) - lunghezza_sequenza):
        current_window = tuple(dati[i:i + lunghezza_sequenza])
        if current_window == initial_pattern and i + lunghezza_sequenza < len(dati):
            # Il bit successivo è quello DOPO la finestra, verso l'alto (più recente)
            preceding_bit = dati[i + lunghezza_sequenza]
            preceding_bits.append(preceding_bit)

    count_0 = preceding_bits.count('0')
    count_1 = preceding_bits.count('1')
    total = len(preceding_bits)

    if total == 0:
        prob_0, prob_1 = 0.5, 0.5
    else:
        prob_0 = count_0 / total
        prob_1 = count_1 / total

    occ = {'0': count_0, '1': count_1}
    TOLLERANZA = 0.0001
    is_optimal = any(abs(prob - 1.0) < TOLLERANZA for prob in [prob_0, prob_1])

    # Controllo per identificare i casi con esattamente un bit inferiore alla soglia minima
    if analisi_automatica:
        bit_inferiori = [bit for bit in preceding_bits if (bit == '0' and prob_0 < soglia_minima / 100) or (bit == '1' and prob_1 < soglia_minima / 100)]
        if len(bit_inferiori) == 1:
            file_b = os.path.basename(file_binario).split('-')[0] + ".txt"
            report_ottimali.aggiungi_caso(
                os.path.basename(file_estrazioni),
                file_b,
                posizione,
                prob_0,
                prob_1
            )
            return True

    valore_predetto = '0' if prob_0 > prob_1 else '1'
    prob_valore = prob_0 if valore_predetto == '0' else prob_1

    logger.log(f"Sequenza iniziale: {''.join(initial_pattern)}")
    logger.log(f"Occorrenze trovate del pattern: {total}")
    logger.log(f"Probabilità '0': {prob_0:.2%} (occorrenze: {count_0})")
    logger.log(f"Probabilità '1': {prob_1:.2%} (occorrenze: {count_1})")
    logger.log(f"Valore predetto: {valore_predetto} (probabilità: {prob_valore:.2%})")

    carrello.aggiungi_predizione(file_binario, posizione, valore_predetto)

    # Aggiunto controllo per fermarsi se tutte le probabilità sono maggiori o uguali alla soglia
    if prob_0 >= soglia_minima / 100 and prob_1 >= soglia_minima / 100:
        return True

    return is_optimal

def processo_automatico(file_input, lunghezza_sequenza, righe_da_analizzare=10000, soglia_minima=100, analisi_automatica=False):
    cartella_output = os.path.dirname(os.path.abspath(file_input))
    nome_file = os.path.basename(file_input)
    logger = Logger(cartella_output)
    report_ottimali = ReportCasiOttimali(cartella_output)
    report_ruote_ottimali = ReportRuote(os.path.dirname(os.path.abspath(__file__)), "RUOTEOTTIMALI.txt")
    report_ruote_non_ottimali = ReportRuote(os.path.dirname(os.path.abspath(__file__)), "RUOTENONOTTIMALI.txt")
    logger.log(f"Inizio elaborazione")
    logger.log(f"File input: {nome_file}")
    logger.log(f"Cartella output: {cartella_output}")
    logger.log(f"Lunghezza sequenza: {lunghezza_sequenza}")
    logger.log(f"Righe da analizzare: {righe_da_analizzare}")
    logger.log(f"Soglia minima: {soglia_minima}%")
    logger.log("\nConversione file decimale in binari...")

    with open(file_input, 'r') as file:
        lines = []
        for i, line in enumerate(file):
            if i < righe_da_analizzare:
                lines.append(line)
            else:
                break

    temp_file = os.path.join(cartella_output, "temp_estrazioni.txt")
    with open(temp_file, 'w') as file:
        file.writelines(lines)

    file_binari = converte_file_decimale(temp_file, cartella_output, logger)
    carrello = CarrelloPredizioni()
    carrello.set_ruota(nome_file)
    is_ruota_ottimale = True

    for file_binario in file_binari:
        logger.log(f"\nElaborazione {os.path.basename(file_binario)}...")
        file_splittati = split_file_binario(file_binario, cartella_output, logger)
        for file_splittato in file_splittati:
            if not analizza_file(file_splittato, lunghezza_sequenza, carrello, logger, report_ottimali, nome_file, soglia_minima, analisi_automatica):
                is_ruota_ottimale = False

    if is_ruota_ottimale:
        report_ruote_ottimali.aggiungi_ruota(carrello.ruota_corrente)
    else:
        report_ruote_non_ottimali.aggiungi_ruota(carrello.ruota_corrente)

    carrello.mostra_risultati(logger, cartella_output)
    report_ottimali.finalizza_report()
    tempo_totale = logger.tempo_totale()
    logger.log(f"\nTempo totale di elaborazione: {tempo_totale}")
    logger.log(f"Report casi ottimali salvato in: {report_ottimali.report_path}")
    logger.log(f"Report ruote ottimali salvato in: {report_ruote_ottimali.report_path}")
    logger.log(f"Report ruote non ottimali salvato in: {report_ruote_non_ottimali.report_path}")

    os.remove(temp_file)

    return report_ottimali.casi_trovati

def ottieni_percorso_file_estrazioni(ruota):
    return os.path.join(ruota, f"estrazioni-{ruota}.txt")

def inizializza_report_ruote():
    script_dir = os.path.dirname(os.path.abspath(__file__))
    for nome_file in ["RUOTEOTTIMALI.txt", "RUOTENONOTTIMALI.txt"]:
        report_path = os.path.join(script_dir, nome_file)
        with open(report_path, 'w', encoding='utf-8') as f:
            f.write(f"=== {nome_file.replace('.txt', '').upper()} ===\n\n")

def main():
    root = Tk()
    root.title("Seleziona Ruote")

    pattern_frame = Frame(root)
    pattern_frame.pack(pady=10)
    Label(pattern_frame, text="Lunghezza pattern:").pack(side='left')
    pattern_length = Entry(pattern_frame, width=5)
    pattern_length.insert(0, "18")
    pattern_length.pack(side='left', padx=5)

    righe_frame = Frame(root)
    righe_frame.pack(pady=10)
    Label(righe_frame, text="Prime righe da analizzare:").pack(side='left')
    righe_da_analizzare = Entry(righe_frame, width=5)
    righe_da_analizzare.insert(0, "10000")
    righe_da_analizzare.pack(side='left', padx=5)

    soglia_frame = Frame(root)
    soglia_frame.pack(pady=10)
    Label(soglia_frame, text="Soglia minima di probabilità (%):").pack(side='left')
    soglia_minima = Entry(soglia_frame, width=5)
    soglia_minima.insert(0, "100")
    soglia_minima.pack(side='left', padx=5)

    analisi_automatica_var = IntVar()
    Checkbutton(root, text="Analisi e selezione automatica", variable=analisi_automatica_var).pack(pady=5)

    Label(root, text="Seleziona le ruote da analizzare:").pack()

    ruote = ["BA", "CA", "FI", "GE", "MI", "NA", "PA", "RO", "TO", "VE", "NZ"]
    ruote_vars = {ruota: IntVar() for ruota in ruote}

    checkbuttons_frame = Frame(root)
    checkbuttons_frame.pack(pady=5)

    for ruota in ruote:
        Checkbutton(checkbuttons_frame, text=ruota, variable=ruote_vars[ruota]).pack(anchor='w')

    buttons_frame = Frame(root)
    buttons_frame.pack(pady=10)

    def seleziona_tutto():
        for var in ruote_vars.values():
            var.set(1)

    def deseleziona_tutto():
        for var in ruote_vars.values():
            var.set(0)

    def analizza():
        try:
            lunghezza_seq = int(pattern_length.get())
            righe = int(righe_da_analizzare.get())
            soglia = float(soglia_minima.get())
            analisi_automatica = analisi_automatica_var.get()
            ruote_selezionate = [ruota for ruota, var in ruote_vars.items() if var.get()]

            inizializza_report_ruote()

            if analisi_automatica:
                lunghezza_seq_iniziale = lunghezza_seq
                while True:
                    casi_trovati = False
                    for ruota in ruote_selezionate:
                        file_input = ottieni_percorso_file_estrazioni(ruota)
                        if os.path.exists(file_input):
                            logger = Logger(os.path.dirname(os.path.abspath(file_input)))
                            logger.log(f"Analizzando ruota: {ruota}")
                            logger.log(f"File input: {file_input}")
                            logger.log(f"Lunghezza sequenza: {lunghezza_seq}")
                            logger.log(f"Righe da analizzare: {righe}")
                            logger.log(f"Soglia minima: {soglia}%")
                            if processo_automatico(file_input, lunghezza_seq, righe, soglia, analisi_automatica):
                                casi_trovati = True
                                logger.log(f"Ruota ottimale trovata: {ruota}")
                                report_ruote_ottimali = ReportRuote(os.path.dirname(os.path.abspath(__file__)), "RUOTEOTTIMALI.txt")
                                report_ruote_ottimali.aggiungi_ruota(f"RUOTA OTTIMALE: {ruota}")
                                winsound.Beep(1000, 2000)  # Emette un bip sonoro a 1000 Hz per 2 secondi
                                break
                    if casi_trovati:
                        break
                    lunghezza_seq += 1
                    logger.log(f"Aumentando la lunghezza del pattern a {lunghezza_seq}")
            else:
                for ruota in ruote_selezionate:
                    file_input = ottieni_percorso_file_estrazioni(ruota)
                    if os.path.exists(file_input):
                        logger = Logger(os.path.dirname(os.path.abspath(file_input)))
                        logger.log(f"Analizzando ruota: {ruota}")
                        logger.log(f"File input: {file_input}")
                        logger.log(f"Lunghezza sequenza: {lunghezza_seq}")
                        logger.log(f"Righe da analizzare: {righe}")
                        logger.log(f"Soglia minima: {soglia}%")
                        processo_automatico(file_input, lunghezza_seq, righe, soglia, analisi_automatica)
                    else:
                        print(f"File di estrazioni per la ruota {ruota} non trovato.")
        except ValueError:
            print("Errore: inserire valori numerici validi.")

    Button(buttons_frame, text="Seleziona Tutto", command=seleziona_tutto).pack(side='left', padx=5)
    Button(buttons_frame, text="Deseleziona Tutto", command=deseleziona_tutto).pack(side='left', padx=5)
    Button(buttons_frame, text="Analizza", command=analizza).pack(side='left', padx=5)

    root.mainloop()

if __name__ == "__main__":
    main()

Per testarlo, e magari contribuire alla sua ottimizzazione e/o correzione, è necessario creare 11 cartelle : BA , CA , FI ecc... fino a NZ con dentro i rispettivi file estrazioni-BA.txt ecc... contenenti ognuno le estrazioni della rispettiva ruota con la prima estrazione in alto e l'ultima in basso in formato con i 5 estratti a doppia cifra (i numeri da 1 a 9 con lo 0 davanti) intervallata da carattere punto (es. 01.88.77.32.05). AI utilizzate per adesso per questo script py: Claude Sonnet 3.5, DeepSeek, ChatGpt e Mistral. Selezionando "Analizza e seleziona automaticamente" lo script continuerà la ricerca ad libitum aumentando la lunghezza del pattern iniziale di una unità ad ogni nuovo ciclo.. Per adesso lo script si potrà interrompere solo bruscamente.. con ctrl + s (pausa) e ctrl + q (prosegui) o con ctrl + c (chiudi) o chiudendo direttamente la finestra dos. Per ovviare a questo comunque basta comunque implementarvi un bottone per chiuderlo in modo + dolce... o non selezionare quell'opzione di analisi automatica...

breve schema e spiegazione dell'idea di base che ho avuto e che mi ha spinto a voler cercare di realizzare questo script :

la sequenza di estratti di ogni estrazione e per ogni ruota viene convertita in rispettivi numeri binari a 7 bit i quali vengono a loro volta scomposti nelle 7 colonne di bit (da bit0 a bit6). Queste 7 colonne vengono analizzate una ad una a partire dal basso verso l'alto dopo che è stato costruito un pattern spia di ricerca prelevando i primi elementi di ciascuna colonna a partire dall'alto. Questa operazione si può fare sia staticamente scegliendo una lunghezza fissa sia dinamicamente lasciando appunto allo script di aumentare ad ogni ciclo la lunghezza del pattern di partenza... Lo script dovrà quindi annotarsi tutte le quantità di 0 e di 1 che incontrerà per ciascuna colonna di bit dopo la sequenza del pattern di ricerca e in base alla loro presenza maggiore e quindi relativa probabilità di apparizione ipotizzare quale ci sarà dopo l'ultimo bit in alto della rispettiva colonna analizzata... Per far questo è possibile scegliere statisticamente una % minima di presenza per far si che il bit che la raggiunge o supera sia considerato + probabile dell'altro.



Vedi l'allegato 2296926

Ciao lotto

Nonostante sia da ottimizzare e correggere su su molti punti condivido il code dell'ultima versione (script-analisi-0-1-versioneforsefinale-38.py) x i + smanettoni tra di voi In questa versione è stato corretto l'ordinamento di ricerca (dal basso verso l'alto e l'implementazione di un abbozzo di automazione e di ricerca della condizione teoricamente + ottimale). Anche l'interfaccia presenta molti + campi e bottoni rispetto alla soprastante.

import os
import time
from datetime import datetime
from tkinter import Tk, filedialog, Checkbutton, IntVar, Button, Label, Entry, Frame
from collections import Counter, defaultdict
import winsound

class Logger:
    def __init__(self, cartella_output):
        self.start_time = time.time()
        self.log_filename = os.path.join(cartella_output,
                                         f"log_elaborazione_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt")

    def log(self, messaggio):
        with open(self.log_filename, 'a', encoding='utf-8') as f:
            timestamp = datetime.now().strftime('%H:%M:%S')
            f.write(f"[{timestamp}] {messaggio}\n")
        print(messaggio)

    def tempo_totale(self):
        tempo_totale = time.time() - self.start_time
        return f"{tempo_totale:.2f} secondi"

class ReportCasiOttimali:
    def __init__(self, cartella_output):
        self.report_path = os.path.join(cartella_output, "reportcasiottimali.txt")
        with open(self.report_path, 'w', encoding='utf-8') as f:
            f.write("=== Report Casi Ottimali ===\n\n")
        self.casi_trovati = False

    def aggiungi_caso(self, file_estrazioni, file_b, posizione, prob_0, prob_1):
        self.casi_trovati = True
        with open(self.report_path, 'a', encoding='utf-8') as f:
            f.write(f"File estrazioni: {file_estrazioni}\n")
            f.write(f"File binario: {file_b}\n")
            f.write(f"Probabilità '0': {prob_0:.2%}\n")
            f.write(f"Probabilità '1': {prob_1:.2%}\n")
            f.write("-" * 50 + "\n")

    def finalizza_report(self):
        if not self.casi_trovati:
            with open(self.report_path, 'a', encoding='utf-8') as f:
                f.write("Nessun caso ottimale trovato.\n")

class ReportRuote:
    def __init__(self, cartella_output, nome_file):
        self.report_path = os.path.join(cartella_output, nome_file)
        if not os.path.exists(self.report_path):
            with open(self.report_path, 'w', encoding='utf-8') as f:
                f.write(f"=== {nome_file.replace('.txt', '').upper()} ===\n\n")

    def aggiungi_ruota(self, ruota):
        with open(self.report_path, 'a', encoding='utf-8') as f:
            f.write(f"{ruota}\n")

class CarrelloPredizioni:
    def __init__(self):
        self.carrelli = defaultdict(lambda: ['_'] * 7)
        self.ruota_corrente = None

    def set_ruota(self, nome_file_input):
        if nome_file_input.startswith('estrazioni-'):
            self.ruota_corrente = nome_file_input.split('-')[1].split('.')[0]

    def aggiungi_predizione(self, file_origine, posizione, valore):
        file_base = os.path.basename(file_origine)
        parti = file_base.split('-')
        numero_file = ''.join(filter(str.isdigit, parti[0]))
        chiave = f"b{numero_file}"
        try:
            posizione = int(parti[1].split('.')[0])
            if 0 <= posizione < 7:
                self.carrelli[chiave][posizione] = valore
        except (ValueError, IndexError) as e:
            print(f"Errore: {e}")

    def mostra_risultati(self, logger, cartella_output):
        logger.log("\n=== Risultati Finali ===")
        script_dir = os.path.dirname(os.path.abspath(__file__))
        report_path = os.path.join(script_dir, "previsionielaborate.txt")
        numeri_decimali = []
        for chiave in sorted(self.carrelli.keys()):
            sequenza_binaria = ''.join(self.carrelli[chiave])
            numero_decimale = str(int(sequenza_binaria, 2))
            numeri_decimali.append(numero_decimale)
            logger.log(f"{chiave}.txt: {numero_decimale} (binario: {sequenza_binaria} = {int(sequenza_binaria, 2)})")
        with open(report_path, 'a', encoding='utf-8') as report:
            if self.ruota_corrente and numeri_decimali:
                report.write(f"{self.ruota_corrente} {'-'.join(numeri_decimali)}\n")
        logger.log("=====================")
        logger.log(f"Report salvato in: {report_path}")

def decimale_a_binario(decimale):
    return '.'.join(format(int(decimale), '07b'))

def converte_file_decimale(file_decimale, cartella_output, logger):
    colonne = []
    with open(file_decimale, 'r') as file:
        for linea in file:
            valori = linea.strip().split('.')
            for i, valore in enumerate(valori):
                if len(colonne) <= i:
                    colonne.append([])
                colonne[i].append(decimale_a_binario(valore))
    file_binari = []
    for i, colonna in enumerate(colonne):
        nome_file = os.path.join(cartella_output, f"b{i + 1}.txt")
        with open(nome_file, 'w') as file:
            file.write('\n'.join(colonna))
        file_binari.append(nome_file)
        logger.log(f"File binario generato: {nome_file}")
    return file_binari

def split_file_binario(file_binario, cartella_output, logger):
    base_name = os.path.basename(file_binario)
    numero_file = ''.join(filter(str.isdigit, base_name.split('.')[0]))
    with open(file_binario, 'r') as file:
        righe = [line.strip().split('.') for line in file]
        colonne = list(zip(*righe))
    file_splittati = []
    for i, colonna in enumerate(colonne):
        nome_file = os.path.join(cartella_output, f"b{numero_file}-{i}.txt")
        with open(nome_file, 'w') as file:
            file.write('\n'.join(colonna))
        file_splittati.append(nome_file)
        logger.log(f"File splittato generato: {nome_file}")
    return file_splittati

def carica_dati(file_path):
    with open(file_path, 'r') as file:
        # Legge i dati e INVERTE l'ordine per avere i più vecchi in alto durante l'analisi
        dati = [bit for line in file for bit in line.strip().split('.')]
        return dati[::-1]  # <-- Modifica chiave qui

def analizza_file(file_binario, lunghezza_sequenza, carrello, logger, report_ottimali, file_estrazioni,
                  soglia_minima, analisi_automatica):
    posizione = int(os.path.basename(file_binario).split('-')[1].split('.')[0])
    dati = carica_dati(file_binario)  # Dati ora sono invertiti: [vecchio, ..., recente]

    logger.log(f"\nAnalisi pattern per {file_binario}")
    logger.log(f"Posizione bit analizzata: bit{posizione}.txt")
    logger.log(f"Lunghezza sequenza pattern: {lunghezza_sequenza}")

    # Controllo per assicurarsi che la lunghezza del pattern sia valida
    if lunghezza_sequenza <= 0:
        logger.log(f"Lunghezza sequenza pattern non valida: {lunghezza_sequenza}")
        return False

    # Pattern iniziale preso dalla FINE dei dati invertiti (corrisponde ai più RECENTI nel file originale)
    initial_pattern = tuple(dati[-lunghezza_sequenza:])  # <-- Modifica qui

    preceding_bits = []

    # Analizza dal basso (vecchio) verso l'alto (recente) nei dati invertiti
    for i in range(len(dati) - lunghezza_sequenza):
        current_window = tuple(dati[i:i + lunghezza_sequenza])
        if current_window == initial_pattern and i + lunghezza_sequenza < len(dati):
            # Il bit successivo è quello DOPO la finestra, verso l'alto (più recente)
            preceding_bit = dati[i + lunghezza_sequenza]
            preceding_bits.append(preceding_bit)

    count_0 = preceding_bits.count('0')
    count_1 = preceding_bits.count('1')
    total = len(preceding_bits)

    if total == 0:
        prob_0, prob_1 = 0.5, 0.5
    else:
        prob_0 = count_0 / total
        prob_1 = count_1 / total

    occ = {'0': count_0, '1': count_1}
    TOLLERANZA = 0.0001
    is_optimal = any(abs(prob - 1.0) < TOLLERANZA for prob in [prob_0, prob_1])

    # Controllo per identificare i casi con esattamente un bit inferiore alla soglia minima
    if analisi_automatica:
        bit_inferiori = [bit for bit in preceding_bits if (bit == '0' and prob_0 < soglia_minima / 100) or (bit == '1' and prob_1 < soglia_minima / 100)]
        if len(bit_inferiori) == 1:
            file_b = os.path.basename(file_binario).split('-')[0] + ".txt"
            report_ottimali.aggiungi_caso(
                os.path.basename(file_estrazioni),
                file_b,
                posizione,
                prob_0,
                prob_1
            )
            return True

    valore_predetto = '0' if prob_0 > prob_1 else '1'
    prob_valore = prob_0 if valore_predetto == '0' else prob_1

    logger.log(f"Sequenza iniziale: {''.join(initial_pattern)}")
    logger.log(f"Occorrenze trovate del pattern: {total}")
    logger.log(f"Probabilità '0': {prob_0:.2%} (occorrenze: {count_0})")
    logger.log(f"Probabilità '1': {prob_1:.2%} (occorrenze: {count_1})")
    logger.log(f"Valore predetto: {valore_predetto} (probabilità: {prob_valore:.2%})")

    carrello.aggiungi_predizione(file_binario, posizione, valore_predetto)

    # Aggiunto controllo per fermarsi se tutte le probabilità sono maggiori o uguali alla soglia
    if prob_0 >= soglia_minima / 100 and prob_1 >= soglia_minima / 100:
        return True

    return is_optimal

def processo_automatico(file_input, lunghezza_sequenza, righe_da_analizzare=10000, soglia_minima=100, analisi_automatica=False):
    cartella_output = os.path.dirname(os.path.abspath(file_input))
    nome_file = os.path.basename(file_input)
    logger = Logger(cartella_output)
    report_ottimali = ReportCasiOttimali(cartella_output)
    report_ruote_ottimali = ReportRuote(os.path.dirname(os.path.abspath(__file__)), "RUOTEOTTIMALI.txt")
    report_ruote_non_ottimali = ReportRuote(os.path.dirname(os.path.abspath(__file__)), "RUOTENONOTTIMALI.txt")
    logger.log(f"Inizio elaborazione")
    logger.log(f"File input: {nome_file}")
    logger.log(f"Cartella output: {cartella_output}")
    logger.log(f"Lunghezza sequenza: {lunghezza_sequenza}")
    logger.log(f"Righe da analizzare: {righe_da_analizzare}")
    logger.log(f"Soglia minima: {soglia_minima}%")
    logger.log("\nConversione file decimale in binari...")

    with open(file_input, 'r') as file:
        lines = []
        for i, line in enumerate(file):
            if i < righe_da_analizzare:
                lines.append(line)
            else:
                break

    temp_file = os.path.join(cartella_output, "temp_estrazioni.txt")
    with open(temp_file, 'w') as file:
        file.writelines(lines)

    file_binari = converte_file_decimale(temp_file, cartella_output, logger)
    carrello = CarrelloPredizioni()
    carrello.set_ruota(nome_file)
    is_ruota_ottimale = True

    for file_binario in file_binari:
        logger.log(f"\nElaborazione {os.path.basename(file_binario)}...")
        file_splittati = split_file_binario(file_binario, cartella_output, logger)
        for file_splittato in file_splittati:
            if not analizza_file(file_splittato, lunghezza_sequenza, carrello, logger, report_ottimali, nome_file, soglia_minima, analisi_automatica):
                is_ruota_ottimale = False

    if is_ruota_ottimale:
        report_ruote_ottimali.aggiungi_ruota(carrello.ruota_corrente)
    else:
        report_ruote_non_ottimali.aggiungi_ruota(carrello.ruota_corrente)

    carrello.mostra_risultati(logger, cartella_output)
    report_ottimali.finalizza_report()
    tempo_totale = logger.tempo_totale()
    logger.log(f"\nTempo totale di elaborazione: {tempo_totale}")
    logger.log(f"Report casi ottimali salvato in: {report_ottimali.report_path}")
    logger.log(f"Report ruote ottimali salvato in: {report_ruote_ottimali.report_path}")
    logger.log(f"Report ruote non ottimali salvato in: {report_ruote_non_ottimali.report_path}")

    os.remove(temp_file)

    return report_ottimali.casi_trovati

def ottieni_percorso_file_estrazioni(ruota):
    return os.path.join(ruota, f"estrazioni-{ruota}.txt")

def inizializza_report_ruote():
    script_dir = os.path.dirname(os.path.abspath(__file__))
    for nome_file in ["RUOTEOTTIMALI.txt", "RUOTENONOTTIMALI.txt"]:
        report_path = os.path.join(script_dir, nome_file)
        with open(report_path, 'w', encoding='utf-8') as f:
            f.write(f"=== {nome_file.replace('.txt', '').upper()} ===\n\n")

def main():
    root = Tk()
    root.title("Seleziona Ruote")

    pattern_frame = Frame(root)
    pattern_frame.pack(pady=10)
    Label(pattern_frame, text="Lunghezza pattern:").pack(side='left')
    pattern_length = Entry(pattern_frame, width=5)
    pattern_length.insert(0, "18")
    pattern_length.pack(side='left', padx=5)

    righe_frame = Frame(root)
    righe_frame.pack(pady=10)
    Label(righe_frame, text="Prime righe da analizzare:").pack(side='left')
    righe_da_analizzare = Entry(righe_frame, width=5)
    righe_da_analizzare.insert(0, "10000")
    righe_da_analizzare.pack(side='left', padx=5)

    soglia_frame = Frame(root)
    soglia_frame.pack(pady=10)
    Label(soglia_frame, text="Soglia minima di probabilità (%):").pack(side='left')
    soglia_minima = Entry(soglia_frame, width=5)
    soglia_minima.insert(0, "100")
    soglia_minima.pack(side='left', padx=5)

    analisi_automatica_var = IntVar()
    Checkbutton(root, text="Analisi e selezione automatica", variable=analisi_automatica_var).pack(pady=5)

    Label(root, text="Seleziona le ruote da analizzare:").pack()

    ruote = ["BA", "CA", "FI", "GE", "MI", "NA", "PA", "RO", "TO", "VE", "NZ"]
    ruote_vars = {ruota: IntVar() for ruota in ruote}

    checkbuttons_frame = Frame(root)
    checkbuttons_frame.pack(pady=5)

    for ruota in ruote:
        Checkbutton(checkbuttons_frame, text=ruota, variable=ruote_vars[ruota]).pack(anchor='w')

    buttons_frame = Frame(root)
    buttons_frame.pack(pady=10)

    def seleziona_tutto():
        for var in ruote_vars.values():
            var.set(1)

    def deseleziona_tutto():
        for var in ruote_vars.values():
            var.set(0)

    def analizza():
        try:
            lunghezza_seq = int(pattern_length.get())
            righe = int(righe_da_analizzare.get())
            soglia = float(soglia_minima.get())
            analisi_automatica = analisi_automatica_var.get()
            ruote_selezionate = [ruota for ruota, var in ruote_vars.items() if var.get()]

            inizializza_report_ruote()

            if analisi_automatica:
                lunghezza_seq_iniziale = lunghezza_seq
                while True:
                    casi_trovati = False
                    for ruota in ruote_selezionate:
                        file_input = ottieni_percorso_file_estrazioni(ruota)
                        if os.path.exists(file_input):
                            logger = Logger(os.path.dirname(os.path.abspath(file_input)))
                            logger.log(f"Analizzando ruota: {ruota}")
                            logger.log(f"File input: {file_input}")
                            logger.log(f"Lunghezza sequenza: {lunghezza_seq}")
                            logger.log(f"Righe da analizzare: {righe}")
                            logger.log(f"Soglia minima: {soglia}%")
                            if processo_automatico(file_input, lunghezza_seq, righe, soglia, analisi_automatica):
                                casi_trovati = True
                                logger.log(f"Ruota ottimale trovata: {ruota}")
                                report_ruote_ottimali = ReportRuote(os.path.dirname(os.path.abspath(__file__)), "RUOTEOTTIMALI.txt")
                                report_ruote_ottimali.aggiungi_ruota(f"RUOTA OTTIMALE: {ruota}")
                                winsound.Beep(1000, 2000)  # Emette un bip sonoro a 1000 Hz per 2 secondi
                                break
                    if casi_trovati:
                        break
                    lunghezza_seq += 1
                    logger.log(f"Aumentando la lunghezza del pattern a {lunghezza_seq}")
            else:
                for ruota in ruote_selezionate:
                    file_input = ottieni_percorso_file_estrazioni(ruota)
                    if os.path.exists(file_input):
                        logger = Logger(os.path.dirname(os.path.abspath(file_input)))
                        logger.log(f"Analizzando ruota: {ruota}")
                        logger.log(f"File input: {file_input}")
                        logger.log(f"Lunghezza sequenza: {lunghezza_seq}")
                        logger.log(f"Righe da analizzare: {righe}")
                        logger.log(f"Soglia minima: {soglia}%")
                        processo_automatico(file_input, lunghezza_seq, righe, soglia, analisi_automatica)
                    else:
                        print(f"File di estrazioni per la ruota {ruota} non trovato.")
        except ValueError:
            print("Errore: inserire valori numerici validi.")

    Button(buttons_frame, text="Seleziona Tutto", command=seleziona_tutto).pack(side='left', padx=5)
    Button(buttons_frame, text="Deseleziona Tutto", command=deseleziona_tutto).pack(side='left', padx=5)
    Button(buttons_frame, text="Analizza", command=analizza).pack(side='left', padx=5)

    root.mainloop()

if __name__ == "__main__":
    main()

Per testarlo, e magari contribuire alla sua ottimizzazione e/o correzione, è necessario creare 11 cartelle : BA , CA , FI ecc... fino a NZ con dentro i rispettivi file estrazioni-BA.txt ecc... contenenti ognuno le estrazioni della rispettiva ruota con la prima estrazione in alto e l'ultima in basso in formato con i 5 estratti a doppia cifra (i numeri da 1 a 9 con lo 0 davanti) intervallata da carattere punto (es. 01.88.77.32.05). AI utilizzate per adesso per questo script py: Claude Sonnet 3.5, DeepSeek, ChatGpt e Mistral. Selezionando "Analizza e seleziona automaticamente" lo script continuerà la ricerca ad libitum aumentando la lunghezza del pattern iniziale di una unità ad ogni nuovo ciclo.. Per adesso lo script si potrà interrompere solo bruscamente.. con ctrl + s (pausa) e ctrl + q (prosegui) o con ctrl + c (chiudi) o chiudendo direttamente la finestra dos. Per ovviare a questo comunque basta comunque implementarvi un bottone per chiuderlo in modo + dolce... o non selezionare quell'opzione di analisi automatica...

breve schema e spiegazione dell'idea di base che ho avuto e che mi ha spinto a voler cercare di realizzare questo script :

la sequenza di estratti di ogni estrazione e per ogni ruota viene convertita in rispettivi numeri binari a 7 bit i quali vengono a loro volta scomposti nelle 7 colonne di bit (da bit0 a bit6). Queste 7 colonne vengono analizzate una ad una a partire dal basso verso l'alto dopo che è stato costruito un pattern spia di ricerca prelevando i primi elementi di ciascuna colonna a partire dall'alto. Questa operazione si può fare sia staticamente scegliendo una lunghezza fissa sia dinamicamente lasciando appunto allo script di aumentare ad ogni ciclo la lunghezza del pattern di partenza... Lo script dovrà quindi annotarsi tutte le quantità di 0 e di 1 che incontrerà per ciascuna colonna di bit dopo la sequenza del pattern di ricerca e in base alla loro presenza maggiore e quindi relativa probabilità di apparizione ipotizzare quale ci sarà dopo l'ultimo bit in alto della rispettiva colonna analizzata... Per far questo è possibile scegliere statisticamente una % minima di presenza per far si che il bit che la raggiunge o supera sia considerato + probabile dell'altro.



Vedi l'allegato 2296926

Ciao lotto_tom75 ho un piccolo dubbio, allora l'estrazione ultima del 15/02 andrebbe posizionata in basso nell' archivio e su su a salire quelle piu' vecchie ? Grazie

 

[lotto_tom75]

Ciao lotto

Ciao lotto_tom75 ho un piccolo dubbio, allora l'estrazione ultima del 15/02 andrebbe posizionata in basso nell' archivio e su su a salire quelle piu' vecchie ? Grazie

No esattamente l'opposto... ma in realtà se ne occupa lo script .ls e .py di posizionare sia le estrazioni (.ls) che i relativi bit (.py) nell'ordine giusto (in alto le recenti e in basso le + vecchie).