Per Joe91 cortesemente...

[Ouroboros]

Buongiorno,
vista la scarsita' di "scriptologi" mi sto avvicinando (dopo le lezioni da Te impartite all' utente Marcolino) a questo mondo.
Sollecitato da un amico ho buttato giu' lo script sottoriportato:

Sub Main()
Dim ruota(2)
Dim nu1(1)
Dim posta(1)
Dim a1,a2,c1,c2,es,a
Dim ce,k,ini,fin,casi
ruota(1) = VE_
ruota(2) = TO_
posta(1) = 1
ce = CInt(InputBox("DI QUANTE ESTRAZIONI VUOI TORNARE INDIETRO? "," ID Estrazione ",156))
k = CInt(InputBox(" Per quanti colpi?"," Colpi di gioco ",13))
ini = EstrazioneFin - ce
fin = EstrazioneFin
For es = ini To fin
Messaggio " elab. estr. [" &(es) & "] del " & DataEstrazione(es)
AvanzamentoElab ini,fin,es
If IndiceMensile(es) = 1 Then
a1 = Estratto(es,TO_,3)'<<--- questo è il 3^estr. di To!!!
a2 = Estratto(es,VE_,3)'<<--- questo è il 3^estr. di Ve!!!
'------------------------------Ambata
c1 = Cadenza(a1)' cadenza a1
c2 = Cadenza(a2)' cadenza a2
nu1(1) = Fuori90(c1 + c2)
casi = casi + 1
Scrivi String(67,"=") & " caso n° " &(casi)
ColoreTesto 1
Scrivi String(77,"-")
ImpostaGiocata es,nu1,ruota,posta,k,0
Gioca es,False,False,1,1
End If
Next
Scrivi String(52,"=") & "",1
ScriviResoconto
End Sub

Guardando l' output mi sono reso conto che c'e' qualcosa che non va:
praticamente in un caso il numero ricercato pur essendo stato estratto non compare (img_01),
nel secondo caso un numero viene rilevato erroneamente (img_02).

Saresti cosi' gentile di dirmi se nello script c'e' qualche istruzione sbagliata o mancante?
Grazie per la cortese risposta.



Uploaded with ImageShack.us



Uploaded with ImageShack.us

 

[Ouroboros]

...molto gentile!!!
Grazie!!!
Ciao.

 

[xabio]

Per Joe91 o chi vuole intervenire .

C'e' una funzione in Spaziometria o in linguaggio vbs che mi permette di dividere un prodotto in cifre !

Es: 47 * 74 = 4378 vorrei dividerlo in 2 numeri partendo da destra diciamo n1=78 n2=43

Es: 12 * 21 = 252 n1=52 n2=25

Approfitto del thread . Saluti e grazie.

 

[LuigiB]

si , le funzioni che operano sulle stringhe

left , right , mid

dim s

s = "1020"

left (s ,2) darà "10"
right(s,2) darà "20"
mid (s ,2,2) darà "02"

notare che un conto è lavorare con le variabili stringa e un conto con quelle numeriche ad esempio

s = 0020

left (s ,2) darà "20"

mentre

s = "0020"

left (s ,2) darà "00"

questo perche nel primo caso mancando le virgolette il valore è interpretato come un numero i cui zeri a sinistra non sono signigficativi
nel secondo anche se sono state passate delle cifre , il fatto di averle passate tra virgolette le fa interpretare come stringa e quindi gli zeri a sinistra sono semplicemente dei caratteri come gli altri.

 

[xabio]

Thank You Luigi mi hai semplificato la vita avevo immente tutta una serie di operazioni con la funzione cadenza poi sottrarre dividere ecc.
Buona giornata .
Ciao.

 

[Joe91]

Buon Giorno a tutti ...

Ringrazio per la fiducia, disaronno e Luigi per le efficaci soluzioni.

Posso solo aggiungere un richiamo a "Len" che restituisce la lunghezza,

e può fornire indicazioni utili sul come dividere la stringa.

Per Luigi:

Ho uno script di Denis, in un altro Basic, che mi piacerebbe poter convertire a Spaziometria.

Ho già letto in passato che non conosci quest'altro dialetto, però mi permetto di chiedere ugualmente.

L'ho già adattato per buona parte alla sintassi di Spaziometria,però purtroppo non (mi) funziona ancora.

Volevo chiederti se lo posso proporre alla tua attenzione ...

perchè tu, avendo la migliore conoscenza possibile di Spaziometria, forse riesci ad individuare,

le differenze nelle istruzioni, che provocano il mancato funzionamento.

Nel ringraziare, sin d'ora, porgo gli auguri di una buona giornata.

 

[LuigiB]

ciao Joe , procedi con la pubblicazione ... se gia lo avessi messo lo avrei gia visto .. solo che ora sono al lavoro oggi pomeriggio da casa vedrò di sicuro se fai in tempo a metterlo.

 

[Joe91]

Grazie Luigi.

Lo script in originale è questo:

'Script realizzato da Denis COSTANTINI - 23/06/2007

