(gile)

Salut, (ssget (list (cons 39 epaisseur)))

Si tu lis avec un peu d'attention la page Wikipedia que tu as mise en lien dans ton premier message et que tu essayes un tant soit peu de déchiffrer les codes postés dans les différentes réponses, tu devrais te rendre compte que les méthodes d'encryptage et de décryptage sont plus ou moins identiques.

Une version en C#. L'algorithme est le même que celui utilisé plus haut en LISP et F#, mais au delà de la différence de langage (syntaxe), j'ai aussi essayé de de privilégier le paradigme POO (Programmation Orientée Objet) quand LISP et F# privilégient plutôt la Programmation Fonctionnelle. Définition d'une classe abstraite Vigenere qui expose trois constructeurs (surcharge) et deux méthodes publiques : Encrypt et Decrypt et de trois classes dérivées pour lesquelles la séquence de caractères à chiffrer est définie. using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace VigenereEncryption { public abstract class Vigenere { private char[] chars; private delegate int Operator(int i, int j); private int encryptOperator(int i, int j) => i + j; private int decryptOperator(int i, int j) => i - j; public Vigenere(char[] alphabet) { chars = alphabet; } public Vigenere(string alphabet) : this(alphabet.ToCharArray()) { } public Vigenere(IEnumerable<int> ints) : this(ints.Select(i => (char)i).ToArray()) { } public string Encrypt(string str, string key) => Crypting(encryptOperator, str, key); public string Decrypt(string str, string key) => Crypting(decryptOperator, str, key); private string Crypting(Operator op, string str, string key) { var builder = new StringBuilder(); int keyIndex = 0; var keyIndices = new int[key.Length]; for (int i = 0; i < key.Length; i++) { keyIndices[i] = Array.IndexOf(chars, key[i]); } foreach (char chr in str) { int n = Array.IndexOf(chars, chr); int m = keyIndices[keyIndex]; if (0 <= n && 0 <= m) { builder.Append(chars[(chars.Length + op(n, m)) % chars.Length]); keyIndex = (keyIndex + 1) % keyIndices.Length; } else { builder.Append(chr); } } return builder.ToString(); } } public class VigenereUppers : Vigenere { const string alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; public VigenereUppers() : base(alphabet) { } } public class VigenereLetters : Vigenere { const string alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZÀÂÄÇÉÈÊËÎÏÔÖÙÛÜŸÆŒabcdefghijklmnopqrstuvwxyzàâäçéèêëîïôöùûüÿæœ"; public VigenereLetters() : base(alphabet) { } } public class VigenereChars : Vigenere { static IEnumerable<int> alphabet = Enumerable.Range(32, 224); public VigenereChars() : base(alphabet) { } } } On crée un objet d'une classe dérivée de la classe de base Vigenere (une instance de cette classe) et on peut appeller les méthodes Encrypt et Decrypt de cet objet. var vigenUppers = new VigenereUppers(); string crypted1 = vigenUppers.Encrypt("J'ADORE ECOUTER LA RADIO TOUTE LA JOURNEE", "MUSIQUE"); var vigenLetters = new VigenereLetters(); string crypted2 = vigenLetters.Encrypt("[Challenge] Petite idée pour un codage/décodage Vigenère", "CADxp"); var vigenChars = new VigenereChars(); string crypted3 = vigenChars.Encrypt("[Challenge] Petite idée pour un codage/décodage Vigenère", "F#4fun");

