उदाहरण 1: गोलांग स्लाइस को आरोही क्रम में क्रमबद्ध करें
'सॉर्ट.स्लाइस()' फ़ंक्शन गो में सबसे महत्वपूर्ण फ़ंक्शन है जो स्लाइस के तत्वों को आरोही क्रम या अवरोही क्रम में पुनर्व्यवस्थित करता है। निम्नलिखित चित्रण को ध्यान में रखें जहां स्लाइस को आरोही क्रम में व्यवस्थित किया गया है:
पैकेट मुख्यआयात (
'एफएमटी'
'क्रम से लगाना'
)
समारोह मुख्य () {
समस्लाइस := [] int यहाँ { 10 , 2 , 8 , 4 , 0 , 6 }
एफएमटी . Println ( 'बिना क्रमबद्ध टुकड़ा:' , समस्लाइस )
क्रम से लगाना . टुकड़ा ( समस्लाइस , समारोह ( मैं , जे int यहाँ ) बूल {
वापस करना समस्लाइस [ मैं ] < समस्लाइस [ जे ]
})
एफएमटी . Println ( 'क्रमबद्ध टुकड़ा:' , समस्लाइस )
}
मुख्य() फ़ंक्शन की शुरुआत में, हम {10, 2, 8, 4, 0, 6} मानों के साथ ईवनस्लाइस स्लाइस को परिभाषित करते हैं। यह स्लाइस उन सम संख्याओं के संग्रह का प्रतिनिधित्व करता है जो प्रारंभ में क्रमबद्ध नहीं हैं। इवनस्लाइस स्लाइस को सॉर्ट करने के लिए, sort.Slice() फ़ंक्शन को स्लाइस के साथ नियोजित किया जाता है। sort.Slice() फ़ंक्शन के अंदर, एक सॉर्टिंग फ़ंक्शन एक तर्क के रूप में प्रदान किया जाता है। यह फ़ंक्शन स्लाइस के दो तत्वों की 'i' और 'j' सूचकांकों पर तुलना करके सॉर्टिंग क्रम निर्धारित करता है। यदि ईवनस्लाइस[i], ईवनस्लाइस[जे] से कम है, तो यह सत्य लौटाता है; अन्यथा, यह गलत रिटर्न देता है। सॉर्ट.स्लाइस() फ़ंक्शन 'इवनस्लाइस' स्लाइस के तत्वों को आरोही क्रम में पुनर्व्यवस्थित करने के लिए इस तुलना फ़ंक्शन का उपयोग करता है।
आरोही क्रम में क्रमबद्ध स्लाइस के परिणाम निम्नलिखित आउटपुट स्क्रीन में उत्पन्न होते हैं:
उदाहरण 2: गोलांग सॉर्ट पार्ट स्लाइस
इसके बाद, गो में sort.Slice() फ़ंक्शन का उपयोग करके सॉर्टिंग को आरोही क्रम में निर्दिष्ट स्लाइस के उप-स्लाइस पर लागू किया जाता है।
पैकेट मुख्य
आयात (
'एफएमटी'
'क्रम से लगाना'
)
समारोह मुख्य () {
एन := [] int यहाँ { 9 , 7 , 3 , 5 }
शुरू := 0
अंत := 3
क्रम से लगाना . टुकड़ा ( एन [ शुरू : अंत ], समारोह ( मैं , जे int यहाँ ) बूल {
वापस करना एन [ शुरू + मैं ] < एन [ शुरू + जे ]
})
एफएमटी . Println ( एन )
}
प्रारंभ में, हम [9, 7, 3, 5] मानों के साथ 'एन' स्लाइस बनाते हैं। इसके अतिरिक्त, दो चर, 'प्रारंभ' और 'अंत', क्रमशः 0 और 3 पर सेट हैं। ये चर 'एन' स्लाइस में सूचकांकों की सीमा को परिभाषित करते हैं जिन्हें क्रमबद्ध किया जाएगा। फिर 'सॉर्ट.स्लाइस()' फ़ंक्शन को पहले तर्क के रूप में उप-स्लाइस 'एन[स्टार्ट:एंड]' के साथ बुलाया जाता है। इस उप-स्लाइस में निर्दिष्ट सीमा के भीतर 'n' के तत्व शामिल हैं। उसके बाद, sort.Slice() फ़ंक्शन के अंदर दूसरे तर्क के रूप में एक सॉर्टिंग फ़ंक्शन दिया जाता है।
यहां, उस फ़ंक्शन को दो सूचकांक, 'i' और 'j' प्राप्त होते हैं, जो उप-स्लाइस के भीतर तत्वों का प्रतिनिधित्व करते हैं। उप-स्लाइस के भीतर तत्वों की तुलना करने के लिए, सॉर्टिंग फ़ंक्शन प्रारंभ का उपयोग करके मूल स्लाइस में संबंधित तत्वों तक पहुंचता है। ऑफसेट। यह n[start+i] और n[start+j] की तुलना करता है। इसके बाद, sort.Slice() फ़ंक्शन उप-स्लाइस के भीतर तत्वों को आरोही क्रम में पुनर्व्यवस्थित करने के लिए दिए गए सॉर्टिंग फ़ंक्शन का उपयोग करता है।
निम्नलिखित आउटपुट प्रदर्शित करता है कि निर्दिष्ट सीमा (प्रारंभ से अंत-1) के भीतर के तत्वों को क्रमबद्ध किया गया है, और सीमा के बाहर के तत्व अपरिवर्तित रहते हैं:
उदाहरण 3: Sort.Ints() फ़ंक्शन का उपयोग करके गोलांग सॉर्ट पूर्णांक स्लाइस
इसके अलावा, कस्टम सॉर्टिंग विधियों को लागू करने की आवश्यकता के बिना पूर्णांकों के स्लाइस को सॉर्ट करने के लिए सबसे सुविधाजनक sort.Ints() फ़ंक्शन है। यह सीधे पूर्णांक स्लाइस पर कार्य करता है और इन-प्लेस सॉर्टिंग करता है। निम्नलिखित प्रोग्राम निर्दिष्ट पूर्णांकों को सॉर्ट करता है:
पैकेट मुख्यआयात (
'एफएमटी'
'क्रम से लगाना'
)
समारोह मुख्य () {
इंटस्लाइस := [] int यहाँ { 10 , 13 , पंद्रह , ग्यारह , 14 , 12 }
एफएमटी . Println ( 'बिना क्रमबद्ध टुकड़ा:' , इंटस्लाइस )
क्रम से लगाना . Ints ( इंटस्लाइस )
एफएमटी . Println ( 'क्रमबद्ध टुकड़ा:' , इंटस्लाइस )
}
सबसे पहले, हम 'इंटस्लाइस' स्लाइस को [10, 13, 15, 11, 14, 12] मानों के साथ घोषित और आरंभ करते हैं जो शुरू में अव्यवस्थित पूर्णांकों के संग्रह का प्रतिनिधित्व करते हैं। फिर, sort.Ints() फ़ंक्शन को 'IntSlice' स्लाइस के साथ 'IntSlice' को सॉर्ट करने के तर्क के रूप में कॉल किया जाता है। इस मामले में sort.Ints() फ़ंक्शन एक अनुकूलित सॉर्टिंग एल्गोरिदम के अनुसार स्लाइस के प्रत्येक भाग को आंतरिक रूप से सॉर्ट करता है। यह मूल स्लाइस को सीधे संशोधित करता है, उसके तत्वों को क्रमबद्ध क्रम में पुनर्व्यवस्थित करता है।
निम्नलिखित आउटपुट पहले दिखाता है कि अवर्गीकृत स्लाइस पहले प्रदर्शित होता है, उसके बाद क्रमबद्ध स्लाइस प्रदर्शित होता है:
उदाहरण 4: गोलांग सॉर्ट स्ट्रिंग स्लाइस
गो सॉर्ट पैकेज का sort.Strings() फ़ंक्शन भी प्रदान करता है जिसका उपयोग एक विशिष्ट क्रम में स्ट्रिंग्स के स्लाइस को सॉर्ट करने के लिए किया जाता है। यहां, निम्नलिखित प्रोग्राम स्ट्रिंग्स के स्लाइस को सॉर्ट करने में सहायता करता है:
पैकेट मुख्यआयात (
'एफएमटी'
'क्रम से लगाना'
)
समारोह मुख्य () {
एसटीआरएसएल := [] डोरी { 'गोलान' , 'अजगर' , 'जावा' , 'पर्ल' , 'टाइपस्क्रिप्ट' }
क्रम से लगाना . स्ट्रिंग्स ( एसटीआरएसएल )
एफएमटी . Println ( एसटीआरएसएल )
}
हमने सबसे पहले 'strSl' स्लाइस को ['गोलंग', 'पायथन', 'जावा', 'पर्ल', 'टाइपस्क्रिप्ट'] मानों के साथ स्थापित किया, जिन्हें क्रमबद्ध नहीं किया गया है। उसके बाद, हम 'strSl' स्लाइस को sort.Strings() फ़ंक्शन के साथ सॉर्ट करते हैं जो स्लाइस के तत्वों को लेक्सिकोग्राफ़िक क्रम में सॉर्ट करता है। यह फ़ंक्शन मूल स्लाइस को सीधे संशोधित करता है, इसके तत्वों को उनके ASCII मानों के आधार पर क्रमबद्ध क्रम में पुनर्व्यवस्थित करता है।
आउटपुट स्ट्रिंग स्लाइस को आरोही तरीके से सॉर्ट करता है जैसा कि निम्नलिखित में दिखाया गया है:
उदाहरण 5: IntAreSort() फ़ंक्शन का उपयोग करके गोलांग चेक सॉर्ट स्लाइस
हालाँकि, Go के sort.IntsAreSorted() फ़ंक्शन के साथ, हम जांच सकते हैं कि पूर्णांकों का दिया गया टुकड़ा आरोही क्रम में क्रमबद्ध है या नहीं। दिए गए स्लाइस के लिए IntAreSort() फ़ंक्शन के निम्नलिखित उदाहरण प्रोग्राम पर विचार करें:
पैकेट मुख्यआयात (
'एफएमटी'
'क्रम से लगाना'
)
समारोह मुख्य () {
क्र := [] int यहाँ { - 33 , 105 , - 42 , 59 , 18 , 0 , - 3 }
एफएमटी . Println ( 'स्लाइस:' )
एफएमटी . Println ( 'अनसॉर्टेड स्लाइस:' , क्र )
परिणाम := क्रम से लगाना . IntsAreSorted ( क्र )
एफएमटी . Println ( ' \एन परिणाम:' )
एफएमटी . Println ( 'क्या दिया गया स्लाइस क्रमबद्ध है?:' , परिणाम )
}
सबसे पहले, यादृच्छिक पूर्णांकों के एक अवर्गीकृत टुकड़े को 'sl' के रूप में परिभाषित किया गया है। इस स्लाइस में बिना किसी विशेष क्रम के पूर्णांकों का संग्रह है। इसके बाद, हम sort.IntsAreSorted() फ़ंक्शन को कॉल करते हैं और 'sl' स्लाइस को एक तर्क के रूप में पास करते हैं। यह फ़ंक्शन एक बूलियन परिणाम प्रदान करता है जो इंगित करता है कि स्लाइस इनपुट आरोही क्रम में व्यवस्थित है या नहीं। फिर, fmt.Println() फ़ंक्शन परिणामों को प्रिंट करता है जो आउटपुट करता है कि दिए गए स्लाइस को लौटाए गए बूलियन मान के आधार पर सॉर्ट किया गया है या नहीं।
पूर्णांकों के एक टुकड़े के क्रमबद्ध क्रम के लिए आउटपुट गलत प्रदर्शित होता है क्योंकि यह क्रमबद्ध नहीं है:
उदाहरण 6: गोलांग रिवर्स सॉर्ट स्लाइस
इसके अलावा, गो में सॉर्ट पैकेज से सॉर्टरिवर्स() और सॉर्टस्ट्रिंगस्लाइस() फ़ंक्शंस का उपयोग करके, हम स्ट्रिंग्स के एक स्लाइस को रिवर्स-सॉर्ट कर सकते हैं। निम्नलिखित प्रोग्राम सॉर्ट.रिवर्स() फ़ंक्शन के कार्य को प्रदर्शित करता है:
पैकेट मुख्यआयात (
'एफएमटी'
'क्रम से लगाना'
)
समारोह मुख्य () {
स्वरस्लाइस := [] डोरी { 'यह है' , 'ए' , 'मैं' , 'में' , 'ओ' }
एफएमटी . Println ( 'छँटाई से पहले:' , स्वरस्लाइस )
क्रम से लगाना . क्रम से लगाना ( क्रम से लगाना . उलटना ( क्रम से लगाना . स्ट्रिंगस्लाइस ( स्वरस्लाइस )))
एफएमटी . Println ( 'सॉर्टिंग के बाद:' , स्वरस्लाइस )
}
हम 'स्वरस्लाइस' स्ट्रिंग के एक टुकड़े को परिभाषित करके शुरू करते हैं जिसमें स्वर 'ई', 'ए', 'आई', 'यू', और 'ओ' शामिल हैं। स्ट्रिंग के निर्दिष्ट स्लाइस की प्रारंभिक सामग्री को पहले 'प्रिंट' फ़ंक्शन का उपयोग करके मुद्रित किया जाता है। इसके बाद, सॉर्टिंग ऑपरेशन सॉर्ट.सॉर्ट() फ़ंक्शन का उपयोग करके सॉर्ट.रिवर्स() और सॉर्ट.स्ट्रिंगस्लाइस() फ़ंक्शन को तर्क के रूप में किया जाता है। यहां, 'सॉर्ट.रिवर्स()' एक नया प्रकार बनाता है जो तत्वों के क्रम को उलट देता है। यह 'sort.StringSlice' प्रकार को अपने तर्क के रूप में लेता है जो स्वरस्लाइस को एक क्रमबद्ध प्रकार में परिवर्तित करता है।
यहां आउटपुट स्वरों को उल्टे वर्णमाला क्रम में प्रदर्शित करता है:
निष्कर्ष
हमने दिए गए स्लाइस को सॉर्ट करने वाले उदाहरणों के साथ विभिन्न सॉर्टिंग फ़ंक्शंस की गहराई से जांच की। हमने उप-स्लाइस की छँटाई और यह जाँचने के बारे में भी बताया कि क्या कोई टुकड़ा पहले से ही छँटा हुआ है। इसलिए, हम उनके गो प्रोजेक्ट्स में सॉर्टिंग चुनौतियों की एक विस्तृत श्रृंखला से निपटने के लिए सॉर्ट पैकेज की क्षमताओं का लाभ उठा सकते हैं।