ఉదాహరణ 1: గోలాంగ్ స్లైస్‌ను ఆరోహణ క్రమంలో క్రమబద్ధీకరించండి
'sort.Slice()' ఫంక్షన్ అనేది Goలో అగ్రశ్రేణి ఫంక్షన్, ఇది స్లైస్ యొక్క మూలకాలను ఆరోహణ క్రమంలో లేదా అవరోహణ క్రమంలో తిరిగి అమర్చుతుంది. స్లైస్ ఆరోహణ క్రమంలో అమర్చబడిన కింది దృష్టాంతాన్ని పరిగణనలోకి తీసుకోండి:
ప్యాకేజీ ప్రధానదిగుమతి (
'fmt'
'క్రమబద్ధీకరించు'
)
ఫంక్ ప్రధాన () {
స్లైస్ := [] int { 10 , 2 , 8 , 4 , 0 , 6 }
fmt . Println ( 'క్రమబద్ధీకరించని స్లైస్:' , స్లైస్ )
క్రమబద్ధీకరించు . స్లైస్ ( స్లైస్ , ఫంక్ ( i , జె int ) బూల్ {
తిరిగి స్లైస్ [ i ] < కూడా స్లైస్ [ జె ]
})
fmt . Println ( 'క్రమబద్ధీకరించబడిన ముక్క:' , స్లైస్ )
}
ప్రధాన() ఫంక్షన్ ప్రారంభంలో, మేము {10, 2, 8, 4, 0, 6} విలువలతో ఈవెన్‌స్లైస్ స్లైస్‌ని నిర్వచించాము. ఈ స్లైస్ ప్రారంభంలో క్రమబద్ధీకరించని సరి సంఖ్యల సేకరణను సూచిస్తుంది. EvenSlice స్లైస్‌ను క్రమబద్ధీకరించడానికి, sort.Slice() ఫంక్షన్ స్లైస్‌తో ఉపయోగించబడుతుంది. sort.Slice() ఫంక్షన్ లోపల, సార్టింగ్ ఫంక్షన్ ఆర్గ్యుమెంట్‌గా అందించబడుతుంది. ఈ ఫంక్షన్ స్లైస్ యొక్క రెండు మూలకాలను “i” మరియు “j” సూచికల వద్ద పోల్చడం ద్వారా క్రమబద్ధీకరణ క్రమాన్ని నిర్ణయిస్తుంది. evenSlice[i] evenSlice[j] కంటే తక్కువగా ఉంటే, అది నిజమని చూపుతుంది; లేకపోతే, అది తప్పుగా తిరిగి వస్తుంది. 'evenSlice' స్లైస్ మూలకాలను ఆరోహణ క్రమంలో క్రమాన్ని మార్చడానికి sort.Slice() ఫంక్షన్ ఈ పోలిక ఫంక్షన్‌ని ఉపయోగిస్తుంది.
ఆరోహణ క్రమంలో క్రమబద్ధీకరించబడిన స్లైస్ ఫలితాలు క్రింది అవుట్‌పుట్ స్క్రీన్‌లో రూపొందించబడతాయి:
ఉదాహరణ 2: గోలాంగ్ క్రమబద్ధీకరణ పార్ట్ స్లైస్
తరువాత, గోలోని sort.Slice() ఫంక్షన్‌ని ఉపయోగించి ఆరోహణ క్రమంలో పేర్కొన్న స్లైస్ యొక్క ఉప-స్లైస్‌కు సార్టింగ్ వర్తించబడుతుంది.
ప్యాకేజీ ప్రధాన
దిగుమతి (
'fmt'
'క్రమబద్ధీకరించు'
)
ఫంక్ ప్రధాన () {
n := [] int { 9 , 7 , 3 , 5 }
ప్రారంభించండి := 0
ముగింపు := 3
క్రమబద్ధీకరించు . స్లైస్ ( n [ ప్రారంభించండి : ముగింపు ], ఫంక్ ( i , జె int ) బూల్ {
తిరిగి n [ ప్రారంభించండి + i ] < 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 := [] int { 10 , 13 , పదిహేను , పదకొండు , 14 , 12 }
fmt . Println ( 'క్రమబద్ధీకరించని స్లైస్:' , IntSlice )
క్రమబద్ధీకరించు . Ints ( IntSlice )
fmt . Println ( 'క్రమబద్ధీకరించబడిన ముక్క:' , IntSlice )
}
ముందుగా, మేము మొదట క్రమబద్ధీకరించని పూర్ణాంకాల సేకరణను సూచించే [10, 13, 15, 11, 14, 12] విలువలతో “IntSlice” స్లైస్‌ను ప్రకటించి, ప్రారంభిస్తాము. అప్పుడు, 'IntSlice'ని క్రమబద్ధీకరించడానికి 'IntSlice' స్లైస్‌తో sort.Ints() ఫంక్షన్ అంటారు. ఈ సందర్భంలో sort.Ints() ఫంక్షన్ ఆప్టిమైజ్ చేసిన సార్టింగ్ అల్గోరిథం ప్రకారం స్లైస్‌లోని ప్రతి భాగాన్ని అంతర్గతంగా క్రమబద్ధీకరిస్తుంది. ఇది అసలైన స్లైస్‌ను నేరుగా సవరించి, దాని మూలకాలను క్రమబద్ధీకరించిన క్రమంలో తిరిగి అమర్చుతుంది.
కింది అవుట్‌పుట్ మొదట క్రమబద్ధీకరించని స్లైస్ ప్రదర్శించబడిందని చూపిస్తుంది, తర్వాత క్రమబద్ధీకరించబడిన స్లైస్:
ఉదాహరణ 4: గోలాంగ్ క్రమబద్ధీకరణ స్ట్రింగ్ స్లైస్
Go క్రమబద్ధీకరణ ప్యాకేజీ యొక్క sort.Strings() ఫంక్షన్‌ను కూడా అందిస్తుంది, ఇది స్ట్రింగ్‌ల స్లైస్‌ను నిర్దిష్ట క్రమంలో క్రమబద్ధీకరించడానికి ఉపయోగించబడుతుంది. ఇక్కడ, క్రింది ప్రోగ్రామ్ స్ట్రింగ్స్ స్లైస్‌ను క్రమబద్ధీకరించడానికి సహాయపడుతుంది:
ప్యాకేజీ ప్రధానదిగుమతి (
'fmt'
'క్రమబద్ధీకరించు'
)
ఫంక్ ప్రధాన () {
strSl := [] స్ట్రింగ్ { 'గోలన్' , 'కొండచిలువ' , 'జావా' , 'పెర్ల్' , 'టైప్‌స్క్రిప్ట్' }
క్రమబద్ధీకరించు . తీగలు ( strSl )
fmt . Println ( strSl )
}
క్రమబద్ధీకరించబడని [“గోలాంగ్”, “పైథాన్”, “జావా”, “పెర్ల్”, “టైప్‌స్క్రిప్ట్”] విలువలతో మేము మొదట “strSl” స్లైస్‌ని ఏర్పాటు చేసాము. ఆ తర్వాత, మేము 'strSl' స్లైస్‌ను sort.Strings() ఫంక్షన్‌తో క్రమబద్ధీకరిస్తాము, ఇది స్లైస్ యొక్క మూలకాలను లెక్సికోగ్రాఫిక్ క్రమంలో క్రమబద్ధీకరిస్తుంది. ఈ ఫంక్షన్ అసలైన స్లైస్‌ను నేరుగా సవరించి, దాని మూలకాలను వాటి ASCII విలువల ఆధారంగా క్రమబద్ధీకరించిన క్రమంలో తిరిగి అమర్చుతుంది.
అవుట్‌పుట్ స్ట్రింగ్ స్లైస్‌ను ఆరోహణ పద్ధతిలో కింది వాటిలో ప్రదర్శించినట్లుగా క్రమబద్ధీకరిస్తుంది:
ఉదాహరణ 5: IntAreSort() ఫంక్షన్‌ని ఉపయోగించి గోలాంగ్ క్రమబద్ధీకరణ స్లైస్‌ని తనిఖీ చేయండి
అయినప్పటికీ, Go యొక్క sort.IntsAreSorted() ఫంక్షన్‌తో, ఇచ్చిన పూర్ణాంకాల స్లైస్ ఆరోహణ క్రమంలో క్రమబద్ధీకరించబడిందో లేదో తనిఖీ చేయవచ్చు. ఇచ్చిన స్లైస్ కోసం IntAreSort() ఫంక్షన్ యొక్క క్రింది ఉదాహరణ ప్రోగ్రామ్‌ను పరిగణించండి:
ప్యాకేజీ ప్రధానదిగుమతి (
'fmt'
'క్రమబద్ధీకరించు'
)
ఫంక్ ప్రధాన () {
క్ర.సం := [] int { - 33 , 105 , - 42 , 59 , 18 , 0 , - 3 }
fmt . Println ( 'ముక్కలు:' )
fmt . Println ( 'క్రమబద్ధీకరించని స్లైస్:' , క్ర.సం )
ఫలితం := క్రమబద్ధీకరించు . IntsAreSorted ( క్ర.సం )
fmt . Println ( ' \n ఫలితం:' )
fmt . Println ( 'ఇచ్చిన స్లైస్ క్రమబద్ధీకరించబడిందా?:' , ఫలితం )
}
ముందుగా, యాదృచ్ఛిక పూర్ణాంకాల యొక్క క్రమబద్ధీకరించని స్లైస్ “sl”గా నిర్వచించబడింది. ఈ స్లైస్ నిర్దిష్ట క్రమంలో లేని పూర్ణాంకాల సేకరణను కలిగి ఉంది. తరువాత, మేము sort.IntsAreSorted() ఫంక్షన్‌ని పిలుస్తాము మరియు “sl” స్లైస్‌ను ఆర్గ్యుమెంట్‌గా పాస్ చేస్తాము. ఈ ఫంక్షన్ స్లైస్ ఇన్‌పుట్ ఆరోహణ క్రమంలో అమర్చబడిందో లేదో సూచించే బూలియన్ ఫలితాన్ని అందిస్తుంది. అప్పుడు, fmt.Println() ఫంక్షన్ ఇచ్చిన స్లైస్ క్రమబద్ధీకరించబడిందా లేదా తిరిగి వచ్చిన బూలియన్ విలువ ఆధారంగా ఫలితాలను ఇచ్చే ఫలితాలను ప్రింట్ చేస్తుంది.
పూర్ణాంకాల స్లైస్ క్రమబద్ధీకరించబడనందున అవుట్‌పుట్ తప్పుగా చూపబడుతుంది:
ఉదాహరణ 6: గోలాంగ్ రివర్స్ సార్ట్ స్లైస్
ఇంకా, Goలోని క్రమబద్ధీకరణ ప్యాకేజీ నుండి sortReverse() మరియు sortStringSlice() ఫంక్షన్‌లను ఉపయోగించి, మేము స్ట్రింగ్‌ల స్లైస్‌ను రివర్స్-సార్ట్ చేయవచ్చు. క్రింది ప్రోగ్రామ్ sort.Reverse() ఫంక్షన్ యొక్క పనిని ప్రదర్శిస్తుంది:
ప్యాకేజీ ప్రధానదిగుమతి (
'fmt'
'క్రమబద్ధీకరించు'
)
ఫంక్ ప్రధాన () {
vowelSlice := [] స్ట్రింగ్ { 'అది' , 'a' , 'నేను' , 'లో' , 'ఓ' }
fmt . Println ( 'క్రమబద్ధీకరించే ముందు :' , vowelSlice )
క్రమబద్ధీకరించు . క్రమబద్ధీకరించు ( క్రమబద్ధీకరించు . రివర్స్ ( క్రమబద్ధీకరించు . స్ట్రింగ్స్లైస్ ( vowelSlice )))
fmt . Println ( 'క్రమబద్ధీకరించిన తర్వాత :' , vowelSlice )
}
మేము 'e', 'a', 'i', 'u' మరియు 'o' అచ్చులను కలిగి ఉన్న 'vowelSlice' స్ట్రింగ్ యొక్క స్లైస్‌ను నిర్వచించడం ద్వారా ప్రారంభిస్తాము. స్ట్రింగ్స్ యొక్క పేర్కొన్న స్లైస్ యొక్క ప్రారంభ కంటెంట్ మొదట 'ప్రింట్' ఫంక్షన్ ఉపయోగించి ముద్రించబడుతుంది. తరువాత, sort.Sort() ఫంక్షన్‌ని sort.Reverse() మరియు sort.StringSlice() ఫంక్షన్‌లను ఆర్గ్యుమెంట్‌లుగా ఉపయోగించి సార్టింగ్ ఆపరేషన్ నిర్వహిస్తారు. ఇక్కడ, “sort.Reverse()” మూలకాల క్రమాన్ని రివర్స్ చేసే కొత్త రకాన్ని సృష్టిస్తుంది. ఇది 'sort.StringSlice' రకాన్ని దాని వాదనగా తీసుకుంటుంది, ఇది vowelSliceని క్రమబద్ధీకరించదగిన రకంగా మారుస్తుంది.
ఇక్కడ అవుట్‌పుట్ అచ్చులను రివర్స్ ఆల్ఫాబెటికల్ ఆర్డర్‌లో ప్రదర్శిస్తుంది:
ముగింపు
మేము అందించిన స్లైస్‌ని క్రమబద్ధీకరించే ఉదాహరణలతో వివిధ సార్టింగ్ ఫంక్షన్‌లను పరిశీలించాము. మేము సబ్-స్లైస్‌ల క్రమబద్ధీకరణ మరియు స్లైస్ ఇప్పటికే క్రమబద్ధీకరించబడిందో లేదో తనిఖీ చేయడం గురించి కూడా కవర్ చేసాము. అందువల్ల, వారి గో ప్రాజెక్ట్‌లలో విస్తృత శ్రేణి సార్టింగ్ సవాళ్లను పరిష్కరించడానికి మేము క్రమబద్ధీకరణ ప్యాకేజీ సామర్థ్యాలను ఉపయోగించుకోవచ్చు.