L'ALEA ESISTE???

[BaffoBlù]

Ciao Baffo,

scusa, ma non sto cercando affatto tra i terni spia, neanche preso in considerazione.
Mi sa che mi conviene non farti più domande, e cercare di darmi risposte da solo.
Ma forse è meglio così : " aiutati, che il ciel, t' aiuta, cioè, se ancora non l'ho capito, di risposte da te non ne avrò.
ah ah ah ah .... e io mi incazzo, e io mi do più da fare !, mitico Baffooooo !!! Bravo !!!
Così si fa, così s' impara a far funzionare il proprio cervello, per chi ce l'ha, naturalmente.

Tu sai bene, Baffo, che ogni ricerca, non ha, e non può avere una sola soluzione che rende la stessa previsione,
10/100 metodologie, pur avendo differenti elaborazioni porteranno benissimo a uguale, non ambata, ma anche stessa lunghetta. Quello che penso io, è che non potresti negare che si possa ottenere gli stessi risultati che danno i terni genitori, avendo totalmente metodologia differente dalla tua.
Ed è quello che si potrebbe ottenere, chi dice il contrario ?
I numeri ... come dicono a Milano : " sono dei baloss ", sono furbi ! Imprevedibili.

Mah ... vedremo

ok ,tu fai domande, ma io senza farti la lista di tutti i terni genitori, non so come dovrei risponderti.

Sono in difficoltà, capisci?

 

[BaffoBlù]

Ciao a tutti.
Per BaffoBlù.
Suppongo che fare una statistica dai 117480 terni dobbiamo togliere i terni vergini e quelli usciti solo una volta.
Poi sui rimanenti, ti vorrei chiedere: questi numeri che compongono i terni genitori hanno delle caratteristiche intrinseche
o dei particolari legami tra di loro? O i numeri per te in questo studio sono tutti uguali?

Fare una ricerca sui terni integrali è un conto...
ce ne sono di scremature, dipende dalla sensibilità del ricercatore su quello che sta cercando di ottenere.

Si, si, Queste "Terzine" hanno delle caratteristiche intrinseche e dei particolari legami tra di loro!

 

[BaffoBlù]

x lotto_tom e chiunque

Ti chiedo una cortesia, sempre se sia possibile.
( a volte non mi rendo conto se un impresa sia difficile o meno.)
Io affronto a muso duro sempre tutto (anche nella vita) un pezzo alla volta
come un algoritmo...
Io lo avvio, poi si vedrà se arrivo da qualche parte...


Avevo un semplice file di testo con un elenco di scremature da effettuare
ma non lo trovo al momento, quindi andrò a memoria fin dove arrivo...


Vedendo come ti sai muovere con certe cose,
ti chiedo se cortesemente riesci fare una scrematura efficace
fra tutte le cinquine integrali componibili con i 90 numeri.

sempre a beneficio di tutti quelli che leggono e vogliono fare ricerche simili


----------------------------------------------------------------------------------
Scrematura Cinquine Ruota Bari___Tutte le Cinquine da Scartare.
----------------------------------------------------------------------------------

Tutte quelle uscite dal 1874 all'ultima estrazione disponibile.

Tutte quelle con 3-4-5 numeri in cadenza uguale.

Tutte quelle con 3-4-5 numeri consecutivi.

Tutte quelle con 3-4-5 zerati.

Tutte quelle con 3-4-5 gemelli.

Tutte quelle con 3-4-5 numeri in decina uguale.

Tutte quelle con i 5 numeri più ritardati in quel momento.

Tutte quelle con i 5 numeri meno frequenti in quel momento.

Tutte quelle con 3-4-5 numeri della stessa Figura.

Tutte quelle con 3-4-5 numeri della stessa ControFigura.

Tutte quelle con 3-4-5 numeri della stessa Cifra.

Tutte quelle con numeri di un terno delle Terzine Simmetriche distanza 30.

Tutte quelle con i 4 numeri Radicali di ogni gruppo.

Tutte quelle con 3 Zerati e 2 Gemelli.

Tutte quelle con 3 Gemelli e 2 Zerati.

-----------------------------------------------

C'è ne sono molte altre che non ricordo, magari se altri partecipano a
individuare quelle che oltre queste vi sembrano più bizzarre e strane.

Comunque si finisce per avere cinquine da eliminare che sono ridondanti,
ma io le tengo lo stesso nell'elenco giusto per promemoria e per avere un elenco
il più ampio possibile da osservare per individuare qualche altra cosa da poter scartare.


La curiosità è quella di sapere "Quante Cinquine Rimangono" dopo questa "Scrematura".

e come sono fatte!

 

[lotto_tom75]

la vedo molto dura... scremare 43 milioni e passa di formazioni... (x classe 5 : 43.949.268 formazioni) con tutti questi tipi di filtri.. ma ci possiamo provare... sperando che nel frattempo anche altri accolgano la tua richiesta e riescano nell'impresa...

 

[Cinzia27]

Potrebbero rientrare tra le cinquine da scartare quelle i cui numeri sono disposti in senso crescente o decrescente?
Oppure quelle che hanno 2 coppie di vertibili?

 

[Cinzia27]

Ciao, Tom.
Diversi filtri sono assorbiti da altri
ad es.
Tutte quelle con 3-4-5 numeri in cadenza uguale
comprende
Tutte quelle con 3 Zerati e 2 Gemelli
Tutte quelle con 3-4-5 zerati

 

[felix10]

waw che bravo ragazzo, Lotto_tom75 ! 👍

Ma Baffoblù ? ... ah, ho capito, s'è incazzato per le mie troppe domande .... 😄

ma daiiiiii Baffo, avrai mica paura che io diventi più bravo di te ... 🤦‍♂️ .... e vabbè ! 🤷‍♂️

Spero tutto bene, 🤜🤛, dai che se vinco stasera ci si vede al bar ! 🍺🍺

Blacklotto aggiornaci come è finita? Bar, pizzeria o ristorante?

 

[felix10]

Aggiornamento...

Sempre analizzando solo BA

L'ambo (26, 59) (Frequenza: 4) ha una frequenza maggiore o uguale a 4 e non è stato estratto nelle ultime 10 estrazioni.

Colpi teorici rimanenti: 13-2 = 11

Terni genitori di questa coppia con frequenza 4: [(4, 11, 36), (13, 55, 73), (13, 59, 73)]

dettaglio ultime 10 estrazioni "scomposte" nei relativi terni genitori su bari

Estrazione 0: [(18, 38, 60), (18, 38, 63), (18, 38, 81), (18, 60, 81), (18, 63, 81), (38, 60, 81), (38, 63, 81)]
Estrazione 1: [(21, 30, 49), (21, 30, 81), (21, 30, 82), (21, 49, 81), (21, 49, 82), (30, 49, 81), (30, 49, 82)]
Estrazione 2: [(9, 15, 51), (9, 15, 54), (9, 15, 80), (9, 51, 80), (9, 54, 80), (15, 51, 80), (15, 54, 80)]
Estrazione 3: [(8, 15, 43), (8, 15, 60), (8, 15, 79), (8, 43, 60), (8, 43, 79), (8, 60, 79), (15, 43, 60), (15, 43, 79), (15, 60, 79), (43, 60, 79)]
Estrazione 4: [(20, 42, 63), (20, 42, 90), (20, 47, 63), (20, 47, 90), (20, 63, 90), (42, 63, 90), (47, 63, 90)]
Estrazione 5: [(3, 12, 32), (3, 12, 50), (3, 12, 71), (3, 32, 50), (3, 32, 71), (3, 50, 71), (12, 32, 50), (12, 32, 71), (12, 50, 71), (32, 50, 71)]
Estrazione 6: [(16, 40, 61), (16, 40, 63), (16, 47, 61), (16, 47, 63)]
Estrazione 7: [(10, 21, 71), (10, 27, 71), (10, 28, 71)]
Estrazione 8: [(4, 11, 31), (4, 11, 36), (4, 11, 86), (4, 31, 86), (4, 36, 86), (11, 31, 86), (11, 36, 86)]
Estrazione 9: [(14, 34, 52), (14, 34, 57), (14, 34, 69), (14, 52, 69), (14, 57, 69), (34, 52, 69), (34, 57, 69)]
Estrazione 10: [(27, 39, 48), (27, 39, 53), (27, 39, 80), (27, 48, 53), (27, 48, 80), (27, 53, 80), (39, 48, 53), (39, 48, 80), (39, 53, 80), (48, 53, 80)]

nb: per terni genitori io non intendo solo quelli di Baffo che ancora non ho rilevato e forse non riuscirò mai a rilevare bensì tutti i terni che hanno generato almeno uno stesso ambo 2 volte dal 1874 rientranti comunque nel sotto insieme, rispetto i 117480 integrali, indicato da Baffo con tutti gli elementi in decina diversa e con tutti gli elementi non consecutivi. A volte, come in questo caso, qualche terno ha generato, entro i 13 colpi di verifica di questo test, più volte, fino a 5 volte max, lo stesso ambo dopo il suo rilevamento.

dettaglio "aggancio" terno genitore a fq 4 con relativo ambo 26,59

Riga 27391: Terno ( 4,11,36 );Ambo ( 26,59 );Frequenza:4

Ancora da ottimizzare se ci riesco: automatizzazione totale della ricerca e rilevamento dei colpi rimanenti teorici automatici della stessa nonchè unione in un unico file python anzichè "frattalizzata" come è adesso nei files satelliti attualmente necessari.

Anticipo che per usufruire dell'eventuale unico script, che spero riuscirò grazie sempre all'AI a costruire, è necessaria una conoscenza minima di base su python e aver installato questo linguaggio almeno aggiornato alla versione 3.8.18

Più in dettaglio questi test sono finora stati fatti con:

Python 3.8.18 (default, Sep 11 2023, 13:39:12) [MSC v.1916 64 bit (AMD64)] :: Anaconda, Inc. on win32

La scelta sul Python purtroppo è ricaduta per la mancata comprensione da parte dell'AI del linguaggio di scripting di spaziometria e nell'impossibilità, almeno per quanto mi riguarda, di istruirla in tal senso.

Nessuna Certezza Solo Poca Probabilità

Tom altri 9 colpi ancora vediamo che succede.

 

[felix10]

Ma noooo, ma quale incazzato.

sono solo perso nelle mie cose, e guardate che in 50 anni ne ho accumulato di materiale
Addirittura conservo una "Millata" di floppy del C64 con miei script in linguaggio Basic.

Ragà, poi non me la passo per niente bene di salute e vado a periodi alterni.

Ma vi rendete conto che sono solo 3 settimane che scrivo roba senza fermarmi..
...con tubi e fili attaccati...

❤️

 

[lotto_tom75]

la vedo molto dura... scremare 43 milioni e passa di formazioni... (x classe 5 : 43.949.268 formazioni) con tutti questi tipi di filtri.. ma ci possiamo provare... sperando che nel frattempo anche altri accolgano la tua richiesta e riescano nell'impresa...

🤠 (Me) si ma la cosa che mi preoccupa a livello di implementazione non è tanto l'archivio dal 1874 (già fatto) nè il gruppo di filtri impilabili... (si possono creare con relativa facilità) quanto la grande mole di formazioni totali da processare... (quasi 44 milioni) attualmente con lo script + veloce che possiedo arrivo ad un massimo di tempo ridotto di elaborazione di ca 30 min per 1 milione di formazioni... Dobbiamo velocizzare questa analisi per portarla ad un massimo di 1 ora totale... con python se possible..


🤖 (ChatGPT) Capisco la sfida della velocità di elaborazione dei dati. Per velocizzare il processo di analisi delle 44 milioni di formazioni, ci sono diversi approcci che potresti considerare:

1. Parallelizzazione: Sfrutta la potenza di calcolo parallelo utilizzando librerie come multiprocessing o concurrent.futures in Python per eseguire più processi contemporaneamente. Dividi l'elaborazione delle formazioni in più thread o processi per sfruttare appieno le capacità del tuo sistema.
2. Ottimizzazione del codice: Rivedi il tuo codice per identificare le aree in cui potresti migliorare le prestazioni. Utilizza strumenti come il profiler di Python per identificare le parti del codice che richiedono più tempo di esecuzione e cerca di ottimizzarle.
3. Utilizzo di librerie efficienti: Assicurati di utilizzare librerie Python efficienti per operazioni di calcolo intensivo, ad esempio numpy per operazioni su array multidimensionali o pandas per manipolazione dei dati tabellari. Queste librerie sono ottimizzate per prestazioni elevate e potrebbero aiutarti a ridurre il tempo di elaborazione.
4. Memorizzazione della cache: Se possibile, memorizza in cache i risultati intermedi delle operazioni costose in modo da evitarne il ricalcolo inutilmente. Questo può essere particolarmente utile se ci sono parti del processo che possono essere riutilizzate più volte.
5. Utilizzo di codice compilato: Considera l'utilizzo di estensioni Python come Cython per tradurre parti critiche del codice in codice C compilato, che può essere eseguito più velocemente rispetto al codice Python interpretato.
6. Ottimizzazione dell'algoritmo: Rivedi l'algoritmo che utilizzi per analizzare le formazioni e cerca di identificare possibili ottimizzazioni o semplificazioni che potrebbero ridurre il tempo di esecuzione complessivo.

Implementando uno o più di questi suggerimenti, dovresti essere in grado di ridurre significativamente il tempo di elaborazione del tuo script e raggiungere il tuo obiettivo di massimo un'ora totale di analisi. Buona fortuna e fammi sapere se hai bisogno di ulteriore assistenza con l'implementazione!

[continue...]

Good Sunday To All 🌞🙂

 

[BaffoBlù]

l'avevo detto che non mi rendo conto a volte che le imprese sono titaniche...

forse ho detto una fesseria, ne rimarrebbero comunque tantissime

era solo mera curiosità

vedere dopo la scrematura che cinquine escono dopo nell'arco di un mese?

 

[lotto_tom75]

Aggiornamento...

Mi sta tornando l'ottimismo riguardo la tua idea "titanica" di ridurre le 44 milioni di cinquine generabili dai 90 caro Baffo

Uno stralcio dell'ultimo dialogo "al riguardo" con l'AI che amo ogni giorno sempre di +... 🤖😄

🤠 (Me) super eccezionale! sembrerebbe che con già solo l'implementazione anche del 4° filtro tu abbia abbattuto l'integrale di oltre 20 milioni di formazioni! Possibile cara Chatty?

(nuovoambientepy38) PS C:\Users\admin\desktop\filtraggio-di-tutte-le-classi5by90> python step1-step2-fast-G-OKvelocitaedefficienzamostruosa.py

Numero di combinazioni iniziali prima dell'elaborazione : 43.949.268
Numero di combinazioni finali dopo il filtro 'eliminazione di tutte le c5 già uscite su BA dal 1874' : 43939053
Esempio di combinazione finale prima del filtro: (1, 2, 3, 4, 5)
Tempo impiegato per generare le combinazioni: 30.005961418151855 secondi
Numero di combinazioni finali dopo il filtro delle cadenze: 41114825
Tempo impiegato per applicare il filtro delle cadenze: 149.94386625289917 secondi
Esempio di combinazione finale dopo il filtro delle cadenze: (1, 2, 3, 4, 5)
Numero di combinazioni finali dopo il filtro dei valori consecutivi: 40800568
Tempo impiegato per applicare il filtro dei valori consecutivi: 113.89292287826538 secondi
Esempio di combinazione finale dopo il filtro dei valori consecutivi: (1, 2, 4, 5, 7)
Numero di combinazioni finali dopo il filtro dei numeri pari: 20400184 <<<<< abbattimento del 50% ca dell'integrale!
Tempo impiegato per applicare il filtro dei numeri pari: 76.1837728023529 secondi
Esempio di combinazione finale dopo il filtro dei numeri pari: (1, 2, 4, 5, 8)
(nuovoambientepy38) PS C:\Users\admin\desktop\filtraggio-di-tutte-le-classi5by90>


