help my

[bplus]

Sudoku helps train brain to think logically automatically.
  [ You are not allowed to view this attachment ]  

But cool if you can make your own version. Here is my Sudoku Game:
https://qb64.freeforums.net/thread/109/sudoku-app

Yes I studied Towers of Hanoi too!

Code: QB64: [Select]

1. _TITLE "Towers of Hanoi 1" 'B+ started 2019-02-28
2. '2019-03-02 I've added mBox since post of original  Towers of Hanoi 1" 'B+ started 2019-02-28
3. ' I found I needed to fix both mBox and getClick to clear old mb clicks
4. ' this copy contains the faulty routines getClick and mBox BUT DOES WORK with _DELAY .2 added in here
5. ' should be fixed in, Towers of Hanoi 1 test with new mBox" 'B+ started 2019-03-02
6.  
7. CONST xmax = 800
8. CONST ymax = 600
9. CONST eTitle$ = "Towers of Hanoi Error:"
10. SCREEN _NEWIMAGE(xmax, ymax, 32)
11. _SCREENMOVE 300, 20
12. DIM SHARED nDisks AS INTEGER, hDisk AS INTEGER, wMult AS INTEGER
13. nDisks = 10
14. hDisk = 520 / nDisks
15. wMult = 240 / nDisks
16. DIM SHARED dpal(1 TO nDisks) AS _UNSIGNED LONG
17. FOR i = 1 TO nDisks
18.     dpal(i) = _RGB32(RND * 255, RND * 255, RND * 255)
19. NEXT
20. DIM SHARED tower(1 TO 3, 1 TO nDisks) AS INTEGER
21.  
22. 'init
23. FOR i = 1 TO nDisks
24.     tower(1, i) = nDisks + 1 - i
25. NEXT
26. updateScreen
27. WHILE 1
28.     'message click or press for fromt
29.     fromT = 0: toT = 0
30.     fromT = getTower%
31.     PRINT "from tower "; fromT
32.     IF topDiskValue(fromT) THEN
33.         toT = getTower
34.         PRINT "to tower "; toT
35.         IF toT <> fromT THEN
36.             'PRINT topDiskValue(tot), topDiskValue(fromt)
37.             IF (topDiskValue(toT) > topDiskValue(fromT)) OR topDiskValue(toT) = 0 THEN
38.                 tower(toT, topDiskPlace(toT) + 1) = topDiskValue(fromT)
39.                 'PRINT "topDiskPlace(fromt)"; topDiskPlace(fromt)
40.                 tower(fromT, topDiskPlace(fromT)) = 0
41.                 updateScreen
42.             ELSE
43.                 mBox "Can't place a larger disk on top a smaller one.", eTitle$
44.             END IF
45.         ELSE
46.             mBox "You attempted to move a disk to the same tower.", eTitle$
47.         END IF
48.     ELSE
49.         IF fromT THEN mBox "There is no disk to move in tower" + STR$(fromT), eTitle$
50.         _DELAY .2 '<<<<< damn it I should not need this!!!
51.     END IF
52.     fromT = 0: toT = 0
53.     _LIMIT 30
54. WEND
55. PRINT "Goodbye!"
56. END
57.  
58.  
59. SUB getClick (mx, my, q)
60.     WHILE _MOUSEINPUT: WEND '<<<<<<<<<<  clear previous mouse activity   ITS NOT CLEARING!!!!!!!!!!!!!!
61.     _KEYCLEAR 'clear previous key presses
62.     mx = -1: my = -1: q = 0
63.     DO WHILE mx = -1 AND my = -1
64.         q = _KEYHIT
65.         IF q = 27 OR (q > 31 AND q < 126) THEN _KEYCLEAR: EXIT SUB
66.         i = _MOUSEINPUT: mb = _MOUSEBUTTON(1)
67.         DO WHILE mb 'wait for release
68.             q = _KEYHIT
69.             IF q = 27 OR (q > 31 AND q < 126) THEN EXIT SUB
70.             i = _MOUSEINPUT: mb = _MOUSEBUTTON(1): mx = _MOUSEX: my = _MOUSEY
71.             _LIMIT 1000
72.         LOOP
73.         _LIMIT 1000
74.     LOOP
75. END SUB
76.  
77. SUB updateScreen
78.     CLS
79.     LINE (0, 580)-STEP(xmax, 0)
80.     FOR t = 1 TO 3
81.         FOR i = 1 TO nDisks
82.             IF tower(t, i) THEN
83.                 xhalf = (tower(t, i) * wMult) / 2
84.                 LINE (t * 250 - xhalf - 125, 580 - hDisk * i)-STEP(2 * xhalf, hDisk), dpal(tower(t, i)), BF
85.             END IF
86.         NEXT
87.     NEXT
88.     _PRINTSTRING (0, ymax - 18), SPACE$(11) + "Tower #1" + SPACE$(24) + "Tower #2" + SPACE$(23) + "Tower #3"
89. END SUB
90.  
91. FUNCTION topDiskValue (t)
92.     FOR i = nDisks TO 1 STEP -1
93.         IF tower(t, i) THEN topDiskValue = tower(t, i): EXIT FUNCTION
94.     NEXT
95. END FUNCTION
96.  
97. FUNCTION topDiskPlace (t)
98.     FOR i = nDisks TO 1 STEP -1
99.         IF tower(t, i) THEN topDiskPlace = i: EXIT FUNCTION
100.     NEXT
101. END FUNCTION
102.  
103. FUNCTION getTower% ()
104.     getClick mx, my, q
105.     IF ABS(150 - mx) < 125 THEN t = 1
106.     IF ABS(400 - mx) < 125 THEN t = 2
107.     IF ABS(650 - mx) < 125 THEN t = 3
108.     IF q THEN
109.         IF INSTR("123", CHR$(q)) > 0 THEN t = INSTR("123", CHR$(q))
110.         IF CHR$(q) = "q" OR q = 27 THEN END
111.     END IF
112.     getTower% = t
113. END FUNCTION
114.  
115. 'title$ limit is 55 chars, all lines are 58 chars max
116. ' Develop from mBox v 2018-10-27 color change, fan fix, cls
117. SUB mBox (m$, title$)
118.  
119.     'first screen dimensions items to restore at exit
120.     DIM curRow AS INTEGER, curCol AS INTEGER
121.     DIM sw AS INTEGER, sh AS INTEGER, fg AS _UNSIGNED LONG, bg AS _UNSIGNED LONG
122.     DIM curScrn AS LONG, backScrn AS LONG, mbx AS LONG 'some handles
123.     DIM ti AS INTEGER, limit AS INTEGER 'ti = text index for t$(), limit is number of chars per line
124.     DIM i AS INTEGER, j AS INTEGER, ff AS _BIT, add AS _BYTE 'index, flag and
125.     DIM bxH AS INTEGER, bxW AS INTEGER 'first as cells then as pixels
126.     DIM mb AS INTEGER, mx AS INTEGER, my AS INTEGER, mi AS INTEGER, grabx AS INTEGER, graby AS INTEGER
127.     DIM tlx AS INTEGER, tly AS INTEGER 'top left corner of message box
128.     DIM lastx AS INTEGER, lasty AS INTEGER, r AS INTEGER, kh AS LONG
129.     DIM b$, c$, tail$, d$
130.     DIM DBLU AS _UNSIGNED LONG, LBLU AS _UNSIGNED LONG, WHT AS _UNSIGNED LONG, BLK AS _UNSIGNED LONG
131.     DBLU = &HFF000066
132.     LBLU = &HFFB0A0FF
133.     BLK = &HFF000000
134.     WHT = &HFFFFFFFF
135.  
136.     curRow = CSRLIN
137.     curCol = POS(0)
138.     sw = _WIDTH
139.     sh = _HEIGHT
140.     fg = _DEFAULTCOLOR
141.     bg = _BACKGROUNDCOLOR
142.     'screen snapshot
143.     curScrn = _DEST
144.     backScrn = _NEWIMAGE(sw, sh, 32)
145.     _PUTIMAGE , curScrn, backScrn
146.  
147.     'setup t$() to store strings with ti as index, linit 58 chars per line max, b$ is for build
148.     REDIM t$(0): ti = 0: limit = 58: b$ = ""
149.     FOR i = 1 TO LEN(m$)
150.         c$ = MID$(m$, i, 1)
151.         'are there any new line signals, CR, LF or both? take CRLF or LFCR as one break but dbl LF or CR means blank line
152.         SELECT CASE c$
153.             CASE CHR$(13) 'load line
154.                 IF MID$(m$, i + 1, 1) = CHR$(10) THEN i = i + 1
155.                 t$(ti) = b$: b$ = "": ti = ti + 1: REDIM _PRESERVE t$(ti)
156.             CASE CHR$(10)
157.                 IF MID$(m$, i + 1, 1) = CHR$(13) THEN i = i + 1
158.                 t$(ti) = b$: b$ = "": ti = ti + 1: REDIM _PRESERVE t$(ti)
159.             CASE ELSE
160.                 IF c$ = CHR$(9) THEN c$ = SPACE$(4): add = 4 ELSE add = 1
161.                 IF LEN(b$) + add > limit THEN
162.                     tail$ = "": ff = 0
163.                     FOR j = LEN(b$) TO 1 STEP -1 'backup until find a space, save the tail end for next line
164.                         d$ = MID$(b$, j, 1)
165.                         IF d$ = " " THEN
166.                             t$(ti) = MID$(b$, 1, j - 1): b$ = tail$ + c$: ti = ti + 1: REDIM _PRESERVE t$(ti)
167.                             ff = 1 'found space flag
168.                             EXIT FOR
169.                         ELSE
170.                             tail$ = d$ + tail$ 'the tail grows!
171.                         END IF
172.                     NEXT
173.                     IF ff = 0 THEN 'no break? OK
174.                         t$(ti) = b$: b$ = c$: ti = ti + 1: REDIM _PRESERVE t$(ti)
175.                     END IF
176.                 ELSE
177.                     b$ = b$ + c$ 'just keep building the line
178.                 END IF
179.         END SELECT
180.     NEXT
181.     t$(ti) = b$
182.     bxH = ti + 3: bxW = limit + 2
183.  
184.     'draw message box
185.     mbx = _NEWIMAGE(60 * 8, (bxH + 1) * 16, 32)
186.     _DEST mbx
187.     COLOR DBLU, WHT
188.     LOCATE 1, 1: PRINT LEFT$(SPACE$((bxW - LEN(title$) - 3) / 2) + title$ + SPACE$(bxW), bxW)
189.     COLOR _RGB32(225, 225, 255), _RGB32(200, 0, 0)
190.     LOCATE 1, bxW - 2: PRINT " X "
191.     COLOR DBLU, LBLU
192.     LOCATE 2, 1: PRINT SPACE$(bxW);
193.     FOR r = 0 TO ti
194.         LOCATE 1 + r + 2, 1: PRINT LEFT$(SPACE$((bxW - LEN(t$(r))) / 2) + t$(r) + SPACE$(bxW), bxW);
195.     NEXT
196.     LOCATE 1 + bxH, 1: PRINT SPACE$(limit + 2);
197.  
198.     'now for the action
199.     _DEST curScrn
200.  
201.     'convert to pixels the top left corner of box at moment
202.     bxW = bxW * 8: bxH = bxH * 16
203.     tlx = (sw - bxW) / 2: tly = (sh - bxH) / 2
204.     lastx = tlx: lasty = tly
205.     'now allow user to move it around or just read it
206.     WHILE 1
207.         CLS
208.         _PUTIMAGE , backScrn
209.         _PUTIMAGE (tlx, tly), mbx, curScrn
210.         _DISPLAY
211.         WHILE _MOUSEINPUT: WEND
212.         mx = _MOUSEX: my = _MOUSEY: mb = _MOUSEBUTTON(1)
213.         IF mb THEN
214.             IF mx >= tlx AND mx <= tlx + bxW AND my >= tly AND my <= tly + 16 THEN 'mouse down on title bar
215.                 IF mx >= tlx + bxW - 24 THEN EXIT WHILE
216.                 grabx = mx - tlx: graby = my - tly
217.                 DO WHILE mb 'wait for release
218.                     mi = _MOUSEINPUT: mb = _MOUSEBUTTON(1)
219.                     mx = _MOUSEX: my = _MOUSEY
220.                     IF mx - grabx >= 0 AND mx - grabx <= sw - bxW AND my - graby >= 0 AND my - graby <= sh - bxH THEN
221.                         'attempt to speed up with less updates
222.                         IF ((lastx - (mx - grabx)) ^ 2 + (lasty - (my - graby)) ^ 2) ^ .5 > 10 THEN
223.                             tlx = mx - grabx: tly = my - graby
224.                             CLS
225.                             _PUTIMAGE , backScrn
226.                             _PUTIMAGE (tlx, tly), mbx, curScrn
227.                             lastx = tlx: lasty = tly
228.                             _DISPLAY
229.                         END IF
230.                     END IF
231.                     _LIMIT 600
232.                 LOOP
233.             END IF
234.         END IF
235.         kh = _KEYHIT
236.         SELECT CASE kh
237.             CASE 27, 13, 32: _DELAY .2: EXIT WHILE
238.         END SELECT
239.         _LIMIT 60
240.     WEND
241.     'put things back
242.     COLOR fg, bg: CLS
243.     _PUTIMAGE , backScrn
244.     _DISPLAY
245.     _FREEIMAGE backScrn
246.     _FREEIMAGE mbx
247.     _AUTODISPLAY
248.     _KEYCLEAR
249.     LOCATE curRow, curCol
250. END SUB
251.  
252.  