En fait, ma réponse (avec fonction générique) est une conversion en LISP de ce que j'ai développé en F#. open System // Fonction de chiffrement/dechiffrement générique. // Utilise le chiffre de Vigenère avec l'alphabet spécifié let coding op chars str key = let aKey = key |> Seq.toArray |> Array.map (fun chr -> Seq.tryFindIndex (fun c -> c = chr) chars) let mutable iKey = 0 let length = Seq.length chars str |> Seq.map (fun chr -> match Seq.tryFindIndex (fun c -> c = chr) chars with | None -> chr | Some i -> match aKey.[iKey] with | None -> chr | Some j -> iKey <- (iKey + 1) % aKey.Length Seq.item ((length + (op i j)) % length) chars) |> Seq.toArray |> String // Fonction générique de chiffrement let encrypt: (seq<char> -> string -> string -> String) = coding (+) // Fonction générique de déchiffrement let decrypt: (seq<char> -> string -> string -> String) = coding (-) // Fonctions de chiffrement/déchiffrement des lettres majuscules let encryptUppers = encrypt [ 'A' .. 'Z' ] let decryptUppers = decrypt [ 'A' .. 'Z' ] // Fonctions de chiffrement/déchiffrement de toutes les lettres let encryptLetters = encrypt "ABCDEFGHIJKLMNOPQRSTUVWXYZÀÂÄÇÉÈÊËÎÏÔÖÙÛÜŸÆŒabcdefghijklmnopqrstuvwxyzàâäçéèêëîïôöùûüÿæœ" let decryptLetters = decrypt "ABCDEFGHIJKLMNOPQRSTUVWXYZÀÂÄÇÉÈÊËÎÏÔÖÙÛÜŸÆŒabcdefghijklmnopqrstuvwxyzàâäçéèêëîïôöùûüÿæœ" // Fonctions de chiffrement/déchiffrement des caractères 32 à 255 let encryptChars = encrypt [ char 32 .. char 255 ] let decryptChars = decrypt [ char 32 .. char 255 ] Outre le fait que F# ait un type de données 'char' pour les caractères et qu'une chaîne soit implicitement une séquence de caractères, on peut noter que la définition des fonctions spécifiques à un "alphabet" utilisent l'application partielle permise par la curryfication.

@VDH-Bruno Ma première version (chiffrage des 26 caractères alphabétiques non accentués uniquement avec respect de la casse) ressemble à la tienne : (defun vigenere (op str key / map lkey lg) (setq lkey (vl-string->list (strcase key)) lg (length lkey) ) (defun map (l i / n m) (setq m (- (nth (rem i lg) lkey) 65)) (cond ((null (setq n (car l))) nil) ((< 64 n 91) (cons (if (<= 0 m 26) (+ 65 (rem (+ 26 (op (- n 65) m)) 26)) n ) (map (cdr l) (1+ i)) ) ) ((< 96 n 123) (cons (if (<= 0 m 26) (+ 97 (rem (+ 26 (op (- n 97) m)) 26)) n ) (map (cdr l) (1+ i)) ) ) (T (cons n (map (cdr l) i))) ) ) (vl-list->string (map (vl-string->list str) 0)) ) (defun encode (str key) (vigenere + str key)) (defun decode (str key) (vigenere - str key)) (decode "Wuhvp à kiv, hp q'hs qvog-êhmh wat rogoiw ke uvgcg lxl mpz jbim w'hmvjye." "VDH-Bruno")

