lisp fonction pour concaténer une liste de chaînes de caractères

J'ai besoin d'écrire une fonction qui va concaténer une liste dans une chaîne. exemple:

(concatString (les guillemets ("bonjour", "le monde"))) ==> "hello world"

voici ce que j'ai à ce jour:

(defun concatString (list)
  "A non-recursive function that concatenates a list of strings."
  (cond
   ((not (listp list))
     (princ "Error: argument to concatNR must be a list")(terpri) ())) ; check if parameter is a list

  (if (not (null list)) ;check if list is not null
      (let ((result (car list)))
        (dolist (item (cdr list))
          (if (stringp item)
              (setq result (concatenate result item)))          
        )
      )
  )
)

J'obtiens une Erreur": "bonjour", est illégale et d'spécificateur de type" message lorsque j'essaie de le lancer. J'ai essayé un tas de façons de modifier cette fonction et je n'ai pas été en mesure de le comprendre. quelqu'un a une idée?

OriginalL'auteur MBU | 2011-03-28

common-lisp string-concatenation

concatenate nécessite un séquence spécificateur de type comme second argument. Pour concaténer deux chaînes de caractères, vous devez appeler concatenate:

(concatenate 'string "hello" "world")

Un autre bug dans votre code: vous n'avez pas assurez-vous que le car de la liste est une chaîne de caractères avant de l'affecter à result. Par la fixation de votre code, je suis venu avec la mise en œuvre suivants:

(defun concatString (list)
  "A non-recursive function that concatenates a list of strings."
  (if (listp list)
      (let ((result ""))
        (dolist (item list)
          (if (stringp item)
              (setq result (concatenate 'string result item))))
        result)))

;; tests
> (concatString (list "hello" " world"))
"hello world"
> (concatString (list "hello" 1 2 3 " world"))
"hello world"
> (concatString (list "hello" 1 2 "3" " world"))
"hello3 world"
> (concatString (list 1 2 3 "hello" " world"))
"hello world"

La suite de la redéfinition de concatString est plus efficace, car elle ne permet pas de créer de nombreux intermédiaires de la chaîne d'objets:

(defun concatString (list)
  "A non-recursive function that concatenates a list of strings."
  (if (listp list)
      (with-output-to-string (s)
         (dolist (item list)
           (if (stringp item)
             (format s "~a" item))))))

Im vérifier si sa chaîne, car pour l'affectation, si c'est un nombre, il ne devrait pas être ajouté à la chaîne. Merci beaucoup si le correctif a fonctionné!!! =)
C'est assez mauvaise: vous êtes à la concaténation de plusieurs reprises la création de nouvelles chaînes de résultat de tous les temps. Elle a peut-être crée une grande quantité de déchets.
Joswig Comment puis-je résoudre ce problème?

OriginalL'auteur Vijay Mathew

14

Suffit d'utiliser la fonction format sur une liste, ce sera tout convertir des chaînes et de les enchaîner avec le bon format de chaîne de caractères.
```
(defun my-concat( list )
  (format nil "~{~a~}" list))
```
Si vous voulez concaténer avec un espace utiliser ce formulaire avec le "~^" directive:
```
(defun my-concat( list )
  (format nil "~{~a~^ ~}" list))
```
Si vous souhaitez filtrer les résultats, vous pouvez simplement transformer la liste avant de formater.
```
(defun my-concat(list)
  (format nil "~{~a~^ ~}" (remove-if-not #'stringp list)))
```
désolé, j'aurais dit que si qu'il doit ignorer les éléments de la liste qui ne sont pas des chaînes de caractères. donc, si un élément est un nombre, il ne faut pas ajouter à la chaîne.
Ouais, que des modifications de l'étendue du problème tout à fait un peu
Vous pouvez filtrer les non chaînes à supprimer-si-non: (defun my-concat( liste ) (format nil "~{~a~}" (supprimer-si-pas de numéro de stringp liste)))

OriginalL'auteur zellio
7

Pour concaténer des séquences d'une chaîne de caractères, utilisez concatenate 'string.
```
(defun concat-strings (list)
  (apply #'concatenate 'string list))
```
À enlever quoi que ce soit à partir de la liste qui n'est pas une chaîne, utilisez remove-if-not.
```
(defun concat-strings (list)
  (apply #'concatenate 'string
         (remove-if-not #'stringp list)))
```
Si l'argument n'est pas une liste, une erreur sera signalée par remove-if-not. Vous pouvez ajouter l'affirmation avant, bien sûr, de donner un message d'erreur plus spécifique, mais il n'a pas vraiment ajouter de la valeur ici.
```
(defun concat-strings (list)
  (assert (listp list)
          "This is not a list: ~s." list)
  (apply #'concatenate 'string
         (remove-if-not #'stringp list)))
```
EDIT:

Comme Rainer notes, apply ne fonctionne que sur les listes de longueur limitée. Si vous n'avez pas de raison de croire que votre liste ne peut pas être plus long que call-arguments-limit moins un, un reduce forme est mieux:
```
(defun concat-strings (list)
  (reduce (lambda (a b)
            (concatenate 'string a b))
          (remove-if-not #'stringp list)))
```
APPLIQUER fonctionne uniquement avec une liste de longueur limitée.
Joswig: Vrai.
Revoir, il convient de noter que, si vous voulez concaténer un plus grand nombre de chaînes, il est plus efficace de travailler avec des flux (par exemple, with-output-to-string), ou de préallouer la chaîne de résultat et le remplir.

OriginalL'auteur Svante
3

Common Lisp de la Langue, 2e Édition

concaténer le résultat de type &repos
les séquences

Ce une
```
(concatenate 'string result item)
```
OriginalL'auteur hoha
3

Selon la Common Lisp Livre De Recettes :
```
(concatenate 'string "Karl" " " "Marx")
"Karl Marx"
```
OriginalL'auteur Sandro Munda

Pourquoi vous limiter à des listes?

(defun concatenate-strings (sequence)
  (reduce #'(lambda (current next)
              (if (stringp next)
                (concatenate 'string current next)
                current))
          sequence
          :initial-value ""))

OriginalL'auteur Mark Cox

2

Voici mes deux cents:

(defmacro concatString (&reste de chaînes de caractères) `(concatenate 'string
,@chaînes) )

OriginalL'auteur Leo

Vous devez vous connecter pour publier un commentaire.