Novità

Matrici e ordinamenti

ciao a tutti, premettendo che l'argomento mi affascina ma non riesco ad entrarvi... Ho provato ad avvalermi della mia protesi.. AI 😅 e con lui (Copilot) forse qualcosina sono riuscito a ricreare. Solo non riesco nemmeno a spiegargli bene cosa dovrebbe fare... Ve la posto chiedendovi se cortesemente qualcuno di voi esperto dell'argomento mi possa dare qualche dritta su cosa chiedere ulteriormente al riguardo a Copilot.

Codice:
# Inserisci i 5 numeri dell'estrazione
numeri_estrazione = [10, 25, 37, 42, 55]

# Creazione di una griglia 90x90
num_righe = 90
num_colonne = 90

# Inizializza la griglia con valori vuoti (ad esempio, 0)
griglia = [[' ' for _ in range(num_colonne)] for _ in range(num_righe)]

# Imposta i valori delle celle corrispondenti ai numeri dell'estrazione
for numero in numeri_estrazione:
    griglia[numero - 1][numero - 1] = 'X'  # Imposta 'X' per indicare la presenza del numero

# Stampa la griglia
for riga in griglia:
    print(' '.join(riga))


In pratica per adesso questo codice python ricrea una griglia 90x90 con vari ordinamenti dislocando qualsiasi formazione di classe 5 di estratti secondo i relativi posizionamenti e sostituendoli con delle X per rendere maggiormente pratica la visualizzazione. In tal senso si occupa anche di rendere invisibile tutte le altre colonne e righe comunque presenti.

Va da se che se io ho Copilot possiamo aiutarvi in qualche modo per cercare di potenziare ulteriormente la vostra ricerca esplorandone altri punti di vista basta chiedere e ci proveremo... secondo la famosa formuletta "win to win".


Grazie anticipate e complimenti per i vostri studi e traguardi.
Ciao
ciao a tutti, premettendo che l'argomento mi affascina ma non riesco ad entrarvi... Ho provato ad avvalermi della mia protesi.. AI 😅 e con lui (Copilot) forse qualcosina sono riuscito a ricreare. Solo non riesco nemmeno a spiegargli bene cosa dovrebbe fare... Ve la posto chiedendovi se cortesemente qualcuno di voi esperto dell'argomento mi possa dare qualche dritta su cosa chiedere ulteriormente al riguardo a Copilot.

Codice:
# Inserisci i 5 numeri dell'estrazione
numeri_estrazione = [10, 25, 37, 42, 55]

# Creazione di una griglia 90x90
num_righe = 90
num_colonne = 90

# Inizializza la griglia con valori vuoti (ad esempio, 0)
griglia = [[' ' for _ in range(num_colonne)] for _ in range(num_righe)]

# Imposta i valori delle celle corrispondenti ai numeri dell'estrazione
for numero in numeri_estrazione:
    griglia[numero - 1][numero - 1] = 'X'  # Imposta 'X' per indicare la presenza del numero

# Stampa la griglia
for riga in griglia:
    print(' '.join(riga))


In pratica per adesso questo codice python ricrea una griglia 90x90 con vari ordinamenti dislocando qualsiasi formazione di classe 5 di estratti secondo i relativi posizionamenti e sostituendoli con delle X per rendere maggiormente pratica la visualizzazione. In tal senso si occupa anche di rendere invisibile tutte le altre colonne e righe comunque presenti.

Va da se che se io ho Copilot possiamo aiutarvi in qualche modo per cercare di potenziare ulteriormente la vostra ricerca esplorandone altri punti di vista basta chiedere e ci proveremo... secondo la famosa formuletta "win to win".


Grazie anticipate e complimenti per i vostri studi e traguardi.
Ciao Lotto Tom ma riesci con copilot a realizzare un software? Ne ho sentito parlare ma non credevo fosse davvero così efficiente.
 
Ciao Lorenzo e a tutti gli altri
ho fatto un automatico che genera le matrici e gli ordinamenti, poi trasformo la cinquina di bari dell'estrazione di calcolo in tutti i settori e faccio il debug per cinquina .... quando la trova e a volte fa molti cicli per esempio l'ultima prova ci sono voluti piu di 17000 cicli ho voluto vedere se poi i settori vicini facessero la quaterna e i terni ..... purtroppo su 10 prove neanche una quaterna e pochissimi terni fuori ruota ..... probabilmente non e' questo il modo per trovare la cinquina.
 
