Challenge 4

[Patrick_35]

Donc, toujours dans la serie. (demain, j'en donne un plus facile pour un niveau intermédiaire)

 

J'ai une chaine de caractère que je souhaite incrémenter de +1

ex : "aaa" --> "aab"

ex : "aaz" --> "aba"

ex : "aef" --> "aeg"

ex : "azz" --> "baa"

ex : "zzz" --> "aaaa"

 

Et pour ceux qui y arrivent, il serait interessant de pouvoir aussi incrémenter la chaine de caractère de +3 ou +10 par exemple

 

ps : Merci à BonusCad de ne pas donner la réponse au premier challenge et perso, je n'ai pas reussi le suivant, sauf par une boucle, mais pas top :(

 

@+

[Didier-AD]

petite précision ?

 

tu dis que la suite de "azz" c'est "baa" celà veut il dire que le nombre de caractères doit rester le même ? en fait c'est comme pour les numéros des bagnoles

(sauf quand on est à "zzz")

 

en fait c'est comme pour les numéros des bagnoles

[(gile)]

Un premier jet que j'essaye d'adapter pour pouvoir spécifier l'incrément

 

(defun inc-str (str / sub)

 (defun sub (lst)
   (if	(      (if (cadr lst)
(cons 97 (sub (cdr lst)))	
(list 97 97)
     )
     (cons (1+ (car lst)) (cdr lst))
   )
 )

 (vl-list->string (reverse (sub (reverse (vl-string->list str)))))
) 

 

 

 

[Edité le 19/5/2007 par (gile)]

[Didier-AD]

Voilà

On supposera utiliser les lettres de l'aphabet en minuscule car entre "Z" et "a", il y a quelques signes qui ne font pas partie de l'aphabet

 
(defun incrStr (ch / lasc incsuiv)
 (setq lasc (reverse (vl-string->list ch))
incsuiv T
 )
 (setq Newlasc
   (mapcar '(lambda (n /)
	     (if incsuiv
	        (if (>  (1+ n) 122)
		  (setq incsuiv T newasc 97)
		  (setq incsuiv nil newasc (1+ n))
	        )
	        (setq newasc n)
	     )
             newasc
     )
     lasc 
   )
 )
 (if incsuiv  
    (strcat "a" (vl-list->string (reverse newlasc)))
    (vl-list->string (reverse newlasc))
 )
)  

 

Et Zut, Giles est encore passé avant moi.

 

[Edité le 19/5/2007 par Didier-AD]

[(gile)]

Avec incrément "à la demande"

 

 

EDIT : fonctionne avec des incréments supérieurs à 26

(defun inc-str (str inc / sub tmp)

 (defun sub (lst inc / tmp)
   (if	(      (if (cadr lst)
(cons (+ (- tmp 122) 96) (sub (cdr lst) 1))
(list 97 97)
     )
     (cons (+ inc (car lst)) (cdr lst))
   )
 )

 [b](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)))
)
 )
 str[/b]
) 

 

(inc-str "aaa" 1) ->"aab"

(inc-str "aaz" 1) ->"aba"

(inc-str "aef" 1) ->"aeg"

(inc-str "azz" 1) ->"baa"

(inc-str "zzz" 1) ->"aaaa"

(inc-str "aaa" 3) ->"aad"

(inc-str "aaz" 3) ->"abc"

(inc-str "aef" 3) ->"aei"

(inc-str "azz" 3) ->"bac"

(inc-str "zzz" 3) ->"aaac"

 

(INC-STR "abz" 26) -> "acz"

(INC-STR "abz" 27) -> "ada"

(INC-STR "abz" (+ 26 9)) -> "adi"

(INC-STR "abz" (* 26 2)) -> "adz"

 

[Edité le 20/5/2007 par (gile)]

[Bred]

moi, je donne la mienne (parceque je n'aurais pas l'impression d'avoir bosser pour rien)...

mais elle est trés brouillon (et je vais me coucher !!!)

(defun inc (e / L LST LST-C LST-C2 LST-F X)
 (setq lst nil
add 0)
 (repeat (setq x (strlen e))
   (setq lst (cons (vl-string-elt e (setq x (1- x))) lst)
  add (+ (vl-string-elt e x) add)
   )
 )
 (if (not (= (/ add (length lst)) 122))
   (progn
 (setq	x     (length lst)
lst-C nil
 )
 (while x
   (if	(= (1+ (nth (setq x (1- x)) lst)) 123)
     (setq lst-C (cons 97 lst-C))
     (setq lst-C (cons (1+ (nth x lst)) lst-C)
    x	  nil
     )
   )
 )
 (setq	x 0
lst-C2 nil
 )
 (repeat (- (length lst) (length lst-C))
   (setq lst-C2 (cons (nth x lst) lst-C2)
  x	 (1+ x)
   )
 )
 (setq lst-F (append (reverse lst-C2) lst-C))  
 )
   (progn 
     (repeat (1+ (length lst))
(setq lst-F (cons 97 lst-F))
)
     )
   )
 (setq l "")
 (foreach n lst-F (setq l (strcat l (chr n))))
 l
)

[Patrick_35]

Pour Didier

Oui, c'est comme passer de 199 à 200, de 2599 à 2600

 

Super (gile) :D

Il ne reste plus grand chose à faire pour aussi y inclure les majuscules et les chiffres, mais on peux laisser cela pour les autres si cela ne te dérange pas ;).

 

@+

 

Le temps de réponde et deux autres message :o , je regarde vos lips

 

[Edité le 19/5/2007 par Patrick_35]

[Patrick_35]

Pas loin (gile), sauf que si j'ai un incrément > à 26

ex : (inc-str "abz" (+ 26 9)) --> "acƒ"

 

Bravo à didier, car le lisp n'est pas facile à faire.Tu sais que (gile) on le surnomme lucky ;)

 

Chapeau aussi à Bred, car ce n'est pas évident

 

La dessus, bonne nuit à vous tous

 

@+

[(gile)]

Pas loin (gile), sauf que si j'ai un incrément > à 26

 

Eh t'as pas l'impression de chipoter là !

 

Bon j'ajoute un (rem ...) et l'affaire est réglée.

[Patrick_35]

Je ne trouve pas, c'est justement ce qui m'a fait "chuter" dans ma recherche d'incrément au choix. De pouvoir mettre n'importe quel nombre

 

@+

[(gile)]

Je pense avoir trouvé une solution, j'ai modifié le code.

[Patrick_35]

Chapeau bas :)

Je suis battu sur ce coup la :cool:

et tu es un malin, faire une boucle sur un pas de 26 alors que de mon coté, je m'usais à trouver une formule pour éviter la boucle et que je n'ai d'ailleurs toujours pas trouvée ;)

Bravo l'artiste

 

@+

[zebulon_]

Bonjour,

 

j'avais fait quelque chose comme ça il y a quelques temps ici

 

Amicalement

Zebulon_