[Challenge] Extraire les nombres d'une chaîne de caractères

[(gile)]

Ça faisait longtemps.

Le but de ce challenge est d'écrire une routine qui prend en argument une chaîne de caractères et renvoie la liste des nombres contenus dans cette chaîne.

Exemple :

(extraireNombres "Longueur = 25.4mm Largeur = 12.7mm Quantité = -42") 

renvoie : (25.4 12.7 -42)

[bonuscad]

Citation

Ça faisait longtemps.

En effet,

Ma participation, mais je m'attend à une fonction récursive de ta part.

(defun extraireNombres (str / l rslt)
  (setq
    l
    (mapcar
      '(lambda (x)
        (if (and (> x 44) (< x 58) (/= x 47)) x 32)
      )
      (vl-string->list str)
    )
    l
    (mapcar
      '(lambda (x y)
        (if (not (= x y 32)) x)
      )
      l
      (append (cdr l) '(32))
    )
    l (vl-remove-if-not '(lambda (x) (eq (type x) 'INT) x) l)
    l (mapcar '(lambda (x) (if (not (eq x 32)) x (list nil))) l)
  )
  (eval (read (strcat "(setq rslt (list " (apply 'strcat (mapcar '(lambda (x) (if (not (listp x)) (chr x) " ")) l)) "))")))
)
(extraireNombres "Longueur = 25.4mm Largeur = 12.7mm Quantité = -42")

 

[(gile)]

@bonuscad

Intéressant. Pour plus de robustesse, il faudrait écarter le caractère 47 (/).

(extraireNombres "Dimensions = 25.4mm / 12.7mm Quantité = -42")

 

[didier]

Bonjour @(gile), bonjour @bonuscad

Chouette le challenge, merci.

Je n'ai pas réussi à faire sans l'aide du programme (de (gile)) str2lst, mais j'arrive finalement à ça :

(extrairenombres "Il faut extraire les nombres de cette liste : Longueur = 456.789 mètres, la largeur est de 123.456 et il faut retirer -56.89 à la quantité qui est de 1234")

va renvoyer (456.789 123.456 -56.89 1234.0)

(defun str2lst (str sep / pos)
    (if (setq pos (vl-string-search sep str))
        (cons (substr str 1 pos)
              (str2lst (substr str (+ (strlen sep) pos 1)) sep)
              )
        (list str)
        )
    )
(defun ExtraireNombres (cha)
    (mapcar '(lambda (x) (atof x))
            (vl-remove "."
             (vl-remove ""
                       (str2lst (vl-list->string
                                    (vl-string->list
                                        (vl-string-translate
                                            "ABCDEFGHIJKLMNOPQRSTUVWXYZ:=(),/?!;"
                                            "                                   "
                                            (strcase cha)
                                            )
                                        )
                                    )
                                " "
                                )
                       )
             )
            )
    )

Je me suis un peu amélioré et je suis content d'avoir réussi.
Bravo BonusCAD pour les imbrications que je n'arrive pas encore bien à intégrer,
par exemple ça je ne comprends pas donc je ne suis pas capable de l'écrire :

(eval (read (strcat "(setq rslt (list " (apply 'strcat (mapcar '(lambda (x) (if (not (listp x)) (chr x) " ")) l)) "))")))

Je veux bien une explication en français dans le texte

Je me doute que (gile) va nous surprendre encore.

EDIT : Correction du code par prise en compte de nouveaux caractères alpha

Amicalement

[Tramber]

Je prends chaque élément de la liste l et le remplace par son CHR ou un espace selon sa nature. (mapcar)

J'écrase le tout en un seul mot (en appliquant strcat à l'ensemble)

C'est tout 😎

Tu l'utilises toi-même le mapcar !?

[(gile)]

@didier

Intéressante approche aussi. Mais attention, certains caractères ne sont pas écartés et génèreront des 0.0 non attendus.

(extrairenombres "Longueur = 456.789 mètres. Largeur = 123.456. Il faut retirer -56.89 à la quantité qui est de 1234 !")

 

[GEGEMATIC]

salut,

moi c'est pas du code élégant, mais très ancien :

