గేమ్‌లు, గ్రాఫిక్స్, వెబ్ సర్వర్‌లు మరియు మరిన్నింటితో సహా అనేక రకాల ప్రోగ్రామ్‌లు C++ ప్రోగ్రామింగ్ లాంగ్వేజ్‌ని ఉపయోగించి తయారు చేయవచ్చు. అయితే, కొన్నిసార్లు మేము మా ప్రోగ్రామ్‌లలోని డేటాపై శోధించడం, క్రమబద్ధీకరించడం లేదా మూలకాల పరిధిలో గరిష్ట లేదా కనిష్ట విలువను కనుగొనడం వంటి కొన్ని కార్యకలాపాలను నిర్వహించాల్సి రావచ్చు. క్రమబద్ధీకరించబడిన మూలకాల పరిధిలో విలువ యొక్క ఎగువ సరిహద్దును కనుగొనడానికి ఉపయోగించే ఫంక్షన్‌లలో ఒకటి ఎగువ_బౌండ్().
C++లో అప్పర్_బౌండ్() ఫంక్షన్ అంటే ఏమిటి
C++లోని అప్పర్_బౌండ్() ఫంక్షన్ అనేది క్రమబద్ధీకరించబడిన మూలకాల పరిధిని మరియు విలువను ఆర్గ్యుమెంట్‌లుగా తీసుకునే ఒక ఫంక్షన్ మరియు విలువ కంటే ఎక్కువ ఉన్న పరిధిలోని మొదటి మూలకాన్ని సూచించే ఇటరేటర్‌ను అందిస్తుంది.
ఇది రెండు విభిన్న రకాల వాదనలను కలిగి ఉంది:
ఎగువ_బౌండ్ సంఖ్య ( ఒకదానిపై. ప్రధమ , ఒకదానిపై. చివరిది , విలువ )
పరిశీలించాల్సిన మూలకాల పరిధిని పేర్కొనే ఇటరేటర్‌లు మొదటి మరియు చివరివి. ఉపయోగించిన విరామం మొదటి మూలకం నుండి చివరి వరకు అన్ని మూలకాలను కలిగి ఉంటుంది కానీ చివరిగా సూచించిన మూలకాన్ని కలిగి ఉండదు. మూలకాలను పోల్చడానికి విలువ అనేది విలువ.
ఎగువ_బౌండ్ సంఖ్య ( ఒకదానిపై. ప్రధమ , ఒకదానిపై. చివరిది , విలువ, సరిపోల్చండి )
ఈ సందర్భంలో, బైనరీ ఫంక్షన్ కంప్ అనేది బూల్‌గా మార్చబడే విలువను ఉత్పత్తి చేస్తుంది మరియు శ్రేణి అంశాల వలె ఒకే రకమైన రెండు పారామితులను అంగీకరిస్తుంది. మొదటి ఆర్గ్యుమెంట్ రెండవ దాని కంటే ఎక్కువగా లేదని ఒక నిర్దిష్ట షరతు నిర్దేశిస్తే, ఫంక్షన్ తప్పక నిజమైన ఫలితాన్ని అందించాలి మరియు కాకపోతే, అది తప్పుని అందించాలి.
C++లో అప్పర్_బౌండ్() ఫంక్షన్‌ని ఎలా ఉపయోగించాలి
వివిధ పరిస్థితులలో క్రమబద్ధీకరించబడిన మూలకాల పరిధిలో విలువ యొక్క ఎగువ సరిహద్దును కనుగొనడానికి ఎగువ_బౌండ్() ఫంక్షన్‌ను ఉపయోగించవచ్చు. ఉదాహరణకు, క్రమబద్ధీకరించబడిన శ్రేణి లేదా వెక్టార్‌లో మూలకం యొక్క స్థానాన్ని కనుగొనడానికి లేదా సెట్ లేదా మ్యాప్‌లో తదుపరి పెద్ద మూలకాన్ని కనుగొనడానికి మేము దానిని ఉపయోగించవచ్చు. C++లో అప్పర్_బౌండ్() ఫంక్షన్‌ను ఎలా ఉపయోగించాలో ఇక్కడ కొన్ని ఉదాహరణలు ఉన్నాయి:
ఉదాహరణ 1: క్రమబద్ధీకరించబడిన శ్రేణిలో మూలకం యొక్క స్థానాన్ని కనుగొనడానికి ఎగువ_బౌండ్() ఫంక్షన్‌ని ఉపయోగించడం
ఇక్కడ ఒక ఉదాహరణ ఉంది, ఇది పూర్ణాంకాల క్రమబద్ధీకరించబడిన శ్రేణిలో మూలకం యొక్క స్థానాన్ని కనుగొనడానికి మరియు దానిని స్క్రీన్‌పై ప్రదర్శించడానికి ఎగువ_బౌండ్() ఫంక్షన్‌ని ఉపయోగిస్తుంది:
#
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
int అమరిక [ ] = { పదిహేను , 35 , నాలుగు ఐదు , 55 , 65 } ;
int a = పరిమాణం ( అమరిక ) / పరిమాణం ( అమరిక [ 0 ] ) ;
కోట్ << 'శ్రేణి కలిగి ఉంది:' ;
కోసం ( int i = 0 ; i < a ; i ++ )
కోట్ << అమరిక [ i ] << '' ;
కోట్ << ' \n ' ;
int బి = నాలుగు ఐదు ; // విలువను ప్రకటించండి మరియు ప్రారంభించండి
int * p = ఉన్నత స్థాయి ( శ్రేణి, శ్రేణి + ఎ, బి ) ;
కోట్ << 'ఎగువ సరిహద్దు' << బి << 'స్థానంలో ఉంది:' << ( p - అమరిక ) << ' \n ' ; // పాయింటర్ అంకగణితాన్ని ఉపయోగించి స్థానాన్ని ప్రదర్శించండి
తిరిగి 0 ;
}
ముందుగా ప్రోగ్రామ్ అవసరమైన హెడర్ ఫైల్‌లు మరియు సంఖ్యలను కలిగి ఉండే శ్రేణిని నిర్వచిస్తుంది మరియు శ్రేణి యొక్క పరిమాణాన్ని పొందడానికి sizeof() ఫంక్షన్‌ని ఉపయోగిస్తుంది. తదుపరి a for loop శ్రేణి యొక్క మూలకాలను ప్రదర్శించడానికి ఉపయోగించబడుతుంది మరియు పూర్ణాంకం ప్రకటించబడుతుంది, దీని స్థానం పాయింటర్‌ను ఉపయోగించి నిర్ణయించబడుతుంది మరియు ఇది అవుట్‌పుట్‌లో ప్రదర్శించబడుతుంది:
ఉదాహరణ 2: ఒక సెట్‌లో తదుపరి గ్రేటర్ ఎలిమెంట్‌ను కనుగొనడానికి ఎగువ_బౌండ్() ఫంక్షన్‌ని ఉపయోగించడం
పూర్ణాంకాల సమితిలో ఇచ్చిన విలువ కంటే తదుపరి పెద్ద మూలకాన్ని కనుగొని దాన్ని స్క్రీన్‌పై ప్రదర్శించడానికి ఎగువ_బౌండ్() ఫంక్షన్‌ని ఉపయోగించే ఉదాహరణ కోడ్ ఇక్కడ ఉంది:
##
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
సెట్ < int > ఒకదానిపై = { పదిహేను , 25 , 35 , నాలుగు ఐదు , 55 } ; // పూర్ణాంకాల సమితిని ప్రకటించండి మరియు ప్రారంభించండి
కోట్ << 'ఇచ్చిన సంఖ్యలు:' ;
కోసం ( దానంతట అదే a : ఒకదానిపై ) // లూప్ కోసం రేంజ్-బేస్డ్ ఉపయోగించి సెట్ ఎలిమెంట్‌లను ప్రదర్శించండి
కోట్ << a << '' ;
కోట్ << ' \n ' ;
int a = నాలుగు ఐదు ; // విలువను ప్రకటించండి మరియు ప్రారంభించండి
దానంతట అదే అది = ఉన్నత స్థాయి ( ఒకదానిపై. ప్రారంభం ( ) , ఒకదానిపై. ముగింపు ( ) , a ) ; // top_bound()ని ఉపయోగించి సెట్‌లో x ఎగువ సరిహద్దును కనుగొనండి
ఉంటే ( అది ! = ఒకదానిపై. ముగింపు ( ) ) // ఇటరేటర్ చెల్లుబాటులో ఉందో లేదో తనిఖీ చేయండి
కోట్ << 'తదుపరి అధిక సంఖ్య' << a << 'ఉంది' << * అది << ' \n ' ; // dereference ఆపరేటర్‌ని ఉపయోగించి మూలకాన్ని ప్రదర్శించండి
లేకపోతే
కోట్ << 'కంటే ఎక్కువ సంఖ్య లేదు' << a << ' \n ' ; // అటువంటి మూలకం కనుగొనబడకపోతే సందేశాన్ని ప్రదర్శించండి
తిరిగి 0 ;
}
మొదట కోడ్ అవసరమైన హెడర్ ఫైల్‌లను నిర్వచిస్తుంది మరియు ఐదు మూలకాల యొక్క వెక్టర్ నిర్వచించబడుతుంది, తదుపరి వెక్టర్ ఆటో కీవర్డ్ ఉపయోగించి ప్రదర్శించబడుతుంది, ఎందుకంటే ఇది మూలకాల యొక్క డేటా రకాన్ని స్వయంచాలకంగా సెట్ చేయగలదు. తదుపరి 45 విలువ కలిగిన వేరియబుల్ ప్రకటించబడింది, అది అప్పర్_బౌండ్() ఫంక్షన్‌ని ఉపయోగించి నిర్వచించిన వెక్టార్‌తో పోల్చబడుతుంది మరియు తర్వాత అది పోలిక ఫలితాన్ని ప్రదర్శిస్తుంది:
ముగింపు
అప్పర్_బౌండ్() ఫంక్షన్ అనేది ఇచ్చిన విలువ కంటే ఎక్కువగా ఉండే క్రమబద్ధీకరించబడిన పరిధిలోని మొదటి మూలకాన్ని సూచించే ఇటరేటర్‌ని తిరిగి ఇచ్చే ఫంక్షన్. పేర్కొన్న సంఖ్య కంటే ఎక్కువ లేదా సమానమైన విరామంలో మొదటి సంఖ్యను గుర్తించడానికి, C++లో ఎగువ_బౌండ్() ఫంక్షన్‌ని ఉపయోగించండి. ఇది జాబితాలో తదుపరి అత్యధిక సంఖ్యను కనుగొనడం లేదా క్రమబద్ధీకరించబడిన శ్రేణిలో ఇచ్చిన థ్రెషోల్డ్ కంటే ఎక్కువగా ఉండే మొదటి మూలకాన్ని కనుగొనడం వంటి పనులకు ఉపయోగపడుతుంది.