[Kiara87]

@bplu a true master in programming
I hope one day I will become as good as you

i am trying to solve the sudoku even though i set it to easy mode
it is still very difficult for me

[SMcNeill]

If it helps, Kiara, remember this -- All computer programming breaks down to 3 steps:

1) Step by step commands
2) Decision making
3) Repetition

Take any problem facing you, and you can break its solution down to those 3 steps (including life problems).  Let's say I tell you, "Make me a peanut butter sandwich."   How do you accomplish that task?

Get up.
Go in kitchen.
Get a knife.
Get bread.
Get peanut butter.
Open bread, remove a slice.
Put knife in peanut butter.
Remove knife from peanut butter.
Wipe knife on bread.
Put down knife.
Remove slice of bread from pack.
Place bread on bread.

And there's the biggest problem programmers usually face -- we think "fix a sandwich", and we do it.  The computer has to have that instruction broken down step-by-step, to accomplish the same task...  It's not the complexity of the problem that confound us; it's the simplicity of the computer.

Even with the above set of instructions, it's probably not enough for your pet robot to make that sandwich.  "Get up" implies it was down somewhere.  "Go in kitchen" is vague.  From Where?  How many steps?  How many turns around corners, or up and down steps?  Whose kitchen?

The trick is to break your problem down into smaller stages, and then see if there's a set of computer commands to fulfill those needs.  If not, break those needs down smaller, until there are.

