Challenge récursive.

[x_all]

(doublon (cdr lstR))

 

quand même j'aurai pu la voir celle là...

J'ai essayer de comprendre la solution de Gégé, ... ben j'y arrive pas. et puis c'est quoi cette commande (listp dont je n'avais jamais entendu perler... j'ai beau lire l'aide je comprend pas à quoi ça sert.

''Verifies that an item is a list'' mais en lisp tout est liste non?

oui je sais je fait mon ronchon il y a les atomes...

 

[GEGEMATIC]

Salut,

@GEGEMATIC, on doit pouvoir supprimer certaines redondances

Oui mais il était tard, il fallait que je rentre !

ci dessous un peu plus concis, mais j'utilise presque toujours le cond, comme ça je sais que je suis directement près à avoir plus de 2 éventualités. Souvent je programme des traitements dans l'urgence, sans avoir eu le temps de faire une analyse correcte, donc "cond"

d'ailleurs, ce challenge, c'est plus une histoire d'analyse que de récursivité.

(defun doublon (lst)
(if
 (and lst
      (listp lst)
 )
 (if (member (car lst) (cdr lst))
  t
  (doublon (cdr lst))
 )
)
)

[x_all]

écrit comme ça je comprend.(listp lst) équivaut à (if (/= nil (cdr lst))

en fait on fait pareil.. mais c'est plus joli avec ta tournure..

 

[Patrick_35]

Bonjour

 

Bravo pour vos efforts :D

 

@gégé

Comme le dis (gile), tu as réussi et c'est le principal. Quelle satisfaction de réussir ce type de challenge car ce qui est énervant, c'est que l'on sent que la solution n'est pas loin, mais qu'on n'y arrive pas.

On a beau essayer de passer à autre chose, mais quand ça trotte dans un coin de la tête ;)

On peut aussi optimiser encore un peu

(defun doublon (lst)
 (and lst
   (if (member (car lst) (cdr lst))
      t
      (doublon (cdr lst))
   )
 )
)

 

@x_all

