Challenge 18

[Patrick_35]

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]

[(gile)]

J'ai une réponse qui utilise 2 routines que j'ai déjà données sur ce site...

[(gile)]

Petite précision, on est bien d'accord qu'il faut respecter le rang (nombre de chiffres) du nombre à la fin de la valeur (quand y en a un) ?

 

(inc "ac5" 10) --> "AD5"

(inc "ac25" 10) --> "AC35"

(inc "ac25" 100) --> "AD25"

(inc "ac25" 75) --> "AD00"

 

PS : j'ai une deuxième solution avec une autre routine déjà donnée ici.

 

[Edité le 17/12/2007 par (gile)]

[Matt666]

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 !

[Matt666]

Bon bah chu bloqué... Fin nan, mais ma routine fait un paquet de lignes seulement pour le niveau 2... C'est la blaze :(

[Patrick_35]

Bonjour

 

(gile) , tu as bien compris, mais tu n'as pas que des chiffres, tu as aussi des lettres comme (inc "zzh" 10) --> zzr et (inc "zzh" 20) --> aaab

Ce qui veut dire que parfois tu as un pas de 10, une autre fois un pas de 26.

Et le top, serait aussi de diffentier les minuscules des majuscules.

En reprenant l'exemple précedent

(inc "ZZH" 10) --> ZZR et (inc "ZZH" 20) --> AAAB

 

 

PS : j'ai une deuxième solution avec une autre routine déjà donnée ici.

Je ne l'ai pas vu passer :o

On dirait que tu commence à avoir une bonne bibliothèque de routines ;)

 

Patrick ! Il est dur ce challenge !! Dément !

Oui, je sais et je pense même que c'est l'un des plus dur que j'ai donné.

J'ai bien aussi une solution d'incrémenter de +1 et ensuite de faire une boucle du nombre à répéter chaque fois, mais c'est une solution que ne me convient qu'à moitié.

Je continue de chercher moi aussi.

 

@+

[(gile)]

Salut,

 

(gile) , tu as bien compris, mais tu n'as pas que des chiffres, tu as aussi des lettres comme (inc "zzh" 10) --> zzr et (inc "zzh" 20) --> aaab

Ce qui veut dire que parfois tu as un pas de 10, une autre fois un pas de 26

J'avais bien compris : ce que je voulais dire c'est que parfois on un pas de 10 "zz5" mais on peut aussi avoir un pas de 100 "zz58" ou de 1000 "zz539" etc ...

 

 

Je ne l'ai pas vu passer

Je crois bien que si ;)

 

 

Et le top, serait aussi de diffentier les minuscules des majuscules.

Je vais essayer d'adapter (soit tout en majuscules, soit tout en minuscules en fonction de la casse de l'argument, OK ?)

 

[Edité le 18/12/2007 par (gile)]

[Patrick_35]

Je crois bien que si ;)

Je dois me faire vieux :(

 

Je vais essayer d'adapter (soit tout majuscules, soit tout minuscules en fonction de la casse de l'argument, OK ?)

Ok

 

@+

[(gile)]

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 ?)

[Patrick_35]

(tu ne te rappelais plus Patrick_35 ?)

Ben non

 

D'après la lecture du lisp, je vois que tu passes par un repeat, ce que je cherche à éviter

Je pense qu'il est possible avec un premier rem, d'incrementer la première valeur, et ensuite avec le restant, d'additionner la différence (pour des nombres < 100 dans un premier temps) sur la seconde valeur

 

par exemple

(inc "045" 34)

j'ajoute 4 au 5 (avec le rem), puis reste 30, que je divise par 10 et que j'ajoute au 4. Je regarde si j'ai fait toute la chaine, sinon, je complete.

Et la logique devrait être la même pour les lettres et ensuite, je combine le tout

 

@+

[(gile)]

Bon, je crois bien que j'ai réussi quelque chose qui correspond à ce que tu dis (plus de repeat), en plus ça fonctionne avec les chiffres, les lettres et la combinaison des deux quelques soient leurs places dans la chaîne, ça respecte la casse qui peut être différente à chaque rang.

 

(inc "9Zz09" 91) --> "10Aa00"

 

Je poste ou j'attends encore ?

[Patrick_35]

Salut (gile)

 

Je poste ou j'attends encore ?

Je pense que tu peux mettre ton code. Le temps me manque et on dirait que nous seuls à chercher (à par matt666 qui bloque)

 

@+

[(gile)]

Je donne la dernière version, les premières me semblent vraiment lourdingues au regard de celle-ci.

 

;; INCSTR
;; Incrémente une chaîne de caractères de la valeur spécifiée.
;;
;; Arguments
;; str : une chaîne constituée uniquement des caractères [a-z] [A-Z] [0-9]
;; inc : un entier positif
;;
;; Retour
;; la chaîne incrémentée
;;
;; Exemples :
;; (incstr "002" 12) = "014"
;; (incstr "ZZ9" 1) = "AAA0"

