இந்த கட்டுரையிலிருந்து, இந்த இரண்டு செயல்பாடுகளுக்கும் இடையிலான வேறுபாடுகளை நீங்கள் கண்டறிந்து அவை எவ்வாறு செயல்படுகின்றன என்பதைப் புரிந்துகொள்வீர்கள்.
C++ இல் கலக்கவும்().
தி கலக்கு() செயல்பாடு என்பது ஒரு உள்ளமைக்கப்பட்ட C++ செயல்பாடாகும், இது கொடுக்கப்பட்ட வரம்பில் உள்ள உறுப்புகளை சீரற்ற முறையில் கலக்க அல்லது மறுசீரமைக்கப் பயன்படுகிறது. செயல்பாடு அறிவிக்கப்பட்டுள்ளது <வழிமுறை> தலைப்பு கோப்பு மற்றும் இரண்டு வாதங்கள் உள்ளன: வரம்பின் தொடக்க நிலை முதல் வாதம், மற்றும் இரண்டாவது வாதம் முடிவு நிலையை குறிக்கிறது.
கூடுதலாக, இது ஒரு விருப்பமான மூன்றாவது அளவுருவையும் எடுக்கும், இது ஒரு செயல்பாட்டு பொருளாகும், இது வரம்பில் உள்ள உறுப்புகளை மாற்றுவதற்கு சீரற்ற எண்களை உருவாக்குகிறது.
எப்பொழுது கலக்கு() செயல்பாடு என்று அழைக்கப்படுகிறது, இது வழங்கப்பட்ட ரேண்டம் எண் ஜெனரேட்டரைப் பயன்படுத்தி குறிப்பிட்ட வரம்பில் உள்ள உறுப்புகளை தோராயமாக மறுவரிசைப்படுத்துகிறது. மாற்றத்தின் முடிவு கணிக்க முடியாதது, மேலும் உறுப்புகளின் ஒவ்வொரு சாத்தியமான வரிசைமாற்றமும் சமமாக நிகழும்.
உதாரணமாக
பயன்படுத்துவதற்கான பின்வரும் உதாரணத்தைக் கவனியுங்கள் shuffle() செயல்பாடு C++ இல். இந்த நிரலில், நாங்கள் திசையன் உருவாக்கியுள்ளோம் ஒரு விஷயம் 0 முதல் 10 வரையிலான முழு எண் மதிப்புகளுடன். பின்னர் நாம் ஒரு சீரற்ற எண் ஜெனரேட்டரை உருவாக்குகிறோம், பின்னர் அது திசையன் வரம்புடன் அனுப்பப்படும் கலக்கு() செயல்பாடு. தி கலக்கு() செயல்பாடு எண்ணை எடுத்து இந்த எண்ணின் அடிப்படையில் உறுப்புகளை மாற்றுகிறது. பின்னர் for loop ஐப் பயன்படுத்தி மறுசீரமைக்கப்பட்ட திசையன் வரிசையை அச்சிட்டோம்
#
#
#
# <ரேண்டம்> அடங்கும்
#
பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( )
{
திசையன் < முழு எண்ணாக > ஒரு விஷயம் { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 } ;
கையொப்பமிடாத விதை = காலவரிசை :: கணினி_கடிகாரம் :: இப்போது ( ) . காலம்_முதல்_காலம் ( ) . எண்ணிக்கை ( ) ;
கலக்கு ( ஒரு விஷயம். தொடங்கும் ( ) , ஒரு விஷயம். முடிவு ( ) , default_random_engine ( விதை ) ) ;
கூட் << 'குலைக்கப்பட்ட கூறுகள்:' ;
க்கான ( முழு எண்ணாக & நான் : ஒரு விஷயம் )
கூட் << '''' << நான் ;
கூட் << endl ;
திரும்ப 0 ;
}
C++ இல் random_shuffle().
தி random_shuffle() செயல்பாடு, கொடுக்கப்பட்ட வரம்பில் உள்ள தனிமங்களை சில தோராயமாக தேர்ந்தெடுக்கப்பட்ட எண்ணுடன் சீரற்ற முறையில் மறுசீரமைக்கிறது. இது சீரற்ற எண்களின் வரிசையை உருவாக்க ஒரு சீரற்ற எண் ஜெனரேட்டரைப் பயன்படுத்துகிறது, பின்னர் வரம்பில் உள்ள உறுப்புகளை மாற்ற அந்த எண்களைப் பயன்படுத்துகிறது, எனவே நீங்கள் நிரலை இயக்கும் ஒவ்வொரு முறையும் நிரலின் வரிசை வேறுபட்டதாக இருக்கும்.
இரண்டு அளவுருக்கள் தேவை random_shuffle() : வரம்பின் தொடக்க நிலை முதல் அளவுரு, மற்றும் இரண்டாவது அளவுரு முடிவு நிலை. கூடுதலாக, random_shuffle() விருப்பமான மூன்றாவது அளவுருவை எடுக்கலாம், இது ஒரு செயல்பாட்டு பொருளாகும், இது உறுப்புகளை மாற்றுவதற்கு சீரற்ற எண்களை உருவாக்க பயன்படுகிறது.
உதாரணமாக
கீழே உள்ள எடுத்துக்காட்டு அதன் செயல்பாட்டை விளக்குகிறது random_shuffle() C++ இல். இந்த குறியீட்டில், நாங்கள் உருவாக்கியுள்ளோம் திசையன் பொருள் 1 முதல் 10 வரையிலான முழு எண்களின் மதிப்புகள் மற்றும் பின்னர் பயன்படுத்தப்பட்டது வளையத்திற்கு தோராயமாக மாற்றப்பட்ட வரிசையை அச்சிட:
##
பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( )
{
திசையன் < முழு எண்ணாக > ஒரு விஷயம் { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 } ;
srand ( நிலையான_வார்ப்பு < கையொப்பமிடாத முழு எண்ணாக > ( நேரம் ( nullptr ) ) ) ;
சீரற்ற_குலைப்பு ( ஒரு விஷயம். தொடங்கும் ( ) , ஒரு விஷயம். முடிவு ( ) ) ;
க்கான ( முழு எண்ணாக நான் : ஒரு விஷயம் ) {
கூட் << நான் << '' ;
}
கூட் << ' \n ' ;
திரும்ப 0 ;
}
கலக்கல்() மற்றும் random_shuffle() இடையே உள்ள வேறுபாடு
இடையே உள்ள முக்கிய வேறுபாடுகள் இங்கே கலக்கு() மற்றும் random_shuffle() C++ இல் செயல்பாடுகள்.
1: random_shuffle() உறுப்புகளின் வரம்பைக் குறிக்கும் ஒரு ஜோடி மறு செய்கைகளை மாற்றுவதற்கு எடுக்கும் கலக்கு() கலப்பதற்கு உறுப்புகளின் வரம்பைக் குறிக்கும் ஒரு ஜோடி மறு செய்கைகளை எடுத்துக்கொள்கிறது.
2: random_shuffle() விட பொதுவாக குறைவான செயல்திறன் கொண்டது கலக்கு() , இது மாற்றுவதற்குப் பயன்படுத்த சீரற்ற எண்களின் வரிசையை உருவாக்க வேண்டும்.
3: random_shuffle() சி++ ஸ்டாண்டர்ட் லைப்ரரியின் ரேண்டம் நம்பர் ஜெனரேட்டரின் உள் செயலாக்கத்தைப் பயன்படுத்தி உறுப்புகளை மாற்றுகிறது. கலக்கு() மாற்றுவதற்குப் பயன்படுத்த உங்கள் சொந்த ரேண்டம் எண் ஜெனரேட்டரைக் குறிப்பிட உங்களை அனுமதிக்கிறது.
4: random_shuffle() C++98 இல் அறிமுகப்படுத்தப்பட்டது மற்றும் C++ ஸ்டாண்டர்ட் லைப்ரரியின் அனைத்து பதிப்புகளாலும் ஆதரிக்கப்படுகிறது கலக்கு() C++11 இல் அறிமுகப்படுத்தப்பட்டது மற்றும் தரநிலையின் அந்த பதிப்பை செயல்படுத்தும் கம்பைலர்களால் மட்டுமே ஆதரிக்கப்படுகிறது.
இறுதி எண்ணங்கள்
இடையே தேர்வு கலக்கு() மற்றும் random_shuffle() உங்கள் குறிப்பிட்ட பயன்பாட்டு வழக்கு மற்றும் தேவைகளைப் பொறுத்தது. ஷஃபிளிங்கின் சீரற்ற தன்மையின் மீது உங்களுக்கு கூடுதல் கட்டுப்பாடு தேவைப்பட்டால் அல்லது தனிப்பயன் ரேண்டம் எண் ஜெனரேட்டரைப் பயன்படுத்த விரும்பினால், பிறகு கலக்கு() ஒரு சிறந்த தேர்வாக இருக்கும். மறுபுறம், உங்களுக்கு அந்த அளவிலான கட்டுப்பாடு தேவையில்லை மற்றும் உறுப்புகளை மாற்றுவதற்கான எளிய வழியை விரும்பினால், பிறகு random_shuffle() போதுமானதாக இருக்கலாம்.