For example let's say I tell you to, "Print the contents of a file for me."

Breaking that order down to its components, we have to:

Choose a file.
Open that file.
Load the contents of that file in memory.
Print that file.
Repeat the last two steps until the whole file is printed.
Close the file.

Now, we have a basic step-by-step road map of how our program will look.

INPUT "Give me the name of the file you want to print ", filename$
OPEN filename$ FOR INPUT AS #1
DO
    LINE INPUT #1, text$
    PRINT text$
LOOP UNTIL EOF(1)
CLOSE #1


Take your complex problem and break it down to its step-by-step components.  If you can do that, you can write your own computer programs.

[_vince]

Take any problem facing you, and you can break its solution down to those 3 steps (including life problems).  Let's say I tell you, "Make me a peanut butter sandwich."   How do you accomplish that task?

I think Steve's trying to say leave the coding to bplus and make him a sandwich

[bplus]

LOL I do like simple things like Peanut Butter and Jelly sandwiches. Gots to have the jelly though!

I guess I like making things simple, certainly things presented simply. But what I really like is thinking of something and seeing it work on the computer screen. That sense of power overcomes all the tedium and frustration that comes from practice with Basic.

I've been working on Sudoku for way over a year, just to check and see if my advanced level puzzles generated from my program are both unique and solvable. I think I have unique but solvable, still uncertain about that one.

Tower of Hanoi is boring after you "get" what it takes to solve the puzzle, it's about 10 or 20 steps repeated over and over in a certain order, so easy for a human to loose track of that order and start going backwards again! 🤦‍♂️

[Kiara87]

If it helps, Kiara, remember this -- All computer programming breaks down to 3 steps:

1) Step by step commands
2) Decision making
3) Repetition

Take any problem facing you, and you can break its solution down to those 3 steps (including life problems).  Let's say I tell you, "Make me a peanut butter sandwich."   How do you accomplish that task?

Get up.
Go in kitchen.
Get a knife.
Get bread.
Get peanut butter.
Open bread, remove a slice.
Put knife in peanut butter.
Remove knife from peanut butter.
Wipe knife on bread.
Put down knife.
Remove slice of bread from pack.
Place bread on bread.

And there's the biggest problem programmers usually face -- we think "fix a sandwich", and we do it.  The computer has to have that instruction broken down step-by-step, to accomplish the same task...  It's not the complexity of the problem that confound us; it's the simplicity of the computer.

Even with the above set of instructions, it's probably not enough for your pet robot to make that sandwich.  "Get up" implies it was down somewhere.  "Go in kitchen" is vague.  From Where?  How many steps?  How many turns around corners, or up and down steps?  Whose kitchen?

The trick is to break your problem down into smaller stages, and then see if there's a set of computer commands to fulfill those needs.  If not, break those needs down smaller, until there are.

For example let's say I tell you to, "Print the contents of a file for me."

Breaking that order down to its components, we have to:

Choose a file.
Open that file.
Load the contents of that file in memory.
Print that file.
Repeat the last two steps until the whole file is printed.
Close the file.

Now, we have a basic step-by-step road map of how our program will look.

INPUT "Give me the name of the file you want to print ", filename$
OPEN filename$ FOR INPUT AS #1
DO
    LINE INPUT #1, text$
    PRINT text$
LOOP UNTIL EOF(1)
CLOSE #1


Take your complex problem and break it down to its step-by-step components.  If you can do that, you can write your own computer programs.

thanks steven for your suggestion



I also see that you are a good programmer

It is always an honor to have advice from you as an expert in programming

[Kiara87]

LOL I do like simple things like Peanut Butter and Jelly sandwiches. Gots to have the jelly though!

I guess I like making things simple, certainly things presented simply. But what I really like is thinking of something and seeing it work on the computer screen. That sense of power overcomes all the tedium and frustration that comes from practice with Basic.

I've been working on Sudoku for way over a year, just to check and see if my advanced level puzzles generated from my program are both unique and solvable. I think I have unique but solvable, still uncertain about that one.

Tower of Hanoi is boring after you "get" what it takes to solve the puzzle, it's about 10 or 20 steps repeated over and over in a certain order, so easy for a human to loose track of that order and start going backwards again! 🤦‍♂️

you are really good 
I'm also following your advice by playing with sudoku
this game is fantastic

I really like how you program I want to become as good as you
you can create anything with QB64

you are my master idol

[bplus]

you are my master idol

Kind of embarrassing, kind of like it :)  Steve's OK too!

Here are some fun puzzles from a real master:  http://paulbourke.net/fun/
I just figured out the first one on the easy list.

Here is Terry Richie's QB64 tutorial that TempodiBasic and I can help you with :)
https://www.qb64sourcecode.com

Be sure to bookmark this:
https://www.qb64.org/wiki/Main_Page

Just 10,000 more hours of fun!

[TempodiBasic]

Salve Kiara87
sembra che nonostante le difficoltà non demordi, brava questa è la prima dote di un buon programmatore la tenacia o la costanza se preferisci.

Dal mio codice vedo che non sei riuscita ad andare verso i tuoi obiettivi:
1 per ogni estrazione evidenziare le coppie di  numeri distanti 30 unità
2 salvare questa elaborazione per usarla altrove....

la  tua tenacia mi ha spinto a fornirti il compito risolto.... con tutta una serie di commenti in italiano... ma se vuoi attingere alla vera conoscenza nella programmazione impara un po' di inglese sia perchè le novità le trovi pubblicate in inglese perchè è una lingua universale... sia perchè puoi accedere alle risorse di tutto il mondo della programmazione.

Steve Bplus e _Vince ti hanno dato degli ottimi consigli sotto forma di lezioni che sembrano per principianti, ed in parte lo sono, ma sono sempre valide... sai come quando impari le 4 operazioni alle elementari ma le userai anche quando farai i calcoli di ingegneria o di fisica o di statistica combinatoria (come quella che stai cercando di sviluppare tu qui relativamente al gioco del lotto)

lo stile di programmazione che hai adottato tu con il tuo file Dafinire8.bas è detto spaghetti code perchè l'uso molteplice e continuo del GOTO se fosse evidenziato da un filo che segue il flusso di esecuzione del programma disegnerebbe una matassa di spaghetti ingarbugliati...
può funzionare, ma è molto difficile da correggere e da capire perchè ogni modifica che apporti non sai bene dove e cosa farà. Quindi difficile da costruire in maniera funzionale, difficile da capire quando lo rileggi dopo tempo, difficile da modificare per una espansione o per un adattamento ad un altro compito similare.
 
Lo stile di programmazione usato dai mitici amici Steve Bplus _Vince e tutti gli altri programmatori di questa community è prevalentemente modulare giacchè Qbasic e QB64 sono linguaggi procedurali o modulari... lo schema che ti ho postato come immagine in questo thread ti indica come progettare un programma per scriverlo in maniera efficiente, rapido, che funzioni, facile da capire, facile da modificare, facile da adattare....
è lo stesso suggerimento di Steve di suddividere l'azione che deve compiere il tuo programma in tante piccole azioni sequenziali e limitare ciascuna di queste in un blocco di codice detto procedura o subroutine o funzione (quando ti da indietro un risultato), e poi se possibile suddividere queste in ulteriori procedure più piccole fino a raggiungere un livello accettabile di semplicità. Fatto questo puoi iniziare a tradurre questo procedimento che si chiama ALGORITMO in CODICE SORGENTE ossia codice che usa parole tipiche di un linguaggio di programmazione e qui tu hai scelto il QB64.  Infine con la compilazione il compilatore traduce questo codice ad alto livello in codice binario (una sequenza di 0 e 1 ) che ha significato per la macchina computer e che esegue sempre e solo quello che tu gli hai detto di fare. Mai niente di più. Quindi quando non ottieni il risultato o l'algoritmo è sbagliato o il codice sorgente è sbagliato. In entrambi i casi l' errore è del programmatore. ;-)

