common-lisp
सूचियों पर मानचित्रण कार्य

अवलोकन

एक या अधिक सूचियों के तत्वों के लिए एक फ़ंक्शन लागू करने के लिए, कॉमन लिस्प में उच्च-स्तरीय मैपिंग फ़ंक्शन का एक सेट उपलब्ध है। वे उस तरीके से भिन्न होते हैं जिसमें फ़ंक्शन को सूचियों पर लागू किया जाता है और अंतिम परिणाम कैसे प्राप्त किया जाता है। निम्न तालिका भिन्नरूपों को संक्षेप में प्रस्तुत करती है और उनमें से प्रत्येक के लिए समान एलओओपी रूप दिखाती है। f लागू किया जाने वाला कार्य है, जिसमें सूचियों की संख्या के बराबर कई तर्क होने चाहिए; "कार पर लागू" का अर्थ है कि यह सूचियों के तत्वों के बदले में लागू होता है, "cdr पर लागू होता है" का अर्थ है कि यह सूचियों, उनके सीडीआर, उनके cddr, आदि के बदले में लागू किया जाता है; "रिटर्न" कॉलम दिखाता है कि यदि वैश्विक परिणाम परिणामों को सूचीबद्ध करके प्राप्त किया जाता है, तो उन्हें संक्षिप्त करना (ताकि उन्हें सूचियां होनी चाहिए!), या बस साइड-इफेक्ट्स के लिए उपयोग किया जाता है (और इस मामले में पहली सूची वापस आ जाती है)।

ध्यान दें, सभी मामलों में, सूची अलग-अलग लंबाई की हो सकती है, और सबसे छोटी सूची समाप्त होने पर आवेदन समाप्त हो जाता है।

मानचित्र कार्यों का एक और जोड़े को उपलब्ध हैं: map , कि दृश्यों (तार, वैक्टर, सूचियों), के अनुरूप करने के लिए लागू किया जा सकता mapcar , और उस क्रम में किसी भी प्रकार लौट सकते हैं, पहला तर्क के रूप में निर्दिष्ट है, और map-into , के अनुरूप map , लेकिन यह विनाशकारी रूप से फ़ंक्शन के अनुप्रयोग के परिणामों को रखने के लिए अपने पहले अनुक्रम तर्क को संशोधित करता है।

MAPCAR के उदाहरण हैं

MAPCAR परिवार का सबसे अधिक इस्तेमाल किया जाने वाला कार्य है:

CL-USER> (mapcar #'1+ '(1 2 3))
(2 3 4)
CL-USER> (mapcar #'cons '(1 2 3) '(a b c))
((1 . A) (2 . B) (3 . C))
CL-USER> (mapcar (lambda (x y z) (+ (* x y) z)) 
                 '(1 2 3) 
                 '(10 20 30) 
                 '(100 200 300))
(110 240 390)
CL-USER> (let ((list '(a b c d e f g h i))) ; randomize this list
           (mapcar #'cdr
                   (sort (mapcar (lambda (x)
                                   (cons (random 100) x))
                                 list)
                         #'<=
                         :key #'car)))
(I D A G B H E C F)

mapcar का एक मुहावरेदार उपयोग एक मैट्रिक्स को सूचियों की सूची के रूप में प्रस्तुत करना है:

CL-USER> (defun transpose (list-of-lists)
           (apply #'mapcar #'list list-of-lists))
ROTATE
CL-USER> (transpose '((a b c) (d e f) (g h i)))
((A D G) (B E H) (C F I))

;  +---+---+---+               +---+---+---+
;  | A | B | C |               | A | D | G |
;  +---+---+---+               +---+---+---+
;  | D | E | F |    becomes    | B | E | H |
;  +---+---+---+               +---+---+---+
;  | G | H | I |               | C | F | I |
;  +---+---+---+               +---+---+---+

स्पष्टीकरण के लिए, यह उत्तर देखें।

MAPLIST के उदाहरण हैं

CL-USER> (maplist (lambda (list) (cons 0 list)) '(1 2 3 4))
((0 1 2 3 4) (0 2 3 4) (0 3 4) (0 4))
CL-USER> (maplist #'append
                  '(a b c d -)
                  '(1 2 3))
((A B C D - 1 2 3) (B C D - 2 3) (C D - 3))

MAPCAN और MAPCON के उदाहरण हैं

MAPCAN:

CL-USER> (mapcan #'reverse '((1 2 3) (a b c) (100 200 300)))
(3 2 1 C B A 300 200 100)
CL-USER> (defun from-to (min max)
           (loop for i from min to max collect i))
FROM-TO
CL-USER> (from-to 1 5)
(1 2 3 4 5)
CL-USER> (mapcan #'from-to '(1 2 3) '(5 5 5))
(1 2 3 4 5 2 3 4 5 3 4 5)

MAPCAN के उपयोगों में से एक NIL मूल्यों के बिना एक परिणाम सूची बनाना है:

CL-USER> (let ((l1 '(10 20 40)))
           (mapcan (lambda (x)
                     (if (member x l1)
                         (list x)
                       nil))
                   '(2 4 6 8 10 12 14 16 18 20
                     18 16 14 12 10 8 6 4 2)))
(10 20 10)

MAPCON:

CL-USER> (mapcon #'copy-list '(1 2 3))
(1 2 3 2 3 3)
CL-USER> (mapcon (lambda (l1 l2) (list (length l1) (length l2))) '(a b c d) '(d e f))
(4 3 3 2 2 1)

MAPC और MAPL के उदाहरण हैं

MAPC:

CL-USER> (mapc (lambda (x) (print (* x x))) '(1 2 3 4))

1 
4 
9 
16 
(1 2 3 4)
CL-USER> (let ((sum 0))
           (mapc (lambda (x y) (incf sum (* x y)))
                 '(1 2 3)
                 '(100 200 300))
           sum)
1400  ; => (1 x 100) + (2 x 200) + (3 x 300)

MAPL:

CL-USER> (mapl (lambda (list) (print (reduce #'+ list))) '(1 2 3 4 5))

15 
14 
12 
9 
5 
(1 2 3 4 5)