Comme l'énoncé n'est pas très clair, j'ai essayé de faire quelque chose de générique en ajoutant comme argument la liste des caractères à chiffrer. La fonction de base : ;;; vigenere ;;; Fonction générique de chiffrement/déchiffrement ;;; Utilise le chiffre de Vigenère avec l'alphabet spécifié ;;; ;;; Arguments ;;; op : opération à effectuer (+ pour le chiffrement, - pour le déchiffrement) ;;; chars : alphabet utilisé (liste de codes ascii des caractères à chiffrer) ;;; str : chaîne à chiffrer ;;; key : clé de chiffrement (defun vigenere (op chars str key / ks lks lcs i) (setq ks (mapcar '(lambda (c) (vl-position c chars)) (vl-string->list key) ) lks (length ks) lcs (length chars) i 0 ) (vl-list->string (mapcar '(lambda (c / n m) (cond ((null (setq n (vl-position c chars))) c) ((null (setq m (nth i ks))) c) (T (setq i (rem (1+ i) lks)) (nth (rem (+ lcs (op n m)) lcs) chars) ) ) ) (vl-string->list str) ) ) ) On peut utiliser cette fonction pour définir deux fonctions génériques, une pour le chiffrement, l'autre pour le déchiffrement. ;;; Fonction générique de chiffrement (defun encrypt (chars str key) (vigenere + chars str key)) ;;; Fonction générique de déchiffrement (defun decrypt (chars str key) (vigenere - chars str key)) Puis utiliser ces fonctions pour définir différentes fonctions suivant les caractères à chiffrer. Pour chiffrer uniquement les lettres majuscules non accentuées (comme dans l'exemple de Wikipedia) (defun encryptUppers (str key) (encrypt (vl-string->list "ABCDEFGHIJKLMNOPQRSTUVWXYZ") str key) ) (defun decryptUppers (str key) (decrypt (vl-string->list "ABCDEFGHIJKLMNOPQRSTUVWXYZ") str key) ) _$ (encryptUppers "J'ADORE ECOUTER LA RADIO TOUTE LA JOURNEE" "MUSIQUE") "V'UVWHY IOIMBUL PM LSLYI XAOLM BU NAOJVUY" _$ (decryptUppers "V'UVWHY IOIMBUL PM LSLYI XAOLM BU NAOJVUY" "MUSIQUE") "J'ADORE ECOUTER LA RADIO TOUTE LA JOURNEE" Pour chiffrer toutes les lettres utilisées en français (y compris les lettre accentuées et les liaisons) (defun encryptLetters (str key) (encrypt (vl-string->list "ABCDEFGHIJKLMNOPQRSTUVWXYZÀÂÄÇÉÈÊËÎÏÔÖÙÛÜŸÆŒabcdefghijklmnopqrstuvwxyzàâäçéèêëîïôöùûüÿæœ" ) str key ) ) (defun decryptLetters (str key) (decrypt (vl-string->list "ABCDEFGHIJKLMNOPQRSTUVWXYZÀÂÄÇÉÈÊËÎÏÔÖÙÛÜŸÆŒabcdefghijklmnopqrstuvwxyzàâäçéèêëîïôöùûüÿæœ" ) str key ) ) _$ (encryptLetters "[Challenge] Petite idée pour un codage/décodage Vigenère" "CADxp") "[EhdÎÀgnjÂ] égtlÆT kdë Équu ŒÄ eogXVg/dëZÇfaj ôkghÔcte" _$ (decryptLetters "[EhdÎÀgnjÂ] égtlÆT kdë Équu ŒÄ eogXVg/dëZÇfaj ôkghÔcte" "CADxp") "[Challenge] Petite idée pour un codage/décodage Vigenère" Pour chiffrer tous les caractères de 32 à 255*. On utilise une fonction pour générer une plage de nombres entiers. ;;; range ;;; Génère une plage de nombres entiers (liste) ;;; ;;; Arguments ;;; from : début de la plage ;;; to : fin de la plage (defun range (from to) (cond ((= from to) (list to)) ((< from to) (cons from (range (1+ from) to))) ((< to from) (cons from (range (1- from) to))) ) ) ;;; Fonctions de chiffrement/déchiffrement des caractères 32 à 255 ;;; ;;; Arguments ;;; str : chaîne à chiffrer ;;; key : clé de chiffrement (defun encryptChars (str key) (encrypt (range 32 255) str key) ) (defun decryptChars (str key) (decrypt (range 32 255) str key) ) _$ (setq crypted (encryptChars "[Challenge] Petite idée pour un codage/décodage Vigenère" "F#4fun")) "F|§Áº‹q{«²nvhˆ¯É³FlxOºn–r‰¸uÔ#wµ¹¯hCª^±•gu­ºn|l{«ÃV˜h" _$ (decryptChars crypted "F#4fun") "[Challenge] Petite idée pour un codage/décodage Vigenère" * Cette séquence de caractères contient des caractères de contrôle non imprimables.

Si on considère une table de 255x255, le code est bien plus simple à mettre en place, mais pour vérifier les résultats "à la main", ça va être plus compliqué...

J'attends un peu pour poster ma réponse (chiffrage des 26 caractères alphabétiques non accentués uniquement avec respect de la casse).

Salut, J'ai quelques soucis avec l’énoncé. La fonction Vigenere devrait prendre aussi la clé en argument. Je ne comprends pas : "Je pense aux 255 caractères usuels", dans la page Wikipedia en lien seules les lettres non accentuées sont chiffrées, les autres caractères (apostrophe et espace) ne sont pas encryptés. Par contre, on pourrait respecter la casse. Je ne comprends pas non plus : "une ou deux clefs", dans la page Wikipedia en lien il n'est question que d'une clé.

Oh oui, OK avec ça !

À quel endroit du code l'erreur survient-elle ? Pour le savoir, dans l'éditeur Visual LISP menu Débogage > cocher Arrêt sur erreur, relancer la routine, à l'arrêt menu Débogage > Source de la dernière interruption. Voir ce screencast.

Salut, Le LISP suivant supprime tous les formatages de texte multiligne dans tous les blocs du dessin. (defun c:NUNFORMAT (/ removeformatting bloc ent) (defun removeformatting (mtext) (setpropertyvalue mtext "Contents" (vl-string-translate "\r\n" "\\P" (getpropertyvalue mtext "Text")) ) ) (while (setq bloc (tblnext "block" (not bloc))) (setq ent (cdr (assoc -2 bloc))) (while ent (if (= (cdr (assoc 0 (entget ent))) "MTEXT") (removeformatting ent) ) (setq ent (entnext ent)) ) ) (command-s "_regen") (princ) )

