Come faccio a implementare una funzione pigro “riducendo mappa”?
Domanda
Sto cercando di implementare una funzione "ridurre mappa". Cioè, deve restituire una sequenza costituita dal risultato dell'applicazione f
ai primi 2 capi di coll
, seguito dal risultato dell'applicazione f
a tale risultato e il terzo elemento coll
, etc.
(def c [[0 0 0 0] [1 0 0 0] [0 1 0 0] [0 0 1 0] [0 0 0 1]])
(defn- sum-vector [v1 v2]
(map + v1 v2))
(defn reduce-map [f coll & acc]
(if (< (count coll) 2)
(if (empty? acc) coll acc)
(let [head (apply f (take 2 coll))
tail (drop 2 coll)]
(recur f (conj tail head) (conj acc head)))))
Ad esempio, chiamare questa funzione in questo modo:
(reduce-map sum-vector c)
dovrebbe restituire:
[[1 0 0 0] [1 1 0 0] [1 1 1 0] [1 1 1 1]]
(In realtà, probabilmente dovrebbe tornare il primo elemento non modificati, nonché, per map
meglio imitare, ma posso risolvere il problema che più tardi).
A destra, ora, questo è quello che ritorna:
((1 1 1 1) (1 1 1 0) (1 1 0 0) (1 0 0 0))
Come faccio a "spingere" al termine di un ss (ny)?
Se io sostituto reduce-map
per recur
, questo è ciò che restituisce:
(((1 1 1 1) ((1 1 1 0) ((1 1 0 0) ((1 0 0 0))))))
Qual è la differenza tra recur
e vera ricorsività nel mio codice di cui sopra?
E, v'è un built-in, o meglio, o più idiomatica, modo di attuare reduce-map
?
Infine, mi piacerebbe la sequenza di uscita di essere pigro. Posso solo avvolgere il tutto in lazy-seq
?
Soluzione
Questo suona un po 'come reductions
.
Per quanto riguarda "spingere" alla fine della SEQ: in generale seguenti del regolamento provvisorio non hanno un "fine", cf. (iterate inc 0)
.
Per quanto riguarda "spingere" al termine di una lista: gli elenchi non sono stati progettati per questo. Utilizzare un vettore. Seed vostro accumulatore con []
, non nil
.
Per quanto riguarda lazy-seq
: utilizzare la ricorsione "vera" invece di recur
. Ecco un esempio:
(defn integer-seq
[start]
(lazy-seq
(cons start (integer-seq (inc start)))))