(define (average ....)) in Lisp

Question

Sto solo giocando con lo schema/lisp e stavo pensando a come avrei corretto la mia definizione di average. Non sono sicuro di come fare alcune cose che penso siano necessarie.

• definire una procedura che richiede un numero arbitrario di argomenti
• contano tali argomenti
• passare l'elenco argomento (+) per sommare insieme

Qualcuno ha un esempio di definizione average? Non sembra che conosca abbastanza LISP per formare una ricerca sul Web che recuperi i risultati che sto cercando.

Answer 1

La definizione sarebbe molto semplice one-liner, ma senza rovinare esso, si dovrebbe guardare in:

• un "riposo" argomento - questo (define (foo . xs) ...xs...) definisce foo come una funzione che prende un numero qualsiasi di argomenti e sono disponibili come un elenco che sarà il valore di xs.

• length restituisce la lunghezza di un elenco.

• apply accetta una funzione e un elenco di valori e applica la funzione a questi valori.

Quando si ottiene che, si può andare per di più:

• vedere la funzione foldl per evitare di applicare un elenco su un potenzialmente molto grande lista (questo può importare in alcune implementazioni in cui la lunghezza dell'elenco degli argomenti è limitato, ma non farebbe molta differenza in Racket).

• nota che Racket ha razionali esatti e che è possibile utilizzare exact->inexact per creare una versione a virgola mobile più efficiente.

---

---

---

---

E gli spoiler sono:

• (define (average . ns) (/ (apply + ns) (length ns)))

• Make it richiede il e argomento: (define (average n . ns) (/ (apply + n ns) (add1 (length ns))))

• Uso foldl: (define (average n . ns) (/ (foldl + 0 (cons n ns)) (add1 (length ns))))

• Ne fanno uso in virgola mobile: (define (average n . ns) (/ (foldl + 0.0 (cons n ns)) (add1 (length ns))))

Answer 2

In Common Lisp, sembra che si può fare:

 
(defun average (&rest args) 
    (when args 
    (/ (apply #'+ args) (length args)))) 

anche se non ho idea se &rest è disponibile su tutte le implementazioni di Lisp. Riferimento here.

Mettendo codice in risultati GNU CLISP in:

 
[1]> (defun average (&rest args) 
     (when args 
     (/ (apply #'+ args) (length args)))) 
AVERAGE 
[2]> (average 1 2 3 4 5 6) 
7/2 

che è 3,5 (corretto).

Answer 3

Nello Schema, io preferisco usare una lista al posto del "riposo" l'argomento in quanto argomento di riposo rende difficili le procedure di implementazione:

> (define (call-average . ns) 
    (average ns)) 
> (call-average 1 2 3) ;; => BANG! 

L'inserimento di un numero arbitrario di argomenti in un elenco consente di eseguire qualsiasi operazione di elenco sugli argomenti. Puoi fare di più con meno sintassi e confusione. Ecco la mia versione del sistema di average che prendono 'n' argomenti:

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

Ecco la stessa procedura in Common Lisp:

(defun average (the-list) 
    (let ((count 0) (sum 0)) 
    (dolist (n the-list) 
     (incf count) 
     (incf sum n)) 
    (/ sum count))) 

Answer 4

Due versioni 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))) 

Answer 5

Nello schema R5RS:

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