Commande: (pw_sep_ch_nomb "Longueur = 456.789 mètres. Largeur = 123.456. Il faut retirer -56.89 à la quantité qui est de 1234 ! sinon c'est 1/2")

->
("Longueur = " "456.789" " mètres. Largeur = " "123.456" ". Il faut retirer -" "56.89" " à la quantité qui est de " "1234" " ! sinon c'est " "1" "/" "2")

je vois qu'il reste un problème avec le signe -

et bien sur, ça ne répond pas au cahier des charges de Gilles, car les nombres ne sont pas isolés.

je me suis dit je corrige ça comme ça:

Commande: (vl-remove-if-not '(lambda (x) (numberp (read x))) (pw_sep_ch_nomb "Longueur = 456.789 mètres. Largeur = 123.456. Il faut retirer -56.89 à la quantité qui est de 1234 ! sinon c'est 1/2"))

"placement incorrect d'un point en entrée" error success

car en fait:

Commande: (read " .1")

"placement incorrect d'un point en entrée"

donc il faudrait retourner dans le code pour régler ça de manière robuste.

a+

gégé

;******************************************************************************
;;;§/str/ cree une liste de chaine à partir d'une chaine contenant nombre et alpha/ch
;** (pw_sep_ch_nomb "PT32A") -> '("PT" "32" "A")
;;;Commande: (pw_sep_ch_nomb "PT3.2A")
;;;("PT" "3.2" "A")
;;;Commande: (pw_sep_ch_nomb ".PT3.2A")
;;;(".PT" "3.2" "A")
;;;(pw_sep_ch_nomb " a1a253t00000")->(" a" "1" "a" "253" "t" "00000")
;;;Commande: (pw_sep_ch_nomb " .a.1.0a253t...00000...000.0a.a")
;;;(" .a." "1.0" "a" "253" "t..." "00000" "..." "000.0" "a.a")
;;;(pw_sep_ch_nomb " .a.1.0a253t...00000...000.0a.a")
;;;(" .a." "1.0" "a" "253" "t..." "00000" "..." "000.0" "a.a")


(defun pw_sep_ch_nomb (ch / tprec lres i chcou  tp buf nb rg lrg )

  (setq i 1)
  (setq chcou "")
  (while (/= "" (setq buf (substr ch i 1)))
    (setq i (+ 1 i))
    (if	(pw_isnum buf)
      (setq tp "num")
      (setq tp "char")
    )

    (if	tprec
      (if (= tp tprec)
	(setq chcou (strcat chcou buf))
	(if tp
	  (progn
	    (setq tprec tp)
	    (setq lres (cons chcou lres))
	    (setq chcou buf)
	  )
	)
      )
      (progn
	(setq tprec tp)
	(setq chcou buf)
      )
    )
  )
  (setq lres (cons chcou lres))
  ;; pour le dernier
  (setq lres (reverse lres))
;;(print lres)
  (if (member "." lres)
    (progn
      (setq lrg (pw_l_rang "." lres))
      (foreach rg lrg
	(setq val-1 (pw_nth (- rg 1) lres)
	      val (pw_nth rg lres)
	      val+1 (pw_nth (+ rg 1) lres)
	)
	(cond
	  ((and	val-1
		val+1
		(= (type val-1) (type val+1)) ;_marche pour "0" "." "0" ou "a" "." "a"
	   )
	   (setq lres (pw_subst_rang nil (- rg 1) lres)) ;_ (nouv rang lst)
	   (setq lres (pw_subst_rang (strcat val-1 val val+1) rg lres)) ;_ (nouv rang lst)	       
	   (setq lres (pw_subst_rang nil (+ rg 1) lres)) ;_ (nouv rang lst)

	  )

	  ((and
	     (/= (type val-1) (type val+1)) ;_marche pour  "a" "." nil
	     (= (type val-1) (type val)) ;_marche pour  "a" "." 
	   )
	   (setq lres (pw_subst_rang nil (- rg 1) lres)) ;_ (nouv rang lst)
	   (setq lres (pw_subst_rang (strcat val-1 val) rg lres)) ;_ (nouv rang lst)	       	       
	  )
	  ((and
	     (/= (type val-1) (type val+1)) ;_marche pour  "1" "." "a"
	     (= (type val+1) (type val)) ;_marche pour   "." "a"
	   )
	   (setq lres (pw_subst_rang nil (+ rg 1) lres)) ;_ (nouv rang lst)
	   (setq lres (pw_subst_rang (strcat val val+1) rg lres)) ;_ (nouv rang lst)	       	       
	  )
	)
      )
      (pw_supp_all nil lres)
    )
    lres
  )					;if
)
;;*************************
;;§/listes/ nth sécurisé qui supprime le message d'erreur lorsque le nth n'est pas trouvé /i lst
;;(pw_nth 3 '(1 2)) -> nil
;;(pw_nth 3 '(1 2 3 4)) -> 4
;;
(defun pw_nth ( i lst /)
  (if (or (= nil lst)
	  (> (length lst) i))
     (nth i lst)
   )
)
;******************************************************************************
;;§/str/determine si un caractere est un chiffre/char
(defun pw_isnum ( char )
 (if (member (ascii char) '(48 49 50 51 52 53 54 55 56 57))
   'T
   nil
 )
)

;***************************************************************************
;;§/listes/retourne la liste des rang d'un elem  une liste/el lst
;;(pw_l_rang "a" '( "a"  "b"  "a" "b")) -> '(0 2)

(Defun pw_l_rang (elem lst / nb val i lres)

  (setq nb (length lst))
  (setq i 0)
  (while (< i nb)
    (setq val (nth i lst))
    (if (= val elem)
      (setq lres (cons i lres))
     )
   (setq i (+ 1 i))
  )
  (reverse lres)
)

;*************************************************************************
;§**/LISTES/ Remplacement dans une liste (par rang), rang commence à 0/nouv rang lst
;;(pw_subst_rang "z" 2 '(1 2 3 4 5))-> (1 2 "z" 4 5)
(defun pw_subst_rang (nouv rang lst)
  (if (null lst)
     nil
     (if (= rang 0)
       (cons nouv (cdr lst))
       (cons (car lst) (pw_subst_rang nouv (- rang 1) (cdr lst)))
     )
  )
)
;*************************************************************************
;§/LISTES/Suppression dans une liste de toutes les occurences de l'elem el /el lst
(defun pw_supp_all (el lst / )
     (while (member el lst)
       (setq lst (pw_supp_elem  el lst))
     )
     lst
)

;****************************************************************************
;§/listes/Supprime la premiere occurence de l'élément "elem" pw_dans la liste "lst"/lm lst
;
(defun pw_supp_elem (lm lst / lst1 lst2 i tp tmp)
 (setq lst2 lst lst1 nil )
 (if (setq tmp (member lm lst2))
  (progn
   (setq lst2 (cdr tmp))
   (setq i 0)
   (while (not (equal lm (setq tp (nth i lst))))
    (setq lst1 (cons tp lst1))
    (setq i (+ 1 i))
   )
   (setq lst1 (reverse lst1))
   (append lst1 lst2)
  )
  (setq lst lst)
 )
)

 

[bonuscad]

@(gile)

Citation

Pour plus de robustesse, il faudrait écarter le caractère 47 (/).

Exact! J'ai modifié le post initial pour inclure cette robustesse (ligne 6)

@didier

Je pense que c'est (eval) et (read) qui te perturbe.

(read) avec l'exemple va me retourner: (SETQ RSLT (LIST 25.4 12.7 -42))

pour valider la variable RSLT il faut évaluer l'expression, ce à quoi sert la fonction (eval): si rslt n'était pas déclaré en variable locale, !rslt en ligne de commande te renverrai sa valeur.

On peut aussi faire cela avec une expression lisp écrite dans un fichier texte avec (read-line)

C'est aussi à travers ce procédé que l'on pourrait rendre le lisp "intelligent" (notez les guillemets) pour qu'il écrive sont propre code en construisant ses propres variables selon certaines conditions.

[(gile)]

@GEGEMATIC

Il semble qu'il manque aussi la fonction : pw_isnum.

[GEGEMATIC]

il y a 54 minutes, (gile) a dit :

@GEGEMATIC

Il semble qu'il manque aussi la fonction : pw_isnum.

Oui,

j'ai rajouté les dépendances, pour que vous puissiez avoir le frisson de faire tourner une application préhistorique,

un peu comme un émulateur de Donkey Kong...

P_supp_elem montre ce que l'absence de visual lisp pouvait engendrer comme complications ...

Enfin ça ne s'appelle pas participer au challenge, puisque le but est de le faire maintenant et avec élégance

mais je me souvenais que cette séparation de nombres n'avait pas été qq chose de simple ...

a+

Gégé

[didier]

Bonjour @Tramber

Il semblerait que tu aies oublié de coller le code dans ton message.

Bonjour @bonuscad

Merci pour le temps passé à tes explications, je vais décortiquer ça pour me coucher moins bête que ce matin.

Bonjour @(gile)

Ok, c'est corrigé dans le code fourni dans mon message.

EDIT 1 : Ah ! Trois fois zut ! j'ai encore le souci avec le point.
Si c'est le séparateur décimal, ça marche, si c'est une ponctuation ça me met un 0.0.

EDIT  2: Ah ! Cette fois-ci est la bonne (sauf avis contraire de votre part), un remove de plus et ça fait le job

Amicalement

 

 

[(gile)]

Il y a 16 heures, bonuscad a dit :

je m'attend à une fonction récursive de ta part.

C'est si bien demandé...

Il y a 4 heures, didier a dit :

Je me doute que (gile) va nous surprendre encore

Je ne pense pas en ce qui concerne l'algorithme :

On lit la chaîne caractère par caractère, dans le sens de lecture.
Dès que le caractère est un chiffre (ou un moins (-) suivi d'un chiffre), on reconstitue le nombre à partir de caractère (ou de ces caractères) et des suivants tant que se sont des chiffres ou un point (unique).
On stocke le nombre reconstitué.
On reprend la lecture des caractères suivants.

Pour l'implémentation, le traitement des listes et la récursivité étant, à mon sens, fondamentaux en LISP, j'utilise la liste des caractères (codes ascii) comme @bonuscad, et la récursivité croisée avec deux fonctions auxiliaires : une qui lit la liste de caractères et stocke les nombres reconstitués (ping) et l'autre qui reconstitue les nombres (pong). J'ai aussi ajouté trois petites fonctions (isDigit, isDot, isHyphen) qui servent essentiellement à rendre le code plus explicite.

;; Evalue si le catactère est un chiffre [0-9]
(defun isDigit (i) (<= 48 i 57))

;; Evalue si le catactère est un point [.]
(defun isDot (i) (= i 46))

;; Evalue si le catactère est un signe moins [-]
(defun isHyphen (i) (= i 45))

;; Renvoie la liste des nombres contenus dans la chaîne
(defun extraireNombres (str / ping pong)

  (defun ping (lst)
    (cond
      ((null lst) nil)
      ((isDigit (car lst))
       (pong (cdr lst) nil (chr (car lst)))
      )
      ((and (isHyphen (car lst)) (isDigit (cadr lst)))
       (pong (cddr lst) nil (strcat (chr (car lst)) (chr (cadr lst))))
      )
      (T (ping (cdr lst)))
    )
  )

  (defun pong (lst dot num)
    (cond
      ((isDigit (car lst))
       (pong (cdr lst) dot (strcat num (chr (car lst))))
      )
      ((and (not dot) (isDot (car lst)) (isDigit (cadr lst)))
       (pong (cddr lst) T (strcat num (chr (car lst)) (chr (cadr lst))))
      )
      (T (cons (read num) (ping (cdr lst))))
    )
  )

  (ping (vl-string->list str))
)

Ceci aurait très bien pu être écrit de manière impérative/procédurale avec des boucles (while ...). Je laisse chercher ceux qui seraient tentés...

À suivre, une version plus concise (récursivité simple).

[didier]

@(gile)

Tu es une source d'inspiration, merci.

Amicalement

[(gile)]

Une autre solution utilisant les expressions régulières.

(defun extraireNombres (str)
  (mapcar '(lambda (x) (read (car x)))
	  (RegExpExecute str "(-?\\d+(.\\d+)?)" nil T)
  )
)

 

[Patrick Emin]

Il y a 2 heures, (gile) a dit :

Une autre solution utilisant les expressions régulières.

(defun extraireNombres (str)
  (mapcar '(lambda (x) (read (car x)))
	  (RegExpExecute str "(-?\\d+(.\\d+)?)" nil T)
  )
)

 

Salut Gilles, j'ai: ai error: no function definition: REGEXPEXECUTE, comment cela se fait-il ? Merci.

[(gile)]

@Patrick Emin La fonction RegExpExecute est définie dans la petite bibliothèque Expressions Régulières en lien dans la réponse ci-dessus ou encore, en bas de cette page.

[VDH-Bruno]

Bonjour à tous, jeunes et moins jeunes

Bon visiblement c'est la réunion des moins jeunes, donc je répond à l'appel 😄

Le 02/10/2024 à 18:49, (gile) a dit :

Ça faisait longtemps.

Oui vous vous doutez bien que l'intitulé du post CHALLENGE entre crochet à de suite éveillé ma curiosité et me fais sortir du bois...

Le 04/10/2024 à 16:55, (gile) a dit :

Le 04/10/2024 à 12:04, didier a dit :

Je me doute que (gile) va nous surprendre encore

Je ne pense pas en ce qui concerne l'algorithme :

On lit la chaîne caractère par caractère, dans le sens de lecture.
Dès que le caractère est un chiffre (ou un moins (-) suivi d'un chiffre), on reconstitue le nombre à partir de caractère (ou de ces caractères) et des suivants tant que se sont des chiffres ou un point (unique).
On stocke le nombre reconstitué.
On reprend la lecture des caractères suivants.

 

Effectivement à la lecture de l'énoncé, j'en suis de suite arrivé à la même conclusion, ce qui signifie que le challenge ne va porter que sur un exercice de style. Les bases étant posé, je savais déjà que je laisserai (gile) dégainer ses expressions régulières (il en est l'auteur), c'est une question d'étique personnelle pour un challenge.

Il y a 22 heures, (gile) a dit :

Une autre solution utilisant les expressions régulières.

 

Voilà ceci étant fait je ne vais pas bouter mon plaisir à me dérouiller les doigts en proposant tout de même quelques lignes,  sachant que l'exercice était plié et qu'il n'y aurait pas d'enjeu algorithmique, sachant également que pour des raisons de souplesses et de performance les codes proposé le seront principalement sur du traitement de liste, par contre pied j'ai tenté de proposer un traitement directement sur la chaine de caractère, en me basant sur un exemple relevé au hasard du file de discutions.

Le 04/10/2024 à 13:43, (gile) a dit :

(extrairenombres "Longueur = 456.789 mètres. Largeur = 123.456. Il faut retirer -56.89 à la quantité qui est de 1234 !")

Mon premier jet basé sur les expressions retourné par la fonction read pour éviter de lire caractère par caractère la chaine ce qui est couteux en lisp.

(defun f (str)
  (cond	((null (setq r (read str))) nil)
	((numberp r) (cons r (f (substr str (+ (strlen (vl-princ-to-string r)) 2)))))
	(T (f (substr str (+ (strlen (vl-princ-to-string r)) 2))))
  )
)

Un test rapide:

_$ (f "slt / 18 +36.0 &gg !")
(18 36.0)

Ok

Puis un regard plus attentif me montre qu'il y a de la ponctuation dans l'exemple fourni, et d'expérience pour avoir déjà expérimenté cette voie je comprend de suite que les caractères  '.() peuvent posé problème à la fonction read

Problème facilement contournable sans alourdir le code en mettant en place une trappe pour gérer les exceptions au moyen de vl-catch-all-apply

Deuxième jet:

(defun f (str)
  (cond	((vl-catch-all-error-p (vl-catch-all-apply 'read (list str))) (f (substr str 2)))
	((null (setq r (read str))) nil)
	((numberp r) (cons r (f (substr str (+ (strlen (vl-princ-to-string r)) 2)))))
	(T (f (substr str (+ (strlen (vl-princ-to-string r)) 2))))
  )
)

Un second test rapide:

_$ (f "Long= 450.0 m . ) 37 ( à -5.0 m !")
(450.0 37 -5.0)

 

Puis une analyse plus attentive des différents exemples, me montre que des caractères peuvent être accolé aux nombres

Le 02/10/2024 à 18:49, (gile) a dit :

Exemple :

(extraireNombres "Longueur = 25.4mm Largeur = 12.7mm Quantité = -42") 

renvoie : (25.4 12.7 -42)

 

Ce qui implique faut complexifier les lignes de codes ou proposer une fonction auxiliaire afin de formater le texte en argument pour qu'il corresponde aux limitations du code proposé. Mais quitte à analyser la chaine autant la traiter dans le même temps et je décide de changer mon fusil d'épaule en travaillant avec des listes, les données sont plus facile à analyser et moins couteuses.

Ma première intention travailler avec des appels croisées  mais hélas (gile) est déjà passé par là...

Le 04/10/2024 à 16:55, (gile) a dit :

la récursivité croisée avec deux fonctions auxiliaires : une qui lit la liste de caractères et stocke les nombres reconstitués (ping) et l'autre qui reconstitue les nombres (pong).

Qu'à cela ne tienne je passe par un accumulateur pour stoker les nombres sous forme de liste et les reconstituer à la remonté des appels de la fonction récursive simple

Ma troisième proposition

(defun extraireNombres (txt / foo)
  (defun foo (l acc)
    (cond ((null l) nil)
	  ((or (< 47 (car l) 58)
	       (and (= (car l) 45) (< 47 (cadr l) 58))
	       (and (= (car l) 46) acc)
	   )
	   (foo (cdr l) (cons (car l) acc))
	  )
	  (acc
	   (cons (read (vl-list->string (reverse acc)))
		 (foo (cdr l) nil)
	   )
	  )
	  (T (foo (cdr l) nil))
    )
  )

  (foo (vl-string->list (strcat txt " ")) nil)
)

Teste

_$ (extraireNombres "Longueur = 25.4mm Largeur = 12.7mm Quantité = -42.")
(25.4 12.7 -42.0)

A+ Bruno

[didier]

Bonjour @VDH-Bruno

Comme je me doutais (et peut-être que Gilles n'en pensait pas moins) les challenges éveillent l'intérêt des anciens du forum.
Ce n'est pas pour résoudre le souci de quelqu'un, c'est pour le fun, j'adore !
Ça permet de traiter le problème posé en profondeur, chacun y allant de sa façon de voir, son niveau de LSP et son quotient d'intelligence pas du tout artificielle.
Analyser les fonctions de chacun contribue à l'épanouissement, grand merci à tous, et particulièrement à Gilles.

Bravo à @GEGEMATIC, il y a du travail et de la ténacité.

Amicalement

 

 

[VDH-Bruno]

Bonjour,

@bonuscad Bonne fête!😄

@didier Je ne suis pas convaincu que se soit le challenge qui éveille l'intérêt des anciens du forum, mais plutôt le type de donnée à traiter qui intimide les moins expérimentés. Extraire des données d'une chaine de caractère avec un formatage qui n'est pas codifié de façon rigoureuse est de mon point de vue un problème bien complexe à traiter et donne du code bien fastidieux à écrire, si on ne maitrise pas comme @(gile) les expressions régulières qui sont de mon point de vu la panacée.

Si la donnée est issue d'un tableur type Excel, nous avons un formatage parfait (libellés, nombres, unités ect...) très facilement interprétable pour un programme 

Si la donnée est issue d'un traitement de texte cela devient beaucoup plus compliqué à interprété, ex: 10.2 mètre cube, 10.2 m3, 10.2m3. Que doit on traiter? (12.2) ou (12.2 3). De même que considère t'on comme une valeur numérique une fraction doit elle être vu comme une valeur numérique exemple 1/3 doit donner 0.33333 ou 1 & 3 et les exemple et contre exemple peuvent être très nombreux.

D'ailleurs pour illustrer le propos j'invite à tester la donnée suivante:

" Volume 1/3 m3 tous les 10m²" avec la version de @(gile) et les expressions régulières...

A+ Bruno

 

[didier]

Bonjour @VDH-Bruno

Je comprends ce que tu dis et je peux revoir mon point de vue au sujet des challenges.
Il n'en est pas moins vrai que ce sont les anciens qui s'y collent et proposent une façon de voir la chose.

Quant à ton dernier exemple, il pose de réels soucis, et interpréter ces risques de confusions va rallonger les conditions.

Amicalement

PS : J'adore ta signature" Apprendre => Prendre => Rendre"

[VDH-Bruno]

Re,

il y a une heure, didier a dit :

Quant à ton dernier exemple, il pose de réels soucis, et interpréter ces risques de confusions va rallonger les conditions.

@didier Je ne pense pas qu'il faille aller plus loin dans le traitement du problème, c'est juste à titre d'illustration car sur ce type de problème on pourra toujours trouver des exceptions et rallonger indéfiniment la liste des conditions, si on ne connait pas à l'avance le domaine d'application pour faire un traitement sur mesure.

Quant à la signature, c'est une contraction en forme d'hommage à un ami enseignant d'Aïkido, dont je ne me souviens plus exactement de la formulation au mot près mais qui disait : "Dans l'action d'apprendre, on entend le mot prendre et dans prendre ne jamais oublier qu'il y a rendre"

Voilà je laisse libre à chacun d'interpréter ces quelques mots🙂

[Patrick Emin]

Bonjour, je ne vais pas répondre ici car ma réflexion est celle des IA, qui n'est pas le sujet du challenge et je voudrais pas polluer ce fil, par contre pour ceux qui ont un intérêt pour les IA, merci de lire ma (longue) réponse ici. Elle est fortement connexe au challenge original.

[bonuscad]

Citation

on pourra toujours trouver des exceptions et rallonger indéfiniment la liste des conditions

Quand (gile) m'a fait remarqué que je devais enlever le caractère /, je me suis dit qu'il serait bien de le conserver pour lire dans le système impérial et fractionnaire.

Mais malheureusement je me suis heurté à la lecture du caractère du pouce (") qui m'a posé problème: le lisp utilisant ce caractère pour encadrer une chaîne... Du coup j'ai laissé tomber rapidement !...

@VDH-Bruno

Bonne fête à toi aussi 😁

 

[VDH-Bruno]

il y a 34 minutes, bonuscad a dit :

Quand (gile) m'a fait remarqué que je devais enlever le caractère /, je me suis dit qu'il serait bien de le conserver pour lire dans le système impérial et fractionnaire.

@bonuscad Merci, les grands esprits se rencontrent, j'ai eu la même réflexion, le problème et que 1/2 peut être considéré comme une valeur fractionnaire et 1 / 2 / 3 / 4 / 5 comme une énumération, et c'est la que je vais faire plaisir à @Patrick Emin .

@Patrick Emin Je viens de parcourir rapidement ton article, pour moi une utilisation intéressante des IA, c'est qu'elles réussissent assez bien à contextualiser une donnée dans un texte, suffit de voir les traducteurs automatique qui ne cessent de s'alimenter et donc de progresser. Sur ce type de problème une solution efficiente serait de laisser au programmeur le traitement ce qui n'est pas compliqué en soi, et de déléguer à une AI le soin de reformater les données en fonction d'un standard compréhensible pour le traitement. (Nb: sur le retour de l'IA, en lisp 1/3 est un symbole (non une valeur numérique) et 10 un nombre entier 😉).

 

 

[Patrick Emin]

il y a 16 minutes, VDH-Bruno a dit :

@Patrick Emin Je viens de parcourir rapidement ton article, pour moi une utilisation intéressante des IA, c'est qu'elles réussissent assez bien à contextualiser une donnée dans un texte, suffit de voir les traducteurs automatique qui ne cessent de s'alimenter et donc de progresser. Sur ce type de problème une solution efficiente serait de laisser au programmeur le traitement ce qui n'est pas compliqué en soi, et de déléguer à une AI le soin de reformater les données en fonction d'un standard compréhensible par le traitement. (Nb: sur le retour de l'IA, en lisp 1/3 est un symbole (non une valeur numérique) et 10 un nombre entier 😉

 

 

Oui, tout à fait, il suffirait d'adapter le prompt pour exclure les fractions, moi je l'avais explicitement demandée. (réponse sur mon site)