'lo script esegue la ricerca delle formazioni da 2 fino a 7 numeri
'in maggior ritardo su TUTTE per la sorte di ambo

'tempo stimato (usando i valori indicati in RitMinimo) circa 30 secondi


CancellaOutput()

Scrivi("TABELLONE DELLE PRINCIPALI COMBINAZIONI IN RITARDO PER AMBO SU TUTTE")
Scrivi("aggiornato all'estrazione n° "+inttostr(EstrazioniArchivio)+" del "+DataEstrazione(EstrazioniArchivio))
Scrivi("")

'valori di ritardo minimo per velocizzare (!) la ricerca
RitMinimo=[0,0,270,135,90,68,55,45]

'inizia ricerca combinazioni da 2 a 7 numeri in ritardo per ambo su TUTTE
for NumeriCercati=2 to 7

  MAXRuota=VarArrayCreate([0,11],3)
  MAXNumero=VarArrayCreate([0,90],3)
  RuotaCercata=VarArrayCreate([0,11],3)
  Minimo=VarArrayCreate([0,90,0,90],3)
  RitAmbo=VarArrayCreate([0,90,0,90],3)
  Numeri=VarArrayCreate([0,90],3)
'
  OrdCom=VarArrayCreate([0,20],12)
  OrdRit=VarArrayCreate([0,20],3)

  Scrivi("combinazioni di "+inttostr(NumeriCercati)+" numeri con ritardo minimo di "+inttostr(RitMinimo[NumeriCercati])+" estrazioni")
  Scrivi("")

  RitardoMinimo=(RitMinimo[NumeriCercati])

  'ricerca dei numeri richiesti
  for i=1 to 10
    MAXRuota[i]=i
  next

  FineRuote=1       'indica al programma di continuare la ricerca finchè FineRuote=0
  r=0
  RuotaCercata[r]=0

  do
    r=r+1
    RuotaCercata[r]=RuotaCercata[r-1]+1
    if RuotaCercata[r]>MAXRuota[r] then
      do
        r=r-1
        if r=0 then
          FineRuote=0
          exit do
        end if
        RuotaCercata[r]=RuotaCercata[r]+1
      loop until (RuotaCercata[r]<=MAXRuota[r])
    end if

    if r=10 then
      'memorizza il ritardo minimo dei 4005 ambi sulle ruote individuate
      for i=1 to 89
        for j=(i+1) to 90
          Minimo[i,j]=EstrazioniArchivio
          for k=1 to 10
            if RitardoAmbo(i,j,RuotaCercata[k])<Minimo[i,j] then
              Minimo[i,j] = RitardoAmbo(i,j,RuotaCercata[k])
            end if
          next
        next
      next

      for i=1 to NumeriCercati
        MAXNumero[i]=90+i-NumeriCercati
      next

      n=1
      Numeri[n]=1
      'inizia la ricerca dei numeri
      do
        Fine=1
        n=n+1
        Numeri[n]=Numeri[n-1]+1
        do
          if Numeri[n]>MAXNumero[n] then
            do
              n=n-1
              if n=0 then
                Fine=0
                exit do
              end if
              Numeri[n]=Numeri[n]+1
            loop until Numeri[n]<=MAXNumero[n]
          end if

          if n>1 then
            FineCiclo=1
            'controllo ritardo degli ambi
            AmbiRitardoValido=0 : Ritardo=EstrazioniArchivio
            for j=1 to (n-1)
              RitardoAttuale=Minimo[Numeri[j],Numeri[n]]
              if RitardoAttuale<RitardoMinimo then
                exit for
              else
                AmbiRitardoValido=AmbiRitardoValido+1
              end if
            next

            if AmbiRitardoValido=(n-1) then
              if n=NumeriCercati then
                'trovato una combinazione
                qqq=" "
                for q=1 to n
                  if Numeri[q]>9 then
                    qqq=qqq+inttostr(Numeri[q])+" "
                  else
                    qqq=qqq+" "+inttostr(Numeri[q])+" "
                  end if
                next
                for q=1 to (n-1)
                  for w=(q+1) to n
                    if Ritardo>Minimo[Numeri[q],Numeri[w]] then
                       Ritardo=Minimo[Numeri[q],Numeri[w]]
                    end if
                  next
                next
'
                jj=0
                for j=10 to 1 step -1
                    if ritardo>OrdRit[j] then
                       jj=j
                    end if
                next
                if jj>0 then
                   if jj=20 then
                      OrdRit[20]=ritardo
                      OrdCom[20]=qqq
                   else
                      for j=20 to jj+1 step -1
                           OrdRit[j]=OrdRit[j-1]
                           OrdCom[j]=OrdCom[j-1]
                      next
                      OrdRit[jj]=ritardo
                      OrdCom[jj]=qqq
                   end if
                end if
'
'                Scrivi("")
                Numeri[n]=Numeri[n]+1
              else
                FineCiclo=0
              end if
            else
              Numeri[n]=Numeri[n]+1
              FineCiclo=1
            end if
          else
            FineCiclo=0
          end if

          if Fine=0 then exit do end if

        loop until FineCiclo=0

      loop until Fine=0

    end if

  loop until FineRuote=0
