Riempire un array

[Top Fuel]

Sono partito con il nuovo progettino, stavolta direttamente in G3 (cominciate a tremare... ) e già mi sono arenato.
In questo nuovo progetto mi serve una matrice come questa:

Codice: [Seleziona]

PRIVATE Numeri[37,6] AS BYTE 

E' una matrice di servizio, ci devo mettere dei valori ben precisi ad inizio programma e poi non li tocco più, vanno solo letti.
Il problema è proprio metterli, dovrei scrivere 222 istruzioni di assegnazione differenti, perchè i numeri non sono messi in una successione aritmetica ben precisa, ma secondo un certo ordine. Nel vecchio Basic c'erano le famose istruzioni DATA nelle quali ci mettevi i valori che volevi e con un paio di cicli FOR NEXT assegnavi i valori, ma qui non ci sono...
Esiste una maniera per scrivere meno roba? Avevo pensato anche a creare un piccolo file da aprire e leggere, ma non so in che formato devo scriverlo.

[vuott]

.... i numeri non sono messi in una successione aritmetica, ma secondo un certo ordine. Nel vecchio Basic c'erano le famose istruzioni DATA nelle quali ci mettevi i valori che volevi e con un paio di cicli FOR NEXT assegnavi i valori, ma qui non ci sono...

...Choose(...)

Esiste una maniera per scrivere meno roba? Avevo pensato anche a creare un piccolo file da aprire e leggere, ma non so in che formato devo scriverlo.

Essendo i valori, da assegnare, di tipo strettamente Byte, direi: binario.


Se poi non vuoi usare un'array bidimensionale, magari potresti utilizzare un Memory Stream dopo aver allocato sufficiente memoria, e scorrere nella lettura all'interno del flusso di dati.... va be'... ma questo è più complesso. 

[Top Fuel]

Choose non è quello che mi serve, non devo scegliere, ma assegnare dei valori.
Comunque l'idea del file binario mi piace, proverò.

[Picavbg]

Codice: [Seleziona]

PRIVATE Numeri[37,6] AS BYTE 

E' una matrice di servizio, ci devo mettere dei valori ben precisi ad inizio programma e poi non li tocco più, vanno solo letti.
Il problema è proprio metterli, dovrei scrivere 222 istruzioni di assegnazione differenti, perchè i numeri non sono messi in una successione aritmetica ben precisa, ma secondo un certo ordine.

Secondo me, impegnare un file per costruire una matrice di cui conosci già la sequenza è un lavoraccio, anche perchè dovresti comunque scriverlo. Tanto vale che ti costruiosca l'array in via automatica nel programma stesso. Se dovvessi essere d'accordo con la mia riflessione, potresti fare un esempio sulla sequenza che vorresti ottenere? Potrei allora tentare di suggeririti una soluzione più pratica rispetto alla gestione di un file esterno. 
 

[vuott]

Choose non è quello che mi serve, non devo scegliere, ma assegnare dei valori.

Ma in Choose puoi disporre i valori come vuoi, e poi li prendi come vuoi.
Comunque...

[Top Fuel]

Ok, spiego cosa voglio fare: la stronzatina che sto scrivendo è una simulazione della Roulette, il famoso gioco dei casinò (si lo so, sono ludico ), e nell'array ci vanno i 37 numeri nell'ordine in cui sono disposti sulla ruota, con lo zero al centro, per avere una idea http://it.wikipedia.org/wiki/File:Roulette_wheel_it.png, parte dal 5 e finisce al 10. Gli altri 5 elementi mi servono per sapere se il numero uscito e pari o dispari, nero o rosso, passe o manque e se appartiene alla 1a, 2a o 3a dozzina e colonna.
Quindi capite che non c'è nulla di ordinato.
Per ora il programma è molto basilare, ha solo fini statistici, può essere utile per vedere se un sistema che si vuole usare funziona oppure no, difatti verrà mostrato quante volte è uscita una combinazione o un numero e l'elenco degli ultimi 10 numeri usciti, però più avanti mi piacerebbe inserire la possibilità di fare delle puntate.
Vediamo che mostro uscirà fuori.

[Picavbg]