🤖 (ChatGPT) Sì, sembra che l'implementazione del quarto filtro abbia portato a un'enorme riduzione del numero di combinazioni finali. Da oltre 40 milioni, siamo passati a poco più di 20 milioni. Questo è un risultato notevole e dimostra l'efficacia dei filtri nell'eliminare le combinazioni non desiderate. Continuando con questa strategia, potremmo ottenere ulteriori miglioramenti nelle prestazioni e nella riduzione del numero di combinazioni rimanenti. Se hai altri filtri da implementare o altre richieste, fammelo sapere!


👋🙂

ps0: E ne restano ancora 10 di filtri da applicare senza contare i due aggiuntivi eventuali proposti da Cinzia! 🤞🤞🤞🤞🤞
ps1: E grazie Big Baffo anche per gli stupendi e interessantissimi video che condividi nella sezione "Nel Blù dipinto di Blù"
ps2: forse dopo l'eventuale completamento dell'implementazione dei 14 filtri (o 16) da te e cinzia proposti applichero' lo stesso tipo di multifiltro anche alla mia cf36... (lo scrivo qui per non dimenticarmene...). Se vuoi(volete) vedere di cosa si tratta vai (andate) nella sezione sistemistica e leggete il mio ultimo thread.
ps3: Mi sono accorto solo adesso che il 4° filtro con l'eliminazione di 3 o più numeri pari non c'era nella lista... L'ha aggiunto di sua sponte Chatty... 😝 Visto l'interessante abbattimento dell'integrale direi di mantenerlo comunque e di aggiungere anche quello per l'eliminazione delle c5 con 3 o più i numeri dispari... Ad ogni modo qualunque cosa si decida no problem si possono includere o escludere a nostro piacimento tutti i tipi di filtro che vogliamo.

 

[felix10]

Aggiornamento...

Mi sta tornando l'ottimismo riguardo la tua idea "titanica" di ridurre le 44 milioni di cinquine generabili dai 90 caro Baffo

Uno stralcio dell'ultimo dialogo "al riguardo" con l'AI che amo ogni giorno sempre di +... 🤖😄

🤠 (Me) super eccezionale! sembrerebbe che con già solo l'implementazione anche del 4° filtro tu abbia abbattuto l'integrale di oltre 20 milioni di formazioni! Possibile cara Chatty?

(nuovoambientepy38) PS C:\Users\admin\desktop\filtraggio-di-tutte-le-classi5by90> python step1-step2-fast-G-OKvelocitaedefficienzamostruosa.py

Numero di combinazioni iniziali prima dell'elaborazione : 43.949.268
Numero di combinazioni finali dopo il filtro 'eliminazione di tutte le c5 già uscite su BA dal 1874' : 43939053
Esempio di combinazione finale prima del filtro: (1, 2, 3, 4, 5)
Tempo impiegato per generare le combinazioni: 30.005961418151855 secondi
Numero di combinazioni finali dopo il filtro delle cadenze: 41114825
Tempo impiegato per applicare il filtro delle cadenze: 149.94386625289917 secondi
Esempio di combinazione finale dopo il filtro delle cadenze: (1, 2, 3, 4, 5)
Numero di combinazioni finali dopo il filtro dei valori consecutivi: 40800568
Tempo impiegato per applicare il filtro dei valori consecutivi: 113.89292287826538 secondi
Esempio di combinazione finale dopo il filtro dei valori consecutivi: (1, 2, 4, 5, 7)
Numero di combinazioni finali dopo il filtro dei numeri pari: 20400184 <<<<< abbattimento del 50% ca dell'integrale!
Tempo impiegato per applicare il filtro dei numeri pari: 76.1837728023529 secondi
Esempio di combinazione finale dopo il filtro dei numeri pari: (1, 2, 4, 5, 8)
(nuovoambientepy38) PS C:\Users\admin\desktop\filtraggio-di-tutte-le-classi5by90>


🤖 (ChatGPT) Sì, sembra che l'implementazione del quarto filtro abbia portato a un'enorme riduzione del numero di combinazioni finali. Da oltre 40 milioni, siamo passati a poco più di 20 milioni. Questo è un risultato notevole e dimostra l'efficacia dei filtri nell'eliminare le combinazioni non desiderate. Continuando con questa strategia, potremmo ottenere ulteriori miglioramenti nelle prestazioni e nella riduzione del numero di combinazioni rimanenti. Se hai altri filtri da implementare o altre richieste, fammelo sapere!


👋🙂

ps0: E ne restano ancora 10 di filtri da applicare senza contare i due aggiuntivi eventuali proposti da Cinzia! 🤞🤞🤞🤞🤞
ps1: E grazie Big Baffo anche per gli stupendi e interessantissimi video che condividi nella sezione "Nel Blù dipinto di Blù"
ps2: forse dopo l'eventuale completamento dell'implementazione dei 14 filtri (o 16) da te e cinzia proposti applichero' lo stesso tipo di multifiltro anche alla mia cf36... (lo scrivo qui per non dimenticarmene...). Se vuoi(volete) vedere di cosa si tratta vai (andate) nella sezione sistemistica e leggete il mio ultimo thread.
ps3: Mi sono accorto solo adesso che il 4° filtro con l'eliminazione di 3 o più numeri pari non c'era nella lista... L'ha aggiunto di sua sponte Chatty... 😝 Visto l'interessante abbattimento dell'integrale direi di mantenerlo comunque e di aggiungere anche quello per l'eliminazione delle c5 con 3 o più i numeri dispari... Ad ogni modo qualunque cosa si decida no problem si possono includere o escludere a nostro piacimento tutti i tipi di filtro che vogliamo.

Tom complimenti sei un mostro.

 

[BaffoBlù]

Aggiornamento...

Mi sta tornando l'ottimismo riguardo la tua idea "titanica" di ridurre le 44 milioni di cinquine generabili dai 90 caro Baffo

Uno stralcio dell'ultimo dialogo "al riguardo" con l'AI che amo ogni giorno sempre di +... 🤖😄

🤠 (Me) super eccezionale! sembrerebbe che con già solo l'implementazione anche del 4° filtro tu abbia abbattuto l'integrale di oltre 20 milioni di formazioni! Possibile cara Chatty?

(nuovoambientepy38) PS C:\Users\admin\desktop\filtraggio-di-tutte-le-classi5by90> python step1-step2-fast-G-OKvelocitaedefficienzamostruosa.py

Numero di combinazioni iniziali prima dell'elaborazione : 43.949.268
Numero di combinazioni finali dopo il filtro 'eliminazione di tutte le c5 già uscite su BA dal 1874' : 43939053
Esempio di combinazione finale prima del filtro: (1, 2, 3, 4, 5)
Tempo impiegato per generare le combinazioni: 30.005961418151855 secondi
Numero di combinazioni finali dopo il filtro delle cadenze: 41114825
Tempo impiegato per applicare il filtro delle cadenze: 149.94386625289917 secondi
Esempio di combinazione finale dopo il filtro delle cadenze: (1, 2, 3, 4, 5)
Numero di combinazioni finali dopo il filtro dei valori consecutivi: 40800568
Tempo impiegato per applicare il filtro dei valori consecutivi: 113.89292287826538 secondi
Esempio di combinazione finale dopo il filtro dei valori consecutivi: (1, 2, 4, 5, 7)
Numero di combinazioni finali dopo il filtro dei numeri pari: 20400184 <<<<< abbattimento del 50% ca dell'integrale!
Tempo impiegato per applicare il filtro dei numeri pari: 76.1837728023529 secondi
Esempio di combinazione finale dopo il filtro dei numeri pari: (1, 2, 4, 5, 8)
(nuovoambientepy38) PS C:\Users\admin\desktop\filtraggio-di-tutte-le-classi5by90>


🤖 (ChatGPT) Sì, sembra che l'implementazione del quarto filtro abbia portato a un'enorme riduzione del numero di combinazioni finali. Da oltre 40 milioni, siamo passati a poco più di 20 milioni. Questo è un risultato notevole e dimostra l'efficacia dei filtri nell'eliminare le combinazioni non desiderate. Continuando con questa strategia, potremmo ottenere ulteriori miglioramenti nelle prestazioni e nella riduzione del numero di combinazioni rimanenti. Se hai altri filtri da implementare o altre richieste, fammelo sapere!


👋🙂

ps0: E ne restano ancora 10 di filtri da applicare senza contare i due aggiuntivi eventuali proposti da Cinzia! 🤞🤞🤞🤞🤞
ps1: E grazie Big Baffo anche per gli stupendi e interessantissimi video che condividi nella sezione "Nel Blù dipinto di Blù"
ps2: forse dopo l'eventuale completamento dell'implementazione dei 14 filtri (o 16) da te e cinzia proposti applichero' lo stesso tipo di multifiltro anche alla mia cf36... (lo scrivo qui per non dimenticarmene...). Se vuoi(volete) vedere di cosa si tratta vai (andate) nella sezione sistemistica e leggete il mio ultimo thread.
ps3: Mi sono accorto solo adesso che il 4° filtro con l'eliminazione di 3 o più numeri pari non c'era nella lista... L'ha aggiunto di sua sponte Chatty... 😝 Visto l'interessante abbattimento dell'integrale direi di mantenerlo comunque e di aggiungere anche quello per l'eliminazione delle c5 con 3 o più i numeri dispari... Ad ogni modo qualunque cosa si decida no problem si possono includere o escludere a nostro piacimento tutti i tipi di filtro che vogliamo.

WOW

sono esterrefatto (più fatto che esterr...)

e i numeri dispari?

In questo momento non mi vengono altre cinquine, (sto sotto oppioidi..)

non è che ci vuole un eminenza grigia per scartare, ma adesso sono praticamente in stand-by...

 

[lotto_tom75]

Aggiornamento...

(nuovoambientepy38) PS C:\Users\admin\desktop\filtraggio-di-tutte-le-classi5by90> python step1-step2-fast-M-OKvelocitaedefficienzamostruosa.py
Numero di combinazioni finali prima di applicare qualunque tipo di filtro: 43.949.268
Numero di combinazioni finali dopo il filtro 'eliminazione di tutte le c5 già uscite su bari dal 1874': 43939053
Esempio di combinazione finale dopo il filtro 'eliminazione c5 già uscite': (1, 2, 3, 4, 5)
Tempo impiegato per generare le combinazioni: 32.72628140449524 secondi
Numero di combinazioni finali dopo il filtro delle cadenze: 41114825
Tempo impiegato per applicare il filtro delle cadenze: 151.45985221862793 secondi
Esempio di combinazione finale dopo il filtro delle cadenze: (1, 2, 3, 4, 5)
Numero di combinazioni finali dopo il filtro dei valori consecutivi: 40800568
Tempo impiegato per applicare il filtro dei valori consecutivi: 101.51080012321472 secondi
Esempio di combinazione finale dopo il filtro dei valori consecutivi: (1, 2, 4, 5, 7)
Numero di combinazioni finali dopo il filtro dell'eliminazione di c5 con 3 o più numeri pari: 20400384
Tempo impiegato per applicare il filtro dei numeri pari: 75.2914764881134 secondi
Esempio di combinazione finale dopo il filtro dell'eliminazione di c5 con 3 o più numeri pari: (1, 2, 4, 5, 7)
Numero di combinazioni finali dopo il filtro dell'eliminazione di c5 con 4 o più numeri dispari: 6891091 (solo... 7 mln ca!)
Tempo impiegato per applicare il filtro dei numeri dispari: 38.16955637931824 secondi
Esempio di combinazione finale dopo il filtro dell'eliminazione di c5 con 3 o più numeri dispari: (1, 2, 5, 7, 9)
(nuovoambientepy38) PS C:\Users\admin\desktop\filtraggio-di-tutte-le-classi5by90>

[continue...]

 

[BaffoBlù]

Aggiornamento...

(nuovoambientepy38) PS C:\Users\admin\desktop\filtraggio-di-tutte-le-classi5by90> python step1-step2-fast-M-OKvelocitaedefficienzamostruosa.py
Numero di combinazioni finali prima di applicare qualunque tipo di filtro: 43.949.268
Numero di combinazioni finali dopo il filtro 'eliminazione di tutte le c5 già uscite su bari dal 1874': 43939053
Esempio di combinazione finale dopo il filtro 'eliminazione c5 già uscite': (1, 2, 3, 4, 5)
Tempo impiegato per generare le combinazioni: 32.72628140449524 secondi
Numero di combinazioni finali dopo il filtro delle cadenze: 41114825
Tempo impiegato per applicare il filtro delle cadenze: 151.45985221862793 secondi
Esempio di combinazione finale dopo il filtro delle cadenze: (1, 2, 3, 4, 5)
Numero di combinazioni finali dopo il filtro dei valori consecutivi: 40800568
Tempo impiegato per applicare il filtro dei valori consecutivi: 101.51080012321472 secondi
Esempio di combinazione finale dopo il filtro dei valori consecutivi: (1, 2, 4, 5, 7)
Numero di combinazioni finali dopo il filtro dell'eliminazione di c5 con 3 o più numeri pari: 20400384
Tempo impiegato per applicare il filtro dei numeri pari: 75.2914764881134 secondi
Esempio di combinazione finale dopo il filtro dell'eliminazione di c5 con 3 o più numeri pari: (1, 2, 4, 5, 7)
Numero di combinazioni finali dopo il filtro dell'eliminazione di c5 con 4 o più numeri dispari: 6891091 (solo... 7 mln ca!)
Tempo impiegato per applicare il filtro dei numeri dispari: 38.16955637931824 secondi
Esempio di combinazione finale dopo il filtro dell'eliminazione di c5 con 3 o più numeri dispari: (1, 2, 5, 7, 9)
(nuovoambientepy38) PS C:\Users\admin\desktop\filtraggio-di-tutte-le-classi5by90>

[continue...]

Lotto_tom .sei incredibile.

puoi fare un elenco come quello che dico sotto?

fai un elenco più specificato tipo il mio iniziale riga per riga con poi a fianco solo il numero di cinquine via via ridotte
metti tutte le righe che puoi.
Non aggiungere altro, tipo tempi etc...

leggendolo in questa maniera senza altro in mezzo posso individuare altro.

 

[lotto_tom75]

Lotto_tom .sei incredibile.

puoi fare un elenco come quello che dico sotto?

fai un elenco più specificato tipo il mio iniziale riga per riga con poi a fianco solo il numero di cinquine via via ridotte
metti tutte le righe che puoi.
Non aggiungere altro, tipo tempi etc...

leggendolo in questa maniera senza altro in mezzo posso individuare altro.

Ciao Baffo e ciao a tutti

Non sono sicuro di aver capito cosa vorresti...