'
  for j=1 to 20
      if inttostr(OrdRit[j])>0 then
         Scrivi("TUTTE   "+OrdCom[j]+"    ritardo : "+inttostr(OrdRit[j]))
      end if
  next
'
  Scrivi("-----------------------------------------------------------------------")
  PosizioneBarra(2,7,NumeriCercati)
next

E ... produce :

TABELLONE DELLE PRINCIPALI COMBINAZIONI IN RITARDO PER AMBO SU TUTTE
aggiornato all'estrazione n° 8660 del 02/03/2013

combinazioni di 2 numeri con ritardo minimo di 270 estrazioni

TUTTE    79 89     ritardo : 351
TUTTE    76 85     ritardo : 284
TUTTE    29 71     ritardo : 280
TUTTE     8 12     ritardo : 279
TUTTE    47 90     ritardo : 273
-----------------------------------------------------------------------
combinazioni di 3 numeri con ritardo minimo di 135 estrazioni

TUTTE     7 40 79     ritardo : 147
TUTTE    24 31 83     ritardo : 141
-----------------------------------------------------------------------
combinazioni di 4 numeri con ritardo minimo di 90 estrazioni

TUTTE    24 31 67 83     ritardo : 101
TUTTE     7 30 60 74     ritardo : 99
TUTTE     7 60 74 79     ritardo : 99
TUTTE     9 11 41 78     ritardo : 97
TUTTE     9 41 47 78     ritardo : 97
-----------------------------------------------------------------------
combinazioni di 5 numeri con ritardo minimo di 68 estrazioni

TUTTE     7 30 60 74 77     ritardo : 79
TUTTE     9 41 58 78 86     ritardo : 75
TUTTE    10 13 69 84 85     ritardo : 75
TUTTE     7 19 53 64 88     ritardo : 72
TUTTE     7 19 24 65 90     ritardo : 71
TUTTE     7 19 53 88 90     ritardo : 70
TUTTE    32 36 56 74 86     ritardo : 70
TUTTE     7 19 24 33 90     ritardo : 69
TUTTE     7 19 32 65 90     ritardo : 69
TUTTE     7 19 32 88 90     ritardo : 69
TUTTE    18 33 37 41 83     ritardo : 69
TUTTE     2 30 33 52 87     ritardo : 68
-----------------------------------------------------------------------
combinazioni di 6 numeri con ritardo minimo di 55 estrazioni

TUTTE     7 19 24 33 65 90     ritardo : 65
-----------------------------------------------------------------------
combinazioni di 7 numeri con ritardo minimo di 45 estrazioni

TUTTE     9 24 30 31 40 47 67     ritardo : 51
TUTTE     9 30 36 37 53 55 86     ritardo : 45
TUTTE    10 67 69 74 81 84 85     ritardo : 45
-----------------------------------------------------------------------

Ragguaglio veloce:

Le matrici richiedono il valore minimo/massimo/tipo. Le ho convertite.

Poi andrebbero portate in Redim ...

Cancellato equivalente di CLS (non serve).

Ho sostituitto tutte le parentesi quadre in Rotonde

