Listen Sie Operationen in Lisp auf

Question

Ich habe überall nach der folgenden Funktionalität in Lisp gesucht und bin nicht weitergekommen:

1. Den Index von etwas in einer Liste finden.Beispiel:

   (index-of item InThisList)
   

2. etwas an einer bestimmten Stelle in einer Liste ersetzen.Beispiel:

   (replace item InThisList AtThisIndex) ;i think this can be done with 'setf'?
   

3. Gibt ein Element an einem bestimmten Index zurück.Beispiel:

   (return InThisList ItemAtThisIndex)
   

Bis jetzt habe ich es mit meinen eigenen Funktionen vorgetäuscht.Ich frage mich, ob ich damit nur mehr Arbeit für mich schaffe.

So habe ich Nummer 1 vorgetäuscht:

(defun my-index (findMe mylist)
  (let ((counter 0) (found 1))
    (dolist (item mylist)
      (cond
        ((eq item findMe) ;this works because 'eq' checks place in memory, 
                  ;and as long as 'findMe' was from the original list, this will work.
         (setq found nil)
        (found (incf counter))))
  counter))

Answer 1

Sie können verwenden setf Und nth zum Ersetzen und Abrufen von Werten nach Index.

(let ((myList '(1 2 3 4 5 6)))
     (setf (nth 4 myList) 101); <----
     myList)

(1 2 3 4 101 6)

Um nach Index zu suchen, können Sie verwenden Die position Funktion.

(let ((myList '(1 2 3 4 5 6)))
     (setf (nth 4 myList) 101)
     (list myList (position 101 myList)))

((1 2 3 4 101 6) 4)

Ich habe diese alle gefunden in diesem Funktionsverzeichnis.

Answer 2

1. Den Index von etwas in einer Liste finden.

In Emacs Lisp und Common Lisp haben Sie das position Funktion:

> (setq numbers (list 1 2 3 4))
(1 2 3 4)
> (position 3 numbers)
2

In Scheme ist hier eine tail-rekursive Implementierung von DrSchemeDokument:

(define list-position 
  (lambda (o l)
    (let loop ((i 0) (l l))
      (if (null? l) #f
          (if (eqv? (car l) o) i
              (loop (+ i 1) (cdr l)))))))

----------------------------------------------------

> (define numbers (list 1 2 3 4))
> (list-position 3 numbers)
2
> 

Aber wenn Sie eine Liste als Sammlung von Slots zum Speichern strukturierter Daten verwenden, sollten Sie vielleicht einen Blick darauf werfen defstruct oder sogar eine Art Lisp-Objektsystem wie CLOS.

Wenn Sie Lisp lernen, sollten Sie unbedingt einen Blick darauf werfen Praktisches gemeinsames Lisp und/oder Der kleine Intrigant.

Prost!

Answer 3

Antworten:

1. (Positionselementsequenz &Schlüssel von-Ende (Start 0) Ende Schlüsseltest Test-nicht)
   http://lispdoc.com/?q=position&search=Basic+search

2. (setf-Wert (elt sequence index))

3. (elt-Sequenzindex)
   http://lispdoc.com/?q=elt&search=Basic+search
   NOTIZ:elt ist nth vorzuziehen, da elt mit jeder Sequenz funktioniert, nicht nur mit Listen

Answer 4

Jeremys Antworten sollten funktionieren;Aber das heißt, wenn Sie sich dabei ertappen, wie Sie Code schreiben

(setf (nth i my-list) new-elt)

Sie verwenden wahrscheinlich die falsche Datenstruktur.Listen sind einfach verknüpfte Listen, sodass der Zugriff über den Index O(N) ist.Möglicherweise ist die Verwendung von Arrays besser geeignet.

Oder vielleicht verwenden Sie Listen als Tupel.In diesem Fall sollte es ihnen gut gehen.Aber wahrscheinlich möchten Sie Accessoren benennen, damit sich jemand, der Ihren Code liest, nicht daran erinnern muss, was „nte 4“ bedeuten soll.Etwas wie

(defun my-attr (list)
  (nth 4 list))

(defun (setf my-attr) (new list)
  (setf (nth 4 list) new))

Answer 5

+2 für „Practical Common Lisp“.Es ist eine Mischung aus einem Common Lisp-Kochbuch und einem hochwertigen Teach Yourself Lisp-Buch.

Es gibt auch „Successful Common Lisp“ (http://www.psg.com/~dlamkins/sl/cover.html Und http://www.psg.com/~dlamkins/sl/contents.html), was ein paar Lücken zu schließen / Dinge in „Practical Common Lisp“ zu erweitern schien.

Ich habe auch Paul Grahams „ANSI Common Lisp“ gelesen, in dem es mehr um die Grundlagen der Sprache geht, es aber eher um ein Referenzhandbuch geht.

Answer 6

Ich muss Thomas zustimmen.Wenn Sie Listen wie Arrays verwenden, ist das nur langsam (und möglicherweise umständlich).Sie sollten also entweder Arrays verwenden oder bei den von Ihnen geschriebenen Funktionen bleiben, sie aber so nach oben verschieben, dass Sie die langsamen Listen später problemlos durch Arrays ersetzen können.