Come estendere il limite di sviluppo della function GetCombSviluppo(aColSviluppo)?

[lotto_tom75]

Do While GetCombSviluppo(aColSviluppo)

Attualmente la funzione di sviluppo integrale consente classi di non + di 20 elementi.
Ora... indipendentemente dall'impossibiità di generare tutte le combinazioni integrali superiori a questa classe partendo dai 90 numeri avrei bisogno se fosse possibile di estendere comunque il limite di sviluppo integrale "teorico" da 20 a 80 per condurre degli esperimenti di sviluppi incompleti ma di tipo integrale e di classe maggiore di 20... E' possibile in qualche modo? Anche ricorrendo a modifiche vbs?

Grazie a tutti/e a cominciare dal Maestro

 

[LuigiB]

Ciao come ho detto anche altre volte uno sviluppo di una serie numerica si può ottenere molto banalmente con dei cicli for nidificati.. sarà brutto non sarà versatile ma funzionerebbe.

 

[Edoardo_95]

Attraverso quale variabile nidifico i cicli for next? E sopratutto li nidifico all'interno del ciclo do while?

 

[LuigiB]

I cicli for sono una cosa i cicli do un altra...ti serve una variabile per ogni ciclo for se devi sviluppare in ventina ad esempio ti servirebbero 20 variabili

 

[Edoardo_95]

Grazie

 

[Edoardo_95]

Caro maestro LuigiB ho provato migliaia di volte a nidificare i cicli for , ma non ho capito come devo fare ne quali variabili creare. Inizio a sospettare di aver un quoziente intellettivo pari a quello di un criceto . Potresti darmi qualche dritta? Sempre se non ti è di disturbo

 

[LuigiB]

ciao , ecco l'esempio piu semplice in questo caso sviluppa in terni tutti i 90 numeri

Option Explicit
Sub Main

  Dim k1 , k2 ,k3
  Dim i
  ReDim aColonna(3)

  For k1 = 1 To 88
     For k2 = k1+1 To 89
        For k3 = k2+1 To 90
           aColonna(1) = k1
           aColonna(2) = k2
           aColonna(3) = k3

           i = i + 1
           Messaggio i        
           Call Scrivi (StringaNumeri (aColonna))
        Next

     Next

  Next

End Sub

quest'altro esempio un po' piu complicato sviluppa i numeri del pronostico sempre in terni , 9 numeri in qquesto caso

Option Explicit
Sub Main

  Dim k1 , k2 ,k3
  Dim i
  ReDim aColonna(3)
  Dim aPronostico

  aPronostico = Array (0 ,1,2,3,4,5,6,7,8,9)

  For k1 = 1 To UBound(aPronostico)-2
     For k2 = k1+1 To UBound(aPronostico)-1
        For k3 = k2+1 To UBound(aPronostico)
           aColonna(1) = aPronostico(k1)
           aColonna(2) = aPronostico(k2)
           aColonna(3) = aPronostico(k3)


           i = i + 1
           Messaggio i         
           Call Scrivi (StringaNumeri (aColonna))
        Next

     Next

  Next

End Sub

 

[salvo50]

Ciao a Tutti.


A tempo perso, qualcosina l'ho imparato

Ho cambiato i numeri nell'array e alla fine ho messo quanti terni si sono formati

Option Explicit
Sub Main
   Dim k1,k2,k3
   Dim i
   ReDim aColonna(3)
   Dim aPronostico
   aPronostico = Array(0,15,19,42,47,65,66,72,78,89)
   For k1 = 1 To UBound(aPronostico) - 2
      For k2 = k1 + 1 To UBound(aPronostico) - 1
         For k3 = k2 + 1 To UBound(aPronostico)
            aColonna(1) = aPronostico(k1)
            aColonna(2) = aPronostico(k2)
            aColonna(3) = aPronostico(k3)
            i = i + 1
            Messaggio i
            Call Scrivi(StringaNumeri(aColonna))
         Next
      Next
   Next
   Call Scrivi("Con " &(UBound(aPronostico)) & " numeri si formano " &(Format2(i)) & " Terni")
