VDH-Bruno

Re, Oui c'est plus dans cette direction, en trouvant le moyen de tous les supprimer...

Oui c'est mieux, mais dans le traitement tu peux facilement optimiser quant je compare à ma version itérative avec foreach😊

Oui justement, ça me laisse perplexe car j'en ai pas eu besoin dans ma version récursive, mais j'avoue que sa fonction est plus efficiente que ma proposition, ça doit tenir à une question de style, je vais essayer de me dégager un peu de temps d'ici mardi soir pour opter pour une réécriture dans style un peu plus efficient, merci à (gile)

Bravo Fraid, maintenant que ça fonctionne je pense que tu dois pouvoir optimiser le traitement😉

Bonjour Fraid, Pour ma part ce n'était pas un problème de passion, juste que le challenge proposé faisait appel à des connaissances que je n'avais pas sur le sujet, donc j'avoue que pour participer cela m'aurait demandé un peu (beaucoup) de recherche pour que je puisse me mettre au niveau de la difficulté à relever. Sur ce coup, j'ai préféré passer mon tour une prochaine fois peut-être. Personnellement je te remercie tout de même de l'avoir posé car qui sait si un jour je veux jouer avec des url ce post sera une bonne base de départ. Salutations Bruno

Bonjour à tous, Dans un challenge précédent il a été rappelé au moyen d'une fonction groupBy l’intérêt de définir des fonctions générique, dans cette esprit (et en plus simple je pense) je propose ici d'écrire une fonction de coupure "générique" (très pratique après une fonction de tri) qui prendrait en argument une fonction prédicat appliqué à une liste: (coupure-if-not predicate-function liste) Pour tester _$ (coupure-if-not '= '(0 0 0 1 1 0 1 1 1 0 0 0 0 1)) ((0 0 0) (1 1) (0) (1 1 1) (0 0 0 0) (1)) _$ (coupure-if-not '(lambda (x y) (= x (1- y))) '(1 2 3 4 6 6 7 8 10 11)) ((1 2 3 4) (6) (6 7 8) (10 11)) Et/ou la fonction symétrique (normalement si on a l'une des deux il est aisé de faire l'autre) (coupure-if predicate-function liste) Pour tester _$ (coupure-if '= '(0 0 0 1 1 0 1 1 1 0 0 0 0 1)) ((0) (0) (0 1) (1 0 1) (1) (1 0) (0) (0) (0 1)) _$ (coupure-if '(lambda (x y) (= x (1- y))) '(1 2 3 4 6 6 7 8 10 11)) ((1) (2) (3) (4 6 6) (7) (8 10) (11)) Le but de ce challenge est de ce familiariser avec l'écriture/utilisation des fonctions dite "d'ordre supérieur", pour laisser tout à chacun le loisir de réfléchir au problème , je ne pense pas remettre ma copie avant Mardi soir ou Mercredi en journée. Pour ceux qui ont déjà cette fonction en magasin prière d'attendre les premières propositions ou tentative de propositions. (En cas de difficulté regarder du coté des fonctions vl-remove-if-not, vl-remove-if, vl-member-if-not, vl-member-if. (gile) en à déjà proposé des équivalences sur le forum, si je retrouve le lien je le posterai). Bon WE à tous

