Challenge de la nuit

[Didier-AD]

bonsoir,

Vue l'heure un pas trop difficile

soit une liste très longue ayant cette structure

(x1 y1 z1 x2 y2 z2 x3 y3 z3........xn yn zn)

 

comment en faire (élégamment et sans utiliser Reverse) une liste de 3 listes

((x1 x2 x3 x4......xn) (y1 y2 y3 ....yn) (z1 z2 z3 ....zn))

 

A demain

[(gile)]

L'élégance étant une question de goût, les réponses devraient être multiples.

 

Une première pour utiliser une expression attribuée à Doug Wilson que je considère comme un summum de l'élégance (3d-coord->pt-lst est une routine que j'utilise pour transformer les listes retournées par (vlax-get Obj 'Coordinates) en liste de points).

 

(defun 3d-coord->pt-lst (lst)
   (if	lst
     (cons (list (car lst) (cadr lst) (caddr lst))
    (3d-coord->pt-lst (cdddr lst))
     )
   )
 )

(defun test (lst)
 (apply 'mapcar (cons 'list (3d-coord->pt-lst lst)))
) 

 

Sinon une plus directe (mais qui semble un peu moins rapide).

 

(defun test (lst)
 (if lst
   (mapcar 'cons
    (list (car lst) (cadr lst) (caddr lst))
    (test (cdddr lst))
   )
   '(nil nil nil)
 )
) 

 

[Edité le 18/5/2007 par (gile)]

[Bred]

sans utiliser Reverse

J'avoue ne pas trop voir où tu peux utilise reverse ...

 

Une solution plus basic :

(defun test (lst / A LSTX LSTY LSTZ) 
 (setq a -1)
;lstx nil
;lsty nil
;lstz nil)
 (repeat (/ (length lst) 3)
   (setq lstx (append lstx (list (nth (setq a (1+ a)) lst)))
  lsty (append lsty (list (nth (setq a (1+ a)) lst)))
  lstz (append lstz (list (nth (setq a (1+ a)) lst)))
   )
 )
 (append (list lstx) (append (list lsty) (list lstz))) 
)

 

[Edité le 18/5/2007 par Bred]

[(gile)]

J'avoue ne pas trop voir où tu peux utilise reverse ...

 

En reprenant ta solution et en utilsant cons plutôt que append pour construire les trois listes, la routine s'exécute presque une fois et demi plus vite.

PS : tu n'est pas obligé de faire deux fois appel à append à la fin, append accepte un nombre indéfini d'arguments

 

(defun test4 (lst / A LSTX LSTY LSTZ)
 (setq a -1)
 (repeat (/ (length lst) 3)
   (setq lstx (cons (nth (setq a (1+ a)) lst) lstx)
  lsty (cons (nth (setq a (1+ a)) lst) lsty)
  lstz (cons (nth (setq a (1+ a)) lst) lstz)
   )
 )
 (append (list (reverse lstx))
  (list (reverse lsty))
  (list (reverse lstz))
 )
) 

 

 

[Didier-AD]

J'avoue ne pas trop voir où tu peux utilise reverse ...

 

Et bien tu vois, Bred, Giles est tombé dans le piège de Reverse dans sa dernière réponse

 

Giles, ta première réponse est trés élégante puisqu'elle utilise la récursivité; c'est celle que j'utilise habituellement ; mais sur des listes très très longues tu risques d'atteindre la limite du tas (entre 500 et 2000 appels récursifs selon la taille de la fonction) ; dans ce cas, ta dernière réponse avec Reverse ou celle de Bred avec append conviennent mieux.

 

 

[(gile)]

Giles est tombé dans le piège de Reverse dans sa dernière réponse

 

Je voulais juste montrer à Bred comment il aurait pu utiliser reverse.

 

Si j'ai utilisé une forme récursive dans ma réponse, outre la coquetterie, c'est justement pour éviter d'utiliser reverse, puisque c'était la consigne.

 

Je pense, et les tests que j'ai pu faire le confirment, que la forme la plus rapide est la suivante (en plus, pas de risque de dépassement de la pile):

 

(defun test (lst / tmp)
 (while lst
   (setq tmp (cons (list (car lst) (cadr lst) (caddr lst)) tmp)
  lst (cdddr lst)
   )
 )
 (apply 'mapcar (cons 'list (reverse tmp)))
) 

 

[Edité le 18/5/2007 par (gile)]

[Patrick_35]

Bonsoir

De manière itérative et sans reverse

 

(defun test(lst / tbl)
 (while lst
   (setq tbl (append tbl (list (list (car lst) (cadr lst) (caddr lst))))
 	  lst (cdr (member (caddr lst) lst))
   )
 )
 tbl
)

(test '(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18))

 

@+

[(gile)]

Salut Patrick,

 

tu n'y est pas tout à fait, si la liste est :

(x0 y0 z0 x1 y1 z1 x2 y2 z2 x3 y3 z3 x4 y4 z4 x5 y5 z5 x6 y6 z6 x7 y7 z7)

 

ta routine retourne :

((X0 Y0 Z0) (X1 Y1 Z1) (X2 Y2 Z2) (X3 Y3 Z3) (X4 Y4 Z4) (X5 Y5 Z5) (X6 Y6 Z6) (X7 Y7 Z7))

 

la consigne c'est de retourner :

((X0 X1 X2 X3 X4 X5 X6 X7) (Y0 Y1 Y2 Y3 Y4 Y5 Y6 Y7) (Z0 Z1 Z2 Z3 Z4 Z5 Z6 Z7))

 

Une variante de celle de Bred, sans reverse ni append :

 

(defun test (lst / n lstx lsty lstz)
 (repeat (/ (setq n (length lst)) 3)
   (setq lstz (cons (nth (setq n (1- n)) lst) lstz)
  lsty (cons (nth (setq n (1- n)) lst) lsty)
  lstx (cons (nth (setq n (1- n)) lst) lstx)
   )
 )
 (list lstx lsty lstz)
) 

[Patrick_35]

Ah oui, j'ai mal lu l'exposé

0/20 :( ;)

 

@+