क्लोजर में काम करते समय कम करें?

मैं क्लोजर प्रोग्रामिंग के लिए नया हूं, और जानना चाहता हूं कि निम्न कार्य करने का बेवकूफ तरीका क्या है:

  1. मैं संख्याओं का संग्रह nums जोड़ना चाहता हूं, जिसमें बड़ी संख्या में संख्याएं हो सकती हैं, आइए मान लें कि केवल सकारात्मक संख्याएं हैं।

  2. यदि राशि बहुत बड़ी है तो मुझे सटीक राशि परवाह नहीं है। उदाहरण के लिए, यदि संख्याओं का योग 99 99 से बड़ा है, तो मैं शेष संख्याओं को संक्षेप में 10000 वापस कर दूंगा।

अगर मैं इसे जावा जैसी कुछ ओओ भाषा के साथ कार्यान्वित करता हूं, तो मैं इसे नीचे जैसा कर सकता हूं:

private int sum(int[] nums) {
  int sum = 0;
  for(int n : nums) {
    if(sum > 9999) {
      sum = 10000;
      break;
    } else {
      sum += n;
    }
  }
  return sum;
}

क्लोजर में एक बेवकूफ कार्यान्वयन इस तरह दिख सकता है:

(let [sum (reduce + nums)]
   (if (> sum 9999) 10000 sum))

हालांकि, ऐसा लगता है कि कुछ सीपीयू संसाधनों को संख्याओं के पूरे संग्रह को पूरा करने के लिए बर्बाद कर दिया गया है, जो वांछित नहीं है। मैं कुछ समय की तलाश में हूं, लेकिन कम करने के लिए, लेकिन इसे नहीं मिला। क्या ऐसा कुछ है:

(reduce-while pred f val coll)

या इस समस्या को हल करने के लिए कोई अन्य क्लोजर बेवकूफ तरीका है? मुझे लगता है कि समाधान को समान तर्क की आवश्यकता वाले समस्याओं के एक सेट पर लागू किया जा सकता है।

किसी भी टिप्पणी की सराहना की है। धन्यवाद।

7

2 उत्तर

यदि आप क्लोजर 1.5.x का उपयोग कर रहे हैं तो आप नया <कोड का लाभ उठा सकते हैं > कम फ़ंक्शन :

(reduce #(if (> %1 9999) (reduced 10000) (+ %1 %2)) nums)
15
जोड़ा
धन्यवाद। यह वही है जो मैं ढूंढ रहा हूं। मैं 4clojure.com में कुछ अभ्यास कर रहा हूं, लेकिन ऐसा लगता है कि यह क्लोजर 1.5 का समर्थन नहीं करता है :(
जोड़ा लेखक nybon, स्रोत

कम ज्ञात क्लोजर फ़ंक्शंस में से एक कटौती लगता है। यह आपको आपके गणना के सभी मध्यवर्ती परिणाम देगा:

(reductions + (range 4)) ;; => (0 1 2 3)
(reduce + (range 4))     ;; => 3

कटौती 'परिणाम seq का अंतिम तत्व कम मूल्य होगा। अपने भविष्यवाणी को लागू करने के कई तरीके हैं, उदा। कुछ का उपयोग करके:

(let [sums (reductions + nums)]
  (if (some #(> % 9999) sums)
    10000
    (last sums)))

The reduce/reduced version given by @leonid-beschastny is probably faster (no lazy sequence overhead, reducers, ...) but this one will work in earlier Clojure versions, too.

10
जोड़ा