Erlang 21 - 3. List Comprehensions

3 सूची बोध




erlang

3 सूची बोध

3.1 सरल उदाहरण

यह खंड एक साधारण उदाहरण के साथ शुरू होता है, एक जनरेटर और एक फिल्टर दिखा रहा है:

> [X || X <- [1,2,a,3,4,b,5,6], X > 3].
[a,4,b,5,6]

इसे निम्नानुसार पढ़ा जाता है: X की सूची ऐसी है कि X को सूची से लिया गया है [1,2,a,...] और X 3 से अधिक है।

नोटेशन X <- [1,2,a,...] एक जनरेटर है और एक्सप्रेशन X > 3 एक फिल्टर है।

integer(X) के परिणाम को प्रतिबंधित करने के लिए एक अतिरिक्त फ़िल्टर, integer(X) जोड़ा जा सकता है:

> [X || X <- [1,2,a,3,4,b,5,6], integer(X), X > 3].
[4,5,6]

जेनरेटर को जोड़ा जा सकता है। उदाहरण के लिए, दो सूचियों के कार्टेशियन उत्पाद को निम्नानुसार लिखा जा सकता है:

> [{X, Y} || X <- [1,2,3], Y <- [a,b]].
[{1,a},{1,b},{2,a},{2,b},{3,a},{3,b}]

3.2 त्वरित सॉर्ट करें

प्रसिद्ध त्वरित क्रमबद्ध दिनचर्या निम्नानुसार लिखी जा सकती है:

sort([Pivot|T]) ->
    sort([ X || X <- T, X < Pivot]) ++
    [Pivot] ++
    sort([ X || X <- T, X >= Pivot]);
sort([]) -> [].

एक्सप्रेशन [X || X <- T, X < Pivot] [X || X <- T, X < Pivot] T में उन सभी तत्वों की सूची है जो Pivot से कम हैं।

[X || X <- T, X >= Pivot] [X || X <- T, X >= Pivot] T में उन सभी तत्वों की सूची है जो [X || X <- T, X >= Pivot] से अधिक या उसके बराबर हैं।

एक सूची इस प्रकार है:

  • सूची में पहले तत्व को अलग किया गया है और सूची को दो उपविदों में विभाजित किया गया है।
  • पहले सबलिस्ट में वे सभी तत्व होते हैं जो सूची में पहले तत्व से छोटे होते हैं।
  • दूसरी सबलिस्ट में वे सभी तत्व होते हैं जो सूची में पहले तत्व से अधिक या उसके बराबर होते हैं।
  • फिर सब्लिस्ट्स को सॉर्ट किया जाता है और परिणाम संयुक्त होते हैं।

3.3 क्रमपरिवर्तन

निम्नलिखित उदाहरण सूची में तत्वों के सभी क्रमपरिवर्तन को उत्पन्न करता है:

perms([]) -> [[]];
perms(L)  -> [[H|T] || H <- L, T <- perms(L--[H])].

यह सभी संभावित तरीकों से L से H लेता है। परिणाम सभी सूचियों का सेट है [H|T] , जहां T , H साथ L के सभी संभावित क्रमपरिवर्तन का समूह है:

> perms([b,u,g]).
[[b,u,g],[b,g,u],[u,b,g],[u,g,b],[g,b,u],[g,u,b]]

३.४ पायथागोरियन ट्रिपल

पायथागॉरियन ट्रिपल्स पूर्णांक {A,B,C} सेट हैं जैसे कि A**2 + B**2 = C**2

फ़ंक्शन pyth(N) सभी पूर्णांकों {A,B,C} की एक सूची बनाता है जैसे कि A**2 + B**2 = C**2 और जहाँ पक्षों का योग बराबर या उससे कम हो, N :

pyth(N) ->
    [ {A,B,C} ||
        A <- lists:seq(1,N),
        B <- lists:seq(1,N),
        C <- lists:seq(1,N),
        A+B+C =< N,
        A*A+B*B == C*C 
    ].
