Version en ligne

Tutoriel : Apprenez à programmer en TI-Basic !

Table des matières

Apprenez à programmer en TI-Basic !
Introduction à la TI
Vue d'ensemble de la calculatrice
Le TI-Basic
Les fonctionnalités de la TI
Les erreurs
Concevoir ses premiers programmes
Les groupes d'instructions
Les résultats
Les commandes d'exécution
L'optimisation
Les variables
Qu'est-ce qu'une variable ?
Stockage et extraction de valeur
Récupérer une entrée
Les branchements
Les étiquettes et redirections
Les menus
Les procédures
Les conditions
Les tests
La boucle IF
Un petit exercice
Les boucles
La boucle While
La boucle Repeat
La boucle For
Exercices
TP : plus ou moins... froid ou chaud
Plus ou moins
Correction
Chaud ou froid
Correction
Un petit pack...
Les listes
Les bases
Mémorisation
Accéder à chaque terme
Les listes personnalisées
Opérations entre listes
Fonctions associées
Attacher une formule à une liste
Editeur de listes
TP : décomposeur
La décomposition : ça veut dire quoi ?
Construire le programme pas à pas
Le code complet
Les matrices
Le format d'une matrice
Les variables matrices
Accès individuel à un terme
Les opérations
L'éditeur de matrices
TP : un snake
Gérer la pression des touches
Conseils
Les chaines de caractères
Vous les avez déjà utilisées !
Comment les stocker
Les opérations
TP : convertisseur de bases
Les bases : ça veut dire quoi ?
Construire le programme pas à pas
Le code complet
Les graphiques
Définition de la fonction et affichage
Quelques réglages...
La fenêtre
Dans un programme
Les fonctions qui retournent plusieurs valeurs
Les images par la fonction
Les ensembles de définition
Les GDB
Le dessin à la volée
Quelques réglages...
Les éléments graphiques de haut niveau
Les éléments graphiques de bas niveau
Des courbes
Les deux écrans
Les variables image
En live sur l'écran graphique
Les statistiques
Gérer les listes
Faire une étude statistique sur l'écran de calculs
Faire une étude statistique de façon graphique
Modéliser une étude statistique
L'art de faire des graphismes avec des stats
Optimisation
Ne les fermez pas !
Gain de vitesse
Autres astuces
Tout sur les String, et même ... beaucoup plus que tout
La magie de DelVar
Amusons-nous avec les End
Le END conditionnel
Le ELSE conditionnel
Un End qui se termine ailleurs
Index de commandes
Comment utiliser le tableau
Tableau des commandes
La gestion de la mémoire
Pour les modèles TI-83+/84+
Pour les modèles TI-76.fr/82stats/82stats.fr/83
Pour les modèles TI-82
Renommer un programme
Echange de données entre 2 calculatrices
Câbles à utiliser
Utiliser le menu Link
Transferts de données en TI-Basic

Apprenez à programmer en TI-Basic !

Vous possédez une TI graphique, et vous voudriez faire plus de choses avec ? Vous avez entendu parler du TI-Basic, mais vous aimeriez bien savoir comment ça marche ? Ou encore, votre professeur de Mathématiques vous demande d'apprendre ce langage ?

Mon tutoriel est alors fait pour vous, car il va vous permettre d'apprendre facilement ce langage, de A à Z.

Pour toutes questions/remarques concernant le tutoriel et ce qu'il enseigne, le sujet Apprenez à programmer en TI-Basic ! est à votre disponibilité.
Et n'oubliez pas les annexes qui sont à la fin, elles vous seront utiles.

Allez, c'est parti ! :ninja:

Introduction à la TI

Vue d'ensemble de la calculatrice

Bonjour à vous, chers heureux lecteurs ! Si vous êtes sur ce tutoriel, c'est probablement que vous avez reçu récemment une calculatrice graphique Texas Instrument, TI pour les intimes. Vous savez faire des calculs dessus, mais cela ne vous suffit pas : vous aimeriez bien faire des programmes, comme par exemple des jeux. :p

Ou encore, vous devez apprendre le TI-Basic parce-que votre professeur vous le demande.

Je considérerai dans ce tutoriel que vous ne connaissez aucun langage, et que d'ailleurs, vous ne savez même pas ce qu'est un langage... Je vous instruirai tout cela !

Vue d'ensemble de la calculatrice

Introduction à la TI Le TI-Basic

Vue d'ensemble de la calculatrice

Votre calculatrice ressemble à ceci :

Image utilisateur

La disposition des touches diffère quelque peu avec les autres modèles, comme la TI-82 stats. Ne vous inquiétez pas, je vous indiquerais ces différences.


Introduction à la TI Le TI-Basic

Le TI-Basic

Vue d'ensemble de la calculatrice Les fonctionnalités de la TI

Le TI-Basic

Le TI-Basic : c'est quoi ?

Le TI-Basic est un langage de programmation comme un autre. Ce n'est rien d'autre qu'une syntaxe inventée par les gars de Texas Instrument qui permet de demander à la calculatrice d'effectuer des actions précises. Par exemple, afficher du texte, faire des calculs, demander à l'utilisateur un nombre etc.

Ce langage est très facile à apprendre, mais pas extrêmement puissant... cela reste néanmoins un langage idéal pour débuter, et avec lequel vous pourrez très vite arriver à de bons résultats. Et regardez d'ailleurs un Worms de ma composition qui accepte jusqu'à 6 joueurs, où chaque joueur peut-être un humain ou une intelligence artificielle :

Image utilisateur

(Si l'image est très lente, c'est sûrement votre
navigateur qui supporte mal les gif animées)

Il existe un langage qui est similaire en certains points : le CASIO-BASIC. C'est aussi du Basic, mais pour les casios ! Et la syntaxe est bien sûr différente.

Vous pourrez programmer de ce langage directement sur la calculatrice, donc, pas besoin de PC pour son édition !

Le TI-Basic : comment ça marche ?

Le TI-Basic, c'est une liste de courses... c'est à dire qu'il ne fait qu'indiquer des tâches à exécuter, les unes après les autres :

En TI-Basic, ça donne ça :

:Input R
:Disp "L'AIR EST :"
:Disp πR²

Plutôt simple, non ? La calculatrice va donc analyser une par une les instructions que l'on lui donne et les exécuter chacune à son tour.


Vue d'ensemble de la calculatrice Les fonctionnalités de la TI

Les fonctionnalités de la TI

Le TI-Basic Les erreurs

Les fonctionnalités de la TI

L'écran principal

L'écran principal permet de faire des calculs. Pour faire un calcul, il suffit de le taper grâce au clavier, et de valider avec

Image utilisateur

.
Il est constitué de 8*16 caractères. Dans les calculs, des fonctions comme cosinus, logarithme etc. peuvent être utilisées. Il suffit pour cela de presser

Image utilisateur

,

Image utilisateur

etc.

Grâce à la touche

Image utilisateur

, il est possible d'accéder à des fonctions supplémentaires, celles qui se trouvent en haut à gauche de chaque touche. Par exemple, il faut faire

Image utilisateur
Image utilisateur

pour entrer le fameux π.

Voici les touches qui permettent d'éditer convenablement une expression :

Image utilisateur

: efface tout le calcul en cours. S'il n'y en a pas, efface tout l'écran.

Image utilisateur

: déplace le curseur d'un cran vers la gauche.

Image utilisateur

: déplace le curseur d'un cran vers la droite.

Image utilisateur

: supprime le caractère à l'emplacement du curseur.

Image utilisateur
Image utilisateur

: met le curseur en mode d’insertion : ainsi, lorsque vous tapez un caractère et qu'il y en a déjà un à l'emplacement du curseur, il est inséré à la place d'écraser le précédent.

Il est également possible de taper du texte. Chaque lettre de l'alphabet se retrouve en haut à droite de chaque touche, et on peut y accéder en pressant

Image utilisateur

. Pour verrouiller le mode ALPHA (ce qui permet de taper plusieurs lettres), il faut presser

Image utilisateur
Image utilisateur

, et pour revenir en mode normal, il faut à nouveau presser

Image utilisateur

.

Pour les TI-76.fr, la touche

Image utilisateur

n'existe pas mais se voit remplacée par la touche

Image utilisateur

permettant d'accéder à un clavier virtuel pour taper du texte :

Image utilisateur

Il faut alors utiliser les touches directionnelles pour sélectionner des caractères et

Image utilisateur

pour les insérer. Pour terminer, il faut choisir l'option ">Terminé<".

Les menus

Certaines touches du clavier permettent l'accès à des menus. Par exemple, le menu MATH en est un et se trouve en pressant

Image utilisateur

.
Les menus sont souvent séparés en plusieurs colonnes ; pour passer de l'une à l'autre, il faut presser

Image utilisateur

ou

Image utilisateur

. Pour monter ou descendre, il faut presser

Image utilisateur

ou

Image utilisateur

. Pour insérer un élément du menu, il faut soit presser

Image utilisateur

, soit taper le caractère qui correspond à l'élément.

Exemples :

Image utilisateur
Image utilisateur
Image utilisateur

ou

Image utilisateur
Image utilisateur
Image utilisateur

