దిగువ_బౌండ్() పద్ధతి అంటే ఏమిటి?
C++లో దిగువ_బౌండ్() పద్ధతి క్రమబద్ధీకరించబడిన కంటైనర్‌లో ఇచ్చిన విలువ యొక్క మొదటి సంఘటనను కనుగొంటుంది. ఇది C++లోని
వాక్యనిర్మాణం
C++లో లోయర్_బౌండ్() పద్ధతికి రెండు వైవిధ్యాలు ఉన్నాయి: డిఫాల్ట్ మరియు కస్టమ్ సింటాక్స్.
డిఫాల్ట్ సింటాక్స్
డిఫాల్ట్ సింటాక్స్ వరుసగా శోధించాల్సిన పరిధిలోని మొదటి మరియు చివరి మూలకాలపై సూచించే ఫార్వర్డ్‌ఇటరేటర్‌ను తీసుకుంటుంది మరియు పరిధిలోని మూలకాలను పోల్చడానికి విలువను తీసుకుంటుంది.
ఫార్వర్డ్‌ఇటరేటర్ దిగువ_బౌండ్ ( ముందుగా ForwardIterator , ForwardIterator చివరిది , స్థిరంగా టి & విలువ ) ;
కస్టమ్ సింటాక్స్
కస్టమ్ సింటాక్స్ అదనంగా వినియోగదారు నిర్వచించిన బైనరీ ప్రిడికేట్ ఫంక్షన్‌ను తీసుకుంటుంది, ఇది మూలకాలను క్రమం చేయడానికి కఠినమైన బలహీనమైన క్రమాన్ని అనుసరిస్తుంది.
ఫార్వర్డ్‌ఇటరేటర్ దిగువ_బౌండ్ ( ముందుగా ForwardIterator , ForwardIterator చివరిది , స్థిరంగా టి & విలువ , సరిపోల్చండి ) ;
పారామితులు
C++లో low_bound() పద్ధతి మూడు పారామితులను తీసుకుంటుంది.
మొదటి చివరి: మొదటి రెండు పారామితులు, 'మొదటి' మరియు 'చివరి', పద్ధతి దిగువ సరిహద్దు కోసం శోధించే పరిధిని [మొదటి, చివరి) నిర్ణయిస్తాయి. పరిధి 'మొదటి' మరియు 'చివరి' అనే రెండు పారామితుల ద్వారా పేర్కొనబడింది. పరిధి 'మొదటి' మరియు 'చివరి' ఇటరేటర్‌ల మధ్య అన్ని ఎలిమెంట్‌లను కలిగి ఉంటుంది కానీ 'చివరి' ఇరేటర్ ద్వారా సూచించబడిన మూలకాన్ని మినహాయిస్తుంది.
విలువ: లోయర్_బౌండ్() పద్ధతి యొక్క మూడవ పరామితి 'వాల్'గా సూచించబడుతుంది. ఇది పేర్కొన్న పరిధిలో కనుగొనవలసిన దిగువ సరిహద్దు విలువను సూచిస్తుంది. Lower_bound() పద్ధతిని పిలిచినప్పుడు, అది అందించిన విలువ “val” కంటే ఎక్కువ లేదా సమానమైన కంటైనర్ యొక్క పేర్కొన్న పరిధిలోని మొదటి మూలకం కోసం శోధిస్తుంది.
కంప్: లోయర్_బౌండ్() పద్ధతి బైనరీ పోలిక ఫంక్షన్‌ను దాని నాల్గవ పరామితిగా కూడా అంగీకరించవచ్చు. దీనికి రెండు వాదనలు అవసరమవుతాయి: సూచించిన రకం ఫార్వర్డ్‌ఇటరేటర్ , మరియు రెండవది విలువ . ఫంక్షన్ రెండు ఆర్గ్యుమెంట్‌ల మధ్య పోలిక ఆధారంగా బూలియన్ విలువను అందిస్తుంది. కాంప్ ఆర్గ్యుమెంట్ దాని ఆర్గ్యుమెంట్‌లలో దేనినీ మార్చదు మరియు అది ఫంక్షన్ పాయింటర్ లేదా ఫంక్షన్ ఆబ్జెక్ట్ మాత్రమే కావచ్చు.
రిటర్న్ విలువ
దిగువ_బౌండ్() ఒక ఇటరేటర్‌ను అందిస్తుంది, అది మొదటి మూలకం వైపు కంటే ఎక్కువ లేదా సమానంగా ఉంటుంది విలువ . కంటైనర్ యొక్క పేర్కొన్న పరిధిలోని అన్ని మూలకాలు ఇచ్చిన విలువ కంటే తక్కువగా ఉంటే విలువ , low_bound() పద్ధతి పరిధిలోని చివరి మూలకాన్ని సూచించే ఇటరేటర్‌ని అందిస్తుంది మరియు అన్ని మూలకాలు దాని కంటే ఎక్కువగా ఉంటే విలువ , ఇది పరిధిలోని మొదటి మూలకాన్ని సూచించే ఇటరేటర్‌ను ఇస్తుంది.
ఉదాహరణ కోడ్
ఈ C++ కోడ్ క్రమబద్ధీకరించబడిన వెక్టార్‌లో ఇవ్వబడిన విలువ కంటే తక్కువ లేని మొదటి మూలకాన్ని కనుగొనడానికి std::lower_bound() ఫంక్షన్‌ని ఉపయోగించడాన్ని ప్రదర్శిస్తుంది.
#int ప్రధాన ( )
{
// ఇన్‌పుట్ వెక్టార్
std :: వెక్టర్ < రెట్టింపు > విలువలు { 10 , పదిహేను , ఇరవై , 25 , 30 } ;
// ప్రింట్ వెక్టర్
std :: కోట్ << 'వెక్టర్ కలిగి ఉంది:' ;
కోసం ( సంతకం చేయలేదు int i = 0 ; i < విలువలు. పరిమాణం ( ) ; i ++ )
std :: కోట్ << '' << విలువలు [ i ] ;
std :: కోట్ << ' \n ' ;
std :: వెక్టర్ < రెట్టింపు >:: పునరావృతం చేసేవాడు అది1 , అది2 , అది3 ;
// std :: lower_bound
అది1 = std :: దిగువ_బౌండ్ ( విలువలు. ప్రారంభం ( ) , విలువలు. ముగింపు ( ) , 13 ) ;
అది2 = std :: దిగువ_బౌండ్ ( విలువలు. ప్రారంభం ( ) , విలువలు. ముగింపు ( ) , 23 ) ;
అది3 = std :: దిగువ_బౌండ్ ( విలువలు. ప్రారంభం ( ) , విలువలు. ముగింపు ( ) , 33 ) ;
std :: కోట్
<< ' \n స్థానం వద్ద మూలకం 13 కోసం దిగువ_బౌండ్: '
<< ( అది1 - విలువలు. ప్రారంభం ( ) ) ;
std :: కోట్
<< ' \n స్థానం వద్ద మూలకం 23 కోసం దిగువ_బౌండ్: '
<< ( అది2 - విలువలు. ప్రారంభం ( ) ) ;
std :: కోట్
<< ' \n స్థానం వద్ద మూలకం 33 కోసం దిగువ_బౌండ్: '
<< ( అది3 - విలువలు. ప్రారంభం ( ) ) ;
తిరిగి 0 ;
}
std:: వెక్టర్ రకం డబుల్-నేమ్డ్ విలువలను నిర్వచించడం ద్వారా మరియు కొన్ని విలువలతో దాన్ని ప్రారంభించడం ద్వారా కోడ్ ప్రారంభమవుతుంది. ఇది వెక్టార్ యొక్క మూలకాలను లూప్ కోసం ఉపయోగించి ముద్రిస్తుంది.
తరువాత, కోడ్ మూడు std:: vector
std::lower_bound() ఫంక్షన్ మూడు విభిన్న విలువలతో పిలువబడుతుంది: 13, 23 మరియు 33. ప్రతి కాల్‌లో, దిగువ_బౌండ్() వెక్టార్‌లోని మొదటి మూలకం వైపు కంటే ఎక్కువ లేదా సమానంగా ఉండే ఇటరేటర్‌ను ఇస్తుంది. పేర్కొన్న విలువ.
std::lower_bound() ద్వారా అందించబడిన ఇటరేటర్ నుండి విలువలు.begin() ఇటరేటర్‌ను తీసివేయడం ద్వారా వెక్టార్‌లోని ఈ మూలకాల స్థానాలను కోడ్ ముద్రిస్తుంది, ఇది వెక్టార్‌లోని మూలకం యొక్క సూచికను ఇస్తుంది.
అవుట్‌పుట్
ముగింపు
C++లో దిగువ_బౌండ్() పద్ధతి క్రమబద్ధీకరించబడిన కంటైనర్‌లో ఇచ్చిన విలువ యొక్క మొదటి సంఘటనను కనుగొంటుంది. ఇది C++లోని