Comment convertir une chaîne à la liste à l'aide de clisp?

Comment puis-je convertir la chaîne "1 2 3 4 5 6 7" dans la liste (1 2 3 4 5 6 7) élégamment? Je suis avec CLISP.

Alors, quels sont exactement vous essayez de faire? "Chaîne à la liste" implique de passer d'une chaîne à une liste de caractères, mais votre exemple est de lire des choses séparées par des espaces.
je suis un lisp débutant. Et je n'ai pas trouver de "split" comme fonction. Jusqu'à maintenant, je peux utiliser "parse-integer" convertir "123" 123.
Avec cl-ppcre: (mapcar #'parse-integer (ppcre:split #\space "1 2 3"))

InformationsquelleAutor z_axis | 2011-09-18

2

Conseil: jetez un oeil à avec-entrée-de-chaîne.
- Il est TRÈS utile, merci!
InformationsquelleAutor huaiyuan

Vous devez utiliser parse-integer dans une boucle.

Par exemple, à l'aide de loop:

(let ((string "1 2 3"))
  (loop :for (integer position) := (multiple-value-list 
                                    (parse-integer string
                                                   :start (or position 0)
                                                   :junk-allowed t))
        :while integer
        :collect integer))

⇒ (1 2 3)

Si vous avez besoin d'un meilleur contrôle à propos de la division, de l'utilisation de la split-sequence ou cl-ppcre bibliothèque.

Si vous avez besoin d'analyser plus générale, les formats de nombre, l'utilisation de la parse-number bibliothèque.

Bibliothèques sont disponibles à partir de Quicklisp.

InformationsquelleAutor Svante

2
```
(with-input-from-string (s "1 2 3 4 5 6 7" :index i :start 0 :end 13)
              (list (read s) (read s) (read s) (read s) (read s) (read s)))
(1 2 3 4 5 6 7)
```
il fonctionne cependant je sens qu'il n'est pas aussi élégante que il y a beaucoup de read appel .

merci encore!
- (with-input-from-string (s "1 2 3 4 5 6 7") (loop for x = (read s nil :end) until (eq x :end) collect x)) devrait fonctionner, mais note qu'il faudra "one two three" à une liste de symboles plutôt que d'une liste de chaînes de caractères.
InformationsquelleAutor z_axis

Voici une solution récursive.

    ;Turns a string into a stream so it can be read into a list
    (defun string-to-list (str)
        (if (not (streamp str))
           (string-to-list (make-string-input-stream str))
           (if (listen str)
               (cons (read str) (string-to-list str))
               nil)))

InformationsquelleAutor Banjocat

1

Je vois que Svante est droit. Ma précédente tentative n'a pas fonctionné. Voici une autre tentative. J'utilise concaténer à la chaîne dans une liste à la représentation. Puis-je utiliser la lecture à partir de la chaîne à convertir la chaîne (s-2) dans une liste.
```
(setf s-0 "1 2 3 4 5 6 7")
(setf s-1 (concatenate 'string "(" s ")" ))
(setf s-2 (read-from-string s-1))
```
Je roule dans une fonction comme ceci:
```
(defun from-string-to-list (s)
  (let ((L (read-from-string 
           (concatenate 'string "(" s ")"))))
    L))
```
Le seul but de "laisser" et "L" est de rendre la fonction de chaîne-à-list retourne uniquement la liste et de ne pas renvoyer plusieurs valeurs. lire-de-string retourne deux valeurs: La liste et la taille de la chaîne, je pense.

InformationsquelleAutor Indinfer
0

Qui ferait,
```
(with-input-from-string (s "1 2 3 4 5")
   (let ((r nil))
      (do ((line (read s nil 'eof)
                 (read s nil 'eof)))
          ((eql line 'eof))
          (push line r))
   (reverse r)))
```
- en outre, dans la forme ci-dessus, dans la première liste, vous pouvez remplacer une chaîne de caractères, ici "1 2 3 4 5", avec une forme comme (read-line stream), pour lire une ligne à partir d'un flux encore donner pas une chaîne mais une liste.
- venez ooonnn ma réponse est correcte.
InformationsquelleAutor Selçuk
0

Je pense que cela peut fonctionner:
```
(setf s "1 2 3 4 5 6 7")
(setf L-temp (coerce s 'list))
```
Cela fait une liste avec des espaces comme des éléments. Supprimer les espaces:
```
(setf L-final (remove #\Space L-temp))
```
- Ce produit de la liste (#\1 #\2 #\3 #\4 #\5 #\6 #\7), j'. e. une liste de chiffres. Aparté: ne pas setf des variables qui n'existent pas.
- Je vois Svante est correct. J'ai essayé de nouveau et posté la réponse à l'aide de lire à partir de la chaîne. Je suis encore commencé à apprendre le langage Lisp. Donc, je suis curieux de ne pas "setf des variables qui n'existent pas". Est qu'une violation de la fonctionnelle de style? Ou faut-il faire mon code plus de confusion dans les grands programmes?
- Non, c'est juste un comportement indéterminé. Vous êtes implicitement la création d'une variable globale qui peut ou ne peut pas être spécial (dynamique). Utilisation defparameter ou defvar pour créer un nouveau à l'échelle mondiale variable spéciale, ou l'utilisation let (ou d'autres constructions de l'introduction d'une portée locale) pour créer des variables locales.
- Je vous remercie de votre explication, Svante. Je vous remercie.
InformationsquelleAutor Indinfer

Vous devez vous connecter pour publier un commentaire.