LISP - सूची

पारंपरिक LISP में सूचियाँ सबसे महत्वपूर्ण और प्राथमिक समग्र डेटा संरचना थीं। वर्तमान दिन का आम LISP अन्य डेटा संरचनाएं प्रदान करता है, जैसे कि वेक्टर, हैश टेबल, कक्षाएं या संरचनाएं।

सूची एकल लिंक की गई सूची है। एलआईएसपी में, सूचियों का निर्माण एक सरल रिकॉर्ड संरचना के नाम से किया जाता हैcons आपस मे जुड़े हैं।

विपक्ष रिकॉर्ड संरचना

ए cons एक रिकॉर्ड संरचना है जिसमें दो घटक होते हैं जिन्हें कहा जाता है car और यह cdr.

विपक्ष कोशिकाएं या विपक्ष ऑब्जेक्ट हैं जो फ़ंक्शन का उपयोग करके बनाए गए मानों के जोड़े हैं cons.

consफ़ंक्शन दो तर्क लेता है और दो मूल्यों वाले एक नए कॉन्स सेल देता है। ये मूल्य किसी भी प्रकार की वस्तु के संदर्भ हो सकते हैं।

यदि दूसरा मान शून्य नहीं है, या अन्य कंसोल सेल है, तो मान को कोष्ठक द्वारा संलग्न बिंदीदार जोड़ी के रूप में मुद्रित किया जाता है।

एक आम कोशिका में दो मान कहलाते हैं car और यह cdr. car फ़ंक्शन का उपयोग पहले मान और एक्सेस करने के लिए किया जाता है cdr फ़ंक्शन का उपयोग दूसरे मान तक पहुंचने के लिए किया जाता है।

उदाहरण

Main.lisp नाम से एक नया सोर्स कोड फ़ाइल बनाएँ और उसमें निम्न कोड टाइप करें।

