(define (Durchschnitt ...)) in Lisp

Ich bin nur spielen, um mit scheme/lisp und darüber nachgedacht, wie ich den richtigen meine eigene definition von average. Ich bin mir nicht sicher, wie zu tun, einige Dinge, die ich denke, sind erforderlich, wenn.

definieren Sie eine Prozedur nimmt eine beliebige Anzahl von Argumenten
zählen diese Argumente
übergeben Sie die Liste der Argumente für ( + ), um die Summe zusammen

Hat jemand ein Beispiel für die Definition average? Ich weiß nicht scheinen, um genug wissen über LISP zu bilden, eine web-Suche, bekommt die Ergebnisse zurück, die ich Suche.

Dies ist keine Hausaufgabe (habe downvoted aus irgendeinem Grund... wahrscheinlich, weil jemand dachte, es war). Ich arbeite durch die SICP natürlich online und ich war nur Herumspielen mit LISP Frage mich, wie man erstellen Sie diese Zeit des Verfahrens.
(FWIW, das war ziemlich klar-fast alle Kurse gehen über Funktionen mit rest-Argumente.)

InformationsquelleAutor Eric Schoonover | 2010-07-14

11

Die definition würde eine sehr einfache one-liner, aber ohne Sie zu verderben, Sie in Aussehen sollte:
- einer "rest" - argument -- dieser (define (foo . xs) ...xs...) definiert foo als eine Funktion, die eine beliebige Anzahl von Argumenten und gibt Sie als eine Liste, die den Wert von xs.
- length gibt die Länge einer Liste.
- apply nimmt eine Funktion und eine Liste von Werten und wendet die Funktion auf diese Werte.
Wenn Sie bekommen, dass Sie gehen können für mehr:
- sehen die foldl - Funktion vermeiden Sie die Anwendung eine Liste auf eine potenziell sehr große Liste (dies kann die Sache in manchen Implementierungen, in denen die Länge der Liste der Argumente ist begrenzt, aber es würde nicht viel Unterschied im Schläger).
- beachten Sie, dass die Schläger hat genau rationals, und Sie können exact->inexact in eine bessere floating-point-version.
Und die Spoiler sind:
- (define (average . ns) (/(apply + ns) (length ns)))
- Machen es erforderlich sein, dass ein argument: (define (average n . ns) (/(apply + n ns) (add1 (length ns))))
- Verwenden foldl: (define (average n . ns) (/(foldl + 0 (cons n ns)) (add1 (length ns))))
- Machen es verwenden, floating point: (define (average n . ns) (/(foldl + 0.0 (cons n ns)) (add1 (length ns))))
InformationsquelleAutor Eli Barzilay
3

In Common Lisp, es sieht aus wie Sie tun können:
```
(defun Durchschnitt (&rest args) 
(wenn args 
(/(apply #'+ args) (Länge args)))) 
```
ich habe zwar keine Ahnung, ob &rest ist auf alle Implementierungen von Lisp. Referenz hier.