Tu y es presque, ta fonction ne marche pas avec par exemple (doublon '(1 2 3 4 5 2 6 7 8 9 3))

 

@Fraid

Encore un effort, et avec les exemples postés, cela peut t'orienter.

 

Bien vu (gile) avec vl-some. j'ai fais une fonction proche de celle de Bonus, mais en récursif et moins bien que celle de gégé

(defun doublon(lst / dbl)
 (defun dbl(lst)
   (if lst
     (cons (vl-position T (mapcar '(lambda(x) (equal (car lst) x)) (cdr lst))) (dbl (cdr lst)))
   )
 )
 (not (apply '= (dbl lst)))
)

 

(defun doublon(lst / dbl)
 (defun dbl(lst)
   (if lst
     (cons (equal (length (vl-remove (car lst) lst)) (1- (length lst))) (dbl (cdr lst)))
   )  
 )
 (not (apply '= (dbl lst)))
)

 

@+

[x_all]

harf... j'étais à 2 doigts... je vais voir ça...

 

 

j'avoue que je capte pas pourquoi il passe par le 2eme If..

Ou est l'embrouille?

c'est vrai ce ce pb disparait avec un (case

   
  
(defun doublon (lstR / rep)
(setq i (+ 1 i))
(if	(and (cdr lstR) (member (car lstR) (cdr lstR)))
 	(setq rep T)
 	(if (/= nil (cdr lstR))
(doublon (cdr lstR )
)
 	)
)

rep

 )

Ps

je sais pas ce qui se passe, mais j'ai des soucis de copier coller avec indentation... j'ai des saut de ligne qui se barrent

je suis le seul?

[Patrick_35]

A mon avis, le problème se situe dans le retour de la fonction avec la variable rep

 

@+

[didier]

Coucou

j'enrage de me sentir isolé

n'étant pas capable de proposer une solution je ne suis pas capable d'appliquer la récursivité, un point c'est tout, putain ça fait mal !

[lecrabe]

Hello Didier

COOL / ZEN : tu peux tres bien atteindre la Retraite en Mode NON Recursif !

Bon WE, Bye, lecrabe

[(gile)]

Dans l'esprit des réponses de GEGEMATIC, x_all et Fraid :

 

(defun doublon (l)
 (cond
   ((null l) nil)
   ((member (car l) (cdr l)) T)
   (T (doublon (cdr l)))
 )
)

 

Ou, plus élégant :

 

(defun doublon (l)
 (or (member (car l) (cdr l))
     (and l (doublon (cdr l)))
 )
)

[Patrick_35]

Salut Didier

 

Je suis d'accord avec lecrabe. Tu peux très bien vivre sans le récursif. Tu peux aussi essayer celui-ci.

 

@+

[didier]

Coucou

non je me sens vraiment out et j'en peux plus, désolé

ma première idée tout de suite est d'effacer toutes mes traces sur le net, je résiste mais combien de temps ?

[Patrick_35]

(defun doublon (l)
 (or (member (car l) (cdr l))
     (and l (doublon (cdr l)))
 )
)

Quand on le voit, cela parait tellement simple.

Encore faut-il l'écrire.

Je n'ai qu'un mot : respect

 

Merci

[Patrick_35]

Tu nous fais un petit coup de grisou ?

 

Allez Didier, tu apportes tellement autrement.

 

@+

[didier]

Coucou

le grisou a pris feu,c'est trop tard

[x_all]

pouh lala

en fait c'est vrai que c'est la variable de retour qui doit être réinitialisée quand le récursivité remonte pour sortir car elle est déclaré en local dans (doublon)?

ou alors ça restera un mistère

Pour me passer de variable il a fallu que je me creuse...mais bon j'ai lu la réponse de (gile) tout est dit, mon code est trop moche pour être posté ...

[DenisHen]

j'enrage de me sentir isolé

n'étant pas capable de proposer une solution je ne suis pas capable d'appliquer la récursivité, un point c'est tout

Non didier, tu n'es pas seul... Et tu restes fort utile sur plein d'autres sujets... ;)

 

PS : tu ne formates plus tes messages ?

[GEGEMATIC]

Coucou

le grisou a pris feu,c'est trop tard

Bon dieu Didier,

j'essaye de retrouver le 1er programme récursif que j'ai vu, (en 1991 ...)

c'était un copain Marocain qui l'avait fait,

par la suite j'ai dû le ré-écrire sans récursion car son usage faisait qu'il dépassait souvent la pile.

mais il était tellement limpide que tout de suite on comprenait.

je cherche depuis 20mn, pas moyen !

Grr !

[DenisHen]

Re.

 

Juste une petite question, la récursivité se reconnait-elle par une commande (ou fonction) qui fait appel à elle-même ?

 

Est-ce sa seule particularité ?

[(gile)]

Re.

 

Juste une petite question, la récursivité se reconnait-elle par une commande (ou fonction) qui fait appel à elle-même ?

 

Est-ce sa seule particularité ?

 

Oui, mais on ne parle pas que de fonctions, on peut parler aussi de structure récursive (arborescences, fractales) :

- un dossier contient potentiellement des fichiers et des dossiers

- une liste de données LISP (liste chaînée) est : soit une liste vide ; soit une donnée (car) et un pointeur vers une liste de données (cdr). Schématiquement : () | (cons x lst).

 

On parle aussi de définition récursive pour le LISP : une expression LISP est : soit un atome ; soit une liste d'expressions LISP.

[DenisHen]

Merci (gile)... Structure Ouroboros ? ;)

 

C'est d'un niveau encore loin pour moi...

 

J'ai lu plusieurs de tes routines et j'ai mal au crane quand je tombe dessus... :(

 

Trop bien écrites, trop "concises", trop efficaces... ;)

 

C'est pas pour les novices... Dont je fais parti... :(

[VDH-Bruno]

Bonjour,

 

Sur ce challenge la porte du récursif ayant été verrouillé par les précédents intervenants. On peut s'autoriser une petite optimisation (si on est pas trop attaché au style) sur "la solution hors sujet" en économisant des parcours sur la liste du au 2ème member dans (member x (cdr (member x l))).

 

vl-some comme mapcar étant des fonctions d'ordre supérieur, a l'appel de ces fonctions l'argument liste est chargé en mémoire, on peut donc à chaque itération "muter" son état dans la fonction argument en écrivant ceci:

 

(defun doublon (l)
 (or (vl-some '(lambda (x) (member x (setq l (cdr l)))) l))
)

 

A+ Bruno

[DenisHen]

Je suis sûr que "VDH" veut dire "récursif" dans une langue... ;)

[VDH-Bruno]

Je suis sûr que "VDH" veut dire "récursif" dans une langue... ;)

Perdu ce sont les initiales de mon nom de famille qui en langue flamande peut ce traduire par "de la lande" ;)

[DenisHen]

...en langue flamande...

Un belge... Quel plaisir... Mes grands parents paternels étaient belge... ;)

Mon nom est d'origine belge... Hennuyer, c'était les habitants du Hainaut...

[VDH-Bruno]

Un belge...

 

Non du tout, même si je serais lundi et mardi du coté de Bruxelles pour le travail. Pour l'anecdote les Flandres ça existe aussi en France

 

Pour info je suis originaire de l'Oise et j'habite dans la région Creilloise

 

A+