स्टैक उपयोग क्षमता और समय

Question

के संदर्भ में कौन सा फ़ंक्शन सबसे अच्छा है, मैंने 3 फ़ंक्शंस लिखे हैं जो एक सूची में एक-तत्व दिखाई देने की संख्या की गणना करते हैं। मैंने विभिन्न इनपुट की कोशिश की और इसे प्रोफाइल किया लेकिन मुझे अभी भी पता नहीं है कि स्टैक उपयोग दक्षता और समय दक्षता के मामले में कौन सा फ़ंक्शन सबसे अच्छा है। कृपया मेरी मदद करें।

;; Using an accumulator 
    (defn count-instances1 [a-list an-element] 
     (letfn [(count-aux [list-aux acc] 
         (cond 
          (empty? list-aux) acc 
          :else (if (= (first list-aux) an-element) 
            (count-aux (rest list-aux) (inc acc)) 
            (count-aux (rest list-aux) acc))))] 
     (count-aux a-list 0))) 

;; Normal counting 
    (defn count-instances2 [a-list an-element] 
    (cond 
     (empty? a-list) 0 
     :else 
      (if (= (first a-list) an-element) 
       (+ 1 (count-instances2 (rest a-list) an-element)) 
       (count-instances2 (rest a-list) an-element)))) 

;; using loop. does this help at all? 
    (defn count-instances3 [a-list an-element] 
     (loop [mylist a-list acount 0] 
      (if (empty? mylist) 
       acount 
       (if (= (first mylist) an-element) 
       (recur (rest mylist)(inc acount)) 
       (recur (rest mylist) acount))))) 

Answer 1

पाश/पुनरावृत्ति होना संस्करण सही तरीका है। Joj की सीमाओं के कारण क्लोजर पूंछ कॉल को अनुकूलित नहीं कर सकता है।

Answer 2

अपने कोड लेखन तो संकलक/interperter पूंछ प्रत्यावर्तन के लिए यह अनुकूलित कर सकते हैं, कुछ प्रदर्शन वृद्धि में परिणाम और उपयोग में कमी ढेर चाहिए। मुझे लगता है कि आपका सामान्य गिनती समारोह पूंछ रिकर्सन के लिए अर्हता प्राप्त कर सकता है ताकि कोई बहुत तेज हो। यकीन नहीं है क्योंकि मैं केवल एक शौक के रूप में लिस्प में डबिल हूं।

http://en.wikipedia.org/wiki/Tail_recursion