@Yann38, il faut changer le format du champ. Remplacer : ">%).Area \\f \"%lu2%pr1%ps[,m²]%\">%" par : ">%).Area \\f \"%lu2%pr2%ps[,m²]%ct8[1.0E-6]\">%"

Je n'étais pas là au tout début. Mon premier message date de 2005, mais CADxp a grandement participé à faire de moi ce que je suis devenu depuis. Merci Patrick.

Peux-tu préciser et fournir un exemple, je n'arrive pas à reproduire ça. Je ne sais pas ce que tu appelles "le centre du bloc". Comme précédemment, fournit un exemple et des explications plus claires.

On peut, par programmation, attacher des références d'attribut à une référence de bloc même si la définition du bloc ne contient pas de définition d'attribut. Sans programmation, tu peux créer une définition de bloc avec un attribut, insérer une référence de ce bloc dans le dessin puis l'ouvrir dans l'éditeur de bloc pour supprimer la définition d'attribut et enregistrer les modifications. De retour dans l'espace objet (ou papier), tu verras que la référence précédemment insérée a toujours son attribut mais que les nouvelles insertions ne l'ont pas et que ATTSYNC ne voudra pas sélectionner ce bloc.

Pas chez moi.

Pour être honnête, je n'ai pas creusé la question.

@lecrabeOui, j'avais vu ce sujet, mais il y a quelque chose que j'ai du mal à définir qui me retient de le conseiller.

Non, les propriétés dynamique d'un bloc imbriqué ne sont pas accessibles (comme ne sont pas accessibles les attributs d'un bloc imbriqué). Non plus, un seul paramètre de visibilité par bloc.

(setq ListLect '("C:\\" "D:\\" "O:\\" "Z:\\") ListChemin '("_OpaleCAD" "_OpaleCAD\\_OpaleGestion" "_OpaleCAD\\Bloc" "_OpaleCAD\\Cartouche" "_OpaleCAD\\Excel" "_OpaleCAD\\Hach" "_OpaleCAD\\Icones" "_OpaleCAD\\Lisp" "_OpaleCAD\\Menu" "_OpaleCAD\\Support" "_OpaleCAD\\VBA" ) ListComplet (apply 'append (mapcar '(lambda (lect) (mapcar '(lambda (chemin) (strcat lect chemin)) ListChemin ) ) ListLect ) ) )

Je pense que mapcar ne s'applique pas à ce que tu cherches à faire. Néanmoins je pense que comprendre comment agit cette fonction est fondamental dans l'apprentissage du LISP. Essaye de comprendre ces expressions en les testant dans la console puis en essayant de les modifier: Avec une liste : (mapcar 'itoa '(1 2 3 4)) Avec deux listes : (mapcar '+ (1 2 3) '(4 5 6)) (mapcar 'strcat '("a" "b" "c") '("1" "2" "3" "4" "5")) Avec un defun : (defun concatenerChaineEntier (str int) (strcat str (itoa int))) (concatenerChaineEntier "a" 1) (mapcar 'concatenerChaineEntier '("a" "b" "c") '(1 2 3)) Avec lambda (compare l'expression lambda avec le defun concatenerChaineEntier): (mapcar '(lambda (str int) (strcat str (itoa int))) '("a" "b" "c") '(1 2 3))

Salut, Manifestement, tu n'as pas seulement "du mal à conjuguer ces deux super fonctions", tu as du mal à utiliser chacune séparément. Apprends d'abord à te servir de mapcar avec des fonctions natives (ou des defun) sur une ou plusieurs listes d'un côté et a comprendre le fonctionnement de lambda d'un autre. Tu pourras ensuite combiner les deux.

Absolument pas. Depuis un fichier dans : "D:\\[Long]\\_Test\\RepA1\\RepA2", il faut remonter de deux dossiers pour arriver à "D:\\[Long]\\_Test" qui est le fichier commun aux deux branches. Donc "..\\..\\" pour arriver à "Test" puis, depuis "Test" : "RepB1\\RepB2\\Liste De Plans.xlsx" ce qui donne : "..\\..\\RepB1\\RepB2\\Liste De Plans.xlsx"

Salut, Il faut autant de '..\' que de dossiers jusqu'au dossier commun en doublant le caractère d'échappement (\) en LISP. Donc ça devrait être : "..\\..\\RepB1\\RepB2\\Liste De Plans.xlsx"