Conventions de programmation TI-Basic - Page 4

arf

Ouais merde t chiant je peux plus répondre
Tu veux pas qu'on continue la discution ici ? (jusqu'a ce que Yaka lache à son tour )

en plus exactement la même erreur que quand j'ai mis HS ce forum! sauf que la j'avais même pas floodé!

c fini de poster en même temps que moi oui ?

/me fait une pause...

/me ne veu tpas casser le forum yaka...

tu voilais qu'on continue la discution rendez vous a post.php?id=1,4990,225 il a bien besoin de ce prendre quelque page inutiles!

je t'attends, homme saint !

PUTAIN !!!

Au post 19 on s'est mit à parler de lignes de programme particulièrement longues...
Bon voilà je crois que j'ai gagné :

augment({#(l_pth[dim(l_pth)])[1]},augment(augment({#(l_pth[dim(l_pth)])[l_jmp[2]+1]},augment(mid(#(l_pth[dim(l_pth)]),2,l_jmp[2]-1),mid(#(l_pth[dim(l_pth)]),l_jmp[2]+2,(dim(#l_tmp)-1)/2-l_jmp[2]))),augment({#(l_pth[dim(l_pth)])[l_jmp[2]+(dim(#l_tmp)-1)/2+1]},augment(mid(#(l_pth[dim(l_pth)]),(dim(#l_tmp)-1)/2+2,l_jmp[2]-1),mid(#(l_pth[dim(l_pth)]),(dim(#l_tmp)-1)/2+l_jmp[2]+2,(dim(#l_tmp)-1)/2-l_jmp[2])))))



Alors en "optimisant" ça donne :

l_pth[dim(l_pth)]»l_tmp
(dim(#l_tmp)-1)/2»l_chx
augment({#l_tmp[1]},augment(augment({#l_tmp[l_jmp[2]+1]},augment(mid(#l_tmp,2,l_jmp[2]-1),mid(#l_tmp,l_jmp[2]+2,l_chx-l_jmp[2]))),augment({#l_tmp[l_jmp[2]+l_chx+1]},augment(mid(#l_tmp,l_chx+2,l_jmp[2]-1),mid(#l_tmp,l_chx+l_jmp[2]+2,l_chx-l_jmp[2])))))

Vive le basic
[edit]Edité par Bob 64 le 11-02-2002 à 15:18:00[/edit]

lol je me disais aussi que c'était vraiment mais vraiment trop barbarre!

T'as vu un peu l'optimisation ? Ça change tout !

Gavé

Eheh j'ai réussi à faire partir ce topic en couille

D'abord avec le concours de la ligne la + longue (d'ailleurs g gagné : post98 ), maintenant je vais me lancer dans l'algo récursif le + compliqué que j'ai jamais tenté...

Faire compliqué et barbare c'est pas dur, le défi c'est de faire complexe et lisible!

moi je peut vous faire des expression recursives :


x^2 -> /x

x est declaré mais contient x^2 ...
bon ok ca n'a rien a voir mais bon...

Uther > Cette ligne compliquée et barbare et la + optimisée que j'ai trouvé pour faire ce que je veux faire... Si tu me trouve mieux je prends volontier !

Azerty > lol

Bob64> J'essairai volontier mais c'est ton prog pas le mien, si j'arrivait a trouver certaine fourmule de mon jeu, t'attriverai pas a comprendre plus!
D'ailleurs moi non plus: ca fait tellement longtemps que j'y ai plus touché!

Oui enfin en fait la c parceque c 1 ligne particulièrement barbare que ça m'amuse

J'ai pas trouvé + court pour le même effet

Tu peux aussi si tu tient a faire dans le barbarre illisible, suprimer tous le retours a la ligne et mettre des ":"

/me pense que Bob64 est vraiment un barbare !!!!

/me a jamais fait aussi compliqué ... remarque c'est impossible de faire encore - lisible ...

Algo récursif:

parite(a) ;;a est un entier naturel
Func
If a=0 Then
"pair"
ElseIf a=1
"impair"
EndIf
parite(a-2)
EndFunc

Et voilà, c'est l'algo récursif le plus compliqué que j'ai jamais trouvé!!!

et heu c censé faire quoi ?
(et puis des return devant les string seraient les bienvenus)
[edit]Edité par azerty83 le 12-02-2002 à 20:24:36[/edit]

Tu connais pas la récursion???
C'est pas sensé faire un truc compliqué, c'est juste fait (au cas ou t'aurais pas compris...) pour renvoyer "pair" si un nombre est pair, et............ devine!

Mais ??? c con ?

si tu lance le prog avec a pair, bah a-2 c'est tjrs pair, a-2-2 encore, etc...
à l'inverse si tu commence avec 1 impair ça tombe tjrs sur un impair...

inutile ?

Et j'ajoute que ma ligne de barbare est ce qu'il y a de + optimisé que j'ai trouvé...
Si qqun a mieux je prends volontier...

Je crois que ton algo récursif va s'arrêter au bout de 70 fois voire +, car la TI ne spporte que 70 (voire + ) imbrications dans un prog BASIC ...

c vrai ...

Bon ça va alors, étant donné que c'est un algo pour un "exloreur" (ou qq chose qui y ressemble), je ne pense pas arriver à 70 dossier imbriqués les uns dans les autres

Ah au fait, y'a pas un équivalent de inString pour les listes ? (une fonction de recherche rapide pour liste)

Sinon va falloir la faire en basic et ça va pas être du rapide...

Bob64-> dans certains langages, t'as que ce moyen pour savoir si un nombre est pair...
Et puis, peut-être que cela pourra faire comprendre la récursion à certains, le principe est pas évident pour tout le monde

Ah ok alors voilà celui que j'ai pondu :

Define itr_delt(l_var,l_elm)=Prgm
Local l_tmp,l_hlp,l_dim,l_typ
(dim(#l_var)-1)/2»l_dim
#(#l_var[l_elm+1])[1]»l_typ
If getType(l_typ)?"STR":"None"»l_typ
If l_typ="Dossier" Then
(dim(#(#l_var[l_elm+1]))-1)/2»l_hlp
For l_tmp,1,l_hlp
itr_delt(#l_var[l_elm+1],1)
EndFor
EndIf
DelVar #(#l_var[l_elm+1])
augment({#l_var[1]},augment(augment(mid(#l_var,2,l_elm-1),mid(#l_var,l_elm+2,l_dim-l_elm)),augment(mid(#l_var,l_dim+2,l_elm-1),mid(#l_var,l_dim+l_elm+2,l_dim-l_elm))))»#l_var
EndPrgm

(Pim, PAS UN MOT sur les indirection )
Il sert à scanner un dossier, tant qu'il tombe sur des fichiers il les supprime, si il tombe sur un dossier il se relance sur lui-même pour le scanner (récursion) et ainsi de suite...
Ça sert pr un exploreur à dossier imbriqués, pour que quand on supprime un dossier il supprime aussi ce qu'il y a dedans