Challenge 14...

[lovecraft]

Merci de vos commentaire, je vais essayer d'organiser un peu mieux ma routine (cf commentaire de gile)

 

bred, je ne pense pas que la fonction member nous soit utile dans notre cas ( c'était le début de ma piste mais j'ai vite abandonné) peut etre que je ne sais pas m'en servir...

 

@plus

[Matt666]

Bah voilà ! Bravo !!! :D

 

Vu que je ne connais pas bien ta maitrise du lisp, je vais (si je peux me permettre) préciser les remarques constructives de (gile)...

 

 

Plus important à mon avis, déclare les variables, ça t'évitera les (setq lst1 nil)

Dans ta routine, tu utilises plusieurs variables (setq). Pour éviter de les mettre à nil au début de la routine, tu peux les déclarer.

Comment déclarer des variales, et où ??

la première ligne de ton code est (en général) la fonction defun (DEfine FUNction).

(defun nom_de_la_fonction (arguments / variables_locales))

Voilà où tu dois mettre tes variables locales.

 

Pour ton premier programme, ce serait ça :

(defun c:test (/ lst nbrelts p_dep nbr_supp i lst2 lst1 lst_final) ...)

Déclarer tes variables signifie en quelque sorte lister toutes les variables qui servent au programme, mais qui ne servent pas en dehors. Lorsque ton programme est fini, toutes les variables inscrites ici seront mises à nil.

 

 

et surtout de mauvaises surprises.

Si tu ne déclares pas tes variables, et ça tu l'as compris puisque tu as mis certaines variables à nil avant de les utiliser, elles peuvent encore avoir une information lorsque tu démarres ton programme. En plus déclarer ses variables est très pratique pour utiliser les mêmes variables dans tous tes programmes ! par exemple toutes mes listes se nomment lst, mes chaînes de caractères str, etc...

 

 

il est préférable de faire une sous routine avec 3 arguments qui retourne la liste transformée.

Rappel de la définition de la fonction defun

(defun nom_de_la_fonction (arguments / variables_locales))

Un argument est un paramètre de la fonction. Presque toutes les fonctions interne utilisées en lisp utilisent des arguments !

Exemple :

(setq nom1 definition_de_la_variable1 [nom2 definition_de_la_variable1])

où nom = nom de la variable

definition_de_la_variable = Ce que tu mets sous cette variable.

Autre exemple :

(defun carre (nb) (* nb nb))

Donc pour trouver le carré de 5, tu fais

(carre 5), et ça te retourne 25...

 

Pour notre challenge, Gile te propose ceci :

(defun delist (lst dep nb / nbrelts ...) ...)

Avec lst = liste à modifier

dep = Numéro de départ

nb = nombre d'éléments à enlever..

 

Nota : juste un truc, on ne peut pas faire d'arguments optionnels pour des fonctions persos.

Par exemple la fonction (substr) :

(substr chaîne début [longueur])

Tu vois que la longueur est entre crochet... Eh bien cet argument n'est pas obligatoire. Voilà.

 

Voilà !! A toi de jouer maintenant !!

 

Bon courage..

A bientot.

Matt.

 

[Bred]

bred, je ne pense pas que la fonction member nous soit utile dans notre cas ( c'était le début de ma piste mais j'ai vite abandonné) peut etre que je ne sais pas m'en servir...

:casstet: Si je t'en parle ....

je lache mon morceau :

 

(defun delst (l pos nb / i ls)
 (repeat (setq i pos)
   (setq ls (cons (nth (setq i (1- i)) l) ls))
   )
 (append ls (member (nth (+ pos nb) l) l))
 )

[Matt666]

Raaah le salaud !! :thumbup:

Si je t'en parle ....

Faut pas le chercher Bred !! hehe

Lovecraft, sache que tu as plusieurs autres solutions, moins techniques (et moins belles du coup) pour y arriver.. Avec un repeat, aussi...

 

Courage !

 

[Edité le 6/12/2007 par Matt666]

[(gile)]

Bred,

 

Ta routine ne fonctionne pas si la liste contient des doublons :

 