Setzen, dass code in GNU CLISP Ergebnisse in:
```
[1]> (defun Durchschnitt (&rest args) 
(wenn args 
(/(apply #'+ args) (Länge args)))) 
DURCHSCHNITTLICHE 
[2]> (Durchschnitt 1 2 3 4 5 6) 
7/2 
```
3,5 (richtig).
- Sie sollten nicht davon ausgehen, dass eine lisp-Implementierung annehmen kann eine beliebige Anzahl von Eingaben (und wenn ich mich Recht erinnere, CLisp brechen). Auch, die Funktion sollte immer wieder eine Zahl-dieser code wird bei Rückgabe NIL, wenn keine Eingänge.
- Sie wissen wahrscheinlich mehr über LISP als ich (wie bewiesen durch Ihre viel umfassendere Antwort). Aber da muss ich widersprechen, auf diese Letzte Aussage. Mathematisch, die durchschnittlich eine leere Menge ist keine Zahl, es ist undefiniert. Wenn Sie wollen, dass es 0 zurück {ugh! IMNSHO : -) } Sie können den code ändern, um so zu tun.
- paxdiablo: richtig, es wird nicht definiert und die übersetzung von code ist in den meisten Fällen am besten durch die Ausgabe einer Fehlermeldung. Siehe mein code-Beispiel: es wirft einen Fehler, wenn keine Eingaben (eine schlechte division durch null in der ersten version, und eine viel bessere stelligkeit Fehler später). Natürlich gibt es auch Fälle, wo würden Sie wollen, wieder einige "undefined" Ergebnis ( null , undefined, nan etc), aber meistens es ist besser, dass der code einen Fehler auslösen, früher, anstatt Sie zu verbreiten, eine möglicherweise falsche Ergebnis durch.
- (Oh, und BTW, jeder lisper würde Stöhnen über "LISP" - es sollte "Lisp".)
- Sorry, ich dachte, es war die acronymn: Viele Reizt die Überflüssigen Klammern 🙂 ich habe immer nur gespielt und ein wenig mit Lisp, mehr so mit dem Schema, da es ein Teil von einem Produkt, das wir einmal angenommen, aber ich kann mich erinnern, von Ihnen heute in der endlosen % Klammer-matching hatte ich zu tun in vi.
- Das klingt eher wie Sie nicht deinen editor richtig.
- Ja-du wirst auch sehen, dass Lisp/Scheme-Programmierer sehr pedantisch über Ihren Einzug: das ist, weil nach einer ersten kurzen Phase der Anpassung, die Sie einfach "nicht sehen" der parens mehr. Dazu gehören viele Menschen, die nie in eine ( ohne schließen ), so source code ist nie unsymmetrisch, was bedeutet, dass Sie nie brauchen, Sie zu zählen -- und das ist praktisch in allen Sprachen. (Aber natürlich nicht aufhören, die üblichen Klammer-bezogene Witze...)
- Eli, warum Lisp? Die SICP-Buch sagt, dass LISP steht für LISt Processing. Gegeben, dass es eine Abkürzung wäre nicht die entsprechende Darstellung in Großbuchstaben? Nicht sagen, dass Sie falsch sind, einfach Fragen, warum Lisp und nicht LISP gegeben, dass die definition.
InformationsquelleAutor paxdiablo

Beiden Versionen in Common Lisp:

(defun average (items)
  (destructuring-bind (l . s)
      (reduce (lambda (c a)
                (incf (car c))
                (incf (cdr c) a)
                c)
              items
              :initial-value (cons 0 0))
    (/ s l)))

(defun average (items &aux (s 0) (l 0))
  (dolist (i items (/ s l))
    (incf s i)
    (incf l)))

InformationsquelleAutor Rainer Joswig

1

Schema, ziehe ich mit Hilfe einer Liste, statt die "rest" - argument, weil rest-argument vereinfacht die Implementierung von Verfahren, wie die folgenden schwer:
```
> (define (call-average . ns)
     (average ns))
> (call-average 1 2 3) ;; => BANG!
```
Verpackung beliebige Anzahl von Argumenten in einer Liste können Sie eine Liste Vorgang auf die Argumente. Sie können mehr tun mit weniger syntax und Verwirrung. Hier ist mein Schema version average dass take 'n' Argumente:
```
(define (average the-list)
  (let loop ((count 0) (sum 0) (args the-list))
    (if (not (null? args))
        (loop (add1 count) (+ sum (car args)) (cdr args))
        (/ sum count))))
```
Hier wird das gleiche Verfahren in Common Lisp:
```
(defun average (the-list)
  (let ((count 0) (sum 0))
    (dolist (n the-list)
      (incf count)
      (incf sum n))
    (/ sum count)))
```
- Sie können apply für die übersetzung von Liste in einer Liste von Argumenten.
- (Incf sum n) ist besser als (setf sum (+ sum n)). Außerdem meinen ersten Prototyp in der Regel wäre (/ (reduce #'+ list) (length list)), und dann könnte ich es ändern um eine (loop for element in list counting element into length summing element into sum finally (return (/ sum length))).
- Könnte man nicht stattdessen schreiben Sie ein einfaches makro zum entpacken der Liste, wie die einzelnen Argumente für den Aufruf average so würde es Aussehen: (define (call-average . ns) (average (unpack ns)))? Ich bin derzeit ein Scheme/Lisp-Neuling, also ich weiß ehrlich nicht, wie möglich das ist.
InformationsquelleAutor Vijay Mathew

In R5RS Scheme:

(define (average . numbers)  
    (/ (apply + numbers) (length numbers)))

InformationsquelleAutor Felipe

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.