> pyth(3).
[].
> pyth(11).
[].
> pyth(12).
[{3,4,5},{4,3,5}]
> pyth(50).
[{3,4,5},
 {4,3,5},
 {5,12,13},
 {6,8,10},
 {8,6,10},
 {8,15,17},
 {9,12,15},
 {12,5,13},
 {12,9,15},
 {12,16,20},
 {15,8,17},
 {16,12,20}]

निम्न कोड खोज स्थान को कम करता है और अधिक कुशल होता है:

pyth1(N) ->
   [{A,B,C} ||
       A <- lists:seq(1,N-2),
       B <- lists:seq(A+1,N-1),
       C <- lists:seq(B+1,N),
       A+B+C =< N,
       A*A+B*B == C*C ].

3.5 सूची बोध के साथ सरलीकरण

एक उदाहरण के रूप में, सूची lists.erl का उपयोग सूची में कुछ कार्यों को सरल बनाने के लिए किया जा सकता है:

append(L)   ->  [X || L1 <- L, X <- L1].
map(Fun, L) -> [Fun(X) || X <- L].
filter(Pred, L) -> [X || X <- L, Pred(X)].

3.6 सूची बोध में परिवर्तनशील बंधन

सूची समझ में आने वाले चरों के लिए गुंजाइश नियम इस प्रकार हैं:

  • एक जनरेटर पैटर्न में होने वाले सभी चर को "ताजा" चर माना जाता है।
  • कोई भी चर जो सूची बोध से पहले परिभाषित किया गया है, और जो फ़िल्टर में उपयोग किया जाता है, वे मूल्य हैं जो सूची समझ से पहले थे।
  • चर को सूची बोध से निर्यात नहीं किया जा सकता है।

इन नियमों के एक उदाहरण के रूप में, मान लें कि आप फ़ंक्शन का select करना चाहते select , जो ट्यूपल्स की सूची से कुछ तत्वों का चयन करता है। मान लें कि आप select(X, L) -> [Y || {X, Y} <- L]. select(X, L) -> [Y || {X, Y} <- L]. L से सभी टुपल्स निकालने के इरादे से, जहां पहला आइटम X

इसका संकलन निम्नलिखित निदान देता है:

./FileName.erl:Line: Warning: variable 'X' shadowed in generate

यह डायग्नोस्टिक चेतावनी देता है कि पैटर्न X में वेरिएबल X वैसा नहीं है जैसा कि फंक्शन हेड में होता है।

select मूल्यांकन निम्नलिखित परिणाम देता है:

> select(b,[{a,1},{b,2},{c,3},{b,7}]).
[1,2,3,7]

यह वांछित परिणाम नहीं है। वांछित प्रभाव को प्राप्त करने के लिए, निम्नानुसार लिखना होगा:

select(X, L) ->  [Y || {X1, Y} <- L, X == X1].

जनरेटर में अब अनबाउंड वैरिएबल हैं और परीक्षण को फ़िल्टर में स्थानांतरित कर दिया गया है।

यह अब उम्मीद के मुताबिक काम करता है:

> select(b,[{a,1},{b,2},{c,3},{b,7}]).
[2,7]

चर को सूची बोध में आयात करने के नियमों का एक परिणाम यह है कि कुछ निश्चित रूप से मेल खाने वाले संचालन को फ़िल्टर में ले जाना चाहिए और जनरेटर में सीधे नहीं लिखा जा सकता है।

इसे समझने के लिए, इस प्रकार लिखें:

f(...) ->
    Y = ...
    [ Expression || PatternInvolving Y  <- Expr, ...]
    ...

इसके बजाय, इस प्रकार लिखें:

f(...) ->
    Y = ...
    [ Expression || PatternInvolving Y1  <- Expr, Y == Y1, ...]
    ...