Rechercher dans la communauté

Gégé, tu as bien compris ce que je voulais dire par "profite vraiment" et ce côté des choses ne peut pas me laisser indifférent : voir ici (réponse 3 page 2) ou encore là (où on peut lire à la fin de la discussion que ma "générosité" n'est pas sans limites). D'autant plus que "le développement sur mesure" et la formation au LISP sont des choses que j'aimerais vraiment faire (contre rémunération, bien sûr). Mais à côté de cet aspect, le partage de routines et/ou de conseils sur des sites comme celui-ci permet à beaucoup (moi le premier) d'apprendre énormément. Je ne pense pas que j'aurais pu évoluer en LISP aussi vite et aussi facilement si j'avais continué tout seul dans mon coin. Et ce, à la fois grâce à l'aide fournie par les plus aguerris, à la lecture et l'étude de routine données par d'autres et par tous les exercices pratiques qui consistent à essayer de répondre aux demandes d'autres membres. Même si je préfère aider (dans la mesure de mes moyens) quelqu'un qui pratique ou veut apprendre le LISP, ou participer à un "challenge", je ne peux m'empêcher de répondre à certaines demandes et de poster la réponse pour avoir un retour. PS Je ne l'ai pas encore ouverte... [Edité le 18/2/2008 par (gile)]

Bien que je n'ai pas d'expérience sur les réacteurs, je pense que ce serait une piste à explorer. Par exemple si le calque est verrouillé alors le réacteur désactive OSMODE. Patrick_35 nous dira si c'est possible car il a de l'expérience sur les réacteurs. Un nouveau challenge de pros ?

Bonsoir, j 'ai voulu faire un autre jeu; à savoir atteindre une cible avec une flèche. Il y a une boite de réglage. ça marche à peu près. Toujours faire la tension de la corde (1) avant de varier l 'angle (2). Justement, j 'aimerais pouvoir tendre ou détendre après avoir changer l 'angle. Si il y a des amateurs.... le code à mettre dans Module1 Public arc As AcadArc Public fleche As AcadLine Public long_fleche As Double Public corde As AcadLWPolyline Public pt0(0 To 2) As Double Public pt1(0 To 2) As Double Public rayon As Double Public angdep As Double Public angdar As Double Public alpha As Double Public lcorde As Double Public ptpoly(0 To 5) As Double Public pttmp As Variant Public ptdepfleche(0 To 2) As Double Public ptdarfleche(0 To 2) As Double Public ptrepos(1) As Double Public pivot(0 To 2) As Double Public ligne_pivot As AcadLine Public cercle As AcadCircle Public ligne As AcadLine Public ptdar_ligne_pivot(0 To 2) As Double Public pos_alea(0 To 2) As Double Public cercle1 As AcadCircle Public Sub talarc() pt0(0) = 0: pt0(1) = 0: pt0(2) = 0 'pt1(0) = 20: pt1(1) = 0: pt1(2) = 0 rayon = 130 angdep = 337 * (3.141589 / 180) 'en radians angdar = 23 * (3.141589 / 180) 'en radians alpha = (2 * 3.141589) - (angdep - angdar) 'angle de l 'arc en radians long_fleche = 100 'trace l 'arc Set arc = ThisDrawing.ModelSpace.AddArc(pt0, rayon, angdep, angdar) 'longueur de la corde lcorde = (2 * rayon) * Sin(alpha / 2) 'trace la corde en LW polyligne pttmp = arc.StartPoint ptpoly(0) = pttmp(0): ptpoly(1) = pttmp(1) ptpoly(2) = pttmp(0): ptpoly(3) = pttmp(1) + lcorde / 2 pttmp = arc.EndPoint ptpoly(4) = pttmp(0): ptpoly(5) = pttmp(1) Set corde = ThisDrawing.ModelSpace.AddLightWeightPolyline(ptpoly) pivot(0) = ptpoly(2) + 10.3347: pivot(1) = ptpoly(3): pivot(2) = 0 'trace fleche 'son point de départ correspondant au sommet 1 de la poyligne corde ptdepfleche(0) = ptpoly(2): ptdepfleche(1) = ptpoly(3): ptdepfleche(2) = 0 'son point final tenant mpte de la longueur ptdarfleche(0) = ptpoly(2) + long_fleche: ptdarfleche(1) = ptpoly(3): ptdarfleche(2) = 0 Set fleche = ThisDrawing.ModelSpace.AddLine(ptdepfleche, ptdarfleche) 'trace ligne de pivot et le cercle qui vont servir à la balistique de la fleche 'Ces 2 éléments sont rendus invisibles ptdar_ligne_pivot(0) = pivot(0): ptdar_ligne_pivot(1) = pivot(1) - 1000: ptdar_ligne_pivot(2) = 0 Set ligne_pivot = ThisDrawing.ModelSpace.AddLine(pivot, ptdar_ligne_pivot) ligne_pivot.Visible = False Set cercle = ThisDrawing.ModelSpace.AddCircle(pivot, fleche.Length) cercle.Visible = False 'appel la création la cible aléatoire cible 'zoom étendu Application.ZoomExtents REGLAGE.Show End Sub Public Sub cible() 'trace cible 'position aléatoire Randomize pos_alea(0) = Int(800 - 500 + 1) * Rnd + 500 pos_alea(1) = 0 pos_alea(2) = 0 Set cercle1 = ThisDrawing.ModelSpace.AddCircle(pos_alea, 20) End Sub le formulaire à télécharger compressé: ici Macro à exécuter : talarc

Optimisation de SORT suite au Challenge 20. La routine, contrairement à vl-sort, ne supprime pas les doublons. Pour les supprimer il suffit d'utiliser remove-doubles, exemple : (sort (remove-doubles '(3 5 6 2 1 3 8 9 4 5)) ' (1 2 3 4 5 6 8 9)

