एफ # - सूची
एफ # में, एक सूची उसी प्रकार के तत्वों की एक क्रमबद्ध, अपरिवर्तनीय श्रृंखला है। यह कुछ हद तक एक लिंक्ड सूची डेटा संरचना के बराबर है।
एफ # मॉड्यूल, Microsoft.FSharp.Collections.List,सूचियों पर आम संचालन है। हालाँकि F # इस मॉड्यूल को स्वचालित रूप से आयात करता है और इसे हर F # एप्लिकेशन के लिए सुलभ बनाता है।
सूची बनाना और आरंभ करना
सूची बनाने के विभिन्न तरीके निम्नलिखित हैं -
सूची का उपयोग करना literals।
का उपयोग करते हुए cons (::) ऑपरेटर।
का उपयोग करते हुए List.init सूची मॉड्यूल की विधि।
कुछ का उपयोग करना syntactic constructs बुलाया List Comprehensions।
सूची का साहित्य
इस विधि में, आप वर्गाकार कोष्ठकों में मानों के अर्धविराम-सीमांकित अनुक्रम को निर्दिष्ट करते हैं। उदाहरण के लिए -
let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]विपक्ष (: :) ऑपरेटर
इस विधि से, आप कुछ मान जोड़कर या जोड़कर देख सकते हैं cons-ingएक मौजूदा सूची में इसका उपयोग :: ऑपरेटर। उदाहरण के लिए -
let list2 = 1::2::3::4::5::6::7::8::9::10::[];;[] एक खाली सूची को दर्शाता है।
सूची विधि
सूची बनाने के लिए सूची मॉड्यूल की List.init विधि का उपयोग अक्सर किया जाता है। इस विधि का प्रकार है -
val init : int -> (int -> 'T) -> 'T listपहला तर्क नई सूची की वांछित लंबाई है, और दूसरा तर्क एक प्रारंभिक कार्य है, जो सूची में आइटम उत्पन्न करता है।
उदाहरण के लिए,
let list5 = List.init 5 (fun index -> (index, index * index, index * index * index))यहां, इंडेक्स फ़ंक्शन सूची बनाता है।
सूची की समझ
सूची बोधक सूची बनाने के लिए प्रयुक्त विशेष वाक्य रचना हैं।
F # लिस्ट कॉम्प्रिहेंशन सिंटैक्स दो रूपों में आता है - रेंज और जनरेटर।
सीमाओं में निर्माण होते हैं - [प्रारंभ .. अंत] और [प्रारंभ .. चरण .. अंत]
उदाहरण के लिए,
let list3 = [1 .. 10]जनरेटर का निर्माण होता है - [संग्रह में x के लिए ... उपज expr]
उदाहरण के लिए,
let list6 = [ for a in 1 .. 10 do yield (a * a) ]के रूप में yield कीवर्ड सूची में एक एकल मान को धक्का देता है, कीवर्ड, yield!, सूची में मूल्यों के संग्रह को धकेलता है।
निम्नलिखित कार्य उपरोक्त विधियों को प्रदर्शित करता है -
उदाहरण
(* using list literals *)
let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
printfn "The list: %A" list1
(*using cons operator *)
let list2 = 1 :: 2 :: 3 :: []
printfn "The list: %A" list2
(* using range constructs*)
let list3 = [1 .. 10]
printfn "The list: %A" list3
(* using range constructs *)
let list4 = ['a' .. 'm']
printfn "The list: %A" list4
(* using init method *)
let list5 = List.init 5 (fun index -> (index, index * index, index * index * index))
printfn "The list: %A" list5
(* using yield operator *)
let list6 = [ for a in 1 .. 10 do yield (a * a) ]
printfn "The list: %A" list6
(* using yield operator *)
let list7 = [ for a in 1 .. 100 do if a % 3 = 0 && a % 5 = 0 then yield a]
printfn "The list: %A" list7
(* using yield! operator *)
let list8 = [for a in 1 .. 3 do yield! [ a .. a + 3 ] ]
printfn "The list: %A" list8जब आप प्रोग्राम को संकलित और निष्पादित करते हैं, तो यह निम्न आउटपुट देता है -
The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The list: [1; 2; 3]
The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The list: ['a'; 'b'; 'c'; 'd'; 'e'; 'f'; 'g'; 'h'; 'i'; 'j'; 'k'; 'l'; 'm']
The list: [(0, 0, 0); (1, 1, 1); (2, 4, 8); (3, 9, 27); (4, 16, 64)]
The list: [1; 4; 9; 16; 25; 36; 49; 64; 81; 100]
The list: [15; 30; 45; 60; 75; 90]
The list: [1; 2; 3; 4; 2; 3; 4; 5; 3; 4; 5; 6]सूची डेटा प्रकार के गुण
निम्न तालिका सूची डेटा प्रकार के विभिन्न गुणों को दिखाती है -
| संपत्ति | प्रकार | विवरण |
|---|---|---|
| सिर | 'टी | पहला तत्व। |
| खाली | 'टी सूची | एक स्थिर संपत्ति जो उपयुक्त प्रकार की एक खाली सूची लौटाती है। |
| खाली है | bool | true यदि सूची में कोई तत्व नहीं है। |
| मद | 'टी | निर्दिष्ट सूचकांक (शून्य-आधारित) पर तत्व। |
| लंबाई | पूर्णांक | तत्वों की संख्या। |
| पूंछ | 'टी सूची | पहले तत्व के बिना सूची। |
निम्न उदाहरण इन गुणों के उपयोग को दर्शाता है -
उदाहरण
let list1 = [ 2; 4; 6; 8; 10; 12; 14; 16 ]
// Use of Properties
printfn "list1.IsEmpty is %b" (list1.IsEmpty)
printfn "list1.Length is %d" (list1.Length)
printfn "list1.Head is %d" (list1.Head)
printfn "list1.Tail.Head is %d" (list1.Tail.Head)
printfn "list1.Tail.Tail.Head is %d" (list1.Tail.Tail.Head)
printfn "list1.Item(1) is %d" (list1.Item(1))जब आप प्रोग्राम को संकलित और निष्पादित करते हैं, तो यह निम्न आउटपुट देता है -
list1.IsEmpty is false
list1.Length is 8
list1.Head is 2
list1.Tail.Head is 4
list1.Tail.Tail.Head is 6
list1.Item(1) is 4सूची पर मूल संचालक
निम्न तालिका सूची डेटा प्रकार पर बुनियादी संचालन दिखाती है -
| मूल्य | विवरण |
|---|---|
| परिशिष्ट: 'टी सूची →' टी सूची → 'टी सूची | एक नई सूची लौटाता है जिसमें पहली सूची के तत्व होते हैं और उसके बाद दूसरे तत्व होते हैं। |
| औसत: 'टी सूची → ^ टी | सूची में तत्वों का औसत लौटाता है। |
| औसतन: ('T → ^ U) →' T सूची → ^ U | सूची के प्रत्येक तत्व में फ़ंक्शन को लागू करके उत्पन्न तत्वों का औसत लौटाता है। |
| चुनें: ('T →' U विकल्प) → 'T सूची →' U सूची | दिए गए फ़ंक्शन को सूची के प्रत्येक तत्व पर लागू करता है। प्रत्येक तत्व के लिए परिणामों में शामिल सूची लौटाता है जहाँ फ़ंक्शन लौटता हैSome। |
| एकत्र: ('टी →' यू सूची) → 'टी सूची →' यू सूची | सूची के प्रत्येक तत्व के लिए, दिए गए फ़ंक्शन को लागू करता है। सभी परिणामों को सम्मिलित करता है और संयुक्त सूची लौटाता है। |
| concat: seq <'T list> →' T सूची | एक नई सूची देता है जिसमें प्रत्येक सूची के तत्व शामिल होते हैं। |
| रिक्त: 'टी सूची | दिए गए प्रकार की एक खाली सूची देता है। |
| मौजूद है: ('टी → बूल) →' टी सूची → बूल | टेस्ट यदि सूची के किसी भी तत्व को दिए गए विधेय को संतुष्ट करता है। |
| मौजूद 2: ('T1 →' T2 → बूल) → 'T1 सूची →' T2 सूची → बूल | यदि सूचियों के संगत तत्वों में से कोई भी युग्म दिए गए विधेय को संतुष्ट करता है। |
| फ़िल्टर: ('टी → बूल) →' टी सूची → 'टी सूची | एक नया संग्रह लौटाता है जिसमें संग्रह के केवल तत्व होते हैं जिसके लिए दिए गए विधेय रिटर्न देता है true। |
| खोजें: ('टी → बूल) →' टी सूची → 'टी | पहला तत्व लौटाता है जिसके लिए दिए गए फ़ंक्शन देता है true। |
| findIndex: ('टी → बूल) →' टी सूची → इंट | सूची में पहले तत्व के सूचकांक को लौटाता है जो दिए गए विधेय को संतुष्ट करता है। |
| गुना: ('राज्य →' टी → 'राज्य) →' राज्य → 'टी सूची →' राज्य | संग्रह के प्रत्येक तत्व के लिए एक फ़ंक्शन लागू करता है, गणना के माध्यम से एक संचायक तर्क को फैलाता है। यह फ़ंक्शन दूसरा तर्क लेता है, और फ़ंक्शन को इसे और सूची के पहले तत्व पर लागू करता है। फिर, यह दूसरे तत्व के साथ फ़ंक्शन में इस परिणाम को पारित करता है, और इसी तरह। अंत में, यह अंतिम परिणाम देता है। यदि इनपुट फ़ंक्शन f है और एलिमेंट्स i0 ... iN हैं, तो यह फ़ंक्शन f (... (fs i0) i1 ...) iN की गणना करता है। |
| fold2: ('State →' T1 → 'T2 →' State) → 'State →' T1 सूची → 'T2 → →' State | संचय के माध्यम से एक संचायक तर्क को फैलाने, दो संग्रह के संबंधित तत्वों के लिए एक फ़ंक्शन लागू करता है। संग्रह में समान आकार होने चाहिए। यदि इनपुट फ़ंक्शन f है और तत्व i0 ... iN और j0 ... jN हैं, तो यह फ़ंक्शन f (... (fs i0 j0) ...) iN jN की गणना करता है। |
| foldBack: ('T →' State → 'State) →' T list → 'State →' स्टेट | संग्रह के प्रत्येक तत्व के लिए एक फ़ंक्शन लागू करता है, गणना के माध्यम से एक संचायक तर्क को फैलाता है। यदि इनपुट फ़ंक्शन isf है और एलिमेंट्स i0 हैं ... iN तब f i0 (... (f iN s)) की गणना करता है। |
| foldBack2: ('T1 →' T2 → 'राज्य →' राज्य) → 'T1 सूची →' T2 सूची → 'राज्य →' राज्य | संचय के माध्यम से एक संचायक तर्क को फैलाने, दो संग्रह के संबंधित तत्वों के लिए एक फ़ंक्शन लागू करता है। संग्रह में समान आकार होने चाहिए। यदि इनपुट फ़ंक्शन f है और एलिमेंट्स i0 ... iN और j0 ... jN हैं, तो यह फ़ंक्शन f i0 j0 (... (f iN jN s)) की गणना करता है। |
| forall: ('टी → बूल) →' टी सूची → बूल | टेस्ट अगर संग्रह के सभी तत्व दिए गए विधेय को संतुष्ट करते हैं। |
| forall2: ('T1 →' T2 → बूल) → 'T1 सूची →' T2 सूची → बूल | टेस्ट यदि संग्रह के सभी संबंधित तत्व दिए गए विधेय को संतुष्ट करते हैं। |
| सिर: 'टी सूची →' टी | सूची का पहला तत्व देता है। |
| init: int → (int → 'T) →' T सूची | प्रत्येक इंडेक्स पर दिए गए जनरेटर को कॉल करके एक सूची बनाता है। |
| isEmpty: 'T सूची → बूल | रिटर्न true यदि सूची में कोई तत्व नहीं है, false अन्यथा। |
| पुनरावृति: ('टी → इकाई) →' टी सूची → इकाई | दिए गए फ़ंक्शन को संग्रह के प्रत्येक तत्व पर लागू करता है। |
| iter2: ('T1 →' T2 → इकाई) → 'T1 सूची →' T2 सूची → इकाई | दिए गए फ़ंक्शन को एक साथ दो संग्रहों पर लागू करता है। संग्रह में समान आकार होना चाहिए। |
| iteri: (int → 'T → unit) →' T सूची → इकाई | दिए गए फ़ंक्शन को संग्रह के प्रत्येक तत्व पर लागू करता है। फ़ंक्शन के लिए दिया गया पूर्णांक तत्व के सूचकांक को इंगित करता है। |
| iteri2: (int → 'T1 →' T2 → इकाई) → 'T1 सूची →' T2 सूची → इकाई | दिए गए फ़ंक्शन को एक साथ दो संग्रहों पर लागू करता है। संग्रह में समान आकार होना चाहिए। फ़ंक्शन के लिए दिया गया पूर्णांक तत्व के सूचकांक को इंगित करता है। |
| लंबाई: 'टी सूची → इंट | सूची की लंबाई लौटाता है। |
| नक्शा: ('T →' U) → 'T सूची →' U सूची | एक नया संग्रह बनाता है जिसके तत्व संग्रह के प्रत्येक तत्व को दिए गए फ़ंक्शन को लागू करने के परिणाम हैं। |
| map2: ('T1 →' T2 → 'U) →' T1 सूची → 'T2 सूची →' U सूची | एक नया संग्रह बनाता है जिसके तत्व दिए गए फ़ंक्शन को दो संग्रह जोड़ी के संगत तत्वों पर लागू करने के परिणाम हैं। |
| map3: ('T1 →' T2 → 'T3 →' U) → 'T1 सूची →' T2 सूची → 'T3 सूची →' U सूची | एक नया संग्रह बनाता है जिसके तत्व दिए गए फ़ंक्शन को तीन संग्रह के संबंधित तत्वों पर एक साथ लागू करने के परिणाम हैं। |
| मापी: (int → 'T →' U) → 'T सूची →' U सूची | एक नया संग्रह बनाता है जिसके तत्व संग्रह के प्रत्येक तत्व को दिए गए फ़ंक्शन को लागू करने के परिणाम हैं। फ़ंक्शन के लिए दिया गया पूर्णांक इंडेक्स तत्व के इंडेक्स (0 से) को इंगित करता है। |
| mapi2: (int → 'T1 →' T2 → 'U) →' T1 सूची → 'T2 सूची →' अंतिम सूची | List.mapi की तरह, लेकिन समान लंबाई की दो सूचियों से संबंधित तत्वों को मैप करना। |
| अधिकतम: 'टी सूची →' टी | ऑपरेटर्समैक्स का उपयोग करके, सूची के सभी तत्वों में से सबसे बड़ा रिटर्न। |
| maxBy: ('T →' U) → 'T सूची →' T | फ़ंक्शन परिणाम पर ऑपरेटर्समैक्स का उपयोग करके, सूची के सभी तत्वों में से सबसे बड़ा रिटर्न देता है। |
| मिनट: 'टी सूची →' टी | ऑपरेटर्स.मिन की तुलना में सूची के सभी तत्वों में से सबसे कम रिटर्न देता है। |
| minBy: ('T →' U) → 'T सूची →' T | फ़ंक्शन परिणाम पर Operators.min का उपयोग करके, सूची के सभी तत्वों के निम्नतम को लौटाता है |
| nth: 'T सूची → int →' T | सूची में शामिल करता है। पहले तत्व में इंडेक्स 0 है। |
| AArray: 'T [] →' T सूची | दी गई सरणी से एक सूची बनाता है। |
| .Seq: seq <'T> →' T सूची | दी गई गणना योग्य वस्तु से एक नई सूची बनाता है। |
| विभाजन: ('टी → बूल) →' टी सूची * 'टी सूची | संग्रह को दो संग्रहों में विभाजित करता है, जिसमें वे तत्व होते हैं जिनके लिए दिए गए विधेय रिटर्न देते हैं true तथा false क्रमशः। |
| परमिट: (int → int) → 'टी सूची →' टी सूची | निर्दिष्ट अनुमति के अनुसार अनुमत सभी तत्वों के साथ एक सूची देता है। |
| पिक: ('टी →' यू विकल्प) → 'टी सूची →' यू | दिए गए फ़ंक्शन को क्रमिक तत्वों पर लागू करता है, पहला परिणाम देता है जहां फ़ंक्शन रिटर्न करता है Some कुछ मूल्य के लिए। |
| कम करें: ('T →' T → 'T) →' T सूची → 'T | संग्रह के प्रत्येक तत्व के लिए एक फ़ंक्शन लागू करता है, गणना के माध्यम से एक संचायक तर्क को फैलाता है। यह फ़ंक्शन सूची के पहले दो तत्वों के लिए निर्दिष्ट फ़ंक्शन को लागू करता है। यह तब तीसरे तत्व के साथ फ़ंक्शन में इस परिणाम को पारित करता है, और इसी तरह। अंत में, यह अंतिम परिणाम देता है। यदि इनपुट फ़ंक्शन f है और तत्व i0 ... iN हैं, तो यह फ़ंक्शन f (... (f i0 i1) i2 ...) iN गणना करता है। |
| कम करें: ('T →' T → 'T) →' T सूची → 'T | संग्रह के प्रत्येक तत्व के लिए एक फ़ंक्शन लागू करता है, गणना के माध्यम से एक संचायक तर्क को फैलाता है। यदि इनपुट फ़ंक्शन isf और तत्व i0 ... iN हैं, तो यह फ़ंक्शन f i0 (... (f iN-1 iN)) की गणना करता है। |
| प्रतिकृति: (int → 'T →' T सूची) | प्रत्येक इंडेक्स पर दिए गए जनरेटर को कॉल करके एक सूची बनाता है। |
| Rev: 'T सूची →' T सूची | रिवर्स ऑर्डर में तत्वों के साथ एक नई सूची देता है। |
| स्कैन: ('राज्य →' टी → 'राज्य) →' राज्य → 'टी सूची →' राज्य सूची | संग्रह के प्रत्येक तत्व के लिए एक फ़ंक्शन लागू करता है, गणना के माध्यम से एक संचायक तर्क को फैलाता है। यह फ़ंक्शन दूसरा तर्क लेता है, और इसे निर्दिष्ट फ़ंक्शन और सूची के पहले तत्व को लागू करता है। फिर, यह इस परिणाम को दूसरे तत्व और इसी के साथ फ़ंक्शन में पास करता है। अंत में, यह मध्यवर्ती परिणामों की सूची और अंतिम परिणाम लौटाता है। |
| स्कैनबैक: ('टी →' राज्य → 'राज्य) →' टी सूची → 'राज्य →' राज्य सूची | फोल्डबैक की तरह, लेकिन इंटरमीडिएट और अंतिम दोनों परिणामों को लौटाता है |
| सॉर्ट: 'टी सूची →' टी सूची | ऑपरेटर्स.कॉम का उपयोग करके दी गई सूची को सॉर्ट करता है। |
| SortBy: ('टी →' की) → 'टी सूची →' टी सूची | दिए गए प्रक्षेपण द्वारा दी गई कुंजियों का उपयोग करके दी गई सूची को सॉर्ट करता है। संचालक की तुलना में की तुलना की जाती है। |
| SortWith: ('T →' T → int) → 'T सूची →' T सूची | दिए गए तुलना फ़ंक्शन का उपयोग करके दी गई सूची को सॉर्ट करता है। |
| योग: ^ टी सूची → ^ टी | सूची में तत्वों का योग लौटाता है। |
| sumBy: ('T → ^ U) →' T सूची → ^ U | सूची के प्रत्येक तत्व में फ़ंक्शन को लागू करके उत्पन्न परिणामों का योग लौटाता है। |
| पूंछ: 'टी सूची →' टी सूची | पहले तत्व के बिना इनपुट सूची देता है। |
| ऐरे: 'टी सूची →' टी [] | दी गई सूची से एक सरणी बनाता है। |
| toSeq: 'T सूची → seq <' T> | अनुक्रम के रूप में दी गई सूची देखें। |
| tryFind: ('T → बूल) →' T सूची → 'T विकल्प | पहला तत्व लौटाता है जिसके लिए दिए गए फ़ंक्शन देता है true। वापसीNone यदि ऐसा कोई तत्व मौजूद नहीं है। |
| tryFindIndex: ('T → बूल) →' T सूची → int विकल्प | सूची में पहले तत्व के सूचकांक को लौटाता है जो दिए गए विधेय को संतुष्ट करता है। वापसीNone यदि ऐसा कोई तत्व मौजूद नहीं है। |
| tryPick: ('T →' U विकल्प) → 'T सूची →' U विकल्प | दिए गए फ़ंक्शन को क्रमिक तत्वों पर लागू करता है, पहला परिणाम देता है जहां फ़ंक्शन रिटर्न करता है Someकुछ मूल्य के लिए। यदि ऐसा कोई तत्व मौजूद नहीं है, तो वापस लौटेंNone। |
| unzip: ('T1 *' T2) सूची → 'T1 सूची *' T2 सूची | दो सूचियों में जोड़े की एक सूची को विभाजित करता है। |
| unzip3: ('T1 *' T2 * 'T3) सूची →' T1 सूची * 'T2 सूची * T3 सूची | तीन सूची में तीनों की सूची को विभाजित करता है। |
| zip: 'T1 सूची →' T2 सूची → ('T1 *' T2) सूची | दो सूचियों को जोड़ियों की सूची में मिलाता है। दो सूचियों की लंबाई समान होनी चाहिए। |
| zip3: 'T1 सूची →' T2 सूची → 'T3 सूची → (' T1 * 'T2 *' सूची '3) | तीनों सूचियों को त्रिगुणों की सूची में मिलाता है। सूचियों की लंबाई समान होनी चाहिए। |
निम्नलिखित उदाहरण उपरोक्त क्रियाओं के उपयोग को प्रदर्शित करते हैं -
उदाहरण 1
यह कार्यक्रम एक सूची को पुनरावर्ती रूप से दिखाता है -
let list1 = [ 2; 4; 6; 8; 10; 12; 14; 16 ]
printfn "The original list: %A" list1
let reverse lt =
let rec loop acc = function
| [] -> acc
| hd :: tl -> loop (hd :: acc) tl
loop [] lt
printfn "The reversed list: %A" (reverse list1)जब आप प्रोग्राम को संकलित और निष्पादित करते हैं, तो यह निम्न आउटपुट देता है -
The original list: [2; 4; 6; 8; 10; 12; 14; 16]
The reversed list: [16; 14; 12; 10; 8; 6; 4; 2]हालाँकि, आप इसका उपयोग कर सकते हैं rev इसी उद्देश्य के लिए मॉड्यूल का कार्य -
let list1 = [ 2; 4; 6; 8; 10; 12; 14; 16 ]
printfn "The original list: %A" list1
printfn "The reversed list: %A" (List.rev list1)जब आप प्रोग्राम को संकलित और निष्पादित करते हैं, तो यह निम्न आउटपुट देता है -
The original list: [2; 4; 6; 8; 10; 12; 14; 16]
The reversed list: [16; 14; 12; 10; 8; 6; 4; 2]उदाहरण 2
यह प्रोग्राम सूची का उपयोग करके सूची को फ़िल्टर करने को दर्शाता है List.filter विधि -
let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
printfn "The list: %A" list1
let list2 = list1 |> List.filter (fun x -> x % 2 = 0);;
printfn "The Filtered list: %A" list2जब आप प्रोग्राम को संकलित और निष्पादित करते हैं, तो यह निम्न आउटपुट देता है -
The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The Filtered list: [2; 4; 6; 8; 10]उदाहरण 3
List.map विधि सूची को एक प्रकार से दूसरे प्रकार में मैप करती है -
let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
printfn "The list: %A" list1
let list2 = list1 |> List.map (fun x -> (x * x).ToString());;
printfn "The Mapped list: %A" list2जब आप प्रोग्राम को संकलित और निष्पादित करते हैं, तो यह निम्न आउटपुट देता है -
The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The Mapped list: ["1"; "4"; "9"; "16"; "25"; "36"; "49"; "64"; "81"; "100"]उदाहरण 4
List.append विधि और @ ऑपरेटर एक सूची को दूसरे में जोड़ता है -
let list1 = [1; 2; 3; 4; 5 ]
let list2 = [6; 7; 8; 9; 10]
let list3 = List.append list1 list2
printfn "The first list: %A" list1
printfn "The second list: %A" list2
printfn "The appened list: %A" list3
let lt1 = ['a'; 'b';'c' ]
let lt2 = ['e'; 'f';'g' ]
let lt3 = lt1 @ lt2
printfn "The first list: %A" lt1
printfn "The second list: %A" lt2
printfn "The appened list: %A" lt3जब आप प्रोग्राम को संकलित और निष्पादित करते हैं, तो यह निम्न आउटपुट देता है -
The first list: [1; 2; 3; 4; 5]
The second list: [6; 7; 8; 9; 10]
The appened list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The first list: ['a'; 'b'; 'c']
The second list: ['e'; 'f'; 'g']
The appened list: ['a'; 'b'; 'c'; 'e'; 'f'; 'g']उदाहरण 5
List.sortविधि एक सूची बनाती है। List.sum विधि सूची में तत्वों का योग देती है और List.average विधि सूची में तत्वों का औसत देती है -
let list1 = [9.0; 0.0; 2.0; -4.5; 11.2; 8.0; -10.0]
printfn "The list: %A" list1
let list2 = List.sort list1
printfn "The sorted list: %A" list2
let s = List.sum list1
let avg = List.average list1
printfn "The sum: %f" s
printfn "The average: %f" avgजब आप प्रोग्राम को संकलित और निष्पादित करते हैं, तो यह निम्न आउटपुट देता है -
The list: [9.0; 0.0; 2.0; -4.5; 11.2; 8.0; -10.0]
The sorted list: [-10.0; -4.5; 0.0; 2.0; 8.0; 9.0; 11.2]
The sum: 15.700000
The average: 2.242857"तह" ऑपरेशन एक सूची में प्रत्येक तत्व के लिए एक फ़ंक्शन लागू करता है, फ़ंक्शन के परिणाम को एक संचयकर्ता चर में एकत्र करता है, और संचयकर्ता को गुना ऑपरेशन के परिणामस्वरूप वापस करता है।
उदाहरण 6
List.fold विधि प्रत्येक तत्व को बाएँ से दाएँ, जबकि तक एक फ़ंक्शन लागू करती है List.foldBack प्रत्येक तत्व को दाईं से बाईं ओर एक फ़ंक्शन लागू करता है।
let sumList list = List.fold (fun acc elem -> acc + elem) 0 list
printfn "Sum of the elements of list %A is %d." [ 1 .. 10 ] (sumList [ 1 .. 10 ])जब आप प्रोग्राम को संकलित और निष्पादित करते हैं, तो यह निम्न आउटपुट देता है -
Sum of the elements of list [1; 2; 3; 4; 5; 6; 7; 8; 9; 10] is 55.