Ciao

Ciao Lotto Tom ma riesci con copilot a realizzare un software? Ne ho sentito parlare ma non credevo fosse davvero così efficiente.

Si sopratutto chatgpt 4o (alias copilot x microsoft) e claude sonnet 3.5 sono in grado di programmare in modo efficiente e veloce anche nelle loro versioni free con limiti di tempo. L'esclusiva funzione "artifacts" di Claude poi è da sballo. Il loro forte da quello che ho potuto testare è python ma credo possano costruire codici efficaci anche in altri molteplici diversi linguaggi.

Ecco un esempio, salvo errori concettuali, dell'ultimo codice python con relativa spiegazione realizzato da parte sempre di chatgpt 4o e chatgpt 3.5 che ho richiesto e che l'AI mi ha realizzato riguardo i vostri studi...

Determinante è stato il post di FrancoBru che ringrazio e saluto che ha riassunto nella sua domanda tutti i punti essenziali della vostra ricerca/riduzione e che sono stati determinanti per la comprensione da parte di chatgpt4o di ciò che volevo ottenere come base di sviluppo.

Codice:
import random
import re
import numpy as np
from scipy.spatial.distance import cosine

# Funzione per creare una griglia 90x90 senza duplicati su righe e colonne
def crea_griglia():
    numeri = list(range(1, 91))
    griglia = []
    for _ in range(90):
        riga = random.sample(numeri, 90)
        griglia.append(riga)
    return griglia

# Funzione per leggere le cinquine da un file
def leggi_cinquine_da_file(nome_file):
    cinquine = []
    with open(nome_file, 'r') as file:
        for line in file:
            line = line.strip()
            if line:
                numeri = re.findall(r'\d+', line)
                cinquina = [int(numero) for numero in numeri[:5]]  # Prende i primi 5 numeri trovati
                if len(cinquina) == 5:
                    cinquine.append(cinquina)
    return cinquine

# Funzione per calcolare la similarità tra cinquine
def calcola_similarita(cinquine):
    similarita = np.zeros((len(cinquine), len(cinquine)))
    for i in range(len(cinquine)):
        for j in range(i + 1, len(cinquine)):
            sim = 1 - cosine(cinquine[i], cinquine[j])
            similarita[i, j] = sim
            similarita[j, i] = sim
    return similarita

# Funzione per filtrare le cinquine interessanti
def filtra_cinquine_interessanti(cinquine, soglia_similarita):
    similarita = calcola_similarita(cinquine)
    da_tenere = np.ones(len(cinquine), dtype=bool)
 
    for i in range(len(cinquine)):
        if da_tenere[i]:
            for j in range(i + 1, len(cinquine)):
                if similarita[i, j] > soglia_similarita:
                    da_tenere[j] = False
 
    cinquine_filtrate = [cinquine[i] for i in range(len(cinquine)) if da_tenere[i]]
    return cinquine_filtrate

# Funzione per trasformare i numeri di una cinquina
def trasforma_cinquina(cinquina, griglia, x, y):
    cinquina_trasformata = []
    for numero in cinquina:
        indice_riga = griglia[y - 1][numero - 1] - 1
        numero_trasformato = griglia[indice_riga][x - 1]
        cinquina_trasformata.append(numero_trasformato)
    return cinquina_trasformata

# Funzione per verificare se una cinquina trasformata è "interessante"
def cinquina_interessante(cinquina_trasformata, estrazione_verifica, soglia_match):
    match = sum(numero in estrazione_verifica for numero in cinquina_trasformata)
    return match >= soglia_match

