Opti-Défi n°4 : codeur MORSE lumineux

[Adriweb]

Au fait, tu as eu ta 83 Premium CE comment ?
En tant que prof ? Eleve dans une classe pilote ? Autre ?

[grosged]

Une TI83PCE ?..Ahhhh, le veinard !!!

Bon!.. Je me suis de nouveau penché sur ma version:
EDIT: maintenant en version 5 ,ce qui fait maintenant 484 octets (sur ma TI-84 Pocket.fr)
1 octet grapillé grâce à Mingerton
(J'en ai profité pour l'agrémenter d'explications (désolé pour l'autre fois: j'avais la flemme )
Depuis la première version, rien n'a changé, si ce n'est qu'elle démarre en mode "chiffres".

Code: Select all

{226,3752,14888,0,0,936,14,3722,3720,938,58,57890,3624,3746,904,232,14472.06004,14882.239752,57992.952456
,930,234,56.014506,906.003754,3626.015016,3618,14504,57896.926242,14984.231562,.057898,0,0,3704968→L1
ClrList L2           // morse codé en binaire (partie entière pour les lettres; fractionnée pour les chiffres sauf 0).
106→dim(L2                 // correspond à la val.max d'un getKey+1.
For(A,0,31                                 // de la touche [A] jusque [0].
L1(A+1→L2(A+42+5int(A/5  // afin que L2(getKey+1) nous donne le code morse adéquat.
End:ClrHome                          // efface l'écran de calcul.
Ans→ΔX:Ans→ΔY                 // grosse valeur dans ΔX,ΔY (en l'occurence L1(32)=3704968).
GridOn                                   // pour qu'un affichage de grille nous
StorePic Pic1                                // noircisse tout l'écran.Stocké dans Pic1                                   
GridOff                                // maintenant: écran  sans grille,
FnOff :AxesOff                 // ni fonction Y=, ni axes.
1→T:1→U                  // T=position de la TI, U=position de l'utilisateur (dans L1 qui contiendra le message).
Menu("DEBIT","LENT",0,"NORMAL",1,"RAPIDE",2
Lbl 0:Ans/2                       // lent? D=.25,
Lbl 1:Ans/2                        // normal? D=.5,
Lbl 2:Ans→D                     // rapide? D=1.
Delvar E0L2→L1                 // E=variable d'état; L1 va contenir le message.
While 1                                // boucle principale...et unique, d'ailleurs!
E+D→E                             // On se permet de déchiffrer seulement quand E est entier.
L1(T                                      // la TI transcrit le bout de code en position T.
If int(Ans:Then                            // Partie entière pas encore nulle?      
   Ans/(1+not(fPart(E→L1(T           // alors on continue son déchiffrage binaire (avec E entier):
       If .5≤fPart(Ans:Then            // on tombe sur un bit à 1 ?
      ClrDraw                                 // donc on efface l'écran...
      Else                                         // sinon,
      RecallPic Pic1                     // on le remplit.
   End
   Else                                     // le déchiffrage était fini ? (=partie entière nulle)
   T+(T≠U→T                        // alors on passe au suivant...s'il y en a un!
End
getKey→G                           // scrute le clavier.
A xor G=31→A                    //permutée grâce à [alpha], A=0 ou 1 (mode "lettres" ou "chiffres").
L2(G+1                                 // Ans=code morse correspondant à la touche pressée
IF A:E6fPart(Ans          // si A=1 (mode "chiffres"), on s'intérèsse à la partie fractionnée (le E est le double petit EE),
int(Ans→L1(U                    // sinon, c'est la partie entière.puis stocké dans L1, en position U
U+not(not(Ans→U            // on a bien eu une touché pressée, laquelle nous a donné un code non nul?..
End                                 // alors on incrémente la position U, et la boucle est bouclée!

Cette 5ème version est téléchargeable ici : http://ti-pla.net/a171073

[Mingerton]

Je dis peut être une option que tu as déjà pesée, mais je pense qu'il y a des gains de vitesse à faire ici :

Code: Select all

Lbl 0:.5Ans
Lbl 1:.5Ans
//
T+(T-U→T
//
If A:fPart(Ans)e6
//
U+not(not(Ans→U          //not(not(Ans c'est Ans ou il y a une subtilité que je n'ai pas comprise ?

Edit : en fait j'ai compris, on récupère la valeur booléenne de Ans

[grosged]

J'avais pensé à .5Ans, mais ça prends le même nombre d'octets que Ans/2
T+(T-U→T ne peut pas remplacer T+(T≠U→T parce que si, par rapport à la TI, on vient de taper plein de caractères d'un coup, l'écart entre T et U sera forcément >1
(en fait T doit petit-à-petit rattraper U par incrément de 1)

Pour ce qui est du fPart(Ans)E6 , bien vu! je n'y avais pas songé, mais ça prend encore le même nombre d'octets que fPart(Ans)10^(6
(d'ailleurs tu me fais remarquer que j'ai mal recopié mon programme: j'avais oublié la parenthèse dans fPart(Ans)10^(6
j'utilise bien la fonction 10x accessible par [2nde][log], et mon erreur de frappe prétait à confusion, merci )
On peut tout de même rogner 1 octet ,il nous suffit d'en changer l'ordre : E6fPart(Ans
Bien joué, Mingerton Je vais modifier en conséquence

[Mingerton]

Je parle en vitesse pour ces optimisations

En effet, une division est deux voire trois fois plus lente qu'une multiplication (en Asm ou en Axe, mais ça se répercute aussi un peu sur le Basic), et le token 10^( est plus long à appeler que E. Pour la première optimisation, c'est vrai qu'elle n'arrange pas, notre processeur est trop lent pour la gérer. Merci pour l'explication, je ne comprenais pas pourquoi dans mes programmes parfois ça fonctionnait et parfois non

[grosged]

Je suis tout à fait d'accord avec toi : une multiplication sera toujours plus rapide qu'une division
Mais dans le cas présent, on peut mettre indépendamment .5Ans ou Ans/2 dans le sens où ça se produit hors boucle.
Tiens! Je viens de grapiller à nouveau 1 octet:
en remplaçant la ligne

Code: Select all

If round(fPart(Ans,0:Then

par

Code: Select all

If .5≤fPart(Ans:Then

[Wistaro]

Et bien, c'est joli tout ça
À côté, mon programme fait tâche 0_o

Pour le code morse, je n'ais pas fait la même chose que vous, mais ça marche. Même si c'est beaucoup moins optimisé.

Show/Hide spoilerAfficher/Masquer le spoiler

J'avais complètement oublié ce topic ! Désolé !