EXCEL E DINTORNI

[Antonio Pagano]

Baciccia buongiorno mi accodo alla richiesta di Pandit. Scusami se rompo anchio. grazie​

 

[Baciccia4251]

Gentile e disponibile come pochi, vedi se è possibile nel ragionevole e grazie...
sei forte

Come sospettavo i tempi di ricerca sono impossibili da gestire col VBA.
Ho chiesto alla AI: la macro sta lavorando e immagino che saranno necessari tempi biblici. Visto che col VBA non si riesce ad avere in tempi ragionevoli un qualche risultato. Che linguaggio si potrebbe utilizzare?
Questa la sua risposta:

Per questo tipo di analisi, che richiede calcoli intensivi, i linguaggi più adatti sarebbero:

1. Python

• Vantaggi:
  • Librerie specializzate come NumPy e Pandas per gestione dati
  • Multiprocessing per sfruttare tutti i core del CPU
  • Ottimo per manipolazione di dati e calcoli matriciali
  • Può leggere direttamente file Excel
• Esempio di approccio:
  • Usare Pandas per leggere il file Excel
  • NumPy per i calcoli vettoriali
  • Multiprocessing per parallelizzare l'analisi dei terni

1. C++

• Vantaggi:
  • Prestazioni molto elevate
  • Ottima gestione della memoria
  • Possibilità di multithreading
• Svantaggio: richiede più tempo per lo sviluppo

1. Rust

• Vantaggi:
  • Prestazioni paragonabili a C++
  • Sicurezza della memoria garantita dal compilatore
  • Eccellente supporto per la concorrenza
• Svantaggio: curva di apprendimento ripida

Tra questi, Python sarebbe probabilmente la scelta migliore per il tuo caso perché:

1. Facile da imparare e usare
2. Ottimo per prototipazione veloce
3. Ampia disponibilità di librerie per l'analisi dei dati
4. Buon compromesso tra velocità di sviluppo e prestazioni

Vuoi che ti mostri un esempio di come strutturare il codice in Python?

Al mio SI ha risposto con questo listato:
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
import pandas as pd
import numpy as np
from datetime import datetime
from itertools import combinations
from multiprocessing import Pool, cpu_count
import time

def load_data(file_path, ruota):
"""Carica i dati della ruota specificata dal file Excel."""
# Mappa delle colonne per ogni ruota
ruote_cols = {
'Bari': ['D', 'E', 'F', 'G', 'H'],
'Cagliari': ['I', 'J', 'K', 'L', 'M'],
'Firenze': ['N', 'O', 'P', 'Q', 'R'],
'Genova': ['S', 'T', 'U', 'V', 'W'],
'Milano': ['X', 'Y', 'Z', 'AA', 'AB'],
'Napoli': ['AC', 'AD', 'AE', 'AF', 'AG'],
'Palermo': ['AH', 'AI', 'AJ', 'AK', 'AL'],
'Roma': ['AM', 'AN', 'AO', 'AP', 'AQ'],
'Torino': ['AR', 'AS', 'AT', 'AU', 'AV'],
'Venezia': ['AW', 'AX', 'AY', 'AZ', 'BA']
}

# Leggi solo le colonne necessarie
cols_to_read = ['C'] + ruote_cols[ruota]
df = pd.read_excel(file_path, usecols=cols_to_read, skiprows=7)

# Rinomina le colonne
df.columns = ['Data'] + [f'N{i+1}' for i in range(5)]
return df

def analizza_terno(args):
"""Analizza un singolo terno."""
terno, numeri_estrazione = args
ultima_estrazione = None

# Converti il terno in set per confronto più veloce
terno_set = set(terno)

# Cerca l'ultima estrazione del terno
for idx, numeri in enumerate(numeri_estrazione):
if len(terno_set.intersection(set(numeri))) == 3:
ultima_estrazione = idx
break

return {
'terno': terno,
'ultima_estrazione': ultima_estrazione,
'ritardo': len(numeri_estrazione) if ultima_estrazione is None else ultima_estrazione
}

def analizza_ruota(file_path, ruota, min_ritardo=6000):
"""Analizza tutti i terni per una ruota specifica."""
print(f"Caricamento dati per la ruota {ruota}...")
df = load_data(file_path, ruota)

# Prepara i dati per l'analisi
numeri_estrazione = df.iloc[:, 1:].values.tolist()
numeri_estrazione.reverse() # Inverti per avere le estrazioni più recenti prima

# Genera tutti i possibili terni
print("Generazione terni...")
terni = list(combinations(range(1, 91), 3))

# Prepara gli argomenti per il multiprocessing
args = [(terno, numeri_estrazione) for terno in terni]

# Usa multiprocessing per l'analisi
print(f"Inizio analisi con {cpu_count()} processori...")
start_time = time.time()

with Pool() as pool:
results = pool.map(analizza_terno, args)

# Filtra i risultati per ritardo minimo
risultati_filtrati = [r for r in results if r['ritardo'] >= min_ritardo]