Salut Didier... Pardon je n'ai pas été assez clair... Parce que je n'ai pas autocad, mais BricsCAD, un clone d'autoCAD qui ne lit pas le VLISP... EDIT : En fait c'est bon, un collègue m'a fait le travail ! Excusez du temps perdu... Merci encore Didier ! PS : Ce serait une bon challenge, ça !!! :) Re-PS : Saloperie de bulge :P A bientot. Matt. [Edité le 22/1/2008 par Matt666]

C'est vrai que les formes récursives sont en général moins rapides que les formes itératives, mais dans ce cas je pense que le choix de l'algorithme (suivant le type de liste) est primordial. J'ai une routine qui utilise un algorithme de tri qui n'a pas encore été utilisé dans ce challenge, elle est récursive et plus rapide que celles déjà postée. Exemple avec la liste longue d'Evgeniy : (benchmark '((tri lst '<) (quicksort lst '<) (tri_pat lst '<) (bubblesort lst '<)(gilesort lst '<))) Benchmarking ......Elapsed milliseconds / relative speed for 8 iteration(s): (GILESORT LST (QUOTE <)).......1156 / 60.93 [b]<[/b]fastest> (TRI_PAT LST (QUOTE <)).........3781 / 18.63 (TRI LST (QUOTE <)).............5344 / 13.18 (QUICKSORT LST (QUOTE <)).......8922 / 7.89 (BUBBLESORT LST (QUOTE <)).....70437 / 1.00 [b]<[/b]slowest> J'attends un peu avant de la donner pour laisser du champ à d'autres réponses. En tout cas, les routines données jusqu'à présent ne semblent pas "au top" question performances...

Nice one Evgeniy, but the challenge is to create a sort function without using AutoLISP or VisualLISP built in sort functions as acad_strlsort, vl-sort and vl-sort-i too. Joli coup Evgeniy, mais le challenge est de créer une fonctions de tri sans utiliser les fonctions de tri AutoLISP ou VisualLISP comme acad_strlsort, vl-sort ainsi que vl-sort-i.

Comme ce n'est pas directement l'objet du challenge, je donne deux méthodes pour faire une fonction de comparaison "générique". L'idée est d'utilser dans le defun un argument (fun) qui contient la fonction de comparaison quotée comme : ' ou '(lambda ...) puis, - soit d'utiliser apply pour faire paser une liste d'arguments à cette fonction. Exemple : (defun compare (e1 e2 fun) (apply fun (list e1 e2)) ) (compare 1 2 ' (compare 1 2 '>) --> nil (compare '(1 2) '(3 2) '(lambda (x1 x2) (= (cadr x1) (cadr x2)))) --> T - soit d'utiliser la fonction eval (defun compare (e1 e2 fun) ((eval fun) e1 e2) ) qui donne les mêmes résultats. On peut donc utiliser ces méthodes pour écrire une fonction de tri "générique" (qui accepte différentes fonctions de comparaison)[Edité le 17/1/2008 par (gile)]

Re, En fait je vais recréer le bloc dynamique en fintant, j'inverse le point d'origine que je n'arrive pas à bouger avec l'autre point du paramètre linéaire => et ca marche! :D Si j'ai le temps je mettrai un post pour le challenge sur les polygone puis sur le tri. Merci encore pour le soutien ;)

Salut, Quitte à refaire un bide, je tente encore de lancer un nouveau challenge. C'est Bseb67 qui m'en a donné l'idée ici. Le but du challenge est de donner une fonction de tri de liste. AutoLISP fournit acad_strlsort et vl-sort, mais la première ne fonctionne que pour les chaînes et la seconde supprime (mais parfois non) les doublons (ce qui peut être un avantage ou un incovénient suivant les cas). Il s'agirait donc de faire une routine qui fonctionnerait comme vl-sort avec tout type de donnée triable, mais sans supprimer les doublons. On pourra, dans un premier temps, se limiter à un tri croissant, mais il n'est pas difficile de mettre un argument fonction à la routine (comme dans vl-sort) pour élargir les possibilité de fonctions de comparaisons. Le tri est classique en programmation et a donné lieu à de nombreux algorithmes : voir ici, ou là ou encore pleins d'autres facile à trouver en faisant une recherche sur le net. Vu le nombre d'algorithmes, les solutions devraient être nombreuses (on peut réver...). De ce que j'ai pu voir, les algorithmes de "tri par insertion" et "tri à bulles" sont assez faciles à traduire en LISP. Parmi les algorithmes plus évolués le "tri fusion" semble bien adaptable aux listes. Donc, en résumé : Faire une routine du type : (defun tri (lst) ....) qui donnerait : (tri '(3 5 2 6 3 4 8 5)) --> (2 3 3 4 5 5 6 8) ou mieux : (defun tri (lst fun) ...) qui donnerait (tri '(3 5 2 6 3 4 8 5) ' (2 3 3 4 5 5 6 8) (tri '(3 5 2 6 3 4 8 5) '>) --> (8 6 5 5 4 3 3 2) (tri '((3 5) (2 6) (3 5) (8 5)) '(lambda (x1 x2) ( ((2 6) (3 5) (3 5) (8 5)) À vos claviers... [Edité le 16/1/2008 par (gile)]

Voilà plus de 15 jours que j'avais lancé ce challenge et toujours aucune réponse... Je donne donc une solution pour évaluer si la liste de points décrit un polygone croisé. Il s'agit d'une routine appelant deux sous-routines récursives, ça laisse la porte ouverte pour écrire l'équivalent sous forme itérative ou quelque chose de différent. La routine évalue si chaque segment (2 points successifs de la liste) ont une intersection avec chacun des autres segments. Elle retourne T si une intersection est trouvée, nil sinon. Les routines utilisent donc les opérateurs logiques and et or. La première sous routine, SUBR1, requiert 3 arguments : 2 points et une liste de points. Elle évalue si les deux points ont une intersection avec les deux premiers points de la liste et s'il n'y a pas d'intersection, refait l'évaluation avec les deuxième et troisième points de la liste et ainsi de suite jusqu'à ce qu'une intersection soit trouvée ou que la liste n'ait plus qu'un seul point. La seconde sous routine, SUBR2, requiert un argument : une liste de points. Elle fait passer les deux premiers points de la liste et la liste privée de ces points à SUBR1 pour trouver une intersection. Si aucune intersection n'est trouvée, le processus est renouvelé avec les deuxième et troisième points et le reste de la liste. SUBR2 n'est pas suffisante pour une évaluation complète. Les deux routines doivent donc être intégrées à une routine principale, CROSSED-P, pour pouvoir évaluer si le dernier segment d'une polyligne fermée (dernier point au premier point) a ou non une intersection avec un des autres segments. CROSSED-P appelle d'abord SUBR1 avec comme arguments les premiers et deuxième points et le reste de la liste, si aucune intersection n'est trouvée, elle appelle SUBR2 avec comme argument la liste dont on a fait passer le premier élément à la fin. (defun crossed-p (l / subr1 subr2) (defun subr1 (p1 p2 l) (and (cdr l) (or (inters p1 p2 (car l) (cadr l) T) (subr1 p1 p2 (cdr l)) ) ) ) (defun subr2 (l) (and (cdddr l) (or (subr1 (car l) (cadr l) (cddr l)) (subr2 (cdr l)) ) ) ) (or (subr1 (car l) (cadr l) (cddr l)) (subr2 (cdr (append l (list (car l))))) ) )

:casstet: :casstet: :casstet: Je ne pense pas... Un triangle est toujours convexe et a, au plus, un seul angle obtu. Je penserais plutôt à évaluer la position de tous les autres sommets par rapport à un segment (et ce, pour chaque segment bien sûr). Voir ce challenge.

Salut! Bon tout d'abord bonne année à tous!Et surtout bonne santé. Pour moi ce n'est pas trop le cas, j'ai fini l'année 2007 et débuté la 2008 avec la grippe :(, que j'ai refillé à ma femme :cool:. Retour sur le challenge. J'ai du faire un truc de ce genre lors de mes cours à la fac. COmme le dit GIle, on peut chercher le croisé en premier. Faire de bonnes boucles et un petit booléen pour stopper dès le premier croisement trouvé (ou non si l'on veut compter le nombre de croisements). Par contre, si mes souvenir sont bons, la proposition de bred sur les angles est la meilleure approche pour concave-convexe. Un concave comporte au moins un angle obtu, tandis que les convexes n'ont que des angles aigus. Comme je suis encore en vacances, je n'attequerai le challenge que la semaine prochaine. a+! [Edité le 2/1/2008 par bseb67]

Bah oui, il est dur ton challenge !! Ca creuse, ca creuse.... A bientot ! Matt.

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

Bon, voilà où j'en suis : - avec uniquement des chiffres, conservation du nombre minimal de chiffres (inc2 "2" 13) --> "15" (inc2 "002" 13) --> "015" - avec uniquement des lettres, conservation de la casse de l'argument et possibilité d'avoir un incrément supérieur à 26 (inc2 "aa" 3) --> "ad" (inc2 "ZZ" 29) --> "ABC" - avec combinaison de lettre et chiffres (inc2 "ac05" 10) --> "ac15" (inc2 "AC05" 150) --> "AD55" (inc2 "zz05" 198) --> "aab03" Comme les réponses n'affluent pas, je propose à ceux qui sont bloqués d'utiliser ou de s'inspirer des routines que j'ai utilisées (soit les unes soit l'autre). Attention, ce ne sont pas des solutions toutes faites, juste des fonctions qui peuvent servir à une réponse au challenge. - Alpha2Number et Number2Alpha de GetExcel. - Inc-Str du challenge 4 (tu ne te rappelais plus Patrick_35 ?)

Il m'énerve ce gile !!! :D Incroyable.... J'en suis arrivé au 2ème niveau, c'est tout !! Patrick ! Il est dur ce challenge !! Dément !

Avec les routines Alpha2Number et Number2Alpha de GetExcel ;;------------------------------------------------------------------------------- ;; Alpha2Number - Convertit une chaîne alphabétique en nombre entier ;; Function By: Gilles Chanteau from Marseille, France ;; Arguments: 1 ;; str = Chaîne à convertir ;; Exemple de syntaxe : (Alpha2Number "BU") = 73 ;;------------------------------------------------------------------------------- (defun Alpha2Number (str / num) (if (= 0 (setq num (strlen str))) 0 (+ (* (- (ascii (strcase (substr str 1 1))) 64) (expt 26 (1- num)) ) (Alpha2Number (substr str 2)) ) ) ) ;;------------------------------------------------------------------------------- ;; Number2Alpha - Convertit un nombre entier en chaîne alphabétique ;; Function By: Gilles Chanteau from Marseille, France ;; Arguments: 1 ;; num = Nombre à convertir ;; Exemple de syntaxe : (Number2Alpha 73) = "BU" ;;------------------------------------------------------------------------------- (defun Number2Alpha (num / val) (if (< num 27) (chr (+ 64 num)) (if (= 0 (setq val (rem num 26))) (strcat (Number2Alpha (1- (/ num 26))) "Z") (strcat (Number2Alpha (/ num 26)) (chr (+ 64 val))) ) ) ) (defun inc1 (str i / n num len low) (setq n (strlen str)) (while (and (< 0 n) (numberp (read (substr str n)))) (setq n (1- n)) ) (if (= n 0) (setq num str str "" ) (setq num (substr str (1+ n)) str (substr str 1 n) ) ) (and (= str (strcase str T)) (setq low T)) (cond ((= "" str) (setq len (strlen num) num (itoa (+ (atoi num) i)) ) (while (< (strlen num) len) (setq num (strcat "0" num)) ) num ) ((= "" num) (strcase (Number2Alpha (+ (Alpha2Number str) i)) (if low T nil ) ) ) (T (setq len (strlen num) str (strcase (Number2Alpha (+ (Alpha2Number str) (/ (+ i (atoi num)) (expt 10 len))) ) (if low T nil) ) num (itoa (rem (+ i (atoi num)) (expt 10 len))) ) (while (< (strlen num) len) (setq num (strcat "0" num)) ) (strcat str num) ) ) ) Avec la routine Inc-Str du challenge 4 modifiée pour respecter la casse ;; INC-STR ;; Incrémente une chaine alphabétique de la valeur spécifiée ;; ;; (inc-str "aa" 2) -> "ac" ;; (inc-str "ZZ" 29) -> "ABC" (defun inc-str (str inc / sub up) (defun sub (lst inc / tmp) (if (< 122 (setq tmp (+ inc (car lst)))) (if (cadr lst) (cons (+ (- tmp 122) 96) (sub (cdr lst) 1)) (list 97 97) ) (cons (+ inc (car lst)) (cdr lst)) ) ) (if (= str (strcase str)) (setq str (strcase str T) up T ) ) (repeat (/ inc 26) (setq str (vl-list->string (reverse (sub (reverse (vl-string->list str)) 26)) ) ) ) (setq str (vl-list->string (reverse (sub (reverse (vl-string->list str)) (rem inc 26))) ) ) (if up (strcase str) str ) ) (defun inc2 (str i / num len) (setq n (strlen str)) (while (and (< 0 n) (numberp (read (substr str n)))) (setq n (1- n)) ) (if (= n 0) (setq num str str "" ) (setq num (substr str (1+ n)) str (substr str 1 n) ) ) (cond ((= "" str) (setq len (strlen num) num (itoa (+ (atoi num) i)) ) (while (< (strlen num) len) (setq num (strcat "0" num)) ) num ) ((= "" num) (inc-str str i)) (T (setq len (strlen num) str (inc-str str (/ (+ i (atoi num)) (expt 10 len))) num (itoa (rem (+ i (atoi num)) (expt 10 len)))) (while (< (strlen num) len) (setq num (strcat "0" num)) ) (strcat str num) ) ) ) [Edité le 18/12/2007 par (gile)]

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]

Salut à tous!! Me servant souvent du entnext (pour les attributs), du entlast pour vérifier si mes appels ont bien créer des éléments. Je suis un peu déçu de ne pas avoir un entfirst :( :( :( . Alors, est-il possible de faire cette fonction? Ce serai pas mal :D , enfin je pense, car cela me tenterai bien de l'avoir afin de scanner un peu les dessins, pour faire du nettoyage par exemple. Ceci pourrai même faire un challenge ! La seule méthode bourrin qui me vient à l'esprit est de chercher grace à l'oid en vlisp. Mais je ne sais pas si cet id est vraiment par ordre croissant de création. :casstet:

Salut ! Super, un nouveau !!! :D <acronym class=dict title= nan, les débutants. Et on est tous passé par là. :P Ce n'est pas ridicule, au contraire... Ca commence bien, en tout cas ! Tu as presque résolu le challenge, il ne te manque pas grand chose ! Tout d'abord, je te conseillerai d'utiliser entsel plutot que nentsel. Nentsel permet de retourner le nom d'une entité qui est dans un bloc. Ici, on veut juste connaitre le nom du calque d'une entité, c'est tout. Mais ce n'est pas ça qui fera fonctionner ta routine ! (setq ent1 (entsel "Cliquer sur une entité : ")) Essie de copier ce bout de code dans la ligne de commande, et valide là. Si tu cliques sur une entité, tu auras ce type de réponse : Ensuite tu enchaînes avec un entget sur ent1 pour avoir les codes dxf associés. Entget attend un nom d'entité à développer. Mais ta variable ent1 est une liste avec un nom d'entité et les coordonnées d'un point. Voici ton erreur. Il faut arriver à donner juste le nom d'entité à entget. Voilà ! Adtal ! Matt. [Edité le 3/1/2008 par Matt666]

Re, Patrick_35=> Mon précédent post signifiait qu'en regardant les infos que le boite donne, devrai donner des indices pour ceux qui vont chercher. Par contre, je peux te dire que sur la version 2008, il y a une petite différence :casstet:. Si tu ne l'utilise pas, je la donnerai à la fin de ce challenge ;)

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. @+

Voici un challenge pour débutants. Ici, les habitués du lisp peuvent répondre en 10 secondes... Mais là n'est pas le but de ce challenge. Pour l'instant la plupart des challenges proposés sont relevés par les habitués et qq débutants. Personne ne se lance, et c'est pourtant le but de ces challenges ! Donc voilà. test avec un challenge simple. Le but est de progresser donc n'hésitez pas ! Voici donc : Créer une routine qui affiche le nom du calque d'une entité sélectionnée. Bon pour l'instant on se contente de faire une routine sans argument. Voilà. PS : Lovecraft, tu comprendras qu'il n'est pas nécessaire pour toi de répondre à ce challenge, tu n'est pas un débutant ! :) Tu peux par contre te pencher sur une routine avec argument ! Voilà ! Bon courage.

Salut Patrick_35 ! En fin de compte le 1er challenge n'était pas très dur... Et qqns ont participé. Par contre la fin était plus ardue (récursivité et longueur d'une pline), et peu d'entre nous ont participé. C'est dommage, ces challenges paraissent réservés aux habitués/ à ceux qui touchent plutot bien, même si c'est n'est pas l'intention première. Pourtant le nombre de lectures est assez fort. Ces challenges intéressent les utilisateurs de ce site... Je vais tenter de proposer un challenge pour débutant extrème (!!), voir s'il recueille plus de participation. Par exemple retourner le nom du calque d'une entité sélectionnée... C'est dommage, je trouve ça vraiment très enrichissant !! Allez je vais le poster... A bientot ! Matt.