(write (cons 1 2))
(terpri)
(write (cons 'a 'b))
(terpri)
(write (cons 1 nil))
(terpri)
(write (cons 1 (cons 2 nil)))
(terpri)
(write (cons 1 (cons 2 (cons 3 nil))))
(terpri)
(write (cons 'a (cons 'b (cons 'c nil))))
(terpri)
(write ( car (cons 'a (cons 'b (cons 'c nil)))))
(terpri)
(write ( cdr (cons 'a (cons 'b (cons 'c nil)))))

जब आप कोड निष्पादित करते हैं, तो यह निम्न परिणाम देता है -

(1 . 2)
(A . B)
(1)
(1 2)
(1 2 3)
(A B C)
A
(B C)

ऊपर दिए गए उदाहरण से पता चलता है कि कैसे एक एकल लिंक की गई सूची बनाने के लिए विपक्ष संरचनाओं का उपयोग किया जा सकता है, उदाहरण के लिए, सूची (एबीसी) में तीन सीडी कोशिकाएं होती हैं जो एक साथ अपने सीडीआर द्वारा जुड़ी होती हैं ।

आरेखीय रूप से, इसे इस प्रकार व्यक्त किया जा सकता है -

LISP में सूचीबद्ध है

हालाँकि, सूची बनाने के लिए cons कोशिकाओं का उपयोग किया जा सकता है, हालाँकि, नेस्टेड में से एक सूची का निर्माण consफ़ंक्शन कॉल सबसे अच्छा समाधान नहीं हो सकता है। list फ़ंक्शन का उपयोग LISP में सूची बनाने के लिए किया जाता है।

सूची फ़ंक्शन किसी भी संख्या में तर्क ले सकता है और जैसा कि यह एक फ़ंक्शन है, यह अपने तर्कों का मूल्यांकन करता है।

first तथा restफ़ंक्शंस पहले तत्व और सूची के बाकी हिस्से को देते हैं। निम्नलिखित उदाहरण अवधारणाओं को प्रदर्शित करते हैं।

उदाहरण 1

Main.lisp नाम से एक नया सोर्स कोड फ़ाइल बनाएँ और उसमें निम्न कोड टाइप करें।

(write (list 1 2))
(terpri)
(write (list 'a 'b))
(terpri)
(write (list 1 nil))
(terpri)
(write (list 1 2 3))
(terpri)
(write (list 'a 'b 'c))
(terpri)
(write (list 3 4 'a (car '(b . c)) (* 4 -2)))
(terpri)
(write (list (list 'a 'b) (list 'c 'd 'e)))

जब आप कोड निष्पादित करते हैं, तो यह निम्न परिणाम देता है -

(1 2)
(A B)
(1 NIL)
(1 2 3)
(A B C)
(3 4 A B -8)
((A B) (C D E))

उदाहरण 2

Main.lisp नाम से एक नया सोर्स कोड फ़ाइल बनाएँ और उसमें निम्न कोड टाइप करें।

(defun my-library (title author rating availability)
   (list :title title :author author :rating rating :availabilty availability)
)

(write (getf (my-library "Hunger Game" "Collins" 9 t) :title))

जब आप कोड निष्पादित करते हैं, तो यह निम्न परिणाम देता है -

"Hunger Game"

सूची हेरफेर कार्य

निम्न तालिका कुछ आमतौर पर इस्तेमाल की जाने वाली सूची हेरफेर कार्यों को प्रदान करती है।

अनु क्रमांक।	समारोह विवरण
1	car यह एक सूची को तर्क के रूप में लेता है, और इसका पहला तत्व देता है।
2	cdr यह एक सूची को तर्क के रूप में लेता है, और पहले तत्व के बिना एक सूची देता है
3	cons यह दो तर्क लेता है, एक तत्व और एक सूची और पहले स्थान पर डाले गए तत्व के साथ एक सूची देता है।
4	list यह किसी भी संख्या में तर्क लेता है और सूची के सदस्य तत्वों के रूप में तर्कों के साथ एक सूची देता है।
5	append यह दो या अधिक सूची को एक में मिला देता है।
6	last यह एक सूची लेता है और एक सूची देता है जिसमें अंतिम तत्व होता है।
7	member यह दो तर्क लेता है, जिनमें से एक दूसरी सूची होना चाहिए, यदि पहला तर्क दूसरे तर्क का सदस्य है, और फिर यह पहले तर्क के साथ शुरू होने वाली सूची के शेष को लौटाता है।
8	reverse यह एक सूची लेता है और रिवर्स ऑर्डर में शीर्ष तत्वों के साथ एक सूची देता है।

कृपया ध्यान दें कि सभी अनुक्रम कार्य सूचियों पर लागू होते हैं।

उदाहरण 3

Main.lisp नाम से एक नया सोर्स कोड फ़ाइल बनाएँ और उसमें निम्न कोड टाइप करें।

(write (car '(a b c d e f)))
(terpri)
(write (cdr '(a b c d e f)))
(terpri)
(write (cons 'a '(b c)))
(terpri)
(write (list 'a '(b c) '(e f)))
(terpri)
(write (append '(b c) '(e f) '(p q) '() '(g)))
(terpri)
(write (last '(a b c d (e f))))
(terpri)
(write (reverse '(a b c d (e f))))

जब आप कोड निष्पादित करते हैं, तो यह निम्न परिणाम देता है -

A
(B C D E F)
(A B C)
(A (B C) (E F))
(B C E F P Q G)
((E F))
((E F) D C B A)

कार और सीडीआर कार्यों का संयोजन

car तथा cdr फ़ंक्शन और उनका संयोजन किसी सूची के किसी विशेष तत्व / सदस्य को निकालने की अनुमति देता है।

हालाँकि, कार और cdr फंक्शंस के सीक्वेंस को अक्षर c के लिए कार और d के लिए अक्षर c और r के भीतर संक्षिप्त करके संक्षिप्त किया जा सकता है।

उदाहरण के लिए, हम फ़ंक्शन कॉल के अनुक्रम को संक्षिप्त करने के लिए कैडडर लिख सकते हैं - कार सीडीआर कार सीडीआर।

इस प्रकार, (कैड्राड ((सीडी)) (एफईजी)) डी वापस आ जाएगी

उदाहरण 4

Main.lisp नाम से एक नया सोर्स कोड फ़ाइल बनाएँ और उसमें निम्न कोड टाइप करें।

(write (cadadr '(a (c d) (e f g))))
(terpri)
(write (caar (list (list 'a 'b) 'c)))   
(terpri)
(write (cadr (list (list 1 2) (list 3 4))))
(terpri)

जब आप कोड निष्पादित करते हैं, तो यह निम्न परिणाम देता है -

D
A
(3 4)