Challenge 10

Matt666 · le 1 octobre 2007

Allez, il faut bien faire repartir ces challenges... :D

Dites moi si c'est trop simple, ou si ça a déjà été tenté !

Personnellement c'est trop dur...

on part d'une chaine de caractères avec chiffres et lettres, et la fonction retourne une liste avec chiffres et les lettres séparées...

Ex : "qvf12qsdf125 5sf 56dfv2" -> ("qvf" 12 "qsdf" 125 " " 5 "sf " 56 "dfv" 2)

Ex : "a1b2c3d4e5" -> ("a" 1 "b" 2 "c" 3 "d" 4 "e" 5)

Ex : "12.52cm" -> (12.52 "cm")

Voilà !

[Edité le 1/10/2007 par Matt666]

bseb67 · le 1 octobre 2007

Salut Matt666!

Petite question: ton troisième exemple pose problème, car un "." peut être une "lettre"?

et pas forcément une virgule.

Ma journée est finie, donc j'attaque demain, mais je sais que gile ou patrick vont faire un truc plus rapide que moi.

Matt666 · le 1 octobre 2007

On va considérer que les points entre deux nombres symbolisent des nombres décimaux. Si ce n'est pas le cas, c'est un caractère...

(gile) · le 1 octobre 2007

Salut,

Super, un challenge :D

Un premier jet :

Edit (2) : petite amélioration (éviter quelques répétitions de l'expression (substr str 1 1) et n'utilser que deux fonctions récursives au lieu de trois)

(defun challenge10gile1	(str / str-sub num-sub char)

 (defun str-sub (elt str / char)
   (if	(/= "" str)
     (if (and (/= "." (setq char (substr str 1 1)))
       (or (= "" str)
	   (numberp (read char))
       )
  )
(cons elt (num-sub char (substr str 2)))
(str-sub (strcat elt char) (substr str 2))
     )
     (list elt)
   )
 )

 (defun num-sub (elt str / char)
   (if	(/= "" str)
     (if (or (and (= "." (setq char (substr str 1 1)))
	   (/= "" (substr str 2 1))
	   (numberp (read (strcat elt (substr str 1 2))))
      )
      (and (/= "." char)
	   (numberp (read char))
      )
  )
(num-sub (strcat elt char) (substr str 2))
(cons (read elt) (str-sub char (substr str 2)))
     )
     (list (read elt))
   )
 )

 (if (and (/= "." (setq char (substr str 1 1)))
   (numberp (read char))
     )
   (num-sub char (substr str 2))
   (str-sub char (substr str 2))
 )
)

EDIT : corrigé un problème avec les points :

(challenge10 ".mes.long: 12.52cm.") -> (".mes.long: " 12.52 "cm.")

[Edité le 1/10/2007 par (gile)][Edité le 1/10/2007 par (gile)]

[Edité le 4/10/2007 par (gile)]

Patrick_35 · le 1 octobre 2007

Salut

Aussi un premier jet

En une seul boucle ;)