pour insérer la fonction abs(

Image utilisateur
Image utilisateur
Image utilisateur
Image utilisateur
Image utilisateur

ou

Image utilisateur
Image utilisateur
Image utilisateur
Image utilisateur
Image utilisateur

pour insérer la fonction Matr►list( (que nous verrons plus tard)

Pour quitter un menu sans rien insérer, et retourner là où vous étiez, il faut presser

Image utilisateur

.

Le catalogue

Le catalogue est un menu qui permet de retrouver quasi toutes les fonctions de la calculatrice. Pour y accéder, on tape

Image utilisateur
Image utilisateur

.
On utilise les touches directionnelles pour sélectionner une fonction et

Image utilisateur

pour valider. Pour annuler et quitter le menu, on presse

Image utilisateur

ou même

Image utilisateur
Image utilisateur

pour se retrouver sur l'écran principal.

Pour trouver plus rapidement une fonction, il est possible d'indiquer par quelle lettre elle commence. Par exemple, si on veut chercher la fonction cos (ce qui serait un tantinet insoucieux car une touche existe pour cela, mais c'est juste pour l'exemple), on va dans le catalogue puis on tape

Image utilisateur

(ALPHA étant automatiquement activé), et on descend jusqu'à trouver la fonction puis on valide.


Le TI-Basic Les erreurs

Les erreurs

Les fonctionnalités de la TI Concevoir ses premiers programmes

Les erreurs

Image utilisateur

Il vous est peut-être déjà arrivé de taper un calcul erroné. Dans ce cas, un menu composé de deux choix s'est offert à vous : Goto pour amener le curseur au niveau de l'erreur, et Quit pour annuler le calcul. Voici un petit récapitulatif des erreurs, il n'est pas exhaustif car il y a beaucoup d'erreurs différentes, je mets donc ici les principales. Si vous tombez sur une erreur non mentionnée ici, vous pouvez consulter le manuel.

ARGUMENT

Vous avez utilisé une fonction sans donner le bon nombre d'arguments.

BREAK

Vous avez stoppé un calcul trop long en pressant la touche ON.

DIVIDE BY 0

Vous avez tenté de diviser un nombre par zéro, où mis des valeurs dans des fonctions qui les a ramenées à effectuer ce calcul.
Vérifiez alors que la valeur que vous avez mise est bien prise en charge par la fonction.

DOMAIN

Vous avez spécifié une valeur dans une fonction en dehors de l'intervalle autorisée.

MEMORY

La mémoire restante de la calculatrice est insuffisante pour terminer le calcul.
Vérifiez que vous n'avez pas fait un erreur dans celui-ci obligeant la calculatrice à recalculer en boucle la même chose sans s'arrêter.

OVERFLOW

Le résultat du calcul ou d'une portion du calcul donne une valeur plus petite que -9.999999999 imes 10^{99} ou plus grande que 9.999999999 imes 10^{99}.

SYNTAX

Vous avez commis une erreur de syntaxe. :p
C'est à dire que vous avez mis des parenthèses en trop, des virgules mal placées etc. etc.

Ou alors vous avez tenté d'exécuter sur l'écran principal une commande réservée aux programmes.

Allez, on peut s'attaquer aux bases du langage. :ninja:


Les fonctionnalités de la TI Concevoir ses premiers programmes

Concevoir ses premiers programmes

Les erreurs Les groupes d'instructions

C'est donc ici que vous allez faire vos premiers pas en TI-Basic. Ne vous inquiétez pas, tout est détaillé et facile à comprendre, mais n'hésitez pas à relire plusieurs fois si nécessaire pour les plus coriaces d'entre vous. :pirate:
De plus, n'oubliez pas que le sujet Apprenez à programmer en TI-Basic ! est là pour vous si vous avez des questions (il faut naturellement être inscrit au site).

Les groupes d'instructions

Concevoir ses premiers programmes Les résultats

Les groupes d'instructions

Bien, prenez votre calculatrice dans les mains, allumez-là, et calculez-moi 78 imes (54+7). Allez, et que ça saute !

Image utilisateurImage utilisateurImage utilisateurImage utilisateurImage utilisateurImage utilisateurImage utilisateurImage utilisateurImage utilisateurImage utilisateur

La combinaison de touches est :

Je suppose que vous ne serez pas très étonnés d'avoir en face de vous l'écran suivant :

Image utilisateur

Pourtant, pour calculer cette expression, la calculatrice a dû l'interpréter afin de donner le résultat souhaité. Notez bien que cette expression peut aussi s'appeler une instruction.

Maintenant, admettons que vous vouliez calculer \sqrt{78 imes (54+7)} + 78 imes (54+7). On a une même expression qui apparait deux fois. Mais il serait trop fatiguant de la taper les deux fois, non ? Lorsqu'une expression est calculée, le résultat est mémorisé dans quelque chose de spécial se nommant Ans. Et nous allons utiliser ce Ans qui remplacera le résultat de la dernière expression.

Il va alors nous suffire de taper sur l'écran principal √(Ans)+Ans puis ENTER et de lire le résultat :

Image utilisateur

Mais admettons à présent que vous en ayez rien à faire du résultat de 78 imes (54+7) mais que vous vouliez seulement celui de \sqrt{78 imes (54+7)} + 78 imes (54+7).
Commencez alors par taper la première expression, ensuite, insérez les deux-points avec

Image utilisateur
Image utilisateur

puis tapez la seconde expression, et enfin, validez avec ENTER :

Image utilisateur

Que s'est-il passé ? Vous avez tout simplement demandé à la calculatrice de calculer plusieurs expressions, les unes à la suite des autres. Et c'est bien sûr ce qu'elle a fait. La première expression a affecté la valeur de Ans, et cela a permis à la seconde de faire son boulo.

Vous pouvez vous amuser à taper autant d'expressions que vous le souhaitez, du moment que vous les séparez à chaque fois par ":". On appelle ça un groupe d'instructions.

Voici un exemple où l'on calcule \left ( \sqrt{78 imes (54+7)} + 78 imes (54+7) ight ) ^2 + \left ( \sqrt{78 imes (54+7)} + 78 imes (54+7) ight ) ^3 :

Image utilisateur

La suite d'expressions est ici : 78*(54+7):√(Ans)+Ans:Ans²+Ans³

En encadrant les différentes expressions chacune par une couleur, ça donne ça :

Image utilisateur

En effet, Ans remplace la valeur de la dernière expression calculée. Donc, si on remplace la première expression par une boîte bleue, on peut se permettre dans l'expression suivante d'utiliser la boite bleue sans se préoccuper de ce qu'il y a dedans. De même, en mettant le tout dans une boîte rouge, on peut se permettre de l'utiliser.

Comme vous êtes à présent des AS des groupes d'instructions, on peut s'attaquer aux résultats et nous pourrons enfin en arriver aux programmes !


Concevoir ses premiers programmes Les résultats

Les résultats

Les groupes d'instructions Les commandes d'exécution

Les résultats

Sur l'écran principal

Avant de s'attaquer enfin aux programmes, abordons les résultats. Dans nos exemples précédents, les résultats des expressions étaient 4758, 4826.978257, et 1.124905372*1011. Le plus souvent, un groupe d'instructions retournera un résultat.

Quoi !? Parce-qu'un calcul, ça peut retourner... rien du tout ?

Souvenez-vous, je vous ai dit qu'une expression pouvait aussi être appelée une instruction... mais une instruction n'est pas forcément un calcul. Elle peut simplement demander d'effectuer quelque chose de précis sans renvoyer de valeur. Par exemple, entrez la chose suivante sur l'écran principal puis validez (en utilisant le catalogue, détaillé dans le premier chapitre) :

Clear Entries
ou
Efface entrées

Vous obtenez alors l'écran suivant :

Calculatrices
anglaises

Calculatrices
françaises

Image utilisateurImage utilisateurImage utilisateurImage utilisateur

Le Done (ou Fait) indique que l'instruction a bien été exécutée, mais sans rien retourner. Par ailleurs, la valeur de Ans n'a pas été modifiée.

Essayez d'ailleurs de n'entrer que les deux-points :

Image utilisateur

Là aussi, il n'y a pas de résultat. Et s'il y a au moins deux instructions vides après une expression, il n'y a de même pas de résultat :

Image utilisateur

Cependant, la valeur de Ans a été modifiée.

Avec un programme

Enfin ! :p
Alors, pour créer un programme, pressez d'abord

Image utilisateur

, puis allez dans la colonne NEW ou NOUV et validez. Tapez le nom du programme (ALPHA est activé par défaut), et validez. Voici ce que vous obtenez (selon le nom que vous avez choisi) :

Image utilisateur

Vous pouvez voir tout en haut de l'écran le nom de votre programme, et à la ligne d'en dessous, deux-points ":" suivis du curseur. Ne rentrez rien mais sortez plutôt du programme en faisant

Image utilisateur
Image utilisateur

. Exécutons le programme. Il faut pour cela mettre son identification sur l'écran principal. Allez dans le menu

Image utilisateur

, placez le curseur sur votre programme (dans la colonne EXEC) et pressez

Image utilisateur

. Voici alors ce que vous pouvez observer :

Image utilisateur

La mention prgm indique que l'on veut exécuter un programme, et le nom doit suivre cette mention. Pressez à nouveau

Image utilisateur

:

Image utilisateur

Visiblement, il ne s'est rien passé : logique, puisqu'il n'y a pas de contenu. Le Done indique que le programme s'est bien exécuté mais que celui-ci n'a rien renvoyé.

Maintenant, on va lui mettre du contenu, dans ce programme. On va éditer le programme en faisant

Image utilisateur
Image utilisateur

puis en sélectionnant le programme (dans notre exemple : PREMPROG). Pour le contenu, c'est un jeu d'enfant, car toute instruction valable sur l'écran principal marche également dans un programme. On peut par exemple y mettre un calcul, comme "58*74+23". Ensuite, on quitte le programme et on l'exécute :

Code du programme

Résultat du programme

Image utilisateurImage utilisateurImage utilisateurImage utilisateur

Il s'est passé exactement la même chose que si vous l'aviez tapé sur l'écran principal. Pour l'instant, cela peut paraitre inutile. Nous verrons dans la sous-partie suivante quelques commandes qui nous permettent d'améliorer cela.

Dans un programme, comme sur l'écran principal, il est possible d'entrer plusieurs instructions. Pour cela, on peut soit les séparer par ":" (comme avec l'écran principal), soit passer à la ligne suivante avec

Image utilisateur

. Notez d'ailleurs qu'une ligne commence toujours par ":". S'il n'y en a pas, c'est alors ce qui déborde d'une autre ligne.

Les programmes suivants sont ainsi identiques :

:78*(54+7):√(Ans)+Ans

:78*(54+7)
:√(Ans)+Ans

Pour insérer à quelque endroit du programme une nouvelle ligne, il suffit de faire

Image utilisateur
Image utilisateur
Image utilisateur

.
Pour effacer le contenu d'une ligne, il faut faire

Image utilisateur

.
Pour supprimer une ligne, il faut soit que celle-ci soit vide puis taper

Image utilisateur

, soit être à la fin de la ligne précédente puis taper

Image utilisateur

.

Un petit exo

Sans pratique, on ne retient rien. Nous allons donc ici faire un mini-exo qui consiste à automatiser le calcul de l'image d'une fonction. L'interface ne sera pas extra, mais nous verrons comment changer cela plus tard.

Soit la fonction f définie par f(x) = \sqrt{x - 5} + x^3 - 78x
Si l'on veut calculer des images par f, il ne serait pas très confortable de les calculer une par une à la main. Nous allons automatiser cela.

Créer un nouveau programme se nommant CALCFN, et y mettre le contenu suivant :

:√(Ans-5)+Ans³-78Ans

Ans remplace donc ici x. Pour calculer des images, il suffit donc de mettre dans Ans leur antécédent puis l'exécution de prgmCALCFN sur l'écran principal, en validant à chaque fois :

10:prgmCALCFN
15:prgmCALCFN
π+12.3:prgmCALCFN
prgmPREMPROG:prgmCALCFN

Dans chacun des cas, la première valeur sera placée dans Ans qui lui-même sera utilisé par le programme. À chaque validation, le résultat sera affiché.
Les deux derniers exemples montrent que nous ne sommes pas limités à de simples valeurs, mais également aux expressions, ou aux appels de programmes... (ici, PREMPROG que nous avons auparavant construit, met 4315 dans Ans, mais il pourrait tout aussi bien ne pas changer sa valeur)


Les groupes d'instructions Les commandes d'exécution

Les commandes d'exécution

Les résultats L'optimisation

Les commandes d'exécution

Jusqu'à présent, toutes les instructions de nos programmes étaient uniquement composées d'expressions. Mais une instruction peut contenir autre chose : une commande d'exécution (ce que nous allons voir ici), une commande de structure (qui sert pour les boucles que nous verrons plus tard) ou une commande de stockage (servant pour les variables que nous étudierons également plus tard).

Voici une commande que nous avons déjà rencontrée :

Clear Entries
ou
Efface entrées

Comme de nombreuses commandes d'exécution et de structure, cette commande ne renvoie rien : elle ne change donc pas non plus Ans.
Les commandes permettent de faire diverses choses, comme afficher du texte, par exemple, ou encore demander un nombre à l'utilisateur. Mais ça peut aller beaucoup plus loin ! Nous ne verrons ici que quelques commandes d'exécution basiques.
Mais attention ! Les commandes que nous allons voir ne sont pas exécutables à partir de l'écran principal. Eh oui, celui-ci est bien limité...

Pour les trouver, aller dans le menu

Image utilisateur

à partir de l'édition d'un programme.

Effacer l'écran

Voici la commande : ClrHome ou EffEcr
Elle ne fait qu'effacer l'écran, l'historique des entrées est donc conservé.
La valeur de Ans n'est pas modifiée.

Voici les étapes détaillées pour accéder à cette commande :

Image utilisateurImage utilisateurImage utilisateurImage utilisateurImage utilisateurImage utilisateurImage utilisateurImage utilisateur

Il faut être dans l'édition
d'un programme.

Image utilisateur

Appuyer sur

Image utilisateur

Appuyer sur

Trois possibilités :

  • Image utilisateurImage utilisateur
  • Image utilisateurImage utilisateurImage utilisateur

    *8

  • Image utilisateurImage utilisateurImage utilisateur

    *5

Avec un peu d'habitude, vous connaitrez la position des commandes par cœur, et il sera plus rapide de les insérer en utilisant la première méthode (plutôt que d'appuyer plein de fois sur les touches directionnelles). Je ne détaillerais pas l'emplacement pour les autres commandes, à vous de vous balader dans le menu pour les trouver. Vous trouverez en annexe du tutoriel une liste des commandes de la TI (non exhaustive) qui renseigne à chacune d'entre elles la séquence de touches pour l'insérer ainsi que la correspondance anglais <=> français.

L'affichage
Disp

Jusqu'ici, nous ne pouvions afficher qu'une seule chose dans un programme, grâce au résultat de celui-ci. Voici donc une commande qui permet d'afficher ce que l'on veut, et quand on veut : Disp
Il suffit de la faire suivre par ce que l'on veut afficher. Exemple :

:25*35
:Disp Ans // affiche 875
:Disp 2Ans // affiche 1750

Programme
en anglais

Programme
en français

Résultat

Image utilisateurImage utilisateurImage utilisateurImage utilisateurImage utilisateurImage utilisateur

Le Done est logique : notre programme ne retourne pas de résultat ! Il a cependant affecté Ans.

Il est possible d'afficher plusieurs choses avec Disp en séparant les différents éléments avec la virgule de séparation (et non le point) qui se trouve ici :

Image utilisateur

Notre programme peut donc se simplifier comme ceci :

:25*35
:Disp Ans,2Ans

Le résultat est exactement le même. Notez que l'on peut aussi afficher du texte, il suffit pour cela de mettre l'élément entre guillemets :

:Disp "HELLO !"

Voici le résultat :

Image utilisateur

Vous pouvez aussi mettre plusieurs éléments lorsque vous affichez du texte. Une p'tite restriction : chaque portion de texte ne doit excéder 16 caractères (la largeur de l'écran). Il faut donc diviser un long texte en plusieurs parties :

Ne faites pas ceci :

:Disp "SALUT, COMMENT VAS-TU ?"

Mais :

:Disp "SALUT, COMMENT","VAS-TU ?"

Un affichage avec Disp ne modifie pas la valeur de Ans.

Output

La commande Output( permet d'afficher du texte à un endroit localisé. Elle prend trois arguments : le premier, le numéro de ligne, le deuxième, le numéro de colonne, et le troisième, le texte. Un petit exemple :

:Output(5,2,"HELLO !!")

Résultat :

Image utilisateur

Comme vous pouvez le voir, cela ne change pas le curseur d'emplacement. Les numéros de ligne et de colonne peuvent également être des expressions. Exemple :

:Output(Ans+3,4*2,"HELLO !!")

Mais le résultat doit être un entier strictement supérieur à 0, et inférieur ou égal à 16 pour la colonne et 8 pour la ligne. Le texte peut être aussi long que l'on veut. S'il sort de l'écran, il déborde sur la ligne d'après :

:Output(5,7,"HELLO WORLD !!")

Résultat :

Image utilisateur

On peut également afficher un nombre avec Output, par exemple : Output(5,2,4Ans-5).

Remarque : il n'y a pas de "Done" lorsque la dernière instruction exécutée fait usage de la commande "Output".

Un affichage avec Output ne modifie pas la valeur de Ans.

Les pauses

Ouf ! après tout ce boulo, je ferai bien une pause ! Malheureusement, ce n'est pas de cela que nous allons parler. >_

Voici la commande : Pause
Elle permet de marquer une pause. Des petits pixels clignotent en haut à droite en attendant que l'utilisateur presse ENTER.

Notez qu'il est également possible d'ajouter quelque chose après cette commande : un élément à afficher. Mais un seul. Pour le texte, vous pouvez alors le faire de la longueur que vous souhaitez, l'utilisateur n'aura qu'à le faire défiler avec

Image utilisateur

et

Image utilisateur

.

Un affichage avec Pause modifie la valeur de Ans.

En résumé :
les commandes d'exécution servent à effectuer des actions précises comme par exemple effacer l'écran avec ClrHome ou EffEcr, afficher du texte ou des nombres avec Disp, ou encore marquer une pause avec Pause. Parfois, elles ne nécessitent pas d'arguments, parfois, il faut en mettre, et parfois, on peut choisir d'en mettre ou pas.


Les résultats L'optimisation

L'optimisation

Les commandes d'exécution Les variables

L'optimisation

Votre TI n'a pas beaucoup de mémoire RAM dispo (à peine plus de 20Ko). Il serait donc bien de rendre chaque programme le plus léger possible afin qu'il ne prenne pas trop de place dans la mémoire. À votre niveau, je ne peux que vous apprendre quelques techniques bien précises. La première et la plus connue est de ne pas fermer les parenthèses (à la fin d'une instruction). Par exemple :

:Output(1,1,"HELLO !")

devient :

:Output(1,1,"HELLO !"

De plus, il est également possible de ne pas fermer les guillemets. On peut donc même écrire :

:Output(1,1,"HELLO !

En revanche, la fermeture des guillemets reste obligatoire si le changement d'instruction se fait via ":" et non un retour à la ligne. Donc le code suivant :

:Output(1,1,"HELLO !:ClrHome

affiche exactement "HELLO !:ClrHome". On peut en effet afficher en tant que texte des commandes. Si vous ne voulez pas afficher ":ClrHome" mais effacer l'écran, il faut donc passer à la ligne :

:Output(1,1,"HELLO !
:ClrHome

D'autre optimisations sont possibles pour gagner de la place. Par exemple :

Ans/10

devient :

.1Ans

car il est possible de ne pas spécifier le "0" avant la virgule d'un nombre ne possédant pas de partie entière. Ici, non seulement on gagne un octet, mais en plus de la vitesse car les multiplication sont plus rapides que les divisions. Si une même expression est utilisée plusieurs fois, il faut la mettre dans Ans pour l'utiliser par la suite :

:Output(2Ans+5,2Ans+5,"HELLO !

devient :

:2Ans+5
:Output(Ans,Ans,"HELLO !

On gagne des octets et de la rapidité. Ah, au fait, beaucoup de caractères et commandes ne prennent que un octet, mais certaines en prennent 2. C'est le cas de Clear Entries. Essayez donc toujours de grappiller dans la mesure du possible des octets par ci par là, c'est toujours ça de gagné.

Après toutes ces choses que vous avez apprises, vous avez maintenant le niveau pour l'utilisation des variables !
Nous ferons au fur et à mesure du tutoriel des choses de plus en plus avancées.

PS : je vous conseille de pratiquer dès maintenant, c'est-à-dire de faire votre propre programme avec ce qu'on vient d'apprendre histoire de s'en souvenir : afficher des nombres, du texte, marquer une pause...


Les commandes d'exécution Les variables

Les variables

L'optimisation Qu'est-ce qu'une variable ?

Les variables, on n'y échappe jamais en programmation. Sans elles, on ne peut pratiquement rien faire.
Comme plusieurs types de variables existent, nous verrons ici celles qui servent à stocker un nombre.

Qu'est-ce qu'une variable ?

Les variables Stockage et extraction de valeur

Qu'est-ce qu'une variable ?

Une variable est destinée à contenir une information, comme un nombre, du texte ou encore une image. Elle sera contenue dans la mémoire de la calculatrice et permettra, dans le cas des nombres, de stocker des valeurs tout au long du programme, comme par exemple le nombre de vies du joueur.

En TI-Basic, il y a 28 variables destinées au stockage de valeurs pour le programmeur : cela va de A à Z en finissant par Ɵ et n. Elles se comportent en fait comme des étiquettes qui vont pointer vers un endroit de la mémoire, comme vous pouvez le voir avec ce schéma vraiment moche :

Image utilisateur

Nous n'aurons pas à nous soucier de la gestion de la mémoire, il nous suffira de spécifier le nom de la variable à utiliser et la calculatrice fera le reste.

Mais alors !? Il sert vraiment à rien ton vieux schéma pourri !

Nooon ! Pas les tomates ! :waw:
Comme vous le montre le schéma, à un instant donné, toutes les variables n'ont pas forcément de valeur. Quand on la demande, elle sera alors 0. Mais ce n'est pas pour ça qu'une variable ne peut pas pointer sur un zéro comme le montre Ɵ sur le schéma.

Et si l'on veut changer la valeur d'une variable sans valeur ?

Dans ce cas, celle-ci sera automatiquement créée et contiendra la valeur que vous aurez spécifiée.

Ce schéma vous montre aussi qu'au lancement de votre programme, toutes les variables ne contiennent pas forcément 0. Il faudra donc les initialiser correctement.


Les variables Stockage et extraction de valeur

Stockage et extraction de valeur

Qu'est-ce qu'une variable ? Récupérer une entrée

Stockage et extraction de valeur

Malgré le titre compliqué, ce que nous allons faire va être très simple : stocker et récupérer les valeurs des variables.

Stockage

Pour le stockage, il n'y a pas plus simple. Voici la syntaxe à respecter :

VALEUR→VARIABLE

Facile, hein ? Cette syntaxe marche pour tous les types de variables. Dans notre cas des nombres, VALEUR correspond à n'importe-quels nombre ou expression, par exemple 36*78+45. Le s'insère en pressant

Image utilisateur

et indique le sens de déplacement des données : de gauche vers la droite. Et enfin, VARIABLE désigne le nom de la variable de destination.

Voici par exemple une instruction qui place 5 dans C :

:5→C

Pour ceux qui ne sauraient pas où on trouve les variables destinées à contenir un nombre, il suffit de savoir taper du texte. Par exemple, pour obtenir C, il faut faire

Image utilisateur
Image utilisateur

Si C n'existe pas, il est créé et initialisé à 5. S'il existe déjà, on remplace son ancienne valeur par 5.

Notez que vous pouvez ne pas fermer les parenthèses avant le "→" comme pour un retour à la ligne. Ceci est donc juste :

:cos(Ans→F

Extraction

L'extraction de la valeur d'une variable se fait de la même manière qu'avec Ans. Par exemple, pour calculer 3*C+5, on peut procéder ainsi :

3C+5

Nous avons ici fait usage de la multiplication implicite, c'est-à-dire une multiplication où l'on ne précise pas l'opérateur de multiplication.
Pour placer une valeur dans une variable, il est possible d'utiliser la valeur d'autres variables, ou encore de la même. Voici un exemple de programme qui affiche 235 :

:24→A
:10→B
:AB-5→B
:Disp B

Destruction

Il suffit pour cela d'utiliser la commande DelVar en la faisant suivre de la variable à détruire. Voici un exemple qui supprime F de la mémoire :

:DelVar F

Si la variable n'existe déjà pas, cette commande n'a aucun effet. Mais si elle existe, le contenu ET l'étiquette seront supprimés. Donc une utilisation future de F renverra 0 car F n'existe plus. Pour ceux qui apprennent le TI-Basic juste pour les Maths, préférez faire :

0→variable

Les autres, si vous voulez optimiser, préférez détruire la variable car cela libère de la mémoire.


Qu'est-ce qu'une variable ? Récupérer une entrée

Récupérer une entrée

Stockage et extraction de valeur Les branchements

Récupérer une entrée

Nous allons ici apprendre à récupérer la saisie d'un nombre par l'utilisateur de différentes manières. Vous pourrez par exemple lui demander son âge, ou le niveau auquel il désire jouer. La récupération d'une valeur se fait grâce à des commandes : il en existe deux différentes pour mener la tâche à bien.

Prompt

C'est la commande la plus utilisée par les débutants. Elle permet de demander facilement une saisie et d'indiquer dans quelle variable le résultat est stocké. L'unique argument à renseigner est la variable de destination. Ainsi, si l'on veut récupérer un nombre tapé par l'utilisateur et le stocker dans K, il faut faire comme ceci :

:Prompt K

Et voici ce que voit l'utilisateur :

Image utilisateur
Input

Cette commande peut accepter 0, 1 ou 2 arguments. Nous étudierons le cas de l'absence d'arguments dans le chapitre sur les graphismes.

Avec 1 argument

Il faut faire suivre la commande par la variable de destination. En reprenant l'exemple utilisant Prompt :

:Input K

Cette fois, l'utilisateur ne voit pas dans quelle variable la valeur entrée sera stockée :

Image utilisateur
Avec 2 arguments

Ici, c'est VOUS qui choisissez le texte qui s'affiche juste avant l'invite d'entrée. Cela permet d'expliciter ce qui est attendu. Voici le contenu d'un programme :

:Input "AGE:",R

Et voici le résultat :

Image utilisateur

Remarque : si l'utilisateur commet une faute dans son entrée, une erreur sera indiquée et il devra la rectifier.

Faisons un petit exercice qui demande à l'utilisateur son âge, qui efface l'écran, puis qui l'affiche :

:Input "AGE:",A
:ClrHome
:Disp "OK, TU AS",A

Et voici le résultat si l'utilisateur répond "25" :

Image utilisateur

J'espère que vous avez bien suivi, car nous utiliserons très souvent les variables : elles sont incontournables.
Et comme je l'ai dit dans le chapitre précédent : faites de la pratique, sinon, vous ne retiendrez rien !


Stockage et extraction de valeur Les branchements

Les branchements

Récupérer une entrée Les étiquettes et redirections

Jusqu'ici, les programmes s'exécutaient dans l'ordre, de haut en bas. Mais maintenant, ce ne sera plus le cas !

Les étiquettes et redirections

Les branchements Les menus

Les étiquettes et redirections

Les étiquettes permettent de localiser un endroit du programme, et elles occupent chacune la place d'une instruction. Voici comment faire une étiquette : il faut commencer l'instruction par Lbl , puis faire suivre cette commande un peu spéciale par le nom de l'étiquette. Ce nom doit faire entre 1 et 2 caractères, chacun étant une lettre ou un chiffre.

Voici un exemple d'étiquette :

:Lbl XP

Elle peut se loger n'importe-où dans un programme :

:Disp "HELLO WORLD !",3F
:Lbl XP
:Disp "BONJOUR !"
:35*8

Une instruction qui spécifie une étiquette n'a aucun effet sur le déroulement du programme. Leur avantage est que l'on peut faire une redirection vers une d'elles, en tant qu'instruction, c'est-à-dire que l'on va demander de poursuivre l'exécution du programme autre part. Il faut pour cela utiliser la commande Goto à laquelle on fournit le nom de l'étiquette vers laquelle on veut aller. Exemple de redirection :

:Goto XP

Voici un petit exemple qui illustre cela :

:Input "AGE:",A
:Goto AF
:Disp "YOUPI"
:Lbl AF
:Disp "TON AGE :",A

Ce programme n'affichera pas "YOUPI" car l'instruction correspondante ne sera pas lue. Les étiquettes peuvent pour l'instant paraitre inutiles, mais elles prendront leur signification avec les Menus.

Au fait : si vous essayez de faire une redirection vers une étiquette inexistante, vous aurez droit à un ERR:LABEL.


Les branchements Les menus

Les menus

Les étiquettes et redirections Les procédures

Les menus

En TI-Basic, il existe une commande très pratique pour demander à l'utilisateur de faire un choix. Ce sont les menus, auxquels il faut faire correspondre un titre, les différents choix possibles et l'identité des étiquettes. La commande se nomme Menu(.

Le premier argument à renseigner est le titre du menu (maximum 16 caractères) qui doit être du texte. Ensuite, pour chaque choix, il faut d'abord mettre la description du choix (texte de maximum 14 caractères), puis l'identité de l'étiquette de redirection. Il est possible de mettre de 1 à 7 choix. Un petit exemple ne fera pas de mal :

:Menu("ETES-VOUS SUR ?","OUI",JA,"NON",NO)

Ou encore :

:Menu("CONTINUER ?","OUI",JA,"NON",NO,"ANNULER",RT)

Les mentions JA, NO et RT sont des étiquettes vers lesquelles rediriger. Par exemple, si l'utilisateur choisit "NON", l'exécution du programme se poursuivra à l'étiquette NO. Voici ce que voit l'utilisateur avec notre premier menu :

Image utilisateur

L'utilisateur doit alors faire un choix de la même manière qu'il aurait dû le faire sur n'importe-quel autre menu de la calculatrice. Voici un petit exemple de programme qui illustre l'utilisation des redirections et des menus :

:Lbl 0
:Menu("CALCULER :","√(X)+X²",A,"X³-24X²",B)
:Lbl A
:Input X
:Disp √(X)+X²
:Goto C
:Lbl B
:Input X
:Disp X³-24X²
:Lbl C
:Menu("CONTINUER ?","OUI",0,"NON",1)
:Lbl 1

Vous avez compris le système ? Si oui, nous allons pouvoir passer à la gestion des procédures. Si vous avez encore un peu de mal avec ça, relisez autant de fois que nécessaire et faites des tests sur votre calculatrice par vous-mêmes.


Les étiquettes et redirections Les procédures

Les procédures

Les menus Les conditions

Les procédures

Les appels

Également appelées routines ou encore sous-programmes, les procédures sont des groupes d'instructions qui peuvent êtres appelés depuis un programme. La différence avec les redirections, c'est qu'une fois que le code est lu, l'exécution reprend là où elle en était. De plus, vous les avez déjà utilisés sans vous en rendre compte : si vous voulez exécuter un programme :

prgmPROG

Le programme a été appelé depuis un autre groupe d'instructions. Vous pouvez d'ailleurs mieux le voir à travers ce groupe que l'on a déjà utilisé :

10:prgmCALCFN

Vous auriez pu aussi taper ceci :

10:prgmCALCFN:2Ans

Le résultat aurait été alors 2 fois supérieur par rapport à ce qui est retourné par le programme. Et comme tout ce que l'on peut faire sur l'écran principal, on peut aussi le faire dans un programme, l'instruction suivante est tout à fait juste :

:prgmROUTINE

Faisons un exemple de programme utilisant les routines :

:Input "NOMBRE :",A
:A
:prgmDISPFN
:Input "NOMBRE 2 :",B
:B
:prgmDISPFN

En ayant en tant que contenu du programme de nom DISPFN :

:Disp "X²-25X =",Ans²-25Ans

Cette routine prend en paramètre le nombre auquel il faut associer l'image. Elle prend ce paramètre à travers Ans afin d'effectuer des calculs dessus.

Les retours

Jusqu'à présent, un programme se terminait quand on arrivait à la fin du programme. Il est possible de forcer le programme à s'arrêter à travers deux commandes différentes. La commande Return agit exactement comme si l'on se trouvait à la fin du programme, mis à part que celui-ci ne fournira pas de résultat. Si le programme a joué le rôle de routine, l'exécution se poursuit là où elle en était juste avant.

Il existe une autre commande : Stop : elle force l'arrêt complet de toute lecture d'instructions. Le programme ne reprend donc pas son cours, là où il avait commencé. Même les instructions placées après la demande d'exécution du programme, sur l'écran principal, ne sont pas lues.

Un petit exemple, pour la route :

:Lbl 0
:Menu("CALCULER :","√(X)+X²",A,"X³-24X²",B)
:Lbl A
:Input X
:Disp √(X)+X²
:Return
:Lbl B
:Input X
:Disp X³-24X²

Vous le verrez lorsque nous ferons les boucles, la seule utilité des étiquettes est en fait de faire des menus. Les Goto, on s'en passera bien vite.


Les menus Les conditions

Les conditions

Les procédures Les tests

Les conditions, vous savez ce que c'est, eh bien, en programmation, elles sont essentielles car permettent de modifier le déroulement du programme en fonction de certains critères, comme par exemple si le joueur n'a plus de vies, ou encore s'il presse la touche de droite ... alors il faudra décaler le personnage vers la droite.

Contrairement à de nombreux cours, et pour bien poser les bases et éviter toute confusion, nous commencerons par voir toutes les conditions et ce qu'elles retournent, pour ensuite en arriver à l'instruction IF.

Les tests

Les conditions La boucle IF

Les tests

Faites un petit tour dans le menu

Image utilisateur
Image utilisateur

. Il est composé de deux parties :

  1. Une qui comporte les signes de comparaison =, ≠, >, ≥, <, ≤.

  2. Une qui contient les opérateurs logiques and, or, xor, not( ; et pour les calculatrices françaises et, ou, ouExcl, non(.

C'est ici que nous allons travailler. Tout comme ce menu est séparé en deux, cette sous-partie sera séparée en deux.

Les signes de comparaison

Vous l'aurez deviné, ils permettent de comparer deux expressions. Si l'égalité ou encore l'inégalité que l'on spécifie est vraie, cela renvoie 1, sinon, cela renvoie 0.
Exemples : 5 > 7 renvoie 0 ; 7 ≠ 10 renvoie 1 ; 8 ≤ 8 renvoie 1 ; 9 = -18 renvoie 0.

Ce qu'il faut donc retenir, c'est que 0 veut dire FAUX, et que 1 veut dire VRAI.

Une règle très importante est le fait que ces opérateurs possèdent une priorité opératoire très faible, et seront donc exécutés dans les derniers. Vous pourrez ainsi facilement comparer des expressions, comme par exemple : 7A = B+7 ; E+20 > U^12

Exercice : fabriquer l'expression qui permet de voir si le joueur dispose de suffisamment d'argent (nommée A) pour s'acheter X produits de prix P.

A≥XP

Si le joueur a suffisamment d'argent, l'expression renverra 1, sinon elle renverra 0.

Les opérateurs logiques

Tout comme les signes de comparaison, il admettent deux arguments : un à gauche et un à droite (sauf le not). Le plus souvent, ces arguments seront 0 ou 1, mais nous verrons que cela n'est pas forcément toujours le cas.
Chacun de ces opérateurs vont renvoyer, comme l'on peut s'y attendre, soit 0, soit 1.

"and" renvoie 1 si les deux arguments sont vrais, sinon, si au moins un des deux arguments est faux, il renvoie 0.
"or", renvoie 1 si au moins un des deux argument est vrai, sinon, si les deux sont faux, il renvoie 0.
"xor" renvoie 1 si un des deux arguments est vrai et que l'autre est faux, sinon, si les deux arguments sont tous les deux vrais ou tous les deux faux, il renvoie 0.

Ces opérateurs ont une moins grande priorité opératoire que les signes de comparaison, donc, par exemple, D>F and 7≤10 et (D>F) and (7≤10) signifient la même chose.

Un petit exercice : admettons que, pour le jeu que vous fabriquez, le joueur ne peut avoir plus de 5 objets sur lui à la fois. Le but est donc de vérifier si le joueur a non seulement suffisamment d'argent, mais en plus s'il reste de la place dans son sac. Nous supposerons que le nombre d'objets dont dispose le joueur se trouve dans N, et, pour les autres variables, nous reprenons l'exercice précédent. (Allez, creusez-vous un peu les méninges)

A≥XP and N+X≤5
Il faut que le joueur ait assez d'argent et que le nombre d'objets qu'il possède déjà augmenté du nombre d'objets qu'il achète ne dépasse pas 5.

Mais, juste comme ça, ça me renvoie quoi si je fais par exemple : 2 and -0.4 ?

Au lieu de me demander, vous n'avez qu'à essayer ! :lol: Cela renverra 1. Pas d'erreur ? Eh non, ce que je ne vous avais pas encore dit, c'est que en fait, tout nombre différent de ZÉRO est considéré comme vrai. Donc par exemple, 41, 0.004, -784434 et 9.99E99 seront considérés comme vrais.

Allez, un petit quelque chose que vous avez certainement deviné : on peut multiplier le résultat puisque c'est un nombre ! (Par exemple, 3(D<7 renverra 0 si D≥7 et 3 si D<7)
L'utilité ? Cherchez un peu ce qui permet de retirer 2 vies au joueur s'il n'a pas mangé depuis au moins 4 jours... (En prenant V le nombre de vies et J le nombre de jours qu'il n'a pas mangé)

:V-2(J≥4→V

Une petit fonction dont je n'ai pas encore parlé : "not(" ("non" en français). Elle renvoie 0 si l'expression est vraie et 1 si elle est fausse.
Exercice : trouver l'expression qui permet de renvoyer 0 si A=0 et 1 dans tous les autres cas.

not(not(A

À travers cette sous-partie, nous avons vu quelques exemples d'utilisation possibles, mais cela va se montrer encore plus concret avec les boucles conditionnelles.

La dangerosité des priorités opératoires

Nous avons déjà vu que "and", "or" et "xor" n'ont pas la même priorité opératoire (relisez la sous-partie si ce n'est pas clair pour vous).
De plus, il sont moins prioritaires que les signes de comparaison, cela permet de faire des expressions comme :

A≥XP and N+X≤5

car elle est ainsi équivalente à :

(A≥XP) and (N+X≤5)

Jusque là, ça va, pas de danger. Mais essayons autre chose :

5<4<6 renvoie 1
12>4>2 renvoie 0

Gné ? C'est n'importe quoi ! o_O

Pas tant que ça ! Essayons de calculer cela à la main. Comme les signes de comparaison ont la même priorité, on effectue les calculs de gauche à droite :

5<4<6 ==> (5<4)<6 ==> 0<6 ==> 1
12>4>2 ==> (12>4)>2 ==> 1>2 ==> 0

Il faut donc faire très attention ! On ne peut pas tester si X appartient à [2;4] en faisant 2≤X≤4, c'est faux !
On est obligé de faire X≥2 and X≤4, ou une expression équivalente.

Retenez bien cela !


Les conditions La boucle IF

La boucle IF

Les tests Un petit exercice

La boucle IF

C'est ici que les conditions vont révéler leur plus grande utilité. Le principe de ce que nous allons voir est d'exécuter certains bouts de code seulement si la condition spécifiée est vérifiée.

Les If ...

Voici un petit schéma :

Image utilisateur

Si la condition est vérifiée, l'instruction située juste après celle-ci sera exécutée, sinon, elle sera sautée. Vous êtes donc capables, en relation avec les exercices d'achat de l'objet précédent, de reprendre l'expression que vous avez faite pour faire un groupe d'instructions qui permet d'afficher "ACHAT REUSSIS" si le joueur a suffisamment d'argent et de place.

:If A≥XP and N+X≤5
:Disp "ACHAT REUSSIS

Et voilà, grâce à la sous-partie précédente, maintenant, ça avance comme sur des roulettes.

Les If ... Then

Cette boucle va nous permettre quand à elle d'exécuter plusieurs instructions si une condition est vérifiée. Il suffit pour cela de placer juste après l'instruction If, avec le test, un Then comme si c'était une instruction, de placer le groupe de commandes, puis de marquer la fin de la boucle par End.

Image utilisateur

Nous allons donc pouvoir ajouter à l'exemple précédent deux instructions : celle qui incrémente le nombre d'objets que le joueur possède, et celle qui diminue l'argent du joueur.

:If A≥XP and N+X≤5
:Then
:N+X→N
:A-XP→A
:Disp "ACHAT REUSSIS
:End

Une particularité des boucles est qu'elles peuvent s'imbriquer, c'est-à-dire que dans l'une, vous pouvez en ajouter une autre :

:If // condition
:Then

// instructions

:If // condition
:Then

// instructions

:End// fin de la boucle imbriquée

// instructions

:End// fin de la boucle extérieur

Pour vérifier que vous avez bien compris, ajoutez ce qui permet de prévenir au joueur qu'il n'a désormais plus de place (uniquement si l'achat a marché).

:If A≥XP and N+X≤5
:Then
:N+X→N
:A-XP→A
:Disp "ACHAT REUSSIS
:If N=5
:Disp "IL N'Y A MAINTE-","NANT PLUS DE","PLACE
:End

Les If ... Then ... Else

Il existe un troisième mot-clé utilisable dans le cadre des conditions, et délimite ce que l'on appelle l'alternative. Celle-ci se caractérise par l'évènement "La condition est fausse". Nous mettions en effet après le Then les instructions à exécuter si la condition est vérifiée, nous pourrons maintenant mettre en plus après le "Else" les instructions à exécuter si la condition n'est pas vérifiée. Et cela donne la syntaxe suivante :

:If // condition
:Then

// groupe d'instructions à exécuter
// si la condition est vérifiée

:Else

// groupe d'instructions à exécuter
// si la condition n'est pas vérifiée (si elle est fausse)

:End

Remarque : il est impossible de ne mettre que un Else, il faudra toujours le Then. Il n'est ainsi pas possible de réduire la syntaxe dans le cas de la présence d'une seule instruction.

Faire une reprise du cas précédent en ajoutant l'affichage du message "ACHAT IMPOSSIBLE" si l'achat n'a pas réussis.

:If A≥XP and N+X≤5
:Then
:N+X→N
:A-XP→A
:Disp "ACHAT REUSSIS
:If N=5
:Disp "IL N'Y A MAINTE-","NANT PLUS DE","PLACE
:Else
:Disp "ACHAT IMPOSSIBLE
:End


Les tests Un petit exercice

Un petit exercice

La boucle IF Les boucles

Un petit exercice

Afin de mettre en pratique les conditions, concoctons-nous un programme de Maths. Il permettra de calculer la ou les solutions d'une équation du second degré. Ce n'est pas grave si vous ne connaissez pas les équations du second degré, nous allons juste travailler sur les formules.

Prenons l'équation : ax² + bx + c = 0

Il faut d'abord calculer : \Delta = b^2 - 4ac

Si le résultat est négatif, il n'y a pas de solution, s'il est nul, il n'y a qu'une seule solution, sinon, s'il est positif, il y en a deux.

S'il y a deux solutions, celles-ci sont calculées par les formules : \frac{- b - \sqrt{\Delta}}{2a} et \frac{- b + \sqrt{\Delta}}{2a}

S'il n'y a qu'une seule solution, celle-ci est calculée par la formule : - \frac{b}{2a}

Pour faire ce programme, il va d'abord falloir demander la valeur de a, b et c, puis regarder le signe de \Delta (ça sent le besoin d'utiliser les tests, non ?), et enfin donner les résultats en conséquence. N'oubliez pas de préciser s'il n'y a pas de solution.

Ne regardez pas la solution tout de suite, et essayez plutôt, cet exercice est fait pour vous entrainer.
Au pire, si vous avez la flemme de le faire maintenant ( :-° ), ne regardez pas la solution afin de pouvoir le faire plus tard. ;)

:Input "A=",A
:Input "B=",B
:Input "C=",C
:B²-4AC→C // on n'a plus besoin de C, donc on y stocke le résultat
:If C<0 // si C négatif
:Then
:Disp "PAS DE SOLUTION
:Else// sinon
:If C // si C non nul, donc strictement positif car il ne peut plus être négatif
:Then
:√(C // pour des raisons d'optimisation, car on l'utilise 2 fois
:Disp .5(-B-Ans)/A,.5(-B+Ans)/A
:Else
:Disp -.5B/A
:End
:End

Voilà, j'espère que vous avez bien tout compris, car les conditions sont très importantes.
Je sais que ça parait bizarre qu'une condition renvoie un 0 ou un 1, mais croyez-moi, c'est parfois très utile. ;)


La boucle IF Les boucles

Les boucles

Un petit exercice La boucle While

Vous connaissez déjà la boucle IF, mais ces boucles ci seront bien différentes puisque leur contenu pourra être exécuté plusieurs fois. Ce n'est pas forcément évident, donc n'hésitez pas à relire jusqu'à comprendre. À partir de maintenant, n'utilisez plus les étiquettes (sauf pour la commande Menu) ! En effet, les boucles sont plus rapides, plus claires et plus logiques.

La boucle While

Les boucles La boucle Repeat

La boucle While

Voici sa syntaxe :

:While condition
// instructions
:End

Penchons-nous sur la première ligne : elle commence par le mot-clef "While" (qui signifie en quelque sorte "tant que"), auquel on ajoute une condition (par exemple A=7). Ensuite se trouve le corps, qui contient des instructions, et enfin le mot-clef "End" qui indique la fin de la boucle.

Lorsque l'on entre en boucle, la condition est analysée, si elle est fausse, l'exécution saute directement juste après le End, sinon le corps de la boucle est exécuté, et on recommence. Voici un petit exemple avec la condition toujours vérifiée :

:While 1
:Disp "HELLO WORLD !
:End

Image utilisateurImage utilisateur

Vous pouvez voir que le code que ce programme contient est sans arrêt exécuté, le seul moyen de sortir du programme est de presser ON.

Voyons maintenant lorsque la condition n'est jamais vérifiée :

:While 0
:Disp "HELLO WORLD !
:End

Image utilisateurImage utilisateur

Le code n'a pas été exécuté, pas même une seule fois, ce qui est normal puisque la condition était fausse.

Essayons maintenant autre chose :

:1
:While Ans<20
:Disp Ans
:2Ans
:End

Image utilisateurImage utilisateur

Vous pouvez remarquer que Ans a pris successivement les valeurs 1, 2, 4, 8 et 16. Sa valeur a à chaque tour de boucle été multipliée par deux, après avoir été affichée. Lorsque cette valeur a excédé 20, on est sorti de la boucle.


Les boucles La boucle Repeat

La boucle Repeat

La boucle While La boucle For

La boucle Repeat

La syntaxe est la même sauf que l'on remplace le mot-clef "While" par "Repeat" :

:Repeat condition
//instructions
:End

Cette boucle est différente de While en deux choses :

  1. elle attend que la condition soit vérifiée pour sortir de la boucle (alors que While attendait qu'elle soit fausse)

  2. au premier tour de boucle, la condition n'est pas évaluée si bien que les instructions seront exécutées au moins une fois

Par exemple, soit le programme suivant :

:1→A
:Repeat A
:Disp A
:End

Il nous affichera 1 et c'est tout, car tout d'abord les instructions sont exécutées (ici, le Disp), et ensuite la condition est analysée : ici, elle est vérifiée donc on sort de la boucle.

Voici un petit exemple qui attend que vous tapiez le code secret :

:Repeat C=1458
:Input "CODE:",C
:End
:Disp "CODE TROUVE !

Image utilisateurImage utilisateur

Dans ce dernier cas, l'utilisation de Repeat est plus appropriée que celle de While car cela permet de demander à l'utilisateur au moins une fois le code : imaginez si au lancement du programme on avait déjà C=1458 ! Certes, nous aurions pu initialiser C à par exemple 0, mais cela aurait été moins optimisé et moins clair.


La boucle While La boucle For

La boucle For

La boucle Repeat Exercices

La boucle For

En TI-Basic, la boucle For est bien différente des autres : la condition est implicite, et la boucle impose une syntaxe bien particulière. La voici :

:For(variable,debut,fin[,pas])
//instructions
:End

Elle va en fait agir sur une variable : elle va tout d'abord l'initialiser à la valeur "debut". Ensuite, elle va vérifier que la valeur de la variable n'excède pas "fin" (si celle-ci l'excède, l'exécution saute au End) puis le contenu du corps sera exécuté. Après cela, la variable donnée se voit augmentée du pas et on reprend au début (au test puis à l'exécution).

Par exemple :

:For(A,1,5,1
:Disp A
:End

Image utilisateurImage utilisateur

Le programme a affiché les valeurs allant de 1 à 5, puis il s'est terminé. Notez que si le pas est de 1 par défaut, il n'est pas obligatoire de l'indiquer. Ainsi le code suivant fait la même chose :

:For(A,1,5
:Disp A
:End

Vous pouvez tout à fait mettre un pas négatif, dans ce cas la boucle s'arrêtera lorsque la valeur de la variable sera plus petite que la valeur de fin. Exemple :

:For(A,5,1,-1
:Disp A
:End

Image utilisateurImage utilisateur

Ici, ce sont les valeurs allant de 5 à 1 qui ont été affichées.

Notez qu'il est tout à fait possible de modifier la valeur de la variable dans la boucle, cet exemple montre ainsi un changement de cette valeur à travers une autre boucle For à l'intérieur :

:For(A,1,50,10

:For(A,A,A+5
:Disp A
:End

:Pause
:End

Image utilisateurImage utilisateur

Cet exemple montre quelque chose d'intéressant : on peut imbriquer les boucles !

En revanche, si vous mettez des variables dans les valeurs de départ, arrivée ou encore de pas, les modifier n'affectera pas le déroulement de la boucle car celles-ci auront été pré-enregistrées :

:5→B
:For(A,1,B
:50→B
:Disp A
:End

Le changement de la valeur de B n'a aucune influence sur la valeur de fin que doit atteindre A dans la boucle.

Le contenu d'une boucle For, au même titre que celui d'une boucle While, peut ne pas être exécuté si dès le début la valeur de la variable excède celle d'arrivée. Deux exemples où le code n'est pas exécuté :

:For(A,5,3
// code
:End

:For(A,3,40,-1
// code
:End

En ce qui concerne le premier exemple, il faut savoir que c'est une source d'erreur fréquente : ce n'est pas parce que la valeur d'arrivée est inférieure à celle de départ qu'automatiquement la variable sera décrémentée à la place d'incrémentée. Il faut bien penser à préciser un pas négatif pour imposer ce comportement !


La boucle Repeat Exercices

Exercices

La boucle For TP : plus ou moins... froid ou chaud

Exercices

Voici quelques exercices d'applications, qui vous permettront de pratiquer l'utilisation des boucles dans vos programmes !

Note : sachez qu'il n'y a pas qu'une seule solution à chacun de ces petits problèmes. Par conséquent, les solutions que je donne sont des solutions possibles, mais ne sont pas les seules ! Il est fort possible que vos boucles soient différentes des miennes, mais fonctionnent tout de même.

Faire un programme qui affiche les 20 premiers nombres triangulaires.
Image utilisateur

Ce schéma montre 4 nombres triangulaires qui ont pour valeur 1, 3, 6 et 10.

Ce schéma montre 4 nombres triangulaires qui ont pour valeur 1, 3, 6 et 10.


La boucle For TP : plus ou moins... froid ou chaud

TP : plus ou moins... froid ou chaud

Exercices Plus ou moins

Le jeu de "plus ou moins", vous le connaissez peut-être déjà. Le but du jeu est de deviner le nombre mystère. Pour cela, on donne un nombre et l'autre dit si c'est plus ou moins. Quand au jeu du "froid ou chaud", c'est une invention de ma part (mais peut-être que ça existe déjà) : l'autre dit "tu chauffes" si on se rapproche du nombre et "tu refroidis" si on s'en éloigne.

Nous allons donc programmer ces deux jeux sur calculatrice pour pouvoir en faire avec elle.

Plus ou moins

TP : plus ou moins... froid ou chaud Correction

Plus ou moins

Le hasard

La première chose à faire dans ce jeu, c'est que la calculatrice choisisse d'elle même un nombre au hasard. Et le problème, c'est qu'en informatique, le hasard n'existe pas. o_O

Pour faire générer un semblant de hasard à la TI, il a donc fallu ruser. Les programmeurs ont stocké dans la calculatrice une très grosse suite de nombres à partir desquels ils ont réussis à créer une simulation de hasard. Et ce hasard est très facile à générer en TI-Basic !

Il existe pour cela une variable un peu spéciale, qui se nomme : rand (ou NbrAléat).
Elle contient à chaque fois un nombre décimal compris entre 0 et 1. À chaque fois que l'on l'utilise, elle change de valeur :

Image utilisateur

Et on peut même changer sa valeur :

Image utilisateur

Si vous voulez initialiser rand à la même valeur que à l'achat de votre calculatrice, il faut mettre 0 dedans.

Pour obtenir un nombre compris entre deux entiers, il existe une fonction : randInt. Elle prend deux arguments : les valeurs minimale et maximale. Exemple de simulation d'un dé :

Image utilisateur

Et nous, comme on veut un nombre compris entre 0 et 10000, on va taper : randInt(0,10000

Les indices

Une fois que l'on a demandé une saisie à l'utilisateur, il faut lui dire si c'est trop, pas assez ou si c'est bon. Vous utiliserez donc les conditions selon les cas. Et si c'est pas bon, on recommence (ça ne vous fait pas penser aux boucles, ça ?). Voici donc l'architecture de votre programme :

>> Choisir une valeur comprise entre 0 et 10.000
>> On fait ce qui suit jusqu'à que la saisie de l'utilisateur soit bonne
>> Saisir
>> Si c'est trop, patati
>> Si c'est pas assez, patata

À partir de ça, vous devriez être capables de faire tout seul votre programme : vous savez comment afficher du texte, comment faire saisir une valeur, les conditions et les boucles...

Quand vous aurez réussi ou que vous aurez bien cherché sans trouver, vous pourrez regarder la correction.


TP : plus ou moins... froid ou chaud Correction

Correction

Plus ou moins Chaud ou froid

Correction

STOP !!!

Si vous lisez ces lignes, vous devez avoir fait votre programme, ou du moins avoir bien cherché. Car on apprend la programmation en faisant de la pratique, il n'y aurait donc aucun intérêt de lire tout ceci sans avoir cherché, même si je ne peux pas vous en empêcher.

Je tiens à vous dire d'avance qu'il est possible que votre programme marche très bien mais ne soit pas exactement pareil que le mien. Il n'y a jamais une seule façon de faire un programme, le code dépend donc de la façon de chacun de programmer !

La première ligne de code du programme est très simple :

:randInt(0,10000→N

Ensuite, on utilise Repeat pour arrêter le programme quand le nombre mystère est trouvé :

:Repeat N=S // jusqu'à ce que le nombre mystère soit trouvé

// contenu de la boucle

:End

On demande à l'utilisateur de saisir un nombre :

:Input S

Et on affiche le texte qui correspond à chaque cas :

:If S<N:Disp "C'EST PLUS
:If S>N:Disp "C'EST MOINS

Et si le nombre mystère a été trouvé, on se fait plaisir :

:Disp "BRAVO !! TU AS","TROUVE LE NOMBRE","MYSTERE !!

Ce qui donne au final :

:randInt(0,10000→N
:Repeat N=S
:Input S
:If S<N:Disp "C'EST PLUS
:If S>N:Disp "C'EST MOINS
:End
:Disp "BRAVO !! TU AS","TROUVE LE NOMBRE","MYSTERE !!

Et voici un petit screen pour le fun :

Image utilisateur

Plus ou moins Chaud ou froid

Chaud ou froid

Correction Correction

Chaud ou froid

Ce programme va être un peu plus compliqué, mais juste un petit peu. Cette fois, il ne s'agit plus seulement de voir si on est en-dessous ou au-dessus du nombre mystère, mais si on s'en est rapproché par rapport à la dernière saisie ou non.

Comme on ne peut pas s'être rapproché ou éloigné du nombre dès la première saisie, on commence par demander à l'utilisateur 2 nombres. Ensuite, on utilise les opérateurs logiques pour voir lequel est le plus proche et on agit en conséquence.

L'architecture du programme est donc finalement quelque chose comme :

>> Saisir un premier nombre
>> Jusqu'à ce que le nombre mystère soit trouvé
>> Saisir un nombre
>> Voir lequel est le plus proche
>> Si le dernier nombre est le plus proche, écrire "TU CHAUFFES", sinon, "TU REFROIDIS"

Pour vous donner un indice en ce qui concerne l'histoire de chauffer ou de refroidir, il faut avoir deux variables : l'une qui représente la toute dernière valeur saisie et l'autre l'ancienne valeur. Avant chaque saisie, il faut stocker la valeur de la nouvelle variable dans l'ancienne, et comme ça, après, on peut comparer les deux avec le nombre mystère.

Pour ceux qui ne voient pas comment faire pour trouver quel est le plus proche du nombre mystère, il suffit de calculer l'écart de chacun d'eux avec le nombre mystère. Pour ceux qui sèchent, voici comment calculer l'écart :

Il faut retrancher à la saisie le nombre mystère, puis en prendre la valeur absolue :

écart(nombre1, nombre2) = abs(nombre1 - nombre2)

Et il faut comparer les deux écarts.

Je n'en dis pas plus, à vous de faire la suite !!!


Correction Correction

Correction

Chaud ou froid Un petit pack...

Correction

J'espère que vous avez trouvé comment faire, ou du moins que vous avez bien cherché : c'est l'essentiel !
Car la programmation s'apprend en pratiquant.

Avant d'entrer dans quelque boucle que ce soit, il faut d'abord demander un premier nombre pour pouvoir voir si l'on se rapproche du nombre mystère.

:Input "DEPART : ",A

Bien évidemment, il faut ensuite choisir un nombre au hasard, ce qui ne devrait pas poser trop de problèmes :

:randInt(0,10000→N

Ensuite, on entre dans la fameuse boucle :

:Repeat B=N // jusqu'à ce que B=N

// contenu de la boucle

:End

Comme vous pouvez le remarquer, je compte mettre dans A le nombre donné le plus ancien, et dans B le nombre donné le plus récent.
Voici d'ailleurs la première et la dernière instructions du corps de la boucle :

:Repeat B=N
:Input B

// on peut travailler avec : A = Ancienne valeur et B = Nouvelle valeur

:B→A
:End

Il ne nous reste plus qu'à comparer les deux écarts et agir en conséquence : voici l'expression de comparaison :

abs(A-N)>abs(B-N

Mot à mot, ça veut dire : tester si l'écart entre le nombre mystère et l'ancienne valeur est supérieur à l'écart entre le nombre mystère et la nouvelle valeur, donc en fait si on chauffe ! Je suppose que vous êtes capables d'en déduire la boucle conditionnelle à utiliser. Indice : il faut utiliser Else.

:If abs(A-N)>abs(B-N
:Then
:Disp "TU CHAUFFES !
:Else
:Disp "TU REFROIDIS !
:End

Mais si la valeur que l'utilisateur a donnée est bonne, il serait inutile d'afficher un de ces messages (il est évident qu'il chauffe), il suffit donc d'ajouter une condition supplémentaire autour de cette dernière afin de n'exécuter le code que si l'utilisateur n'a pas trouvé la bonne valeur.

:If B≠N
:Then
:If abs(A-N)>abs(B-N
:Then
:Disp "TU CHAUFFES !
:Else
:Disp "TU REFROIDIS !
:End
:End

Et puis un petit message après la boucle :

:Disp "TU AS TROUVE LE","NOMBRE MYSTERE !

Et donc le code final :

:Input "DEPART : ",A
:randInt(0,10000→N
:Repeat B=N
:Input B
:If B≠N
:Then
:If abs(A-N)>abs(B-N
:Then
:Disp "TU CHAUFFES !
:Else
:Disp "TU REFROIDIS !
:End
:End
:B→A
:End
:Disp "TU AS TROUVE LE","NOMBRE MYSTERE !

Alors, c'était si difficile que ça ? ^^
C'est même plus facile de fabriquer ce jeu que d'y jouer, vous allez le constater !

Bon, comme l'interface est un peu moche, on va améliorer tout ça...


Chaud ou froid Un petit pack...

Un petit pack...

Correction Les listes

Un petit pack...

Les menus

Tout en améliorant l'interface, nous allons mettre ces deux jeux... dans un seul programme ! Cela va être grandement facile avec l'utilisation des menus. Et puis on va en profiter pour ajouter les instructions pour comment y jouer.

On commence déjà par choisir ce qu'il y aura dans le menu principal :

  1. LANCER + OU -

  2. LANCER CHAUFROID

  3. CREDITS

  4. QUITTER

Le menu de + OU - :

  1. JOUER

  2. INSTRUCTIONS

  3. RETOUR

  4. QUITTER

Et le menu de CHAUFROID :

  1. JOUER

  2. INSTRUCTIONS

  3. RETOUR

  4. QUITTER

Ah mince, ils sont drôlement identiques tes deux derniers menus !

Ne vous inquiétez pas, on va arranger tout ça...

Le menu principal, les crédits et quitter

On s'attaque au menu principal :

:Lbl 0
:DelVar M
:Menu("MEGA PACK","LANCER + OU -",A,"LANCER CHAUFROID",B,"CREDITS",C,"QUITTER",Q

Je suppose que vous avez remarqué l'effacement en mémoire de la variable M. Considérez cela comme une mise à 0 de M. Elle va en fait nous permettre de s'occuper du problème des deux menus identiques ce qui gâche de la mémoire pour rien.

Pour les crédits :

:Lbl C
:ClrHome
:Output(1,1,"FAIT PAR MDR1 SUR SON TUTORIEL DE TI-BASIC
:Pause
:Goto 0

Bien entendu, vous pouvez remplacer mes crédits par celui de votre choix. ;)

En ce qui concerne le fait de quitter le programme, on va tout simplement mettre l'étiquette tout à la fin du programme :

:Lbl Q

Jouer aux jeux

Maintenant, on s'occupe de l'histoire des deux menus. Le principe est d'aller dans les deux cas dans le même menu, mais en ayant enregistré au préalable quel jeu a été sélectionné :

:Lbl A
:1→M
:Lbl B
:Menu("","JOUER",J,"INSTRUCTIONS",I,"RETOUR",0,"QUITTER",Q

M contient 1 si on veut jouer au + ou - et 0 si on veut jouer au chaud ou froid grâce au DelVar.

Le menu "INSTRUCTIONS"

Le voici qui arrive tout simplement :

:Lbl I
:Output(1,1,"BUT DU JEU: TROUVER LE NOMBRE COMPRIS ENTRE 0 ET 10000.
:Output(3,1,"ON VOUS DIT A CHAQUE FOIS SI VOUS
:If M
:Then
:Output(5,3,"ETES AU-DESSUS OU EN-DESSOUS.
:Else
:Output(5,3,"VOUS EN ELOIGNEZ OU VOUS EN RAPPROCHEZ.
:End
:Pause
:Goto B

Un même texte est toujours affiché, et le suivant dépend du jeu que l'on a sélectionné. Et à la fin, on se redirige vers l'étiquette B pour ne pas changer la valeur de M.

Le menu "JOUER"

Il suffit tout simplement d'évaluer quel jeu est sélectionné puis d'exécuter le bon groupe d'instructions en fonction de cela :

:If M
:Then

// Code du jeu du + ou -

:Else

// Code du jeu CHAUFROID

:End
:Goto B // retourner à l'ancien menu sans changer la valeur de M

Le code complet

:Lbl 0
:DelVar M
:Menu("MEGA PACK","LANCER + OU -",A,"LANCER CHAUFROID",B,"CREDITS",C,"QUITTER",Q

:Lbl C
:ClrHome
:Output(1,1,"FAIT PAR MDR1 SUR SON TUTORIEL DE TI-BASIC
:Pause
:Goto 0

:Lbl A
:1→M
:Lbl B
:Menu("","JOUER",J,"INSTRUCTIONS",I,"RETOUR",0,"QUITTER",Q

:Lbl I
:Output(1,1,"BUT DU JEU: TROUVER LE NOMBRE COMPRIS ENTRE 0 ET 10000.
:Output(3,1,"ON VOUS DIT A CHAQUE FOIS SI VOUS
:If M
:Then
:Output(5,3,"ETES AU-DESSUS OU EN-DESSOUS.
:Else
:Output(5,3,"VOUS EN ELOIGNEZ OU VOUS EN RAPPROCHEZ.
:End
:Pause
:Goto B

:Lbl J
:randInt(0,10000→N
:If M
:Then

:Repeat N=S
:Input S
:If S<N:Disp "C'EST PLUS
:If S>N:Disp "C'EST MOINS
:End

:Else

:Input "DEPART : ",A
:Repeat B=N
:Input B
:If B≠N
:Then
:If abs(A-N)>abs(B-N
:Then
:Disp "TU CHAUFFES !
:Else
:Disp "TU REFROIDIS !
:End
:End
:End

:B→A
:End
:Disp "BRAVO !! TU AS","TROUVE LE NOMBRE
:Pause"MYSTERE !!
:Goto B
:Lbl Q

Notez bien que je me suis permis de mettre pour les deux jeux en commun le choix du nombre aléatoire ainsi que le message qui indique que l'on a trouvé le nombre mystère, afin de gagner de la place en mémoire.

Maintenant, vous pouvez ajouter de nombreuses améliorations : un compteur qui indique en combien de coups on a trouvé le nombre mystère, un troisième mode qui croise les deux méthodes d'indice (une fois sur deux, l'un, et une fois sur deux, l'autre)...

Bon, après ce lourd travail, pas de QCM, on a suffisamment travaillé comme ça. Par contre, je vous recommande vivement de modifier le programme, ajouter des machins et de créer votre propre jeu, si vous avez envie de vous améliorer en TI-Basic et de vous souvenir des commandes.
Je vous conseille de ne pas directement passer à la suite mais plutôt vous entrainer, comme ça, ce qui suit vous semblera beaucoup pus simple ! ;)


Correction Les listes

Les listes

Un petit pack... Les bases

Les listes sont simplement de nouvelles variables qui contiennent une suite de nombres, "listés" dans un certain ordre. Un exemple de liste : \{25,89.3,5/3\}
Elles seront très utiles !

Un exemple de programme qui utilise les listes : le TP sur la décomposition.

Les bases

Les listes Mémorisation

Les bases

Bon, déjà, on sait qu'une liste est une suite de nombres. Mais quelle est la syntaxe d'une liste, comment en écrire une ?
Si vous voulez par exemple "fabriquer" une liste avec les termes 56, 38 et 44.5, il suffit de les placer entre deux accolades et de les séparer par des virgules. Dans notre exemple, la liste s'écrirait {56,38,44.5}.

Les accolades se trouvent en faisant

Image utilisateur
Image utilisateur

pour l'accolade ouvrante et

Image utilisateur
Image utilisateur

pour l'accolade fermante.

Si vous tapez cette liste sur l'écran principal, l'écran vous affichera la même mais avec des espaces à la place des virgules.

Maintenant, vous allez pouvoir voir comment effectuer une opération sur une liste pour que celle-ci s'applique à chacun de ses termes.

Nous allons donc, pour commencer, essayer de fractionner la liste ... ou plutôt les termes de la liste. Il suffit pour cela de faire comme nous l'aurions fait pour une autre variable. Nous tapons donc : {56,38,44.5}>Frac

Et là, magie magie :magicien:

Image utilisateur

Nos termes sont fractionnés ! (Bon, ok, là il n'y avait qu'un seul terme qui pouvait être fractionné)

Et maintenant, essayez de multiplier et diviser la liste par un nombre, ou encore de lui additionner et retrancher un autre nombre. Exemples :

Vous pouvez donc remarquer que l'on a fait plusieurs opérations en une seule fois. Voici un petit schéma pour mieux comprendre :

Image utilisateur

Voilà. Vous pouvez même, si vous le souhaitez, appliquer à la liste des fonctions, par exemple la trigonométrie.
Ex:cos({56,38,44.5}) = {.5591929035, .7880107536, .7132504492}

Mais… mon écran n'affiche qu'une partie du résultat !

Sans doute parce que le résultat est trop long ; pour le faire défiler, il faut utiliser les touches droite et gauche.

Bon, maintenant que vous savez pas mal de choses sur les listes, on va voir comment les mémoriser et les rappeler.


Les listes Mémorisation

Mémorisation

Les bases Accéder à chaque terme

Mémorisation

Création

Maintenant que l'on sait comment fabriquer, afficher, multiplier, etc. les listes, on va voir comment mémoriser ces variables.

Il y a 6 listes déjà prédéfinies. Leurs noms se trouvent en faisant

Image utilisateur

+ une touche entre 1 et 6, et la variable liste correspondante est insérée (format du nom : L + indice chiffre entre 1 et 6).
Et pour mémoriser notre liste dans la variable, on fait comme pour n'importe quelle variable. Dans notre exemple, il faut taper {56, 38, 44.5} → L1

Cela nous donne donc : {56, 38, 44.5 → L1

Exercice : donner l'expression qui permet d'additionner 28 à cette liste (en utilisant la variable) puis de multiplier le résultat par 4,5.

4.5(L1+28

Essayez de rappeler L1 avec

Image utilisateur

.

Image utilisateurImage utilisateurImage utilisateurImage utilisateurImage utilisateurImage utilisateur

Et hop le contenu de la liste vient s'insérer au niveau du curseur.

Nous allons voir 2 fonctions avant de passer au chapitre suivant :

Maintenant, vous avez tous les bagages nécessaires pour apprendre à accéder individuellement à chaque terme de la liste.

Destruction

Je crois que vous avez deviné la méthode. :p
Allez, détruisez-moi la liste L1 !

DelVar L1

Les bases Accéder à chaque terme

Accéder à chaque terme

Mémorisation Les listes personnalisées

Accéder à chaque terme

Contrairement à de nombreux langages, la numérotation des termes commence à 1, et non pas à 0. Toujours dans notre même exemple de liste, le terme n°1 aura pour valeur 56, le n°2 : 38, et le n°3 : 44.5. Mais pour accéder à un terme précis, il faut que la liste soit enregistrée dans une variable Liste.

Et là, c'est d'une facilité déconcertante : on fait suivre le nom de la variable du numéro entre parenthèses.
Par exemple, pour obtenir le terme n°2, on tape : L1(2). Mais fermer la parenthèse n'est pas obligatoire. On peut donc remplacer par : L1(2

Vous pouvez en plus modifier la valeur d'un terme de la liste, il suffit pour cela de suivre cet exemple : 78.2 → L3(2
Ici, le terme n°2 de la liste L3 est initialisé à 78.2.

Mais avec cette initialisation, une application intéressante peut en être tirée : logiquement, nous pourrions penser que le numéro indiqué ne doit pas dépasser le nombre de termes que contient la liste ; eh bien cela n'est pas tout à fait vrai. Vous pouvez en effet faire excéder le numéro d'une unité.

Je n'ai rien compris ! Je quitte immédiatement ton tutoriel, j'en ai par-dessus la tête !

Non ! Pour que vous puissiez comprendre, je vous illustre tout ça par un exemple :

:{24,32→L1  // Notre liste L1 possède 2 termes
:78.2→L1(2  // L1 = {24,78.2}
:-8→L1(4    // Strictement interdit : le numéro indiqué n'est pas dans la liste. Il se produit donc une erreur
:-7→L1(3    // L1 = {24,78.2,-7}

La ligne 4 se révèle particulièrement importante : l'instruction a marché et un nouveau terme s'est présenté à la liste. Pourquoi ? Tout simplement parce-que le numéro indiqué n'avait qu'un décalage de un cran. Dans ce cas et seulement dans ce cas, l'instruction est acceptée et un nouveau terme sera créé.

Exercice : placer le triple de la valeur du terme n°2 augmenté de la valeur du terme n°1 dans le terme n°3 (oui, il sont tordus mes exercices).

3L1(2)+L1(1→L1(3


Mémorisation Les listes personnalisées

Les listes personnalisées

Accéder à chaque terme Opérations entre listes

Les listes personnalisées

Les listes personnalisées sont des listes que l'on crée soi-même et auxquelles on donne un nom choisi (autre que les noms prédéfinis L1, L2, L3…).
Elles sont généralement utilisées pour sauvegarder des scores, ou des parties, mais rarement pour autre chose car elles prennent de la place dans la mémoire (à chaque utilisation, il faut taper le nom en entier, un octet par caractère) et sont plus lentes d'utilisation.

Pour faire une liste personnalisée à partir d'un programme ou de l'écran principal, on utilise le caractère "ʟ" (un "L" en indice) qui se trouve dans le menu consacré aux listes en faisant :

Image utilisateur
Image utilisateur

Bon, j'en profite pour vous apprendre à utiliser ce menu. Il est composé de 3 colonnes (on choisit grâce aux touches droite et gauche) :

Revenons à nos moutons : on fait suivre ce caractère par d'autres caractères (qui composent le nom de la liste) qui peuvent être :

Exercice : Dans un programme, créer une liste personnalisée de nom "ABC3" avec pour termes : 78, 3.2, 41.5 ; puis mettre la somme du triple du terme n°2 et de la moitié du terme n°3 dans le terme n°1.

Image utilisateurImage utilisateur

Vous constatez sûrement qu'il devient lassant de répéter à chaque fois le nom, et que le programme s'alourdit rapidement.

Nous pouvons alléger un peu ce programme : lors de l'initialisation, le "ʟ" est facultatif juste après le "→". On peut donc remplacer l'ancien par :

:{78,3.2,41.5→ABC3
:3ʟABC3(2)+.5ʟABC3(3→ABC3(1


Accéder à chaque terme Opérations entre listes

Opérations entre listes

Les listes personnalisées Fonctions associées

Opérations entre listes

Si vous n'avez pas oublié, vous devez vous souvenir que l'on peut multiplier, diviser, etc. une liste par un réel. Maintenant, nous allons voir comment multiplier, diviser, etc. les listes entres elles.

Une première condition vient s'imposer : les listes que l'on utilise doivent avoir la même dimension (le nombre de termes qui les compose). Après, vous faites presque ce que vous voulez. Voici un exemple de multiplication de 2 listes entre elles :
{12,2.3,7} * {0.4,12,3.6} = {12*0.4,2.3*12,7*3.6} = {4.8,27.6,25.2}
Vous voyez donc que chaque terme de la liste applique l'opérateur (ici la multiplication) sur le terme de la liste voisine de même numéro. Voici un petit schéma pour mieux comprendre :

Image utilisateur

Vous voyez la différence avec l'ancien schéma ? Vous pouvez donc maintenant deviner les opérateurs et fonctions que vous pouvez utiliser.


Les listes personnalisées Fonctions associées

Fonctions associées

Opérations entre listes Attacher une formule à une liste

Fonctions associées

Nous allons voir ici les fonctions les plus importantes, les plus utilisées et les plus évidentes.

seq( // suite(

Cette fonction sert à créer des suites finies. On va donc entrer comme arguments :

Par exemple, si je veut calculer les racines carré des nombres de 4 à 27 en comptant de 3 en 3 en utilisant la variable G, il faut taper le code suivant :

seq(√(G),G,4,27,3

N'oubliez pas :

SortA( et SortD( // Tricroi( et TriDécroi(

Elles servent respectivement à classer une liste dans un ordre croissant et décroissant. On spécifie dans les parenthèses une ou plusieurs listes à trier séparées par des virgules de séparation. Elles ont cependant plusieurs particularités :

Si on veut trier dans l'ordre croissant la liste {5,9,2,7,3}, voici comment nous devons procéder :

:{5,9,2,7,3→L1
:SortA(L1      // L1 = {2,3,5,7,9}

La particularité de cette fonction est donc de directement modifier la valeur de l'argument.

min( et max(

Ces fonctions renvoient la valeur minimale ou la valeur maximale de deux nombres. Exemple : max(27,12) = 27.
On peut également les utiliser avec les listes. Exemple : min({12,56,14},{15,28,10}) = {12,28,10}

mean( // moyenne(

Donne la moyenne de la liste avec ou sans coefficients.

Sans coefficient

Syntaxe : mean(liste
Exemple : mean({2,4}) = 3

Avec coefficients

Syntaxe : mean(liste,liste_coefficients
Exemple : mean({5,8},{2,1}) = 6

augment( // chaîne(

Concatène (joint bout à bout) deux listes (pas forcément avec le même nombre de termes).
Exemple: augment({26,53.1},{17,-12,11}) = {26,53.1,17,-12,11}

sum( // somme(

Donne la somme de tous les éléments (ou termes) d'une liste.
Exemple : sum({12,15,-25}) = 12+15-25 = 2

On peut aussi demander la somme des termes compris entre deux rangs.
Exemple : sum({10,6,8,9,5,12,14},2,5) = 6+8+9+5 = 28

prod(

Renvoie le produit des terme d'une liste.
Exemple : prod({2,5,4}) = 40

On peut aussi demander le produit des termes compris entre deux rangs.
Exemple : prod({5,7,2,3,4,8},2,6) = 7*2*3*4*8 = 1344

median( // médiane(

Donne la médiane (valeur pour laquelle on a autant de valeurs supérieures qu'inférieures) d'une liste avec ou sans effectifs.

Sans effectifs

Syntaxe : median(liste
Exemple : median({2,4,25}) = 4

Avec effectifs

Syntaxe : median(liste,liste_effectifs
Exemple : median({2,4,25},{1,1,3}) = 25

cumSum( // somCum(

Renvoie une liste des somme cumulées.
Exemple : cumSum({1,4,8}) = {1,5,13}

∆List( // ∆Liste(

Renvoie les écarts entre termes dans une liste comportant un terme de moins.
Exemple : ∆List({4,28,10,14}) = {24,-18,4}

select( // Sélect(

Permet de choisir un échantillon d'un nuage de points (définis par une abscisse et une ordonnée).
Syntaxe : select(liste_abscisses,liste_ordonnées)
Les points doivent être sélectionnés dans une série statistique (stat plot) et affichés à l'écran.

Lors de l'exécution de l'instruction, choisir le début (gauche) de l'échantillon puis la fin (droite) en utilisant les flèches droite et gauche et la touche

Image utilisateur

. Il faut au préalable avoir choisi la série statistique à prélever grâce aux touches haut et bas. Si vous ne comprenez pas son utilisation, ce n'est pas grave car elle ne sert pas à grand chose.

stdDev( et variance( // ecart-type( et variance(

Donnent respectivement l'écart type et la variance d'une liste (notion étudiée au lycée).
Exemples : stdDev({2,7,4,5}) = 2.081665999 et variance({2,7,4,5}) = 13/3


Opérations entre listes Attacher une formule à une liste

Attacher une formule à une liste

Fonctions associées Editeur de listes

Attacher une formule à une liste

Ça veut dire quoi : attacher une formule à une liste ?

C'est quand on va par exemple demander à une liste d'ajuster ses valeurs en fonction d'une autre liste. On va par exemple lui demander de toujours rester le double d'une liste (ce qui est équivalent à demander que chacun de ses termes soit toujours le double du terme de même indice de l'autre liste).

Mais là arrive un petit problème : si on demande à L1 d'être le double de L2 et à L2 d'être le double de L1 ? Dans ce cas, votre calculatrice explose. :'( Vous vous doutez bien que ça n'est pas vrai. :p Votre calculette va calculer, calculer et calculer mais pas bien longtemps : il va rapidement arriver l'erreur "OVERFLOW". En effet, il va vite y avoir un dépassement (>9.999999999E99 ou <-9.999999999E99). Et s'il n'y en a pas, c'est un "ERR:MEMORY" qui vient à la place car au bout d'un moment, la calculatrice n'a plus assez de RAM pour poursuivre le calcul.

Bon, on continue ? J'aimerais bien savoir comment on fait pour attacher une formule, moi !

Vous placez la formule entre guillemets, vous placez le fameux caractère "→" et enfin le nom de liste. Par exemple, si vous voulez que la liste L4 ait toujours pour valeur le double de celle de L2, il suffit d'entrer : "2L2→L4 (n'oublions pas que fermer les guillemets n'est pas obligatoire).

Exercice : attacher à L3 la formule "le triple de L2 élevé de la moitié de L5" (des phrases mathématiques ne vous feront pas de mal :p ).

"3L2+.5L5→L3

Encore un truc et vous connaissez tout sur les formules jointes à une liste : comment détacher une formule ? Plusieurs solutions :

On peut passer à l'éditeur (pas indispensable mais pratique).


Fonctions associées Editeur de listes

Editeur de listes

Attacher une formule à une liste TP : décomposeur

Editeur de listes

Il existe un éditeur de listes assez souple, et nous allons donc nous pencher dessus et étudier les possibilités proposées. Pour y accéder, il suffit de faire

Image utilisateur

puis 1:Edit...
Vous pouvez aussitôt voir apparaitre l'éditeur de listes. Nous allons donc voir comment il fonctionne.

Image utilisateur
Ajouter une liste

Pour ce faire, il suffit d'amener le curseur tout en haut (au niveau des noms de liste) à l'endroit où vous désirez insérer une liste, puis de faire

Image utilisateur
Image utilisateur

. Vous voyez une nouvelle ligne apparaître avec en bas de l'écran une invite qui propose de donner un nom à cette nouvelle liste (ALPHA est automatiquement activé).

Image utilisateur

Vous pouvez taper une liste préprogrammée (exemple pour L1 :

Image utilisateur
Image utilisateur

) ou bien générer une liste personnalisée (par exemple pour la liste "ABC" :

Image utilisateur
Image utilisateur
Image utilisateur

car ALPHA est activé).
Valider avec

Image utilisateur
Supprimer une liste

Pour retirer une liste de l'éditeur (elle ne sera pas supprimée), il faut amener le curseur sur celle-ci (toujours dans l'en-tête) puis presser la touche

Image utilisateur
Vider le contenu d'une liste

Toujours le curseur sur la bonne liste, il faut cette fois presser la touche

Image utilisateur

puis de presser la touche bas.

Insérer, supprimer, ou modifier un terme

Pour les termes, cela ce fait semblablement :

Vous voyez que ce n'était pas trop difficile. On va donc pouvoir passer aux matrices.
P.S. : Pour l'utilité des listes, vous la découvrirez dans divers programmes que je vous présenterais.


Attacher une formule à une liste TP : décomposeur

TP : décomposeur

Editeur de listes La décomposition : ça veut dire quoi ?

Je vais vous présenter ici un de mes mini-programmes que j'ai nommé sur ma calculatrice "PREM2".
Je ne vous impose rien, d'ailleurs vous pourrez même l'optimiser, l'améliorer et en faire part à tout le monde.
Bref, voici donc un programme de maths qui fait le boulot à notre place. :-°

Pour suivre ce chapitre, il faut connaitre les listes, elles sont expliquées à la première partie. Leur compréhension est facile et rapide.

La décomposition : ça veut dire quoi ?

TP : décomposeur Construire le programme pas à pas

La décomposition : ça veut dire quoi ?

Nous allons donc faire un programme de décomposition d'un naturel en facteurs premiers.

Euh... et ça veut dire quoi tout ça ?

Déjà, un naturel est un entier positif.
Exemples : 1,2,3,4, ... 20,21, ... 1486221456, ...
Un nombre premier est un nombre (entier) qui a deux diviseurs: 1 et lui même.
Exemples : 2,3,5,7,11,13,17,23, ... 101, ...
Les autres nombres sont divisibles par d'autres nombres et ils sont donc "décomposables" en facteurs (pas pour la boîte aux lettres :lol: mais pour la multiplication) premiers.
Pourquoi premiers ? Pour qu'ils soient décomposés au maximum.
Exemple1 : 54=2*3*3*3
Exemple2 : 78=2*3*13

La décomposition a plein d'applications algébriques, mais que je ne vous enseignerais pas ici, parce-qu'on n'est pas en cours de maths ! :D


TP : décomposeur Construire le programme pas à pas

Construire le programme pas à pas

La décomposition : ça veut dire quoi ? Le code complet

Construire le programme pas à pas

Passons donc au programmme :

Étape n°1:

Très simple : on demande à la calculette de créer une liste dans laquelle on placera les facteurs premiers et on place dans C le nombre de termes de cette liste augmenté de 1 (sauf au début car le premier terme de valeur 1 sera supprimé).

:{1→L1
:1→C
Étape n°2:

On va demander à l'aide d'un message d'invitation (beaucoup plus confortable qu'un "A=?" :-° ) le nombre à décomposer.

:Input "dec ",A

Et tes minuscules, tu les trouve où ?

Alors soit les minuscules sont activées, soit je fait VARS / 5 et j'ai dans les différents menus quelques minuscules. :p (c'est expliqué dans le chapitre consacré aux astuces)

Étape n°3:

On va maintenant créer une boucle conditionnelle dans laquelle on donnera à B les valeurs de 2 (le plus petit nombre premier) à √A.

:For(B,2,√(A

//instructions diverses et variées

:End
Étape n°4:

Va bien falloir donner un corps à la boucle précédente, non ? A l'intérieur de celle-ci, on va vérifier si A est divisible par B.
Voici donc le corps de la boucle "For(" :

:While not(fPart(A/B  //Tant que A est divisible par B
:B→L1(C  //on ajoute B à la liste (au terme n°C)
:C+1→C  //la liste comporte un terme de plus
:A/B→A  //on réduit le nombre restant
:End
Étape n°5:

On finalise le projet puis on affiche la liste.

:If A≠1:A→L1(C  //s'il reste un nombre premier, l'ajouter à la liste
:L1  //afficher la liste en pouvant la faire défiler sur l'écran principal