common-lisp
सूचियों पर मानचित्रण कार्य
खोज…
अवलोकन
एक या अधिक सूचियों के तत्वों के लिए एक फ़ंक्शन लागू करने के लिए, कॉमन लिस्प में उच्च-स्तरीय मैपिंग फ़ंक्शन का एक सेट उपलब्ध है। वे उस तरीके से भिन्न होते हैं जिसमें फ़ंक्शन को सूचियों पर लागू किया जाता है और अंतिम परिणाम कैसे प्राप्त किया जाता है। निम्न तालिका भिन्नरूपों को संक्षेप में प्रस्तुत करती है और उनमें से प्रत्येक के लिए समान एलओओपी रूप दिखाती है। f लागू किया जाने वाला कार्य है, जिसमें सूचियों की संख्या के बराबर कई तर्क होने चाहिए; "कार पर लागू" का अर्थ है कि यह सूचियों के तत्वों के बदले में लागू होता है, "cdr पर लागू होता है" का अर्थ है कि यह सूचियों, उनके सीडीआर, उनके cddr, आदि के बदले में लागू किया जाता है; "रिटर्न" कॉलम दिखाता है कि यदि वैश्विक परिणाम परिणामों को सूचीबद्ध करके प्राप्त किया जाता है, तो उन्हें संक्षिप्त करना (ताकि उन्हें सूचियां होनी चाहिए!), या बस साइड-इफेक्ट्स के लिए उपयोग किया जाता है (और इस मामले में पहली सूची वापस आ जाती है)।
| समारोह | पर लागू किया गया | रिटर्न | समतुल्य ऋण |
|---|---|---|---|
| (मैपकार fl 1 … l n ) | गाड़ी | परिणामों की सूची | (पाश के लिए एक्स 1 एल 1 में ... एक्स के लिए n l में n कलेक्ट (fx 1 ... एक्स एन)) |
| (मानचित्र सूची fl 1 … l n ) | सीडीआर | परिणामों की सूची | (एल 1 पर एक्स 1 के लिए पाश ... एक्स के लिए n l पर n कलेक्ट (fx 1 ... एक्स एन)) |
| (मैपकेन फ्लै 1 … एल एन ) | गाड़ी | नतीजों का सिलसिला | (पाश के लिए एक्स 1 एल 1 में ... एक्स के लिए n l n nconc में (fx 1 ... एक्स एन)) |
| (मैपकॉन fl 1 … l n ) | सीडीआर | नतीजों का सिलसिला | (एल 1 पर एक्स 1 के लिए पाश ... एक्स के लिए n l n nconc पर (fx 1 ... एक्स एन)) |
| (नक्शा 1 fl… l n ) | गाड़ी | एल 1 | (l में x 1 के लिए लूप 1 … x n में l n do (fx 1 … x n ) के लिए अंत में (वापसी l 1 )) |
| (मेपल fl 1 … l n ) | सीडीआर | एल 1 | (एल 1 पर एक्स 1 के लिए पाश ... एक्स के लिए n l पर n करना (fx 1 ... n एक्स) अंत में (वापसी एल 1)) |
ध्यान दें, सभी मामलों में, सूची अलग-अलग लंबाई की हो सकती है, और सबसे छोटी सूची समाप्त होने पर आवेदन समाप्त हो जाता है।
मानचित्र कार्यों का एक और जोड़े को उपलब्ध हैं: 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)
