எனவே நீங்கள் இருக்கிறீர்கள். நிம்மதியாக. தீர்ந்துவிட்டது. உங்கள் நேர்காணல் உங்களிடம் கேட்கும் தந்திரமான குறியீட்டு கேள்வியை தீர்க்க ஒரு அணுகுமுறையை நீங்கள் இறுதியாக கொண்டு வந்துள்ளீர்கள். ஒருவேளை நீங்கள் அதை ஒயிட் போர்டில், வரி மூலம் எழுதலாம். நீங்கள் நல்ல நேரம் செய்தீர்கள்! நீங்கள் கூட்டத்திற்கு 20 நிமிடங்கள் மட்டுமே. உங்கள் நேர்காணல் செய்பவர் ஈர்க்கப்பட வேண்டும்.
சரியா?
"இது வேலை செய்யும், ஆனால் அதை எவ்வாறு திறமையாக செய்வது என்பதற்கான ஏதேனும் யோசனைகள் உள்ளதா?"
உங்கள் இதயம் மூழ்கும். நீங்கள் தந்திரமான வழிமுறை வடிவமைப்பு பகுதியுடன் முடித்துவிட்டீர்கள் என்று நினைத்தீர்கள்! சிக்கலைத் தீர்ப்பதற்கான கூடுதல் வழிகளைப் பற்றி நீங்கள் சிந்திக்க முயற்சிக்கிறீர்கள், ஆனால் நீங்கள் ஏற்கனவே கொண்டு வந்த ஒரு அணுகுமுறையே நீங்கள் சிந்திக்க முடியும்.
இது கிட்டத்தட்ட அனைவருக்கும் நிகழ்கிறது. அவர்கள் முட்டாள் என்பதால் அல்ல. ஏனென்றால், பெரும்பாலானவர்களுக்கு அவர்களின் வழிமுறைகளின் செயல்திறனை மேம்படுத்த ஒரு முறை இல்லை.
ஆனால் உண்மை என்னவென்றால், நிறைய உள்ளன. அடுத்த முறை நீங்கள் ஸ்டம்பிங் செய்யும்போது, இந்த மூன்று பொதுவான அணுகுமுறைகளைப் பயன்படுத்த முயற்சிக்கவும்.
1. ஹாஷ் வரைபடத்தைப் பயன்படுத்தவும்
அது சரி. ஹாஷ் வரைபடங்கள் / துணை வரிசைகள் / அகராதிகள் (அவை நீங்கள் பயன்படுத்தும் நிரலாக்க மொழியைப் பொறுத்து பல பெயர்களால் செல்கின்றன) வழிமுறைகளின் இயக்க நேரத்தைக் குறைக்க ஒரு மந்திர திறனைக் கொண்டுள்ளன.
எடுத்துக்காட்டாக, எண்களின் வரிசையில் மிகவும் மீண்டும் மீண்டும் எண்ணைக் கண்டுபிடிப்பதே கேள்வி என்று வைத்துக்கொள்வோம்.
உங்கள் முதல் எண்ணம் சில சுழல்களில் குதிக்கலாம். எங்கள் ஒவ்வொரு எண்களுக்கும், அதன் எண்ணிக்கையைக் கண்டுபிடித்து, அது மிகப்பெரியதா என்று பாருங்கள். ஒவ்வொரு எண்ணுக்கான எண்ணிக்கையை எவ்வாறு பெறுவது? வரிசை வழியாக சுழற்று, அது எத்தனை முறை நிகழ்கிறது என்பதைக் கணக்கிடுகிறது! எனவே நாங்கள் இரண்டு உள்ளமை சுழல்களைப் பற்றி பேசுகிறோம். சூடோகுறியீட்டில்:
def get_mode (எண்கள்): எண்களில் சாத்தியமான_மொடிக்கு max_count = 0 பயன்முறை: பூஜ்யம்: எங்கள்_அரேயில் எண்ணுக்கு = 0: எண்ணிக்கை + = 1 என்றால் எண்ணிக்கை> = அதிகபட்சம்_குறிப்பு: பயன்முறை = சாத்தியமான_மொடி அதிகபட்ச_கணக்கு = எண்ணிக்கை திரும்பும் முறை
இப்போது, வரிசையில் உள்ள ஒவ்வொரு உருப்படிக்கும் ஒரு முறை எங்கள் முழு வரிசையிலும் சுழல்கிறோம் - ஆனால் நாங்கள் சிறப்பாகச் செய்ய முடியும். பெரிய O குறியீட்டில், இது மொத்தம் O (n 2 ) நேரம்.
எங்கள் எண்ணிக்கையை ஒரு ஹாஷ் வரைபடத்தில் சேமித்தால் (எண்களை அவற்றின் எண்ணிக்கையில் மேப்பிங் செய்கிறோம்), வரிசை (ஓ (என்) நேரம்!) வழியாக ஒரே ஒரு நடைப்பயணத்தில் சிக்கலை தீர்க்க முடியும்:
def get_mode (எண்கள்): max_count = 0 பயன்முறை = பூஜ்ய எண்ணிக்கைகள் = புதிய ஹாஷ்மேப், எண்களில் சாத்தியமான_மொடிக்கு ஒவ்வொரு மதிப்பையும் 0 எனத் தொடங்குகிறது: எண்ணிக்கைகள் + = 1 எண்ணிக்கையில் இருந்தால்> அதிகபட்சம்_குறிப்பு: பயன்முறை = சாத்தியமான_மொடி அதிகபட்ச_கணக்கு = திரும்பும் முறை
மிக வேகமாக!
2. பிட் கையாளுதலைப் பயன்படுத்துங்கள்
இது உங்களை பேக்கிலிருந்து ஒதுக்கி வைக்கும். இது ஒவ்வொரு பிரச்சினைக்கும் பொருந்தாது, ஆனால் இதை நீங்கள் உங்கள் பின் சட்டைப் பையில் வைத்து சரியான நேரத்தில் வெளியேற்றினால், நீங்கள் ஒரு ராக்ஸ்டார் போல இருப்பீர்கள்.
இங்கே ஒரு எடுத்துக்காட்டு: எங்களிடம் எண்களின் வரிசை இருந்தது என்று வைத்துக்கொள்வோம், அங்கு ஒவ்வொரு எண்ணும் இரண்டு முறை தோன்றும், ஒரு எண்ணைத் தவிர ஒரு முறை மட்டுமே நிகழ்கிறது. தனிமையான, மீண்டும் மீண்டும் செய்யாத எண்ணைக் கண்டுபிடிக்க ஒரு செயல்பாட்டை எழுதுகிறோம்.
உங்கள் முதல் உள்ளுணர்வு ஒரு ஹாஷ் வரைபடத்தைப் பயன்படுத்துவதாக இருக்கலாம், ஏனெனில் நாங்கள் அதைப் பற்றி பேசினோம். இது ஒரு நல்ல உள்ளுணர்வு! இது இதற்காக வேலை செய்யும். நாம் மிகவும் ஒத்த “எண்ணிக்கைகள்” வரைபடத்தை உருவாக்கலாம், மேலும் எந்த எண்ணிக்கையானது 1 எண்ணிக்கையுடன் முடிவடைகிறது என்பதைப் பார்க்க அதைப் பயன்படுத்தலாம்.
ஆனால் இன்னும் சிறந்த வழி இருக்கிறது. பிட் கையாளுதலை நீங்கள் அறிந்திருந்தால், நீங்கள் XOR உடன் தெரிந்திருக்கலாம். XOR இன் சிறப்பு என்னவென்றால், நீங்கள் ஒரு எண்ணை XOR செய்தால், பிட்கள் 0 க்கு "ரத்துசெய்கின்றன". இந்த சிக்கலுக்கு, வரிசையில் உள்ள ஒவ்வொரு எண்ணையும் நாம் XOR செய்தால், செய்யாத ஒரு எண்ணைக் கொண்டு எஞ்சியிருப்போம் ரத்து செய்யவில்லை:
def find_unrepeated (எண்கள்): எண்களில் எண்ணுக்கு மறுபரிசீலனை செய்யப்படாதது = 0: மறுபரிசீலனை செய்யப்படாதது = மீண்டும் செய்யப்படாத XOR எண் திரும்பத் திரும்பத் திரும்பத் திரும்ப வரவில்லை
3. கீழே செல்லுங்கள்
ஒரு எண் n கொடுக்கப்பட்ட “nth” Fibonacci எண்ணை வெளியிடும் ஒரு செயல்பாட்டை எழுதுங்கள். இது ஒரு உன்னதமானது, மேலும் இது மறுநிகழ்வுக்கு மிக நேர்த்தியாக உதவுகிறது:
def fib (n): n 0 அல்லது 1 ஆக இருந்தால்: 1 திரும்பும் இழை (n-1) + இழை (n-2)
ஆனால் எளிமையான சுழல்நிலை பதில் மட்டும் இல்லை! இந்த செயல்பாடு என்ன செய்கிறது என்பதை கவனமாக சிந்தியுங்கள். N 5 என்று வைத்துக்கொள்வோம். பதிலைப் பெற, அது மீண்டும் மீண்டும் ஃபைப் (4) மற்றும் ஃபைப் (3) என்று அழைக்கிறது. இப்போது, ஃபைப் (4) க்கு என்ன அழைப்பு? இது ஃபைப் (3) மற்றும் ஃபைப் (2) என்று அழைக்கிறது. ஆனால் நாங்கள் ஏற்கனவே ஃபைப் (3) க்கு அழைப்பு விடுத்துள்ளோம் என்று சொன்னோம்! இந்த அழகான சுழல்நிலை செயல்பாடு மீண்டும் மீண்டும் வேலை செய்கிறது. மொத்த நேர செலவு O (2 n ) ஆக மாறும். இது O (n 2 ) ஐ விட மோசமானது.
N இலிருந்து 1 க்கு கீழே செல்வதற்கு பதிலாக, 1 முதல் n வரை “கீழே-மேலே” செல்வோம். இது மறுநிகழ்வைத் தவிர்க்க எங்களுக்கு உதவுகிறது:
def fib (n): 1 முதல் n வரையிலான வரம்பில் i க்கு முந்தைய = 0 முந்தைய_பிரீவேஸ் = 1: நடப்பு = முந்தைய + முந்தைய_ முந்தைய_ முந்தைய_பிரிவு = முந்தைய முந்தைய = தற்போதைய வருவாய் தற்போதைய
குறியீடு நீளமானது, ஆனால் இது மிகவும் திறமையானது! O (n) நேரத்திற்கு கீழே. சுழல்நிலை வழிமுறைகளை நீக்குவதன் மூலம் கூடுதல் போனஸாக, நாங்கள் இடத்தை சேமிக்கிறோம். அந்த சுழல்நிலை அழைப்புகள் அனைத்தும் அழைப்பு அடுக்கில் உருவாகின்றன, இது நினைவகத்தில் அமர்ந்து எங்கள் இட செலவை கணக்கிடுகிறது. எங்கள் சுழல்நிலை செயல்பாட்டில் O (n) விண்வெளி செலவு இருந்தது, ஆனால் இந்த மறு செய்கை ஒன்று O (1) இடத்தை எடுக்கும்.
அடுத்த முறை உங்கள் நேர்காணல் உங்கள் தீர்வின் செயல்திறனை மேம்படுத்தும்படி கேட்கும்போது, இந்த உத்திகளைக் கடைப்பிடிக்க முயற்சிக்கவும், அவர்கள் உதவி செய்கிறார்களா என்று பார்க்கவும். போதுமான நடைமுறையில், உகந்த தீர்வுக்கு நேராக குதித்து, மிகவும் அப்பாவியாக இருக்கும் தீர்வைத் தவிர்ப்பீர்கள். அது ஒரு பெரிய விஷயம். நீங்கள் ஒரு சிறந்த நேர்காணல் ஆகிறீர்கள் என்று அர்த்தமல்ல - அதாவது நீங்கள் ஒரு சிறந்த பொறியியலாளராக மாறுகிறீர்கள்.
