Rechercher dans la communauté

Jolie, Pour ta version 1, j'ai une version équivalente sauf que je me suis limité pour le jeu de ne pas écrire de fonction auxiliaire et à ne me servir que des fonctions natives en Autolisp. Pour ta version 2, je vais étudié cela plus dans le détail quant je serais en meilleur forme, notamment comment fonctionne la façon dont tu exprime l'infini dans ton code, je vais surement apprendre quelque chose. Pour ce qui est d'éviter de recalculer la valeur en entré je m'étais essayé par le passé à écrire une fonction de "mémoïsation" (pas sur que ce soit le bon terme) à titre expérimental, impossible de retrouver mes codes pour les adapter à ce challenge, de toute façon les opérations étant limité le coût aurait été supérieur au gain. La version codé sur le principe de la fonction TriangleRec donné précédemment avec les fonctions mathématiques native fournie en AutoLisp (atan sin / sqrt expt + -), contrairement aux tiennes je n'ai pas bordé les saisies, j'ai été au plus simple, l'idée était de montrer le procédé... ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Trigones 1 VDH-Bruno ;; ;; ---------------------------------------------------------------------------- ;; ;; Algorithme: Chaques fontions est définie en fonction d'une autre de façon ;; ;; qu'elles soient toutes chainées de façon à créer une dépendance ;; ;; circulaire, de fait si une valeur est insérer dans la boucle de ;; ;; dépendance toutes les fonctions sont alors définie et leurs ;; ;; valeurs respective retournées ;; ;; ---------------------------------------------------------------------------- ;; ;; Description: -> "lire dépend de" ;; ;; (tang) -> (sec) -> (cosinus) -> (cot) -> (csc) -> (sinus) -> (ang) -> (tang) ;; ;; ---------------------------------------------------------------------------- ;; ;; Liste des fonctions: ;; ;; - Angle (ang) ;; ;; - Sinus (sinus) ;; ;; - Cosinus (cosinus) ;; ;; - Sécante (sec) ;; ;; - Cosécante (csc) ;; ;; - Tangente (tang) ;; ;; - Cotangente (cot) ;; (defun trigones1 (ang sinus cosinus sec csc tang cot) (mapcar '(lambda (val fun) (if val (eval (list 'defun fun () val)) fun ) ) (list ang sinus cosinus sec csc tang cot) (list (defun ang () (atan (tang))) (defun sinus () (sin (ang))) (defun cosinus () (/ (cot) (sqrt (1+ (expt (cot) 2.))))) (defun sec () (/ 1. (cosinus))) (defun csc () (/ 1. (sinus))) (defun tang () (sqrt (1- (expt (sec) 2.)))) (defun cot () (sqrt (1- (expt (csc) 2.)))) ) ) (list (ang) (sinus) (cosinus) (sec) (csc) (tang) (cot)) )

Merci de la précision très intéressant, pour la version lisp je t’avouerai que je suis parti du principe que les valeurs saisies étant dans le premier quadrant du cercle, elle était forcément valide donc je n'ai pas prévu de gestion d'erreur... Le but "déguisé" était de montrer l’intérêt d'écrire une solution fonctionnelle en "chainant" les appels. Après comme il y avait peu de candidat sur le challenge j'ai aussi écrit une version plus "classique", version qui prend plus de 15mn à écrire 😉 .

Bonsoir nazemrap, En Lisp c'est mieux mais si tu souhaites en déposer une que tu ne peux pas retranscrire dans ce langage, personnellement je ne suis pas contre. Par contre je ne pourrai pas te la tester ou te faire un éventuel retour dessus. Après tout dépend du langage car je sais que certains font appel à des bibliothèques mathématiques spécialisées très bien fournies, dans ce cas il y a plus vraiment de challenge;) Salutations Bruno

Zut... Je viens d'en trouver une autre plus analytique, du coup la première que j'avais écrite perd un peu de son intérêt dans ce que je voulais démontrer, si j'avais un peu mieux réfléchie au sujet, j'aurais certainement modifier l'énoncé du challenge... Bon c'est le jeu on peut pas penser à tout😉

Bonjour (gile) Génial, même si j'en doutais pas, oui merci d'attendre un peu pour ne pas tuer le match. Perso j'ai écrit la mienne en moins de 15mn (j'ai été au plus simple), et je pense que l'on doit avoir sensiblement la même, si tu es impatient, tu peux me la poster en MP je jetterai un œil ça m'occupera, j'ai exceptionnellement un peu de temps devant moi, je suis à l'isolement forcé depuis hier... donc un peu de temps pour lancer et tester un challenge. Bruno

Salut, Je suis toujours ravi de pouvoir participer à un nouveau challenge. J'ai bien une réponse, mais je vais attendre un peu que d'autres répondent.

Bonjour Un nouveau challenge :D Le but est de retrouver tous les sous-répertoires à partir d'une branche de l'arborescence. Si on indique la racine, on aura donc tous les répertoires du disque. Ceux qui ont déjà la solution pourront patienter jusqu'à demain ;) @+

Salut, Ça fait longtemps qu'il n'y en pas eu, alors j'en propose un pas trop difficile. Il s'agit de faire une routine qui retourne la position d'une suite d'éléments dans une liste. Exemples : _$ (position '(3 1) '(3 1 3 3 4 2 1)) 0 _$ (position '(4 2 1) '(3 1 3 3 4 2 1)) 4 _$ (position '(4 1) '(3 1 3 3 4 2 1)) nil

Salut, Un petit challenge pour jouer avec l'appariement de caractères. Les parenthèses du LISP, les accolades du DCL ou des formatages de mtextes fonctionnent par paires et peuvent être profondément imbriquées. Il s'agirait donc de faire une routine "générique" qui retournerait une liste composée de la position d'un caractère ouvrant et de son correspondant fermant dans une chaîne. Les arguments pourraient être : - le caractère (ou suite de caractère) "ouvrant" ex : "(", "{", "% - son correspondant fermant, ex : ")", "}", ">%"... - la chaîne - la position du départ de la recherche dans la chaîne exemples : (paire "(" ")" "(* (+ 2 3) 6)" 0) retourne (0 12) (paire "(" ")" "(* (+ 2 3) 6)" 1) retourne (3 9) (paire "(" ")" "(* (+ 2 3) 6" 0) retourne nil [Edité le 18/8/2008 par (gile)]

Bonjour Je propose à petit challenge pour tous niveaux. Ceux qui se considèrent comme débutant peuvent déjà proposer leurs solutions. Ceux qui se considèrent comme d'un niveau intermédiaire pourront proposer leur solution à partir de mercredi. Et pour les autres, à partir de jeudi. Le but, serait à partir d'une liste, d'en extraire le début, la fin ou remplacer un élément d'une liste. Un exemple (setq lst '((1 "a") (2 "b") (1 "a") (1 "a") (5 "e") (3 "c"))) (deb_pat lst 3) --> ((1 "a") (2 "b") (1 "a")) (fin_pat lst 3) --> ((1 "a") (1 "a") (5 "e") (3 "c")) (sub_pat lst '(9 "i") 3) --> ((1 "a") (2 "b") (1 "a") (9 "i") (5 "e") (3 "c")) Un test du Benchmark sera fait sur toutes les propositions afin de déterminer le vainqueur pour la routine la plus rapide. A vous neurones ;) @+

Bonjour à tous, Allez je lance le p'tit challenge du WE. Le but c'est de creer des types de lignes avec des formes. Comme ci-dessous: 800x400http://images.imagehotel.net/w45xtrzy5p.jpg[/img] Je donne quelques piste pour les personnes qui ne connaissent pas. 1/ creer un fichier shp 2/faire un fichier shx 3/creer un fichier de type de ligne .lin Le but c'est de nous montrer vos plus belle oeuvres :) Bonne journée LB[Edité le 14/6/2008 par lovecraft][Edité le 14/6/2008 par lovecraft][Edité le 14/6/2008 par lovecraft][Edité le 14/6/2008 par lovecraft] [Edité le 14/6/2008 par lovecraft]

Bonsoir, Il s 'agit donc d' un puzzle paramétrable en nombre de pièces horizontales et verticales, ce qui donne des niveaux de jeux. N 'allez toutefois pas au delà de 10 x 10 sinon ça va ramer, quoique... C 'est un fichier compressé qui contient le module puzzle.dvb et l 'image puzzle_01.jpg, qu 'il faudra mettre à la racine C: Sinon, vous devrez adapter le code. Vous pourrez bien sûr changer l 'image qui devra être de 234 sur 234 en pixels. Quel est le challenge ? Cela ne génère que des pièces rectangulaires, j 'aimerais avoir des vraies pièces de puzzle. Dans le code, il y a les prémisses de cette construction.... Avis aux amateurs. Je n 'ai pas testé très profondément, retour souhaité ici. télécharger ici [Edité le 21/3/2008 par nazemrap]

Hello @VDH-Bruno Veux tu que je publie "en ton nom: VDH-Bruno" ta 2eme routine sur le challenge ? (defun test2 (str) (= 26 (length (member 90 (reverse (member 65 (vl-sort (vl-string->list (strcase str)) '<)))))) ) La Sante, Bye, lecrabe

Bonjour encore une idée de challenge :) Cette fois ci, ce serait pour incrémenter une valeur avec un nombre au choix par exemple (inc "40" 10) --> 50 (facile) (inc "ac5" 10) --> ad5 (on commence à corser) (inc "ac5" 20) --> ae5 (inc "ay5" 10) --> az5 (inc "ay5" 20) --> ba5 (inc "aaj" 10) --> aat (cela devient sérieux) (inc "aaj" 20) --> abd (inc "zy5" 10) --> zz5 (inc "zy5" 20) --> aaa5 (inc "zzh" 10) --> zzr (inc "zzh" 20) --> aaab @+ [Edité le 17/12/2007 par Patrick_35]

Bonjour et bonnes fêtes à tous, J 'ai changé de rubrique, celle-ci me paraissant plus adaptée. J 'ai voulu terminer mon challenge, cela n'a pas été sans mal. Je le soumets donc à vos appréciations et critiques, améliorations bienvenues. j' ai souhaité dessiner les symboles au moins une fois, en utilisant la création de blocs. Pas d' autres explications , c'est dans le code. A rajouter: le comptage et affichage du score.... Si ça ne marche pas, protester ici. Addiction interdite. 'definition des variables pour les 3 cartes (le 0 compte aussi) Dim carte(2) As AcadLWPolyline 'definition des points nécesssaires à la polyligne 4 sommets avec x et y pour chacun soit 8 valeurs en double précision Dim pt(0 To 15) As Double 'definition de la variable pour la largeur Dim largeur As Double ' definition de la variable pour la hauteur Dim hauteur As Double ' definition d' une varariable entier pour une boucle Dim fois As Integer ' definition d' une varariable entier pour l 'écart séparant 2 cartes Dim dep As Double ' definition d'une variable pour le chanfrein de la carte Dim ray As Double ' definition d'une variable pour verifier bloc existant Dim bloc As AcadBlock 'definition d' un contenant pour la liste de tirage. Dim liste As Variant Dim cp_liste As Variant Dim alea As Integer '----------------------- ' definition du point de centre de la carte Dim centre_carte(0 To 2) As Double 'definition de la position du symbole de la carte Dim pos_symbole(0 To 2) As Double 'definition de 3 arcs pour l 'as de coeur Dim arc(3) As AcadArc 'definition as de coeur comme région Dim as_de_coeur As AcadRegion '----------------------- 'definition des éléments necessaires a as de coeur 'liste d'entités qui composent le symbole coeur Dim liste_obj(3) As AcadEntity 'définition de la variable qui recevra la région Dim region As Variant 'définition des variables nécessaires à la hachure du symbole Dim hachure As AcadHatch Dim hachure_pique As AcadHatch Dim nom_motif As String Dim hachure_type As Long Dim associatif As Boolean Dim contour_hachure(0) As AcadEntity '----------------------- 'definition des blocs Dim pt_insertion(0 To 2) As Double Dim bloc_pied As AcadBlock Dim bloc_coeur As AcadBlock Dim bloc_pique As AcadBlock Dim bloc_trefle As AcadBlock '----------------------- 'definition des references de blocs Dim ref_coeur As AcadBlockReference Dim ref_pique As AcadBlockReference Dim ref_trefle As AcadBlockReference Dim calq1 As AcadLayer Dim calq2 As AcadLayer Dim calq_actif As AcadLayer '----------------------- 'definition des variables pour rejouer ou arreter Dim no_gagnant As Long Dim retour_carte As AcadLWPolyline Dim reponse As Integer 'definit variable pour verifier Dim verif As Integer Public Function DenR(angle) Pi = 4 * Atn(1) DenR = (angle * Pi) / 180 End Function Public Sub bonneteau_1() verif = 0 debut: pt_insertion(0) = 0: pt_insertion(1) = 0: pt_insertion(2) = 0 'valoriser les 3 paramètres de dimension et placement 'largeur = InputBox("Quelle est la largeur de la carte")'mettre en service ici pour la largeur de carte largeur = 10 'à supprimer si utlisation de la ligne supétieure. hauteur = largeur * 2 dep = largeur * 2 ray = largeur * 0.1 'positionne le symbole 'conforme aux tracés géométriques préconisés, mais à modifier suivant besoins 'cela permettra de changer le point de base si on fait tout un jeu un jour 'position en X pos_symbole(0) = pt_insertion(0) - (ray / 2) 'position en Y pos_symbole(1) = pt_insertion(1) + (ray) 'on reste sur le plan à 0 pos_symbole(2) = 0 'Stop 'Création des blocs si necessaires If verif = 0 Then coeur pied pique trefle End If 'Création des calques Set calq1 = ThisDrawing.Layers.Add("rouge_coeur_carreau") calq1.color = acRed Set calq2 = ThisDrawing.Layers.Add("noir_pique_trefle") calq2.color = acWhite 'la liste liste = Array("coeur", "pique", "trefle") cp_liste = liste 'création des cartes avec une boucle '3 tours For fois = 0 To 2 'point d' origine au tour suivant le placement du point d 'origine est augmenté de la variable de placement pt(0) = 0 + (dep * fois) + ray: pt(1) = 0 pt(2) = pt(0) + largeur - 2 * ray: pt(3) = pt(1) pt(4) = pt(2) + ray: pt(5) = pt(3) + ray pt(6) = pt(4): pt(7) = pt(3) + hauteur - ray pt(8) = pt(2): pt(9) = pt(3) + hauteur pt(10) = pt(0): pt(11) = pt(9) pt(12) = pt(0) - ray: pt(13) = pt(7) pt(14) = pt(12): pt(15) = pt(1) + ray 'creation de la carte proprement dit avec une polyligne 2d Set carte(fois) = ThisDrawing.ModelSpace.AddLightWeightPolyline(pt) 'propriété qui permet de fermer la polyligne sur son premier point carte(fois).Closed = True 'centre de la carte 'permettra les positionnements centre_carte(0) = pt(0) + (largeur / 2) - ray centre_carte(1) = hauteur / 2 centre_carte(2) = 0 'propriété qui permet d'avoir des coins arrondis For fois2 = 1 To 7 Step 2 carte(fois).SetBulge fois2, Tan(DenR(22.5)) Next fois2 'creation aleatoire pour dessinner les symboles Randomize alea = Int((2 * Rnd) + 0.5) While cp_liste(alea) = "rien" alea = Int((2 * Rnd) + 0.5) Wend 'Appel création de symbole Set calq_actif = ThisDrawing.ActiveLayer Select Case alea Case 0 ThisDrawing.ActiveLayer = calq1 Set ref_coeur = ThisDrawing.ModelSpace.InsertBlock(centre_carte, "coeur", 1, 1, 1, 0) Case 1 ThisDrawing.ActiveLayer = calq2 Set ref_pique = ThisDrawing.ModelSpace.InsertBlock(centre_carte, "pique", 1, 1, 1, 0) Case 2 ThisDrawing.ActiveLayer = calq2 Set ref_trefle = ThisDrawing.ModelSpace.InsertBlock(centre_carte, "trefle", 1, 1, 1, 0) End Select ThisDrawing.ActiveLayer = calq_actif cp_liste(alea) = "rien" Next fois 'reglage du zoom ThisDrawing.Application.ZoomExtents Dim pointz1(0 To 2) As Double Dim pointz2(0 To 2) As Double pointz1(0) = -(largeur / 2): pointz1(1) = 0: pointz1(2) = 0 pointz2(0) = largeur * 6: pointz2(1) = hauteur * 2.5: pointz2(2) = 0 ZoomWindow pointz1, pointz2 'boite de dialogue proposant de jouer If verif = 0 Then Dim Msg, Style, Titre Msg = "Jouer ?" ' Définit le message. Style = vbYesNo ' Définit les boutons. Titre = "Lancer le jeu" ' Définit le titre. ' Affiche le message. reponse = MsgBox(Msg, Style, Titre) End If 'efface les blocs ref_coeur.Delete ref_pique.Delete ref_trefle.Delete 'si reponse négative, sortir If reponse = 7 Then GoTo fin '--------------------------- 'seconde phase '--------------------------- 'affecte la carte gagnante Randomize alea = Int((2 * Rnd) + 0.5) no_gagnant = carte(alea).ObjectID 'Selection éventuelle de la carte gagnante 'MsgBox "Selectionnez l' as de coeur" 'Message d' invite, également sur la ligne de commande ThisDrawing.Utility.GetEntity retour_carte, basePnt, "Selectionnez l' as de coeur en cliquant sur le contour." If retour_carte.ObjectID = no_gagnant Then MsgBox "BRAVO, vous avez gagné !!!!" Else MsgBox "Malheureusement ce n 'est pas la bonne carte !" End If reponse = MsgBox("Voulez-vous rejouer ?", vbYesNo) If reponse = 6 Then For fois2 = 0 To 2 carte(fois2).Delete Next 'retourne à l 'étiquette debut en evitant la boite initiale verif = 1 GoTo debut End If fin: 'supprime les contours et les calques For fois2 = 0 To 2 carte(fois2).Delete Next calq1.Delete calq2.Delete ' Attention les blocs ne sont pas purgés. End Sub Public Sub coeur() '-------------------------- ' il s' agit ici d'un sous programme qui définit le bloc coeur. '-------------------------- Set bloc_coeur = ThisDrawing.Blocks.Add(pt_insertion, "coeur") 'traçage de arc1 supérieur gauche en reprenant le rayon défini pour l'arrondi et économiser les variables 'ceci est complètement arbitraire, à vous d 'innover sur ce point. ' l 'arc a besoin du centre, du rayon, de l'angle de départ en radian et de l'angle de fin en radian 'sens trigo 'on réutilise ici la fonction de MDSV31 pour la conversion degrés vers radians Set arc(0) = ThisDrawing.ModelSpace.AddArc(pos_symbole, ray, DenR(60), DenR(180)) 'miroir pour arc1 en symétrie avec 2 points Set arc(1) = arc(0).Mirror(arc(0).StartPoint, pt_insertion) 'traçage de arc3 inférieur gauche car je dispose maintenant du point final de 'arc1 qui devient le centre de arc3 Set arc(3) = ThisDrawing.ModelSpace.AddArc(arc(0).EndPoint, (3 * ray), DenR(300), DenR(360)) 'miroir pour arc2 en symétrie avec 2 points Set arc(2) = arc(3).Mirror(arc(0).StartPoint, pt_insertion) 'mettre les arcs dans la liste For fois2 = 0 To 3 Set liste_obj(fois2) = arc(fois2) Next 'Stop 'la region dans la variable variant region = ThisDrawing.ModelSpace.AddRegion(liste_obj) 'recupération de la région qui est la première et 'la seule créée présente dans la variable region 'il peut donc éventuellement y en avoir plusieurs Set as_de_coeur = region(0) as_de_coeur.Move arc(2).EndPoint, pt_insertion ' définition de la hachure nom_motif = "SOLID" hachure_type = acHatchPatternTypePreDefined associatif = True ' création de la hachure Set hachure = ThisDrawing.Blocks("coeur").AddHatch(hachure_type, nom_motif, associatif) Set contour_hachure(0) = as_de_coeur ' ajouter le contour et afficher la hachure hachure.AppendOuterLoop (contour_hachure) hachure.Evaluate hachure.color = acByLayer ThisDrawing.Regen True 'suppression du contour as_de_coeur.Delete arc(2).Delete End Sub Public Sub pied() '-------------------------- ' il s' agit ici d'un sous programme qui sera appelé par le programme principal. 'création du pied en bloc necessaire pour le pique et le trefle 'vous avez remarqué que c 'est la même figure à l 'envers 'avec les grands arcs inversés, ces arc ont été coservés après la création du coeur '-------------------------- Set bloc_pied = ThisDrawing.Blocks.Add(pt_insertion, "pied") 'miroir arc3 pour obtenir l 'inverse 'en utisant comme point de la ligne de symétrie les extrémités de arc3 Set arc(2) = arc(3).Mirror(arc(3).StartPoint, arc(3).EndPoint) 'supprime arc3 arc(3).Delete 'miroir arc2 pour obtenir l 'inverse Set arc(3) = arc(2).Mirror(arc(0).StartPoint, pt_insertion) 'transforme en region '--------------------------- 'pour faire une région, il faut une liste d' objets 'pour le nombre d' objets nécessaires à créer la région 'une region est dans une variable de type variant 'mettre les arcs dans la liste For fois2 = 0 To 3 Set liste_obj(fois2) = arc(fois2) Next 'la region dans la variable variant region = ThisDrawing.ModelSpace.AddRegion(liste_obj) 'recupération de la region qui est la première et 'la seule crée présente dans la variable region 'il peut donc éventuellement y en avoir plusieurs Set piedepique = region(0) 'retournement par rotation piedepique.Rotate arc(3).StartPoint, DenR(180) piedepique.Move arc(3).StartPoint, pt_insertion ' définition de la hachure nom_motif = "SOLID" hachure_type = acHatchPatternTypePreDefined associatif = True ' création de la hachure Set hachure = ThisDrawing.Blocks("pied").AddHatch(hachure_type, nom_motif, associatif) Set contour_hachure(0) = piedepique ' ajouter le contour et afficher la hachure hachure.AppendOuterLoop (contour_hachure) hachure.Evaluate hachure.color = acByLayer ThisDrawing.Regen True 'suppression des arcs maintenant inutiles, et du contour For fois2 = 0 To 3 arc(fois2).Delete Next piedepique.Delete End Sub Public Sub pique() '-------------------------- ' il s' agit ici d'un sous programme qui crée l' as de pique depuis les 2 blocs précédents '-------------------------- Set bloc_pique = ThisDrawing.Blocks.Add(pt_insertion, "pique") Set ref_pied = ThisDrawing.Blocks("pique").InsertBlock(pt_insertion, "pied", 0.8, 0.8, 0.8, 0) pt_insertion(1) = (3 * ray) + (ray / 2) Set ref_coeur = ThisDrawing.Blocks("pique").InsertBlock(pt_insertion, "coeur", 1, 1, 1, DenR(180)) pt_insertion(1) = 0 End Sub Public Sub trefle() '-------------------------- ' il s' agit ici d'un sous programme qui crée l 'as de trèle depuis les 2 premiers blocs '-------------------------- Set bloc_trefle = ThisDrawing.Blocks.Add(pt_insertion, "trefle") Set ref_coeur = ThisDrawing.Blocks("trefle").InsertBlock(pt_insertion, "coeur", 0.5, 0.5, 0.5, DenR(-100)) 'fait un réseau de 3 reseau = ref_coeur.ArrayPolar(3, DenR(200), pt_insertion) Set ref_pied = ThisDrawing.Blocks("trefle").InsertBlock(pt_insertion, "pied", 0.8, 0.8, 0.8, 0) End Sub

Bonjour Je propose un nouveau challenge auquel j'ai déjà donné la solution. Donc merci de ne pas tricher ;) Le but serait de savoir si un fichier dwg est déjà ouvert et si oui, par qui. @+

Donc, pour continuer dans la serie ;) J'ai une liste qui se compose de cette manière (setq lst '("a" "b" "c" "f" "a" "c" "f" "g" "t" "b" "c" "a")) J'aimerai connaitre le nombre de ""a, de "b", etc... sous la forme d'une liste et tant qu'à faire dans l'ordre alphabétique. @+

Bonjour , Voici le challenge auquel je suis confronté : --Je souhaite copier des repertoires contenat des dessins en dxf 2000 vers un repertoire avec ces dessins en dwg2004 avec au passage la creation de la miniatures .... --Pour la cretion de la miniatures , il suufit d'ouvrir chaque dessin dans autocad et de l'enregistrer à nouveau ( en ayant bien configurer autoacd )) Merci pour vos pistes , acr je ne sais pas trop si je pars sur du vba ou un cript ou un lisp... A bientot ..

Bonsoir, je me lance dans un challenge de débutant. Afin de sortir de l 'austérité du boulot, je souhaiterais fabriquer un jeu de bonneteau. (vous savez ce jeu de 3 cartes retournées où il faut retrouver la bonne). Ce thème pourrait faire l 'objet de choix d 'évolution. La première étape sera de faire dessiner 3 cartes . Elles seront rectangulaires en polyligne 2d de 10 de large sur 20 de haut, alignées horizontalement, séparées de 10 unités Le moins de lignes de code possible est souhaité, mais les commentaires sont les bienvenus, l 'objectif étant de faire connaître des possibilités d' utilisation. VBA bien sûr. [Edité le 21/10/2007 par nazemrap]

Voilà, je relance le challenge débutant j'espère qu'il attira les plus novices.Comme je me situe dans la cours des débutants, je vais essayer de lancer un thème. 1- traitement d'un jeu de selection 2-creer une liste de ce jeu

Suite à ce message, je propose un premier "challenge" en LISP réservé aux "débutants". Il faudrait donc que les lispeurs confirmés s'abstiennent dans un premier temps de répondre pour laisser les autres proposer leurs solutions, disons au moins jusqu'à Lundi soir ou Mardi matin dans la mesure où il y aurait déjà plusieurs réponses. Le but : - donner une routine qui retourne le centre de gravité d'un triangle défini par ses 3 sommets (p1, p2 et p3). - que le résultat soit juste (bien sûr) - essayer de faire le plus concis et élégant possible. Exemple : (defun cen-grav (p1 p2 p3) ...) tel que, avec : (setq pt1 '(10.0 5.0)) (setq pt2 '(4.0 15.0)) (setq pt3 '(-2.0 -5.0)) (cen-grav pt1 pt2 pt3) retourne (4.0 5.0) Le sujet a, il me semble déjà été traité, mais je le pense qu'il est intéressant pour ceux qui ne connaîtraient pas de solution à priori (encore une fois, les autres s'abstiennent de répondre). [Edité le 19/5/2007 par (gile)]

Bonjours à tous. Je voulais réaliser un lisp un petit peu "fun", mais qui pourrais être aussi utile. (une sorte de type de ligne, mais invariable) J'ai déjà commencé aujourd'hui et suis arrivé à un certain résultat. Le mieux est de l'essayer pour vous rendre compte de ce que je veux faire. (appliquez le sur un rectangle) J'en profite donc pour lancer un challenge (d'été), afin de l'améliorer et avoir un résultat correct pour toutes les LwPolylignes (arc). Au départ je voulais pouvoir l'appliquer à tout les objets curvilignes, mais ça complique pas mal les choses. Je pense que la partie (entmake) n'as pas besoin d'être reprise (sous réserve...) C'est plutôt la liste l_42, que je réserve pour la suite pour essayer de mettre le motif courbé. Celui-ci est pour l'instant traitée en segment droit. Le motif pourra être changé, on peut envisager un traitement de motif différent (losange, croix, insertion de segment non épais...) Mais déjà pour la mise au point, on peut garder ce motif. Donc pour ceux que l'idée interresse, les propositions sont attendues...et j'expliquerais les variables employées si vous ne comprenez pas à quoi elles servent. NB: Les points d'appuis originaux doivent êtres conservés. (defun c:lw2motif ( / ent obj_valx dxf_obj pt_first ep_lw d_inc pt_snd nb_vtx count l_pt lg_inc start_ep end_ep delta lg_vtx l_40 l_41 l_42) (vl-load-com) (while (not (setq ent (entsel "\nSelectionner un objet: ")))) (setq obj_vlax (vlax-ename->vla-object (car ent)) dxf_obj (entget (car ent))) (cond ((eq (cdr (assoc 0 dxf_obj)) "LWPOLYLINE") (setq pt_first (vlax-curve-getStartPoint obj_vlax)) (initget 71) (setq ep_lw (getdist pt_first "\nEpaisseur du symbole: ")) (initget 71) (setq d_inc (getdist pt_first "\nLongueur du symbole: ")) (setq pt_snd (vlax-curve-getPointAtParam obj_vlax 1) nb_vtx (fix (vlax-curve-getEndParam obj_vlax)) count 0 l_pt (list (cons 10 pt_first)) l_40 (list (cons 40 ep_lw)) l_41 (list (cons 41 0.0)) ; l_42 (list (cons 42 (vlax-invoke obj_vlax 'GetBulge count))) l_42 (list (cons 42 0.0)) lg_inc 0.0 start_ep ep_lw end_ep 0.0 delta 0.0 ) (repeat nb_vtx (setq lg_inc (vlax-curve-getDistAtParam obj_vlax count) lg_vtx (vlax-curve-getDistAtParam obj_vlax (1+ count)) ) (while (< (+ lg_inc d_inc) lg_vtx) (if (< (+ lg_inc d_inc) lg_vtx) (setq start_ep (if (zerop delta) ep_lw end_ep) end_ep 0.0 delta 0.0 ) (setq start_ep ep_lw delta (- lg_vtx lg_inc) end_ep (* (/ ep_lw d_inc) delta) ) ) (setq l_pt (cons (cons 10 (vlax-curve-getPointAtDist obj_vlax (setq lg_inc (+ lg_inc d_inc)))) l_pt) l_40 (cons (cons 40 start_ep) l_40) l_41 (cons (cons 41 end_ep) l_41) ; l_42 (cons (cons 42 (vlax-invoke obj_vlax 'GetBulge count)) l_42) l_42 (cons (cons 42 0.0 )l_42) ) ) (setq count (1+ count) pt_first (vlax-curve-getPointAtParam obj_vlax count) pt_snd (vlax-curve-getPointAtParam obj_vlax (1+ count)) l_pt (cons (cons 10 pt_first) l_pt) l_40 (cons (cons 40 start_ep) l_40) l_41 (cons (cons 41 end_ep) l_41) ; l_42 (cons (cons 42 (vlax-invoke obj_vlax 'GetBulge count)) l_42) l_42 (cons (cons 42 0.0 )l_42) ) ) (setq l_pt (reverse l_pt) l_40 (reverse l_40) l_41 (reverse l_41) l_42 (reverse l_42) ) (entmake (append (list (cons 0 "LWPOLYLINE") (cons 100 "AcDbEntity") (assoc 67 dxf_obj) (assoc 410 dxf_obj) (assoc 8 dxf_obj) (if (assoc 62 dxf_obj) (assoc 62 dxf_obj) (cons 62 256)) (if (assoc 6 dxf_obj) (assoc 6 dxf_obj) (cons 6 "BYLAYER")) (if (assoc 370 dxf_obj) (assoc 370 dxf_obj) (cons 370 -1)) (cons 100 "AcDbPolyline") (cons 90 (length l_pt)) (cons 70 (if (zerop (boole 1 (rem (cdr (assoc 70 dxf_obj)) 128) 1)) (boole 1 (cdr (assoc 70 dxf_obj)) 128) (1+ (boole 1 (cdr (assoc 70 dxf_obj)) 128)) ) ) (cons 38 (if (assoc 38 dxf_obj) (cdr (assoc 38 dxf_obj)) 0.0)) (cons 39 (if (assoc 39 dxf_obj) (cdr (assoc 39 dxf_obj)) 0.0)) ) (apply 'append (mapcar '(lambda (x10 x40 x41 x42) (append (list x10 x40 x41 x42)) ) l_pt l_40 l_41 l_42 ) ) (list (assoc 210 dxf_obj)) ) ) ) (T (princ "\nN'est pas une polyligne optimisée!") ) ) (princ) )

Je propose d'écrire trois différents programmes, mais ils sont semblables. C'est une tâche très intéressante - on peut la décider par la quantité immense de moyens. 1. (Union lst1 lst2) 2. (Intersection lst1 lst2) 3. (Subtraction lst1 lst2) L'exemple (setq lst1 '((1 . 5) (8 . 10) (20 . 20)) lst2 '((2 . 2) (4 . 6) (9 . 30)) ) ;_ setq (Union lst1 lst2) => '((1 . 6) (8 . 30)) (Intersection lst1 lst2) => '((2 . 2) (4 . 5) (9 . 10) (20 . 20)) (Subtraction lst1 lst2) => '((1 . 1) (3 . 3) (8 . 8))

Bonjour, on s'est déjà pris la tête avec des tris sur des listes. C'est un sujet similaire, car je souhaite obtenir le minimum d'une liste avec une fonction qu'on va appeler min-list. Quand on a : (setq L '(5 3 2 8 10 5 0 -3 8 -3)) on obtient : (min-list L) -3 Là, c'est facile, puisqu'il suffit de faire un tri et de prendre le premier de la liste. Là ou je voudrais corser la chose c'est en demandant la même chose sur une liste de listes, comme sur cet exemple : (setq L '(1 (2 4 6 0) (3 -1 (2 -5)) 4 5 6)) où (min-list L) doit donner -5 Amicalement Vincent [Edité le 27/8/2008 par zebulon_]

On suppose que la liste et les sous listes ne sont composées que de nombres. (defun min-list (lst) (apply 'min (mapcar (function (lambda (x) (if (listp x) (min-list x) x ) ) ) lst ) ) )