Perl Language
छंटाई

परिचय

वाक्य - विन्यास

• सॉबनाम सूची को सॉर्ट करें
• सॉर्ट ब्लॉक सूची
• तरह

बेसिक लेक्सिकल सॉर्ट

@sorted = sort @list;

@sorted = sort { $a cmp $b } @list;

sub compare { $a cmp $b }
@sorted = sort compare @list;

ऊपर दिए गए तीन उदाहरण बिल्कुल एक ही काम करते हैं। आप किसी भी तुलनित्र समारोह या ब्लॉक की आपूर्ति नहीं करते हैं, तो sort आप चाहते हैं अपने दाईं ओर की सूची lexically हल कर रखती है। यह आमतौर पर वह रूप है जो आप चाहते हैं, यदि आपको केवल कुछ पूर्वानुमानित क्रम में अपने डेटा की आवश्यकता है और भाषाई शुद्धता के बारे में परवाह नहीं है।

sort @list में आइटमों की @list को तुलनित्र फ़ंक्शन में देता है, जो sort करता है कि कौन सा आइटम बड़ा है। cmp ऑपरेटर स्ट्रिंग्स के लिए ऐसा करता है जबकि <=> संख्याओं के लिए यही काम करता है। तुलनित्र को अक्सर कहा जाता है, औसत n * लॉग ( n ) बार n के साथ तत्वों की संख्या को छांटा जाता है, इसलिए यह महत्वपूर्ण है कि यह तेज़ हो। यही कारण है sort का उपयोग करता है पैकेज वैश्विक चर पूर्वनिर्धारित ( $a और $b ) तत्वों पारित करने के लिए ब्लॉक या समारोह की तुलना में हो सकता है, उचित समारोह मापदंडों के बजाय।

यदि आप use locale , cmp खाते में स्थान विशिष्ट मिलान आदेश लेता है, जैसे यह सॉर्ट जाएगा Å तरह A एक डेनिश स्थान के तहत लेकिन बाद Z एक अंग्रेजी या जर्मन एक के तहत। हालाँकि, यह अधिक जटिल यूनिकोड छँटाई के नियमों को ध्यान में नहीं रखता है और न ही यह आदेश पर कोई नियंत्रण प्रदान करता है - उदाहरण के लिए फोन की किताबें अक्सर शब्दकोशों से अलग तरह से क्रमबद्ध होती हैं। उन मामलों के लिए, Unicode::Collate और विशेष रूप से Unicode::Collate::Locale मॉड्यूल की सिफारिश की जाती है।

न्यूमेरिक सॉर्ट

@sorted = sort { $a <=> $b } @list;

<=> ऑपरेटर के साथ $a और $b की तुलना करना सुनिश्चित करता है कि उनकी तुलना संख्यात्मक रूप से की जाती है और मूल रूप से डिफ़ॉल्ट रूप से नहीं।

क्रमबद्ध उलट

@sorted = sort { $b <=> $a } @list;
@sorted = reverse sort { $a <=> $b } @list;

अवरोही क्रम में छंटनी की वस्तुओं को तुलनित्र ब्लॉक में $a और $b स्वैप करके आसानी से प्राप्त किया जा सकता है। हालांकि, कुछ लोग थोड़ा धीमे होने के बावजूद एक अलग reverse की स्पष्टता पसंद करते हैं।

श्वार्टज़ियन ट्रांसफ़ॉर्म

यह शायद पर्ल के कार्यात्मक प्रोग्रामिंग सुविधाओं का उपयोग करने के लिए एक सॉर्ट ऑप्टिमाइज़ेशन का सबसे प्रसिद्ध उदाहरण है, जिसका उपयोग करने के लिए जहां वस्तुओं का क्रम एक महंगे फ़ंक्शन पर निर्भर करता है।

# What you would usually do
@sorted = sort { slow($a) <=> slow($b) } @list;

# What you do to make it faster
@sorted =
map { $_->[0] }
sort { $a->[1] <=> $b->[1] }
map { [ $_, slow($_) ] }
@list;

पहले उदाहरण के साथ परेशानी यह है कि तुलनित्र को बहुत बार बुलाया जाता है और धीमी गति से फ़ंक्शन का उपयोग करके पुनरावर्ती मूल्यों को रखता है। एक विशिष्ट उदाहरण उनके फ़ाइल आकार द्वारा फ़ाइल नामों को छाँटना होगा:

use File::stat;
@sorted = sort { stat($a)->size <=> stat($b)->size } glob "*";

यह काम करता है, लेकिन सबसे अच्छी तरह से यह प्रति तुलना में दो सिस्टम कॉल के ओवरहेड को उकसाता है, कम से कम इसे डिस्क पर जाना पड़ता है, दो बार, हर एक तुलना के लिए, और वह डिस्क दूसरी तरफ एक ओवरलोड फ़ाइल सर्वर में हो सकती है ग्रह।

रान्डेल श्वार्ट्ज की चाल दर्ज करें।

श्वार्ट्ज़ियन ट्रांसफ़ॉर्म मूल रूप से तीन कार्यों, निचले-से-ऊपर के माध्यम से @list को @list । पहला map प्रत्येक प्रविष्टि को मूल आइटम की दो-तत्व सूची में और एक धीमी कुंजी के रूप में धीमी गति से कार्य करता है, इसलिए इसके अंत में हमने slow() को प्रत्येक तत्व के लिए एक बार कहा है। फिर निम्न sort सूची में देख कर क्रमबद्ध कुंजी को एक्सेस कर सकता है। जैसा कि हम सॉर्ट कुंजी के बारे में परवाह नहीं करते हैं, लेकिन केवल क्रमबद्ध क्रम में मूल तत्वों की आवश्यकता होती है, अंतिम map दो तत्वों की सूची को पहले से ही सॉर्ट की गई सूची @sort से प्राप्त करता है और केवल उनके पहले सदस्यों की सूची देता है। ।

केस असंवेदनशील क्रमबद्ध

sort अनदेखी करने की पारंपरिक तकनीक है कि तुलना के लिए lc या uc स्ट्रिंग्स पास करें:

@sorted = sort { lc($a) cmp lc($b) } @list;

यह पर्ल 5 के सभी संस्करणों पर काम करता है और अंग्रेजी के लिए पूरी तरह से पर्याप्त है; इससे कोई फर्क नहीं पड़ता कि आप uc या lc उपयोग करते हैं। हालाँकि, यह ग्रीक या तुर्की जैसी भाषाओं के लिए एक समस्या प्रस्तुत करता है जहाँ ऊपरी और निचले अक्षरों के बीच कोई 1: 1 पत्राचार नहीं होता है, इसलिए आपको अलग-अलग परिणाम मिलते हैं, जो इस बात पर निर्भर करते हैं कि आप uc या lc उपयोग करते हैं। इसलिए, पर्ल 5.16 और उच्चतर में एक केस फोल्डिंग फ़ंक्शन होता है जिसे fc कहा जाता है जो इस समस्या से बचा जाता है, इसलिए आधुनिक बहुभाषी छँटाई का उपयोग करना चाहिए:

@sorted = sort { fc($a) cmp fc($b) } @list;