लूप के लिए क्लोजर, सेट को सेट या मानचित्र में

Question

यह मुझे थोड़ी देर के लिए परेशान कर रहा है, हमें लूप में किसी सेट या मानचित्र में मूल्य कैसे स्टोर करना चाहिए?

(let [s #{}] 
    (for [ i (range 10) 
      j (range 10) ] 
     (into s [i j]))) 

मुझे पता है यह काम नहीं करेगा, लेकिन मैं एक कार्यक्षमता इस के समान है, जहां सेट अंत में शामिल होंगे चाहते [0 0] [0 1] ... [0 9] [1 0] .. । [9 9]

धन्यवाद

Answer 1

अगर मैं आपके सवाल का सही ढंग से समझ है कि आप अपने अभिव्यक्ति चालू करने की आवश्यकता के अंदर-आउट:

(let [s #{}] 
    (into s (for [i (range 10) 
       j (range 10)] 
      [i j]))) 

बात यहाँ है महसूस करने के लिए कि for जावा और सी

Answer 2

clojure परिवर्तनशील राज्य के प्रबंधन के लिए एक कई महान प्रणाली है। इस मामले में आप चाहते हैं एक atom एक सेट से युक्त हो सकता है

अपने अन्य विकल्प हैं:

• एक ref यदि एक से अधिक परिवर्तन (कई धागे समन्वित)
• एक var अगर यह हो जाएगा बनाया करने की जरूरत है एकल थ्रेड (एक वर बस के रूप में अच्छी तरह से यहाँ एक परमाणु के रूप में काम कर सकते हैं)
• एक agent अगर आप

एसिंक्रोनस रूप से मूल्य निर्धारित करने के लिए करना चाहता था

पाठ्यक्रम for एक दृश्य देता है पहले से ही ऐसा तुम सिर्फ चाहते हो सकता है

(into #{} (for [ i (range 10) 
        j (range 10) ] 
      [i j])) 

Answer 3

जैसी अधिक अनिवार्य भाषाओं में फॉर-लूप के विपरीत एक मान (आलसी अनुक्रम) देता है, क्या यह आप चाहते हैं?

(into #{} (for [i (range 10) j (range 10)] 
    [i j])) 
;-> #{[2 1] [3 2] [4 3] [5 4] [6 5] [7 6] [8 7] [9 8] [1 0] 
;  [2 2] [3 3] [4 4] [5 5] [6 6]... 

और तुम सिर्फ एक सेट के रूप में सूची चाहते हैं:

(set (for [i (range 10) j (range 10)] 
    [i j]))  

आप जोड़ों का एक समूह के साथ खत्म हो जाएगा।

Answer 4

आम तौर पर आप loop/recur से एक सेट या एक नक्शा या अन्य 'एकल मान' है कि एक seq पर एक 'बार-बार' सामान्यीकृत आपरेशन से एक seq नहीं है वापस जाने के लिए, का उपयोग कर reduce अधिक मुहावरेदार है/सरल चाहते हैं, और for हमेशा एक सीक (एक सेट या मानचित्र नहीं) देता है।

(reduce conj #{} (for [i (range 10) j (range 10)] [i j])) 

ध्यान दें कि (के लिए ..) यहाँ केवल एक seq सभी मूल्यों से युक्त एकल परिणाम सेट में संकलित करने के लिए उत्पादन किया जाता है। या, उदाहरण के लिए:

(reduce + 0 (range 100)) 
=> 4950 

Answer 5

मुझे लगता है कि आप इस परिदृश्य में कुछ क्षणिक डेटा संरचना का भी उपयोग कर सकते हैं।

(let [s (transient #{})] 
(for [ i (range 10) 
     j (range 10) ] 
    (assoc! s i j))) 
(persistent! s) 

बस एक कोड नमूना, परीक्षण नहीं किया गया।