Salve colleghi, avete presente quel bel giochino, chiamato il quadrato magico?
Ebbene, ho sviluppato un software in grado di risolverlo... Ma allora dove sta il problema?? Ecco... OVVIAMENTE il programma funziona correttamente (sviluppato in QuickBasic), Solo, che secondo alcuni miei calcoli, dovrebbe riuscire a completare il lavoro in un paio di mesi senza sosta... Ovviamente si capisce dove sta il problema... non posso tenere il computer acceso per così tanto.. Ed avevo anche promesso che entro una settimana avrei portato nero su bianco la soluzione.
Vi mostro il codice QBasic:
' Program tabella1 1.1
'Baldini Davide
1 PRINT "inizio del calcolo?";
INPUT "1Si 2No"; a
IF a = 2 THEN END
IF a <> 1 AND a <> 2 THEN PRINT "selezione errata": GOTO 1
DIM p(100)
min = 100
FOR ca = 1 TO 100
locate 2,1,0,1,1
print "Stato: ";ca
print "minimo: "; min; " "
if ca >= 90 then con = 1
if con = 1 AND ca < min then min = ca
IF ca = 1 THEN
IF p(1) = 0 THEN p(1) = 1: GOTO 200
IF p(1) = 1 THEN p(1) = 10: GOTO 200
IF p(1) = 10 THEN p(1) = 90: GOTO 200
IF p(1) = 90 THEN p(1) = 100: GOTO 200
END IF
2
' Controllo posizione
FOR cb = 1 TO 10
IF p(ca - 1) = cb THEN la = 1
NEXT cb
FOR cb = 11 TO 20
IF p(ca - 1) = cb THEN la = 2
NEXT cb
FOR cb = 21 TO 30
IF p(ca - 1) = cb THEN la = 3
NEXT cb
FOR cb = 10 TO 100 STEP 10
IF p(ca - 1) = cb THEN lb = 1
NEXT cb
FOR cb = 9 TO 99 STEP 10
IF p(ca - 1) = cb THEN lb = 2
NEXT cb
FOR cb = 8 TO 98 STEP 10
IF p(ca - 1) = cb THEN lb = 3
NEXT cb
FOR cb = 91 TO 100
IF p(ca - 1) = cb THEN lc = 1
NEXT cb
FOR cb = 81 TO 90
IF p(ca - 1) = cb THEN lc = 2
NEXT cb
FOR cb = 71 TO 80
IF p(ca - 1) = cb THEN lc = 3
NEXT cb
FOR cb = 1 TO 91 STEP 10
IF p(ca - 1) = cb THEN ld = 1
NEXT cb
FOR cb = 2 TO 92 STEP 10
IF p(ca - 1) = cb THEN ld = 2
NEXT cb
FOR cb = 3 TO 93 STEP 10
IF p(ca - 1) = cb THEN ld = 3
NEXT cb
FOR cd = 1 TO ca - 1
IF p(cd) = p(ca - 1) - 22 THEN s1 = 1
IF p(cd) = p(ca - 1) - 30 THEN s2 = 1
IF p(cd) = p(ca - 1) - 18 THEN s3 = 1
IF p(cd) = p(ca - 1) + 3 THEN s4 = 1
IF p(cd) = p(ca - 1) + 22 THEN s5 = 1
IF p(cd) = p(ca - 1) + 30 THEN s6 = 1
IF p(cd) = p(ca - 1) + 18 THEN s7 = 1
IF p(cd) = p(ca - 1) - 3 THEN s8 = 1
NEXT cd
' se richiamato:
IF p(ca) <> 0 THEN
FOR cc = ca + 1 TO 100
p(cc) = 0
NEXT cc
IF p(ca) = p(ca - 1) - 22 THEN GOTO 4
IF p(ca) = p(ca - 1) - 30 THEN GOTO 5
IF p(ca) = p(ca - 1) - 18 THEN GOTO 6
IF p(ca) = p(ca - 1) + 3 THEN GOTO 7
IF p(ca) = p(ca - 1) + 22 THEN GOTO 8
IF p(ca) = p(ca - 1) + 30 THEN GOTO 9
IF p(ca) = p(ca - 1) + 18 THEN GOTO 10
IF p(ca) = p(ca - 1) - 3 THEN bloccato = 1: goto 12
END IF
IF (la = 0 OR la = 3) AND (ld = 0 OR ld = 3) AND s1 = 0 then p(ca) = p(ca - 1) - 22: goto 12
4 IF la = 0 AND s2 = 0 THEN p(ca) = p(ca - 1) - 30: GOTO 12
5 IF (la = 0 OR la = 3) AND s3 = 0 AND (lb = 0 OR lb = 3) THEN p(ca) = p(ca - 1) - 18: GOTO 12
6 IF lb = 0 AND s4 = 0 THEN p(ca) = p(ca - 1) + 3: GOTO 12
7 IF (lc = 0 OR lc = 3) AND s5 = 0 AND (lb = 0 OR lb = 3) THEN p(ca) = p(ca - 1) + 22: GOTO 12
8 IF lc = 0 AND s6 = 0 THEN p(ca) = p(ca - 1) + 30: GOTO 12
9 IF (ld = 0 OR ld = 3) AND s7 = 0 AND (lc = 0 OR lc = 3) THEN p(ca) = p(ca - 1) + 18: GOTO 12
10 IF ld = 0 AND s8 = 0 THEN p(ca) = p(ca - 1) - 3: GOTO 12
bloccato = 1
12 IF bloccato = 1 THEN ca = ca - 2: GOTO 190
' azzeramento limiti
190
bloccato = 0
la = 0
lb = 0
lc = 0
ld = 0
s1 = 0: s2 = 0: s3 = 0: s4 = 0: s5 = 0: s6 = 0: s7 = 0: s8 = 0
200 NEXT ca
ss = 0
OPEN "C:\res.txt" FOR OUTPUT AS #1
FOR bb = 1 TO 100
FOR vv = 1 TO 100
IF p(vv) = bb THEN PRINT #1, p(vv); " "; : ss = ss + 1
IF ss = 10 THEN PRINT #1, " ": ss = 0
NEXT vv
NEXT bb
PRINT #1, "************"
FOR gg = 1 TO 100
PRINT #1, gg, p(gg)
NEXT gg
CLOSE #1
END
Apparte le ultime righe che sono estremamente incasinate, il resto va abbastanza bene.
Chi legge il programma si accorge che vengono eseguiti dei tentativi, partendo da un angolo, e continuando dove possibile (con direzioni che variano in senso orario).
La voce che compare una volta eseguito il programma "minimo" sta a indicare quanto è sceso al massimo dopo aver raggiunto i novanta numeri (altrimenti il minimo sarebbe 1, visto che è da quel numero che il programma inizia).
Il programma funziona in questo modo: parte da un angolo, controlla se le direzioni sono all'interno della tabella, controlla se nel suo raggio ci sono altri numeri ad impedirli di andare, e se tutto libero va nella direzione libera seguendo il senso orari. se una volta arrivato ad un certo punto, non puo' piu' proseguire, torna in dietro di una mossa, e ricomincia dalle direzioni rimaste libere. E' un po' difficile da spiegare, ma se lo leggete capite meglio.
Pensavo che per risparmiare tempo avrei potuto mandarlo preferibilmente in diagonale, visto che fino ad ora in orrizzontale ed in verticale non ha dato buoni risultati.
Infatti, in questo modo (cioè quello del programma di sopra), dopo circa 16 ore di calcolo il valore minimo (cioè che specifica fino a quale numero è tornato in dietro, e che significa che tutte le combinazioni dal numero successivo sono fallite) non era sceso sotto il 64. Ovviamente quando viene raggiunto il valore 1 il programma trova per forza di cose la soluzione, visto che significa che le ha provate tutte. però il problema secondo me è che parte col piede sbagliato, quindi gli è poi richiesto di tornare indietro fino all'ultimo, impiegando anche alcune settimane di lavoro.
So perfettamente che non avete capito niente, però volevo un vostro aiuto.
Provate a fare eseguire il programma (senza ottenere risultati tempestivi...)
leggetelo e cercate di capirlo, poi chiedetemi quello che non avete capito.
Se invece sapete gia' la soluzione, postate che mi farete felice.
(nessuno arriverà mai a leggere fino in fondo... 8( )
Provate