Codility பாணியிலான coding தேர்வுப் பயிற்சி

உண்மையான தேர்வு பொதுவாக எப்படி இருக்கும்

Codility தேர்வு என்று ஒன்றே ஒன்று இல்லை. Codility ஒரு தளம்: ஒவ்வொரு நிறுவனமும் தங்களின் தேர்வுக்கான பணிகள், அனுமதிக்கப்படும் மொழிகள் மற்றும் நேர வரம்பைத் தேர்வு செய்கிறது. உங்களுக்கு வரவிருக்கும் தேர்வு குறித்த சிறந்த வழிகாட்டி, நிறுவனத்திடமிருந்து வரும் அழைப்பிதழ்தான்.

Codility தெரிவிப்பது. ஒவ்வொரு பணியும் நிர்ணயிக்கப்பட்ட அளவுகோல்களின் அடிப்படையில் தானாகவே மதிப்பிடப்படும் என்று Codility கூறுகிறது (Codility). புரோகிராமர்களுக்கான அதன் இலவசப் பாடங்கள் (Codility) பணிகளின் வடிவத்தைக் காட்டுகின்றன: ஒரு சிறிய சிக்கல், எழுத வேண்டிய function, குறிப்பிடப்பட்ட input வரம்புகள். உதாரணமாக, அதன் BinaryGap பாடப் பணி 2,147,483,647 வரையிலான input-களுக்கு "an efficient algorithm" எழுதக் கோருகிறது (Codility). அதன் பாடங்களில் ஒன்று Time Complexity என்ற தலைப்பைக் கொண்டுள்ளது (Codility).

Codility தேர்வுகள் குறித்து பொதுவாகத் தெரிவிக்கப்படுபவை (தேர்வர்கள் மற்றும் வழிகாட்டிகளிடமிருந்து கிடைத்த தகவல்கள்; எங்களால் அணுக முடிந்த Codility பக்கத்தில் உறுதிப்படுத்தப்படவில்லை):

• ஒரே நேரக் கணக்கில் சில பணிகள்: முழுத் தேர்வுக்கும் ஒரே timer இருக்கும்; பெரும்பாலும் 30 minutes முதல் 2 hours வரை.
• மறைக்கப்பட்ட சரிபார்ப்புச் சோதனைகள்: பணியில் உள்ள உதாரணத்தைத் தாண்டி, நீங்கள் பார்க்க முடியாத நிலைகளிலும் உங்கள் code சரிபார்க்கப்படும்.
• பெரிய input-களில் செயல்திறன்: algorithm சார்ந்த பணிகளில், சரியானதாயிருந்தாலும் மெதுவான தீர்வுக்கு மதிப்பெண்கள் குறையலாம்.
• நீங்கள் எடுத்துக்கொள்ளும் நேரம்: நேர வரம்புக்குள் நீங்கள் எடுத்துக்கொள்ளும் நேரம் மதிப்பெண்ணின் ஒரு பகுதியாகாது.

எங்கள் மாதிரித் தேர்வுகளில் உள்ளவை. ஒவ்வொரு முழு மாதிரித் தேர்விலும் எளிய பணியிலிருந்து கடினமான பணி வரை 90 minutes-ல் மூன்று coding பணிகள் இருக்கும். Python, JavaScript, Java அல்லது C++-இல் தீர்வை எழுதி இயக்கலாம். அது மறைக்கப்பட்ட test case-களுடன் சரிபார்க்கப்படும்; வெற்றிகரமாகக் கடக்கும் ஒவ்வொரு case-க்கும் மதிப்பெண் கிடைக்கும். Laptop பயன்படுத்தப் பரிந்துரைக்கப்படுகிறது. சமர்ப்பிக்கும் வரை திரும்பிச் சென்று தீர்வை மாற்றலாம்.

எங்கள் மாதிரித் தேர்வுகள் வித்தியாசமாகச் செயல்படும் விதம். உண்மையான Codility பணிகள் சரியானதா என்றும், பல பணிகளில் பெரிய input-களில் செயல்திறன் எப்படி உள்ளது என்றும் சரிபார்க்கப்படுவதாகப் பொதுவாகத் தெரிவிக்கப்படுகிறது. எங்களின் மறைக்கப்பட்ட case-கள் சிறியவை; அவை சரியான விடையையும் edge case-களையும் சரிபார்க்கும். எனவே மெதுவான தீர்வுக்கு நேரம் முடிந்துவிடாது. பெரிய input-க்கு எத்தகைய complexity தேவை என்பதை ஒவ்வொரு பணியின் விளக்கமும் குறிப்பிடும். 10 இலவசக் கேள்விகளும் பல்தேர்வு முறையில் இருக்கும். அவை சரியான விடை, complexity, edge case-கள் மற்றும் வேகம் பற்றியவை - இந்தச் சரிபார்ப்புகளில் தேர்ச்சி பெறுவதற்கான சிந்தனை முறையைப் பயிற்சி செய்ய உதவும்.