# Processo principale
def main(nome_file_cinquine, estrazione_verifica, soglia_match):
    # Creazione della griglia
    griglia = crea_griglia()
 
    # Stampa della griglia (opzionale)
    print("Griglia iniziale:")
    for riga in griglia:
        print(' '.join(f"{num:2d}" for num in riga))
 
    # Leggi le cinquine dal file
    cinquine_base = leggi_cinquine_da_file(nome_file_cinquine)
 
    # Determina dinamicamente le cinquine interessanti da filtrare
    cinquine_interessanti_da_filtrare = [cinquina for cinquina in cinquine_base if sum(cinquina) > 200]
 
    # Calcola la similarità tra le cinquine
    cinquine_interessanti_filtrate = filtra_cinquine_interessanti(cinquine_base, 0.8)
 
    # Lista per contenere i risultati delle cinquine trasformate per ogni cella della griglia
    risultati_cinquine_trasformate = [[[] for _ in range(90)] for _ in range(90)]
 
    # Itera su tutte le celle della griglia e trasforma le cinquine
    for y in range(1, 91):
        for x in range(1, 91):
            risultati_cinquine_trasformate[y - 1][x - 1] = [trasforma_cinquina(cinquina, griglia, x, y) for cinquina in cinquine_base]
 
    # Lista per contenere le cinquine interessanti
    cinquine_interessanti = []
 
    # Itera sui risultati delle cinquine trasformate per trovare quelle interessanti
    for y in range(90):
        for x in range(90):
            for cinquina_trasformata in risultati_cinquine_trasformate[y][x]:
                if cinquina_interessante(cinquina_trasformata, estrazione_verifica, soglia_match):
                    cinquine_interessanti.append((cinquina_trasformata, (x + 1, y + 1)))  # Aggiungi la cinquina e le coordinate
 
    # Stampa delle cinquine interessanti trovate
    print("\nCinquine interessanti trovate:")
    for cinquina, coord in cinquine_interessanti:
        print(f"Cinquina: {cinquina}, Trovata alla cella: {coord}")
 
    # Definiamo una soglia per il grado di match
    soglia_match_filtraggio = 250
 
    # Filtriamo le cinquine interessanti in base alla soglia di match
    cinquine_filtrate = [(cinquina, posizione) for cinquina, posizione in cinquine_interessanti if sum(cinquina) > soglia_match_filtraggio]
 
    # Stampiamo le cinquine filtrate
    print("\nCinquine filtrate per soglia di match:")
    for cinquina, posizione in cinquine_filtrate:
        print(f"Cinquina: {cinquina}, Trovata alla cella: {posizione}")

# Esecuzione dello script
if __name__ == "__main__":
    nome_file_cinquine = 'cinquine.txt'  # Sostituisci con il nome effettivo del tuo file di cinquine
    estrazione_verifica = [23, 76, 44, 33, 13]  # Esempio di estrazione di verifica
    soglia_match = 3  # Esempio di soglia minima di match per considerare una cinquina interessante
    main(nome_file_cinquine, estrazione_verifica, soglia_match)
 
Ultima modifica:
Claudio a noi non interessa se ha un senso ma solo avere delle previsioni affidabili.
Tu avrai ragione solo se vai avanti a tentativi e la fortuna è dalla tua, ma se non viè una base di logica nel processo, manco il caos ti può dare soluzioni.
Se testando arrivi ad una soluzione, ben venga.
 
Bravo! tutto quello che serve sta nell'estrazione di calcolo.
Lasciate perdere gli esempi che ho inviato non li potete replicare era meglio se non li mettevo è troppo presto per quel tipo di schema.
Il Debug fa fatto per terno testate ruota- ruota esempio:
bari-bari
Cagliari-Cagliari e cosi via ... dovete trovare una sola cinquina che deve fare ambo a ruota a colpo.
Nella giocata viene preso tutto il compartimento ma deve essere UNA SOLA CINQUINA.
Avete le matrici random qualsiasi ottimizzazione fate non cambia nulla, dovete imparare a prendere la cinquina giusta,tipo la prima che hai
scelto e ha fatto il suo punteggio.
Bene questa sopra può essere una tecnica di ricerca
Domanda:
Si può creare uno schema matematico con le matrici e gli ordinamenti senza nessun tipo di filtroriduzione basato unicamente nelle trasformazioni?
Per matematico intendo che se nel Debug dell'estrazione di calcolo la trasformata ti ritorna la cinquina di entrata, una casella vicina deve dare la quaterna e altre vicine i terni.
Secondo voi è fattibile sta cosa oppure è una castroneria?
Tu che hai tanta esperienza di matrici e di ottimizzazioni delle stesse, cosa ne pensi di questa seconda domanda?
 