Ho convertito Amboritardo / Ritardoambo (ove si manifesta l'errore)

Ho provato questa routine portandola fuori dallo script e funziona ...

Ho testato anche i Do-Loop e sono compatibili (anche se penso che il problema nasca in questi)

in ultimo ho provato anche a modificare l'array con cui si caricano i ritardi di riferimento minimo.

Lo script ... a metà del guado.

'Script realizzato da Denis COSTANTINI - 23/06/2007

'lo script esegue la ricerca delle formazioni da 2 fino a 7 numeri
'in maggior ritardo su TUTTE per la sorte di ambo

'tempo stimato (usando i valori indicati in RitMinimo) circa 30 secondi


Scrivi("TABELLONE DELLE PRINCIPALI COMBINAZIONI IN RITARDO PER AMBO SU TUTTE")
Scrivi("aggiornato all'estrazione n° " &(EstrazioniArchivio) & " del " & DataEstrazione(EstrazioniArchivio))
Scrivi("")

'valori di ritardo minimo per velocizzare (!) la ricerca

RM = "0,0,270,135,90,68,55,45"

RitMinimo = Split(RM,",")

'inizia ricerca combinazioni da 2 a 7 numeri in ritardo per ambo su TUTTE
For NumeriCercati = 2 To 7

Dim MAXRuota(12)
Dim MAXNumero(90)
Dim RuotaCercata(12)
Dim Minim(90,90)
Dim RitAmbo(90,90)
Dim Numeri(90)
'
Dim OrdCom(20)
Dim OrdRit(20)

'Scrivi("combinazioni di " & (NumeriCercati) & " numeri con ritardo minimo di " & (RitMinimo(NumeriCercati)) & " estrazioni")
Scrivi("")

RitardoMinimo =(RitMinimo(NumeriCercati))

'ricerca dei numeri richiesti
For i = 1 To 10
MAXRuota(i) = i
Next

FineRuote = 1 'indica al programma di continuare la ricerca finchè FineRuote=0
r = 0
RuotaCercata(r) = 0

Do
r = r + 1
RuotaCercata(r) = RuotaCercata(r - 1) + 1
If RuotaCercata(r) > MAXRuota(r) Then
Do
r = r - 1
If r = 0 Then
FineRuote = 0
Exit Do
End If
RuotaCercata(r) = RuotaCercata(r) + 1
Loop Until(RuotaCercata(r) <= MAXRuota(r))
End If

If r = 10 Then
'memorizza il ritardo minimo dei 4005 ambi sulle ruote individuate
For i = 1 To 89
For j =(i + 1) To 90
Minim(i,j) = EstrazioniArchivio
For k = 1 To 10
If AmboRitardo(RuotaCercata(k),i,j) < Minim(i,j) Then
Minim(i,j) = AmboRitrdo(RuotaCercata(k),i,j)
End If
Next
Next
Next

For i = 1 To NumeriCercati
MAXNumero(i) = 90 + i - NumeriCercati
Next

n = 1
Numeri(n) = 1
'inizia la ricerca dei numeri
Do
Fine = 1
n = n + 1
Numeri(n) = Numeri(n - 1) + 1
Do
If Numeri(n) > MAXNumero(n) Then
Do
n = n - 1
If n = 0 Then
Fine = 0
Exit Do
End If
Numeri(n) = Numeri(n) + 1
Loop Until Numeri(n) <= MAXNumero(n)
End If

If n > 1 Then
FineCiclo = 1
'controllo ritardo degli ambi
AmbiRitardoValido = 0 : Ritardo = EstrazioniArchivio
For j = 1 To(n - 1)
RitardoAttuale = Minim(Numeri(j),Numeri(n))
If RitardoAttuale < RitardoMinimo Then
Exit For
Else
AmbiRitardoValido = AmbiRitardoValido + 1
End If
Next

If AmbiRitardoValido = (n - 1) Then
If n = NumeriCercati Then
'trovato una combinazione
qqq = " "
For q = 1 To n
If Numeri(q) > 9 Then
qqq = qqq + inttostr(Numeri(q)) + " "
Else
qqq = qqq + " " + inttostr(Numeri(q)) + " "
End If
Next
For q = 1 To(n - 1)
For w =(q + 1) To n
If Ritardo > Minimo(Numeri(q),Numeri(w)) Then
Ritardo = Minimo(Numeri(q),Numeri(w))
End If
Next
Next
'
jj = 0
For j = 10 To 1 Step - 1
If ritardo > OrdRit(j) Then
jj = j
End If
Next
If jj > 0 Then
If jj = 20 Then
OrdRit[20] = ritardo
OrdCom[20] = qqq
Else
For j = 20 To jj + 1 Step - 1
OrdRit(j) = OrdRit(j - 1)
OrdCom(j) = OrdCom(j - 1)
Next
OrdRit(jj) = ritardo
OrdCom(jj) = qqq
End If
End If
'
'                Scrivi("")
Numeri(n) = Numeri(n) + 1
Else
FineCiclo = 0
End If
Else
Numeri(n) = Numeri(n) + 1
FineCiclo = 1
End If
Else
FineCiclo = 0
End If

If Fine = 0 Then Exit Do End If

Loop Until FineCiclo = 0

Loop Until Fine = 0

End If

Loop Until FineRuote = 0
'
For j = 1 To 20
If inttostr(OrdRit(j)) > 0 Then
Scrivi("TUTTE   " + OrdCom(j) + "    ritardo : " + inttostr(OrdRit(j)))
End If
Next
'
Scrivi("-----------------------------------------------------------------------")

'PosizioneBarra(2,7,NumeriCercati) 

Next

Grazie per l'interessamento.

 

[LuigiB]

ciao Joe , se puoi metti pure lo script originale senza nessuna modifica. sicuramente avrai fatto tutto bene ma visto che devo vederlo vorrei anche l'originale ..un saluto

 

[LuigiB]

pardon lo script originale gia c'è ... oggi pomeriggio vedrò .. ciao

 

[LuigiB]

ciao Joe , laddove i cicli do sono implementati funzioinano allo stesso modo in tutti i linguaggi.
Ho modificato lo script per farlo girare ora a te la verifica del fatto che funzioni ...
Ciao

Option Explicit
Sub Main
	Dim RitMinimo 
	Dim NumeriCercati 
	Dim RitardoMinimo 
	Dim i , j , k , n , r , q , w , jj , qqq
	Dim FineRuote 
	Dim Fine
	Dim FineCiclo
	Dim AmbiRitardoValido 
	Dim RitardoAttuale 
	Dim Ritardo 
	
	
	'Script realizzato da Denis COSTANTINI - 23/06/2007
	'lo script esegue la ricerca delle formazioni da 2 fino a 7 numeri
	'in maggior ritardo su TUTTE per la sorte di ambo
	'tempo stimato (usando i valori indicati in RitMinimo) circa 30 secondi
	Scrivi("TABELLONE DELLE PRINCIPALI COMBINAZIONI IN RITARDO PER AMBO SU TUTTE")
	Call Scrivi("aggiornato all'estrazione n° " & EstrazioniArchivio & " del " & DataEstrazione(EstrazioniArchivio))
	Call Scrivi("")
	'valori di ritardo minimo per velocizzare (!) la ricerca
	RitMinimo = Array (0,0,270,135,90,68,55,45)
	
	'inizia ricerca combinazioni da 2 a 7 numeri in ritardo per ambo su TUTTE
	For NumeriCercati = 2 To 7
		ReDim MaxRuota (11) ' MaxRuota = VarArrayCreate([0,11],3)
		ReDim MaxNumero (90) ' MAxNumero = VarArrayCreate([0,90],3)
		ReDim RuotaCercata (11)' RuotaCercata = VarArrayCreate([0,11],3)
		ReDim Minim (90 , 90 )' = VarArrayCreate([0,90,0,90],3)
		ReDim RitAmbo (90,90) ' RitAmbo = VarArrayCreate([0,90,0,90],3)
		ReDim Numeri (90) ' Numeri = VarArrayCreate([0,90],3)
		ReDim OrdCom (20) ' OrdCom = VarArrayCreate([0,20],12)
		ReDim OrdRit (20) ' OrdRit = VarArrayCreate([0,20],3)
		Scrivi("combinazioni di " & NumeriCercati & " numeri con ritardo minimo di " & RitMinimo(NumeriCercati) & " estrazioni")
		Scrivi("")
		RitardoMinimo = RitMinimo(NumeriCercati)
		'ricerca dei numeri richiesti
		For i = 1 To 10
			MaxRuota(i) = i
		Next
		FineRuote = 1 'indica al programma di continuare la ricerca finchè FineRuote=0
		r = 0
		RuotaCercata(r) = 0
		Do
			r = r + 1
			RuotaCercata(r) = RuotaCercata(r - 1) + 1
			If RuotaCercata(r) > MaxRuota (r) Then
				Do
					r = r - 1
					If r = 0 Then
						FineRuote = 0
						Exit Do
					End If
					RuotaCercata(r) = RuotaCercata(r) + 1
				Loop Until RuotaCercata(r) <= MaxRuota(r)
			End If
			If r = 10 Then
				'memorizza il ritardo minimo dei 4005 ambi sulle ruote individuate
				For i = 1 To 89
					For j =(i + 1) To 90
						Minim(i,j) = EstrazioniArchivio
						For k = 1 To 10
							If AmboRitardoTurbo(RuotaCercata(k), i,j) < Minim(i,j) Then
								Minim(i,j) = AmboRitardoTurbo(RuotaCercata(k),i,j)
							End If
						Next
					Next
				Next
				For i = 1 To NumeriCercati
					MaxNumero(i) = 90 + i - NumeriCercati
				Next
				n = 1
				Numeri(n) = 1
				'inizia la ricerca dei numeri
				Do
					Fine = 1
					n = n + 1
					Numeri(n) = Numeri(n - 1) + 1
					Do
						If Numeri(n) > MaxNumero(n) Then
							Do
								n = n - 1
								If n = 0 Then
									Fine = 0
									Exit Do
								End If
								Numeri(n) = Numeri(n) + 1
							Loop Until Numeri(n) <= MaxNumero(n)
						End If
						If n > 1 Then
							FineCiclo = 1
							'controllo ritardo degli ambi
							AmbiRitardoValido = 0 : Ritardo = EstrazioniArchivio
							For j = 1 To(n - 1)
								RitardoAttuale = Minim(Numeri(j),Numeri(n))
								If RitardoAttuale < RitardoMinimo Then
									Exit For
								Else
									AmbiRitardoValido = AmbiRitardoValido + 1
								End If
							Next
							If AmbiRitardoValido =(n - 1) Then
								If n = NumeriCercati Then
									'trovato una combinazione
									qqq = " "
									For q = 1 To n
										If Numeri(q) > 9 Then
											qqq = qqq & Numeri(q) & " "
										Else
											qqq = qqq & " " & Numeri(q) & " "
										End If
									Next
									For q = 1 To(n - 1)
										For w =(q + 1) To n
											If Ritardo > Minim(Numeri(q),Numeri(w)) Then
												Ritardo = Minim(Numeri(q),Numeri(w))
											End If
										Next
									Next
									'
									jj = 0
									For j = 10 To 1 Step - 1
										If Ritardo > OrdRit(j) Then
											jj = j
										End If
									Next
									If jj > 0 Then
										If jj = 20 Then
											OrdRit(20) = Ritardo
											OrdCom(20) = qqq
										Else
											For j = 20 To jj + 1 Step - 1
												OrdRit(j) = OrdRit(j - 1)
												OrdCom(j) = OrdCom(j - 1)
											Next
											OrdRit(jj) = Ritardo
											OrdCom(jj) = qqq
										End If
									End If
									'
									'                Scrivi("")
									Numeri(n) = Numeri(n) + 1
								Else
									FineCiclo = 0
								End If
							Else
								Numeri(n) = Numeri(n) + 1
								FineCiclo = 1
							End If
						Else
							FineCiclo = 0
						End If
						If Fine = 0 Then Exit Do End If
					Loop Until FineCiclo = 0
				Loop Until Fine = 0
			End If
		Loop Until FineRuote = 0
		'
		For j = 1 To 20
			If OrdRit(j) > 0 Then
				Call Scrivi("TUTTE   " & OrdCom(j) & "    ritardo : " & OrdRit(j))
			End If
		Next
		'
		Scrivi("-----------------------------------------------------------------------")
		'PosizioneBarra(2,7,NumeriCercati)
		Call AvanzamentoElab(2,7 , NumeriCercati)
		If ScriptInterrotto Then Exit For 
	Next
	
	
End Sub

 

[Joe91]

-----------------------------------------------------------------------
combinazioni di 3 numeri con ritardo minimo di 135 estrazioni

TUTTE 7 40 79 ritardo : 147

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

Ciao Luigi ... più veloce della Lottomatica!

Laddove l'esempio prodotto dallo script originale evidenziava una terzina per ambo,

quello in prova a Spaziometria, giustamente non l'elenca più per la caduta, questa sera,

dell' Ambo 7.40 a Bari.

Naturalmente riserverò allo script (ed alle tue correzioni) ancora alcuni controlli ... più approfonditi,

ma è doveroso il mio solito GROSSO grazie.

Buona Serata a tutte/i.

 

[xabio]

Buon Giorno a tutti ... Ringrazio per la fiducia, disaronno e Luigi per le efficaci soluzioni. Posso solo aggiungere un richiamo a "Len" che restituisce la lunghezza, e può fornire indicazioni utili sul come dividere la stringa. Per Luigi: Ho uno script di Denis, in un altro Basic, che mi piacerebbe poter convertire a Spaziometria. Ho già letto in passato che non conosci quest'altro dialetto, però mi permetto di chiedere ugualmente. L'ho già adattato per buona parte alla sintassi di Spaziometria,però purtroppo non (mi) funziona ancora. Volevo chiederti se lo posso proporre alla tua attenzione ... perchè tu, avendo la migliore conoscenza possibile di Spaziometria, forse riesci ad individuare, le differenze nelle istruzioni, che provocano il mancato funzionamento. Nel ringraziare, sin d'ora, porgo gli auguri di una buona giornata.

Grazie Joe per la funzione "Len" sto facendo il mio primo Script . Quando lo termino lo posto. Ciao.

 

[Joe91]

Ciao Xabio ...

attendiamo fiduciosi ed intanto complimenti per l' approccio-operoso che hai allo script.

Anch'io, ho fatto i compiti a casa ...(ove "la guida" su strada reputo sia il miglior modo per imparare)

trovando tutti gli errori e le mancate correzioni allo script che ho proposto e che Luigi ha reso funzionante.

Questo è il riassunto di quanto emerso:

RitardoMinimo =(RitMinimo(NumeriCercati))
If RuotaCercata(r) > MAXRuota(r) Then
Loop Until(RuotaCercata(r) <= MAXRuota(r))
If AmboRitardo(RuotaCercata(k),i,j) < Minim(i,j) Then
Minim(i,j) = [COLOR=#ff0000]AmboRitrdo[/COLOR](RuotaCercata(k),i,j)
qqq = qqq + inttostr(Numeri(q)) + " "
qqq = qqq + " " + inttostr(Numeri(q)) + " "
If Ritardo > Minimo(Numeri(q),Numeri(w)) Then
Ritardo = Minimo(Numeri(q),Numeri(w))
OrdRit[20] = ritardo
OrdCom[20] = qqq
If inttostr(OrdRit(j)) > 0 Then
Scrivi("TUTTE   " + OrdCom(j) + "    ritardo : " + inttostr(OrdRit(j)))

Dove l'errore più grave, ancora presente, era stato il mio, di digitazione.

Buona giornata a tutte/i.

 

[xabio]

Ciao Joe
Ho pescato un metodo in internet di un certo Ettore Tenuta non l'avevo mai trovato prima di adesso sembra essere stato famoso!

'TECNICA QUANTISTICA.....
'In onore al GRANDEMAESTRO ETTORE TENUTA :da conservare.....perchè questo 'fa parte del vero gioco del LOTTO
'Ricercare su due ruote nella stessa estrazione e In forma isotopa"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""Ho analizzato solo ruote consecutive
'due numeri di cui uno sia il vertibile dell'altro è che l'ambo vertibile deve essere formato da un elemento pari e uno dispari.
'Sono esclusi gli ambi vertibili diametrali.Ora attenzione eseguiamo lo sviluppo della previsione
'ESEMPIO del 3 marzo 2001
'Napoli 76 (terzo Estratto - pari)
'Torino 67 (terzo Estratto-dispari)
'La prima operazione da fare è quella di calcolare i diametrali
'dei due elementi per cui :
'76-45=31(dispari)
'67-45=22( pari)
'sommiamo adesso gli elementi dispari : 31+67=98       sommiamo ora gli elementi pari : 76+22= 98
'dividiamo le due some per 2      98:2=49   98:2=49 ai risultati delle divisioni faremo il complemento a 90    90-49=41 90-49=41
'ai risultati delle sottrazioni ricaviamo le rispettive chiusure simmetriche a passo 30 per cui:  la chiusura simmetrica di 49 sarà 79 e 19 
'la chiusura simmetrica di 41 sarà 71-11
'queste chiusure simmetriche le adopereremo x abbinarle all'ambata capogioco
'ITER PER IL RICAVO DELL'AMBATA: Riprendiamo In considerazione i nostri  due elementi vertibili andando a moltiplicarli tra loro ,per cui: 67x 76= 5092 (prodotto
' della moltiplicazione)
'tale prodotto lo andiamo a scomporre partendo da destra verso sinistra considerando due cifre alla volta per cui
'Primo numero 92 con il fuori 90 diventa 2  secondo numero 50 sommiamo gli elementi 2+50= 52 poi tale somma la andiamo a completare a 91 per cui :  91-52= 39
'il complemento a 91 arà la nostra ambata da porre In gioco a cui andranno abbinati i quattro numeri precedentemente ricavati (chiusura simmetriche)
'Le previsioni vanno giocate da uno a 9 colpi ,facendo attenzione prima di porlre In gioco ,che l'ambata non sia presente nella data di estrazione e nelle 9 precedenti.
Option Explicit
Sub Main
    Dim r1,r2,p1,n1,n2,n3,n4,n5,n6,est,estini,estfin,a1,a2,a3,a4,a5,a6,a7,s1,s2,s3,s4,s5,s6,j,start
    Dim ruote(2)
    Dim num(7)
    Dim poste(2)
    Dim n(7)
    start = InputBox("Intervallo Estrazioni partendo da ultima in Archivio",,150)
    estini = EstrazioneFin - start
    estfin = EstrazioneFin
    For est = estini To estfin
        For r1 = 1 To 9
            r2 = r1 + 1
            For p1 = 1 To 5
                n1 = Estratto(est,r1,p1)
                n2 = Estratto(est,r2,p1)
                If n1 = Vert(n2) Then
                    If pari(n1) And dispari(n2) Or dispari(n1) And pari(n2) Then
                        If n1 < 10 Then n1 = 0 & n1
                        If n2 < 10 Then n2 = 0 & n2
                        n3 = n1*n2
                        If Len(n3) = 4 Then
                            n4 = Fuori90(CInt(Right(n3,2)))
                            n5 = Fuori90(CInt(Left(n3,2)))
                        End If
                        If Len(n3) = 3 Then
                            n4 = Fuori90(CInt(Right(n3,2)))
                            n5 = Fuori90(CInt(Left(n3,1)))
                        End If
                        n6 = Fuori90(n4 + n5)
                        a1 = 91 - n6
                        If RitardoEstratto(a1,est,r1) > 9 And RitardoEstratto(a1,est,r2) > 9 Then
                            s1 = Fuori90(n1 + 45)
                            s2 = Fuori90(n2 + 45)
                            s3 = n1 + s2
                            s4 = n2 + s1
                            s5 = s4/2
                            s6 = 90 - s5
                            a2 = Fuori90(s5 + 30):a3 = Fuori90(a2 + 30):a4 = Fuori90(a3 + 30)
                            a5 = Fuori90(s6 + 30):a6 = Fuori90(a5 + 30):a7 = Fuori90(a6 + 30)
                            poste(2) = 1:ruote(1) = r1:ruote(2) = r2
                            n(2) = a2
                            n(3) = a3
                            n(4) = a4
                            n(5) = a5
                            n(6) = a6
                            n(7) = a7
                            For j = 2 To 7
                                num(1) = a1
                                num(2) = n(j)
                                ImpostaGiocata 1,num,ruote,poste,8,2
                                Gioca est
                            Next
                        End If
                    End If
                End If
            Next
        Next
    Next
    ScriviResoconto
End Sub

Non sapevo come ipostare la giocata con una fissa e 6 abbinamenti .
Volevo chiederti se la funzione Call e' opzionale o quando si deve usarla.
Ciao.

 

[Joe91]

Buon Giorno a tutti ...

A) Ho controllato la versione per Spaziometria dello script reso funzionante dal Luigi

esso, fornisce indicazioni corrette ed allineate, sia allo script originale, sia ai valori statistici attuali.

Funziona.

B) Per Xabio ... in queste cose ... Luigi è il Maestro d'orchestra, io sono solo uno strimpellatore.

Quindi più che una certezza ti do una mia opinione.

Call è la forma più completa ed elegante e con essa i parametri si includono tra le parentesi,

sparati da una virgola ES: Call Routine (a,b,c,d)

Differentemente la chiamata senza Call ... è in forma abbreviata, probabilmente risonosciuta,

dall' interprete, per semplificare il compito dello scripter. Forse.

C) Lo script (dunque, il metodo di cui non ho memoria come non ho memoria dell'autore) ...

Si, nella storia del lotto, (l'ho controllato in 5000 estrazioni) si comporta molto bene,

naturalmente con le alternanze di periodi buoni e non che contraddistinguono TUTTI i metodi.

Ma, così come l'hai proposto in script è molto meglio di tante "favole" che si sentono raccontare ,in giro.

 

[xabio]

Buon Giorno a tutti ... Per Xabio ... in queste cose ... Luigi è il Maestro d'orchestra, io sono solo uno strimpellatore. Quindi più che una certezza ti do una mia opinione. Call è la forma più completa ed elegante e con essa i parametri si includono tra le parentesi, sparati da una virgola ES: Call Routine (a,b,c,d) Differentemente la chiamata senza Call ... è in forma abbreviata, probabilmente risonosciuta, dall' interprete, per semplificare il compito dello scripter. Forse. C) Lo script (dunque, il metodo di cui non ho memoria come non ho memoria dell'autore) ... Si, nella storia del lotto, (l'ho controllato in 5000 estrazioni) si comporta molto bene, naturalmente con le alternanze di periodi buoni e non che contraddistinguono TUTTI i metodi. Ma, così come l'hai proposto in script è molto meglio di tante "favole" che si sentono raccontare ,in giro.

Grazie del check Joe . Sono un po' in ritardo ciao.

 

[xabio]

Hello Joe .
Posso chiederti come si fa a scrivere gli elementi di un vettore tramite un ciclo for / next nella finestra di output
in riga piuttosto che in colonna .
Es:
dim a(20)
c1=c1+1
a(c1)=estratto x

For k=1 To c1
Scrivi a(k)
Next

Mi riporta tutti i valori in colonna , preferirei averli in riga per leggerli meglio.
Ciao.

 

[Joe91]

Hello Joe .
Posso chiederti come si fa a scrivere gli elementi di un vettore tramite un ciclo for / next nella finestra di output
in riga piuttosto che in colonna .
Es:
dim a(20)
c1=c1+1
a(c1)=estratto x

For k=1 To c1
Scrivi a(k)
Next

Mi riporta tutti i valori in colonna , preferirei averli in riga per leggerli meglio.
Ciao.

Ciao Xabio.

La domanda è precisa ma accenno a Scrivi StringaNumeri ed i suoi parametri.

Mentre se devi o vuoi usare Scrivi ... per ogni oggetto ... farai riferimento ai parametri di scrivi.

Recentemente Luigi ha modificato Spaziometria ampliando ed indicando le personalizzazioni possibili.

Trovi le mie richieste specifice e le sue fattive risposte in Spaziometria Nuova Versione,

ove sono ben spscificati i "parametri" di scrivi ed i nuovi settaggi di Spaziometria.

Brevemente :

Scrivi / "Oggetto" (& "eventuali spazi o separatori") virgola (1=Neretto / 0=Normale) virgola ( 0=unito / 1= aCapo).

Vi è anche questo esempio delle nuove possibilità di "formattazione condizionale":

Sub Main
    For N = 1 To 15
        If pari(N) Then Bold = True
        Somma = Somma + N
        Call Scrivi(N & " ",Bold,0,,,Iif(bold,4,2))
        Bold = False
    Next
    Scrivi Somma ',True
    Scrivi : Somma = 0
    For N = 1 To 15
        If pari(N) Then Bold = True
        Somma = Somma + N
        Scrivi N & " ",Bold,0
        Bold = False
    Next
    Scrivi Somma,True
End Sub

 

[gennaro]

Semplici esempi che rallegrano la vita poiche' ti fanno capire delle cose ...

Sub Main
    Dim a(10)
    Call Scrivi("Bold, SI ritorno a capo (def), fondo ciano, Txt Rosso, dimensione 3 ",True,1,vbCyan,vbRed,3)
    Call Scrivi("NO Bold (def), NO ritorno a capo, fondo giallo, Txt Nero (def), dimensione 2 (def) ",False,0,vbYellow,vbBlack,2)
    Call Scrivi("NO ritorno a capo",,0)
    Call Scrivi("SI ritorno a capo (def)",,1)
    Call Scrivi("Ultimo rigo tutto default")
    
    For k = 1 To 10
        a(k) = k*2
    Next
    
    Scrivi
    Scrivi String(80,"*"),1
    Scrivi StringaNumeri(a)
    Scrivi StringaNumeri(a,"/")
    Scrivi StringaNumeri(a,"-",1)


    Scrivi    
    Scrivi String(100,"*"),0
    For k = 1 To 10
     Scrivi a(k)
    Next


    Scrivi    
    Scrivi String(120,"*"),1
    For k = 1 To 10
     Scrivi a(k) & " ",,0
    Next
    
End Sub