e dopo tante chiacchiere ecco il codice sorgente in QB64 del programma cerca coppie di numeri a distanza di 30 unità nella estrazione del lotto leggendo i dati di estrazione da un file di testo in cui ogni riga contiene i dati come una sola cifra. (questa ti sembra una definizione più chiara del programma e di ciò che fa?)
1.
prendi i dati -->
    leggi i dati dal file e memorizzali in RAM (mediante variabili)-->
    apri il file di dati e leggi i dati e copiali in variabile/variabili dopo aver dichiarato le variabili


2.
analizza i dati estraendo i numeri distanti 30 in ogni estrazione lotto --> la singola sequenza della singola estrazione è formata da 4 cifre iniziali di riga che sono il numero estrazione e da 110 cifre che sono i numeri estratti (ogni numero estratto va da 01 a 90 rappresentati da 2 cifre) le ruote di estrazioni sono 11 e ogni estrazione ha 5 cifre estratte quindi 2*5*11 = 110

Accedendo al file in maniera binaria ossia a basso livello dobbiamo considerare che il segno che di andare a capo corrisponde ad altri 2 carattere CR+LF che corrispondono ai numeri ASCII 13 e 10, quindi accedendo in maniera binaria a basso livello ogni riga termina con questa coppia di numeri ASCII e quindi ogni riga è lunga in modalità testo 4+110 = 114 mentre in modalità binaria 4+110+CR+LF = 116 caratteri

3.
stampa e memorizza i dati estratti --> mostra con colore diverso a video e scrivi su file i dati estratti
ho trovato molto più semplice scrivere tutta la griglia di numeri non analizzati con il colore dei numeri NON distanti 30 e riscrivere poi in secondo tempo i numeri con distanza 30 in altro colore. Mentre la griglia di lettura ossia le ruote e il numero di estrazione hanno un colore diverso per meglio distinguerle. Nella stessa procedura di cerca distanza 30 ho messo la memorizzazione su file degli stessi, mentre il numero estrazione viene segnato nel ciclo (loop) principale.

Code: QB64: [Select]

1. ' Programma lotto di kiara87
2. ' il programma legge i dati (numeri estratti da un file.dat)
3. ' e permette di vedere  le estrazioni a video
4. ' i numeri con distanza 30 sono evidenziati con colore rosso
5. ' questi numeri vengono memorizzati e stampati
6.  
7. ' Nota 1: sono d'accordo con Bplus e' molto piu'
8. ' rapido lavorare con dati in RAM che con dati su Disco HDD/SSD/USB/CD/DVD
9.  
10. ' valori COSTANTI  generali Vero e Falso
11. CONST True = -1, False = NOT True
12. ' le 11 ruote del lotto
13. CONST Bari = 1, Cagliari = 2, Firenze = 3, Genova = 4, Milano = 5
14. CONST Napoli = 6, Palermo = 7, Roma = 8, Torino = 9, Venezia = 10, Nazionale = 11
15. CONST Cifra = 2 ' ogni numero estratto e' una cifra di due caratteri (01-90)
16.  
17. DIM a AS STRING ' una stringa per leggere i dati dal file
18.  
19. ' salta al sottoprogramma LeggiFile delimitato
20. ' dalla Label LeggiFIle e dal RETURN
21. GOSUB LeggiFile
22.  
23. ' verifica che tutto il file sia letto
24. 'FOR b = 1 TO LEN(a) - 116 STEP 116
25. '    PRINT MID$(a, b, 116)
26. '    '    PRINT INSTR(b, a, CHR$(13))
27. '    _DELAY .1
28. 'NEXT b
29.  
30.  
31.  
32. ' il ciclo DO...LOOP UNTIL condizione e' un modo piu' moderno
33. ' rispetto a Etichetta: .... IF condizione GOTO Etichetta
34. b = 1
35. z$ = " "
36. OPEN "distanza30.dat" FOR APPEND AS #2
37. DO
38.     IF z$ <> "" THEN
39.         CLS ' questo risolve un glitch di output sullo schermo
40.         ' in alternativa alla riga sopra CLS nel sottoblocco
41.         ' MostraEstratti va stampata la stringa estratto e
42.         ' non il suo valore corrispondente ottenuto con VAL
43.         GOSUB MostraRuote ' scrive il nome delle ruote del lotto
44.         GOSUB MostraEstratti
45.     END IF
46.     ' prende l'input dell'utente
47.     z$ = UCASE$(INKEY$) ' Z$ mantiene il maiuscolo di Inkey$
48.     IF z$ = "+" AND b < (LEN(a) - 116) THEN b = b + 116
49.     IF z$ = "-" AND b > 116 THEN b = b - 116
50. LOOP UNTIL z$ = "Q"
51. CLOSE #2
52.  
53. END ' indica la fine logica del programma
54.  
55.  
56. '-----------------------AREA sottoprogrammi /SUBroutines
57.  
58. ' questa etichetta /label indica il punto di inizio
59. ' del sottoprogramma (SUBroutine) LeggiFile scritto con vecchio stile GOSUB
60. ' che usa una etichetta/label e un RETURN per riprendere da dove si era interotto
61. ' nota1: un metodo ancora piu' antico e' il salto con GOTO
62. '        che richiede una seconda etichetta per ritornare nel MAIN o programma principale
63. ' nota2: un metodo migliore e' SUB nomeroutine....END SUB
64. '        perche' permette la localizzazione delle variabili
65. LeggiFile:
66. 'se non trova lotto.dat segnala l'errore a video e termina il programma
67. IF NOT _FILEEXISTS("lotto.dat") THEN PRINT "File non trovato": END
68. '<--------------------
69. ' questo metodo e' piu' lento
70. ' apre il file lotto.dat per leggere in maniera sequenziale i dati
71. 'OPEN "lotto.dat" FOR INPUT AS #1
72. 'LINE INPUT #1, a  ' riempe la variabile a con una riga intera di valori
73. '<--------------------
74.  
75. ' apre lotto.dat per leggerlo in maniera binaria
76. OPEN "lotto.dat" FOR BINARY AS #1
77. a = SPACE$(LOF(1)) ' riempe la variabile a di spazi fino alla grandezza in byte del file aperto
78. GET #1, , a ' legge con una unica operazione il file e lo pone nella variabiel a
79. CLOSE #1 ' chiude il file appena letto
80. ' indica il termine della SUBroutine LeggiFile
81. ' e RITORNA alla riga di codice successiva al salto GOSUB
82. RETURN
83.  
84. 'seconda SUBroutine /sottoprogramma
85. MostraRuote:
86. COLOR 7, 6
87. LOCATE 1, 1
88. PRINT "BARI"
89. LOCATE 3, 1
90. PRINT "CAGLIARI"
91. LOCATE 5, 1
92. PRINT "FIRENZE"
93. LOCATE 7, 1
94. PRINT "GENOVA"
95. LOCATE 9, 1
96. PRINT "MILANO"
97. LOCATE 11, 1
98. PRINT "NAPOLI"
99. LOCATE 13, 1
100. PRINT "PALERMO"
101. LOCATE 15, 1
102. PRINT "ROMA"
103. LOCATE 17, 1
104. PRINT "TORINO"
105. LOCATE 19, 1
106. PRINT "VENEZIA"
107. LOCATE 21, 1
108. PRINT "NAZIONALE"
109. LOCATE 23, 1
110. PRINT "premi q per terminare, + avanti, - indietro"
111.  
112. ' indica il termine della SUBroutine MostraRuote
113. ' e RITORNA alla riga di codice successiva al salto GOSUB
114. RETURN
115.  
116. 'terzo sottoprogramma o SUBroutine
117. MostraEstratti:
118.  
119. ' le prime 4 cifre sembrano essere in numero della estrazione
120. LOCATE 1, 40
121. PRINT "estraz.num "; MID$(a, b, 4)
122. PRINT #2, "estraz.num "; MID$(a, b, 4)
123. DIM x AS INTEGER, y AS INTEGER, V AS INTEGER, A1 AS STRING
124. y = 13 ' prima posizione per il carattere da stampare
125. FOR x = 1 TO 5 STEP 1 ' questo ciclo   FOR e' di 5 perche' ogni ruota ha 5 estrazioni
126.     A1 = "" ' resetto a1 per il prossimo giro
127.     FOR V = Bari TO Nazionale ' per tutte le ruote
128.         COLOR 15, 0
129.         'posiziona il cursore
130.         LOCATE (V * 2) - 1, y
131.         ' scrive il numero estratto
132.         PRINT VAL(MID$(a, (V - 1) * 10 + 5 + ((x - 1) * 2) + (b - 1), Cifra)); " ";
133.         A1 = A1 + (MID$(a, (V - 1) * 10 + 5 + ((x - 1) * 2) + (b - 1), Cifra))
134.     NEXT V
135.     GOSUB Mostra30
136.     y = POS(0)
137. NEXT x
138. ' indica il termine della SUBroutine MostraEstratti
139. ' e RITORNA alla riga di codice successiva al salto GOSUB
140. RETURN
141.  
142.  
143. Mostra30:
144. DIM v1 AS INTEGER, v2 AS INTEGER
145. FOR v1 = Bari TO Venezia ' per tutte le ruote
146.     FOR v2 = v1 + 1 TO Nazionale
147.         IF ABS(VAL(MID$(a, (v1 - 1) * 10 + 5 + ((x - 1) * 2) + (b - 1), Cifra)) - VAL(MID$(a, (v2 - 1) * 10 + 5 + ((x - 1) * 2) + (b - 1), Cifra))) = 30 THEN
148.             COLOR 1, 0
149.             'posiziona                                                                      il cursore
150.             LOCATE (v1 * 2) - 1, y
151.             ' scrive il numero estratto
152.             PRINT VAL(MID$(a, (v1 - 1) * 10 + 5 + ((x - 1) * 2) + (b - 1), Cifra)); " ";
153.             PRINT #2, (MID$(a, (v1 - 1) * 10 + 5 + ((x - 1) * 2) + (b - 1), Cifra))
154.             'posiziona                                                                      il cursore
155.             LOCATE (v2 * 2) - 1, y
156.             ' scrive il numero estratto
157.             PRINT VAL(MID$(a, (v2 - 1) * 10 + 5 + ((x - 1) * 2) + (b - 1), Cifra)); " ";
158.             PRINT #2, MID$(a, (v2 - 1) * 10 + 5 + ((x - 1) * 2) + (b - 1), Cifra)
159.         END IF
160.     NEXT v2
161. NEXT v1
162. COLOR 15, 0
163. ' indica il termine della SUBroutine MostraEstratti
164. ' e RITORNA alla riga di codice successiva al salto GOSUB
165. RETURN