End Sub

 

[lotto_tom75]

Salutando e ringraziando tutti gli intervenuti a cominciare dal Maestro Luigi che ringrazio di cuore e che ancora una volta ci ha illuminato in modo a dir poco esemplare provo a riportare una mia leggera modifica del suo script "indicatore" x sviluppo in classe integrale 4 di 10 numeri desiderati per vedere se ho capito bene come poter ricreare qualsiasi sviluppo di classe integrale passo passo...

Option Explicit
Sub Main
'esempio di costruzione integrale in classe 4 per gruppo desiderato.
   Dim k1,k2,k3,k4  '<- qui andranno aggiunti tanti k quanto è il valore di classe desiderato... (es. k89)
   Dim i
   ReDim aColonna(4) ' <- Qui va messo il valore di classe desiderato
   Dim aPronostico
   aPronostico = Array(0,1,2,3,4,5,6,7,8,9,10) ' <- qui dopo lo 0 vanno messi i numeri desiderati da sviluppare in modo integrale

   For k1 = 1 To UBound(aPronostico) - 3
      For k2 = k1 + 1 To UBound(aPronostico) - 2
         For k3 = k2 + 1 To UBound(aPronostico) - 1
           For k4 = k3 + 1 To UBound(aPronostico) '<- qui andranno aggiunte tante righe "analoghe" quanto è il valore di classe 'desiderato... (es. For k89...)
            aColonna(1) = aPronostico(k1)
            aColonna(2) = aPronostico(k2)
            aColonna(3) = aPronostico(k3)
            aColonna(4) = aPronostico(k4) '<- qui andrà aggiunto righe analoghe progressive fino ad avere  'aColonna(numerodiclassedesiderato)
            i = i + 1
            Messaggio i
            Call Scrivi(StringaNumeri(aColonna))
         Next
      Next
   Next
   Next
'<- qui andranno aggiunti tanti Next quanto è il numero di classe di sviluppo desiderato (es. extreme: 89 :) )

   Call Scrivi("Con " &(UBound(aPronostico)) & " numeri si formano " &(Format2(i)) & " Quaterne") '<- qui si mette il nome di classe 'desiderato es. decine, dodicine ecc...
End Sub

Di nuovo un salutissimo a tutti/e

 

[LuigiB]

Ciao Tom hai capito perfettamente..

 

[lotto_tom75]

Ciao Tom hai capito perfettamente..

Grazie mille per la conferma Luigi

 

[LuigiB]

Eh... non fare il modesto ;-) .. mi sembra che tu sappia fare ben di più

 

[LuigiB]

come puoi notare Tom si tratta di un sistema semplice ma anche molto rigido e quindi poco versatile..
l'ideale sarebbe fare una routine che sviluppi qualsiasi classe senza cicli for la faccenda però era più complicata ad ogni modo i cicli for anche se hanno i loro gravi difetti di rigidità sviluppano in modo leggermente piu veloce rispetto ad un'ipotetica routine che avesse un approccio diverso.

 

[Beppignello]

ciao


vorrei porre una domanda

ma perché in modo random si può sviluppare anche con classi grandi, e per milioni di combinazioni, mentre per con

Do While GetCombSviluppo(aColSviluppo) no?

è vero che acolsviluppo contiene tutte le colonne integrali e quindi è ovvio che ci sia un problema
di memoria insufficente, ma cosa vieta di caricare parzialmente l'integrale, che ne so per fare un esempio

da 1 ad un milione di colonne alla volta?
dalla un milione e 1 colonna a due milioni
etc.…

fino a completare l'integrale, qualora ci sia la necessita di farlo?​

 

[LuigiB]

ciao Bep ,non è assolutamente un problema di memoria .bensì è un problema di tempo macchina.

Con la funzione GetCombSviluppo a differenza di SviluppoIntegrale le combinazioni vengono sviluppate una alla volta su richiesta della routine chiamante proprio lanciando la suddetta funzione GetCombSviluppo