விளக்கத்துடன் கூடிய எடுத்துக்காட்டுகளுடன் கேள்வி வகைகள்

ஒவ்வொரு வகைக் கேள்விக்கும் ஒரு எடுத்துக்காட்டு, பலரும் செய்யும் தவறையும் சேர்த்து.

1. எந்த solution சரியானது. பணி: ஒரு list-இல் உள்ள தனித்துவமான மதிப்புகளின் எண்ணிக்கையைத் தர வேண்டும். Solution: len(set(A)). காலியான list உட்பட எல்லா list-களுக்கும் இது சரியானது; காலியான list-க்கு 0 கிடைக்கும். தவறு ஏற்படக்கூடிய இடம்: sorted list-ஐப் பயன்படுத்தி சொந்தமாக loop எழுதும்போது முதல் அல்லது கடைசி உருப்படியை மறந்துவிடுவது. ஏற்கெனவே உள்ள built-in இதைச் செய்யுமானால், edge cases-ஐச் சரியாகக் கையாளுகிறதா என்று பார்த்துவிட்டு அதைப் பயன்படுத்துங்கள்.

2. Time complexity. ஒரு solution, A-ஐச் சுற்றி loop செய்கிறது; அந்த loop-க்குள் max(A[:i])-ஐ அழைக்கிறது. Slice மற்றும் max இரண்டும் தலா i உருப்படிகள் வரை அணுகுவதால், மொத்தம் சுமார் N squared-ஐ 2-ஆல் வகுத்த படிகள், அதாவது O(N squared). அதற்குப் பதிலாக running maximum வைத்திருந்தால் O(N) ஆகும். தவறு ஏற்படக்கூடிய இடம்: ஒரு loop-ஐப் பார்த்துவிட்டு O(N) என்று முடிவு செய்வது. அதற்குள் slices, sums, counts, searches உள்ளனவா என்று பாருங்கள்.

3. எந்த input-இல் இது தோல்வியடையும். பணி: A-இல் இல்லாத மிகச் சிறிய நேர்ம முழு எண்ணைத் தர வேண்டும். ஒரு solution max(A) + 1 எனத் தருகிறது. A = [1, 2, 3] என்று முயற்சிக்கவும்: அது 4 எனத் தருகிறது; இது சரி. A = [1, 3] என்று முயற்சிக்கவும்: அது 4 எனத் தருகிறது. ஆனால் 2 இல்லை; எனவே பதில் 2. A = [-3, -1] என்று முயற்சிக்கவும்: அது 0 எனத் தருகிறது; ஆனால் பதில் 1. தவறு ஏற்படக்கூடிய இடம்: ஒரு சரியான case கிடைத்ததும் நிறுத்திவிடுவது. இடைவெளிகள், அனைத்தும் எதிர்மறை மதிப்புகள், அனுமதிக்கப்பட்டால் காலியான list, ஒரு உருப்படி, அனைத்தும் ஒரே மதிப்பு, அனுமதிக்கப்பட்ட அதிகபட்ச மதிப்புகள் என edge cases-ஐத் திட்டமிட்டுப் பட்டியலிடுங்கள்.

4. N 100,000 வரை இருக்கும்போது போதுமான வேகம். தோராயமான வழிகாட்டியாக, அந்த அளவில் O(N) அல்லது O(N log N) இலக்காகக் கொள்ளுங்கள். O(N squared) என்றால் சுமார் 10 billion படிகள்; இது பொதுவான time limit-ஐவிட மிக அதிகம். தவறு ஏற்படக்கூடிய இடம்: பத்து உருப்படிகளைக் கொண்டு சோதிப்பது. அப்போது எல்லா முறைகளும் உடனடியாகச் செயல்படுவதுபோல் தோன்றும். N அதிகரிக்கும்போது வேலை எவ்வாறு அதிகரிக்கிறது என்று சிந்தியுங்கள்.