e questo è lo screenshot
  [ You are not allowed to view this attachment ]  

osservazioni:
-lavorare in RAM è molto più veloce che lavorare su disco
-accedere al file in maniera binaria ti permette di caricare tutto il file in RAM con una unica istruzione
-con MID$ sapendo la struttura della singola estrazione del lotto |numero di 4 cifre|estrazioni di 110cifre 1ruota5estrazioni2ruota5estrazioni...11ruota5estrazioni|acapo CR+LF| puoi navigare attraverso i dati con sicurezza

-una alternativa validissima è l'uso di un array dinamico

Code: QB64: [Select]

1. REDIM Estrazioni (1 to Max) AS STRING
2.  

-una altra alternativa validissima è l'uso di una UDT con TYPE---END TYPE con un array dinamico
ad esempio

Code: QB64: [Select]

1. TYPE Estrazione
2.    Numestrazione AS STRING * 4
3.    EstrattiBari AS STRING * 10
4.    EstrattiCagliari AS STRING * 10
5.    EstrattiFirenze AS STRING * 10
6.    ...
7.    EstrattiNazionale AS STRING * 10
8. END TYPE
9.  
10. REDIM Lotto (1 to Max) AS Estrazione
11.  

Buona avventura nel mondo della programmazione e non cadere nella trappola dei principianti che cambiano continuamente linguaggio perchè pensano di poter farme meglio con una altro rispetto a quello che stanno imparando... ;)

[Kiara87]

grazie @TempodiBasic
anche te sei una macchinetta di programmazione il tuo stile di programmazione e ottimo
solamente che sono io che ancora non riesco a leggere bene il codice essendo ancora alle prime armi
grazie per la tua spiegazione sei molto gentile e grazie per avermi imparato di scrivere il codice in pseudocodice
poi il problema e' quello di convertire in codice sorgente pero' credo che con il tempo imparo anche questo
tutte le tue spiegazioni servono e' cerchero di mettere in atto anche se alcuni punti non riesco a capire anche se sono bene dettagliate
hai ragione il mio primo codice era codice spaghetti inizialmente non sapevo il significato sono andato su internet e ho capito cosa intendi
troppi goto  un codice con troppi nodi che non si riesce a leggere come ho capito anche se esiste istruzione goto meglio evitarla
ho visto codice append che crea un file che poi lo rilegge devo ancora studiare anche questo

la cosa che mi viene molto difficile da capire e' questa parte qui

Code: QB64: [Select]

1. LOCATE 1, 40
2. PRINT "estraz.num "; MID$(a, b, 4)
3. PRINT #2, "estraz.num "; MID$(a, b, 4)
4. DIM x AS INTEGER, y AS INTEGER, V AS INTEGER, A1 AS STRING
5. y = 13 ' prima posizione per il carattere da stampare
6. FOR x = 1 TO 5 STEP 1 ' questo ciclo   FOR e' di 5 perche' ogni ruota ha 5 estrazioni
7.     A1 = "" ' resetto a1 per il prossimo giro
8.     FOR V = Bari TO Nazionale ' per tutte le ruote
9.         COLOR 15, 0
10.         'posiziona il cursore
11.         LOCATE (V * 2) - 1, y
12.         ' scrive il numero estratto
13.         PRINT VAL(MID$(a, (V - 1) * 10 + 5 + ((x - 1) * 2) + (b - 1), Cifra)); " ";
14.         A1 = A1 + (MID$(a, (V - 1) * 10 + 5 + ((x - 1) * 2) + (b - 1), Cifra))
15.     NEXT V
16.     GOSUB Mostra30
17.     y = POS(0)
18. NEXT x
19.  