# Ordina per ritardo decrescente
risultati_filtrati.sort(key=lambda x: x['ritardo'], reverse=True)

# Converti i risultati in DataFrame
df_risultati = pd.DataFrame(risultati_filtrati)

# Aggiungi la data dell'ultima estrazione
df_risultati['ultima_data'] = df_risultati['ultima_estrazione'].apply(
lambda x: df.iloc[-(x+1)]['Data'] if x is not None else 'Mai uscito'
)

# Converti i terni in stringhe
df_risultati['terno'] = df_risultati['terno'].apply(lambda x: '-'.join(map(str, x)))

print(f"\nAnalisi completata in {time.time() - start_time:.2f} secondi")
return df_risultati

def salva_risultati(df_risultati, ruota, output_file):
"""Salva i risultati in un nuovo file Excel."""
with pd.ExcelWriter(output_file) as writer:
df_risultati.to_excel(writer, sheet_name='TerniRitardo', index=False)

# Applica formattazione
workbook = writer.book
worksheet = writer.sheets['TerniRitardo']

# Formatta le intestazioni
header_format = workbook.add_format({'bold': True})
for col_num, value in enumerate(df_risultati.columns.values):
worksheet.write(0, col_num, value, header_format)

# Aggiusta larghezza colonne
worksheet.set_column('A', 15)

def main():
# Configurazione
file_path = 'archivio.xlsx' # Aggiusta il percorso del tuo file
output_file = 'risultati_terni.xlsx'

# Lista delle ruote disponibili
ruote = ['Bari', 'Cagliari', 'Firenze', 'Genova', 'Milano',
'Napoli', 'Palermo', 'Roma', 'Torino', 'Venezia']

# Menu di selezione ruota
print("Seleziona la ruota da analizzare:")
for i, ruota in enumerate(ruote, 1):
print(f"{i}. {ruota}")

scelta = int(input("\nInserisci il numero della ruota: ")) - 1
if scelta < 0 or scelta >= len(ruote):
print("Selezione non valida")
return

ruota_scelta = ruote[scelta]

# Esegui l'analisi
df_risultati = analizza_ruota(file_path, ruota_scelta)

# Salva i risultati
salva_risultati(df_risultati, ruota_scelta, output_file)
print(f"\nRisultati salvati in {output_file}")
print(f"Trovati {len(df_risultati)} terni con ritardo >= 6000")

if __name__ == '__main__':
main()

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

Ecco una versione in Python che sfrutta il multiprocessing per velocizzare l'analisi:
In questo caso si riferisce solo ad una ruota, prendendo in considerazione solo i terni aventi ritardo di almeno 6000 estrazioni.
La scelta l'avevo fatta per cercare di velocizzare VBA.

Quello che importa è che per chi conosce il linguaggio Python probabilmente è fattibile creare qualcosa per soddisfare la tua richiesta.
Ho provato a guardare qualcosa di python ma mi perdo dopo due righe...
Se non sbaglio sul forum c'è qualcuno che lo conosce, forse potrebbe dare una mano...
------------------------------------------------------------------------------------------------------------------------------------------------------
Restando al VBA avevo pensato che se si disponesse di tabelle con i ritardi dei terni già calcolati si potrebbe fare qualcosa, ma dove trovare queste tabelle? Basterebbe che riportassero anche solo gli ultimi 500/1000 ritardi.

Se qualcuno ha qualche idea parli ora e continui a farlo fintantoché non abbiamo risolto il problema.

 

[Pandit]

Grazie Baciccia, immaginavo fosse più semplice, neppure io di linguaggi non capisco una cippa, grazie per il tentativo e la Tua grande disponibilità..

 

[claudio8]

Carissimo Pandit
non rompi affatto. Sei sempre il benvenuto. Ci proverò però il VBA forse non è il più indicato per ricerche di questo tipo. Il numero di terni da controllare, su tutte le ruote, è grande e i tempi rischiano di essere biblici. Comunque vedremo.
Un saluto fraterno
Baciccia

Prova a porre la domanda in altri termini.
Quante volte ed in quali estrazione si è verificata la presenza di 1 terno uguale su 3 ruote.

 

[Baciccia4251]

Prova a porre la domanda in altri termini.
Quante volte ed in quali estrazione si è verificata la presenza di 1 terno uguale su 3 ruote.

Ciao Claudio8
Proverò a fare come suggerisci, d'altra parte la AI risponde in maniera corretta solo quando le poni le corrette domande corredate se possibile da quante più informazioni puoi.
Spesso, avendo le idee poco chiare, le pongo le domande nel modo non corretto o facilmente comprensibile.
Di conseguenza le risposte sono non funzionanti oppure, come per i terni, con tempi lunghissimi.
Ti farò sapere
Ciao
Baciccia

 

[trivellatomariotretre33]

Ciao Buongiorno Baciccia
volevo farti notare che il foglio ( RisAnalisi )
non va ce qualcosa che Blocca Lanalisi
Grazie.