Come dividere un numero in Clojure?

Question

Sto cercando un metodo piacevole per dividere un numero con n cifre in Clojure ho questi due metodi verbose inefficienti:

(->> (str 942) 
     seq 
     (map str) 
     (map read-string)) => (9 4 2) 

e ...

(defn digits [n] ;YUK!! 
    (cons 
     (str (mod n 10)) (lazy-seq (positive-numbers (quot n 10))))) 

(map read-string (reverse (take 5 (digits 10012)))) => (1 0 0 1 2) 

C'è un altro metodo conciso per fare questo tipo di operazione?

Answer 1

Una versione di gestire il primo metodo è

(defn digits [n] 
    (->> n str (map (comp read-string str)))) 

... e del vostro secondo è

(defn digits [n] 
    (if (pos? n) 
    (conj (digits (quot n 10)) (mod n 10)) 
    [])) 

Un idiomatica alternativa

(defn digits [n] 
    (->> n 
     (iterate #(quot % 10)) 
     (take-while pos?) 
     (mapv #(mod % 10)) 
     rseq)) 

Per esempio,

(map digits [0 942 -3]) 
;(nil (9 4 2) nil) 

• Il calcolo è essenzialmente ansioso, poiché l'ultima cifre in è il primofuori. Quindi potremmo anche usare mapv e rseq (anziché map e reverse) per farlo più velocemente.
• La funzione è pronta per il trasduttore.
• Funziona correttamente solo con numeri positivi.

Answer 2

Si potrebbe semplicemente fare

(map #(Character/digit % 10) (str 942))

EDIT: Aggiunta di una definizione di funzione

(defn digits [number] (map #(Character/digit % 10) (str number))) 

Usage:

(digits 1234) 

Nota: Questa è conciso, ma fa uso di Java String e classi di personaggi. Un'implementazione efficiente può essere scritta utilizzando l'intero modulo aritmetico, ma non sarà concisa. Una tale soluzione simile alla risposta di Charles' sarebbe:

(defn numTodigits 
    [num] 
    (loop [n num res []] 
    (if (zero? n) 
     res 
     (recur (quot n 10) (cons (mod n 10) res))))) 

Source

Answer 3

io non sono sicuro di concisa, ma questo evita inefficienza inutili come la conversione di stringhe e di nuovo a numeri interi.

(defn digits [n] 
    (loop [result (list), n n] 
    (if (pos? n) 
     (recur (conj result (rem n 10)) 
      (quot n 10)) 
     result))) 

Answer 4

Un'implementazione ricorsiva (potrebbe essere più efficiente e meno concisa, ma non dovrebbe essere importante per numeri ragionevoli).

(defn digits [n] 
    (when (pos? n) 
    (concat (digits (quot n 10)) 
      [(mod n 10)]))) 

Answer 5

un metodo loop:

(defn split-numbers [number] 
    (loop [itr 0 res [] n number] 
    (if (= n 0) 
     res 
     (recur (inc itr) (concat (vector (mod n 10)) res) (int (/ n 10))) 
     ) 
    ) 
    )