Codice:
import random
import re
import numpy as np
from scipy.spatial.distance import cosine
# Funzione per creare una griglia 90x90 senza duplicati su righe e colonne
def crea_griglia():
    numeri = list(range(1, 91))
    griglia = []
    for _ in range(90):
        riga = random.sample(numeri, 90)
        griglia.append(riga)
    return griglia
Se non conosci i linguaggi che usi devi almeno sapere come leggere i suoi output altrimenti ti fai trascinare in errori di cui non sai neanche l'esistenza.
Alcuni amici mi dicono di non fidarsi cecamente, la loro utilizzazione velocizza i progetti, ma non garantisce la correttezza dei processi, e il progettista deve conoscere i linguaggi che usa. ( il pyton in particolare è un linguaggio veloce ma "criptato",,, studialo)
# Funzione per creare una griglia 90x90 senza duplicati su righe e colonne

Prova questo "suo" codice che hai sopra per creare la griglia 90x90, io non ho Pyton, lo ho fatto tradurre in altro linguaggio, se lo ha tradotto correttamente, non ha creato esattamente quello che tu gli hai chiesto.
Salutoni
 
Ultima modifica:
Ciao Redmoon
Rispondo alle due domande ...
Secondo Me sono fattibili ma non con le matrici e ordinamenti che abbiamo Noi che sono random.
Vorrei capire se possibile se le Tue matrici e ordinamenti sono 90X90?
Oppure hanno lunghezze variabili?
oppure usi il doppio ordinamento ? che non so a cosa serve ....ma l'ho visto su un'altro programma che tratta le matrici
Ciao Rosetta
Esatto per avere il controllo della griglia servono matrici e ordinamenti diversi...non random
Gli ordinamenti e le matrici sono 90x90 e come sai non puoi fare nessun tipo di filtraggio.
Il doppio ordinamento non serve a nulla
 
Il controllo della griglia avendo una cinquina in ingresso che deve essere la stessa in uscita posso averlo solo tramite la manipolazione degli ordinamenti e delle matrici non ci sono altri modi perché rimangono le uniche variabili. Quindi lo schema può verificarsi con matrici e ordinamenti random ma proprio per il fatto che sono random non è necessario che rimangano le stesse visto che ogni estrazione è fine a se stessa nello schema .
Si mette mano a ordinamenti e matrici.... e si costruisce lo schema
 
Bene questa sopra può essere una tecnica di ricerca

Tu che hai tanta esperienza di matrici e di ottimizzazioni delle stesse, cosa ne pensi di questa seconda domanda?
Che puoi fare cose che i metodi classici non possono fare,questo per il semplice motivo che hanno bisogno dell'archivio
per formulare previsioni le matrici no per questo motivo lo schema ha preso il nome " Knows the future"
 
Ciao Lorenzo e a tutti gli altri
ho fatto un automatico che genera le matrici e gli ordinamenti, poi trasformo la cinquina di bari dell'estrazione di calcolo in tutti i settori e faccio il debug per cinquina .... quando la trova e a volte fa molti cicli per esempio l'ultima prova ci sono voluti piu di 17000 cicli ho voluto vedere se poi i settori vicini facessero la quaterna e i terni ..... purtroppo su 10 prove neanche una quaterna e pochissimi terni fuori ruota ..... probabilmente non e' questo il modo per trovare la cinquina.
Rosetta è vietato barare!!!
Alla fine hai visto che nei settori vicini c'è solo il deserto.
 
ciao a tutti, premettendo che l'argomento mi affascina ma non riesco ad entrarvi... Ho provato ad avvalermi della mia protesi.. AI 😅 e con lui (Copilot) forse qualcosina sono riuscito a ricreare. Solo non riesco nemmeno a spiegargli bene cosa dovrebbe fare... Ve la posto chiedendovi se cortesemente qualcuno di voi esperto dell'argomento mi possa dare qualche dritta su cosa chiedere ulteriormente al riguardo a Copilot.