come voi programmatori posizionate i numeri con i locate e li distanziate
esempio: mentre io usavo locate 1,10 ecc..
e un altro punto che devo ancora adattarmi  esempio io il file lo leggevo con la variabile a e mid$ ma devo capire la funzione di altri variabili aggiunti -->
PRINT VAL(MID$(a, (V - 1) * 10 + 5 + ((x - 1) * 2) + (b - 1), Cifra)); " ";
        A1 = A1 + (MID$(a, (V - 1) * 10 + 5 + ((x - 1) * 2) + (b - 1), Cifra))

credo che per capirle cerchero di modificare i valori

una domanda magari banale per saper programmare ci vuole conoscenza di matematica? oppure la conoscenda di matematica ci vuole per questo tipo di programma?
per conoscenza matematica non intendo quella elementare ma superiore alle scuole basi

ancora grazie e' sei stato moltissimo di aiuto a spiegare la tua esperienza e condividerla qui
ovviamente si deve studiare per imparare
io ricordo che le prime volte domandavo sui forum quanto tempo ci vuole per imparare a programmare
adesso forse la risposta e' dipende quante ore studi al giorno
io non ho tanto tempo magari 1 oppure 2 ore al giorno
magari ci impiego di piu'
ma non mollerò

Salve Kiara87
sembra che nonostante le difficoltà non demordi, brava questa è la prima dote di un buon programmatore la tenacia o la costanza se preferisci.

Dal mio codice vedo che non sei riuscita ad andare verso i tuoi obiettivi:
1 per ogni estrazione evidenziare le coppie di  numeri distanti 30 unità
2 salvare questa elaborazione per usarla altrove....

la  tua tenacia mi ha spinto a fornirti il compito risolto.... con tutta una serie di commenti in italiano... ma se vuoi attingere alla vera conoscenza nella programmazione impara un po' di inglese sia perchè le novità le trovi pubblicate in inglese perchè è una lingua universale... sia perchè puoi accedere alle risorse di tutto il mondo della programmazione.

Steve Bplus e _Vince ti hanno dato degli ottimi consigli sotto forma di lezioni che sembrano per principianti, ed in parte lo sono, ma sono sempre valide... sai come quando impari le 4 operazioni alle elementari ma le userai anche quando farai i calcoli di ingegneria o di fisica o di statistica combinatoria (come quella che stai cercando di sviluppare tu qui relativamente al gioco del lotto)

lo stile di programmazione che hai adottato tu con il tuo file Dafinire8.bas è detto spaghetti code perchè l'uso molteplice e continuo del GOTO se fosse evidenziato da un filo che segue il flusso di esecuzione del programma disegnerebbe una matassa di spaghetti ingarbugliati...
può funzionare, ma è molto difficile da correggere e da capire perchè ogni modifica che apporti non sai bene dove e cosa farà. Quindi difficile da costruire in maniera funzionale, difficile da capire quando lo rileggi dopo tempo, difficile da modificare per una espansione o per un adattamento ad un altro compito similare.
 
Lo stile di programmazione usato dai mitici amici Steve Bplus _Vince e tutti gli altri programmatori di questa community è prevalentemente modulare giacchè Qbasic e QB64 sono linguaggi procedurali o modulari... lo schema che ti ho postato come immagine in questo thread ti indica come progettare un programma per scriverlo in maniera efficiente, rapido, che funzioni, facile da capire, facile da modificare, facile da adattare....
è lo stesso suggerimento di Steve di suddividere l'azione che deve compiere il tuo programma in tante piccole azioni sequenziali e limitare ciascuna di queste in un blocco di codice detto procedura o subroutine o funzione (quando ti da indietro un risultato), e poi se possibile suddividere queste in ulteriori procedure più piccole fino a raggiungere un livello accettabile di semplicità. Fatto questo puoi iniziare a tradurre questo procedimento che si chiama ALGORITMO in CODICE SORGENTE ossia codice che usa parole tipiche di un linguaggio di programmazione e qui tu hai scelto il QB64.  Infine con la compilazione il compilatore traduce questo codice ad alto livello in codice binario (una sequenza di 0 e 1 ) che ha significato per la macchina computer e che esegue sempre e solo quello che tu gli hai detto di fare. Mai niente di più. Quindi quando non ottieni il risultato o l'algoritmo è sbagliato o il codice sorgente è sbagliato. In entrambi i casi l' errore è del programmatore. ;-)

e dopo tante chiacchiere ecco il codice sorgente in QB64 del programma cerca coppie di numeri a distanza di 30 unità nella estrazione del lotto leggendo i dati di estrazione da un file di testo in cui ogni riga contiene i dati come una sola cifra. (questa ti sembra una definizione più chiara del programma e di ciò che fa?)
1.
prendi i dati -->
    leggi i dati dal file e memorizzali in RAM (mediante variabili)-->
    apri il file di dati e leggi i dati e copiali in variabile/variabili dopo aver dichiarato le variabili


2.
analizza i dati estraendo i numeri distanti 30 in ogni estrazione lotto --> la singola sequenza della singola estrazione è formata da 4 cifre iniziali di riga che sono il numero estrazione e da 110 cifre che sono i numeri estratti (ogni numero estratto va da 01 a 90 rappresentati da 2 cifre) le ruote di estrazioni sono 11 e ogni estrazione ha 5 cifre estratte quindi 2*5*11 = 110

Accedendo al file in maniera binaria ossia a basso livello dobbiamo considerare che il segno che di andare a capo corrisponde ad altri 2 carattere CR+LF che corrispondono ai numeri ASCII 13 e 10, quindi accedendo in maniera binaria a basso livello ogni riga termina con questa coppia di numeri ASCII e quindi ogni riga è lunga in modalità testo 4+110 = 114 mentre in modalità binaria 4+110+CR+LF = 116 caratteri

3.
stampa e memorizza i dati estratti --> mostra con colore diverso a video e scrivi su file i dati estratti
ho trovato molto più semplice scrivere tutta la griglia di numeri non analizzati con il colore dei numeri NON distanti 30 e riscrivere poi in secondo tempo i numeri con distanza 30 in altro colore. Mentre la griglia di lettura ossia le ruote e il numero di estrazione hanno un colore diverso per meglio distinguerle. Nella stessa procedura di cerca distanza 30 ho messo la memorizzazione su file degli stessi, mentre il numero estrazione viene segnato nel ciclo (loop) principale.

Code: QB64: [Select]