nell'array ci vanno i 37 numeri nell'ordine in cui sono disposti sulla ruota, con lo zero al centro, per avere una idea http://it.wikipedia.org/wiki/File:Roulette_wheel_it.png, parte dal 5 e finisce al 10. Gli altri 5 elementi mi servono per sapere se il numero uscito e pari o dispari, nero o rosso, passe o manque e se appartiene alla 1a, 2a o 3a dozzina e colonna.

Non conoscendo la disposizione dei 37 numeri nella ruota della roulette, ho cercato di capirne il meccanismo ed ho trovato una spiegazione dettagliata, tranne l'ultimo passo che descrive come sia avvenuta l'ulteriore passo per aumentare la casualità di disposizione dei numeri.

Quando Francois Blanc decise di togliere lo zero per attirare i clienti al suo casinò, si trovò con il problema di avere due rossi attaccati (27 e 1). Ne approfittò per disporre i numeri in maniera più casuale e non potendo cambiare il colore associato ad ogni numero (ormai consolidato) si concentrò sull'alternanza non solo tra nero e rosso, ma anche tra manque e passe.
La ruota francese quindi oltre ad aver mentenuto l'impossibilità di giocare due numeri confinanti ha messo all'opposto le coppie di chance: Rosso/Manque, Nero/Passe da una parte e Rosso/Passe, Nero /Manque dall'altra.

Secondo me andare a costruire un sistema di istruzioni di riempimento automatico dell'array diventa un'impresa ardua e poco ricorsiva, per le troppe eccezioni che bisogna gestire. É molto più semplice scrivere l'array già pieno al momento della sua dichiarazione.

Codice: [Seleziona]

Public Sub Roulette()
Dim ySequenza As New Byte[37, 6] 

 ySequenza = [cByte("5"), cByte("24"), cByte("16"), cByte("33"), ....., cByte("0"), cByte("32"), cByte("154"), cByte("19"), ...... cByte("10"), cByte("1"),cByte("0"), cByte("0"), cByte("1") .....,cByte("2"), .....,  cByte("0"), cByte("1"),  cByte("0"),.....] 

La sequenza dei 222 elementi complessivi nella mtarice può sembrarti sbagliata, ma Gambas organizza i valori di una matrice bidimensionale secondo il seguente citerio

Elemento 0,0
Elemento 0,1
Elemento 0,2
.....................
Elemento 0,36
Elemento 1,0
Elemento 1,1
Elemento 1,2
.......................
Elemento 1,36
......................
e così via.

