ఈ వ్యాసం నుండి, మీరు ఈ రెండు ఫంక్షన్ల మధ్య తేడాలను కనుగొంటారు మరియు అవి ఎలా పని చేస్తాయో అర్థం చేసుకుంటారు.
C++లో షఫుల్() చేయండి
ది షఫుల్ () ఫంక్షన్ అనేది ఇచ్చిన పరిధిలోని మూలకాలను యాదృచ్ఛికంగా షఫుల్ చేయడానికి లేదా క్రమాన్ని మార్చడానికి ఉపయోగించే అంతర్నిర్మిత C++ ఫంక్షన్. ఫంక్షన్ లో ప్రకటించబడింది <అల్గోరిథం> శీర్షిక ఫైల్ మరియు రెండు ఆర్గ్యుమెంట్‌లు ఉన్నాయి: పరిధి యొక్క ప్రారంభ స్థానం మొదటి ఆర్గ్యుమెంట్, మరియు రెండవ ఆర్గ్యుమెంట్ ముగింపు స్థానాన్ని సూచిస్తుంది.
అదనంగా, ఇది ఒక ఐచ్ఛిక మూడవ పరామితిని కూడా తీసుకుంటుంది, ఇది శ్రేణిలోని మూలకాలను షఫుల్ చేయడానికి ఉపయోగించే యాదృచ్ఛిక సంఖ్యలను రూపొందించే ఒక ఫంక్షన్ ఆబ్జెక్ట్.
ఎప్పుడు అయితే షఫుల్ () ఫంక్షన్ అంటారు, ఇది అందించిన యాదృచ్ఛిక సంఖ్య జనరేటర్‌ని ఉపయోగించి పేర్కొన్న పరిధిలోని మూలకాలను యాదృచ్ఛికంగా క్రమాన్ని మార్చుతుంది. షఫుల్ ఫలితం ఊహించదగినది కాదు మరియు మూలకాల యొక్క ప్రతి ప్రస్తారణ సమానంగా జరిగే అవకాశం ఉంది.
ఉదాహరణ
ఉపయోగించిన క్రింది ఉదాహరణను పరిగణించండి షఫుల్() ఫంక్షన్ C++లో. ఈ ప్రోగ్రామ్‌లో, మేము వెక్టర్‌ని సృష్టించాము ఒక వస్తువు పూర్ణాంకాల విలువలు 0 నుండి 10 వరకు ఉంటాయి. అప్పుడు మేము యాదృచ్ఛిక సంఖ్య జనరేటర్‌ను రూపొందిస్తాము, అది వెక్టార్ పరిధితో పాటుగా పంపబడుతుంది షఫుల్ () ఫంక్షన్. ది షఫుల్ () ఫంక్షన్ సంఖ్యను తీసుకుంటుంది మరియు ఈ సంఖ్య ఆధారంగా మూలకాలను మార్చుకుంటుంది. అప్పుడు మేము for loopని ఉపయోగించి పునర్వ్యవస్థీకరించబడిన వెక్టర్ క్రమాన్ని ముద్రించాము
#
#
#
# <యాదృచ్ఛిక> చేర్చండి
#
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
వెక్టర్ < int > ఒక వస్తువు { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 } ;
సంతకం చేయలేదు విత్తనం = కాలక్రమం :: సిస్టమ్_గడియారం :: ఇప్పుడు ( ) . కాలం_నుండి_యుగం ( ) . లెక్కించండి ( ) ;
షఫుల్ ( ఒక వస్తువు. ప్రారంభం ( ) , ఒక వస్తువు. ముగింపు ( ) , డిఫాల్ట్_రాండమ్_ఇంజిన్ ( విత్తనం ) ) ;
కోట్ << 'షఫుల్ చేయబడిన అంశాలు:' ;
కోసం ( int & i : ఒక వస్తువు )
కోట్ << '' << i ;
కోట్ << endl ;
తిరిగి 0 ;
}
C++లో random_shuffle().
ది random_shuffle() ఫంక్షన్ కూడా యాదృచ్ఛికంగా కొన్ని యాదృచ్ఛికంగా ఎంచుకున్న సంఖ్యతో ఇచ్చిన పరిధిలోని మూలకాలను తిరిగి అమర్చుతుంది. ఇది యాదృచ్ఛిక సంఖ్యల క్రమాన్ని రూపొందించడానికి యాదృచ్ఛిక సంఖ్య జనరేటర్‌ను ఉపయోగిస్తుంది మరియు ఆ సంఖ్యలను పరిధిలోని మూలకాలను షఫుల్ చేయడానికి ఉపయోగిస్తుంది, కాబట్టి మీరు ప్రోగ్రామ్‌ను అమలు చేసిన ప్రతిసారీ ప్రోగ్రామ్ యొక్క క్రమం భిన్నంగా ఉంటుంది.
కోసం రెండు పారామితులు అవసరం random_shuffle() : పరిధి యొక్క ప్రారంభ స్థానం మొదటి పరామితి మరియు రెండవ పరామితి ముగింపు స్థానం. అదనంగా, random_shuffle() ఐచ్ఛిక మూడవ పరామితిని తీసుకోవచ్చు, ఇది ఎలిమెంట్‌లను షఫుల్ చేయడానికి యాదృచ్ఛిక సంఖ్యలను రూపొందించడానికి ఉపయోగించే ఫంక్షన్ ఆబ్జెక్ట్.
ఉదాహరణ
దిగువ ఉదాహరణ దాని పనిని వివరిస్తుంది random_shuffle() C++లో. ఈ కోడ్‌లో, మేము a సృష్టించాము వెక్టర్ విషయం పూర్ణాంకాల విలువలతో 1 నుండి 10 వరకు ఆపై ఉపయోగించబడుతుంది లూప్ కోసం యాదృచ్ఛికంగా షఫుల్ చేయబడిన క్రమాన్ని ముద్రించడానికి:
##
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
వెక్టర్ < int > ఒక వస్తువు { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 } ;
srand ( స్టాటిక్_కాస్ట్ < సంతకం చేయలేదు int > ( సమయం ( nullptr ) ) ) ;
యాదృచ్ఛిక_షఫుల్ ( ఒక వస్తువు. ప్రారంభం ( ) , ఒక వస్తువు. ముగింపు ( ) ) ;
కోసం ( int i : ఒక వస్తువు ) {
కోట్ << i << '' ;
}
కోట్ << ' \n ' ;
తిరిగి 0 ;
}
షఫుల్() మరియు రాండమ్_షఫుల్() మధ్య వ్యత్యాసం
మధ్య ప్రధాన తేడాలు ఇక్కడ ఉన్నాయి షఫుల్ () మరియు random_shuffle() C++లో విధులు.
1: random_shuffle() షఫుల్ చేయడానికి మూలకాల పరిధిని సూచించే ఒక జత ఇటరేటర్‌లను తీసుకుంటుంది షఫుల్ () షఫుల్ చేయడానికి మూలకాల పరిధిని సూచించే ఒక జత ఇటరేటర్‌లను తీసుకుంటుంది, అలాగే షఫుల్ చేయడానికి ఉపయోగించే యాదృచ్ఛిక సంఖ్య జనరేటర్‌ను తీసుకుంటుంది.
2: random_shuffle() కంటే సాధారణంగా తక్కువ సమర్థవంతమైనది షఫుల్ () , ఇది షఫుల్ కోసం ఉపయోగించడానికి యాదృచ్ఛిక సంఖ్యల క్రమాన్ని రూపొందించాలి.
3: random_shuffle() మూలకాలను షఫుల్ చేయడానికి C++ స్టాండర్డ్ లైబ్రరీ యొక్క యాదృచ్ఛిక సంఖ్య జనరేటర్ యొక్క అంతర్గత అమలును ఉపయోగిస్తుంది, అయితే షఫుల్ () షఫులింగ్ కోసం ఉపయోగించడానికి మీ స్వంత యాదృచ్ఛిక సంఖ్య జనరేటర్‌ను పేర్కొనడానికి మిమ్మల్ని అనుమతిస్తుంది, ఇది షఫుల్ యొక్క యాదృచ్ఛికతపై మీకు మరింత నియంత్రణను ఇస్తుంది.
4: random_shuffle() C++98లో ప్రవేశపెట్టబడింది మరియు C++ స్టాండర్డ్ లైబ్రరీ యొక్క అన్ని వెర్షన్‌ల ద్వారా మద్దతు ఉంది షఫుల్ () C++11లో ప్రవేశపెట్టబడింది మరియు ప్రమాణం యొక్క ఆ సంస్కరణను అమలు చేసే కంపైలర్‌ల ద్వారా మాత్రమే మద్దతు ఉంది.
తుది ఆలోచనలు
మధ్య ఎంపిక షఫుల్ () మరియు random_shuffle() మీ నిర్దిష్ట వినియోగ సందర్భం మరియు అవసరాలపై ఆధారపడి ఉంటుంది. షఫులింగ్ యొక్క యాదృచ్ఛికతపై మీకు మరింత నియంత్రణ అవసరమైతే లేదా మీరు అనుకూల యాదృచ్ఛిక సంఖ్య జనరేటర్‌ని ఉపయోగించాలనుకుంటే, అప్పుడు షఫుల్ () ఒక మంచి ఎంపిక ఉంటుంది. మరోవైపు, మీకు ఆ స్థాయి నియంత్రణ అవసరం లేకుంటే మరియు ఎలిమెంట్‌లను షఫుల్ చేయడానికి సులభమైన మార్గం కావాలనుకుంటే, అప్పుడు random_shuffle() సరిపోతుంది.