Opti-Défi n°1 : Jeu du taquin 4x4

[m@thieu41]

Concernant:

Code: Select all

[[1,2,3,4][5,6,7,8][9,10,11,12][13,14,15,0→[A]

J'aurais fais:

Code: Select all

{1,5,9,13
Liste>Matr(Ans,Ans+1,Ans+2,Ans+3,[A]
0->[A](4,4

(on gagne ~10 octets il me semble).

Voici mon programme (optimisé niveau octets exclusivement, donc pas forcément très fluide... Notamment un affreux clignotement) :

Show/Hide spoilerAfficher/Masquer le spoiler

Code: Select all

//On génère un liste parfaite (16 = vide)
seq(A,A,1,16->L1
Ans->L3

//On effectue un nombre pair de permutations, entre la 1ère case et une autre aléatoire (mais pas celle de la case vide)
For(A,1,40
randint(2,15->B
L1(A->E
L1(1->L1(A
E->L1(1
End

//Position de départ
3->B
4->A

//On joue tant qu'on est pas revenu à la liste sauvegardée
Repeat min(L1=L3

//Affichage (dans la boucle permet de gagner en octets, mais perds en fluidité, avec un clignotement à chaque déplacement)
EffEcr
For(W,4,19
L1(W-3
If Ans-16
Output(ent(W/4),12fPart(W/4)+1,Ans
End

//On attend une touche
Repeat Ans
getKey->K
End

//Déplacement (de la case vide pour moi)
max(1,min(4,A+(K=26)-(K=24->C
max(0,min(3,B+(K=24)-(K=25->D

L1(4D+C->L1(4B+A
16->L1(4D+C

D->B
C->A

End

//On a gagné
ClrHome
"GAGNE

En fait j'ai gagné encore un octet en recopiant, donc 233!


Je suis d'accord pour dire qu les programmes obtenus sont médiocres à cause de la contrainte gagner le plus d'octets possibles...
Un défis pour faire un programme le plus rapide et le moins lourd possible semble plus sympathique à coder déjà.

[Wistaro]

Je posterais le mien tout à l'heure.

[grosged]

Hey, je vois que vous en êtes (aussi!) arrivé à utiliser les matrices
C'est vrai que, dès le départ , nous étions conscient qu'un programme le plus petit possible ne brillerait pas vraiment... esthétiquement parlant

Bon, j'ai encore grapillé (au niveau de l'affichage final)
re-EDIT : taille = 227 octets (grâce à M@thieu41

Point faible : le mélange des nombres assez lent (env. 4secondes)
point fort : l'affichage est stable, ne clignote pas

Show/Hide spoilerAfficher/Masquer le spoiler

40→C ; nb de coups joués par la TI (environ) afin de désordonner
4→X:4→Y ;coord. case vide
{1,2,3,4 ; création de la grille gagnante (afin de ne pas risquer
List►matr(.1Ans,.1Ans+.4,8+Ans,12+Ans,[I] ; un affichage "bancal",
.9→[I](1,3 ; .1 .2 .3 .... remplacent 1 2 3 ...
[I]→[G] ; stocke la grille initiale [i] dans [g]
Repeat [G]=[I] ; en boucle tant qu'on n'est pas revenu à la grille initiale
For(F,0,C ; pendant (env.) 41x , la TI déplace des cases...
X→H:Y→V ; mémorise les coord de la case vide
While XY=HV ; tant que la case n'a pas bougé
getKey-24 ; scrute les touches fléchées 24,25,26,34....déc de 24
If C:int(4rand ; si c pas à 0, alors la TI simule l'appui de touches
Ans+7(Ans=3→T ; ça c'est pour la simulation de la touche 34
max(1,X-(T=2)+(X<4not(T→X ; Déc/inc X en fonction des touches
min(4,Y-(YT>10)+(T=1→Y ; Déc/inc Y en fonction des touches
End ; boucle tant que la case vide n'a pas bougé
[G](X,Y→[G](H,V ; sur la grille, échange entre la case vide et la voisine
16→[G](X,Y ; inscrit 16 pour marquer la case vide
End ; fin de la phase "mélange" (plus tard =phase de jeu
DelVar CClrHome ; nb de coups joués par la TI définitivement à 0
Disp [G]T ; affiche la matrice (avec inversion des colonnes/lignes
Output(Y,1+3X,"░░ ; efface tout de suite la valeur 16 ( la case vide )
End ; boucle tant qu'on a pas résolu
"GAGNE ; c'est gagné!

[grosged]

Je trouve qu'on a , chacun de notre côté, bien "retourné" le problème
En faisant un "mix" de tout ça, on descendrait encore ?! héhé

(là, j'suis en train d'ajouter un peu d'explication à mon listing...)

[m@thieu41]

Déjà je te fais gagner 2o :

Code: Select all

X-(T=2 and X>1)+(X<4not(T→X
Y-(YT>10)+(T=1 and Y<4→Y

devient:

Code: Select all

max(1,X-(T=2)+(X<4not(T→X
min(4,Y-(YT>10)+(T=1→Y

EDIT:

Code: Select all

randInt(0,3

devient:

Code: Select all

int(4rand

[grosged]

Hey Bravo , Mathieu !!

20 octets en moins , alors ?!!

le programme descendrait donc à 212 !!!

[m@thieu41]

Non 2 octets (2o) pas 20
(plus 1 avec mon opti de mon edit donc 3 octets de gagnés )

[grosged]

ah ok ok !! hahaha ...autant pour moi

je fais les modifs de suite...

Grâce à toi, j'en suis à 227 octets maintenant !!

Show/Hide spoilerAfficher/Masquer le spoiler

40→C ; nb de coups joués par la TI (environ) afin de désordonner
4→X:4→Y ;coord. case vide
{1,2,3,4 ; création de la grille gagnante (afin de ne pas risquer
List►matr(.1Ans,.1Ans+.4,8+Ans,12+Ans,[I] ; un affichage "bancal",
.9→[I](1,3 ; .1 .2 .3 .... remplacent 1 2 3 ...
[I]→[G] ; stocke la grille initiale [i] dans [g]
Repeat [G]=[I] ; en boucle tant qu'on n'est pas revenu à la grille initiale
For(F,0,C ; pendant (env.) 41x , la TI déplace des cases...
X→H:Y→V ; mémorise les coord de la case vide
While XY=HV ; tant que la case n'a pas bougé
getKey-24 ; scrute les touches fléchées 24,25,26,34....déc de 24
If C:int(4rand ; si c pas à 0, alors la TI simule l'appui de touches
Ans+7(Ans=3→T ; ça c'est pour la simulation de la touche 34
max(1,X-(T=2)+(X<4not(T→X ; Déc/inc X en fonction des touches
min(4,Y-(YT>10)+(T=1→Y ; Déc/inc Y en fonction des touches
End ; boucle tant que la case vide n'a pas bougé
[G](X,Y→[G](H,V ; sur la grille, échange entre la case vide et la voisine
16→[G](X,Y ; inscrit 16 pour marquer la case vide
End ; fin de la phase "mélange" (plus tard =phase de jeu
DelVar CClrHome ; nb de coups joués par la TI définitivement à 0
Disp [G]T ; affiche la matrice (avec inversion des colonnes/lignes
Output(Y,1+3X,"░░ ; affiche deux espaces ( =la case vide )
End ; boucle tant qu'on a pas résolu
"GAGNE ; c'est gagné!

[m@thieu41]

En fait les listes c'est mieux

Et l'affichage est plus propre, sans les "." devant les nombres à 1 chiffres.

je m'inspire de ton code pour... 226 octets! (bon ok ça fait qu'un octet de différence ^^)

Show/Hide spoilerAfficher/Masquer le spoiler

Code: Select all

//On génère un liste parfaite (16 = vide)
seq(A,A,1,16->L1
Ans->L2

40->C //nb déplacements aléatoires

//Position de départ
3->B
4->A

//On joue tant qu'on est pas revenu à la liste sauvegardée
Repeat min(L1=L2

For(F,0,C //Gestion du mélange

//Anciennes positions
A->D
B->E

//On attend un déplacement
While A=D and B=E

//On récupère le numéro de déplacement
getKey-24
If C
ent(4rand
Ans+7(Ans=3->K

//Calcul des nouvelles coordonnées
max(1,min(4,A+(K=2)-not(K->A
max(0,min(3,B+(K=10)-(K=1->B

End

//Déplacement
L1(4B+A->L1(4E+D
16->L1(4B+A

//Affichage (dans la boucle permet de gagner en octets, mais perds en fluidité, avec un clignotement à chaque déplacement)
Delvar CClrHome
For(W,4,19
L1(W-3
If Ans-16
Output(ent(W/4),12fPart(W/4)+1,Ans
End

End

//On a gagné
ClrHome
"GAGNE

[grosged]

226 !!! Bravo !!...
(en fait j'ai recours aux .1 .2 .3 .4 pour éviter que parfois 1 colonne ou 2 ne rétrécissent, en fonction des emplacements des chiffres)

dis, je vois While A=D and B=E
pourquoi pas While AD=BE ?