(delst_bred '(1 2 3 4 5 1 2 3 4 5) 2 5) -> (1 2 3 4 5 1 2 3 4 5)

 

(delst_bred '(1 2 3 4 5 1 2 3 4 5) 7 2) -> (1 2 3 4 5 1 2 5 1 2 3 4 5)

 

au lieu de :

 

(delst_gile1 '(1 2 3 4 5 1 2 3 4 5) 2 5) -> (1 2 3 4 5)

 

(delst_gile1 '(1 2 3 4 5 1 2 3 4 5) 7 2) -> (1 2 3 4 5 1 2 5)

 

 

[Bred]

Bred,

Ta routine ne fonctionne pas si la liste contient des doublons :

Tu es désobligeant (gile)... de me balancer à chaque fois ma médiocrité à la figure !!! :( :( ;)

 

En effet... lovecraft avait vu juste au sujet de member...

 

pfffff... une autre méthode alors ?

(defun delst (l pos nb / i ls1 ls2)
 (repeat (setq i pos)
   (setq ls1 (cons (nth (setq i (1- i)) l) ls1))) 
 (repeat (- (setq i (length l)) (+ pos nb))
   (setq ls2 (cons (nth (setq i (1- i)) l) ls2)))
 (append ls1 ls2)
 )

 

... mais un double repeat, c'est pas beau.... :P

[Bred]

Exactement la même chose que précedement, mais un poil plus jolie....

(defun delst (l pos nb / i ls1 ls2)
 (append
 (repeat (setq i pos)
   (setq ls1 (cons (nth (setq i (1- i)) l) ls1))) 
 (repeat (- (setq i (length l)) (+ pos nb))
   (setq ls2 (cons (nth (setq i (1- i)) l) ls2)))
 )
)

[Bred]

Bon, je m'amuse tout seul là, mais je voulais enlever ces 2 repeat...

voilà :

(defun delst (l pos nb / i ls)
 (repeat (setq i (length l))
   (if (or (< (setq i (1- i)) pos) (> i (1- (+ nb pos))))
     (setq ls (append (list (nth i l)) ls))
     )
   )
 ls
 )

[(gile)]

Non, tu ne t'amuses pas tout seul, mais prétentieusement je pensais devoir attendre encore un peu pour poster.

Vu où tu met la barre, je me lance.

 

Une première récursive (on ne se refait pas...)

 

(defun delst_gile1 (lst pos nb)
 (cond
   ((or (null lst) (zerop nb)) lst)		
   ((     (cons (car lst) (delst_gile1 (cdr lst) (1- pos) nb))
   )
   (T (delst_gile1 (cdr lst) (1- pos) (1- nb)))
 )
) 

 

Une avec while (sûrement la plus rapide)

 

(defun delst_gile2 (lst pos nb / i ret)
 (and (  (while (    (and (= (+ pos nb) i) (setq i pos))
   (setq ret (cons (nth (setq i (1- i)) lst) ret))
 )
 ret
) 

 

Une avec repeat (moins élégante que celle de Bred, mais une seule évaluation dans le repeat)

 

(defun delst_gile3 (lst pos nb / i n ret)
 (if (    (setq i pos n pos)
   (setq n (- i nb))
 )	
 (repeat n
   (and (= (+ pos nb) i) (setq i pos))
   (setq ret (cons (nth (setq i (1- i)) lst) ret))
 )
 ret
) 

 

Et une avec la routine sublist (ce que je suggérait à Lovecraft)

 

(defun sublist (lst start leng / n r)
 (if (or (not leng) (    (setq leng (- (length lst) start))
 )
 (setq n (+ start leng))
 (repeat leng
   (setq r (cons (nth (setq n (1- n)) lst) r))
 )
)

(defun delst_gile4 (lst pos nb)
 (append (sublist lst 0 pos) (sublist lst (+ pos nb) nil))
) 

[Matt666]

Bon bah je vais faire pareil...

 

(defun lsdel (lst pos nb / nlst)
   (repeat pos
       (setq nlst (cons (car lst) nlst))
       (setq lst (cdr lst))
   )
   (repeat nb (setq lst (cdr lst)))
   (append (reverse nlst) lst)
)

 

 

[Bred]

Une première récursive (on ne se refait pas...)

Moi, ça me trou 'lisp cette manière...

Je n'arrive vraiment pas à l'assimiler, malgré toutes les explications de (gile)...

[Matt666]

C'est vrai que c'est assez hallucinant....

[(gile)]

Super Matt, pas d'évaluation, ça devrait être rapide, je vais essayer quelques benchmarks.

[lovecraft]

Bon je crois que j'ai encore beaucoup de boulot devant moi (je vais oublier la solution récursive). Disons que le principal c'est que j'ai pu reussir à donner ma solution qui fonctionne avec des béquilles.

Enfin, encore merci de votre aide, vos challenges et commentaires qui me font progresser à une vitesse.....

 

@plus

[(gile)]

Lovecraft, ta solution ne fonctionne tout à fait honnorablement.

 

J'ai fait quelques benchmarks, pour ça j'ai renommé les fonctions avec un suffixe et un numéro s'il y en a plusieurs.

J'ai extrait une sous routine de la solution de Lovecraft pour pouvoir l'intégrer aux tests :

(defun delst_lovecraft (lst p_dep nbr_supp / i lst1 lst2)
 (setq i (+ p_dep nbr_supp))
 (repeat (- (length lst) (+ p_dep nbr_supp))
   (setq lst2 (cons (nth i lst) lst2))
   (setq i (+ i 1))
 )
 (setq i 0)
 (repeat p_dep
   (setq lst1 (cons (nth i lst) lst1))
   (setq i (+ i 1))
 )
 (append (reverse lst1) (reverse lst2))
) 

 

Cette série de test est faite avec une liste de 20 éléments, les résultats varient en fonction du nombre et de la position des éléments supprimés.

NOTA : la routine d'Evgeniy, plus polyvalente, fonctionne différement, elle supprime les éléments dont la position des donnée dans la liste (2nd argument).

 

Test 1 : 16 éléments supprimés au milieu de la liste

 

_$ (benchmark '((delst_bred1 lst 2 16)

(delst_bred2 lst 2 16)

(delst_bred3 lst 2 16)

(delst_matt lst 2 16)

(delst_lovecraft lst 2 16)

(delst_evgeniy lst '(3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18))

(delst_gile1 lst 2 16)

(delst_gile2 lst 2 16)

(delst_gile3 lst 2 16)

(delst_gile4 lst 2 16)

)

)

Benchmarking .................Elapsed milliseconds / relative speed for 16384 iteration(s):

 

(DELST_GILE2 LST 2 16).......................1094 / 3.68

(DELST_BRED1 LST 2 16).......................1110 / 3.63

(DELST_BRED2 LST 2 16).......................1157 / 3.48

(DELST_GILE3 LST 2 16).......................1172 / 3.44

(DELST_LOVECRAFT LST 2 16)...................1218 / 3.31

(DELST_GILE4 LST 2 16).......................1235 / 3.26

(DELST_MATT LST 2 16)........................1281 / 3.15

(DELST_GILE1 LST 2 16).......................1609 / 2.51

(DELST_BRED3 LST 2 16).......................1828 / 2.21

(DELST_EVGENIY LST (QUOTE (3 4 5 6 7...).....4031 / 1.00

 

Test 2 : 2 éléments supprimés au milieu de la liste

 

_$ (benchmark '((delst_bred1 lst 9 2)

(delst_bred2 lst 9 2)

(delst_bred3 lst 9 2)

(delst_matt lst 9 2)

(delst_lovecraft lst 9 2)

(delst_evgeniy lst '(10 11))

(delst_gile1 lst 9 2)

(delst_gile2 lst 9 2)

(delst_gile3 lst 9 2)

(delst_gile4 lst 9 2)

)

)

Benchmarking .................Elapsed milliseconds / relative speed for 16384 iteration(s):

 

(DELST_MATT LST 9 2)....................1157 / 1.69

(DELST_GILE1 LST 9 2)...................1203 / 1.62

(DELST_BRED1 LST 9 2)...................1422 / 1.37

(DELST_BRED2 LST 9 2)...................1422 / 1.37

(DELST_GILE2 LST 9 2)...................1438 / 1.36

(DELST_GILE4 LST 9 2)...................1500 / 1.30

(DELST_LOVECRAFT LST 9 2)...............1515 / 1.29

(DELST_GILE3 LST 9 2)...................1579 / 1.24

(DELST_EVGENIY LST (QUOTE (10 11))).....1891 / 1.03

(DELST_BRED3 LST 9 2)...................1953 / 1.00

 

Test 3 : avant dernier élément supprimé

 

_$ (benchmark '((delst_bred1 lst 18 1)

(delst_bred2 lst 18 1)

(delst_bred3 lst 18 1)

(delst_matt lst 18 1)

(delst_lovecraft lst 18 1)

(delst_evgeniy lst '(19))

(delst_gile1 lst 18 1)

(delst_gile2 lst 18 1)

(delst_gile3 lst 18 1)

(delst_gile4 lst 18 1)

)

)

Benchmarking ..................Elapsed milliseconds / relative speed for 32768 iteration(s):

 

(DELST_MATT LST 18 1)................1984 / 2.33

(DELST_BRED1 LST 18 1)...............2172 / 2.13

(DELST_BRED2 LST 18 1)...............2172 / 2.13

(DELST_GILE2 LST 18 1)...............2234 / 2.07

(DELST_GILE1 LST 18 1)...............2250 / 2.06

(DELST_GILE4 LST 18 1)...............2312 / 2.00

(DELST_LOVECRAFT LST 18 1)...........2391 / 1.93

(DELST_GILE3 LST 18 1)...............2516 / 1.84

(DELST_BRED3 LST 18 1)...............3141 / 1.47

(DELST_EVGENIY LST (QUOTE (19))).....4625 / 1.00

 

Test 3 : deuxième élément supprimé

 

_$ (benchmark '((delst_bred1 lst 1 1)

(delst_bred2 lst 1 1)

(delst_bred3 lst 1 1)

(delst_matt lst 1 1)

(delst_lovecraft lst 1 1)

(delst_evgeniy lst '(2))

(delst_gile1 lst 1 1)

(delst_gile2 lst 1 1)

(delst_gile3 lst 1 1)

(delst_gile4 lst 1 1)

)

)

Benchmarking ..................Elapsed milliseconds / relative speed for 32768 iteration(s):

 

(DELST_GILE1 LST 1 1)...............2203 / 2.31

(DELST_MATT LST 1 1)................2344 / 2.17

(DELST_EVGENIY LST (QUOTE (2))).....2390 / 2.13

(DELST_BRED1 LST 1 1)...............2875 / 1.77

(DELST_BRED2 LST 1 1)...............2875 / 1.77

(DELST_GILE2 LST 1 1)...............3641 / 1.40

(DELST_GILE4 LST 1 1)...............3718 / 1.37

(DELST_LOVECRAFT LST 1 1)...........3843 / 1.33

(DELST_GILE3 LST 1 1)...............3968 / 1.28

(DELST_BRED3 LST 1 1)...............5094 / 1.00

 

 

[Edité le 7/12/2007 par (gile)]

[(gile)]

J'ai fait aussi quelques tests sur une liste de 100 éléments les différences dans les résultats pécédent s'accentuent surtout si on supprime peu d'élements et à fortiori si les éléments supprimés sont en début de liste.

Les résultats des routines delst_evgeniy, delst-matt et delst_gile1 s'expliquent du fait que la liste après les éléments supprimés est retournée sans être parcourrue.

 

Bravo à Matt666 !

 

Suppression du 6ème élément d'une liste comptant 100 éléments

 

_$ (benchmark '((delst_bred1 lst 5 1)

(delst_bred2 lst 5 1)

(delst_bred3 lst 5 1)

(delst_matt lst 5 1)

(delst_lovecraft lst 5 1)

(delst_evgeniy lst '(6))

(delst_gile1 lst 5 1)

(delst_gile2 lst 5 1)

(delst_gile3 lst 5 1)

(delst_gile4 lst 5 1)

)

)

Benchmarking .................Elapsed milliseconds / relative speed for 16384 iteration(s):

 

(DELST_GILE1 LST 5 1)................1047 / 13.34

(DELST_MATT LST 5 1).................1094 / 12.77

(DELST_EVGENIY LST (QUOTE (6)))......1391 / 10.04

(DELST_BRED1 LST 5 1)................4031 / 3.47

(DELST_BRED2 LST 5 1)................4032 / 3.46

(DELST_GILE4 LST 5 1)................4110 / 3.40

(DELST_LOVECRAFT LST 5 1)............4437 / 3.15

(DELST_GILE2 LST 5 1)................4515 / 3.09

(DELST_GILE3 LST 5 1)................5062 / 2.76

(DELST_BRED3 LST 5 1)...............13969 / 1.00

[Matt666]

Bravo à Matt666 !

 

Merci... :red:

C'est marrant pourtant l'utilise un append... Je croyais que c'était plus lent...

Vivement un autre challenge (un peu moins balaise que le 15 !!) :o

 

A bientot..

Matt.

[lovecraft]

C'est sympa ce que tu fais gile, Merci pour l'encouragement ;)

Oui vivement un autre challenge...avant Noel faites que je puisse y participé comme celui-ci.

 

Merci

@plus

[Patrick_35]

Salut

 

Vivement un autre challenge (un peu moins balaise que le 15 !!) :o

Quand c'est trop facile, personne ne répond ou presque :(

 

Des idées de challenge pour évoluer, ce n'est pas ce qui manque, se sont les volontaires

 

Allez, juste une pour voir et ne trichez pas ;)

 

Il s"agit de retrouver toutes les cordonnées d'une polyligne dans une liste

 

@+

[Matt666]

Quand c'est trop facile, personne ne répond ou presque

Oui... Mais quand c'est trop dur, Gile trouve ça facile :D

Ceci dit ton challenge 15 est très intéressant !! Pas eu le temps de répondre. Dommage...

 

Sinon, Tu ne veux pas poster un nouveau sujet, plutot ?

Je n'avais pas vu ton post....

 

C'est un bon challenge, je pense !

 

A bientot.

Matt.

 

[Edité le 10/12/2007 par Matt666]