Newsgroup: it.comp.lang.visual-basic
Titolo: [?2] Superenalotto: sviluppo delle colonne ridotte

Per la garanzia 5 devono cambiare almeno 2 numeri;
Ho provato con lo STEP 2:
For n1 = 1 To N - 5     STEP 2
    For n2 = n1 + 1 To N - 4    STEP 2
        For n3 = n2 + 1 To N - 3    STEP 2
            For n4 = n3 + 1 To N - 2    STEP 2
                For n5 = n4 + 1 To N - 1    STEP 2
                    For n6 = n5 + 1 To N    STEP 2
                .........
            .......
ma senza esito positivo. Ho fatto anche altri tentativi che però
evidentemente non corrispondono a quello giusto.
Dato che l'algoritmo dello sviluppo integrale riesce a ricavare
correttamente le colonne (integrali), credo ancora che la soluzione la si
possa ricavare modificandolo opportunamente,  ma come però?! Forse sarà pure
semplice, ma purtroppo finora non ci sono ancora riuscito.
In sintesi: qual è la variazione che si deve fare rispetto al codice dello
sviluppo
integrale, per cambiare x(2,3,4) numeri e ottenere così le rid. alla
n-x(2,3,4)?
Dai!!! Fatemi vedere che i programmers vb sono sempre grandi!
Grazie a tutti.
Max.
Allego msg di Stefano:
Ho fatto un piccolo programma per sviluppare integralmente un sistema di N
numeri contenuti in una variabile chiamata NumeriInGioco (1 to N).
For n1 = 1 To N - 5
    For n2 = n1 + 1 To N - 4
        For n3 = n2 + 1 To N - 3
            For n4 = n3 + 1 To N - 2
                For n5 = n4 + 1 To N - 1
                    For n6 = n5 + 1 To N
                        Combinazione=NumeriInGioco(n1) & " " & _
                            NumeriInGioco(n2) & " " & NumeriInGioco(n3) & "
" & _
                            NumeriInGioco(n4) & " " & NumeriInGioco(n5) & "
" & _
                            NumeriInGioco(n6)
                        List1.additem Combinazione 'questo per inserire le
combinazioni   in una list.
                    Next
                Next
            Next
        Next
    Next
Next
Ad ogni ciclo la variabile "Combinazione" contiene una stringa che è una
combinazione del
sistema integrale. Questo sistema è il cosiddetto "a garanzia di 6" (detta
anche n).
Giocando 8 numeri (da 1 a 8) viene fuori:
1 2 3 4 5 6
1 2 3 4 5 7
1 2 3 4 5 8
...
2 3 5 6 7 8
2 4 5 6 7 8
3 4 5 6 7 8
Di solito nei programmi si possono calcolare 4 tipi di garanzie: 6,5,4,3 (in
gergo n,n-1,n-2,n-3). Per la garanzia del 6, come hai visto, basta che cambi
un numero. Per la garanzia 5 devono cambiare almeno 2 numeri; per la
garanzia del 4 devono cambiare almeno 3 numeri e per quella del 3 almeno 4.
Per "cambiare" intendo dire che la combinazione calcolata deve avere tot
numeri diversi da una qualsiasi altra combinazione già calcolata.
...........
..........
Stefano

dunque....
per la garanzia del 3,4,5,6 devi fare un controllo a ritroso ogni qual volta
componi una nuova colonna. Ti faccio un esempio
il sistema sviluppa come prima colonna
1 2 3 4 5 6
dalla seconda colonna in poi che il sistema sviluppa devi fare un controllo
a ritroso scartando la colonna attuale se i numeri che coincidono sono
1,2,3,4,5 in base alla garanzia richiesta.
Mettiamo che chiedi la garanzia del 4 (allora lo scarto deve essere di 3
punti)... quindi
lo sviluppo salterà un bel pò di colonne fino a quando non incontra la
1 2 3 7 8 9
ecc...
raga io sviluppo software per il Lotto da qualche anno.... ne sto ultimando
proprio uno adesso e sarà pronto per Pasqua, se vi va di darmi una mano con
la stampa delle schede ricambierò volentieri... altrimenti sarò costretto ad
inventarmi la stampa delle schedine e giuro non ho un attimo di tempo. In
cambio del vostro aiuto vi inserisco nella lista dei collaboratori così
magari avrete anche l'opportunità di farvi conoscere a livello nazionale per
la programmazione di software dedicato ai giochi e in più vi do qualche
numero buono per vincere ;-))
ciao Davide

