எடுத்துக்காட்டு 1: கோலாங் ஸ்லைஸை ஏறுவரிசையில் வரிசைப்படுத்தவும்
“sort.Slice()” செயல்பாடானது Go இல் முதன்மையான செயல்பாடாகும், இது ஸ்லைஸின் உறுப்புகளை ஏறுவரிசையில் அல்லது இறங்கு வரிசையில் மறுசீரமைக்கிறது. ஸ்லைஸ் ஏறுவரிசையில் அமைக்கப்பட்டிருக்கும் பின்வரும் விளக்கத்தை கணக்கில் எடுத்துக்கொள்ளவும்:
தொகுப்பு முக்கியஇறக்குமதி (
'fmt'
'வகைபடுத்து'
)
செயல்பாடு முக்கிய () {
கூட துண்டு := [] முழு எண்ணாக { 10 , 2 , 8 , 4 , 0 , 6 }
fmt . Println ( 'வரிசைப்படுத்தப்படாத துண்டு:' , கூட துண்டு )
வகைபடுத்து . துண்டு ( கூட துண்டு , செயல்பாடு ( நான் , ஜே முழு எண்ணாக ) பூல் {
திரும்ப கூட துண்டு [ நான் ] < கூட துண்டு [ ஜே ]
})
fmt . Println ( 'வரிசைப்படுத்தப்பட்ட துண்டு:' , கூட துண்டு )
}
பிரதான() செயல்பாட்டின் தொடக்கத்தில், ஈவ்ஸ்லைஸ் ஸ்லைஸை {10, 2, 8, 4, 0, 6} மதிப்புகளுடன் வரையறுக்கிறோம். இந்த ஸ்லைஸ் ஆரம்பத்தில் வரிசைப்படுத்தப்படாத இரட்டை எண்களின் தொகுப்பைக் குறிக்கிறது. ஈவ்ஸ்லைஸ் ஸ்லைஸை வரிசைப்படுத்த, ஸ்லைஸுடன் சோர்ட்.ஸ்லைஸ்() செயல்பாடு பயன்படுத்தப்படுகிறது. sort.Slice() செயல்பாட்டின் உள்ளே, வரிசைப்படுத்தும் செயல்பாடு ஒரு வாதமாக வழங்கப்படுகிறது. இந்தச் செயல்பாடு ஸ்லைஸின் இரண்டு கூறுகளை “i” மற்றும் “j” குறியீடுகளில் ஒப்பிடுவதன் மூலம் வரிசையாக்க வரிசையைத் தீர்மானிக்கிறது. evenSlice[i] evenSlice[j] ஐ விட குறைவாக இருந்தால், அது உண்மையாக இருக்கும்; இல்லையெனில், அது தவறானது. 'evenSlice' ஸ்லைஸின் கூறுகளை ஏறுவரிசையில் மறுசீரமைக்க sort.Slice() செயல்பாடு இந்த ஒப்பீட்டு செயல்பாட்டைப் பயன்படுத்துகிறது.
ஏறுவரிசையில் வரிசைப்படுத்தப்பட்ட துண்டுகளின் முடிவுகள் பின்வரும் வெளியீட்டுத் திரையில் உருவாக்கப்படுகின்றன:
எடுத்துக்காட்டு 2: கோலாங் வரிசை பகுதி துண்டு
அடுத்து, குறிப்பிட்ட ஸ்லைஸின் துணை ஸ்லைஸில் வரிசைப்படுத்துதல், Go இல் உள்ள sort.Slice() செயல்பாட்டைப் பயன்படுத்தி ஏறுவரிசையில் பயன்படுத்தப்படுகிறது.
தொகுப்பு முக்கிய
இறக்குமதி (
'fmt'
'வகைபடுத்து'
)
செயல்பாடு முக்கிய () {
n := [] முழு எண்ணாக { 9 , 7 , 3 , 5 }
தொடங்கு := 0
முடிவு := 3
வகைபடுத்து . துண்டு ( n [ தொடங்கு : முடிவு ], செயல்பாடு ( நான் , ஜே முழு எண்ணாக ) பூல் {
திரும்ப n [ தொடங்கு + நான் ] < என் [ தொடங்கு + ஜே ]
})
fmt . Println ( n )
}
ஆரம்பத்தில், [9, 7, 3, 5] மதிப்புகளுடன் “n” ஸ்லைஸை உருவாக்குகிறோம். கூடுதலாக, இரண்டு மாறிகள், 'தொடக்கம்' மற்றும் 'முடிவு', முறையே 0 மற்றும் 3 என அமைக்கப்பட்டுள்ளன. இந்த மாறிகள் 'n' ஸ்லைஸில் வரிசைப்படுத்தப்படும் குறியீடுகளின் வரம்பை வரையறுக்கின்றன. 'sort.Slice()' செயல்பாடு, 'n[start:end]' என்ற துணை ஸ்லைஸுடன் முதல் வாதமாக அழைக்கப்படுகிறது. இந்த துணை ஸ்லைஸில் குறிப்பிடப்பட்ட வரம்பிற்குள் 'n' கூறுகள் உள்ளன. அதன் பிறகு, sort.Slice() செயல்பாட்டிற்குள் இரண்டாவது வாதமாக ஒரு வரிசைப்படுத்தல் செயல்பாடு வழங்கப்படுகிறது.
இங்கே, அந்தச் செயல்பாடு “i” மற்றும் “j” ஆகிய இரண்டு குறியீடுகளைப் பெறுகிறது, அவை துணை ஸ்லைஸில் உள்ள உறுப்புகளைக் குறிக்கின்றன. துணை ஸ்லைஸில் உள்ள உறுப்புகளை ஒப்பிட, வரிசையாக்க செயல்பாடு தொடக்கத்தைப் பயன்படுத்தி அசல் ஸ்லைஸில் உள்ள தொடர்புடைய உறுப்புகளை அணுகுகிறது. ஆஃப்செட். இது n[start+i] மற்றும் n[start+j] ஐ ஒப்பிடுகிறது. அடுத்து, sort.Slice() செயல்பாடு, துணை ஸ்லைஸில் உள்ள உறுப்புகளை ஏறுவரிசையில் மறுசீரமைக்க வழங்கப்பட்ட வரிசையாக்க செயல்பாட்டைப் பயன்படுத்துகிறது.
பின்வரும் வெளியீடு குறிப்பிட்ட வரம்பிற்குள் உள்ள உறுப்புகள் (தொடக்கம் முதல் முடிவு-1 வரை) வரிசைப்படுத்தப்பட்டிருப்பதையும், வரம்பிற்கு வெளியே உள்ள உறுப்புகள் மாறாமல் இருப்பதையும் காட்டுகிறது:
எடுத்துக்காட்டு 3: Sort.Ints() செயல்பாட்டைப் பயன்படுத்தி கோலாங் முழு எண் துண்டுகளை வரிசைப்படுத்தவும்
மேலும், முழு எண்களின் துண்டுகளை வரிசைப்படுத்த மிகவும் வசதியானது தனிப்பயன் வரிசையாக்க முறைகளை செயல்படுத்த வேண்டிய அவசியமின்றி sort.Ints() செயல்பாடு ஆகும். இது முழு எண் துண்டுகளில் நேரடியாக செயல்படுகிறது மற்றும் ஒரு இடத்தில் வரிசைப்படுத்துகிறது. பின்வரும் நிரல் குறிப்பிட்ட முழு எண்களை வரிசைப்படுத்துகிறது:
தொகுப்பு முக்கியஇறக்குமதி (
'fmt'
'வகைபடுத்து'
)
செயல்பாடு முக்கிய () {
IntSlice := [] முழு எண்ணாக { 10 , 13 , பதினைந்து , பதினொரு , 14 , 12 }
fmt . Println ( 'வரிசைப்படுத்தப்படாத துண்டு:' , IntSlice )
வகைபடுத்து . Ints ( IntSlice )
fmt . Println ( 'வரிசைப்படுத்தப்பட்ட துண்டு:' , IntSlice )
}
முதலில், ஆரம்பத்தில் வரிசைப்படுத்தப்படாத முழு எண்களின் தொகுப்பைக் குறிக்கும் [10, 13, 15, 11, 14, 12] மதிப்புகளுடன் “IntSlice” ஸ்லைஸை அறிவித்து துவக்குவோம். பின்னர், sort.Ints() செயல்பாடு 'IntSlice' ஐ வரிசைப்படுத்த ஒரு வாதமாக 'IntSlice' ஸ்லைஸுடன் அழைக்கப்படுகிறது. இந்த வழக்கில் உள்ள sort.Ints() செயல்பாடு, ஸ்லைஸின் ஒவ்வொரு பகுதியையும் உகந்த வரிசையாக்க வழிமுறையின்படி வரிசைப்படுத்துகிறது. இது அசல் ஸ்லைஸை நேரடியாக மாற்றியமைக்கிறது, அதன் உறுப்புகளை வரிசைப்படுத்தப்பட்ட வரிசையில் மறுசீரமைக்கிறது.
பின்வரும் வெளியீடு முதலில் வரிசைப்படுத்தப்படாத ஸ்லைஸ் காட்டப்படும், அதைத் தொடர்ந்து வரிசைப்படுத்தப்பட்ட ஸ்லைஸ் காட்டப்படும்:
எடுத்துக்காட்டு 4: கோலாங் வரிசை சரம் துண்டு
Go ஆனது வரிசைப்படுத்தல் தொகுப்பின் sort.Strings() செயல்பாட்டையும் வழங்குகிறது, இது ஒரு குறிப்பிட்ட வரிசையில் சரங்களின் ஸ்லைஸை வரிசைப்படுத்தப் பயன்படுகிறது. இங்கே, பின்வரும் நிரல் சரங்களின் துண்டுகளை வரிசைப்படுத்த உதவுகிறது:
தொகுப்பு முக்கியஇறக்குமதி (
'fmt'
'வகைபடுத்து'
)
செயல்பாடு முக்கிய () {
strSl := [] லேசான கயிறு { 'கோலன்' , 'மலைப்பாம்பு' , 'ஜாவா' , 'பெர்ல்' , 'டைப்ஸ்கிரிப்ட்' }
வகைபடுத்து . சரங்கள் ( strSl )
fmt . Println ( strSl )
}
வரிசைப்படுத்தப்படாத [“கோலாங்”, “பைதான்”, “ஜாவா”, “பெர்ல்”, “டைப்ஸ்கிரிப்ட்”] மதிப்புகளுடன் “strSl” ஸ்லைஸை முதலில் நிறுவினோம். அதன் பிறகு, 'strSl' ஸ்லைஸை sort.Strings() செயல்பாட்டின் மூலம் வரிசைப்படுத்துகிறோம், இது ஸ்லைஸின் கூறுகளை லெக்சிகோகிராஃபிக் வரிசையில் வரிசைப்படுத்துகிறது. இந்த செயல்பாடு அசல் ஸ்லைஸை நேரடியாக மாற்றியமைக்கிறது, அதன் உறுப்புகளை அவற்றின் ASCII மதிப்புகளின் அடிப்படையில் வரிசைப்படுத்தப்பட்ட வரிசையில் மறுசீரமைக்கிறது.
வெளியீடு பின்வருவனவற்றில் காட்டப்பட்டுள்ளபடி சரம் ஸ்லைஸை ஏறுவரிசையில் வரிசைப்படுத்துகிறது:
எடுத்துக்காட்டு 5: IntAreSort() செயல்பாட்டைப் பயன்படுத்தி கோலாங் ஸ்லைஸை வரிசைப்படுத்தவும்
இருப்பினும், Go இன் sort.IntsAreSorted() செயல்பாட்டின் மூலம், கொடுக்கப்பட்ட முழு எண்களின் துண்டு ஏறுவரிசையில் வரிசைப்படுத்தப்பட்டுள்ளதா இல்லையா என்பதை நாம் சரிபார்க்கலாம். கொடுக்கப்பட்ட துண்டுக்கான IntAreSort() செயல்பாட்டின் பின்வரும் எடுத்துக்காட்டு நிரலைக் கவனியுங்கள்:
தொகுப்பு முக்கியஇறக்குமதி (
'fmt'
'வகைபடுத்து'
)
செயல்பாடு முக்கிய () {
sl := [] முழு எண்ணாக { - 33 , 105 , - 42 , 59 , 18 , 0 , - 3 }
fmt . Println ( 'துண்டுகள்:' )
fmt . Println ( 'வரிசைப்படுத்தப்படாத துண்டு:' , sl )
விளைவாக := வகைபடுத்து . IntsAreSorted ( sl )
fmt . Println ( ' \n விளைவாக:' )
fmt . Println ( 'கொடுக்கப்பட்ட துண்டு வரிசைப்படுத்தப்பட்டதா?:' , விளைவாக )
}
முதலில், சீரற்ற முழு எண்களின் வரிசையாக்கப்படாத துண்டானது “sl” என வரையறுக்கப்படுகிறது. இந்த ஸ்லைஸில் குறிப்பிட்ட வரிசையில் முழு எண்களின் தொகுப்பு உள்ளது. அடுத்து, நாம் sort.IntsAreSorted() செயல்பாட்டை அழைக்கிறோம் மற்றும் 'sl' ஸ்லைஸை ஒரு வாதமாக அனுப்புகிறோம். இந்தச் செயல்பாடு ஒரு பூலியன் முடிவை வழங்குகிறது, இது ஸ்லைஸ் உள்ளீடு ஏறுவரிசையில் அமைக்கப்பட்டதா இல்லையா என்பதைக் குறிக்கிறது. பின்னர், fmt.Println() செயல்பாடு, கொடுக்கப்பட்ட ஸ்லைஸ் வரிசைப்படுத்தப்பட்டதா அல்லது திரும்பிய பூலியன் மதிப்பின் அடிப்படையில் முடிவுகளை வெளியிடும் முடிவுகளை அச்சிடுகிறது.
வரிசைப்படுத்தப்படாத முழு எண்களின் வரிசையாக்க வரிசைக்கு வெளியீடு தவறானதாகக் காட்டுகிறது:
எடுத்துக்காட்டு 6: கோலாங் தலைகீழ் வரிசை ஸ்லைஸ்
மேலும், Go இல் உள்ள வரிசை தொகுப்பிலிருந்து sortReverse() மற்றும் sortStringSlice() செயல்பாடுகளைப் பயன்படுத்தி, சரங்களின் ஸ்லைஸை நாம் தலைகீழாக வரிசைப்படுத்தலாம். பின்வரும் நிரல் sort.Reverse() செயல்பாட்டின் செயல்பாட்டை நிரூபிக்கிறது:
தொகுப்பு முக்கியஇறக்குமதி (
'fmt'
'வகைபடுத்து'
)
செயல்பாடு முக்கிய () {
உயிர் துண்டு := [] லேசான கயிறு { 'இது' , 'அ' , 'நான்' , 'உள்' , 'ஓ' }
fmt . Println ( 'வரிசைப்படுத்துவதற்கு முன் :' , உயிர் துண்டு )
வகைபடுத்து . வகைபடுத்து ( வகைபடுத்து . தலைகீழ் ( வகைபடுத்து . StringSlice ( உயிர் துண்டு )))
fmt . Println ( 'வரிசைப்படுத்திய பின் :' , உயிர் துண்டு )
}
'e', 'a', 'i', 'u' மற்றும் 'o' ஆகிய உயிரெழுத்துக்களைக் கொண்ட 'vowelSlice' சரத்தின் ஒரு பகுதியை வரையறுப்பதன் மூலம் தொடங்குகிறோம். குறிப்பிடப்பட்ட சரங்களின் ஆரம்ப உள்ளடக்கம் முதலில் 'அச்சு' செயல்பாட்டைப் பயன்படுத்தி அச்சிடப்படுகிறது. அடுத்து, sort.Sort() செயல்பாட்டை sort.Reverse() மற்றும் sort.StringSlice() செயல்பாடுகளை வாதங்களாகப் பயன்படுத்தி வரிசைப்படுத்துதல் செயல்பாடு செய்யப்படுகிறது. இங்கே, 'sort.Reverse()' ஆனது உறுப்புகளின் வரிசையை மாற்றியமைக்கும் புதிய வகையை உருவாக்குகிறது. இது 'sort.StringSlice' வகையை அதன் வாதமாக எடுத்துக்கொள்கிறது, இது vowelSlice ஐ வரிசைப்படுத்தக்கூடிய வகையாக மாற்றுகிறது.
இங்குள்ள வெளியீடு உயிரெழுத்துக்களை தலைகீழ் அகரவரிசையில் காட்டுகிறது:
முடிவுரை
வழங்கப்பட்ட ஸ்லைஸை வரிசைப்படுத்தும் எடுத்துக்காட்டுகளுடன் பல்வேறு வரிசையாக்க செயல்பாடுகளை நாங்கள் ஆராய்ந்தோம். துணை-துண்டுகளை வரிசைப்படுத்துவது மற்றும் ஒரு துண்டு ஏற்கனவே வரிசைப்படுத்தப்பட்டுள்ளதா என்பதைச் சரிபார்க்கவும். எனவே, அவர்களின் Go திட்டங்களில் பரந்த அளவிலான வரிசையாக்க சவால்களைச் சமாளிக்க, வரிசைப்படுத்தல் தொகுப்பின் திறன்களை நாம் பயன்படுத்த முடியும்.