Comment faire pour supprimer les parenthèses imbriquées en LISP

Comment puis-je supprimer les parenthèses imbriquées de manière récursive en Common LISP comme

  (unnest '(a b c (d e) ((f) g))) => (a b c d e f g)
  (unnest '(a b))                 => (a b)
  (unnest '(() ((((a)))) ()))     => (a)

Grâce

Vous n'avez pas supprimer les parenthèses. Les parenthèses ne sont qu'un aspect d'une représentation imprimée pour les listes. Ce que vous faites est l'aplatissement des listes.

OriginalL'auteur bubdada | 2010-04-21

17

Voici ce que j'avais à faire:
```
(ql:quickload "alexandria")
(alexandria:flatten list)
```
Qui travaille principalement parce que j'ai Quicklisp déjà installé.

Si modeste! Qui travaille principalement parce que vous créer Quicklisp déjà.

OriginalL'auteur Xach

(defun flatten (l)
  (cond ((null l) nil)
        ((atom l) (list l))
        (t (loop for a in l appending (flatten a)))))

OriginalL'auteur Donnie Cameron

(defun flatten (l)
  (cond ((null l) nil)
        ((atom (car l)) (cons (car l) (flatten (cdr l))))
        (t (append (flatten (car l)) (flatten (cdr l))))))

OriginalL'auteur Bill

5

Je me rends compte que c'est un vieux fil, mais il est l'un des la première qui me vient quand je google lisp aplatir. La solution que j'ai découvert est similaire à ceux décrits ci-dessus, mais la mise en forme est légèrement différente. Je vais vous expliquer que si vous êtes nouveau à lisp, comme je l'ai été quand j'ai googlé cette question, il est donc probable que d'autres le seront également.
```
(defun flatten (L)
"Converts a list to single level."
    (if (null L)
        nil
        (if (atom (first L))
            (cons (first L) (flatten (rest L)))
            (append (flatten (first L)) (flatten (rest L))))))
```
Pour ceux qui sont nouveaux à lisp, c'est un bref résumé.

La ligne suivante déclare une fonction appelée aplatir avec l'argument L.
```
(defun flatten (L)
```
La ligne ci-dessous vérifie si la liste est vide.
```
    (if (null L)
```
La ligne suivante renvoie nul parce que les cons de l'ATOME nil déclare une liste avec une entrée (ATOM). C'est le cas de base de la récursivité et permet à la fonction de savoir quand s'arrêter. La ligne après cette vérification pour voir si le premier élément de la liste est un atome à la place d'une autre liste.
```
        (if (atom (first L))
```
Puis, si elle l'est, il utilise la récursivité pour créer une liste réduite de cet atome combiné avec le reste de la liste aplatie que la fonction va générer. les inconvénients combine un atome avec une autre liste.
```
            (cons (first L) (flatten (rest L)))
```
Si ce n'est pas un atome, alors nous avons pour aplatir sur elle, parce que c'est une autre liste que peuvent avoir d'autres listes à l'intérieur d'elle.
```
            (append (flatten (first L)) (flatten (rest L))))))
```
La fonction append ajoute la première liste pour le début de la deuxième liste.
Notez également que chaque fois que vous utilisez une fonction lisp, vous devez l'entourer avec la parenthèse. Ce qui me confond au premier abord.

et est-il la queue récursive?

OriginalL'auteur Chantry Cargill

On pourrait définir comme ceci par exemple:

(defun unnest (x)
  (labels ((rec (x acc)
    (cond ((null x) acc)
      ((atom x) (cons x acc))
      (t (rec (car x) (rec (cdr x) acc))))))
    (rec x nil)))

OriginalL'auteur Jakob

1

Lisp a la fonction remove pour enlever des choses. Ici, j'utilise une version REMOVE-IF qui supprime tous les élément pour lequel un prédicat est vrai. Je test si la chose est une parenthèse et de les supprimer si vrai.

Si vous souhaitez supprimer les parenthèses, voir cette fonction:
```
(defun unnest (thing)
  (read-from-string
   (concatenate
    'string
    "("
    (remove-if (lambda (c)
                 (member c '(#\( #\))))
               (princ-to-string thing))
    ")")))
```
Noter, cependant, que les Svante mentionne, on n'a généralement pas d'enlever les parenthèses.

OriginalL'auteur Rainer Joswig
1

C'est un accumulateur. La fonction locale %aplatir garde un accumulateur de la queue (le droit partie de la liste qui a déjà été aplatie). Lorsque la partie qui reste à être aplatie (les gauche partie de la liste) est vide, il revient la queue. Lorsque la partie aplatie est un non-liste, il renvoie la partie préfixe sur la queue. Lorsque la partie aplatie est une liste, il aplatit le reste de la liste (avec le courant de la queue), puis utilise ce résultat comme la queue pour l'aplatissement de la première partie de la liste.
```
(defun flatten (list)
  (labels ((%flatten (list tail)
             (cond
               ((null list) tail)
               ((atom list) (list* list tail))
               (t (%flatten (first list)
                            (%flatten (rest list)
                                      tail))))))
    (%flatten list '())))
```
```
CL-USER> (flatten '((1 2) (3 4) ((5) 6) 7))
(1 2 3 4 5 6 7)
```
OriginalL'auteur Joshua Taylor
1

Je sais que cette question est vraiment vieux mais j'ai remarqué que personne ne l'utilise le push/nreverse idiome, et je suis donc en téléchargement ici.

la fonction reverse-atomize prend chaque "atome" et le met dans la output de l'appel suivant. À la fin, il produit une liste aplatie qui est en arrière, qui est résolu avec le nreverse fonction dans le atomize fonction.
```
(defun reverse-atomize (tree output)
    "Auxillary function for atomize"
    (if (null tree)
      output
      (if (atom (car tree))
          (reverse-atomize (cdr tree) (push (car tree) output))
          (reverse-atomize (cdr tree) (nconc (reverse-atomize (car tree)
                                                               nil)
                                              output)))))

(defun atomize (tree)
    "Flattens a list into only the atoms in it"
     (nreverse (reverse-atomize tree nil)))
```
Afin de l'appelant atomize '((a b) (c) d) ressemble à ceci:
```
(A B C D)
```
Et si vous deviez appeler reverse-atomize avec reverse-atomize '((a b) (c) d) cela ne se produise:
```
(D C B A)
```
Gens aiment utiliser des fonctions comme push, nreverse, et nconc, car ils utilisent moins de mémoire vive que leurs respectifs cons, reverse, et append fonctions. Cela étant dit, la double nature récursive de reverse-atomize vient avec son propre RAMtech niques.

OriginalL'auteur Spenser Truex

(defun unnest (somewhat)
  (cond
   ((null somewhat) nil)
   ((atom somewhat) (list somewhat))
   (t
    (append (unnest (car somewhat)) (unnest (cdr somewhat))))))

OriginalL'auteur Bernard Adrian

Vous devez vous connecter pour publier un commentaire.