5. வரம்புகளைப் படித்தல். மதிப்புகள் 1,000,000,000 வரை இருக்கலாம் என்றும் N 100,000 என்றும் இருந்தால், மொத்தத் தொகை 100 trillion வரை செல்லலாம். Python-இன் integers இதைக் கையாளும். ஆனால் fixed-size integers கொண்ட மொழிகளில் overflow ஏற்படும். தவறு ஏற்படக்கூடிய இடம்: மதிப்புகளின் வரம்பைப் புறக்கணிப்பது. இது overflow ஏற்படுமா என்பதையும், counting array போன்ற வழிமுறைகளைப் பயன்படுத்த முடியுமா என்பதையும் சொல்கிறது.

எப்படித் தயாராவது

1. முதலில் உங்கள் அழைப்பிதழைப் படியுங்கள். பணிகளின் எண்ணிக்கை, மொத்த நேரம் மற்றும் அனுமதிக்கப்பட்ட மொழிகளைக் குறித்துக்கொள்ளுங்கள். இவற்றை நிறுவனங்களே தீர்மானிக்கின்றன; எனவே நீங்களாகவே ஊகிக்க வேண்டாம்.
2. உங்களுக்கு நன்றாகத் தெரிந்த ஒரு மொழியைப் பயன்படுத்துங்கள். அதன் lists, dictionaries, sets, sorting மற்றும் string methods ஆகியவற்றைத் தேடிப் பார்க்காமல் பயன்படுத்தத் தெரிந்துகொள்ளுங்கள்.
3. Code எழுதுவதற்கு முன் வரம்புகளைப் படியுங்கள். ஒரு பணியில் குறிப்பிடப்பட்டுள்ள input அளவுகளும் மதிப்பு வரம்புகளும், தீர்வு எவ்வளவு வேகமாக இருக்க வேண்டும், எந்த edge case-கள் முக்கியம் என்பதைத் தெரிவிக்கும். Codility-யின் சொந்தப் பாடப் பணிகளும் இதற்கு உதாரணம் (Codility).
4. முதலில் சரியாக்குங்கள், பிறகு வேகப்படுத்துங்கள். முதலில் எளிய, சரியான பதிப்பை எழுதுங்கள். அது O(N squared) ஆகவும் N 100,000 வரை செல்லக்கூடியதாகவும் இருந்தால், அதை மேம்படுத்த running total, dictionary, set அல்லது sorting பயன்படுத்த முடியுமா என்று பாருங்கள்.
5. Edge case-களை நீங்களே சோதியுங்கள். பணியில் உள்ள உதாரணம் ஒரே ஒரு case மட்டுமே. அனுமதிக்கப்பட்டால் காலியான input, ஒரே ஒரு உருப்படி, அனைத்தும் ஒரே மதிப்பாக இருப்பது, எதிர்மறை மதிப்புகள், மிகச் சிறிய மற்றும் மிகப் பெரிய மதிப்புகள், மிகப் பெரிய N ஆகியவற்றை முயற்சியுங்கள்.
6. பொதுவான முறைகளைக் கற்றுக்கொள்ளுங்கள். Prefix sums, sliding windows, dictionary மூலம் எண்ணுதல், two pointers, முதலில் sorting செய்தல், எளிய greedy தேர்வுகள் ஆகியவை பல சிறிய algorithm பணிகளுக்குப் பயன்படும். Codility-யின் இலவசப் பாடங்கள் இந்தப் பணிகளின் பாணியைப் பார்ப்பதற்கு நல்ல இடம் (Codility).
7. நேர வரம்புக்குள் முழுத் தீர்வுகளை எழுதிப் பழகுங்கள். எங்கள் முழு மாதிரித் தேர்வுகளில் மறைக்கப்பட்ட case-களுக்கு எதிராக code எழுதி இயக்குவீர்கள். நேர வரம்புக்குள் எழுதுவது இயல்பாகத் தோன்றும் வகையில், நீங்களே தேர்ந்தெடுத்த பணிகளிலும் இதேபோல் பயிற்சி செய்யுங்கள்.
8. உண்மையான வேகத்தில் பயிற்சி செய்யுங்கள். ஒரே நேரக் கணக்கில் மூன்று பணிகளைச் செய்து முடிப்பது தேர்வு நாளில் இயல்பாகத் தோன்ற, முழுமையான நேரக் கட்டுப்பாட்டுடன் கூடிய மாதிரித் தேர்வுகளை முயற்சியுங்கள்.

பொதுவாக மதிப்பெண் வழங்கும் முறை

மதிப்பீட்டு முறையை ஒவ்வொரு பணியமர்த்துநரும் அமைக்கிறார். ஒவ்வொரு பணியும் நிர்ணயிக்கப்பட்ட அளவுகோல்களின்படி தானாக மதிப்பிடப்படுவதாக Codility தெரிவிக்கிறது (Codility). எந்த மதிப்பெண் போதுமானது என்பதை ஒவ்வொரு பணியமர்த்துநரும் முடிவு செய்கிறார். எல்லோருக்கும் பொதுவான தேர்ச்சி மதிப்பெண் எதுவும் இல்லை.