(defun incstr (str inc / lst crt pas ind dep quo ret)
 (setq lst (reverse (vl-string->list str)))
 (while (setq crt (car lst))
   (cond
     ((       (setq pas 10
     ind 48
      )
     )
     ((       (setq pas 26
     ind 65
      )
     )
     ((       (setq pas 26
     ind 97
      )
     )
   )
   (setq dep (- crt ind)
  quo (/ (+ dep inc) pas)
  ret (cons (+ ind (rem (+ dep inc) pas)) ret)
   )
   (if	(zerop quo)
     (setq ret	(append (reverse (cdr lst)) ret)
    lst	nil
     )
     (if (cdr lst)
(setq lst (cdr lst)
      inc quo
)
(setq lst (list ind)
      inc (if (= 10 pas)
	    quo
	    (1- quo)
	  )
)
     )
   )
 )
 (vl-list->string ret)
) 

[Patrick_35]

Bravo (gile)

 

L'oeuvre d'un grand maître :D

 

@+

[Bred]

Pffffffffff....

Le temps me manque et on dirait que nous seuls à chercher

Et non... j'étais dessus aussi... et à part écrire un truc débile avec une multitude de conditions, je n'arrivais à rien.

Et maintenant que (gile) à publier son code, et que le truc malin étais d'utiliser vl-string->list permettant de faire un code en peu de ligne, j'avoue que je laisse tomber...

 

Fabuleux, (gile) !

 

[(gile)]

Bravo (gile)

Fabuleux, (gile)

 

http://pagesperso-orange.fr/gile/Images/coolsmiley.gif

 

 

J'avais un peu de temps, et les premières routines que j'avais faites à partir de routines existantes étaient plus longues et moins élégantes (voir ici).

 

La version donnée ci dessus est en fait une traduction avec while d'un prototype qui utilisait une sous routine récursive (cette forme étant la première qui m'est venue à l'esprit) :

 

(defun incstr (str inc / subr)

 (defun subr (l i / c p d b q)
   (if	(setq c (car l))
     (progn
(cond
  ((	   (setq p 10
	 d 48
   )
  )
  ((	   (setq p 26
	 d 65
   )
  )
  ((	   (setq p 26
	 d 97
   )
  )
)
(setq b	(- c d)
      q	(/ (+ b i) p)
)
(cons (+ d (rem (+ b i) p))
      (if (zerop q)
	(cdr l)
	(if (cdr l)
	  (subr (cdr l) q)
	  (subr	(list d)
		(if (= 10 p)
		  q
		  (1- q)
		)
	  )
	)
      )
)
     )
   )
 )

 (vl-list->string
   (reverse
     (subr (reverse (vl-string->list str)) inc)
   )
 )
) 

[Matt666]

:o ...

 

Ouch..

Impressionant !

 

Bravo Gile !

[(gile)]

La routine donnée plus haut n'évalue pas la validité des caractères de la chaîne à incrémenter : si la chaîne contient des caractères autres que [0-9], [a-z] ou [A-Z] le résultat sera faut.

 

Ça me titillait depuis quelques temps et ce message m'a donné une idée.

 

Voilà donc une nouvelle routine sur le même principe mais qui n'incrémente que le suffixe valide.

Est considéré comme suffixe, la partie terminale de la chaîne qui ne ne contient que les caractères [0-9] ainsi que les caractères [a-z] ou [A-Z] si l'argument alpha est non nil.

 

;; INCSUFF -Gilles Chanteau- 15/01/08
;; Incrémente le suffixe d'une chaîne de caractères de la valeur spécifiée.
;; Est pris en compte comme suffixe, l'ensemble des caractères [0-9] depuis
;; la fin de la chaîne ainsi que les caractères [A-Z] et [a-z] si alpha est non nil
;;
;; Arguments
;; str : une chaîne avec un suffixe valide
;; inc : un entier positif
;; alpha : si non nil, les caractères [a-z] [A-Z] sont intégrés au suffixe
;;
;; Retour
;; la chaîne avec son suffixe incrémenté (ou nil si aucun suffixe valide)
;;
;; Exemples :
;; (incsuff "N°002" 12 T) = "N°014"
;; (incsuff "test_ZZ9" 1 T) = "test_AAA0"
;; (incsuff "test_ZZ9" 1 nil) = "test_ZZ10"
;; (incsuff "12-" 1 nil) = nil

(defun incsuff (str inc alpha / lst crt pas ind dep quo ret)
 (setq lst (reverse (vl-string->list str)))
 (while
   (and
     (setq crt (car lst))
     (cond
((	 (setq pas 10
       ind 48
 )
)
((and alpha (	 (setq pas 26
       ind 65
 )
)
((and alpha (	 (setq pas 26
       ind 97
 )
)
((	 (setq crt (if (= 10 pas)
	     ind
	     (1- ind)
	   )
       lst (cons (car lst) lst)
 )
)
     )
   )
    (setq dep (- crt ind)
   quo (/ (+ dep inc) pas)
   ret (cons (+ ind (rem (+ dep inc) pas)) ret)
    )
    (if (zerop quo)
      (setq ret (append (reverse (cdr lst)) ret)
     lst nil
      )
      (if (cdr lst)
 (setq lst (cdr lst)
       inc quo
 )
 (setq lst (list ind)
       inc (if (= 10 pas)
	     quo
	     (1- quo)
	   )
 )
      )
    )
 )
 (if ret
   (vl-list->string ret)
 )
) 

 

[Edité le 15/1/2008 par (gile)]