(gile)

OK, mais les prudhommes ne sont pas une protection (ils n'agissent qu'a posteriori) donc ma conclusion reste valable :

Je pense qu'il n'aurait pas pu faire plus concis que VDH-Bruno réponse #29, AutoLISP n'ayant pas de fonction qui utilise les expressions régulières comme Ruby (#38) ou Python (#49), ni de compréhension de liste comme Python (#51) ou F#.

Ça, je n'en suis pas sûr du tout. Ce que tu produis pendant que tu es salarié appartient à ton patron pour toujours, que ce soit des dessins ou autre. Tu peux juste refuser de faire de la programmation s'il te le demande et que tu estimes ne pas être payé pour ça. Mais si le patron sais que tu programmes pendant tes heures de travail (qu'il te l'ait demandé ou pas) le programme, code source compris, lui appartient au même titre que tout ce que tu produis (dwg, pdf, xls, etc). Dans ce cas, la meilleure protection c'est d'abord de ne rien donner au patron et de coder à la maison ou de ne pas se faire prendre si tu codes pendant les heures de travail.

La compilation et l'encryptage des LISP est exactement la même. Chaque fichier .lsp est compilé en un fichier fas et le fichier VLX contient tous les .fas plus les fichier de ressource non encryptés s'il y en a. Si le VLX ne contient que du LISP il est identique au FAS excepté une ligne d'entête en plus dans le VLX pour décrire le contenu.

À ma connaissance, c'est pareil. les codes LISP sont compilés en FAS, un VLX peut contenir plusieurs FAS et d'autres fichiers de ressource (DCL par exemple) qui ne sont pas encryptés.

Ça c'est pas un challenge. On inverse les rôles avec un truc simple. Ci-joint une version d'évaluation de CroixDsQuadri limitée à 3 jours (penser à débloquer le zip). Comment tu ferais ? CroixDsQuadri.zip

Salut, La seule façon fiable de protéger ton code, c'est de ne jamais le distribuer. Si tu le distribues, tu peux seulement essayer de le rendre plus ou moins difficile à "craquer". Comme il y aura forcément une vérification de la validité de la licence ou de la période d'essai dans le code même, il convient en premier lieu d’encrypter/compiler celui-ci. Avec AutoLISP, le plus simple est de créer une application .fas ou .vlx, mais on trouve sur internet des programmes qui décompilent plus ou moins bien les .fas ou .vlx. Le reste est plus sensible et n'est pas vraiment un bon sujet pour un challenge. Ceux qui essayent de protéger leurs programme n'ont pas envie de dire publiquement comment il le font.