இந்த அளவுகோல்கள் எவ்வாறு செயல்படுகின்றன என்பது பொதுவாகத் தெரிவிக்கப்படுவது: ஒரு பணிக்கான மதிப்பெண், மறைக்கப்பட்ட சரித்தன்மைச் சோதனைகளையும், பல அல்காரிதம் பணிகளில் பெரிய உள்ளீடுகளுக்கான செயல்திறன் சோதனைகளையும் அடிப்படையாகக் கொண்டது. இவை இணைக்கப்பட்டு, அந்தப் பணிக்கும் பின்னர் முழுத் தேர்வுக்கும் சதவீதமாகக் கணக்கிடப்படுகின்றன. சிறிய உள்ளீடுகளில் சரியாகச் செயல்பட்டாலும் பெரிய உள்ளீடுகளில் மிக மெதுவாக இருக்கும் தீர்வு, செயல்திறன் புள்ளிகளை இழக்கலாம். ஒரு விளிம்பு நிலைச் சோதனையில் தோல்வியடையும் தீர்வு, சரித்தன்மை மதிப்பெண்ணின் ஒரு பகுதியை இழக்கும். இதனால்தான் எங்கள் மாதிரித் தேர்வுகளில் "இது சரியா?" என்றும் "இது போதுமான வேகத்தில் உள்ளதா?" என்றும் தனித்தனியாகக் கேட்கிறோம்.

எங்கள் பயிற்சி மதிப்பெண் என்பது எங்கள் கேள்விகளில் நீங்கள் சரியாகப் பதிலளித்தவற்றின் எண்ணிக்கை. பணி வாரியான விவரங்களும் இதில் உள்ளதால், எதில் கவனம் செலுத்த வேண்டும் என்பதை நீங்கள் அறியலாம். இது ஒரு பயிற்சி மதிப்பெண் மட்டுமே: இது Codility மதிப்பெண்ணோ, எந்தப் பணியமர்த்துநரின் முடிவோ அல்ல; நீங்கள் தேர்ச்சி பெறுவீர்களா என்பதையும் இது கணிக்காது.

பொதுவான தவறுகள்

• உதாரணத்தை மட்டும் நம்புவது. ஒரு task-இன் உதாரணம், பல மறைக்கப்பட்ட test case-களில் ஒன்று மட்டுமே. ஒரு solution அதில் வெற்றி பெற்றாலும், மொத்த score-இல் பெரும்பாலானவற்றில் தோல்வியடையலாம்.
• N-ஐப் புறக்கணிப்பது. சரியான O(N squared) solution கூட, N = 100,000 ஆக இருக்கும்போது performance checks-இல் தோல்வியடையலாம். முதலில் limits-ஐச் சரிபார்க்கவும்.
• Loop-க்குள் மறைந்திருக்கும் வேலை. Loop-க்குள் list-இல் செய்யப்படும் slice, sum, count, index அல்லது "in" செயல்பாடு செலவைப் பல மடங்காக்கும்.
• கடைசி உருப்படியைத் தவறவிடுவது. Off-by-one ranges மற்றும் list-இன் இறுதியில் முடியும் runs ஆகியவை பொதுவான தோல்விக்கான காரணங்கள். கடைசிப் படியை கையால் கண்காணிக்கவும்.
• தொடக்க மதிப்புகள் தவறாக இருப்பது. Maximum-ஐ 0-இல் தொடங்குவதோ, minimum-ஐ கற்பனையான பெரிய எண்ணில் தொடங்குவதோ, எதிர்மறை அல்லது மிகப் பெரிய மதிப்புகளைக் கையாளும்போது சிக்கலை ஏற்படுத்தும். முதல் உருப்படியிலிருந்து தொடங்கவும்.
• Task சார்ந்திருக்கும் வரிசையை மாற்றுவது. Sorting ஒரு சிறந்த கருவி. ஆனால் பதில் இடங்கள் அல்லது "list-இல் முதலில் வருவது" என்பதைச் சார்ந்திருந்தால், sorting செய்யக்கூடாது.
• ஒரே task-க்காக எல்லா நேரத்தையும் செலவிடுவது. முதலில் ஒவ்வொரு task-க்கும் சரியான version-ஐச் சமர்ப்பிக்கவும். பிறகு நேரம் இருந்தால் வேகத்தை மேம்படுத்தவும்.