1. ' Programma lotto di kiara87
2. ' il programma legge i dati (numeri estratti da un file.dat)
3. ' e permette di vedere  le estrazioni a video
4. ' i numeri con distanza 30 sono evidenziati con colore rosso
5. ' questi numeri vengono memorizzati e stampati
6.  
7. ' Nota 1: sono d'accordo con Bplus e' molto piu'
8. ' rapido lavorare con dati in RAM che con dati su Disco HDD/SSD/USB/CD/DVD
9.  
10. ' valori COSTANTI  generali Vero e Falso
11. CONST True = -1, False = NOT True
12. ' le 11 ruote del lotto
13. CONST Bari = 1, Cagliari = 2, Firenze = 3, Genova = 4, Milano = 5
14. CONST Napoli = 6, Palermo = 7, Roma = 8, Torino = 9, Venezia = 10, Nazionale = 11
15. CONST Cifra = 2 ' ogni numero estratto e' una cifra di due caratteri (01-90)
16.  
17. DIM a AS STRING ' una stringa per leggere i dati dal file
18.  
19. ' salta al sottoprogramma LeggiFile delimitato
20. ' dalla Label LeggiFIle e dal RETURN
21. GOSUB LeggiFile
22.  
23. ' verifica che tutto il file sia letto
24. 'FOR b = 1 TO LEN(a) - 116 STEP 116
25. '    PRINT MID$(a, b, 116)
26. '    '    PRINT INSTR(b, a, CHR$(13))
27. '    _DELAY .1
28. 'NEXT b
29.  
30.  
31.  
32. ' il ciclo DO...LOOP UNTIL condizione e' un modo piu' moderno
33. ' rispetto a Etichetta: .... IF condizione GOTO Etichetta
34. b = 1
35. z$ = " "
36. OPEN "distanza30.dat" FOR APPEND AS #2
37. DO
38.     IF z$ <> "" THEN
39.         CLS ' questo risolve un glitch di output sullo schermo
40.         ' in alternativa alla riga sopra CLS nel sottoblocco
41.         ' MostraEstratti va stampata la stringa estratto e
42.         ' non il suo valore corrispondente ottenuto con VAL
43.         GOSUB MostraRuote ' scrive il nome delle ruote del lotto
44.         GOSUB MostraEstratti
45.     END IF
46.     ' prende l'input dell'utente
47.     z$ = UCASE$(INKEY$) ' Z$ mantiene il maiuscolo di Inkey$
48.     IF z$ = "+" AND b < (LEN(a) - 116) THEN b = b + 116
49.     IF z$ = "-" AND b > 116 THEN b = b - 116
50. LOOP UNTIL z$ = "Q"
51. CLOSE #2
52.  
53. END ' indica la fine logica del programma
54.  
55.  
56. '-----------------------AREA sottoprogrammi /SUBroutines
57.  
58. ' questa etichetta /label indica il punto di inizio
59. ' del sottoprogramma (SUBroutine) LeggiFile scritto con vecchio stile GOSUB
60. ' che usa una etichetta/label e un RETURN per riprendere da dove si era interotto
61. ' nota1: un metodo ancora piu' antico e' il salto con GOTO
62. '        che richiede una seconda etichetta per ritornare nel MAIN o programma principale
63. ' nota2: un metodo migliore e' SUB nomeroutine....END SUB
64. '        perche' permette la localizzazione delle variabili
65. LeggiFile:
66. 'se non trova lotto.dat segnala l'errore a video e termina il programma
67. IF NOT _FILEEXISTS("lotto.dat") THEN PRINT "File non trovato": END
68. '<--------------------
69. ' questo metodo e' piu' lento
70. ' apre il file lotto.dat per leggere in maniera sequenziale i dati
71. 'OPEN "lotto.dat" FOR INPUT AS #1
72. 'LINE INPUT #1, a  ' riempe la variabile a con una riga intera di valori
73. '<--------------------
74.  
75. ' apre lotto.dat per leggerlo in maniera binaria
76. OPEN "lotto.dat" FOR BINARY AS #1
77. a = SPACE$(LOF(1)) ' riempe la variabile a di spazi fino alla grandezza in byte del file aperto
78. GET #1, , a ' legge con una unica operazione il file e lo pone nella variabiel a
79. CLOSE #1 ' chiude il file appena letto
80. ' indica il termine della SUBroutine LeggiFile
81. ' e RITORNA alla riga di codice successiva al salto GOSUB
82. RETURN
83.  
84. 'seconda SUBroutine /sottoprogramma
85. MostraRuote:
86. COLOR 7, 6
87. LOCATE 1, 1
88. PRINT "BARI"
89. LOCATE 3, 1
90. PRINT "CAGLIARI"
91. LOCATE 5, 1
92. PRINT "FIRENZE"
93. LOCATE 7, 1
94. PRINT "GENOVA"
95. LOCATE 9, 1
96. PRINT "MILANO"
97. LOCATE 11, 1
98. PRINT "NAPOLI"
99. LOCATE 13, 1
100. PRINT "PALERMO"
101. LOCATE 15, 1
102. PRINT "ROMA"
103. LOCATE 17, 1
104. PRINT "TORINO"
105. LOCATE 19, 1
106. PRINT "VENEZIA"
107. LOCATE 21, 1
108. PRINT "NAZIONALE"
109. LOCATE 23, 1
110. PRINT "premi q per terminare, + avanti, - indietro"
111.  
112. ' indica il termine della SUBroutine MostraRuote
113. ' e RITORNA alla riga di codice successiva al salto GOSUB
114. RETURN
115.  
116. 'terzo sottoprogramma o SUBroutine
117. MostraEstratti:
118.  
119. ' le prime 4 cifre sembrano essere in numero della estrazione
120. LOCATE 1, 40
121. PRINT "estraz.num "; MID$(a, b, 4)
122. PRINT #2, "estraz.num "; MID$(a, b, 4)
123. DIM x AS INTEGER, y AS INTEGER, V AS INTEGER, A1 AS STRING
124. y = 13 ' prima posizione per il carattere da stampare
125. FOR x = 1 TO 5 STEP 1 ' questo ciclo   FOR e' di 5 perche' ogni ruota ha 5 estrazioni
126.     A1 = "" ' resetto a1 per il prossimo giro
127.     FOR V = Bari TO Nazionale ' per tutte le ruote
128.         COLOR 15, 0
129.         'posiziona il cursore
130.         LOCATE (V * 2) - 1, y
131.         ' scrive il numero estratto
132.         PRINT VAL(MID$(a, (V - 1) * 10 + 5 + ((x - 1) * 2) + (b - 1), Cifra)); " ";
133.         A1 = A1 + (MID$(a, (V - 1) * 10 + 5 + ((x - 1) * 2) + (b - 1), Cifra))
134.     NEXT V
135.     GOSUB Mostra30
136.     y = POS(0)
137. NEXT x
138. ' indica il termine della SUBroutine MostraEstratti
139. ' e RITORNA alla riga di codice successiva al salto GOSUB
140. RETURN
141.  
142.  
143. Mostra30:
144. DIM v1 AS INTEGER, v2 AS INTEGER
145. FOR v1 = Bari TO Venezia ' per tutte le ruote
146.     FOR v2 = v1 + 1 TO Nazionale
147.         IF ABS(VAL(MID$(a, (v1 - 1) * 10 + 5 + ((x - 1) * 2) + (b - 1), Cifra)) - VAL(MID$(a, (v2 - 1) * 10 + 5 + ((x - 1) * 2) + (b - 1), Cifra))) = 30 THEN
148.             COLOR 1, 0
149.             'posiziona                                                                      il cursore
150.             LOCATE (v1 * 2) - 1, y
151.             ' scrive il numero estratto
152.             PRINT VAL(MID$(a, (v1 - 1) * 10 + 5 + ((x - 1) * 2) + (b - 1), Cifra)); " ";
153.             PRINT #2, (MID$(a, (v1 - 1) * 10 + 5 + ((x - 1) * 2) + (b - 1), Cifra))
154.             'posiziona                                                                      il cursore
155.             LOCATE (v2 * 2) - 1, y
156.             ' scrive il numero estratto
157.             PRINT VAL(MID$(a, (v2 - 1) * 10 + 5 + ((x - 1) * 2) + (b - 1), Cifra)); " ";
158.             PRINT #2, MID$(a, (v2 - 1) * 10 + 5 + ((x - 1) * 2) + (b - 1), Cifra)
159.         END IF
160.     NEXT v2
161. NEXT v1
162. COLOR 15, 0
163. ' indica il termine della SUBroutine MostraEstratti
164. ' e RITORNA alla riga di codice successiva al salto GOSUB
165. RETURN

e questo è lo screenshot
  [ You are not allowed to view this attachment ]  