...


hai mai provato ad usare l'oggetto printer?
setti l'unità di misura in millimetri
printer.scalemode=        (6 o 7, adesso non ricordo, uno è centimetri,
l'altro è millimetri)
poi ti sposti grazie a currentx e currenty
printer.currentx=        (il punto che ti interessa)
printer.currenty=        (il punto che ti interessa)
poi se vuoi stampi una X usando il carattere curier (devi fare delle prove
sulla grandezza del carattere, prova con un 6)
printer.font=        (il carattere curier)
alla fine se hai finito le schedine usi
printer.enddoc
se ne devi stamparne altre
printer.newdoc
e rinizi la stampa(magari con un ciclo)
spero di esserti stato utile
...GooD LooK...
EffEPi SySteM
EffEPi...@iol.it
Fabrizio Parrella
 - VB6 -
UIN:21371755

Ciao a tutti.
Mi attacco al thread per discutere, dal punto di vista "algoritmico", un
altro problema legato al superenalotto e giochi simili.
La classica riduzione n-qualcosa funziona così: si gioca un sottoinsieme del
sistema integrale e, nel caso si fa 6, viene garantita matematicamente una
vincita di categoria inferiore. Ad es. giocando a n-2 devo fare 6 nel
sistema integrale per esser sicuro di avere almeno un 6-2 = 4 nelle mie
colonne giocate.
Fin qui non ci piove. Adesso vorrei fare una cosa diversa.
Supponiamo di avere N numeri in gioco. Per fare un esempio pratico
supponiamo N=25.
Ora: io voglio garantiti i 3 punti se faccio 3 punti nel sistema integrale
di 25 numeri, e naturalmente voglio giocare il minor numero di colonne
possibili.
Da questi 25 numeri mi genero tutte le combinazioni di 25 elementi presi a 6
a 6, con degli opportuni cicli for innestati (io l'ho fatto in C++ ma questo
poco importa ai fini dell'algoritmo).
Quindi C(25,6) =177.100 colonne (integrale).
Poi mi genero tutte le possibili terzine estraibili dai 25 numeri.
C(25,3) = 2.300 gruppi da 3.
Per avere garantiti i 3 punti facendone 3 sull'integrale, devo giocare tutte
le 2300 terzine. Ma al Superenalotto si giocano 6 numeri, quindi dovrei
raggruppare opportunamente queste terzine in gruppi da 6.
Una sestina può rappresentare al massimo 20 terzine: C(6,3) = 20.
Quindi, io mi aspetterei di poter raggruppare le terzine, sostituendo ogni
gruppo da 20 con una sestina che lo rappresenta, ottenendo: 2300 / 20 = 115
colonne da giocare.
Ricapitolando:
Prendo 25 numeri, genero tutti i gruppi da 3 possibili, li raggruppo in
sestine (1 sestina = 20 terzine) e mi gioco 115 colonne per aver garantito
il 3 con 3 punti su 25.
La DOMANDA è questa: dall'integrale di 177.100 colonne, quali sono queste
115 che mi rappresentano il "sistema minimo" per fare 3 con 3 punti?
Ho provato diversi metodi, con poco sucesso, ad es.: prendo e metto da parte
una sestina dalle 177.100 integrale, mi elimino le 20 terzine generabili da
questa colonna, poi prendo la successiva colonna che copre altre 20 terzine
tra quelle rimaste (che sono 2300 - 20 = 2280), e continuo così fino alla
copertura totale delle terzine in gioco... però arrivo ad un punto in cui
rimangono terzine non raggruppabili in gruppi da 20, quindi non riesco ad
avere il sistema minimo di 115 colonne.
Idee?
--
Ciao, AntoGal
*************************************************
Home Page (area programmatori di VolFtp)
http://volftp.tin.it/italiani/galletta/
per scaricare un gioco di DAMA ITALIANA
*************************************************

beh io scrivo da qualche anno su "la settimana del lotto" quindi sono
abbastanza conosciuto tramite il giornale.. adesso ho anche un sito internet
da un paio di mesi...i progr si vendono tramite il giornale o in genere si
contattano i clienti diecondo loro che è disponibile
l'aggiornamento...spedisco i progr in contrassegno.... le etichette le
stamperò con la stampante, però il mio prossimo prog sarà su Cd quindi credo
che acquisterò il CdLabel
ciao Davide
http://www.dreamlink.net/davidegreco

e rinizi la stampa(magari con un ciclo)
si ok....sul carattere sulla grandezza e su NewDoc EndPrinter non ci sono
problemi... il difficile sta nel centrare esattamente le caselle da
contrassegnare


si tratta dello sviluppo detto 'ortogonale' che è il meglio che ci si possa
augurare, Purtroppo non esiste nessun algoritmo in grado di soddisfare al
100% qualsiasi tipo di sistema a qualunque garanzia.
O meglio se prendi 15 numeri e li sviluppi in terzine a garanzia dell'ambo
ottieni 35 bollette che rappresentano lo sviluppo integrale (e ortogonale)
del sistema. Infatti indovinando 2 numeri hai sempre l'ambo.
Se invece consideri 16 numeri già lo sviluppo ortogonale diventa impossibile
!!
Per cui lo sviluppo ortogonale è applicabile solo a pochi tipi di sistemi.
Di quel sistema di 115 colonne per il superenalotto se n'era già discusso su
it.hobby.lotto ma senza giungere a nessuna conclusione perchè non esiste (o
almeno io non sono riuscito a trovare) un algoritmo che permetta di ordinare
le colonne in modo da ottenere il minor numero di bollette possibile.
Se poi consideri che c'è ancora gente che modifica uno sviluppo manualmente
per risparmiare colonne allora ti rendi conto che l'argomento è proprio off
limit
ciao Davide

...



si in effetti come algoritmo diventa un po lentuccio.... ma non proprio con
i 30 numeri...
Per risolvere il problema si dovrebbe poter scartare all'istante le
combinazioni ripetute quindi senza controlli a ritroso. Per fare una cosa
del genere mi viene in mente per adesso solo una possibilità:
se il sistema è a garanzia di Ambo_ verificare se anche solo uno degli ambi
che si formano con la bolletta da controllare siano già presenti in qualche
bolletta,
lo stesso discorso anche per i sistemi a garanzia di Terno, ecc
adesso però risolviamo un altro problema...
con 90 numeri si formano
4.005 ambi
117.000 (circa) terni
2.500.000 (circa) quaterne
49.000.000 (circa) cinquine
ecc
finchè si tratta di controllare che gli ambi i terni e volendo anche le
quaterne dell'ultima bolletta siano già stati sviluppati è ok... ma come si
fa a gestire 49 milioni di cinquine ???
quindi presumibilmente anche questa strada non è conveniente !!
resta quindi da vedere come evitare il controllo a ritroso (che è lento solo
quando si ha a che fare con sviluppi molto grandi). Se consideriamo che
generalmente l'utente non mette in gioco più di qualche centinaio di colonne
allora il problema è risolto... infatti basta dare l'opportunità di
interrompere lo sviluppo quando il numero di bollette va oltre le intenzioni
dell'utente.
senza però aggirare l'ostacolo..... vediamo come risolvere il problema del
controllo delle combinazioni già presenti nello sviluppo.... fatevi avanti
;-))
ciao Davide