Codice:
# Inserisci i 5 numeri dell'estrazione
numeri_estrazione = [10, 25, 37, 42, 55]

# Creazione di una griglia 90x90
num_righe = 90
num_colonne = 90

# Inizializza la griglia con valori vuoti (ad esempio, 0)
griglia = [[' ' for _ in range(num_colonne)] for _ in range(num_righe)]

# Imposta i valori delle celle corrispondenti ai numeri dell'estrazione
for numero in numeri_estrazione:
    griglia[numero - 1][numero - 1] = 'X'  # Imposta 'X' per indicare la presenza del numero

# Stampa la griglia
for riga in griglia:
    print(' '.join(riga))


In pratica per adesso questo codice python ricrea una griglia 90x90 con vari ordinamenti dislocando qualsiasi formazione di classe 5 di estratti secondo i relativi posizionamenti e sostituendoli con delle X per rendere maggiormente pratica la visualizzazione. In tal senso si occupa anche di rendere invisibile tutte le altre colonne e righe comunque presenti.

Va da se che se io ho Copilot possiamo aiutarvi in qualche modo per cercare di potenziare ulteriormente la vostra ricerca esplorandone altri punti di vista basta chiedere e ci proveremo... secondo la famosa formuletta "win to win".


Grazie anticipate e complimenti per i vostri studi e traguardi.
Non voglio scoraggiarti ma la IA qui non può aiutarti.
 
Ciao Lorenzo e a tutti gli altri
ho fatto un automatico che genera le matrici e gli ordinamenti, poi trasformo la cinquina di bari dell'estrazione di calcolo in tutti i settori e faccio il debug per cinquina .... quando la trova e a volte fa molti cicli per esempio l'ultima prova ci sono voluti piu di 17000 cicli ho voluto vedere se poi i settori vicini facessero la quaterna e i terni ..... purtroppo su 10 prove neanche una quaterna e pochissimi terni fuori ruota ..... probabilmente non e' questo il modo per trovare la cinquina.
Ciao Rosetta io la cosa che ho notato che provando con Matrici e Ordini random e poi spogliando per ambo al primo colpo ottengo questo:
1719704860237.png

1719704922235.png

1719704958834.png
Come puoi notare molti settori si uniscono a gruppi lasciando poi dei vuoti abbastanza ampi questi 3 esempi sono relativi alla data del 02 Aprile 2024 con spoglio al primo colpo in data 04 Aprile 2024 ruote in ordine Bari Cagliari Firenze. Secondo me esiste un modo per creare questo schema creando le matrici in funzione degli ordinamenti. Sto cercando di capire come analizzando questi 3 esempi.
 
Buongiorno,
mi sono defilato dalla discussione perchè dopo aver provato le cd matrici in tutte le salse non mi va di rompermi la testa con griglie di vario genere. Tanto premesso comunque seguo il 3D e sono incuriosito dal ruolo ricoperto da redmoon............
Hai già una soluzione?
Poi, si usa solo un'estrazione ma su quanti colpi si gioca e su quali ruote? Che nesso casuale c'è usare l'estrazione di Bari, ad esempio. come generatrice della griglia e poi andare a ricercare le vincite su altre ruote
Trovo più logico invece il ragionamento di Rg05 che esegue una ricerca rnd per trovare le matrici che soddisfino la cd "condizione".
Se la condizione è vincente..........................
 
Ultima modifica:

Ultima estrazione Lotto

  • Estrazione del lotto
    giovedì 21 novembre 2024
    Bari
    06
    79
    30
    52
    15
    Cagliari
    03
    85
    61
    44
    25
    Firenze
    30
    76
    84
    34
    13
    Genova
    39
    63
    06
    50
    81
    Milano
    01
    34
    78
    86
    36
    Napoli
    63
    51
    82
    61
    07
    Palermo
    11
    66
    09
    59
    34
    Roma
    15
    26
    32
    38
    89
    Torino
    38
    43
    77
    33
    42
    Venezia
    76
    60
    78
    47
    31
    Nazionale
    85
    83
    79
    12
    51
    Estrazione Simbolotto
    Torino
    31
    38
    42
    06
    10

Ultimi Messaggi

Indietro
Alto