C'est quand même en LISP qu'il y a le plus de réponses et les réponses dans d'autres langages on permis aux curieux de découvrir d'autres choses (j'ai écris mes premières lignes de code en Ruby). Quant à la concision, c'est un critère prisé par ceux qui pratiquent certains langages (dont le LISP) et auquel j'ai eu (trop) tendance à prêter un grande importance. Aujourd'hui, je travaille sur des programmes de plusieurs dizaines de milliers de lignes (en C#, pas en LISP) et je me rend compte que privilégier la concision se fait parfois au détriment de le compréhension immédiate du code quand on revient dessus après quelques mois. Ça reste néanmoins une très bonne stimulation pour ce genre de challenge parce que ça oblige à coder en évitant tout verbiage superflu, ce qui est encore pire, à mon avis, pour la compréhension immédiate du code. En tous cas, je me suis régalé, merci.

Je ne pas dit "plutôt que Lisp", j'ai dit "à côté de AutoLISP". J'aime trop la simplicité et l'élégance "mathématique" de ce langage. Oui mais une véritable intégration avec un PYIDE qui permette d'exécuter le code directement dans AutoCAD serait un vrai plus pour ceux qui sont allergiques aux parenthèses et préfèrent une syntaxe plus "conventionnelle" mais surtout de bénéficier de toute les bibliothèques de Python.

Un autre exemple en F# qui, s'il n'est pas le plus concis, a le mérite de décrire clairement l'algorithme grâce à la composition de fonction : let test : string -> string = Seq.chunkBySize 2 >> Seq.rev >> Seq.concat >> String.Concat

Je comprends le succès (mérité) de Python (même si ayant goûté au typage statique, j'ai du mal à revenir à un typage dynamique) Un vrai progrès serait que Autodesk l'intègre comme langage de script embarqué dans AutoCAD au côté de AutoLISP.

Une autre en Python qui utilise les compréhensions de liste : def challenge(s): return ''.join([i for sub in reversed([s[i:i + 2] for i in range(0, len(s), 2)]) for i in sub])

Je me doutais bien qu'on pouvait faire plus concis avec Python : def pyChallenge(str): return ''.join(reversed(re.findall(r'..', str)))

En même temps ce n'est pas bien compliqué, le code de nazemrap est identique à l'algorithme du premier message : str_rev_two=((str.reverse!).scan(/../).each{|el| el.reverse!}).join 1. Inverser les caractères : (str.reverse!) 2. Les grouper par 2 : .scan(/../) 3. Inverser les caractères dans chaque paire : .each{|el| el.reverse!}) Comme on a vu qu'on pouvait simplifier l'algorithme en : 1. Grouper les caractères par 2 : str.scan(/../) 2. Inverser la liste de paires : .reverse! Ce n'était pas complique de réécrire le code : str_rev_two=(str.scan(/../).reverse!).join Un dernier jet en F#, je ne pense pas pouvoir faire plus concis : let rec f = function "" -> "" | s -> f s.[2 ..] + s.[.. 1]

J'ai essayé un truc en Python sur le même principe que le code en Ruby (d'après ce que j'ai compris), mais je connais très mal ce langage. def pyChallenge(str): lst = re.findall(r'..', str) lst.reverse() return ''.join(lst) >>> pyChallenge('5637159071856346') '4663857190153756'

Impressionant ! Ruby semble bien équipé pour le traitement des chaînes. Et si on fait directement : str_rev_two=(str.scan(/../).reverse!).join ça donne quoi ?

Encore une fois, le nombre de lignes n'est pas un critère, d'autant plus que Fraid ajoute au code la fonction son environnement et un appel à la fonction. Pour comparer avec les fonctions LISP, C# ou F# ci dessus, il faut ne considérer que : Java (réponse #24) public static String chal( String txt){ String ret = ""; while (1 < txt.length()) { ret = txt.substring(0, 2) + ret; txt = txt.substring(2); } return ret; } ou PHP (réponse #33) function chal($txt) { $ret = ""; while (1 < strlen ($txt)) { $ret = substr($txt,0, 2) . $ret; $txt = substr($txt,2); } echo $ret; } Dans tous les cas, ce qui fera la concision (hormis le nombre de lettres des symboles) c'est le nombre d'expressions. Par exemple les fonctions récursives permettent d'éviter nombre de (setq ...). Les langages fonctionnels (F# ou LISP) renvoie le résultat de la dernière expression sans avoir besoin d'un : return ... D'autre part, certains langages (comme F# ou Python) sont moins bruyants (noisy) en utilisant l'indentation plutôt que des parenthèses, des accolades, des points-virgules ou des End... pour délimiter les blocs de code. Ceci dit, comme le disaient Fraid et Bruno, la concision n'est pas toujours synonyme de performance. En LISP les fonctions récursives sont en général moins rapides que les fonctions itératives équivalentes. Et dans ce cas précis, celles qui traitent les listes de caractères seront plus rapides que celles qui traitent directement les chaînes. En résumé, si la dernière fonction postée par Bruno est de loin celle que je préfère pour sa concision et son élégance, c'est probablement la fonction jeu2 de la réponse #31 qui est la plus rapide.

Ce matin quand j'ai vu ce sujet, je me suis dit : "Super, un challenge en LISP, ça faisait longtemps." Qui dit LISP dit liste, qui dit concision dit recursion. Mon premier jet est donc une fonction qui utilise la chaîne sous forme de liste de caractères (codes ascii) de manière récursive. (defun jeu (s / f) (defun f (l) (if (cdr l) (vl-list* (cadr l) (car l) (f (cddr l))) ) ) (vl-list->string (f (reverse (vl-string->list s)))) ) Mais, comme l'a dit VDH-Bruno : 1. inverser les caractères 2. les grouper par paires 3. inverser les caractères de chaque paire est équivalent à : 1. grouper les caractères par paires 2. inverser la liste des paires Ni une ni deux, je modifie le code et l'utilisation d'un accumulateur dans la fonction récursive permet d'éviter le reverse. Le code F# de la réponse #10 est équivalente. (defun jeu1 (s / f) (defun f (l a) (if (cdr l) (f (cddr l) (vl-list* (car l) (cadr l) a)) a ) ) (vl-list->string (f (vl-string->list s) nil)) ) L'équivalent en style impératif (avec itération) est un peu moins concis (à peine à cause de l'utilisation d'une fonction auxiliaire. (defun jeu2 (s / l r) (setq l (vl-string->list s)) (while (cdr l) (setq r (vl-list* (car l) (cadr l) r) l (cddr l) ) ) (vl-list->string r) ) Cherchant toujours plus de concision, j'ai pensé aux opérateurs F# qui permettent de traiter les chaînes et sous-chaînes directement comme des collections de caractères ce qui donnera la le code de la réponse #21. L'équivalent en LISP ne fait pas gagner grand chose en terme de concision et devrait être moins efficient (LISP est meilleur avec les liste qu'avec les chaînes). (defun jeu3 (str / f) (defun f (s r) (if (< 1 (strlen s)) (f (substr s 3) (strcat (substr s 1 2) r)) r ) ) (f str "") ) Et l'équivalent avec while. (defun jeu4 (s / r) (setq r "") (while (< 1 (strlen s)) (setq r (strcat (substr s 1 2) r) s (substr s 3) ) ) r ) Voilà, un grand bravo à VDH-Bruno ! Je suis resté bloqué sur une fonction auxiliaire inutile si on traite directement la chaîne. Je ne peux que le parodier en F# pour être à peine plus concis. let rec f s = if s = "" then s else f s.[2 ..] + s.[.. 1] PS: le nombre de lignes de code n'est pas un critère fiable de concision, il dépend de la façon dont le code est formaté.

Maintenant que vous avez vu ce que j'avais très mal caché, vous pourriez poster vos réponses dans le bon sujet.

Un exemple en C# (ça devrait ressembler à du Java) string Challenge(string source) { string result = ""; while (1 < source.Length) { result = source.Substring(0, 2) + result; source = source.Substring(2); } return result; }

Pour faire court, JavaScript est un langage de script (langage interprété à typage dynamique) comme Python, VBScript ou encore LISP, Java est un langage compilé à typage statique comme C, C++, C#, VB.NET ou encore F#. F#, qui privilégie la programmation fonctionnelle, utilise un typage très rigoureux (pas de conversions implicites) qui permet une puissante inférence de type (le type des données est directement déduit du code avant compilation). Ceci permet un syntaxe très concise qui rappelle les langages de script. Un autre exemple F# encore plus concis : let foo str = let rec f s r = if s = "" then r else f s.[2 ..] (s.[.. 1] + r) f str ""

Je pensais juste laisser ouvert à des réponses dans d'autres langages. Dans tous les cas, ne t'attends pas à une avalanche de réponses.

On pourrait accepter des réponses dans d'autres langages. Il est peu probable qu'on arrive à faire aussi concis qu'en LISP, excepté avec certains langages fonctionnels comme F#: let jeu str = let rec f a = function | x :: y :: t -> f (x :: y :: a) t | _ -> a new string(str |> Seq.toList |> f [] |> List.toArray)

J'ai une solution, mais je laisse d'autres répondre avant de la poster. PS: il y a une petite erreur dans l'énoncé : la base devrait être : "5637159071856346"

Bump !