Voilà : je vais essayer d'améliorer mon morpion de l'ancien forum Tout82, notamment en lui ajoutant la vérification de victoire et de match nul. J'utilse pour cela trois listes qui sont stockées dans une matrice :

Code:

For(A,1,3
Fill(-1,lA
List>matr(lA,lA,lA,[A]
End

Bon déjà là ça m'étonnerait que ce soit pas optimisable....  

Par la suite je vérifie la victoire en faisant la somme des termes de ma liste, sachant que quand on pose un signe j'effectue la valeur de la matrice plus le numéro du joueur (1 ou 2). Si la somme est égale à 0 ou 3, le jeu s'arrête.

Code:

lA((B+1)/3)+J->lA((B+1)/3
If sum(lA)=3 or sum(lA)=0
Then
ClrHome
Disp "OK!"
Stop
End

C'est un exemple pour vous montrer le principe. Seulement, après le 2e placement, le jeu s'arrête, alors que d'après le code ça devrait pas (enfin je crois). Je vois pas trop où est le problème, c'est pourquoi je vous demande de l'aide !   

lA=[liste]A

Hey!

Déjà concernant le remplissage de la matrice:

Code:

For(A,1,3
Fill(-1,lA
List>matr(lA,lA,lA,[A]
End

Si on décortique:

Code:

Fill(-1,lA
List>matr(lA,lA,lA,[A]

Tu remplis lA de -1
Puis tu accole trois fois la liste lA, dans la matrice [A]
Donc dans [A] tu auras:
[[-1,...],[-1...],[-1,..]]
Avec un nombre de ligne qui dépend de la dimension de lA (3 je suppose).

Du coup, le faire 3 fois sers strictement à rien.
De plus, tu peux directement remplir la matrice, donc comme suit:

Code:

{3,3->dim([A] //Modifie les dimensions au besoin
Fill(-1,[A]

Tu auras donc bien ta matrice

Code:

-1 -1 -1
-1 -1 -1
-1 -1 -1

Concernant les tests de victoire, une petite remarque avant tout:
If sum(lA)=3 or sum(lA)=0
Sauf que... Imagine qu'on ait la configuration, sur une ligne:
J1 J2 vide
ce qui donne la liste:
0 1 -1
soit une somme de 0 (pourtant il n'y a pas eut de victoire...).

Par contre:
lA((B+1)/3)+J->lA((B+1)/3

Pourquoi agis tu sur la liste et non pas sur la matrice?
N'oublie pas que quand tu fais List>Matr(lA,[A]), tu copies les infos de lA dans une colonne de [A], la liste et la matrice ne sont en aucun cas liées! Modifier la liste ne modifiera pas la matrice, et vice versa.


Par contre:

J'utilse pour cela trois listes qui sont stockées dans une matrice

Comme je viens de te le signaler, les listes ne sont pas stockées, mais copiées, et en plus, dans ton code je ne vois qu'une seule liste (lA).

Merci de ta réponse aussi rapide !  

En fait la lA provient d'une manipulation que j'ai faite : j'ai pensé que le A du nom de ma liste varierait en même temps que le A de mon curseur (A étant l'abscisse du curseur). C'est pourquoi je n'ai qu'une seule liste.

En fait je me suis encombré de toutes ces listes car d'après mes connaissances on ne peut pas tester une seule ligne ou colonne d'une matrice (peut être serai-je agréablement surpris !). J'ai donc penser à séparer les lignes et colonnes (avec la fonction T) en faisant ma matrice à partir de plusieurs listes. Mais on dirait que j'ai mal compris la fonction List>matr(.

Pour cette ligne :

Code:

lA((B+1)/3)+J->lA((B+1)/3

En fait comme j'étais parti sur les listes j'en ai oublié la matrice. C'est en effet plus simple et plus efficace avec la matrice  

Pour les tests de victoires, si on stocke une autre valeur dans la matrice, peut être que ça marcherait. Sinon je peux tout de suite oublier l'idée de la somme...(comment faire )

Enfin, si je n'ai pas choisi la matrice simple, c'est tout simplement comme je l'ai déjà dit pour pouvoir effectuer la somme et donc les tests de victoire.

Donc la question est : y a t-il un moyen d'isoler mes lignes pour effectuer mes tests ou y a t-il un autre moyen d'obtenir le même résultat avec une autre utilisation des matrices ?

En fait je me suis encombré de toutes ces listes car d'après mes connaissances on ne peut pas tester une seule ligne ou colonne d'une matrice (peut être serai-je agréablement surpris !).

On ne peut pas faire ça directement depuis la matrice, par contre on peut se débrouiller à récupérer les lignes et les colonnes d'une matrice dans une liste.

Pour récupérer la colonne n°X dans la liste L1:
Matr>List([A],X,L1
On ne peut pas récupérer directement une ligne, mais on peut inverser les lignes/colonnes d'une matrice avec le T (en sorte d'exposant) que tu trouves dans le menu matrice->MATH (2e choix normalement).
Donc:
Matr>List([A]T,X,L1
Pour récupérer la ligne X dans la liste L1.

En bouclant, tu devrait pouvoir tester toutes les lignes et toutes les colonnes une à une.

L'idée de somme est intéressante, mais il faut prendre d'autres valeurs que -1, 0 et 1.
Par exemple, tu initialise toutes les positions vide à 0.
Pour un joueur tu rajoutes 1 (donc somme = 3), et pour l'autre tu rajoute 10 (somme = 30), pas de risque de problème ici.
Ou rajouter 1 (S=3) et enlever -1 (S=-3) pour l'autre.

L'exposant T des matrices est l'opérateur de transposition. Un peu de vocabulaire à résumer. Je confirme que c'est une bonne chose pour accéder à des lignes au lieu de colonnes et réciproquement.

Je confirme l'extraction des lignes/matrices par la fonction Matr>List(). Puis on peut effectuer les tests et calculs globaux sur ces listes dès la ti82stats.
max(L1) représente qu'au moins une valeur est non-nulle.

Je vous conseille de laisser tomber les sommes mais plutôt d'utiliser 0/1/2 et des produits qui donnent 1 ou 8 pour un alignement de trois cases, et 0, 2 ou 4 le reste du temps. Et on peut utiliser la variable du joueur pour comparer à la table.
Les sommes posent toujours des problèmes dans la reconnaissance de combinaisons.

Dans mes morpions très optimisés je teste seulement les diagonales et la ligne et la colonne de la case jouée pour poursuivre ou quitter. Et si 9 cases ont été remplies parmi 9, alors il y a match nul.
Je n'avais pas optimisé la condition avec les listes par contre.

Code:

0->R //tours
2->M //joueur
Repeat R=9 or max(M^3={[A](I,1)[A](I,2)[A](I,3),[A](1,J)[A](2,J)[A](3,J),[A](1,1)[A](2,2)[A](3,3),[A](1,3)[A](2,2)[A](3,1)

3-M->M
...//controle qui affecte les coordonnées I,J
R+1->R
End
If R=9
Disp "NUL
Disp M // vainqueur ou dernier joueur

Tu peux utiliser une seule boucle pour parcourir plusieurs lignes/colonne simultanément et stocker les résultats. Cependant cela accède manuellement aux termes à chaque itération.

Code:

{1,1,1,1
For(A,1,3
Ans{[A](I,A),[A](A,J),[A](A,A),[A](A,4-A
End
max(Ans=M^3

J'avoue ne jamais avoir pensé à ne regardé que la ligne et la colonne où on a joué   
Ca parait évident pourtant une fois que tu le signales

Bon désolé j'ai pas pu poster les recherches que j'ai faites de mon coté...
J'étais arrivé à la même conclusion que toi @mathieu41, en fait j'extrayais trois listes de [A] et trois autres de [A]T pour effectuer mes tests.

Seulement ces tests s'arrêtaient au test d'une seule liste, là où réside le dernier problème.
@linkakro, Pour lesdits tests, j'avais pas abandonné les sommes (), en fait j'effectuais cela :

Code:

If not(variance(L1) and sum(L1)≠-3
...

Ca m'a semblé adapté, mais en effet ça bloque au test d'une seule liste. Je prends en compte vos solutions !  

@linkakro : j'avoue ne pas avoir bien compris ton utilisation de max(...   

Ce max() est un exemple d'analyse de calcul global sur une liste.
Dans le cas présent j'utilise les conditions globales qui existent dès la 82stat/83.
http://tout82.free.fr/forum/sujet.php?sujet=2741

{a,b}=c donne {a=c,b=c}
Pour des valsurs adaptées telles que 0 et 1, on peut résumer avec les fonctions de listes.
max({condition1,condition2}) imite une opération OU.
sum({condition1,condition2}) de même imite une opération OU mais donnera facilement des valeurs excessives même pour 0 et 1 en entrée.
min({condition1,condition2}) et prod({condition1,condition2}) imitent une opération ET.

Les opérations de max() que j'ai placé dans les programmes permet d'effectuer une analyse concentrée des conditions puisque la condition M^3={} est appliquée globalement à la liste de mes produits. Au moins un des produits vaut M^3 donc au moins un alignement est présent.

Si tu utilises des fonctions de listes telles que Matr>List et sum/prod alors tu peux encore réduire le code plus que moi en calculant les conditions en dehors de celle de la boucle, c'est-à-dire à la fin de la boucle.

Mais l'essentiel du travail est d'adapter les valeurs et les calculs
Moi j'ai choisi le produit de 0,1,2. Persiste dans la voie que tu veux pourvu que ça marche efficacement.

Donc ce truc :

Code:

Matr>list([A],L₁,L₂,L₃
Matr>list([A]T,L₄,L₅,L₆
{L₁(1),L₂(2),L₃(3)}→⌊A
{L₁(3),L₂(2),L₃(1)}→⌊B
If (variance(L₁)=0 and sum(L₁)≠–3) or (variance(L₂)=0 and sum(L₂)≠–3) or (variance(L₃)=0 and sum(L₃)≠–3) or (variance(L₄)=0 and sum(L₄)≠–3) or (variance(L₅)=0 and sum(L₅)≠–3) or (variance(L₆)=0 and sum(L₆)≠–3) or (variance(⌊A)=0 and sum(⌊A)≠–3) or (variance(⌊B)=0 and sum(⌊B)≠–3)

Devient grossièrement ça :

Code:

Matr>list([A],L₁,L₂,L₃
Matr>list([A]T,L₄,L₅,L₆
{L₁(1),L₂(2),L₃(3)}→⌊A
{L₁(3),L₂(2),L₃(1)}→⌊B
If max({(min({not(variance L₁),sum (L₁)≠-3}),(min({not(variance L₂),sum L₂≠-3}),(min({not(variance L₃),sum L₃≠-3}),(min({not(variance L₄),sum L₁≠L₄}),(min({not(variance L₅),sum L₅≠-3}),(min({not(variance L₆),sum L₆≠-3}),(min({not(variance ⌊A),sum ⌊A≠-3}),(min({not(variance ⌊B),sum ⌊B≠-3

Maintenant faut optimiser... mais tel que c'est c'est 150 octets plus lourd

Ton écriture de somme sans parenthèses n'a aucun sens sur ti82stat et postérieures.

La plupart des écritures de listes ont pour unique objectif l'optimisation, souvent aussi bien en code qu'en rapidité. Utiliser des listes sans optimiser dès le début est inutile.

Voici ce que j'attend comme optimisation en exploitant l'identité du joueur.

Code:

// -1,0,1 comme valeurs de cases
//-1,1 pour identifier le joueur M
Matr>list([A],L₁,L₂,L₃
Matr>list([A]^t,L₄,L₅,L₆
max(3M={sum(L₁),sum(L₂),sum(L₃),sum(L₄),sum(L₅),sum(L₆)})

Voici une version indépendante du joueur.

Code:

Matr>list([A],L₁,L₂,L₃
Matr>list([A]^t,L₄,L₅,L₆
{sum(L₁),sum(L₂),sum(L₃),sum(L₄),sum(L₅),sum(L₆)}
max(Ans=-3) or max(Ans=3)
 // ou bien max(abs(Ans)=3)

Je suis adepte des boucles qui, malgré un manque d'utilisation de toutes les routines du système, permet une synthèse du code sans écriture de plusieurs listes.
On peut envisager de stocker la transposée une fois au début pour ne pas la calculer trois fois.

Code:

0
For(A,1,3
Matr>list([A],A,L₁
max(Ans,3M=sum(L₁
Matr>list([A]^t,A,L₁
max(Ans,3M=sum(L₁
End

EDIT : J'AI OUBLIé les DIAGONALES !!! Merci pour le rappel ci-dessous.

Avec les calculs de produits c'est plus simple tout compte fait : 1 ou 8 et pas de "and" à gérer, si on prend 0,1 et 2 comme valeurs de case et 1 et 2 pour identifier le joueur.

C'est vrai qu'au lieu d'avoir 8 listes c'est plus simple avec la boucle. Je note  . Par contre, je vois pas comment obtenir les listes des diagonales. Peut-être comme ça ? :

Code:

0
For(A,1,3
Matr>list([A],A,L₁
L₁(A)->L₂(A)
max(Ans,3M=sum(L₁
max(Ans,3M=sum(L₂
Matr>list([A]^t,A,L₁
L₁(4-A)->L₂(4-A)
max(Ans,3M=sum(L₁
max(Ans,3M=sum(L₂
End

Mais tel que je l'ai écrit je crois que Ans va changer...

Si j'adapte avec le produit, qu'est que j'obtiendrais comme code ?

Pour l'instant, le morceau pas optimisé avec le prod( donne ça :

Code:

Matr>list([A],L₁,L₂,L₃
Matr>list([A]^T,L₄,L₅,L₆
{L₁(1),L₂(2),L₃(3→⌊A
{L₁(3),L₂(2),L₃(1→⌊B
If prod(L₁)=1 or prod(L₁)=8 or prod(L2)=1 or prod(L2)=8 or prod(L3)=1 or prod(L3)=8 or prod(L4)=1 or prod(L4)=8 or prod(L5)=1 or prod(L5)=8 or prod(L6)=1 or prod(L6)=8 or prod(LA)=1 or prod(LA)=8 or prod(LB)=1 or prod(LB)=8

Reprend mes codes du 21 mai 2014 à 18:54 puis remplace simplement l'opération fondamentale et les valeurs de comparaison.
sum() par prod
3M par M^3
-M par 3-M
=-3 par =8
=3 par =1
-3M par 9-M

J'ai oublié les diagonales dans le message concerné. J'en parelrai plus loin.

----

Le premier code de ton message du 22 mai 2014 à 17:35 est en effet biaisé par les affectations qui modifient Ans. Utilise une autre variable et ce sera réglé.

Cependant tu ne récupères pas les diagonales, tu copies L1 dans L2.
La transposition n'a aucune utilité pour les diagonales.
Tu n'as pas besoin de stocker les lignes et colonnes de la matrice pour en extraire une case à la fois. Tu devrais lire les cases une par une. En effet je ne suis pas convaincu que la rapidité de lecture de matrice par Matr>list compenserait les pertes de temps autour.

Voici une amélioration suivant mon point de vue.

Code:

For(A,1,3
[A](A,A->L₁(A
[A](A,4-A->L₂(A
End
max(prod(L₁),prod(L₂

Je préfère calculer les produits progressivement sans la boucle, comme mes trois code du 20 mai.
----

Seule une boucle ou la fonction seq() ou suite() peut acquérir une diagonale et la stocker dans une liste sans tout écrire pour chaque case.
(( La fonction Sigma() des ti84plus MathPrint peut aussi servir. ))

(( Puisqu'on parle de seq(), on peut aussi optimiser des choses sans boucle grâce à elle. ))

Inspire toi de mon troisième code du 21 mai 2014 18:54 et du second du 20 mai 2014. Ainsi tu auras la conversion en liste des lignes/colonnes et la boucle des diagonales. La seule nuance manquante est que j'avais déjà optimisé avec un produit de liste à liste.

Code:

// les états 0,1,2

//les lignes et colonnes
0
For(A,1,3
Matr>list([A],A,L₁
max(Ans,M^3=prod(L₁
Matr>list([A]^t,A,L₁
max(Ans,M^3=prod(L₁
End
Ans->B

// une simple boucle de diagonales
1->C
1->D
For(A,1,3
C[A](A,A)->C
D[A](A,4-A->D
End
max(B,C=M^3,D=M^3

// une optimisation avec seq(), histoire d'illustrer pour plus tard
prod(seq([A](A,A),A,1,3->C
prod(seq([A](A,4-A),A,1,3->D
max(B,C=M^3,D=M^3

// une optimisation avec un produit de liste à liste, comme la méthodes mon troisième code du 20 mai, mais seulement pour les diagonales

{1,1
For(A,1,3
Ans{[A](A,A),[A](A,4-A
End
max(B,max(Ans=M^3

((
Par ailleurs dans la première partie (lignes/colonnes) du programme ci-dessus et son original du 21 mai :
j'ai rassemblé dans Ans les résultats de la condition de chaque liste,
alors que j'aurais pu commencer par stocker les sommes/produits de chaque ligne/colonne dans des cases d'une liste, et enfin réaliser la condition =3M ou +M^3 sur cette liste à la fin.
Cela se rapprocherait plus de la condition de mon tout premier code du sujet.
))

Pour donner une vue d'ensemble, ceci :

Code:

ClrHome
"+--+--+--+→Str1
"!  !  !  !→Str2
For(I,1,7,2
Output(I,1,Str1
End
For(I,2,6,2
Output(I,1,Str2
End
Output(1,11,"MORPIO
Output(3,13,"J-X
Output(5,13,"J-O
Output(3,12,">
1→J
2→X:2→Y
2→A:2→B
{3,3→dim([A]
Fill(0,[A]
For(I,1,9
Repeat K=105
Output(A,B,"
Output(Y,X,"+
Y→A:X→B
getKey→K
X-3(K=24)+3(K=26→X
Y-2(K=25)+2(K=34→Y
If X>8:2→X
If X<2:8→X
If Y>6:2→Y
If Y<2:6→Y
End
3-J→J
[A](A/2,(B+1)/3)+J→[A](A/2,(B+1)/3
Output(7-2J,12,"
Output(1+2J,12,">
Output(A,B,"
Output(A,B+1,sub("OX",J,1
Matr>list([A],L₁,L₂,L₃
Matr>list([A]^T,L₄,L₅,L₆
{L₁(1),L₂(2),L₃(3→⌊A
{L₁(3),L₂(2),L₃(1→⌊B
If prod(L₁)=1 or prod(L₁)=8 or prod(L₂)=1 or prod(L₂)=8 or prod(L₃)=1 or prod(L₃)=8 or prod(L₄)=1 or prod(L₄)=8 or prod(L₅)=1 or prod(L₅)=8 or prod(L₆)=1 or prod(L₆)=8 or prod(⌊A)=1 or prod(⌊A)=8 or prod(⌊B)=1 or prod(⌊B)=8
Then
Output(8,5,sub("OX",J,1
Output(8,7,"GAGNE !
Stop
End
End
Output(8,4,"MATCH NUL !

Deviendrait cela :

Code:

ClrHome
"+--+--+--+→Str1
"!  !  !  !→Str2
For(I,1,7,2
Output(I,1,Str1
End
For(I,2,6,2
Output(I,1,Str2
End
Output(1,11,"MORPIO
Output(3,13,"J-X
Output(5,13,"J-O
Output(3,12,">
1→J
2→X:2→Y
2→A:2→B
{3,3→dim([A]
Fill(0,[A]
For(C,1,9
Repeat K=105
Output(A,B,"
Output(Y,X,"+
Y→A:X→B
getKey→K
X-3(K=24)+3(K=26→X
Y-2(K=25)+2(K=34→Y
If X>8:2→X
If X<2:8→X
If Y>6:2→Y
If Y<2:6→Y
End
3-J→J
J→[A](A/2,(B+1)/3
Output(7-2J,12,"
Output(1+2J,12,">
Output(A,B,"
Output(A,B+1,sub("OX",J,1
0
For(C,1,3
Matr>list([A],C,L₁
max(Ans,J^3=prod(L₁
Matr>list([A]^t,C,L₁
max(Ans,J^3=prod(L₁
End
Ans->D
1->E
1->F
For(C,1,3
E[A](C,C)->E
F[A](C,4-C->F
End
If max(D,E=M^3,F=M^3
Then
Output(8,5,sub("OX",J,1
Output(8,7,"GAGNE !
Stop
End
End
Output(8,4,"MATCH NUL !

Si j'ai pas fait d'erreur...  

Du coup cette ligne peut être supprimée non ? (edit  : ou alors que avec seq()...)

Code:

[A](A/2,(B+1)/3)+J→[A](A/2,(B+1)/3

EDIT : La première et la troisième modification pointées par Linkakro le 22/05 à 21:14 ont été effectuées.

Il manque If et Then pour lire la condition de victoire.

Code:

If max(D,E=M^3,F=M^3
Then

Déplace la complémentation de J. Il ne faut pas changer de numéro de joueur entre l'affectation de la matrice et les tests de victoire ou modifier le test.

L'affectation de la matrice me surprend.
[A](A/2,(B+1)/3)+J→[A](A/2,(B+1)/3
Tu peux simplement affecter J. La valeur neutre est zéro et représente le vide.
(( Si tu avais les état 1,0,-1 alors on aurait pu tricher et permettre d'annuler des coups (avec deux décrément du compteur de coups), mais cela ne convient pas avec 0,1,2. ))

Tout est appliqué ici pour calculer sans trop d'optimisation la condition sur la totalité de la matrice. Mais si tu extrais le contenu de la boucle des lignes/colonnes, alors tu peux analyser seulement la ligne et la colonne qui ont été jouées au tour d'avant. Ainsi cela se rapprochera de mon tout premier exemple, avec optimisation du calcul en plus.

A propos de la complémentation de J,
Si je fais comme ça, ça va ? (je ne montre que ce qui est après la boucle Repeat) :

Code:

J→[A](A/2,(B+1)/3
Output(7-2J,12,"
Output(1+2J,12,">
Output(A,B,"
Output(A,B+1,sub("OX",J,1
0
For(C,1,3
Matr>list([A],C,L₁
max(Ans,J^3=prod(L₁
Matr>list([A]^t,C,L₁
max(Ans,J^3=prod(L₁
End
Ans->D
1->E
1->F
For(C,1,3
E[A](C,C)->E
F[A](C,4-C->F
End
If max(D,E=M^3,F=M^3
Then
Output(8,5,sub("OX",J,1
Output(8,7,"GAGNE !
Stop
End
3-J->J            // Ici ?
End
Output(8,4,"MATCH NUL !

Oui je pense à ça. Mais sâche que tu n'as pas les meilleurs tests parmi ceux mentionnés.

Oui j'ai bien vu en effet. Je vais améliorer tous ça dans les jours à venir.

En remplaçant les tests par mes préférences personnelles.

Spoiler:

Mais je préfère largement cet algorithme plutôt que des ruptures sauvages telles que Stop.

Spoiler:

Je n'ai pas critiqué les calculs de coordonnées, mais je préférerais représenter les coordonnées de la matrice et multiplier vers les coordonnées graphiques plutôt que diviser les coordonnées graphiques vers les coordonnées de la matrice.

EDIT : commentaires de correction des calculs de ligne et colonne du test de victoire

Je préférais aussi changer l'initialisation. Je préfère aussi ton code, personnellement, notamment car celui de mon précédent message gagnait des octets mais perdait en vitesse. Problème réglé !   
Tant qu'on est dans les opérations de listes, est-ce qu'elles permettraient d'optimiser les initialisations de variables au début :

Code:

2→J
2→X:2→Y
2→A:2→B

Dans le sens assigner 2 à plusieurs variables en même temps. J'ai un peu fouillé mais je tombe souvent sur des solutions relatives à d'autres langages (C ou C++) ; (peut-être pas les opérations de listes ou autre chose, je sais pas..)

[[ EDIT : Après démarrage sur ma calcu, je trouve une "ERR: INVALID DIM" sur ces lignes, selon si je joue sur elles ou pas :

Code:

Matr>List([A],B,L1
// ou
Matr>List([A]^t,A,L1

Je pense que c'est du au fait que les coordonnées du placement ne correspondent pas aux coordonnées dans la matrice, sauf erreur de ma part. ]]

Affecter plusieurs variables numériques en une seule opération est impossible à ce que je sache.

Je me suis trompé en confondant les coordonnées de matrice et les coordonnées d'écran. C'est bête puisque j'avais déjà mentionné la différence entre les deux.
Donc utilise A/2 et (B+1)/3 en place de A et B pour le test abrégé dans ton programme.

Ok dommage pour l'affectation. Bon ba ça devrait être fonctionnel alors. Merci !  
Peut-on estimer que l'optimisation est maximale où y a t-il une meilleure solution encore ?
Au lancement, je note aussi qu'il commence à jouer O et non X. J'ai donc changé l'initialisation de J en 1->J (j'utilise ton 2e code).

L'optimisation est différente selon qu'on privilégie la fluidité ou la taille du programme ou même des variables. Et puis le TI-Basic est interprété donc d'autres considération entrent en jeu selon ce qui est interprété ou calculé en interne.

J'ai déjà optimisé avec la variable Ans/Rép. Je ne pense pas qu'on puisse faire mieux sur la gestion des variables.

J'ai insisté pour calculer simultanément les produits des diagonales, mais tu es libre de revenir aux deux calculs avec deux variables.

Tu tenais à optimiser en convertissant la matrice en liste. Cela permet de parcourir la matrice avec les fonctions assembleur plutôt que d'interpréter des coordonnées TI-Basic pour chaque case.
Je suis plutôt tenté par les fonctions augment/chaîne et seq/suite.
Mais ce que je préfère est le troisième test de mon premier message : une seule boucle et produit liste à liste pour rassembler le plus d'opérations en le moins de commandes TI-Basic.

Non je pense que ça va.

J'ai lancé le programme sur ma calcu, et j'ai remarqué quelque chose d'important : le compteur de coups n'arrête jamais le jeu, tant et si bien que le "Match nul !" ne sera jamais affiché. Erreur de recopie de ma part ? Mon code ressemble à ça :

Code:

ClrHome
For(I,1,7,2
Output(I,1,"+--+--+--+
End
For(I,2,6,2
Output(I,1,"!  !  !  !
End
Output(1,11,"MORPIO
Output(3,13,"J-X
Output(5,13,"J-O
Output(3,12,">
1→J
2→X:2→Y
2→A:2→B
0identity(3→[A]
DelVar θRepeat θ=9 or Ans
θ+1→θ
3-J→J
Repeat K=105
Output(A,B,"
Output(Y,X,"+
Y→A:X→B
getKey→K
X-3(K=24)+3(K=26→X
Y-2(K=25)+2(K=34→Y
X+9(X<2)-9(X>8→X
Y+6(Y<2)-6(Y>6→Y
End
J→[A](A/2,(B+1)/3
Output(7-2J,12,"
Output(1+2J,12,">
Output(A,B,"
Output(A,B+1,sub("OX",J,1
Matr>list([A],(B+1)/3,L₁
prod(L₁
Matr>list([A]^t,A/2,L₁
max(J^3={Ans,prod(L₁→D
{1,1
For(C,1,3
Ans{[A](C,C),[A](C,4-C
End
max(D,max(J^3=Ans
End
If Ans
Then
Output(8,5,sub("OX",J,1
Output(8,7,"GAGNE !
Else
Output(8,4,"MATCH NUL !

Dernière chose, je me demandais si pour empêcher le remplacement (en apparence) des cases, quelque chose comme ça irait :

Code:

If [A](A/2,(B+1)/3
A+2→A

Sauf que tel que c'est ça m'a l'air d'être pas pratique à gérer et ça ne prend en compte que la position du curseur. Y aurait-il une solution plus efficace pour empêcher la pression si la case est remplie, ou tout simplement empêcher le curseur de passer sur la case ?

EDIT : code corrigé

Nous avons oublié que la variable C est utilisée par les boucles de test donc elle ne peut être utilisée pour compter les coups.
Il faut simplement utiliser une autre variable pour une des deux. ( Excepté pour une solution avec seq() puisque la variable est alors indépendante. )

La ligne suivante est incomplète.
Repeat C=9 or Ans

Place une boucle autour de la détection de pression de touche pour interdire de jouer dans une case occupée. Ce jeu n'est pas dynamique donc contente toi d'une boucle.

Ok merci. Pourtant il me semblait avoir changé la variable dans mon programme... Un oubli alors. Bon ba ça a l'air d'aller là.

Pourrait-on avec une matrice optimiser ce truc ? :

Code:

If X>8:2→X
If X<2:8→X
If Y>6:2→Y
If Y<2:6→Y

Dans le genre définir une zone au curseur en en définissant une dans une matrice ?

Code:

X-3(K=24)+3(K=26→X
Y-2(K=25)+2(K=34→Y
If X>8:2→X
If X<2:8→X
If Y>6:2→Y
If Y<2:6→Y

Tu peux exploiter les booléens:

Code:

X-3(K=24)+3(K=26→X
Y-2(K=25)+2(K=34→Y
X+9(X<2)-9(X>8->X
Y+6(Y<2)-6(Y>6->Y

Je ne comprends pas le rapport avec la matrice par contre.

Bon ok merci, c'est ce que je recherchais de toute façon !   Je pensais que ça se faisait avec une matrice c'est tout.

Ah bah je vois pas comment associer une matrice là dedans   

Les calculatrices TI ne permettent pas de réaliser des tests terme à terme de matrices, on peut seulement tester l'égalité ou inégalité de deux matrices.
[[1,2][3,4]]=[[0,0][0,0]] renverra simplement le nombre zéro signifiant "faux".

Un produit matriciels peut être utilisés mais cela n'a aucun intérêt car l'opération est lourde et le stockage dans les variables de coordonnées sera une perte que je juge prédominante.
Quant à une somme matricielle, elle n'a aucun intérêt devant les listes.

On peut comparer deux listes terme à terme dans le calcul des coordonnées, mais le stockage des nombres résultat posera toujours le même problème. (confère mon propos sur les matrice)

Ci-dessous opérations simultanées et défaut de stockage dans les variables numériques.

Code:

{X,Y}+(K={26,34})-(K={24,25->L1
L1(1->X
L1(2->Y

Ci-dessous une totale improvisation de mauvaise qualité car je n'ai aucun souvenir de mes essais passés. Cela illustrera le niveau de complexité inutile dans un cas de produit matriciel.

Code:

[[X][Y]]+[[-1,1]]*[[K=24,K=25][K=26,K=34->[A]
[A](1,1->X
[A](1,2->Y

###
Utilisez donc l'éternelle solution des booléens qui est la meilleure des réductions de code et est correcte dans les programmes sans exigence de vitesse.
En cas de vitesse les booléens peuvent ne pas convenir, cela reste à étudier au cas par cas.