Wie entfernen, verschachtelte Klammern in LISP

Wie kann ich entfernen, verschachtelte Klammern rekursiv in Common LISP wie

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

Dank

InformationsquelleAutor der Frage bubdada | 2010-04-21

17

Hier ist, was ich tun würde:
```
(ql:quickload "alexandria")
(alexandria:flatten list)
```
Das funktioniert vor allem, weil ich Quicklisp bereits installiert.

InformationsquelleAutor der Antwort Xach

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

InformationsquelleAutor der Antwort 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))))))

InformationsquelleAutor der Antwort Bill

4

Ich weiß, dies ist ein Alter thread, aber es ist einer der ersten, der kommt, wenn ich google lisp glätten. Die Lösung, die ich entdeckt, ist ähnlich dem, der oben diskutiert wird, aber die Formatierung ist etwas anders. Ich werde erklären, dass es, wenn man neue lisp, wie ich war, als ich das erste mal gegoogelt, diese Frage, so ist es wahrscheinlich, dass andere es auch sein.
```
(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))))))
```
Für diejenigen, lisp, dies ist eine kurze Zusammenfassung.

Die folgende Zeile deklariert eine Funktion, die aufgerufen reduzieren, mit dem argument L.
```
(defun flatten (L)
```
In der Zeile darunter Prüfungen für eine leere Liste.
```
    (if (null L)
```
Die nächste Zeile, wird nil zurückgegeben, weil die Nachteile ATOM nil deklariert eine Liste mit einem Eintrag (ATOM). Dies ist der basisfall der Rekursion und können die Funktion wissen, Wann man aufhören. Die Linie, nachdem dieser überprüft, ob das erste Element in der Liste ist ein atom, anstatt einer anderen Liste.
```
        (if (atom (first L))
```
Dann, wenn es ist, es verwendet die Rekursion zu erstellen flachgedrückten-Liste dieses atom in Kombination mit dem rest der reduzierten Liste, die der Funktion generiert. Nachteile verbindet sich ein atom mit einer anderen Liste.
```
            (cons (first L) (flatten (rest L)))
```
Wenn es nicht ein atom, dann müssen wir reduzieren, denn es ist eine andere Liste, können weitere Listen innerhalb von es.
```
            (append (flatten (first L)) (flatten (rest L))))))
```
Der append-Funktion append die erste Liste an den Anfang der zweiten Liste.
Beachten Sie auch, dass jedes mal, wenn Sie eine Funktion in lisp, müssen Sie umgeben Sie es mit Klammern. Dies verwirrte mich zunächst.

InformationsquelleAutor der Antwort Chantry Cargill

Können Sie definieren, wie diese zum Beispiel:

(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)))

InformationsquelleAutor der Antwort Jakob

1

Lisp hat die Funktion remove Dinge zu entfernen. Hier verwende ich eine version REMOVE-IF entfernt werden, jeden Artikel, für die ein Prädikat wahr ist. Ich testen, ob das Ding eine Klammer, und entfernen Sie es, wenn wahr.

Wenn Sie möchten, entfernen von Klammern finden Sie diese Funktion:
```
(defun unnest (thing)
  (read-from-string
   (concatenate
    'string
    "("
    (remove-if (lambda (c)
                 (member c '(#\( #\))))
               (princ-to-string thing))
    ")")))
```
Hinweis, obwohl, wie Svante erwähnt, in der Regel nicht 'entfernen' Klammern.

InformationsquelleAutor der Antwort Rainer Joswig
1

Dies ist ein Akku-basierten Ansatz. Die lokale Funktion %reduzieren hält ein Akku der Schwanz (die Recht Teil der Liste bereits reduziert). Wenn das Teil noch zu flach (die Links Teil der Liste) leer ist, gibt es die Rute. Wenn das Teil zu glätten, ist eine nicht-Liste, gibt es das Teil vorangestellt, auf den Schwanz. Wenn der Teil, der abgeflacht ist, eine Liste, es flacht die rest von der Liste (mit der aktuellen Rute), dann verwendet das Ergebnis als der Schwanz für die Abflachung der erste Teil der 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)
```
InformationsquelleAutor der Antwort Joshua Taylor
1

Ich weiß, diese Frage ist wirklich altaber ich bemerkte, dass niemand verwendet das push/nreverse idiom, also bin ich auch hochladen, hier.

die Funktion reverse-atomize nimmt jedes "atom" und stellt es in die output auf den nächsten Anruf. Am Ende erzeugt es eine vereinfachte Liste, das ist Rückschritt, das ist behoben, mit der nreverse Funktion in der atomize Funktion.
```
(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)))
```
So aufrufen atomize '((a b) (c) d) sieht wie folgt aus:
```
(A B C D)
```
Und wenn Sie rufen reverse-atomize mit reverse-atomize '((a b) (c) d) dieses auftreten würde:
```
(D C B A)
```
Menschen wie die Verwendung von Funktionen wie pushnreverseund nconc weil Sie weniger RAM als Ihre jeweiligen consreverseund append Funktionen. Das sagte die Doppel-rekursive Natur des reverse-atomize kommt mit seinen eigenen RAMifications.

InformationsquelleAutor der Antwort Spenser Truex

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

InformationsquelleAutor der Antwort Bernard Adrian

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.