6
मैं सूचियों की सूची का हस्तांतरण करने के लिए एक पुनरावर्ती कार्य करने की कोशिश कर रहा हूं, n x p
से p x n
। लेकिन मैं ऐसा करने में असमर्थ हूं। मैं एक n x 3
एक करने के लिए सूची का एक 3 x n
सूची स्थानांतरित करने के लिए एक समारोह बनाने के लिए सक्षम किया गया है:सूचियों की सूची का हस्तांतरण
let rec drop1 list=
[(match (List.nth list 0) with [] -> [] | a::b -> b);
(match (List.nth list 1) with [] -> [] | a::b -> b);
(match (List.nth list 2) with [] -> [] | a::b -> b);]
let rec transpose list=
if List.length (List.nth list 0) == 0 then []
else [(match (List.nth list 0) with [] -> 0 | a::b -> a);
(match (List.nth list 1) with [] -> 0 | a::b -> a);
(match (List.nth list 2) with [] -> 0 | a::b -> a)]
:: transpose (drop1 list)
लेकिन मैं इसे सामान्य करने में सक्षम नहीं हूँ। मैं निश्चित रूप से गलत दिशा में सोच रहा हूँ। क्या यह सामान्य है? क्या कोई बेहतर समाधान है? कृपया मदद करे।
+1, वाह! मैं List.map फ़ंक्शन से अवगत नहीं था। मैनुअल का कहना है कि यह पूंछ-रिकर्सिव नहीं है। यदि मैं इसे एक बड़े कोड में उपयोग करता हूं तो इसका क्या प्रभाव हो सकता है? – lalli
@lalli: बहुत बड़ी सूचियों के लिए यह एक ढेर अतिप्रवाह का कारण बन सकता है। उस स्थिति में, आपको इसके बजाय 'List.rev_map' का उपयोग करना चाहिए और फिर अंत में सूचियों के माध्यम से जाना चाहिए और उन्हें उलट देना चाहिए। ध्यान दें कि 'ट्रांसपोज़' की मेरी परिभाषा भी पूंछ रिकर्सिव नहीं है (न ही आपका है)। – sepp2k
आपको पहले पूंछ-रिकर्सिविटी के बारे में चिंता नहीं करना चाहिए; एक सरल और स्पष्ट कार्यान्वयन करने का प्रयास करें। बहुत बड़ी सूचियों के साथ "एक सूची सूची" पर "ट्रांसपोज़" फ़ंक्शन का उपयोग करना शायद वैसे भी एक बहुत बुरा विचार है। यदि आपके पास बहुत अधिक डेटा है, तो एक अन्य डेटा संरचना (उदाहरण के लिए (int * int) द्वारा अनुक्रमित एक मैट्रिक्स, जिसमें निरंतर समय 'ट्रांज़ेक्शन' फ़ंक्शन है) शायद अधिक उपयुक्त है। – gasche