क्लोजर में 2 डी सरणी का उपयोग करने के लिए उचित फॉर्म और प्रत्येक सेल

Question

(लिस्प शुरुआतकर्ता) मुझे 2 डी सरणी बनाने और सरणी में प्रत्येक सेल को प्रारंभ करने की आवश्यकता है। प्रत्येक सेल को एक फ़ंक्शन के साथ प्रारंभ किया जाता है जो पिछले सेल में डेटा पर आधारित होता है। इसलिए 0,1 के रूप में सेल को उस फ़ंक्शन के परिणामस्वरूप प्रारंभ किया जाएगा जो सेल 0,0 से डेटा का उपयोग करता है, और इसी तरह।

मैं सोच रहा था कि इस तरह की डेटा संरचना स्थापित करने के लिए उचित क्लोजर मुहावरे क्या है।

Answer 1

आपकी सरणी का प्रतिनिधित्व वास्तव में इसे उपयोग करने की आवश्यकता पर निर्भर करता है, इसे प्रारंभ नहीं करता है। उदाहरण के लिए, यदि आप घने मैट्रिक्स है, तो आप सबसे शायद वैक्टर की वेक्टर इस तरह उपयोग करना चाहिए:

[[0, 1, 2, 3, 4], 
[5, 6, 7, 8, 9], 
[9, 8, 7, 6, 5], 
[4, 3, 2, 1, 0], 
[0, 1, 2, 3, 4]] 

या कच्चे लंबाई पर कुछ अतिरिक्त जानकारी के साथ एकल वेक्टर:

{:length 5 
:data 
[0, 1, 2, 3, 4, 
5, 6, 7, 8, 9, 
9, 8, 7, 6, 5, 
4, 3, 2, 1, 0, 
0, 1, 2, 3, 4] 
} 

और यदि आप विरल जरूरत मैट्रिक्स, आप hash-map s का उपयोग कर सकते हैं:

{0 {0 0, 4 4}, 
2 {2 7}, 
3 {0 4, 2 2}} 

(के बाद से अपने 2 डी सरणी छोटा है और आप पिछले एक के आधार पर अगले मूल्य उत्पन्न करते हैं, मेरा मानना ​​है कि पहले विकल्प बेहतर सूट है आपके लिए डी)।

यदि आप बहुत सारे मैट्रिक्स-विशिष्ट मैनिप्लेशंस (गुणा, अपघटन, आदि) बनाने जा रहे हैं तो आप Incanter जैसे कुछ मौजूदा पुस्तकालयों का उपयोग करना चाह सकते हैं।

और भरने के लिए के रूप में, मेरे प्रस्ताव transients का उपयोग करें और अंतरिम परिणामों, यानी (एक आयामी वेक्टर के लिए) स्टोर करने के लिए है:

(defn make-array [initial-value f length] 
    (loop [result (transient []), length-left length, interim-value initial-value] 
    (if (= length-left 0) 
     (persistent! result) 
     (recur (conj! result (f interim-value)) (- length-left 1) (f interim-value)))) 

यात्रियों प्रत्येक नए तत्व पर नया डेटा संरचना बनाने से बचना होगा, और अंतरिम मूल्य क्षणिक संरचना से पिछले तत्व को पढ़ने में आवश्यकता से बच जाएगा।

Answer 2

मुझे नहीं पता कि यह एक बुरी तकनीक है, लेकिन मैंने 2 डी "सरणी" निर्दिष्ट करने के लिए हैश (या आमतौर पर आदेश दिया गया) मानचित्र का उपयोग किया है। वे इस तरह का निर्माण करते हैं:

{ [x y] value ... } 

इस पर विपक्ष हैं क्योंकि आपको किसी भी तरह सरणी की सीमा निर्दिष्ट करना है। और संभवतः यह फ़ेसर्स पोस्ट में वर्णित सीधे वेक्टर प्रस्तुतियों की तुलना में बहुत धीमी है।