Quindi nella matrice che costruirei io a manina, occorre elencare prima tutti i numeri poi  i contrassegni di Pari ( Cbyte("0") o Dispari Cbyte("1"), poi quelli di NeroCbyte("0")  o RossoCbyte("1") e così via fino alla fine.
Penso che tutto sommato sia il sistema più veloce per costruire l'array. Naturalmente sei sempre tu a stabilire se possa andare o no. 
Ciao.

[Picavbg]

Scusa, ma perché hai bisogno di un struttura di tipo Byte? Secondo me, se definissi l'array in formato String diventerebbe più comprensibile sia il suo contenuto che la sua gestione; infatti gli elementi di contrassegno del colore diventerebbero "N" per il nero e "R" per il rosso, "P" per il pari "D" per il dispari, "S" per il passe  e "M" per il manque, "1" , "2", "3" per le dozzine,  "1" , "2", "3" per le colonne.
Che ne pensi?
 

[Top Fuel]

Ok, mi rassegno a costruirlo a manina.
Non male neppure l'idea di usare le stringhe.

[Top Fuel]

Problema: come temevo, se faccio una unica istruzione:

Codice: [Seleziona]

ySequenza = [cByte("5"), cByte("24"), cByte("16"), cByte("33"), .....

con tutti i 222 elementi di fila mi da errore Too many arguments , quindi devo spezzettarla in 4 o 5 righe come minimo. L'istruzione .Add va bene?

[Picavbg]

Problema: come temevo, se faccio una unica istruzione:

Codice: [Seleziona]

ySequenza = [cByte("5"), cByte("24"), cByte("16"), cByte("33"), .....

con tutti i 222 elementi di fila mi da errore Too many arguments , quindi devo spezzettarla in 4 o 5 righe come minimo. L'istruzione .Add va bene?

Un array così grande non l'avevo mai dichiarato. Hai ragione; ho provato anche definendolo come "String" e l'errore si manifesta anche con codesto tipo di struttura. Però dalla tua precedente risposta avevo capito che ti saresti indirizzato verso un array di tipo "String". Ma tu hai deciso così di mantenerlo nel formati byte? Io ho provato banalmente il passo seguente,tanto per vedere se funziona:

Codice: [Seleziona]

Public Sub Roulette()
Dim i As Integer
Dim ii As Integer
Dim ySequenza As New String[37, 6]  '
For i = 0 To 36
   For ii = 0 To 5
      ySequenza[i, ii] = Str(ii)
   Next
Next
End

Così funziona. Non badare al contenuto dei valori caricati nell'array. É solamente una prova. Ora però si dovrebbe solamente decidere come organizzare i gruppi di dati da caricare con una logica derivata da quella della prova riportata sopra. Per fare ciò è necessario conoscere la tua scelta: vuoi mantenere il formato "Byte" o vuoi passare formato "String"? Fammi sapere in modo da costruire un metodo adatto alla soluzione che sceglierai.
 

[Picavbg]

Riprendo l'argomento immediatamente perchè ieri notte, ho scritto  i cicli di "For ... Next" con un'inesattezza, in quanto l'array è stato già dimensionato in fase di dichiarazione, pertanto il metodo ".Add" non è corretto. Ho perciò modificato nella stessa prova riportata nel post precedente l'istruzione di caricamento nell'array. Perciò, come puoi constatare tu stesso, l'istruzione è diventata:

Codice: [Seleziona]

 ySequenza[i, ii] = Str(ii)

In attesa di prendere sonno ho rivisitato mentalmente il modo più congeniale per procedere col caricamento dell'array finale. Si potrebbero creare più array tutti di 37 elementi valorizzati nella stessa istruzione di dichiarazione. Successivamente, per esempio, nella FMain_new, utilizzare il metodo  "For ... Next"" per trasferife i contenuti degli array provvisori in quello finale di 222 elementi. Farò più tardi una prova e ti darò notizie. 
  

[vuott]

Probabilmente mi sbaglierò, ma io non opterei per un riempimento mediante un ciclo, poiché questo vorrebbe dire un doppio lavoro. Infatti da dove li prenderesti i valori da inserire nella variabile array ? Sicuramente da qualcosa che li contiene; e questa cosa li contiene perché ce l'hai scritti tu.
Si avrebbe, mi sembra, dunque una situazione, nella quale il programma riempie l'array con valori che tu hai già scritto riempiendo qualcos'altro (un file, una variabile).
Ed allora, forse, è meglio scriverli una volta sola.  

[Top Fuel]

Per quanto mi riguarda, String o Byte è al stessa cosa, in fin dei conti a parte i numeri il resto sono solo dei flag, una volta che sai a cosa servono il formato è indifferente.
Sto riprendendo in considerazione l'idea del file, magari scritto in formato stringa, più facile da scrivere rispetto ad un file binario.
Ve lo avevo detto che quando arrivo io pianto i casini...

[Picavbg]

Mettiamola come vgliamo, sta benedetta matrice la dobbiamo pur riempire e la riempiremo una sola volta. Non c'è dubbio che dobbiamo partire da qualcosa di scritto manualmente, sia esso un file o un'area di memoria, o istruzione dopo istruzione. Si tratta solo, secondo me, di individuare la via più conveniente, perchè meno impegnativa per il programmatore. Personalmente sono contrario a scrivere dati in un file che poi mi servirà per leggerlo una sola volta, all'avvio del programma. Io farei così:
Dichiarerei all'inizio del programma la famosa matrice a 2 dimensioni "$Sequenza". Nella FMain_new dichiarerei con Dim le 6 matrici provvisorie contenente ciascuna 37 elementi, coi dati da caricare più avanti nella matrice.
Le prime istruzioni della procedura "_new" si occuperebbero di riempire la matrice "$Sequenza".
A questo punto, se volessi essere proprio zelante, ma non occorre, potrei ripulire il contenuto delle 6 matrici provvisorie.

Codice: gambas [Seleziona]

Public $Sequenza As New String[37, 6]  

Public Sub _new()
Dim i As Integer
Dim ii As Integer

Dim $Matrice0 As String[] = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37"]
Dim $Matrice1 As String[] = ["1°", "2°", "3°", "4°", "5°", "6°", "7°", "8°", "9°", "10°", "11°", "12°", "13°", "14°", "15°", "16°", "17°", "18°", "19°", "20°", "21°", "22°", "23°", "24°", "25°", "26°", "27°", "28°", "29°", "30°", "31°", "32°", "33°", "34°", "35°", "36°", "37°"]
Dim $Matrice2 As String[] = ["1.", "2.", "3.", "4.", "5.", "6.", "7.", "8.", "9.", "10.", "11.", "12.", "13.", "14.", "15.", "16.", "17.", "18.", "19.", "20.", "21.", "22.", "23.", "24.", "25.", "26.", "27.", "28.", "29.", "30.", "31.", "32.", "33.", "34.", "35.", "36.", "37."]
Dim $Matrice3 As String[] = ["1+", "2+", "3+", "4+", "5+", "6+", "7+", "8+", "9+", "10+", "11+", "12+", "13+", "14+", "15+", "16+", "17+", "18+", "19+", "20+", "21+", "22+", "23+", "24+", "25+", "26+", "27+", "28+", "29+", "30+", "31+", "32+", "33+", "34+", "35+", "36+", "37+"]
Dim $Matrice4 As String[] = ["a1", "a2", "a3", "a4", "a5", "a6", "a7", "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15", "a16", "a17", "a18", "a19", "a20", "a21", "a22", "a23", "a24", "a25", "a26", "a27", "a28", "a29", "a30", "a31", "a32", "a33", "a34", "a35", "a36", "a37"]
Dim $Matrice5 As String[] = ["ù1", "ù2", "ù3", "ù4", "ù5", "ù6", "ù7", "ù8", "ù9", "ù10", "ù11", "ù12", "ù13", "ù14", "ù15", "ù16", "ù17", "ù18", "ù19", "ù20", "ù21", "ù22", "ù23", "ù24", "ù25", "ù26", "ù27", "ù28", "ù29", "ù30", "ù31", "ù32", "ù33", "ù34", "ù35", "ù36", "ù37"]

For i = 0 To 36
  $Sequenza[i, 0] = $Matrice0[i]
  $Sequenza[i, 1] = $Matrice1[i]
  $Sequenza[i, 2] = $Matrice2[i]
  $Sequenza[i, 3] = $Matrice3[i]
  $Sequenza[i, 4] = $Matrice4[i]
  $Sequenza[i, 5] = $Matrice5[i]
Next
'----------------------------------------------------------------- istruzioni di prova ------------------------------------------------------------------------------------------------
For i = 0 To 36
   For ii = 0 To 5
      Print "ySequenza[" & i & "," & ii & "]= " & $Sequenza[i, ii]
   Next
Next
End

Risultato del caricamento:

$Sequenza[0,0]= 1
$Sequenza[0,1]= 1°
$Sequenza[0,2]= 1.
$Sequenza[0,3]= 1+
$Sequenza[0,4]= a1
$Sequenza[0,5]= ù1
$Sequenza[1,0]= 2
$Sequenza[1,1]= 2°
$Sequenza[1,2]= 2.
$Sequenza[1,3]= 2+
$Sequenza[1,4]= a2
$Sequenza[1,5]= ù2
$Sequenza[2,0]= 3
$Sequenza[2,1]= 3°
$Sequenza[2,2]= 3.
$Sequenza[2,3]= 3+
$Sequenza[2,4]= a3
$Sequenza[2,5]= ù3
...............................................
$Sequenza[36,0]= 37
$Sequenza[36,1]= 37°
$Sequenza[36,2]= 37.
$Sequenza[36,3]= 37+
$Sequenza[36,4]= a37
$Sequenza[36,5]= ù37

Sempre secondo me, la soluzione ottenuta ora é funzionale e poco impegnativa; infatti, una volta che i dati da distribuire nelle matrici temporanee sono stati già scritti nel programma, il lavoro è praticamente finito. C'è soltanto da distribuirli nelle matrici temporanee, scrivere quelle poche righe di codice, come  dal mio esempio, e fare partire il programma per cominciare col verificare l'esattezza del contenuto di  "$Sequenza"..