rendezvous with cassidoo challenge: 22.07.31

num_of_ones.clj

(ns num-of-ones
  (:require [clojure.test :refer [deftest is]]))
                                                                                                 
(defn n->digits 
  "ex. (n->digits 14) => [1 4]"
  [n]                                                                              
  (if (< n 10)                                                                                   
    [n]                                                                                          
    (conj (n->digits (quot n 10)) (rem n 10))))                                                  
                                                                                                 
(defn number-of-ones [n]                                                                         
  (->> (range (inc n))                                                                           
       (mapcat n->digits)                                                                        
       (filter #(= 1 %))                                                                         
       count))  
       
(deftest number-of-ones-test                                                                     
  (is (= 7 (number-of-ones 14))))
  

Various transducer versions that run almost twice as fast for a large input number:

(defn number-of-ones-into [n]                                                                    
  (let [xf (comp (mapcat n->digits)                                                              
                 (filter #(= 1 %)))]                                                             
    (count                                                                                       
      (into [] xf (range (inc n))))))                                                            
                                                                                                 
;; (number-of-ones-into 14) ;; 7                                                                 
                                                                                                 
(defn number-of-ones-transduce [n]                                                               
  (let [xf (comp (mapcat n->digits)                                                              
                 (filter #(= 1 %)))]                                                             
    (count                                                                                       
      (transduce xf conj (range (inc n))))))                                                     
                                                                                                 
;; (number-of-ones-transduce 14) ;; 7                                                            
                                                                                                 
(defn number-of-ones-eduction [n]                                                                
  (count                                                                                         
    (into []                                                                                     
          (eduction (mapcat n->digits) (filter #(= 1 %)) (range (inc n))))))                     
                                                                                                 
;; (number-of-ones-eduction 14) ;; 7                                                             
                                                                                                 
;; (time (number-of-ones 10000000))           ;; Elapsed time: ~8.5 seconds                      
;; (time (number-of-ones-into 10000000))      ;; Elapsed time: ~4.5 seconds                      
;; (time (number-of-ones-transduce 10000000)) ;; Elapsed time: ~5 seconds                        
;; (time (number-of-ones-eduction 10000000))  ;; Elapsed time: ~4.6 seconds