क्लोजर

Question

में हेड प्रतिधारण "क्लोजर प्रोग्रामिंग" (पृष्ठ 98) में मुख्य प्रतिधारण के बारे में पैराग्राफ पढ़ना, मुझे पता नहीं लगा कि split-with उदाहरण में क्या होता है। मैंने प्रतिलिपि के साथ प्रयोग करने की कोशिश की है लेकिन यह मुझे और अधिक भ्रमित कर दिया है।

(time (let [r (range 1e7) 
      a (take-while #(< % 12) r) 
      b (drop-while #(< % 12) r)] 
     [(count a) (count b)])) 
"Elapsed time: 1910.401711 msecs" 
[12 9999988] 

(time (let [r (range 1e7) 
      a (take-while #(< % 12) r) 
      b (drop-while #(< % 12) r)] 
     [(count b) (count a)])) 
"Elapsed time: 3580.473787 msecs" 
[9999988 12] 

(time (let [r (range 1e7) 
      a (take-while #(< % 12) r) 
      b (drop-while #(< % 12) r)] 
     [(count b)])) 
"Elapsed time: 3516.70982 msecs" 
[9999988] 

आप पिछले उदाहरण से देख सकते हैं, अगर मैं a गणना नहीं है, समय किसी भी तरह लेने वाली होती है। मुझे लगता है, मैंने यहाँ कुछ याद किया है, लेकिन क्या?

Answer 1

Count ओ (1) है। यही कारण है कि आपके माप इस पर निर्भर नहीं हैं।

Answer 2

let फॉर्म में बाध्यकारी भी हम इस मूल्य का उपयोग नहीं करते हैं। प्रिंट ऊपर

(let [x (println "Side effect")] 1) 

कोड "साइड प्रभाव", और वापसी 1.

अपने सभी तीन उदाहरण अंदर जाने के रूप में एक ही बंधन का इस्तेमाल किया है, इसलिए मैं कोई फर्क यहाँ नहीं दिख रहा। वैसे, मेरी मशीन पर आपके सभी स्निपेट लगभग बराबर समय लेते थे।

वास्तविक अंतर है जब आप कुछ इस तरह का प्रयास करें:

(time (let [r (range 2e7) 
     a (take 100 r) 
     b (drop 100 r)] 
    [(count a)])) 
"Elapsed time: 0.128304 msecs" 
[100] 

(time (let [r (range 2e7) 
     a (take 100 r) 
     b (drop 100 r)] 
    [(count b)])) 
"Elapsed time: 3807.591342 msecs" 
[19999900] 

तथ्य यह है कि b और a आलसी दृश्यों, O(n) समय में count काम करता हैं के कारण। लेकिन पहले उदाहरण में हम बी के लिए गिनती की गणना नहीं करते हैं, इसलिए यह लगभग तुरंत काम करता है।

Answer 3

count फ़ंक्शन ओ (1) Counted संग्रहों के लिए है, जिसमें वैक्टर और सूचियां शामिल हैं।

दूसरी ओर, अनुक्रम, not counted हैं जो count ओ (एन) बनाता है। यहां महत्वपूर्ण हिस्सा यह है कि कार्य take-while और drop-while रिटर्न अनुक्रम। तथ्य यह है कि वे भी आलसी हैं यहां एक प्रमुख कारक नहीं है।

Answer 4

जब समय एक एक बेंचमार्क का उपयोग कर, परीक्षण एक सटीक परिणाम

user> (defn example2 [] (let [r (range 1e7)            
       a (take-while #(< % 12) r)          
       b (drop-while #(< % 12) r)]       
      [(count a) (count b)])) 
#'user/example2 

user> (dorun (take 1000 (repeatedly example2))) 
nil 

user> (time (example2)) 
"Elapsed time: 614.4 msecs" 
[12 9999988] 

मैं क्रम में विचरण दोष क्योंकि हॉटस्पॉट संकलक अभी तक पूरी तरह उत्पन्न वर्गों optomized है प्राप्त करने के लिए कई बार चलाते हैं। मैं पहले और दूसरे उदाहरण कई बार भाग गया और मिश्रित रिश्तेदार परिणाम मिल गया:

रन उदाहरण एक दो बार:

autotestbed.core> (time (let [r (range 1e7)                 
             a (take-while #(< % 12) r)          
                b (drop-while #(< % 12) r)]       
           [(count a) (count b)])) 
"Elapsed time: 929.681423 msecs"                   
[12 9999988] 
autotestbed.core> (time (let [r (range 1e7)                 
             a (take-while #(< % 12) r)          
                b (drop-while #(< % 12) r)]       
           [(count a) (count b)])) 
"Elapsed time: 887.81269 msecs"                    
[12 9999988] 

तो उदाहरण दो चलाने दो बार:

core> (time (let [r (range 1e7)                 
        a (take-while #(< % 12) r)          
        b (drop-while #(< % 12) r)]       
      [(count a) (count b)])) 
"Elapsed time: 3838.751561 msecs"                   
[12 9999988] 
core> (time (let [r (range 1e7)                 
        a (take-while #(< % 12) r)          
        b (drop-while #(< % 12) r)]       
      [(count a) (count b)])) 
"Elapsed time: 970.397078 msecs"                   
[12 9999988] 

sometiems दूसरा उदाहरण बस

Answer 5

जितना समय दिखा रहा है वह पूरी तरह से सिस्टम निर्भर है .... यदि आप इसे फिर से निष्पादित करते हैं, तो यह कुछ अलग दिखाएगा प्रत्येक निष्पादन के लिए समय बीत गया