Gagné 😄😄😄 @(gile), bon je ne mettais pas trompé, c'est exactement ce à quoi je faisais allusion, je me souviens encore dans de ce sujet la première fois ou tu as exposé cette façon de faire, je l'ai décortiqué deux soir de suite pour me l'approprier, tellement je trouvais ça propre, je l'ai même resservie derrière sur Theswamp (j'étais tout fier 😉), une fois de plus merci.

Oui en les mettant à nil à la fin du code (repeat i (set (read (strcat var (itoa (setq i (1- i))))) nil))

Les listes sont beaucoup trop courte pour mesurer l'impacte de la récursivité, et sur ce type d'exercice, je ne pense pas que la vitesse d'exécution soit le critère à prendre en compte, la concision, l’élégance du raisonnement, ou la flexibilité du code sont plus à privilégier. J'ai pas le temps pour le tenter faire mais je pense que (gile) va nous proposer une résolution par "clef de recherche", ou quelque chose d'approchant attendons... @ Bruno

Je t'avouerai que je n'ai pas spécialement généralisé les miens, n'ayant pas complètement saisie les critères si le pas doit varié ou pas pour les valeur en Y et Z, et comment ils doivent être spécifié à l'appel de la fonction soit en dur (func lst_de_point fuzzX fuzzY fuzzZ) ou (func lst_de_point list_de_fuzz) ou (func lst_de_point fuzz_Identique X Y Z) mais comme la fonction de filtrage est passé en argument sur la première proposition, ce sera pas trop difficile à adapter au besoin😉

Je poste un dernier petit code écrit rapidement pendant la pause déjeuné, car je m'aperçois en lisant le fil de discutions que ma deuxième proposition ressemble beaucoup à ce qui a été proposé par fraid 😉 Rapidement ma troisième proposition dans la plus pur des traditions, sans fonction lisp spécialisé: (defun groupX (pts fuzz / f) (defun f (i l res acc) (if l (if (> i (caar l)) (f i (cdr l) (cons (car l) res) acc) (f i (cdr l) res (cons (car l) acc)) ) (if acc (cons res (f (+ i fuzz) acc nil nil)) (list res) ) ) ) (f (+ (apply 'min (mapcar 'car pts)) fuzz) pts nil nil) ) @+ Bruno

Bonjour à tous, Visiblement il y enfin "consensus sur l’énoncé" (ce qui visiblement a été le challenge du challenge 😄), je publie les codes écrit hier et très rapidement remanié sur la 2ème proposition [-14.3, -4.3[, [-4.3, 4.3[... Le premier un peu dans le même esprit que ce qu'avait proposé Luna, une base de code facilement généralisable en Y, Z... (defun groupeX (pts fuzz / loop) (defun loop (i pts f) (if pts (cons (vl-remove-if f pts) (loop (+ i fuzz) (vl-remove-if-not f pts) f)) ) ) (loop (+ (apply 'min (mapcar 'car pts)) fuzz) pts '(lambda (x) (< i (car x)))) ) Pour tester: _$ (groupeX pts 10) (((-14.3 14.3) (-6.3 14.2) (-13.6 7.5) (-6.6 4.7)) ((4.8 0.7) (-1.9 -3.2) (2.4 -4.9)) ((14.4 4.7) (8.0 0.9) (9.3 4.7) (6.6 11.2))) Le second sur un trie préalable des points et l'écriture d'une fonction auxiliaire (f) de groupement par plage de 10: (defun groupeX (pts fuzz / f) (defun f (i pts acc) (cond ((null pts) (list acc)) ((> i (caar pts)) (f i (cdr pts) (cons (car pts) acc))) (T (cons acc (f (+ i fuzz) (cdr pts) (list (car pts))))) ) ) (setq pts (vl-sort pts '(lambda (l1 l2) (< (car l1) (car l2))))) (f (+ (caar pts) fuzz) pts nil) ) Pour tester: _$ (groupeX pts 10) (((-6.3 14.2) (-6.6 4.7) (-13.6 7.5) (-14.3 14.3)) ((4.8 0.7) (2.4 -4.9) (-1.9 -3.2)) ((14.4 4.7) (9.3 4.7) (8.0 0.9) (6.6 11.2))) Je poste maintenant, car je ne pense pas pouvoir me dégager d'avantage de temps pour aller plus loin, mes je lirais vos codes avec un intérêt non dissimulé (Ps: Le gros challenge pour moi a été de générer un mot de passe valide pour me connecter au forum...😉) @+ Bruno

Bonjour, Cette fois je ne pensais pas participé (peu de disponibilité), mais comme ça n'a pas l'air de ce bousculer, une première proposition avec un code à minima calqué sur les 2 dernières propositions de l'exercice précédent. (defun c:ccc1 (/ nc ns c pt r ang) (and (setq nc (getint "\nEntrez le nombre de cercles: ")) (setq ns (getint "\nEntrez le nombre de sommets: ")) (setq c (getpoint "\nSpécifiez le centre: ")) (setq pt (getpoint c "\nSpécifiez la position du sommet: ")) (setq r (distance c pt) ang (angle c pt) ) (repeat nc (command "_.circle" "_non" c r) (command "_.polygon" ns "_non" c "_I" "_non" (polar c ang r)) (setq r (* r (cos (/ pi ns)))) ) ) (princ) ) :(rires forts): :(rires forts): :(rires forts): C'est forcément, cette dernière affirmation qui m'a fait sourire et décider de participé (car je sais trés bien ce que cela implique), car non on ne fera pas aussi bien que en .net, à moins d'essayer d'émuler le code au moyen de la fonction grread et de réécrire les accrochages aux objets en faisant d'interminable page de code fastidieuse, pour au final avoir un fonctionnement plus ou moins bancal... Malgré tout on peut s'en approcher à très peu de frais, très rapidement ma deuxième proposition sur le ton de l'humour :D : (defun c:ccc2 (/ nc ns c pt r ang cmdecho) (and (setq nc (getint "\nEntrez le nombre de cercles: ")) (setq ns (getint "\nEntrez le nombre de sommets: ")) (setq c (getpoint "\nSpécifiez le centre: ")) (princ "\nSpécifiez la position du sommet: ") (setq cmdecho (getvar 'cmdecho)) (setvar 'cmdecho 0) (vl-cmdf "_.polygon" ns "_non" c "_I" "_non" pause) (setq pt (cdr (assoc 10 (entget (entlast)))) r (distance c pt) ang (angle c pt) ) (entdel (entlast)) (repeat nc (command "_.circle" "_non" c r) (command "_.polygon" ns "_non" c "_I" "_non" (polar c ang r)) (setq r (* r (cos (/ pi ns)))) ) (setvar 'cmdecho cmdecho) ) (princ) ) A+ Bruno

@ Didier un petit oublie dans le code, les changements de plans (code 210 sur le cercle et la lwp) @ DenisHen, à être spectateur tu passes à coté de tous ce qu'il y a prendre dans ce type d'exercice, c'est vraiment dommage... Salutations Bruno

Pour la dernière je me suis fait doubler sur le fil du rasoir.. Le temps de lire le sujet et d'écrire les qq lignes de codes en command... (defun c:ccc2 (/ ss c r cmdecho) (setq c (getpoint "\nSpécifiez le centre du Cercle: ") ss (ssadd) r 1. cmdecho (getvar 'cmdecho) ) (setvar 'cmdecho 0) (repeat (getint "\nEntrez le nombre de Cercles: ") (command "_circle" c r) (ssadd (entlast) ss) (command "_rectang" "_NON" (polar c (* 1.25 pi) r) "_NON" (polar c (* 0.25 pi) r)) (ssadd (entlast) ss) (setq r (* (/ (sqrt 2) 2) r)) ) (princ "\nSpécifiez le rayon: ") (command "_scale" ss "" c pause) (setvar 'cmdecho cmdecho) (princ) )

Que dire a part renouveler ici mon admiration, c'est un festival ;) Au passage merci, je m'aperçois ici que je fais un abus de langage lorsque j'utilise le terme de "composition de fonctions" alors qu'en comparaison, je devrai qualifier cela d'imbrication de fonctions.

Merci pour le lien très intéressant, je ne connaissais pas ce site, je l'ai mis en favori, en cas de blocage futur je saurai à qui m'adresser :D Je pensais suivre ce cours https://www.fun-mooc.fr/courses/course-v1:UCA+107001+session02/about pour débuter, visiblement on en dit du bien, mais c'est toujours intéressant d'avoir plusieurs sources, le plus dur sera de se libérer les 7 à 10h /semaine nécessaire et en continue, d'aprés ce qui est conseillé.

Chapeau bas, très intéressant, j’ai récemment installer l’interpréteur Python sur mon ordi perso, pour le suivie scolaire de ma fille qui rentrera au Lycée l’année prochaine, mais j’avoue ne pas encore avoir trop regardé comment cela fonctionne, j’espère pouvoir me libérer un peu de temps pour ça cette été… A par AutoLisp, il n’y a que sur Scratch ou j’ai développé quelques compétences (Scratch c’est que de la programmation impérative et procédurale… Une horreur pour mon cerveau je suis vraiment pas outillé pour ça, mais au collège la barre et pas trop haute j'arrive encore à suivre ). Peut être que l'année prochaine je saurai dire si il y a moyen de faire mieux... en Python

Je crois qu'il est tombé dedans quant il était grand, car il est arrivé sur le tard, c'est d'autant plus remarquable :)

Bonjour à tous, Merci, je profite de l’occasion pour développer un peu la réponse de (gile), sur les fonctions auxiliaires et les accumulateurs, en limitant la portée de mon propos au Lisp (je laisse à chacun d’étendre cela à son propre langage en étant bien incapable). En général lorsque l’on dit récursion, 2 choix s’offre à nous la "récursion enveloppante", qui retourne les données dans le même ordre, et la "récursion terminal" qui stocke les résultats dans le corps de la fonction, puis retourne les résultats inversés (un peu comme le fais une boucle while). AutoLisp n’optimisant pas la récursion terminal et ne permettant pas les arguments optionnels, en général si l’ordre des termes en retour de fonction n’a pas d’importance, on privilégie la première forme considérée comme plus concise et plus élégante. En revanche si l’ordre des termes en retour nécessite une inversion pour économiser un reverse, on privilégie la récursion terminale avec l'emploi d’une fonction auxiliaire (defun ou lambda) afin d’introduire un accumulateur (à l'occasion on peut aussi être moins puriste en déclarant une variable globale). Dans notre cas : (defun f (s) (if (= s "") s (strcat (f (substr s 3)) (substr s 1 2))) ) Ce qui fait la concision de cette expression, n’est pas tant le fait de traiter directement la chaine, mais plus le fait d’utiliser une fonction de concaténation, pour s’affranchir de l’utilisation d’un accumulateur et d'une fonction auxiliaire. Les fonctions de concaténation de chaine, liste etc… , Comme strcat ou append porte déjà un accumulateur implicite dans leur définition. Par exemple si le problème posé l’avait été sous forme de liste : (setq l '(5 6 3 7 1 5 9 0 7 1 8 5 6 3 4 6)) En reprenant la fonction jeu1 donnée par (gile), avec l’emploi d’un accumulateur, on aurait : (defun jeu1 (l / f) (defun f (l a) (if (cdr l) (f (cddr l) (vl-list* (car l) (cadr l) a)) a ) ) (f l nil) ) _$ (jeu1 l) (4 6 6 3 8 5 7 1 9 0 1 5 3 7 5 6) Maintenant au jeu de la concision, lorsque la structure de donnée le permet et par analogie, on peut s’affranchir de la fonction auxiliaire qui n’a pour but que d’implémenter un accumulateur. En utilisant la fonction append : (defun f (l) (if l (append (f (cddr l)) (list (car l) (cadr l))) ) ) _$ (f l) (4 6 6 3 8 5 7 1 9 0 1 5 3 7 5 6) Avec ce type de fonction, on passe de la récursion terminal à enveloppant et vice-versa juste en changeant la position des appels à la fonction définie récursivement. Pour l’exemple la même fonction en modifiant la position des arguments dans la fonction append, la fonction retourne les données sans en modifier l’ordre: (defun g (l) (if l (append (list (car l) (cadr l)) (g (cddr l))) ) ) _$ (g l) (5 6 3 7 1 5 9 0 7 1 8 5 6 3 4 6) Bonne lecture Bruno

Grand bravo à toi (gile), j'admire ton aisance et ta polyvalence :) Bruno

Très rapidement une autre, et je m’arrête là car je vais me mettre dans le rouge sur mon dossier en cour.... (defun f (s) (if (= s "") s (strcat (f (substr s 3)) (substr s 1 2))) ) A+ Bruno

Salut Patrice La concision a un coût, c'est pas la plus rapide et en plus j'ai triché en prenant quelques liberté avec l’énoncé :P Amicalement Bruno

Salut (gile) Quant je suis passé il n'y avait que les 2 premières, j'ai pas vu que tu en avais rajouté, j'aurais du joué le jeu... Sans regret ce genre de challenge tombe toujours lorsque l'on est charrette c'est la loi de Murphy Amicalement Bruno

Bonjour, Par erreur je suis tombé sur les codes de (gile), avant de consulter ce post et comme je suis persuadé que j’aurais écrit sensiblement le même code sur l’algorithme proposé. Je ne vais pas aller sur cette voie (et faire moins bien), donc pour le jeu de la concision je ferai remarquer que : Inverser une donné puis permuter ses termes 2 à 2, revient à grouper les termes 2 à 2 puis à inverser le résultat. ;) Dans cet esprit et très rapidement ma proposition par composition de fonctions : (defun f (s) (vl-list->string (apply 'append (reverse (grp2 (vl-string->list s))))) ) Avec la fonction grp2 définie comme suit : ;; groupe les éléments 2 à 2 (defun grp2 (l) (if l (cons (list (car l) (cadr l)) (grp2 (cddr l)))) ) @+ Bruno