(defun sep(val / 1er cac lst old str)
 (setq 1er (substr val 1 1)
cac (type (read 1er))
str 1er
 )
 (while (/= val "")
   (setq val (substr val 2)
  1er (substr val 1 1)
  old cac
  cac (type (read 1er))
   )
   (if (= cac old)
     (setq str (strcat str 1er))
     (setq lst (cons (if (= (type (read str)) 'INT) (read str) str) lst)
    str 1er
     )
   )
 )
 (reverse lst)
)

(sep "qvf12qsdf125 5sf 56dfv2") --> ("qvf" 12 "qsdf" 125 " " 5 "sf" " " 56 "dfv" 2)

ps : faudrait que je regarde pour le ".", je n'y avais pas pensé

@+

Matt666 · le 1 octobre 2007

Dément :D

Chu content que ça réponde !!

La vache... Faut savoir que j'ai pas réussi à faire cette fonction... Et là forcément les maîtres du lisp cadxpien (avec Bonuscad, bseb67 et Bred, et j'en oublie) arrivent et me pondent deux routines différentes !!

Patrick_35, ta routine ne fonctionne pas avec les ponctuations, comme tu l'as remarqué..

Gile, c'est parfait :D

Si on veut corser un peu le truc, ce serait ceci :

"223 : Dites-donc, 2 réponses... & les ponctuations !!! 29 caractères ?"

->("223" " : Dites-donc, " 2 " réponses... & les ponctuations !!! " 29 " caractères ?")

;)

Bon je sais c'est un peu nul...

A bientot !!

Matt...

[Edité le 1/10/2007 par Matt666]

Matt666 · le 1 octobre 2007

Impressionante de concision ta routine, Patrick_35 :D Bravo !! Il ne te manque pas gran chose...

J'étais parti sur un (ascii) mais je vois que vous deux pas du tout... C'est vraime t très enrichissant ces challenges, merci encore !!

Matt.

bseb67 · le 2 octobre 2007

Salut Matt666!

Pour info

Et là forcément les maîtres du lisp cadxpien (avec Bonuscad, bseb67 et Bred, et j'en oublie)

, je ne suis pas un maître.

J'ai peut être une formation d'ingénieur de développement, mais à la fac c'était du C, C++ et Java. Le lisp je l'ai appris par une petite formation d'une semaine en février 2007, sachant que je ne connaissait on va dire quasiment rien à autocad.

Comme toi, je sera parti sur des tests ascii, je passe toujours par un algo pseudo-code pour ensuite chercher à le transcrire. Mais en tout cas je ferai pas mieux que (gile) ou patrick_35.

Je vais la faire ce matin et lancer une comparaison de performances entre les trois ;) .

Bred · le 2 octobre 2007

Re,

zut, pas vu....

et maintenant que Patrick_35 et (gile) ont répondu, la difficulté du challenge augmente encore plus car maintenant il faut trouver encore plus "simple et concis".....

pffffffffffff.....

encore bien joué en tout cas !

Patrick_35 · le 2 octobre 2007

J'ai eu un peu de mal avec le "." car ça ne passe pas avec le read, mais voici quand même la solution

(defun sep(val / 1er cac lst old str ajout test)
 (defun test()
   (setq 1er (substr val 1 1)
  old cac
   )
   (if (= 1er ".")
     (and (= (substr val 2 1) ".")
(setq cac 'SYM)
     )
     (setq cac (type (read 1er)))
   )
   (or cac
     (setq cac 'SYM)
   )
 )
 (defun ajout()
   (setq lst (cons (if (numberp
		  (if (= (substr (vl-string-trim " " str) 1 1) ".")
		    ""
		    (read str)
	          )
		)
	      (read str)
	      str
	    )
	    lst
      )
  str 1er
   )
 )

 (test)
 (setq str 1er)
 (while (/= val "")
   (setq val (substr val 2))
   (test)
   (if (= cac old)
     (setq str (strcat str 1er))
     (ajout)
   )
 )
 (or (eq str "")
   (ajout)
 )
 (reverse lst)
)

@+

bseb67 · le 2 octobre 2007

Re-salut!

Eh bien, j'ai fait le lisp à midi, j'ai rajouté celui de gile (qui marche) et celui de patrick_35.

J'ai fait une boucle avec un appel sur une chaine de 320 caractères.

Il y a une différence entre le résultat du lisp de gile et le mien: pour gile, il faut qu'un point soit entouré de nombre, chez moi, si on 1.d => 1. "d", d.1 => "d." 1

Voici mon code

 
;---------------------------------;
; nom: challenge10bseb67          ;
; role: à partir d'une chaine de  ;
;       caractères avec chiffres  ;
;       et lettres, et la fonction;
;       retourne une liste avec   ;
;       chiffres et les lettres   ;
;       séparées                  ;
; param: chaine                   ;
; retour: liste                   ;
;         ou -1 si erreur         ;
; date: 02/10/2007                ;
; Sébastien BLAES                 ;
;---------------------------------;
(defun challenge10bseb67( depart / res etat tmp cpt lg charlu)

 	; on test si départ est bien une chaine
 	(if (= (type depart) 'STR)
 		(progn
		(setq res '() tmp "" cpt 0 lg (strlen depart))

	  	; on initialise l'état
	  	(if (or (= (substr depart 1 1) ".") (= (type (read (substr depart 1 1))) 'SYM))
			(setq etat 'SYM)
			(setq etat 'INT)
		) ; if

	  	; on boucle sur la chaine pour la traiter
	  	(while (< cpt lg)
			(setq charlu (substr depart (1+ cpt) 1))
			
		  	; on test les cas possibles
		  	(cond
			  	; on continue la chaine
			  	((and (= etat 'SYM) (or (= charlu ".") (= charlu " ") (= (type (read charlu)) 'SYM)))
					(setq tmp (strcat tmp charlu))
				)

				; on continue le nombre
				((and (= etat 'INT) (or (= charlu ".") (= (type (read charlu)) 'INT)))
					(setq tmp (strcat tmp charlu))
				)

				; sinon on change de type
				(t
				 	(if (= etat 'SYM)
					  	(setq etat 'INT res (append res (list tmp)) tmp charlu)
					  	(setq etat 'SYM res (append res (list (read tmp))) tmp charlu)
					) ; if
				) 
			) ; cond

		  	; on incrémente cpt
		  	(setq cpt (1+ cpt))
		) ; while

	  	; on ajoute le dernier morceau
	  	(setq res (append res (list tmp)))
	) ; progn
  	(progn
		(alert "Le paramètre d'appel de challenge10bseb67 n'est pas une chaine!")
	  	(setq res -1)
	) ; progn
) ; if
       ; on affiche res
       ;(print res)
; on renvoie le résultat
 	res
) ; challenge10bseb67

Les fonctions basique de mesure de temps

 ;-----------------------------------;
; nom: start_time                   ;
; role: sauvegarde la date de départ;
;       d'un lisp                   ;
; param: aucun                      ;
; retour: aucun                     ;
; date: 22/05/2007                  ;
; BLAES Sébastien                   ;
;-----------------------------------;
(defun start_time()
(setq starttimevar (getvar "DATE") timetot 0 intertimevar 0)
) ; start_time

;----------------------------------;
; nom: stop_time                   ;
; role: sauvegarde la date de fin  ;
;       d'un lisp                  ;
; param: affichage => si t oui     ;
; retour: temps entre start et stop;
;         en secondes              ;
; date: 22/05/2007                 ;
; BLAES Sébastien                  ;
;----------------------------------;
(defun stop_time( affichage)
(setq stoptimevar (getvar "DATE"))
(setq stoptimevar (* 86400.0 (- stoptimevar starttimevar intertimevar)))
	
(if affichage
	(alert (strcat "temps: " (rtos stoptimevar 2 2) "s" ))
	(strcat "temps: " (rtos stoptimevar 2 2) "s" )
) ; if
) ; stop_time

Et enfin le lisp de test:

 
(defun test( / cpt nb)

 	(setq cpt 0 nb 50 var_test "4v qsgfg.4qf4gdfsgq g4f4sv4 qg 4qsrg4g1hqrhg 3h4q4h4h4 hqt4dh4q 4ht4qh/44hgh t../ ghh4 84f3h.h 1h84t1.t18e6ah4a 1h61t 86h61.h 8a4eh86a4 .haet864h6 .h186h 1x831gbe4ht6hj4,k4kl4ik4 b6g 6g44h6 hb1dh4t .h4 hte4h69t4h4etajh.ha4 .h4 +at4.agjha74jh9 4+8t4j1v 4aha4h 1,n4.hah1 ah9+4ar+4jhqb1azth4ab1fg4ht84jh+4h1qdf84ha4th+1t+j48y")
 	
 	(start_time)
 	(while (< cpt nb)
 		(challenge10bseb67 var_test)
	(setq cpt (1+ cpt))
) ; while
 	(setq cpt 0)
 	(setq tbseb (stop_time nil))
 	(print "bseb fini")
 
 	(start_time)
 	(while (< cpt nb)
 		(challenge10gile var_test)
 		(setq cpt (1+ cpt))
) ; while
 	(setq cpt 0)
 	(setq tgile (stop_time nil))
(print "gile fini")
 
 	(start_time)
 	(while (< cpt nb)
 		;(challenge10pat var_test)
  	(setq cpt (1+ cpt))
) ; while
 	(setq cpt 0)
 	(setq tpat (stop_time nil))
(print "pat fini")
 
 	(alert (strcat "tps bseb: " tbseb "\ntps (gile): " tgile "\ntps tarick_35: " tpat))
) ; test

(test)

(gile), j'ai juste renommé ta fonction ;)

Et bien au début, avant le renvoie de res dans mon lisp, je faisait un print.

En lancant le test sur mon poste j'obtenais :

0.52s pour mon lisp

0.25s pour (gile)

:( !! Ca m'a rendu triste de prendre 2 fois plus de temps. Puis un souvenir decours m'est revenu:

les print sont un bouffe temps!!!

J'ai commenté le print et le nouveau résultat:

0.19s pour mon lisp

0.25s pour (gile)

:o !!! J'ai divisé par 2.5 mon temps.

Mais en fait c'est tout à fait normal!!! ;) des appels récursifs sont plus gourmands que de l'itérative (autre connaissance de cours).

bseb67 · le 2 octobre 2007

Patrick à déposer pendant j'écrivais, donc avec son code j'obtiens le même temps pour lui que pour moi.

Je vais devoir rallonger la boucle de test ;)!

(gile) · le 2 octobre 2007

des appels récursifs sont plus gourmands que de l'itérative

Eh oui, et en plus si la chaine est trop longue, on risque un "dépassement de la limite de la pile" et un échec de la routine. Mais je n'ai pas pu m'en empécher :

- c'est ce qui m'est venu en premier à l'esprit (je dois avoir l'esprit tordu)

- ça m'amusait de faire des appels récurssifs croisés avec 3 routines

- en répondant avec cette forme assez peu usitée par d'autres sur ce site, je laissais la places à d'autres réponses (Bred, il en reste)

- et puis je trouve ça tellement "élégant"

Il y a une différence entre le résultat du lisp de gile et le mien: pour gile, il faut qu'un point soit entouré de nombre, chez moi, si on 1.d => 1. "d", d.1 => "d." 1

J'ai opté pour cette solution après des tests sur des chaines avec beaucoup de points du style :

".point.25.4.8.cm."

(challenge10gile ".point.25.4.8.cm.") -> (".point." 25.4 "." 8 ".cm.")

(sep ".point.25.4.8.cm.") -> (".point." "25.4.8." "cm.")

(challenge10bseb67 ".point.25.4.8.cm.") -> (".point." 25 "cm.")

PS : Bseb67, pour tester la rapidité d'exécution de routines ou d'expressions LISP tu peux utiliser le LISP Benchmark de Michael Puckett (discussion à ce sujet ici).

[Edité le 2/10/2007 par (gile)]

(gile) · le 3 octobre 2007

Puisqu'il est question de rapidité, voilà une autre version (challenge10gile2) pour laquelle j'ai sacrifié la concision et l'élégance sur l'autel de la perfomance.

Elle retourne les mêmes résultats que la première (que j'ai renommée challenge10gile1 et un peu améliorée dans mon premier message)

(defun challenge10gile2	(str / lst rslt tmp)
 (setq	lst  (vl-string->list str)
rslt (if (	       (cons (- (car lst) 48) rslt)
       (cons (chr (car lst)) rslt)
     )
lst  (cdr lst)
 )
 (while lst
   (if	(numberp (car rslt))
     (cond
((and (cadr lst) (= 46 (car lst)))
 (setq tmp (read (strcat (vl-princ-to-string (car rslt))
			 "."
			 (chr (cadr lst))
		 )
	   )
 )
 (if (numberp tmp)
   (setq rslt (cons tmp (cdr rslt))
	 lst  (cddr lst)
   )
   (setq rslt (cons "." rslt)
	 lst  (cdr lst)
   )
 )
)
((	 (setq
   rslt	(cons (read (strcat (vl-princ-to-string (car rslt))
			    (chr (car lst))
		    )
	      )
	      (cdr rslt)
	)
   lst	(cdr lst)
 )
)
(T
 (setq rslt (cons (chr (car lst)) rslt)
       lst  (cdr lst)
 )
)
     )
     (if (	(setq rslt (cons (- (car lst) 48) rslt)
      lst  (cdr lst)
)
(setq rslt (cons (strcat (car rslt) (chr (car lst))) (cdr rslt))
      lst  (cdr lst)
)
     )
   )
 )
 (reverse rslt)
)

Petit benchmark avec la chaine donnée par bseb67

(benchmark '((challenge10bseb67 str) (sep str) (challenge10gile1 str) (challenge10gile2 str)))

Benchmarking .............Elapsed milliseconds / relative speed for 1024 iteration(s):

(CHALLENGE10GILE2 STR)......1422 / 2.81

(CHALLENGE10GILE1 STR)......2797 / 1.43

(CHALLENGE10BSEB67 STR).....3390 / 1.18

(SEP STR)...................4000 / 1.00

[Edité le 4/10/2007 par (gile)]

Matt666 · le 3 octobre 2007

Eh ben...

J'aurais jamais été capable de faire de telles routines... Il va me falloir quelques temps pour les décortiquer !! Cool !!

Merci à vous 4 !

A bientot.

Matt.

(gile) · le 3 octobre 2007

Une troisième, de forme récursive pour essayer de marier concision, élégance et performance.

(defun challenge10gile3	(str / num-sub str-sub lst)

 (defun str-sub (char lst)
   (if	lst
     (if (	(cons char (num-sub (chr (car lst)) (cdr lst)))
(str-sub (strcat char (chr (car lst))) (cdr lst))
     )
     (list char)
   )
 )

 (defun num-sub (char lst / tmp)
   (cond
     ((null lst) (list (read char)))
     ((= 46 (car lst))
      (if (and	(cadr lst)
	(numberp
	  (read (setq tmp (strcat char "." (chr (cadr lst)))))
	)
   )
 (num-sub tmp (cddr lst))
 (cons (read char) (str-sub (chr (car lst)) (cdr lst)))
      )
     )
     ((       (num-sub (strcat char (chr (car lst))) (cdr lst))
     )
     (T (cons (read char) (str-sub (chr (car lst)) (cdr lst))))
   )
 )

 (setq lst (vl-string->list str))
 (if (    (num-sub (chr (car lst)) (cdr lst))
   (str-sub (chr (car lst)) (cdr lst))
 )
)

Le benchmark ci dessous montre bien, si c'était nécessaire, qu'au delà de la manière dont on boucle (récursivité ou itérations) ce qu'on évalue à chaque itération ou appel récursif importe beaucoup.

(benchmark '((challenge10bseb67 str) (sep str) (challenge10gile1 str) (challenge10gile2 str) (challenge10gile3 str)))

Benchmarking .............Elapsed milliseconds / relative speed for 1024 iteration(s):

(CHALLENGE10GILE3 STR)......1281 / 3.00

(CHALLENGE10GILE2 STR)......1359 / 2.83

(CHALLENGE10GILE1 STR)......2688 / 1.43

(CHALLENGE10BSEB67 STR).....3437 / 1.12

(SEP STR)...................3844 / 1.00

[Edité le 4/10/2007 par (gile)]

Patrick_35 · le 4 octobre 2007

Ouin, dernier au test de Benchmark :o

Il va falloir que je revoie mon lisp, mais faute de temps, je décerne donc la médaille d'or à (gile)

@+

Matt666 · le 4 octobre 2007

Tout à fait d'accord !

(gile) · le 4 octobre 2007

je décerne donc la médaille d'or à (gile)

On ne fait pas ça pour des médailles ;)

J'ai trouvé ce challenge intéressant, pas tellement pour ses applications possibles (là je vois pas bien) mais pour ce qu'il m'aura révélé ou confirmé :

- le traitement des listes est plus rapide que celui des chaines. Les routines les plus rapides (pour l'instant) sont celle qui traitent une liste de codes ascii plutôt que la chaine directement.

- paradoxalement, dans le cas présent les formes récursives semblent plus rapides que les méthodes itératives équivalentes et ce, d'autant plus que la chaine est longue (je ne comprends pas encore tout à fait bien pourquoi)

Ouin, dernier au test de Benchmark :o

Attention ces résultat sont à tempérer du fait que les routines ne retourne pas exactement la même chose dans certains cas (voir réponse 12) la routine de bseb67 semble éluder certains tests que font les autres ce qui pourrait expliquer une exécution plus rapide.

PS : C'était moi le dernier avec ma première routine avant que je lui supprime un appel récursif inutile.

[Edité le 4/10/2007 par (gile)]

(gile) · le 4 octobre 2007

J'ai réussi à faire une routine itérative (challenge10gile4) avec un fonctionnement le plus proche possible de la précédente et elle s'avère un peu plus rapide, on en revient donc à la "normale" : les formes récursives sont (un peu) moins rapides que les formes itératives.

La routine :

(defun challenge10gile4	(str / lst test rslt num tmp)
 (setq	lst  (vl-string->list str)
test (chr (car lst))
 )
 (if (    (setq num T)
 )
 (while (setq lst (cdr lst))
   (if	num
     (cond
((= 46 (car lst))
 (if (and (cadr lst)
	  (setq tmp (strcat test "." (chr (cadr lst))))
	  (numberp (read tmp))
     )
   (setq test tmp
	 lst  (cdr lst)
   )
   (setq rslt (cons (read test) rslt)
         test "."
	 num  nil
   )
 )
)
((	 (setq test (strcat test (chr (car lst))))
)
(T
 (setq rslt (cons (read test) rslt)
       test (chr (car lst))
       num  nil
 )
)
     )
     (if (	(setq rslt (cons test rslt)
      test (chr (car lst))
      num  T
)
(setq test (strcat test (chr (car lst))))
     )
   )
 )
 (if num
   (setq rslt (cons (read test) rslt))
   (setq rslt (cons test rslt))
  )
 (reverse rslt)
)

(benchmark '((sep str) (challenge10bseb67 str) (challenge10gile1 str) (challenge10gile2 str) (challenge10gile3 str) (challenge10gile4 str)))

Benchmarking .............Elapsed milliseconds / relative speed for 1024 iteration(s):

(CHALLENGE10GILE4 STR)......1219 / 3.32

(CHALLENGE10GILE3 STR)......1265 / 3.20

(CHALLENGE10GILE2 STR)......1406 / 2.88

(CHALLENGE10GILE1 STR)......2625 / 1.54

(SEP STR)...................3750 / 1.08

(CHALLENGE10BSEB67 STR).....4047 / 1.00

PS : curieusement, sur tous mes derniers tests, la routine sep est passée devant challenge10bseb67.

[Edité le 4/10/2007 par (gile)]

Patrick_35 · le 4 octobre 2007

On ne fait pas ça pour des médailles ;)

oh, je sais bien, mais je sais reconnaitre quand un lisp est meilleur que le mien.

le traitement des listes est plus rapide que celui des chaines

Ce qui est surprenant. Il faut convertir la chaine en une liste pour ensuite transformer le code ascii en caractère. Cela fait deux manips de plus :casstet:

Mais si les tests le prouvent, ok

PS : C'était moi le dernier avec ma première routine avant que je lui supprime un appel récursif inutile.

Donc au prochain, car avec ta dernière routine, je ne pense pas que l'on puisse ajouter grand chose :)

@+

Matt666 · le 4 octobre 2007

pas tellement pour ses applications possibles (là je vois pas bien)

A la base c'est, comme tu dirais Gile une coquetterie... J'ai fait une routine qui copie un texte et le colle en ajoutant un nombre à la chaîne. Si c'est un entier ou un décimal, pas de p. J'aurais pu laisser tomber à partir du moment où le texte copié est une chaine de caractères, mais nan !

A chaque nombre trouvé il ajoute la valeur demandée ! Voilà... Ce n'est pas le lisp le plus utile jamais écrit, mais il a le mérite de soulever des problèmes méritant un challenge ;)

A bientot.

Matt.

[Edité le 4/10/2007 par Matt666]

saamreivax2 · le 12 octobre 2007

Cela peut être utile pour lire des fichiers xml

ElpanovEvgeniy · le 12 octobre 2007

(defun test (s)
;;(test s)
(if (listp s)
 (cond ((= (ascii (last s)) 0)
        (if (car s)
         (list(car s))
         (list((if (wcmatch (cadr s) "*.*") atof atoi) (cadr s)))
        ) ;_  if
       )
       ((car s)
        (if (or (= (ascii (cadr s)) 46) (< 47 (ascii (cadr s)) 58))
         (cons (car s) (test (cadr s)))
         (test (list (strcat (car s) (substr (last s) 1 1)) (substr (last s) 2)))
        ) ;_  if
       )
       (t
        (if (or (= (ascii (caddr s)) 46) (< 47 (ascii (caddr s)) 58))
         (test (list nil (strcat (cadr s) (substr (caddr s) 1 1)) (substr (caddr s) 2)))
         (cons ((if (wcmatch (cadr s) "*.*") atof atoi) (cadr s)) (test (caddr s)))
        ) ;_  if
       )
 ) ;_  cond
 (cond ((= (ascii s) 0) nil)
       (t
        (if (or (= (ascii s) 46) (< 47 (ascii s) 58))
         (test (list nil (substr s 1 1) (substr s 2)))
         (test (list (substr s 1 1) (substr s 2)))
        ) ;_  if
       )
 ) ;_  cond
) ;_  if
)

ElpanovEvgeniy · le 12 octobre 2007

(defun test-for-bench (s / a )
(defun test1 (a b f)
 (cond ((null b)
        (list (if f
               ((if (vl-position 46 a)
                 atof
                 atoi
                ) ;_  if
                (vl-list->string (reverse a))
               )
               (vl-list->string (reverse a))
              ) ;_  if
        ) ;_  list
       )
       (f
        (if (or (= (car b) 46) (< 47 (car b) 58))
         (test1 (cons (car b) a) (cdr b) f)
         (cons ((if (vl-position 46 a)
                 atof
                 atoi
                ) ;_  if
                (vl-list->string (reverse a))
               )
               (test1 (list (car b)) (cdr b) nil)
         ) ;_  cons
        ) ;_  if
       )
       (t
        (if (or (= (car b) 46) (< 47 (car b) 58))
         (cons (vl-list->string (reverse a)) (test1 (list (car b)) (cdr b) t))
         (test1 (cons (car b) a) (cdr b) nil)
        ) ;_  if
       )
 ) ;_  cond
) ;_  defun
(setq s (vl-string->list s))
(test1 (list (car s))
       (cdr s)
       (if (or (= (car s) 46) (< 47 (car s) 58))
        t
       ) ;_  if
) ;_  test1
)

Salut gile! :)

recursion, spécialement pour le contrôle de la vitesse...

 (setq s "qvf12qsdf125 5sf 56dfv2")
(BenchMark '((challenge10gile3 s)(test-for-bench s)))


Benchmarking ................Elapsed milliseconds / relative speed for 8192 iteration(s):

   (TEST-FOR-BENCH S).......1390 / 1.16 
   (CHALLENGE10GILE3 S).....1610 / 1

[Edité le 12/10/2007 par ElpanovEvgeniy]

Connexion

Challenge 10

Messages recommandés

Matt666

bseb67

Matt666

(gile)

Patrick_35

Matt666

Matt666

bseb67

Bred

Patrick_35

bseb67

bseb67

(gile)

(gile)

Matt666

(gile)

Patrick_35

Matt666

(gile)

(gile)

Patrick_35

Matt666

saamreivax2

ElpanovEvgeniy

ElpanovEvgeniy

Créer un compte ou se connecter pour commenter

Créer un compte

Se connecter

Forums

Naviguer

Activité

Information importante