osservazioni:
-lavorare in RAM è molto più veloce che lavorare su disco
-accedere al file in maniera binaria ti permette di caricare tutto il file in RAM con una unica istruzione
-con MID$ sapendo la struttura della singola estrazione del lotto |numero di 4 cifre|estrazioni di 110cifre 1ruota5estrazioni2ruota5estrazioni...11ruota5estrazioni|acapo CR+LF| puoi navigare attraverso i dati con sicurezza

-una alternativa validissima è l'uso di un array dinamico

Code: QB64: [Select]

1. REDIM Estrazioni (1 to Max) AS STRING
2.  

-una altra alternativa validissima è l'uso di una UDT con TYPE---END TYPE con un array dinamico
ad esempio

Code: QB64: [Select]

1. TYPE Estrazione
2.    Numestrazione AS STRING * 4
3.    EstrattiBari AS STRING * 10
4.    EstrattiCagliari AS STRING * 10
5.    EstrattiFirenze AS STRING * 10
6.    ...
7.    EstrattiNazionale AS STRING * 10
8. END TYPE
9.  
10. REDIM Lotto (1 to Max) AS Estrazione
11.  

Buona avventura nel mondo della programmazione e non cadere nella trappola dei principianti che cambiano continuamente linguaggio perchè pensano di poter farme meglio con una altro rispetto a quello che stanno imparando... ;)

[TempodiBasic]

@ kiara87
about

come voi programmatori posizionate i numeri con i locate e li distanziate
esempio: mentre io usavo locate 1,10 ecc..

PRINT si comporta in maniera differente se stampa un numero o una stringa
nell'elaborare l'output grafico della tabella dei numeri estratti mi sono imbattuto in un glitch perchè appunto la scritta a video viene spostata a seconda che si tratti di una cifra o 2 cifre.

Il problema ha 2 possibili soluzioni 1. ripulire lo schermo prima di riscriverlo come ho fatto io mettendo il CLS nel loop principale del programma (nel main) oppure 2 stampare la stringa invece del numero corrispondente (la differenza è che a video tu vedrai 02 al posto di 2)
una terza via 3. è usare l'struzione PRINT USING (come ti ha suggerito Bplus) per formattare l'output a video (questo è analogo al C  Printf(%d,%f...),a,c,...)

il

Code: QB64: [Select]

1.    FOR V = Bari TO Nazionale ' per tutte le ruote
2.         COLOR 15, 0
3.         'posiziona il cursore
4.         LOCATE (V * 2) - 1, y

usa la variabile del ciclo FOR per tutte le ruote (da Bari a Nazionale) per posizionare la riga (devi ricordare che SCREEN 0, ossia la modalità di video solo testo è di default in QB se non definisci alcuna modalità video, essa è detta anche modalità console e come default ha 80 colonne e 25 righe, cerca nella wiki per maggiori informazioni) mentre y definisce la colonna da cui partire a stampare il testo... la ; permette di non andare a capo dopo la scrittura

about

e un altro punto che devo ancora adattarmi  esempio io il file lo leggevo con la variabile a e mid$ ma devo capire la funzione di altri variabili aggiunti -->
PRINT VAL(MID$(a, (V - 1) * 10 + 5 + ((x - 1) * 2) + (b - 1), Cifra)); " ";

qui si dice al PC di stampare a video il valore della parte della stringa a, estratta con MID$ a partire dalla posizione  (V - 1) * 10 + 5 + ((x - 1) * 2) + (b - 1)  e di lunghezza Cifra (ricorda che Cifra è una costante di valore 2 ossia al posto di Cifra tu leggi di lunghezza 2 caratteri)
quindi NON stai leggendo dal file ora ma stai NAVIGANDO il file contenuto interamente nella variabile a di tipo stringa mentre qui è stato letto il file 

Code: QB64: [Select]

1. ' apre lotto.dat per leggerlo in maniera binaria
2. OPEN "lotto.dat" FOR BINARY AS #1
3. a = SPACE$(LOF(1)) ' riempe la variabile a di spazi fino alla grandezza in byte del file aperto
4. GET #1, , a ' legge con una unica operazione il file e lo pone nella variabile a
5. CLOSE #1 ' chiude il file appena letto

Come fai a sapere dove sei nella variabile a e cosa stai leggendo?
questa è la bussola

analizza i dati estraendo i numeri distanti 30 in ogni estrazione lotto --> la singola sequenza della singola estrazione è formata da 4 cifre iniziali di riga che sono il numero estrazione e da 110 cifre che sono i numeri estratti (ogni numero estratto va da 01 a 90 rappresentati da 2 cifre) le ruote di estrazioni sono 11 e ogni estrazione ha 5 cifre estratte quindi 2*5*11 = 110

Accedendo al file in maniera binaria ossia a basso livello dobbiamo considerare che il segno che di andare a capo corrisponde ad altri 2 carattere CR+LF che corrispondono ai numeri ASCII 13 e 10, quindi accedendo in maniera binaria a basso livello ogni riga termina con questa coppia di numeri ASCII e quindi ogni riga è lunga in modalità testo 4+110 = 114 mentre in modalità binaria 4+110+CR+LF = 116 caratteri

Buon studio e buon lavoro sulla comprensione e memorizzazione della sintassi.
Non preoccuparti se non ricordi bene tutto, la wiki c'è apposta. Ancora oggi mi chiedo spesso se LOCATE vuole riga,colonna o colonna,riga e la wiki risolve spesso! ;)

[Kiara87]

@ kiara87

salve TempodiBasic volevo chiederti riguardo sulla funzione goto i programmatori la evitano a  causa del stile spaghetti
quindi evitano anche GOSUB visto che GOSUB è identica come istruzione giusto?

[bplus]

@Kiara87

Can you count and list the words in this sentence?

Can you write code to count and list the words in any given sentence?

Can you count the words in reply #85 above? Hope you don't get an overflow error ;-))

Can you count the QB64 CODE words in reply #84?

  [ You are not allowed to view this attachment ]  

Hmm... looks like we will have to do something about punctuation ;-))

[TempodiBasic]

@Kiara87
GOTO  e GOSUB sono due bacchette magiche che l'apprendista stregone programmatore deve temere e ammirare. Sono potenti ma senza limiti quindi se non sai quello che stai facendo fai di certo un gran pasticcio, come topolino nell'apprendista stregone https://www.youtube.com/watch?v=U546yRNeNh4

giusto per esercizio e per comprensione  tu poi considerare GOSUB  un GOTO semplificato perchè con RETURN ti permette di ritornare indietro all'istruzione del salto senza usare una ulteriore etichetta

Code: QB64: [Select]

1. GOTO There
2. Here:
3. PRINT "Hi Guys"
4. END
5.  
6. There:
7. PRINT "I'm QB64 coder "
8. GOTO Here
9.  

is the same that

Code: QB64: [Select]

1. GOSUB There
2. PRINT "Hi Guys"
3. END
4.  
5. There:
6. PRINT "I'm QB64 coder "
7. RETURN
8.  

ma tu puoi costruire i loop WHILE..WEND, DO WHILE..LOOP, DO UNTIL..LOOP; DO..LOOP UNTIL, DO..LOOP WHILE con i rispettivi EXIT WHILE o EXIT DO usando il GOTO e le etichette, lo stesso per FOR NEXT...
prova come esercizio a creare questi loop con GOTO e li comprenderai meglio.

@bplus
PRINT LEN(88)
:-)

[bplus]

Can you count the QB64 CODE words in reply #84?