Ma per adesso ti ho buttato giù questo... (con l'aggiornamento incluso...)

Salvo errori...

--------- prova elenco richiesto da Baffo ----------------------------------

Combinazioni totali in classe 5 generabili dai 90 : 43.949.268

Dopo eliminazione di:

Tutte quelle uscite dal 1874 all'ultima estrazione disponibile: 43939053

Tutte quelle con 3-4-5 numeri in cadenza uguale: 41114825

Tutte quelle con 3-4-5 numeri consecutivi: 40800568

Tutte quelle con 3-4-5 numeri pari : 20400384 <<<<< riduzione del 50% ca della massa numerica...

Tutte quelle con 4-5 numeri dispari : 6891091

Tutte quelle con 3-4-5 gemelli: 6862400

Tutte quelle con 3-4-5 numeri in decina uguale: 6348057

Tutte quelle con 3-4-5 numeri della stessa Figura: 5815449

Tutte quelle con 3-4-5 numeri della stessa ControFigura: 5413090

Tutte quelle con 3-4-5 numeri della stessa Cifra: 223928 <<<<< Quindi, il valore 223928 è ridotto di circa il 95.87% rispetto al valore 5413090

Tutte quelle con numeri di un terno delle Terzine Simmetriche distanza 30: 223928

Tutte quelle con i 4 numeri Radicali di ogni gruppo: 223928

Tutte quelle con 3 Zerati e 2 Gemelli: 223928

Tutte quelle con 3 Gemelli e 2 Zerati: 223928

Tutte quelle con 3-4-5 zerati: 223928

Tutte quelle con i 5 numeri più ritardati in quel momento: 223928

Tutte quelle con i 5 numeri meno frequenti in quel momento: 223928



Come si vede da questo "elenco progressivo discendente della quantità di cinquine di volta in volta rimaste dopo l'applicazione di ciascun filtro impilato" la riduzione sembra purtroppo.. stabilizzarsi a 223928 cinquine che comunque è già di per sè una riduzione "mostruosa" rispetto le circa 44 milioni formazioni generabili integralmente in classe 5 by 90. I picchi riduzionali maggiori si notano ai filtri pari e dispari e a quello delle cifre.


👋🙂

Relativo "last code" python da verificare, ottimizzare e completare... ma già funzionante...

import itertools
import time


#memo riguardo i filtri già implementati e da implementare

# 1) eliminazione di tutte le cinquine già uscite su bari dal 1874 OK
# 2) Tutte quelle con 3-4-5 numeri in cadenza uguale. OK
# 3) Tutte quelle con 3-4-5 numeri consecutivi. OK
# 4) Tutte quelle con almeno 3 numeri pari OK
# 5) Tutte quelle con almeno 4 numeri dispari OK
# 6) Tutte quelle con 3-4-5 gemelli. OK
# 7) Tutte quelle con 3-4-5 numeri in decina uguale. OK
# 8) Tutte quelle con 3-4-5 numeri della stessa Figura. OK
# 9) Tutte quelle con 3-4-5 numeri della stessa ControFigura. OK
# 10) Tutte quelle con 3-4-5 numeri della stessa Cifra. OK
# 11) Tutte quelle con numeri di un terno delle Terzine Simmetriche distanza 30. OK anche se necessita forse di ulteriore verifica visto che non avrebbe filtrate nessuna...
# 12) Tutte quelle con i 4 numeri Radicali di ogni gruppo. OK anche se necessita forse di ulteriore verifica visto che non avrebbe filtrate nessuna...
# 13) Tutte quelle con 3 Zerati e 2 Gemelli. OK anche se necessita forse di ulteriore verifica visto che non avrebbe filtrate nessuna...
# 14) Tutte quelle con 3 Gemelli e 2 Zerati. OK anche se necessita forse di ulteriore verifica visto che non avrebbe filtrate nessuna...
# 15 Tutte quelle con 3-4-5 zerati.   OK anche se necessita forse di ulteriore verifica visto che non avrebbe filtrate nessuna...
# 16) Tutte quelle con i 5 numeri più ritardati in quel momento.  ANCORA DA FARE...
# 17) Tutte quelle con i 5 numeri meno frequenti in quel momento.  ANCORA DA FARE...


#implementata anche la possibilità di scegliere anzichè tutti i 90 anche gruppi numerici base molto più ristretti come abs, semi abs, cf ecc...
#io a tal proposito lo testerò subito con due mie cf36 una per BARI e una per CAGLIARI... :)



file_path = "estrazioni-bari.txt"
# Creiamo un dizionario per memorizzare tutte le combinazioni estratte da Bari
formazioni_estrazioni = {}
# Apriamo il file e leggiamo le estrazioni riga per riga
with open(file_path, "r") as file:
    for line in file:
        # Dividiamo la riga in una lista di numeri
        numeri_riga = tuple(sorted(map(int, line.strip().split(","))))
        # Aggiungiamo la tupla dei numeri estratti al dizionario con la combinazione come chiave
        formazioni_estrazioni[numeri_riga] = True

# Definiamo il tempo di inizio dell'esecuzione dello script
start_time = time.time()

# Definisci il gruppo numerico personalizzato di tua scelta
gruppo_numerico_personalizzato = [1, 3, 7, 8, 9, 11, 12, 13, 14, 17, 20, 25, 26, 32, 37, 38, 42, 43, 48, 49, 51, 52, 54, 58, 62, 63, 67, 69, 71, 72, 73, 76, 79, 81, 82, 89]

# Stampiamo il numero di combinazioni finali prima di applicare qualunque tipo di filtro
print("Numero di combinazioni finali prima di applicare qualunque tipo di filtro:", len(list(itertools.combinations(gruppo_numerico_personalizzato, 5))))

# Generiamo tutte le possibili combinazioni di 5 numeri nel gruppo numerico personalizzato, escludendo le combinazioni già estratte da Bari
combinazioni_finali = []
for combinazione in itertools.combinations(gruppo_numerico_personalizzato, 5):
    if combinazione not in formazioni_estrazioni:
        combinazioni_finali.append(combinazione)

# Stampiamo il numero di combinazioni finali dopo il filtro e un esempio di esse
print("Numero di combinazioni finali dopo il filtro 'eliminazione di tutte le c5 già uscite su bari dal 1874':", len(combinazioni_finali))
if combinazioni_finali:
    print("Esempio di combinazione finale dopo il filtro 'eliminazione c5 già uscite':", combinazioni_finali[0])

# Stampiamo il tempo impiegato per generare le combinazioni
end_time = time.time()
generation_time = end_time - start_time
print("Tempo impiegato per generare le combinazioni:", generation_time, "secondi")



# Definiamo una funzione per verificare se una combinazione ha 3, 4 o 5 numeri nella stessa cadenza
def has_same_stride(combination):
    cadenze = {
        1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 0: 0
    }
    # Calcoliamo la cadenza di ciascun numero nella combinazione
    for num in combination:
        cadenza = num % 10
        cadenze[cadenza] += 1
    # Controlliamo se ci sono 3, 4 o 5 numeri nella stessa cadenza
    for numeri_cadenza in cadenze.values():
        if numeri_cadenza >= 3:
            return True
    return False
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate = [combinazione for combinazione in combinazioni_finali if not has_same_stride(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle cadenze:", len(combinazioni_finali_filtrate))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro delle cadenze:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate:
    print("Esempio di combinazione finale dopo il filtro delle cadenze:", combinazioni_finali_filtrate[0])
# Definiamo una funzione per verificare se una combinazione ha 3 numeri consecutivi
def has_consecutive_numbers(combination):
    sorted_combination = sorted(combination)
    for i in range(len(sorted_combination) - 2):
        if sorted_combination[i] + 1 == sorted_combination[i+1] and sorted_combination[i+1] + 1 == sorted_combination[i+2]:
            return True
    return False
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_consecutivi = [combinazione for combinazione in combinazioni_finali_filtrate if not has_consecutive_numbers(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro dei valori consecutivi:", len(combinazioni_finali_filtrate_consecutivi))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro dei valori consecutivi:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_consecutivi:
    print("Esempio di combinazione finale dopo il filtro dei valori consecutivi:", combinazioni_finali_filtrate_consecutivi[0])
# Modifichiamo la funzione per verificare se una combinazione ha almeno 3 numeri pari
def has_at_least_three_even_numbers(combination):
    count_even = sum(1 for num in combination if num % 2 == 0)
    return count_even >= 3
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_pari = [combinazione for combinazione in combinazioni_finali_filtrate_consecutivi if not has_at_least_three_even_numbers(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro dell'eliminazione di c5 con 3 o più numeri pari:", len(combinazioni_finali_filtrate_pari))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro dei numeri pari:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_pari:
    print("Esempio di combinazione finale dopo il filtro dell'eliminazione di c5 con 3 o più numeri pari:", combinazioni_finali_filtrate_pari[0])
# Definiamo una funzione per verificare se una combinazione ha almeno 4 numeri dispari
def has_at_least_four_odd_numbers(combination):
    count_odd = sum(1 for num in combination if num % 2 != 0)
    return count_odd >= 4
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_dispari = [combinazione for combinazione in combinazioni_finali_filtrate_pari if has_at_least_four_odd_numbers(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro dell'eliminazione di c5 con 4 o più numeri dispari:", len(combinazioni_finali_filtrate_dispari))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro dei numeri dispari:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_dispari:
    print("Esempio di combinazione finale dopo il filtro dell'eliminazione di c5 con 4 o più numeri dispari:", combinazioni_finali_filtrate_dispari[0])
# Definiamo una funzione per verificare se una combinazione ha 3 o più numeri gemelli
def has_three_or_more_twins(combination):
    twins = [11, 22, 33, 44, 55, 66, 77, 88]  # Lista dei numeri gemelli
    count_twins = sum(1 for num in combination if num in twins)
    if count_twins >= 3:
        return True
    return False
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_gemelli = [combinazione for combinazione in combinazioni_finali_filtrate_dispari if not has_three_or_more_twins(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3 o più gemelli:", len(combinazioni_finali_filtrate_gemelli))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro dei gemelli:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_gemelli:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3 o più gemelli:", combinazioni_finali_filtrate_gemelli[0])
# Definiamo una funzione per verificare se una combinazione ha 3, 4 o 5 numeri nella stessa decina
def has_same_decade(combination):
    decade_count = {}
    for num in combination:
        decade = num // 10
        if decade in decade_count:
            decade_count[decade] += 1
        else:
            decade_count[decade] = 1
    for count in decade_count.values():
        if count >= 3:
            return True
    return False
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_decade = [combinazione for combinazione in combinazioni_finali_filtrate_gemelli if not has_same_decade(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3-4-5 numeri in decina uguale:", len(combinazioni_finali_filtrate_decade))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con 3-4-5 numeri in decina uguale:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_decade:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3-4-5 numeri in decina uguale:", combinazioni_finali_filtrate_decade[0])
# Definiamo le figure nel lotto
figure = {
    1: [1, 10, 19, 28, 37, 46, 55, 64, 73, 82],
    2: [2, 11, 20, 29, 38, 47, 56, 65, 74, 83],
    3: [3, 12, 21, 30, 39, 48, 57, 66, 75, 84],
    4: [4, 13, 22, 31, 40, 49, 58, 67, 76, 85],
    5: [5, 14, 23, 32, 41, 50, 59, 68, 77, 86],
    6: [6, 15, 24, 33, 42, 51, 60, 69, 78, 87],
    7: [7, 16, 25, 34, 43, 52, 61, 70, 79, 88],
    8: [8, 17, 26, 35, 44, 53, 62, 71, 80, 89],
    9: [9, 18, 27, 36, 45, 54, 63, 72, 81, 90]
}
# Definiamo una funzione per verificare se una combinazione ha 3, 4 o 5 numeri della stessa figura
def has_same_figure(combination):
    for figura, numeri_figura in figure.items():
        count = sum(1 for num in combination if num in numeri_figura)
        if count >= 3:
            return True
    return False
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_figura = [combinazione for combinazione in combinazioni_finali_filtrate_decade if not has_same_figure(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3-4-5 numeri della stessa figura:", len(combinazioni_finali_filtrate_figura))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con 3-4-5 numeri della stessa figura:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_figura:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3-4-5 numeri della stessa figura:", combinazioni_finali_filtrate_figura[0])
# Definiamo le controfigure nel lotto
controfigure = {
    1: [1, 12, 23, 34, 45, 56, 67, 78, 89],
    2: [2, 13, 24, 35, 46, 57, 68, 79, 90],
    3: [3, 11, 14, 25, 36, 47, 58, 69, 80],
    4: [4, 15, 22, 26, 37, 48, 59, 70, 81],
    5: [5, 16, 27, 33, 38, 49, 60, 71, 82],
    6: [6, 17, 28, 39, 44, 50, 61, 72, 83],
    7: [7, 18, 29, 40, 51, 55, 62, 73, 84],
    8: [8, 19, 30, 41, 52, 63, 66, 74, 85],
    9: [9, 20, 31, 42, 53, 64, 75, 77, 86],
    10: [10, 21, 32, 43, 54, 65, 76, 87, 88]
}
# Definiamo una funzione per verificare se una combinazione ha 3, 4 o 5 numeri della stessa controfigura
def has_same_controfigure(combination):
    for controfigura, numeri_controfigura in controfigure.items():
        count = sum(1 for num in combination if num in numeri_controfigura)
        if count >= 3:
            return True
    return False
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_controfigura = [combinazione for combinazione in combinazioni_finali_filtrate_figura if not has_same_controfigure(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3-4-5 numeri della stessa controfigura:", len(combinazioni_finali_filtrate_controfigura))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con 3-4-5 numeri della stessa controfigura:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_controfigura:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3-4-5 numeri della stessa controfigura:", combinazioni_finali_filtrate_controfigura[0])
def filtro_cifra_uguale(combinazioni):
    cifre = {
        1: [1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 21, 31, 41, 51, 61, 71, 81],
        2: [2, 12, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 32, 42, 52, 62, 72, 82],
        3: [3, 13, 23, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 43, 53, 63, 73, 83],
        4: [4, 14, 24, 34, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 54, 64, 74, 84],
        5: [5, 15, 25, 35, 45, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 65, 75, 85],
        6: [6, 16, 26, 36, 46, 56, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 76, 86],
        7: [7, 17, 27, 37, 47, 57, 67, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 87],
        8: [8, 18, 28, 38, 48, 58, 68, 78, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89]
    }
    start_time = time.time()
    combinazioni_filtrate = []
    for combinazione in combinazioni:
        cifre_presenti = []
        for numero in combinazione:
            for cifra, numeri_cifra in cifre.items():
                if numero in numeri_cifra:
                    cifre_presenti.append(cifra)
                    break
        if len(set(cifre_presenti)) >= 3:
            continue
        combinazioni_filtrate.append(combinazione)
    end_time = time.time()
    tempo_impiegato = end_time - start_time
    return combinazioni_filtrate, tempo_impiegato
# Utilizzo del filtro
#combinazioni_dopo_filtro_cifra_uguale, tempo_filtro_cifra_uguale = filtro_cifra_uguale(combinazioni)
# Utilizzo del filtro
combinazioni_dopo_filtro_cifra_uguale, tempo_filtro_cifra_uguale = filtro_cifra_uguale(combinazioni_finali_filtrate_controfigura)
# Stampa dei risultati
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3-4-5 numeri della stessa cifra:", len(combinazioni_dopo_filtro_cifra_uguale))
print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3-4-5 numeri della stessa cifra:", combinazioni_dopo_filtro_cifra_uguale[0])  # Modifica l'indice in base alla tua necessità
print("Tempo impiegato per applicare il filtro delle combinazioni con 3-4-5 numeri della stessa cifra:", tempo_filtro_cifra_uguale, "secondi")
#import time  # Assicurati di importare il modulo time per utilizzare la funzione time.time()
# Definiamo le terzine simmetriche
terzine_simmetriche = [
    [16, 46, 76], [6, 36, 66], [28, 58, 88], [21, 51, 81], [5, 35, 65],
    [1, 31, 61], [23, 53, 83], [22, 52, 82], [2, 32, 62], [19, 49, 79],
    [20, 50, 80], [24, 54, 84], [29, 59, 89], [30, 60, 90], [27, 57, 87],
    [25, 55, 85], [26, 56, 86], [18, 48, 78], [9, 39, 69], [10, 40, 70],
    [11, 41, 71], [4, 34, 64], [7, 37, 67], [8, 38, 68], [15, 45, 75],
    [3, 33, 63], [17, 47, 77], [12, 42, 72], [13, 43, 73], [14, 44, 74]
]
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
# Creiamo una nuova lista vuota per le combinazioni finali dopo il filtro delle terzine simmetriche
combinazioni_finali_dopo_terzine = []
# Iteriamo su ogni combinazione rimanente dopo i filtri precedenti
for combinazione in combinazioni_dopo_filtro_cifra_uguale:
    # Verifichiamo se la combinazione contiene almeno tre numeri appartenenti a una terzina simmetrica
    has_symmetric = False
    for trio in terzine_simmetriche:
        count = sum(1 for num in combinazione if num in trio)
        if count >= 3:
            has_symmetric = True
            break
    # Se la combinazione non contiene una terzina simmetrica, la aggiungiamo alla lista delle combinazioni finali
    if not has_symmetric:
        combinazioni_finali_dopo_terzine.append(combinazione)
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con terzine simmetriche:", len(combinazioni_finali_dopo_terzine))
filter_time = time.time() - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con terzine simmetriche:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_dopo_terzine:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con terzine simmetriche:", combinazioni_finali_dopo_terzine[0])
# Definiamo la funzione filtro_numeri_radicali
def filtro_numeri_radicali(combinazioni_finali_dopo_terzine):
    gruppi_radicali = {
        8: [8, 80, 88, 89],
        4: [4, 40, 44, 49],
        7: [7, 70, 77, 79],
        3: [3, 30, 33, 39],
        6: [6, 60, 66, 69],
        2: [2, 20, 22, 29],
        1: [1, 10, 11, 19],
        5: [5, 50, 55, 59]
    }
    combinazioni_filtrate = []
    for combinazione in combinazioni_finali_dopo_terzine:
        numeri_radicali_presenti = 0
        for gruppo in gruppi_radicali.values():
            if all(numero in combinazione for numero in gruppo):
                numeri_radicali_presenti += 1
        if numeri_radicali_presenti < 4:
            combinazioni_filtrate.append(combinazione)
    return combinazioni_filtrate
# Applichiamo il filtro numeri radicali
combinazioni_filtrate = filtro_numeri_radicali(combinazioni_finali_dopo_terzine)
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni radicali:", len(combinazioni_filtrate))
filter_time = time.time() - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni radicali:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_filtrate:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni radicali:", combinazioni_filtrate[0])
# 17) eliminazione di tutte le cinquine rimaste dopo i precedenti filtri con 3 Zerati e 2 Gemelli
def filtro_cinquine_zerati_gemelli(combinazioni_finali_dopo_numeri_radicali):
    combinazioni_filtrate = []
    for combinazione in combinazioni_finali_dopo_numeri_radicali:
        count_zerati = sum(1 for num in combinazione if num % 10 == 0)
        count_gemelli = sum(1 for num in combinazione if combinazione.count(num) >= 2)
        if count_zerati != 3 or count_gemelli != 2:
            combinazioni_filtrate.append(combinazione)
    return combinazioni_filtrate
# Applichiamo il filtro delle cinquine con 3 Zerati e 2 Gemelli
combinazioni_filtrate = filtro_cinquine_zerati_gemelli(combinazioni_filtrate)
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3 Zerati e 2 Gemelli:", len(combinazioni_filtrate))
filter_time = time.time() - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con 3 Zerati e 2 Gemelli:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_filtrate:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3 Zerati e 2 Gemelli:", combinazioni_filtrate[0])
# 18) eliminazione delle cinquine rimaste dopo i precedenti filtri con 3 Gemelli e 2 Zerati
def filtro_cinquine_gemelli_zerati(combinazioni_finali_dopo_zerati_gemelli):
    combinazioni_filtrate = []
    for combinazione in combinazioni_finali_dopo_zerati_gemelli:
        count_gemelli = sum(1 for num in combinazione if combinazione.count(num) >= 2)
        count_zerati = sum(1 for num in combinazione if num % 10 == 0)
        if count_gemelli != 3 or count_zerati != 2:
            combinazioni_filtrate.append(combinazione)
    return combinazioni_filtrate
# Applichiamo il filtro delle cinquine con 3 Gemelli e 2 Zerati
combinazioni_filtrate = filtro_cinquine_gemelli_zerati(combinazioni_filtrate)
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3 Gemelli e 2 Zerati:", len(combinazioni_filtrate))
filter_time = time.time() - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con 3 Gemelli e 2 Zerati:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_filtrate:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3 Gemelli e 2 Zerati:", combinazioni_filtrate[0])
# 19) eliminazione di tutte le cinquine rimaste con 3-4-5 zerati
def filtro_cinquine_zerati(combinazioni_finali_dopo_cinquine_gemelli_zerati):
    combinazioni_filtrate = []
    for combinazione in combinazioni_finali_dopo_cinquine_gemelli_zerati:
        count_zerati = sum(1 for num in combinazione if num % 10 == 0)
        if count_zerati not in [3, 4, 5]:
            combinazioni_filtrate.append(combinazione)
    return combinazioni_filtrate
# Applichiamo il filtro delle cinquine con 3-4-5 zerati
combinazioni_filtrate = filtro_cinquine_zerati(combinazioni_filtrate)
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3-4-5 zerati:", len(combinazioni_filtrate))
filter_time = time.time() - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con 3-4-5 zerati:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_filtrate:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3-4-5 zerati:", combinazioni_filtrate[0])

ps: con gruppi base ridotti... tipo abs, semi abs e gruppi di classe <= 45 è una scheggia... Io come già detto e come ho scritto anche nelle info all'interno del code lo testerò con le mie cf36 condivise nel mio thread relativo nella sezione "sistemistica" x teorico esito a colpo su ruota unica.

 

[BaffoBlù]

Ciao Baffo e ciao a tutti

Non sono sicuro di aver capito cosa vorresti...

Ma per adesso ti ho buttato giù questo... (con l'aggiornamento incluso...)

Salvo errori...

--------- prova elenco richiesto da Baffo ----------------------------------

Combinazioni totali in classe 5 generabili dai 90 : 43.949.268

Dopo eliminazione di:

Tutte quelle uscite dal 1874 all'ultima estrazione disponibile: 43939053

Tutte quelle con 3-4-5 numeri in cadenza uguale: 41114825

Tutte quelle con 3-4-5 numeri consecutivi: 40800568

Tutte quelle con 3-4-5 numeri pari : 20400384 <<<<< riduzione del 50% ca della massa numerica...

Tutte quelle con 4-5 numeri dispari : 6891091

Tutte quelle con 3-4-5 gemelli: 6862400

Tutte quelle con 3-4-5 numeri in decina uguale: 6348057

Tutte quelle con 3-4-5 numeri della stessa Figura: 5815449

Tutte quelle con 3-4-5 numeri della stessa ControFigura: 5413090

Tutte quelle con 3-4-5 numeri della stessa Cifra: 223928 <<<<< Quindi, il valore 223928 è ridotto di circa il 95.87% rispetto al valore 5413090

Tutte quelle con numeri di un terno delle Terzine Simmetriche distanza 30: 223928

Tutte quelle con i 4 numeri Radicali di ogni gruppo: 223928

Tutte quelle con 3 Zerati e 2 Gemelli: 223928

Tutte quelle con 3 Gemelli e 2 Zerati: 223928

Tutte quelle con 3-4-5 zerati: 223928

Tutte quelle con i 5 numeri più ritardati in quel momento: 223928

Tutte quelle con i 5 numeri meno frequenti in quel momento: 223928



Come si vede da questo "elenco progressivo discendente della quantità di cinquine di volta in volta rimaste dopo l'applicazione di ciascun filtro impilato" la riduzione sembra purtroppo.. stabilizzarsi a 223928 cinquine che comunque è già di per sè una riduzione "mostruosa" rispetto le circa 44 milioni formazioni generabili integralmente in classe 5 by 90. I picchi riduzionali maggiori si notano ai filtri pari e dispari e a quello delle cifre.


👋🙂

Relativo "last code" python da verificare, ottimizzare e completare... ma già funzionante...

import itertools
import time


#memo riguardo i filtri già implementati e da implementare

# 1) eliminazione di tutte le cinquine già uscite su bari dal 1874 OK
# 2) Tutte quelle con 3-4-5 numeri in cadenza uguale. OK
# 3) Tutte quelle con 3-4-5 numeri consecutivi. OK
# 4) Tutte quelle con almeno 3 numeri pari OK
# 5) Tutte quelle con almeno 4 numeri dispari OK
# 6) Tutte quelle con 3-4-5 gemelli. OK
# 7) Tutte quelle con 3-4-5 numeri in decina uguale. OK
# 8) Tutte quelle con 3-4-5 numeri della stessa Figura. OK
# 9) Tutte quelle con 3-4-5 numeri della stessa ControFigura. OK
# 10) Tutte quelle con 3-4-5 numeri della stessa Cifra. OK
# 11) Tutte quelle con numeri di un terno delle Terzine Simmetriche distanza 30. OK anche se necessita forse di ulteriore verifica visto che non avrebbe filtrate nessuna...
# 12) Tutte quelle con i 4 numeri Radicali di ogni gruppo. OK anche se necessita forse di ulteriore verifica visto che non avrebbe filtrate nessuna...
# 13) Tutte quelle con 3 Zerati e 2 Gemelli. OK anche se necessita forse di ulteriore verifica visto che non avrebbe filtrate nessuna...
# 14) Tutte quelle con 3 Gemelli e 2 Zerati. OK anche se necessita forse di ulteriore verifica visto che non avrebbe filtrate nessuna...
# 15 Tutte quelle con 3-4-5 zerati.   OK anche se necessita forse di ulteriore verifica visto che non avrebbe filtrate nessuna...
# 16) Tutte quelle con i 5 numeri più ritardati in quel momento.  ANCORA DA FARE...
# 17) Tutte quelle con i 5 numeri meno frequenti in quel momento.  ANCORA DA FARE...


#implementata anche la possibilità di scegliere anzichè tutti i 90 anche gruppi numerici base molto più ristretti come abs, semi abs, cf ecc...
#io a tal proposito lo testerò subito con due mie cf36 una per BARI e una per CAGLIARI... :)



file_path = "estrazioni-bari.txt"
# Creiamo un dizionario per memorizzare tutte le combinazioni estratte da Bari
formazioni_estrazioni = {}
# Apriamo il file e leggiamo le estrazioni riga per riga
with open(file_path, "r") as file:
    for line in file:
        # Dividiamo la riga in una lista di numeri
        numeri_riga = tuple(sorted(map(int, line.strip().split(","))))
        # Aggiungiamo la tupla dei numeri estratti al dizionario con la combinazione come chiave
        formazioni_estrazioni[numeri_riga] = True

# Definiamo il tempo di inizio dell'esecuzione dello script
start_time = time.time()

# Definisci il gruppo numerico personalizzato di tua scelta
gruppo_numerico_personalizzato = [1, 3, 7, 8, 9, 11, 12, 13, 14, 17, 20, 25, 26, 32, 37, 38, 42, 43, 48, 49, 51, 52, 54, 58, 62, 63, 67, 69, 71, 72, 73, 76, 79, 81, 82, 89]

# Stampiamo il numero di combinazioni finali prima di applicare qualunque tipo di filtro
print("Numero di combinazioni finali prima di applicare qualunque tipo di filtro:", len(list(itertools.combinations(gruppo_numerico_personalizzato, 5))))

# Generiamo tutte le possibili combinazioni di 5 numeri nel gruppo numerico personalizzato, escludendo le combinazioni già estratte da Bari
combinazioni_finali = []
for combinazione in itertools.combinations(gruppo_numerico_personalizzato, 5):
    if combinazione not in formazioni_estrazioni:
        combinazioni_finali.append(combinazione)

# Stampiamo il numero di combinazioni finali dopo il filtro e un esempio di esse
print("Numero di combinazioni finali dopo il filtro 'eliminazione di tutte le c5 già uscite su bari dal 1874':", len(combinazioni_finali))
if combinazioni_finali:
    print("Esempio di combinazione finale dopo il filtro 'eliminazione c5 già uscite':", combinazioni_finali[0])

# Stampiamo il tempo impiegato per generare le combinazioni
end_time = time.time()
generation_time = end_time - start_time
print("Tempo impiegato per generare le combinazioni:", generation_time, "secondi")



# Definiamo una funzione per verificare se una combinazione ha 3, 4 o 5 numeri nella stessa cadenza
def has_same_stride(combination):
    cadenze = {
        1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 0: 0
    }
    # Calcoliamo la cadenza di ciascun numero nella combinazione
    for num in combination:
        cadenza = num % 10
        cadenze[cadenza] += 1
    # Controlliamo se ci sono 3, 4 o 5 numeri nella stessa cadenza
    for numeri_cadenza in cadenze.values():
        if numeri_cadenza >= 3:
            return True
    return False
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate = [combinazione for combinazione in combinazioni_finali if not has_same_stride(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle cadenze:", len(combinazioni_finali_filtrate))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro delle cadenze:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate:
    print("Esempio di combinazione finale dopo il filtro delle cadenze:", combinazioni_finali_filtrate[0])
# Definiamo una funzione per verificare se una combinazione ha 3 numeri consecutivi
def has_consecutive_numbers(combination):
    sorted_combination = sorted(combination)
    for i in range(len(sorted_combination) - 2):
        if sorted_combination[i] + 1 == sorted_combination[i+1] and sorted_combination[i+1] + 1 == sorted_combination[i+2]:
            return True
    return False
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_consecutivi = [combinazione for combinazione in combinazioni_finali_filtrate if not has_consecutive_numbers(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro dei valori consecutivi:", len(combinazioni_finali_filtrate_consecutivi))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro dei valori consecutivi:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_consecutivi:
    print("Esempio di combinazione finale dopo il filtro dei valori consecutivi:", combinazioni_finali_filtrate_consecutivi[0])
# Modifichiamo la funzione per verificare se una combinazione ha almeno 3 numeri pari
def has_at_least_three_even_numbers(combination):
    count_even = sum(1 for num in combination if num % 2 == 0)
    return count_even >= 3
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_pari = [combinazione for combinazione in combinazioni_finali_filtrate_consecutivi if not has_at_least_three_even_numbers(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro dell'eliminazione di c5 con 3 o più numeri pari:", len(combinazioni_finali_filtrate_pari))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro dei numeri pari:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_pari:
    print("Esempio di combinazione finale dopo il filtro dell'eliminazione di c5 con 3 o più numeri pari:", combinazioni_finali_filtrate_pari[0])
# Definiamo una funzione per verificare se una combinazione ha almeno 4 numeri dispari
def has_at_least_four_odd_numbers(combination):
    count_odd = sum(1 for num in combination if num % 2 != 0)
    return count_odd >= 4
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_dispari = [combinazione for combinazione in combinazioni_finali_filtrate_pari if has_at_least_four_odd_numbers(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro dell'eliminazione di c5 con 4 o più numeri dispari:", len(combinazioni_finali_filtrate_dispari))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro dei numeri dispari:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_dispari:
    print("Esempio di combinazione finale dopo il filtro dell'eliminazione di c5 con 4 o più numeri dispari:", combinazioni_finali_filtrate_dispari[0])
# Definiamo una funzione per verificare se una combinazione ha 3 o più numeri gemelli
def has_three_or_more_twins(combination):
    twins = [11, 22, 33, 44, 55, 66, 77, 88]  # Lista dei numeri gemelli
    count_twins = sum(1 for num in combination if num in twins)
    if count_twins >= 3:
        return True
    return False
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_gemelli = [combinazione for combinazione in combinazioni_finali_filtrate_dispari if not has_three_or_more_twins(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3 o più gemelli:", len(combinazioni_finali_filtrate_gemelli))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro dei gemelli:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_gemelli:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3 o più gemelli:", combinazioni_finali_filtrate_gemelli[0])
# Definiamo una funzione per verificare se una combinazione ha 3, 4 o 5 numeri nella stessa decina
def has_same_decade(combination):
    decade_count = {}
    for num in combination:
        decade = num // 10
        if decade in decade_count:
            decade_count[decade] += 1
        else:
            decade_count[decade] = 1
    for count in decade_count.values():
        if count >= 3:
            return True
    return False
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_decade = [combinazione for combinazione in combinazioni_finali_filtrate_gemelli if not has_same_decade(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3-4-5 numeri in decina uguale:", len(combinazioni_finali_filtrate_decade))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con 3-4-5 numeri in decina uguale:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_decade:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3-4-5 numeri in decina uguale:", combinazioni_finali_filtrate_decade[0])
# Definiamo le figure nel lotto
figure = {
    1: [1, 10, 19, 28, 37, 46, 55, 64, 73, 82],
    2: [2, 11, 20, 29, 38, 47, 56, 65, 74, 83],
    3: [3, 12, 21, 30, 39, 48, 57, 66, 75, 84],
    4: [4, 13, 22, 31, 40, 49, 58, 67, 76, 85],
    5: [5, 14, 23, 32, 41, 50, 59, 68, 77, 86],
    6: [6, 15, 24, 33, 42, 51, 60, 69, 78, 87],
    7: [7, 16, 25, 34, 43, 52, 61, 70, 79, 88],
    8: [8, 17, 26, 35, 44, 53, 62, 71, 80, 89],
    9: [9, 18, 27, 36, 45, 54, 63, 72, 81, 90]
}
# Definiamo una funzione per verificare se una combinazione ha 3, 4 o 5 numeri della stessa figura
def has_same_figure(combination):
    for figura, numeri_figura in figure.items():
        count = sum(1 for num in combination if num in numeri_figura)
        if count >= 3:
            return True
    return False
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_figura = [combinazione for combinazione in combinazioni_finali_filtrate_decade if not has_same_figure(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3-4-5 numeri della stessa figura:", len(combinazioni_finali_filtrate_figura))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con 3-4-5 numeri della stessa figura:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_figura:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3-4-5 numeri della stessa figura:", combinazioni_finali_filtrate_figura[0])
# Definiamo le controfigure nel lotto
controfigure = {
    1: [1, 12, 23, 34, 45, 56, 67, 78, 89],
    2: [2, 13, 24, 35, 46, 57, 68, 79, 90],
    3: [3, 11, 14, 25, 36, 47, 58, 69, 80],
    4: [4, 15, 22, 26, 37, 48, 59, 70, 81],
    5: [5, 16, 27, 33, 38, 49, 60, 71, 82],
    6: [6, 17, 28, 39, 44, 50, 61, 72, 83],
    7: [7, 18, 29, 40, 51, 55, 62, 73, 84],
    8: [8, 19, 30, 41, 52, 63, 66, 74, 85],
    9: [9, 20, 31, 42, 53, 64, 75, 77, 86],
    10: [10, 21, 32, 43, 54, 65, 76, 87, 88]
}
# Definiamo una funzione per verificare se una combinazione ha 3, 4 o 5 numeri della stessa controfigura
def has_same_controfigure(combination):
    for controfigura, numeri_controfigura in controfigure.items():
        count = sum(1 for num in combination if num in numeri_controfigura)
        if count >= 3:
            return True
    return False
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_controfigura = [combinazione for combinazione in combinazioni_finali_filtrate_figura if not has_same_controfigure(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3-4-5 numeri della stessa controfigura:", len(combinazioni_finali_filtrate_controfigura))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con 3-4-5 numeri della stessa controfigura:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_controfigura:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3-4-5 numeri della stessa controfigura:", combinazioni_finali_filtrate_controfigura[0])
def filtro_cifra_uguale(combinazioni):
    cifre = {
        1: [1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 21, 31, 41, 51, 61, 71, 81],
        2: [2, 12, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 32, 42, 52, 62, 72, 82],
        3: [3, 13, 23, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 43, 53, 63, 73, 83],
        4: [4, 14, 24, 34, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 54, 64, 74, 84],
        5: [5, 15, 25, 35, 45, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 65, 75, 85],
        6: [6, 16, 26, 36, 46, 56, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 76, 86],
        7: [7, 17, 27, 37, 47, 57, 67, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 87],
        8: [8, 18, 28, 38, 48, 58, 68, 78, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89]
    }
    start_time = time.time()
    combinazioni_filtrate = []
    for combinazione in combinazioni:
        cifre_presenti = []
        for numero in combinazione:
            for cifra, numeri_cifra in cifre.items():
                if numero in numeri_cifra:
                    cifre_presenti.append(cifra)
                    break
        if len(set(cifre_presenti)) >= 3:
            continue
        combinazioni_filtrate.append(combinazione)
    end_time = time.time()
    tempo_impiegato = end_time - start_time
    return combinazioni_filtrate, tempo_impiegato
# Utilizzo del filtro
#combinazioni_dopo_filtro_cifra_uguale, tempo_filtro_cifra_uguale = filtro_cifra_uguale(combinazioni)
# Utilizzo del filtro
combinazioni_dopo_filtro_cifra_uguale, tempo_filtro_cifra_uguale = filtro_cifra_uguale(combinazioni_finali_filtrate_controfigura)
# Stampa dei risultati
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3-4-5 numeri della stessa cifra:", len(combinazioni_dopo_filtro_cifra_uguale))
print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3-4-5 numeri della stessa cifra:", combinazioni_dopo_filtro_cifra_uguale[0])  # Modifica l'indice in base alla tua necessità
print("Tempo impiegato per applicare il filtro delle combinazioni con 3-4-5 numeri della stessa cifra:", tempo_filtro_cifra_uguale, "secondi")
#import time  # Assicurati di importare il modulo time per utilizzare la funzione time.time()
# Definiamo le terzine simmetriche
terzine_simmetriche = [
    [16, 46, 76], [6, 36, 66], [28, 58, 88], [21, 51, 81], [5, 35, 65],
    [1, 31, 61], [23, 53, 83], [22, 52, 82], [2, 32, 62], [19, 49, 79],
    [20, 50, 80], [24, 54, 84], [29, 59, 89], [30, 60, 90], [27, 57, 87],
    [25, 55, 85], [26, 56, 86], [18, 48, 78], [9, 39, 69], [10, 40, 70],
    [11, 41, 71], [4, 34, 64], [7, 37, 67], [8, 38, 68], [15, 45, 75],
    [3, 33, 63], [17, 47, 77], [12, 42, 72], [13, 43, 73], [14, 44, 74]
]
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
# Creiamo una nuova lista vuota per le combinazioni finali dopo il filtro delle terzine simmetriche
combinazioni_finali_dopo_terzine = []
# Iteriamo su ogni combinazione rimanente dopo i filtri precedenti
for combinazione in combinazioni_dopo_filtro_cifra_uguale:
    # Verifichiamo se la combinazione contiene almeno tre numeri appartenenti a una terzina simmetrica
    has_symmetric = False
    for trio in terzine_simmetriche:
        count = sum(1 for num in combinazione if num in trio)
        if count >= 3:
            has_symmetric = True
            break
    # Se la combinazione non contiene una terzina simmetrica, la aggiungiamo alla lista delle combinazioni finali
    if not has_symmetric:
        combinazioni_finali_dopo_terzine.append(combinazione)
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con terzine simmetriche:", len(combinazioni_finali_dopo_terzine))
filter_time = time.time() - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con terzine simmetriche:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_dopo_terzine:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con terzine simmetriche:", combinazioni_finali_dopo_terzine[0])
# Definiamo la funzione filtro_numeri_radicali
def filtro_numeri_radicali(combinazioni_finali_dopo_terzine):
    gruppi_radicali = {
        8: [8, 80, 88, 89],
        4: [4, 40, 44, 49],
        7: [7, 70, 77, 79],
        3: [3, 30, 33, 39],
        6: [6, 60, 66, 69],
        2: [2, 20, 22, 29],
        1: [1, 10, 11, 19],
        5: [5, 50, 55, 59]
    }
    combinazioni_filtrate = []
    for combinazione in combinazioni_finali_dopo_terzine:
        numeri_radicali_presenti = 0
        for gruppo in gruppi_radicali.values():
            if all(numero in combinazione for numero in gruppo):
                numeri_radicali_presenti += 1
        if numeri_radicali_presenti < 4:
            combinazioni_filtrate.append(combinazione)
    return combinazioni_filtrate
# Applichiamo il filtro numeri radicali
combinazioni_filtrate = filtro_numeri_radicali(combinazioni_finali_dopo_terzine)
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni radicali:", len(combinazioni_filtrate))
filter_time = time.time() - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni radicali:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_filtrate:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni radicali:", combinazioni_filtrate[0])
# 17) eliminazione di tutte le cinquine rimaste dopo i precedenti filtri con 3 Zerati e 2 Gemelli
def filtro_cinquine_zerati_gemelli(combinazioni_finali_dopo_numeri_radicali):
    combinazioni_filtrate = []
    for combinazione in combinazioni_finali_dopo_numeri_radicali:
        count_zerati = sum(1 for num in combinazione if num % 10 == 0)
        count_gemelli = sum(1 for num in combinazione if combinazione.count(num) >= 2)
        if count_zerati != 3 or count_gemelli != 2:
            combinazioni_filtrate.append(combinazione)
    return combinazioni_filtrate
# Applichiamo il filtro delle cinquine con 3 Zerati e 2 Gemelli
combinazioni_filtrate = filtro_cinquine_zerati_gemelli(combinazioni_filtrate)
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3 Zerati e 2 Gemelli:", len(combinazioni_filtrate))
filter_time = time.time() - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con 3 Zerati e 2 Gemelli:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_filtrate:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3 Zerati e 2 Gemelli:", combinazioni_filtrate[0])
# 18) eliminazione delle cinquine rimaste dopo i precedenti filtri con 3 Gemelli e 2 Zerati
def filtro_cinquine_gemelli_zerati(combinazioni_finali_dopo_zerati_gemelli):
    combinazioni_filtrate = []
    for combinazione in combinazioni_finali_dopo_zerati_gemelli:
        count_gemelli = sum(1 for num in combinazione if combinazione.count(num) >= 2)
        count_zerati = sum(1 for num in combinazione if num % 10 == 0)
        if count_gemelli != 3 or count_zerati != 2:
            combinazioni_filtrate.append(combinazione)
    return combinazioni_filtrate
# Applichiamo il filtro delle cinquine con 3 Gemelli e 2 Zerati
combinazioni_filtrate = filtro_cinquine_gemelli_zerati(combinazioni_filtrate)
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3 Gemelli e 2 Zerati:", len(combinazioni_filtrate))
filter_time = time.time() - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con 3 Gemelli e 2 Zerati:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_filtrate:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3 Gemelli e 2 Zerati:", combinazioni_filtrate[0])
# 19) eliminazione di tutte le cinquine rimaste con 3-4-5 zerati
def filtro_cinquine_zerati(combinazioni_finali_dopo_cinquine_gemelli_zerati):
    combinazioni_filtrate = []
    for combinazione in combinazioni_finali_dopo_cinquine_gemelli_zerati:
        count_zerati = sum(1 for num in combinazione if num % 10 == 0)
        if count_zerati not in [3, 4, 5]:
            combinazioni_filtrate.append(combinazione)
    return combinazioni_filtrate
# Applichiamo il filtro delle cinquine con 3-4-5 zerati
combinazioni_filtrate = filtro_cinquine_zerati(combinazioni_filtrate)
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3-4-5 zerati:", len(combinazioni_filtrate))
filter_time = time.time() - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con 3-4-5 zerati:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_filtrate:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3-4-5 zerati:", combinazioni_filtrate[0])

ps: con gruppi base ridotti... tipo abs, semi abs e gruppi di classe <= 45 è una scheggia... Io come già detto e come ho scritto anche nelle info all'interno del code lo testerò con le mie cf36 condivise nel mio thread relativo nella sezione "sistemistica" x teorico esito a colpo su ruota unica.

siiii, elenco perfetto

finisco di postare cose importanti (previsione in corso da condizioni rare...)

poi se non mi addormento (per farmaci) ripasso qui a rileggerlo con calma

 

[felix10]

Ciao Baffo e ciao a tutti

Non sono sicuro di aver capito cosa vorresti...

Ma per adesso ti ho buttato giù questo... (con l'aggiornamento incluso...)

Salvo errori...

--------- prova elenco richiesto da Baffo ----------------------------------

Combinazioni totali in classe 5 generabili dai 90 : 43.949.268

Dopo eliminazione di:

Tutte quelle uscite dal 1874 all'ultima estrazione disponibile: 43939053

Tutte quelle con 3-4-5 numeri in cadenza uguale: 41114825

Tutte quelle con 3-4-5 numeri consecutivi: 40800568

Tutte quelle con 3-4-5 numeri pari : 20400384 <<<<< riduzione del 50% ca della massa numerica...

Tutte quelle con 4-5 numeri dispari : 6891091

Tutte quelle con 3-4-5 gemelli: 6862400

Tutte quelle con 3-4-5 numeri in decina uguale: 6348057

Tutte quelle con 3-4-5 numeri della stessa Figura: 5815449

Tutte quelle con 3-4-5 numeri della stessa ControFigura: 5413090

Tutte quelle con 3-4-5 numeri della stessa Cifra: 223928 <<<<< Quindi, il valore 223928 è ridotto di circa il 95.87% rispetto al valore 5413090

Tutte quelle con numeri di un terno delle Terzine Simmetriche distanza 30: 223928

Tutte quelle con i 4 numeri Radicali di ogni gruppo: 223928

Tutte quelle con 3 Zerati e 2 Gemelli: 223928

Tutte quelle con 3 Gemelli e 2 Zerati: 223928

Tutte quelle con 3-4-5 zerati: 223928

Tutte quelle con i 5 numeri più ritardati in quel momento: 223928

Tutte quelle con i 5 numeri meno frequenti in quel momento: 223928



Come si vede da questo "elenco progressivo discendente della quantità di cinquine di volta in volta rimaste dopo l'applicazione di ciascun filtro impilato" la riduzione sembra purtroppo.. stabilizzarsi a 223928 cinquine che comunque è già di per sè una riduzione "mostruosa" rispetto le circa 44 milioni formazioni generabili integralmente in classe 5 by 90. I picchi riduzionali maggiori si notano ai filtri pari e dispari e a quello delle cifre.


👋🙂

Relativo "last code" python da verificare, ottimizzare e completare... ma già funzionante...

import itertools
import time


#memo riguardo i filtri già implementati e da implementare

# 1) eliminazione di tutte le cinquine già uscite su bari dal 1874 OK
# 2) Tutte quelle con 3-4-5 numeri in cadenza uguale. OK
# 3) Tutte quelle con 3-4-5 numeri consecutivi. OK
# 4) Tutte quelle con almeno 3 numeri pari OK
# 5) Tutte quelle con almeno 4 numeri dispari OK
# 6) Tutte quelle con 3-4-5 gemelli. OK
# 7) Tutte quelle con 3-4-5 numeri in decina uguale. OK
# 8) Tutte quelle con 3-4-5 numeri della stessa Figura. OK
# 9) Tutte quelle con 3-4-5 numeri della stessa ControFigura. OK
# 10) Tutte quelle con 3-4-5 numeri della stessa Cifra. OK
# 11) Tutte quelle con numeri di un terno delle Terzine Simmetriche distanza 30. OK anche se necessita forse di ulteriore verifica visto che non avrebbe filtrate nessuna...
# 12) Tutte quelle con i 4 numeri Radicali di ogni gruppo. OK anche se necessita forse di ulteriore verifica visto che non avrebbe filtrate nessuna...
# 13) Tutte quelle con 3 Zerati e 2 Gemelli. OK anche se necessita forse di ulteriore verifica visto che non avrebbe filtrate nessuna...
# 14) Tutte quelle con 3 Gemelli e 2 Zerati. OK anche se necessita forse di ulteriore verifica visto che non avrebbe filtrate nessuna...
# 15 Tutte quelle con 3-4-5 zerati.   OK anche se necessita forse di ulteriore verifica visto che non avrebbe filtrate nessuna...
# 16) Tutte quelle con i 5 numeri più ritardati in quel momento.  ANCORA DA FARE...
# 17) Tutte quelle con i 5 numeri meno frequenti in quel momento.  ANCORA DA FARE...


#implementata anche la possibilità di scegliere anzichè tutti i 90 anche gruppi numerici base molto più ristretti come abs, semi abs, cf ecc...
#io a tal proposito lo testerò subito con due mie cf36 una per BARI e una per CAGLIARI... :)



file_path = "estrazioni-bari.txt"
# Creiamo un dizionario per memorizzare tutte le combinazioni estratte da Bari
formazioni_estrazioni = {}
# Apriamo il file e leggiamo le estrazioni riga per riga
with open(file_path, "r") as file:
    for line in file:
        # Dividiamo la riga in una lista di numeri
        numeri_riga = tuple(sorted(map(int, line.strip().split(","))))
        # Aggiungiamo la tupla dei numeri estratti al dizionario con la combinazione come chiave
        formazioni_estrazioni[numeri_riga] = True

# Definiamo il tempo di inizio dell'esecuzione dello script
start_time = time.time()

# Definisci il gruppo numerico personalizzato di tua scelta
gruppo_numerico_personalizzato = [1, 3, 7, 8, 9, 11, 12, 13, 14, 17, 20, 25, 26, 32, 37, 38, 42, 43, 48, 49, 51, 52, 54, 58, 62, 63, 67, 69, 71, 72, 73, 76, 79, 81, 82, 89]

# Stampiamo il numero di combinazioni finali prima di applicare qualunque tipo di filtro
print("Numero di combinazioni finali prima di applicare qualunque tipo di filtro:", len(list(itertools.combinations(gruppo_numerico_personalizzato, 5))))

# Generiamo tutte le possibili combinazioni di 5 numeri nel gruppo numerico personalizzato, escludendo le combinazioni già estratte da Bari
combinazioni_finali = []
for combinazione in itertools.combinations(gruppo_numerico_personalizzato, 5):
    if combinazione not in formazioni_estrazioni:
        combinazioni_finali.append(combinazione)

# Stampiamo il numero di combinazioni finali dopo il filtro e un esempio di esse
print("Numero di combinazioni finali dopo il filtro 'eliminazione di tutte le c5 già uscite su bari dal 1874':", len(combinazioni_finali))
if combinazioni_finali:
    print("Esempio di combinazione finale dopo il filtro 'eliminazione c5 già uscite':", combinazioni_finali[0])

# Stampiamo il tempo impiegato per generare le combinazioni
end_time = time.time()
generation_time = end_time - start_time
print("Tempo impiegato per generare le combinazioni:", generation_time, "secondi")



# Definiamo una funzione per verificare se una combinazione ha 3, 4 o 5 numeri nella stessa cadenza
def has_same_stride(combination):
    cadenze = {
        1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 0: 0
    }
    # Calcoliamo la cadenza di ciascun numero nella combinazione
    for num in combination:
        cadenza = num % 10
        cadenze[cadenza] += 1
    # Controlliamo se ci sono 3, 4 o 5 numeri nella stessa cadenza
    for numeri_cadenza in cadenze.values():
        if numeri_cadenza >= 3:
            return True
    return False
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate = [combinazione for combinazione in combinazioni_finali if not has_same_stride(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle cadenze:", len(combinazioni_finali_filtrate))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro delle cadenze:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate:
    print("Esempio di combinazione finale dopo il filtro delle cadenze:", combinazioni_finali_filtrate[0])
# Definiamo una funzione per verificare se una combinazione ha 3 numeri consecutivi
def has_consecutive_numbers(combination):
    sorted_combination = sorted(combination)
    for i in range(len(sorted_combination) - 2):
        if sorted_combination[i] + 1 == sorted_combination[i+1] and sorted_combination[i+1] + 1 == sorted_combination[i+2]:
            return True
    return False
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_consecutivi = [combinazione for combinazione in combinazioni_finali_filtrate if not has_consecutive_numbers(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro dei valori consecutivi:", len(combinazioni_finali_filtrate_consecutivi))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro dei valori consecutivi:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_consecutivi:
    print("Esempio di combinazione finale dopo il filtro dei valori consecutivi:", combinazioni_finali_filtrate_consecutivi[0])
# Modifichiamo la funzione per verificare se una combinazione ha almeno 3 numeri pari
def has_at_least_three_even_numbers(combination):
    count_even = sum(1 for num in combination if num % 2 == 0)
    return count_even >= 3
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_pari = [combinazione for combinazione in combinazioni_finali_filtrate_consecutivi if not has_at_least_three_even_numbers(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro dell'eliminazione di c5 con 3 o più numeri pari:", len(combinazioni_finali_filtrate_pari))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro dei numeri pari:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_pari:
    print("Esempio di combinazione finale dopo il filtro dell'eliminazione di c5 con 3 o più numeri pari:", combinazioni_finali_filtrate_pari[0])
# Definiamo una funzione per verificare se una combinazione ha almeno 4 numeri dispari
def has_at_least_four_odd_numbers(combination):
    count_odd = sum(1 for num in combination if num % 2 != 0)
    return count_odd >= 4
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_dispari = [combinazione for combinazione in combinazioni_finali_filtrate_pari if has_at_least_four_odd_numbers(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro dell'eliminazione di c5 con 4 o più numeri dispari:", len(combinazioni_finali_filtrate_dispari))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro dei numeri dispari:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_dispari:
    print("Esempio di combinazione finale dopo il filtro dell'eliminazione di c5 con 4 o più numeri dispari:", combinazioni_finali_filtrate_dispari[0])
# Definiamo una funzione per verificare se una combinazione ha 3 o più numeri gemelli
def has_three_or_more_twins(combination):
    twins = [11, 22, 33, 44, 55, 66, 77, 88]  # Lista dei numeri gemelli
    count_twins = sum(1 for num in combination if num in twins)
    if count_twins >= 3:
        return True
    return False
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_gemelli = [combinazione for combinazione in combinazioni_finali_filtrate_dispari if not has_three_or_more_twins(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3 o più gemelli:", len(combinazioni_finali_filtrate_gemelli))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro dei gemelli:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_gemelli:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3 o più gemelli:", combinazioni_finali_filtrate_gemelli[0])
# Definiamo una funzione per verificare se una combinazione ha 3, 4 o 5 numeri nella stessa decina
def has_same_decade(combination):
    decade_count = {}
    for num in combination:
        decade = num // 10
        if decade in decade_count:
            decade_count[decade] += 1
        else:
            decade_count[decade] = 1
    for count in decade_count.values():
        if count >= 3:
            return True
    return False
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_decade = [combinazione for combinazione in combinazioni_finali_filtrate_gemelli if not has_same_decade(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3-4-5 numeri in decina uguale:", len(combinazioni_finali_filtrate_decade))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con 3-4-5 numeri in decina uguale:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_decade:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3-4-5 numeri in decina uguale:", combinazioni_finali_filtrate_decade[0])
# Definiamo le figure nel lotto
figure = {
    1: [1, 10, 19, 28, 37, 46, 55, 64, 73, 82],
    2: [2, 11, 20, 29, 38, 47, 56, 65, 74, 83],
    3: [3, 12, 21, 30, 39, 48, 57, 66, 75, 84],
    4: [4, 13, 22, 31, 40, 49, 58, 67, 76, 85],
    5: [5, 14, 23, 32, 41, 50, 59, 68, 77, 86],
    6: [6, 15, 24, 33, 42, 51, 60, 69, 78, 87],
    7: [7, 16, 25, 34, 43, 52, 61, 70, 79, 88],
    8: [8, 17, 26, 35, 44, 53, 62, 71, 80, 89],
    9: [9, 18, 27, 36, 45, 54, 63, 72, 81, 90]
}
# Definiamo una funzione per verificare se una combinazione ha 3, 4 o 5 numeri della stessa figura
def has_same_figure(combination):
    for figura, numeri_figura in figure.items():
        count = sum(1 for num in combination if num in numeri_figura)
        if count >= 3:
            return True
    return False
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_figura = [combinazione for combinazione in combinazioni_finali_filtrate_decade if not has_same_figure(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3-4-5 numeri della stessa figura:", len(combinazioni_finali_filtrate_figura))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con 3-4-5 numeri della stessa figura:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_figura:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3-4-5 numeri della stessa figura:", combinazioni_finali_filtrate_figura[0])
# Definiamo le controfigure nel lotto
controfigure = {
    1: [1, 12, 23, 34, 45, 56, 67, 78, 89],
    2: [2, 13, 24, 35, 46, 57, 68, 79, 90],
    3: [3, 11, 14, 25, 36, 47, 58, 69, 80],
    4: [4, 15, 22, 26, 37, 48, 59, 70, 81],
    5: [5, 16, 27, 33, 38, 49, 60, 71, 82],
    6: [6, 17, 28, 39, 44, 50, 61, 72, 83],
    7: [7, 18, 29, 40, 51, 55, 62, 73, 84],
    8: [8, 19, 30, 41, 52, 63, 66, 74, 85],
    9: [9, 20, 31, 42, 53, 64, 75, 77, 86],
    10: [10, 21, 32, 43, 54, 65, 76, 87, 88]
}
# Definiamo una funzione per verificare se una combinazione ha 3, 4 o 5 numeri della stessa controfigura
def has_same_controfigure(combination):
    for controfigura, numeri_controfigura in controfigure.items():
        count = sum(1 for num in combination if num in numeri_controfigura)
        if count >= 3:
            return True
    return False
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_controfigura = [combinazione for combinazione in combinazioni_finali_filtrate_figura if not has_same_controfigure(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3-4-5 numeri della stessa controfigura:", len(combinazioni_finali_filtrate_controfigura))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con 3-4-5 numeri della stessa controfigura:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_controfigura:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3-4-5 numeri della stessa controfigura:", combinazioni_finali_filtrate_controfigura[0])
def filtro_cifra_uguale(combinazioni):
    cifre = {
        1: [1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 21, 31, 41, 51, 61, 71, 81],
        2: [2, 12, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 32, 42, 52, 62, 72, 82],
        3: [3, 13, 23, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 43, 53, 63, 73, 83],
        4: [4, 14, 24, 34, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 54, 64, 74, 84],
        5: [5, 15, 25, 35, 45, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 65, 75, 85],
        6: [6, 16, 26, 36, 46, 56, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 76, 86],
        7: [7, 17, 27, 37, 47, 57, 67, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 87],
        8: [8, 18, 28, 38, 48, 58, 68, 78, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89]
    }
    start_time = time.time()
    combinazioni_filtrate = []
    for combinazione in combinazioni:
        cifre_presenti = []
        for numero in combinazione:
            for cifra, numeri_cifra in cifre.items():
                if numero in numeri_cifra:
                    cifre_presenti.append(cifra)
                    break
        if len(set(cifre_presenti)) >= 3:
            continue
        combinazioni_filtrate.append(combinazione)
    end_time = time.time()
    tempo_impiegato = end_time - start_time
    return combinazioni_filtrate, tempo_impiegato
# Utilizzo del filtro
#combinazioni_dopo_filtro_cifra_uguale, tempo_filtro_cifra_uguale = filtro_cifra_uguale(combinazioni)
# Utilizzo del filtro
combinazioni_dopo_filtro_cifra_uguale, tempo_filtro_cifra_uguale = filtro_cifra_uguale(combinazioni_finali_filtrate_controfigura)
# Stampa dei risultati
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3-4-5 numeri della stessa cifra:", len(combinazioni_dopo_filtro_cifra_uguale))
print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3-4-5 numeri della stessa cifra:", combinazioni_dopo_filtro_cifra_uguale[0])  # Modifica l'indice in base alla tua necessità
print("Tempo impiegato per applicare il filtro delle combinazioni con 3-4-5 numeri della stessa cifra:", tempo_filtro_cifra_uguale, "secondi")
#import time  # Assicurati di importare il modulo time per utilizzare la funzione time.time()
# Definiamo le terzine simmetriche
terzine_simmetriche = [
    [16, 46, 76], [6, 36, 66], [28, 58, 88], [21, 51, 81], [5, 35, 65],
    [1, 31, 61], [23, 53, 83], [22, 52, 82], [2, 32, 62], [19, 49, 79],
    [20, 50, 80], [24, 54, 84], [29, 59, 89], [30, 60, 90], [27, 57, 87],
    [25, 55, 85], [26, 56, 86], [18, 48, 78], [9, 39, 69], [10, 40, 70],
    [11, 41, 71], [4, 34, 64], [7, 37, 67], [8, 38, 68], [15, 45, 75],
    [3, 33, 63], [17, 47, 77], [12, 42, 72], [13, 43, 73], [14, 44, 74]
]
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
# Creiamo una nuova lista vuota per le combinazioni finali dopo il filtro delle terzine simmetriche
combinazioni_finali_dopo_terzine = []
# Iteriamo su ogni combinazione rimanente dopo i filtri precedenti
for combinazione in combinazioni_dopo_filtro_cifra_uguale:
    # Verifichiamo se la combinazione contiene almeno tre numeri appartenenti a una terzina simmetrica
    has_symmetric = False
    for trio in terzine_simmetriche:
        count = sum(1 for num in combinazione if num in trio)
        if count >= 3:
            has_symmetric = True
            break
    # Se la combinazione non contiene una terzina simmetrica, la aggiungiamo alla lista delle combinazioni finali
    if not has_symmetric:
        combinazioni_finali_dopo_terzine.append(combinazione)
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con terzine simmetriche:", len(combinazioni_finali_dopo_terzine))
filter_time = time.time() - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con terzine simmetriche:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_dopo_terzine:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con terzine simmetriche:", combinazioni_finali_dopo_terzine[0])
# Definiamo la funzione filtro_numeri_radicali
def filtro_numeri_radicali(combinazioni_finali_dopo_terzine):
    gruppi_radicali = {
        8: [8, 80, 88, 89],
        4: [4, 40, 44, 49],
        7: [7, 70, 77, 79],
        3: [3, 30, 33, 39],
        6: [6, 60, 66, 69],
        2: [2, 20, 22, 29],
        1: [1, 10, 11, 19],
        5: [5, 50, 55, 59]
    }
    combinazioni_filtrate = []
    for combinazione in combinazioni_finali_dopo_terzine:
        numeri_radicali_presenti = 0
        for gruppo in gruppi_radicali.values():
            if all(numero in combinazione for numero in gruppo):
                numeri_radicali_presenti += 1
        if numeri_radicali_presenti < 4:
            combinazioni_filtrate.append(combinazione)
    return combinazioni_filtrate
# Applichiamo il filtro numeri radicali
combinazioni_filtrate = filtro_numeri_radicali(combinazioni_finali_dopo_terzine)
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni radicali:", len(combinazioni_filtrate))
filter_time = time.time() - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni radicali:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_filtrate:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni radicali:", combinazioni_filtrate[0])
# 17) eliminazione di tutte le cinquine rimaste dopo i precedenti filtri con 3 Zerati e 2 Gemelli
def filtro_cinquine_zerati_gemelli(combinazioni_finali_dopo_numeri_radicali):
    combinazioni_filtrate = []
    for combinazione in combinazioni_finali_dopo_numeri_radicali:
        count_zerati = sum(1 for num in combinazione if num % 10 == 0)
        count_gemelli = sum(1 for num in combinazione if combinazione.count(num) >= 2)
        if count_zerati != 3 or count_gemelli != 2:
            combinazioni_filtrate.append(combinazione)
    return combinazioni_filtrate
# Applichiamo il filtro delle cinquine con 3 Zerati e 2 Gemelli
combinazioni_filtrate = filtro_cinquine_zerati_gemelli(combinazioni_filtrate)
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3 Zerati e 2 Gemelli:", len(combinazioni_filtrate))
filter_time = time.time() - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con 3 Zerati e 2 Gemelli:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_filtrate:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3 Zerati e 2 Gemelli:", combinazioni_filtrate[0])
# 18) eliminazione delle cinquine rimaste dopo i precedenti filtri con 3 Gemelli e 2 Zerati
def filtro_cinquine_gemelli_zerati(combinazioni_finali_dopo_zerati_gemelli):
    combinazioni_filtrate = []
    for combinazione in combinazioni_finali_dopo_zerati_gemelli:
        count_gemelli = sum(1 for num in combinazione if combinazione.count(num) >= 2)
        count_zerati = sum(1 for num in combinazione if num % 10 == 0)
        if count_gemelli != 3 or count_zerati != 2:
            combinazioni_filtrate.append(combinazione)
    return combinazioni_filtrate
# Applichiamo il filtro delle cinquine con 3 Gemelli e 2 Zerati
combinazioni_filtrate = filtro_cinquine_gemelli_zerati(combinazioni_filtrate)
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3 Gemelli e 2 Zerati:", len(combinazioni_filtrate))
filter_time = time.time() - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con 3 Gemelli e 2 Zerati:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_filtrate:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3 Gemelli e 2 Zerati:", combinazioni_filtrate[0])
# 19) eliminazione di tutte le cinquine rimaste con 3-4-5 zerati
def filtro_cinquine_zerati(combinazioni_finali_dopo_cinquine_gemelli_zerati):
    combinazioni_filtrate = []
    for combinazione in combinazioni_finali_dopo_cinquine_gemelli_zerati:
        count_zerati = sum(1 for num in combinazione if num % 10 == 0)
        if count_zerati not in [3, 4, 5]:
            combinazioni_filtrate.append(combinazione)
    return combinazioni_filtrate
# Applichiamo il filtro delle cinquine con 3-4-5 zerati
combinazioni_filtrate = filtro_cinquine_zerati(combinazioni_filtrate)
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3-4-5 zerati:", len(combinazioni_filtrate))
filter_time = time.time() - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con 3-4-5 zerati:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_filtrate:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3-4-5 zerati:", combinazioni_filtrate[0])

ps: con gruppi base ridotti... tipo abs, semi abs e gruppi di classe <= 45 è una scheggia... Io come già detto e come ho scritto anche nelle info all'interno del code lo testerò con le mie cf36 condivise nel mio thread relativo nella sezione "sistemistica" x teorico esito a colpo su ruota unica.

Tom ho provato ha fare girare lo script con Colab ma si pianta il PC. Se in futuro si riuscirà con uno script che gira su spazio metria sarò lieto di aiutarti nelle ricerche e snellire i tempi.

 

[BaffoBlù]

Ciao Baffo e ciao a tutti

Non sono sicuro di aver capito cosa vorresti...

Ma per adesso ti ho buttato giù questo... (con l'aggiornamento incluso...)

Salvo errori...

--------- prova elenco richiesto da Baffo ----------------------------------

Combinazioni totali in classe 5 generabili dai 90 : 43.949.268

Dopo eliminazione di:

Tutte quelle uscite dal 1874 all'ultima estrazione disponibile: 43939053

Tutte quelle con 3-4-5 numeri in cadenza uguale: 41114825

Tutte quelle con 3-4-5 numeri consecutivi: 40800568

Tutte quelle con 3-4-5 numeri pari : 20400384 <<<<< riduzione del 50% ca della massa numerica...

Tutte quelle con 4-5 numeri dispari : 6891091

Tutte quelle con 3-4-5 gemelli: 6862400

Tutte quelle con 3-4-5 numeri in decina uguale: 6348057

Tutte quelle con 3-4-5 numeri della stessa Figura: 5815449

Tutte quelle con 3-4-5 numeri della stessa ControFigura: 5413090

Tutte quelle con 3-4-5 numeri della stessa Cifra: 223928 <<<<< Quindi, il valore 223928 è ridotto di circa il 95.87% rispetto al valore 5413090

Tutte quelle con numeri di un terno delle Terzine Simmetriche distanza 30: 223928

Tutte quelle con i 4 numeri Radicali di ogni gruppo: 223928

Tutte quelle con 3 Zerati e 2 Gemelli: 223928

Tutte quelle con 3 Gemelli e 2 Zerati: 223928

Tutte quelle con 3-4-5 zerati: 223928

Tutte quelle con i 5 numeri più ritardati in quel momento: 223928

Tutte quelle con i 5 numeri meno frequenti in quel momento: 223928



Come si vede da questo "elenco progressivo discendente della quantità di cinquine di volta in volta rimaste dopo l'applicazione di ciascun filtro impilato" la riduzione sembra purtroppo.. stabilizzarsi a 223928 cinquine che comunque è già di per sè una riduzione "mostruosa" rispetto le circa 44 milioni formazioni generabili integralmente in classe 5 by 90. I picchi riduzionali maggiori si notano ai filtri pari e dispari e a quello delle cifre.


👋🙂

Relativo "last code" python da verificare, ottimizzare e completare... ma già funzionante...

import itertools
import time


#memo riguardo i filtri già implementati e da implementare

# 1) eliminazione di tutte le cinquine già uscite su bari dal 1874 OK
# 2) Tutte quelle con 3-4-5 numeri in cadenza uguale. OK
# 3) Tutte quelle con 3-4-5 numeri consecutivi. OK
# 4) Tutte quelle con almeno 3 numeri pari OK
# 5) Tutte quelle con almeno 4 numeri dispari OK
# 6) Tutte quelle con 3-4-5 gemelli. OK
# 7) Tutte quelle con 3-4-5 numeri in decina uguale. OK
# 8) Tutte quelle con 3-4-5 numeri della stessa Figura. OK
# 9) Tutte quelle con 3-4-5 numeri della stessa ControFigura. OK
# 10) Tutte quelle con 3-4-5 numeri della stessa Cifra. OK
# 11) Tutte quelle con numeri di un terno delle Terzine Simmetriche distanza 30. OK anche se necessita forse di ulteriore verifica visto che non avrebbe filtrate nessuna...
# 12) Tutte quelle con i 4 numeri Radicali di ogni gruppo. OK anche se necessita forse di ulteriore verifica visto che non avrebbe filtrate nessuna...
# 13) Tutte quelle con 3 Zerati e 2 Gemelli. OK anche se necessita forse di ulteriore verifica visto che non avrebbe filtrate nessuna...
# 14) Tutte quelle con 3 Gemelli e 2 Zerati. OK anche se necessita forse di ulteriore verifica visto che non avrebbe filtrate nessuna...
# 15 Tutte quelle con 3-4-5 zerati.   OK anche se necessita forse di ulteriore verifica visto che non avrebbe filtrate nessuna...
# 16) Tutte quelle con i 5 numeri più ritardati in quel momento.  ANCORA DA FARE...
# 17) Tutte quelle con i 5 numeri meno frequenti in quel momento.  ANCORA DA FARE...


#implementata anche la possibilità di scegliere anzichè tutti i 90 anche gruppi numerici base molto più ristretti come abs, semi abs, cf ecc...
#io a tal proposito lo testerò subito con due mie cf36 una per BARI e una per CAGLIARI... :)



file_path = "estrazioni-bari.txt"
# Creiamo un dizionario per memorizzare tutte le combinazioni estratte da Bari
formazioni_estrazioni = {}
# Apriamo il file e leggiamo le estrazioni riga per riga
with open(file_path, "r") as file:
    for line in file:
        # Dividiamo la riga in una lista di numeri
        numeri_riga = tuple(sorted(map(int, line.strip().split(","))))
        # Aggiungiamo la tupla dei numeri estratti al dizionario con la combinazione come chiave
        formazioni_estrazioni[numeri_riga] = True

# Definiamo il tempo di inizio dell'esecuzione dello script
start_time = time.time()

# Definisci il gruppo numerico personalizzato di tua scelta
gruppo_numerico_personalizzato = [1, 3, 7, 8, 9, 11, 12, 13, 14, 17, 20, 25, 26, 32, 37, 38, 42, 43, 48, 49, 51, 52, 54, 58, 62, 63, 67, 69, 71, 72, 73, 76, 79, 81, 82, 89]

# Stampiamo il numero di combinazioni finali prima di applicare qualunque tipo di filtro
print("Numero di combinazioni finali prima di applicare qualunque tipo di filtro:", len(list(itertools.combinations(gruppo_numerico_personalizzato, 5))))

# Generiamo tutte le possibili combinazioni di 5 numeri nel gruppo numerico personalizzato, escludendo le combinazioni già estratte da Bari
combinazioni_finali = []
for combinazione in itertools.combinations(gruppo_numerico_personalizzato, 5):
    if combinazione not in formazioni_estrazioni:
        combinazioni_finali.append(combinazione)

# Stampiamo il numero di combinazioni finali dopo il filtro e un esempio di esse
print("Numero di combinazioni finali dopo il filtro 'eliminazione di tutte le c5 già uscite su bari dal 1874':", len(combinazioni_finali))
if combinazioni_finali:
    print("Esempio di combinazione finale dopo il filtro 'eliminazione c5 già uscite':", combinazioni_finali[0])

# Stampiamo il tempo impiegato per generare le combinazioni
end_time = time.time()
generation_time = end_time - start_time
print("Tempo impiegato per generare le combinazioni:", generation_time, "secondi")



# Definiamo una funzione per verificare se una combinazione ha 3, 4 o 5 numeri nella stessa cadenza
def has_same_stride(combination):
    cadenze = {
        1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 0: 0
    }
    # Calcoliamo la cadenza di ciascun numero nella combinazione
    for num in combination:
        cadenza = num % 10
        cadenze[cadenza] += 1
    # Controlliamo se ci sono 3, 4 o 5 numeri nella stessa cadenza
    for numeri_cadenza in cadenze.values():
        if numeri_cadenza >= 3:
            return True
    return False
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate = [combinazione for combinazione in combinazioni_finali if not has_same_stride(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle cadenze:", len(combinazioni_finali_filtrate))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro delle cadenze:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate:
    print("Esempio di combinazione finale dopo il filtro delle cadenze:", combinazioni_finali_filtrate[0])
# Definiamo una funzione per verificare se una combinazione ha 3 numeri consecutivi
def has_consecutive_numbers(combination):
    sorted_combination = sorted(combination)
    for i in range(len(sorted_combination) - 2):
        if sorted_combination[i] + 1 == sorted_combination[i+1] and sorted_combination[i+1] + 1 == sorted_combination[i+2]:
            return True
    return False
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_consecutivi = [combinazione for combinazione in combinazioni_finali_filtrate if not has_consecutive_numbers(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro dei valori consecutivi:", len(combinazioni_finali_filtrate_consecutivi))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro dei valori consecutivi:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_consecutivi:
    print("Esempio di combinazione finale dopo il filtro dei valori consecutivi:", combinazioni_finali_filtrate_consecutivi[0])
# Modifichiamo la funzione per verificare se una combinazione ha almeno 3 numeri pari
def has_at_least_three_even_numbers(combination):
    count_even = sum(1 for num in combination if num % 2 == 0)
    return count_even >= 3
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_pari = [combinazione for combinazione in combinazioni_finali_filtrate_consecutivi if not has_at_least_three_even_numbers(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro dell'eliminazione di c5 con 3 o più numeri pari:", len(combinazioni_finali_filtrate_pari))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro dei numeri pari:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_pari:
    print("Esempio di combinazione finale dopo il filtro dell'eliminazione di c5 con 3 o più numeri pari:", combinazioni_finali_filtrate_pari[0])
# Definiamo una funzione per verificare se una combinazione ha almeno 4 numeri dispari
def has_at_least_four_odd_numbers(combination):
    count_odd = sum(1 for num in combination if num % 2 != 0)
    return count_odd >= 4
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_dispari = [combinazione for combinazione in combinazioni_finali_filtrate_pari if has_at_least_four_odd_numbers(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro dell'eliminazione di c5 con 4 o più numeri dispari:", len(combinazioni_finali_filtrate_dispari))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro dei numeri dispari:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_dispari:
    print("Esempio di combinazione finale dopo il filtro dell'eliminazione di c5 con 4 o più numeri dispari:", combinazioni_finali_filtrate_dispari[0])
# Definiamo una funzione per verificare se una combinazione ha 3 o più numeri gemelli
def has_three_or_more_twins(combination):
    twins = [11, 22, 33, 44, 55, 66, 77, 88]  # Lista dei numeri gemelli
    count_twins = sum(1 for num in combination if num in twins)
    if count_twins >= 3:
        return True
    return False
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_gemelli = [combinazione for combinazione in combinazioni_finali_filtrate_dispari if not has_three_or_more_twins(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3 o più gemelli:", len(combinazioni_finali_filtrate_gemelli))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro dei gemelli:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_gemelli:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3 o più gemelli:", combinazioni_finali_filtrate_gemelli[0])
# Definiamo una funzione per verificare se una combinazione ha 3, 4 o 5 numeri nella stessa decina
def has_same_decade(combination):
    decade_count = {}
    for num in combination:
        decade = num // 10
        if decade in decade_count:
            decade_count[decade] += 1
        else:
            decade_count[decade] = 1
    for count in decade_count.values():
        if count >= 3:
            return True
    return False
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_decade = [combinazione for combinazione in combinazioni_finali_filtrate_gemelli if not has_same_decade(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3-4-5 numeri in decina uguale:", len(combinazioni_finali_filtrate_decade))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con 3-4-5 numeri in decina uguale:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_decade:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3-4-5 numeri in decina uguale:", combinazioni_finali_filtrate_decade[0])
# Definiamo le figure nel lotto
figure = {
    1: [1, 10, 19, 28, 37, 46, 55, 64, 73, 82],
    2: [2, 11, 20, 29, 38, 47, 56, 65, 74, 83],
    3: [3, 12, 21, 30, 39, 48, 57, 66, 75, 84],
    4: [4, 13, 22, 31, 40, 49, 58, 67, 76, 85],
    5: [5, 14, 23, 32, 41, 50, 59, 68, 77, 86],
    6: [6, 15, 24, 33, 42, 51, 60, 69, 78, 87],
    7: [7, 16, 25, 34, 43, 52, 61, 70, 79, 88],
    8: [8, 17, 26, 35, 44, 53, 62, 71, 80, 89],
    9: [9, 18, 27, 36, 45, 54, 63, 72, 81, 90]
}
# Definiamo una funzione per verificare se una combinazione ha 3, 4 o 5 numeri della stessa figura
def has_same_figure(combination):
    for figura, numeri_figura in figure.items():
        count = sum(1 for num in combination if num in numeri_figura)
        if count >= 3:
            return True
    return False
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_figura = [combinazione for combinazione in combinazioni_finali_filtrate_decade if not has_same_figure(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3-4-5 numeri della stessa figura:", len(combinazioni_finali_filtrate_figura))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con 3-4-5 numeri della stessa figura:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_figura:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3-4-5 numeri della stessa figura:", combinazioni_finali_filtrate_figura[0])
# Definiamo le controfigure nel lotto
controfigure = {
    1: [1, 12, 23, 34, 45, 56, 67, 78, 89],
    2: [2, 13, 24, 35, 46, 57, 68, 79, 90],
    3: [3, 11, 14, 25, 36, 47, 58, 69, 80],
    4: [4, 15, 22, 26, 37, 48, 59, 70, 81],
    5: [5, 16, 27, 33, 38, 49, 60, 71, 82],
    6: [6, 17, 28, 39, 44, 50, 61, 72, 83],
    7: [7, 18, 29, 40, 51, 55, 62, 73, 84],
    8: [8, 19, 30, 41, 52, 63, 66, 74, 85],
    9: [9, 20, 31, 42, 53, 64, 75, 77, 86],
    10: [10, 21, 32, 43, 54, 65, 76, 87, 88]
}
# Definiamo una funzione per verificare se una combinazione ha 3, 4 o 5 numeri della stessa controfigura
def has_same_controfigure(combination):
    for controfigura, numeri_controfigura in controfigure.items():
        count = sum(1 for num in combination if num in numeri_controfigura)
        if count >= 3:
            return True
    return False
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
combinazioni_finali_filtrate_controfigura = [combinazione for combinazione in combinazioni_finali_filtrate_figura if not has_same_controfigure(combinazione)]
end_time = time.time()
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3-4-5 numeri della stessa controfigura:", len(combinazioni_finali_filtrate_controfigura))
filter_time = end_time - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con 3-4-5 numeri della stessa controfigura:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_filtrate_controfigura:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3-4-5 numeri della stessa controfigura:", combinazioni_finali_filtrate_controfigura[0])
def filtro_cifra_uguale(combinazioni):
    cifre = {
        1: [1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 21, 31, 41, 51, 61, 71, 81],
        2: [2, 12, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 32, 42, 52, 62, 72, 82],
        3: [3, 13, 23, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 43, 53, 63, 73, 83],
        4: [4, 14, 24, 34, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 54, 64, 74, 84],
        5: [5, 15, 25, 35, 45, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 65, 75, 85],
        6: [6, 16, 26, 36, 46, 56, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 76, 86],
        7: [7, 17, 27, 37, 47, 57, 67, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 87],
        8: [8, 18, 28, 38, 48, 58, 68, 78, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89]
    }
    start_time = time.time()
    combinazioni_filtrate = []
    for combinazione in combinazioni:
        cifre_presenti = []
        for numero in combinazione:
            for cifra, numeri_cifra in cifre.items():
                if numero in numeri_cifra:
                    cifre_presenti.append(cifra)
                    break
        if len(set(cifre_presenti)) >= 3:
            continue
        combinazioni_filtrate.append(combinazione)
    end_time = time.time()
    tempo_impiegato = end_time - start_time
    return combinazioni_filtrate, tempo_impiegato
# Utilizzo del filtro
#combinazioni_dopo_filtro_cifra_uguale, tempo_filtro_cifra_uguale = filtro_cifra_uguale(combinazioni)
# Utilizzo del filtro
combinazioni_dopo_filtro_cifra_uguale, tempo_filtro_cifra_uguale = filtro_cifra_uguale(combinazioni_finali_filtrate_controfigura)
# Stampa dei risultati
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3-4-5 numeri della stessa cifra:", len(combinazioni_dopo_filtro_cifra_uguale))
print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3-4-5 numeri della stessa cifra:", combinazioni_dopo_filtro_cifra_uguale[0])  # Modifica l'indice in base alla tua necessità
print("Tempo impiegato per applicare il filtro delle combinazioni con 3-4-5 numeri della stessa cifra:", tempo_filtro_cifra_uguale, "secondi")
#import time  # Assicurati di importare il modulo time per utilizzare la funzione time.time()
# Definiamo le terzine simmetriche
terzine_simmetriche = [
    [16, 46, 76], [6, 36, 66], [28, 58, 88], [21, 51, 81], [5, 35, 65],
    [1, 31, 61], [23, 53, 83], [22, 52, 82], [2, 32, 62], [19, 49, 79],
    [20, 50, 80], [24, 54, 84], [29, 59, 89], [30, 60, 90], [27, 57, 87],
    [25, 55, 85], [26, 56, 86], [18, 48, 78], [9, 39, 69], [10, 40, 70],
    [11, 41, 71], [4, 34, 64], [7, 37, 67], [8, 38, 68], [15, 45, 75],
    [3, 33, 63], [17, 47, 77], [12, 42, 72], [13, 43, 73], [14, 44, 74]
]
# Applichiamo il filtro alle combinazioni finali
start_time = time.time()
# Creiamo una nuova lista vuota per le combinazioni finali dopo il filtro delle terzine simmetriche
combinazioni_finali_dopo_terzine = []
# Iteriamo su ogni combinazione rimanente dopo i filtri precedenti
for combinazione in combinazioni_dopo_filtro_cifra_uguale:
    # Verifichiamo se la combinazione contiene almeno tre numeri appartenenti a una terzina simmetrica
    has_symmetric = False
    for trio in terzine_simmetriche:
        count = sum(1 for num in combinazione if num in trio)
        if count >= 3:
            has_symmetric = True
            break
    # Se la combinazione non contiene una terzina simmetrica, la aggiungiamo alla lista delle combinazioni finali
    if not has_symmetric:
        combinazioni_finali_dopo_terzine.append(combinazione)
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con terzine simmetriche:", len(combinazioni_finali_dopo_terzine))
filter_time = time.time() - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con terzine simmetriche:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_finali_dopo_terzine:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con terzine simmetriche:", combinazioni_finali_dopo_terzine[0])
# Definiamo la funzione filtro_numeri_radicali
def filtro_numeri_radicali(combinazioni_finali_dopo_terzine):
    gruppi_radicali = {
        8: [8, 80, 88, 89],
        4: [4, 40, 44, 49],
        7: [7, 70, 77, 79],
        3: [3, 30, 33, 39],
        6: [6, 60, 66, 69],
        2: [2, 20, 22, 29],
        1: [1, 10, 11, 19],
        5: [5, 50, 55, 59]
    }
    combinazioni_filtrate = []
    for combinazione in combinazioni_finali_dopo_terzine:
        numeri_radicali_presenti = 0
        for gruppo in gruppi_radicali.values():
            if all(numero in combinazione for numero in gruppo):
                numeri_radicali_presenti += 1
        if numeri_radicali_presenti < 4:
            combinazioni_filtrate.append(combinazione)
    return combinazioni_filtrate
# Applichiamo il filtro numeri radicali
combinazioni_filtrate = filtro_numeri_radicali(combinazioni_finali_dopo_terzine)
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni radicali:", len(combinazioni_filtrate))
filter_time = time.time() - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni radicali:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_filtrate:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni radicali:", combinazioni_filtrate[0])
# 17) eliminazione di tutte le cinquine rimaste dopo i precedenti filtri con 3 Zerati e 2 Gemelli
def filtro_cinquine_zerati_gemelli(combinazioni_finali_dopo_numeri_radicali):
    combinazioni_filtrate = []
    for combinazione in combinazioni_finali_dopo_numeri_radicali:
        count_zerati = sum(1 for num in combinazione if num % 10 == 0)
        count_gemelli = sum(1 for num in combinazione if combinazione.count(num) >= 2)
        if count_zerati != 3 or count_gemelli != 2:
            combinazioni_filtrate.append(combinazione)
    return combinazioni_filtrate
# Applichiamo il filtro delle cinquine con 3 Zerati e 2 Gemelli
combinazioni_filtrate = filtro_cinquine_zerati_gemelli(combinazioni_filtrate)
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3 Zerati e 2 Gemelli:", len(combinazioni_filtrate))
filter_time = time.time() - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con 3 Zerati e 2 Gemelli:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_filtrate:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3 Zerati e 2 Gemelli:", combinazioni_filtrate[0])
# 18) eliminazione delle cinquine rimaste dopo i precedenti filtri con 3 Gemelli e 2 Zerati
def filtro_cinquine_gemelli_zerati(combinazioni_finali_dopo_zerati_gemelli):
    combinazioni_filtrate = []
    for combinazione in combinazioni_finali_dopo_zerati_gemelli:
        count_gemelli = sum(1 for num in combinazione if combinazione.count(num) >= 2)
        count_zerati = sum(1 for num in combinazione if num % 10 == 0)
        if count_gemelli != 3 or count_zerati != 2:
            combinazioni_filtrate.append(combinazione)
    return combinazioni_filtrate
# Applichiamo il filtro delle cinquine con 3 Gemelli e 2 Zerati
combinazioni_filtrate = filtro_cinquine_gemelli_zerati(combinazioni_filtrate)
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3 Gemelli e 2 Zerati:", len(combinazioni_filtrate))
filter_time = time.time() - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con 3 Gemelli e 2 Zerati:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_filtrate:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3 Gemelli e 2 Zerati:", combinazioni_filtrate[0])
# 19) eliminazione di tutte le cinquine rimaste con 3-4-5 zerati
def filtro_cinquine_zerati(combinazioni_finali_dopo_cinquine_gemelli_zerati):
    combinazioni_filtrate = []
    for combinazione in combinazioni_finali_dopo_cinquine_gemelli_zerati:
        count_zerati = sum(1 for num in combinazione if num % 10 == 0)
        if count_zerati not in [3, 4, 5]:
            combinazioni_filtrate.append(combinazione)
    return combinazioni_filtrate
# Applichiamo il filtro delle cinquine con 3-4-5 zerati
combinazioni_filtrate = filtro_cinquine_zerati(combinazioni_filtrate)
# Stampiamo il numero di combinazioni finali dopo l'applicazione del filtro e il tempo impiegato
print("Numero di combinazioni finali dopo il filtro delle combinazioni con 3-4-5 zerati:", len(combinazioni_filtrate))
filter_time = time.time() - start_time
print("Tempo impiegato per applicare il filtro delle combinazioni con 3-4-5 zerati:", filter_time, "secondi")
# Stampiamo un esempio di combinazione finale dopo il filtro
if combinazioni_filtrate:
    print("Esempio di combinazione finale dopo il filtro delle combinazioni con 3-4-5 zerati:", combinazioni_filtrate[0])

ps: con gruppi base ridotti... tipo abs, semi abs e gruppi di classe <= 45 è una scheggia... Io come già detto e come ho scritto anche nelle info all'interno del code lo testerò con le mie cf36 condivise nel mio thread relativo nella sezione "sistemistica" x teorico esito a colpo su ruota unica.

#memo riguardo i filtri già implementati e da implementare

# 1) eliminazione di tutte le cinquine già uscite su bari dal 1874 OK
# 2) Tutte quelle con 3-4-5 numeri in cadenza uguale. OK
# 3) Tutte quelle con 3-4-5 numeri consecutivi. OK

# 4) Tutte quelle con almeno 3 numeri pari OK
# 5) Tutte quelle con almeno 4 numeri dispari OK

(perché non cambi i pari con 4 ?)

# 6) Tutte quelle con 3-4-5 gemelli. OK
# 7) Tutte quelle con 3-4-5 numeri in decina uguale. OK
# 8) Tutte quelle con 3-4-5 numeri della stessa Figura. OK
# 9) Tutte quelle con 3-4-5 numeri della stessa ControFigura. OK
# 10) Tutte quelle con 3-4-5 numeri della stessa Cifra. OK

# 11) Tutte quelle con numeri di un terno delle Terzine Simmetriche distanza 30. OK anche se necessita forse di ulteriore verifica visto che non avrebbe filtrate nessuna...
# 12) Tutte quelle con i 4 numeri Radicali di ogni gruppo. OK anche se necessita forse di ulteriore verifica visto che non avrebbe filtrate nessuna...
# 13) Tutte quelle con 3 Zerati e 2 Gemelli. OK anche se necessita forse di ulteriore verifica visto che non avrebbe filtrate nessuna...
# 14) Tutte quelle con 3 Gemelli e 2 Zerati. OK anche se necessita forse di ulteriore verifica visto che non avrebbe filtrate nessuna...
# 15 Tutte quelle con 3-4-5 zerati.   OK anche se necessita forse di ulteriore verifica visto che non avrebbe filtrate nessuna...

(prova a farle all'inizio delle altre e vedi che ti esce...)

# 16) Tutte quelle con i 5 numeri più ritardati in quel momento.  ANCORA DA FARE...
# 17) Tutte quelle con i 5 numeri meno frequenti in quel momento.  ANCORA DA FARE...
------------------------------------------------------------------------------------------------------------

ottimo lavoro !