Le colonne quindi vengono fornite in modo ordinato e senza memorizzarle tu ad esempio durante lo sviluppo ma anche dopo non puoi mica richiedergli la colonna numero 1 se ormai l'ha gia sviluppata .. eventualmente era lo script a dover memorizzare le colonne non certo la funzione che le sviluppa.

Detto questo a livello teorico la funzione avrebbe potuto benissimo sviluppare colonne di qualsiasi classe però a livello pratico era impossibile per il tempo che sarebbe occorso e dato che la funzione come detto fornisce le colonne in modo ordinato sarebbe successo che solo la prima parte dello sviluppo si sarebbe riuscita ad ottenere e anzi aumentando la classe piu si riduceva il rapporto tra colonne sviluppate e colonne integrali.. prova ad immaginare il risultato della divisione tra le ipotetiche colonne che riesci a sviluppare fossero pure 50 milioni diviso il numero di colonne integrali di uno sviluppo 90 numeri classe 30 ... chissa quanti 0 ci saranno prima di vedere un numero... e quindi pensa che piccolissima inutile parte dello sviluppo si sarebeb potuta usare.. da qui il limite pure troppo alto
di classe 20

le combinazioni casuali proprio perche casuali non sono soggette ad uno sviluppo ordinato e percio ogni volta che se ne chiede una si va a coprire idealmente una posizione qualsiasi che spazia da 1 a NumColonneIntegrali , nell'altro modo (quello integrale ) si sarebbero coperte solo e sempre le prime colonne che uno sarebbe riouscito a sviluppare.
Esempio pratico in uno sviluppo dei 90 numeri in classe 30 prima di vedere il 30 in prima posizione
si sarebbe fuso il povero pc .. mica abbiamo i sistemi di Nikor ...

ciao

 

[Edoardo_95]

Grazie infinite a tutti quanti ma sopratutto a LuigiB, che nonostante i suoi impegni ha avuto il tempo di sopportarmi ahahaha

 

[i legend]

Ciao a tutti

ora capisco perché quando realizziamo qualche script mettiamo controlli e limitazioni e ci preoccupiamo dei tempi di sviluppo. ...
qualcosina l abbiamo imparata.
ciao prof
ciao a tutti

 

[Beppignello]

i tempi di elaborazione per classe grandi di combinazioni è normale che sia molto lungo, ma ciò non ha fermato i sistemisti
che hanno saputo spaccare l'integrale in sotto elaborazioni o spaccando l'integrale a blocchi, eseguibili anche in tempi
diversi.

oggi elaboro 1 milione a 10 milioni di colonne
domani ne elaboro altrettante
e a seguire fino alla fine dell'integrale completo. Vedi Jolla Primati

tantè che per il MillionDay
non si possono giocare cinque schedine uguali (o cinque cinquine uguali), perché in ricevitoria ti segnala al momento
della validazione della tua schedina, che non è più possibile giocare questa combinazione.

il programma di validazione in pochi secondi, elabora e controlla i 4Milioni di colonne possibili e segnala questi limiti.
ovvio che loro lo fanno per non pagare più di 5 vincitori in un unico concorso. é un limite autoimposto, o un limite nei pagamenti.

 

[LuigiB]

ciao Bep , fai una supposizione errata è vero che la macchinetta controlla la colonna ma non lo fa certo elaborando tutte le 4 milioni in qualche secondo .. ...semplicemente ogni volta che uno va a giocare la macchinetta registra la colonna in un database centralizzato e gli basta interrogare il database per sapere se la tale colonna è stata giocata un po come quando i signori di equitalia digitano il codicefiscale di mario rossi sul loro sistema informatico e la posizione del contribuente appare in un secondo anche se gli italiani sono 50 milioni ...detto questo per necessita particolari bisogna scriversi il proprio codice

 

[i legend]

Ciao ,
mi hai anticipato nella risposta.
essendo i numeri ordinati anche inserendosi in un array in un array integrale sarebbe veloce verificare
Se una formazione è presente o quante volte è stata caricata.
ciao a tutti