Codility-ശൈലിയിലുള്ള കോഡിങ് ടെസ്റ്റ് പരിശീലനം

യഥാർഥ ടെസ്റ്റ് സാധാരണയായി എങ്ങനെയിരിക്കും

ഒരൊറ്റ Codility ടെസ്റ്റ് ഇല്ല. Codility ഒരു പ്ലാറ്റ്‌ഫോമാണ്: ഓരോ തൊഴിലുടമയും അവരുടെ ടെസ്റ്റിനുള്ള ടാസ്‌ക്കുകളും അനുവദിക്കുന്ന പ്രോഗ്രാമിങ് ഭാഷകളും സമയപരിധിയും തിരഞ്ഞെടുക്കുന്നു. നിങ്ങൾക്ക് ലഭിക്കുന്ന ടെസ്റ്റ് ഏതാണെന്ന് മനസ്സിലാക്കാൻ തൊഴിലുടമയുടെ ക്ഷണമാണ് ഏറ്റവും നല്ല മാർഗ്ഗനിർദ്ദേശം.

Codility നൽകുന്ന വിവരങ്ങൾ. നിശ്ചിത മാനദണ്ഡങ്ങൾ ഉപയോഗിച്ച് ഓരോ ടാസ്‌ക്കും സ്വയം സ്‌കോർ ചെയ്യപ്പെടുന്നുവെന്ന് Codility പറയുന്നു (Codility). പ്രോഗ്രാമർമാർക്കുള്ള അവരുടെ സൗജന്യ പാഠങ്ങൾ (Codility) ടാസ്‌ക്കുകളുടെ രീതി കാണിക്കുന്നു: ഒരു ചെറിയ പ്രശ്നം, എഴുതേണ്ട ഒരു ഫങ്ഷൻ, വ്യക്തമാക്കിയ ഇൻപുട്ട് പരിധികൾ. ഉദാഹരണത്തിന്, അവരുടെ BinaryGap പാഠത്തിലെ ടാസ്‌ക് 2,147,483,647 വരെയുള്ള ഇൻപുട്ടുകൾക്കായി "കാര്യക്ഷമമായ ഒരു അൽഗോരിതം" എഴുതാൻ ആവശ്യപ്പെടുന്നു (Codility). ഒരു പാഠത്തിന്റെ പേര് Time Complexity എന്നാണ് (Codility).

Codility ടെസ്റ്റുകളെക്കുറിച്ച് സാധാരണയായി റിപ്പോർട്ട് ചെയ്യപ്പെടുന്നത് (കാൻഡിഡേറ്റുകളിൽ നിന്നും ഗൈഡുകളിൽ നിന്നും ലഭിച്ച വിവരങ്ങൾ; ഞങ്ങൾക്ക് തുറക്കാനായ Codility പേജിൽ സ്ഥിരീകരിച്ചിട്ടില്ല):

• ഒരു ടൈമറിനുള്ളിൽ കുറച്ച് ടാസ്‌ക്കുകൾ: മിക്കപ്പോഴും മുഴുവൻ ടെസ്റ്റിനും 30 മിനിറ്റിനും 2 മണിക്കൂറിനും ഇടയിൽ സമയപരിധിയുണ്ടാകും.
• മറഞ്ഞിരിക്കുന്ന കൃത്യതാ പരിശോധനകൾ: ടാസ്‌ക്കിലെ ഉദാഹരണത്തിനപ്പുറം, നിങ്ങൾക്ക് കാണാനാകാത്ത സാഹചര്യങ്ങൾ ഉപയോഗിച്ച് നിങ്ങളുടെ കോഡ് പരിശോധിക്കും.
• വലിയ ഇൻപുട്ടുകളിലെ പ്രകടനം: അൽഗോരിതം ആവശ്യമായ ടാസ്‌ക്കുകളിൽ, ശരിയായതെങ്കിലും വേഗം കുറഞ്ഞതുമായ പരിഹാരത്തിന് പോയിന്റുകൾ നഷ്ടപ്പെടാം.
• നിങ്ങൾ എടുക്കുന്ന സമയം: സമയപരിധിക്കുള്ളിൽ നിങ്ങൾ എത്ര സമയം എടുക്കുന്നു എന്നത് സ്‌കോറിന്റെ ഭാഗമല്ല.

ഞങ്ങളുടെ മോക്കുകളിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്നത്. ഓരോ സമ്പൂർണ മോക്കിലും എളുപ്പമുള്ളതിൽ നിന്ന് കൂടുതൽ ബുദ്ധിമുട്ടുള്ളതിലേക്ക് ക്രമപ്പെടുത്തിയ 90 മിനിറ്റിൽ മൂന്ന് കോഡിങ് ടാസ്‌ക്കുകൾ ഉണ്ട്. Python, JavaScript, Java അല്ലെങ്കിൽ C++ ഉപയോഗിച്ച് നിങ്ങൾ പരിഹാരം എഴുതി പ്രവർത്തിപ്പിക്കാം. മറഞ്ഞിരിക്കുന്ന ടെസ്റ്റ് കേസുകൾ ഉപയോഗിച്ച് അത് പരിശോധിക്കും; വിജയിക്കുന്ന ഓരോ കേസിനും ക്രെഡിറ്റ് ലഭിക്കും. ലാപ്‌ടോപ്പ് ഉപയോഗിക്കാൻ ശുപാർശ ചെയ്യുന്നു. സമർപ്പിക്കുന്നതുവരെ നിങ്ങൾക്ക് തിരികെ പോയി പരിഹാരം മാറ്റാം.

ഞങ്ങളുടെ മോക്കുകൾ വ്യത്യസ്തമാകുന്നത്. Codility ടാസ്‌ക്കുകൾ കൃത്യതയ്ക്കും, പല ടാസ്‌ക്കുകളിലും, വലിയ ഇൻപുട്ടുകളിലെ പ്രകടനത്തിനും പരിശോധിക്കപ്പെടുന്നുവെന്നാണ് സാധാരണയായി റിപ്പോർട്ട് ചെയ്യപ്പെടുന്നത്. ഞങ്ങളുടെ മറഞ്ഞിരിക്കുന്ന കേസുകൾ ചെറുതാണ്; കൃത്യതയും എഡ്ജ് കേസുകളും പരിശോധിക്കുന്നു. അതിനാൽ വേഗം കുറഞ്ഞ പരിഹാരത്തിന് സമയം തീരില്ല. വലിയ ഇൻപുട്ടിന് ആവശ്യമായ കോംപ്ലെക്സിറ്റി എന്താണെന്ന് ഓരോ ടാസ്‌ക്കിന്റെയും വിശദീകരണം പറയുന്നു. 10 സൗജന്യ ചോദ്യങ്ങൾ കൃത്യത, കോംപ്ലെക്സിറ്റി, എഡ്ജ് കേസുകൾ, വേഗം എന്നിവയെക്കുറിച്ചുള്ള മൾട്ടിപ്പിൾ ചോയ്‌സ് ചോദ്യങ്ങളാണ്. ഈ പരിശോധനകളിൽ വിജയിക്കാൻ ആവശ്യമായ ചിന്താരീതിയാണ് അവ പരിശീലിപ്പിക്കുന്നത്.

ഉദാഹരണങ്ങൾ സഹിതമുള്ള ചോദ്യങ്ങളുടെ തരങ്ങൾ

ഓരോ തരത്തിലുള്ള ചോദ്യത്തിനും ഒരു വിശദീകരിച്ച ഉദാഹരണം. മിക്കവരും വീഴുന്ന കുഴപ്പവും ഉൾപ്പെടുത്തിയിട്ടുണ്ട്.

1. ഏത് solution ആണ് ശരി. Task: ഒരു list-ലെ വ്യത്യസ്ത മൂല്യങ്ങളുടെ എണ്ണം നൽകുക. Solution: len(set(A)). ശൂന്യമായ list ഉൾപ്പെടെ എല്ലാ list-കൾക്കും ഇത് ശരിയാണ്; ശൂന്യമായ list-ന് 0 ലഭിക്കും. കുഴപ്പം: sorted list ഉപയോഗിച്ച് സ്വന്തം loop എഴുതുകയും ആദ്യത്തെയോ അവസാനത്തെയോ item മറക്കുകയും ചെയ്യുന്നത്. ഒരു built-in ഉപയോഗിച്ച് കാര്യം ചെയ്യാമെങ്കിൽ, edge case-കൾ ശരിയായി കൈകാര്യം ചെയ്യുന്നുണ്ടെന്ന് പരിശോധിച്ചശേഷം അത് ഉപയോഗിക്കുക.

2. Time complexity. ഒരു solution A-യിലൂടെ loop ചെയ്ത്, അതിനുള്ളിൽ max(A[:i]) വിളിക്കുന്നു. slice-ഉം max-ഉം ഓരോന്നും i items വരെ പരിശോധിക്കും. അതിനാൽ ആകെ steps ഏകദേശം N squared-ന്റെ പകുതിയാണ്, അതായത് O(N squared). പകരം running maximum സൂക്ഷിച്ചാൽ O(N) ആകും. കുഴപ്പം: ഒരു loop കണ്ടിട്ട് O(N) എന്ന് കരുതുന്നത്. അതിനുള്ളിലെ slice-കൾ, sum-കൾ, count-ുകൾ, search-കൾ എന്നിവ പരിശോധിക്കുക.

3. ഏത് input ആണ് പിഴവ് കണ്ടെത്തുക. Task: A-യിൽ ഇല്ലാത്ത ഏറ്റവും ചെറിയ positive integer നൽകുക. ഒരു solution max(A) + 1 നൽകുന്നു. A = [1, 2, 3] പരീക്ഷിച്ചാൽ 4 ലഭിക്കും, അത് ശരിയാണ്. A = [1, 3] പരീക്ഷിച്ചാൽ 4 ലഭിക്കും; പക്ഷേ 2 ഇല്ലാത്തതിനാൽ ഉത്തരം 2 ആണ്. A = [-3, -1] പരീക്ഷിച്ചാൽ 0 ലഭിക്കും; എന്നാൽ ഉത്തരം 1 ആണ്. കുഴപ്പം: ശരിയായ ഒരു case കണ്ടശേഷം പരിശോധന നിർത്തുന്നത്. Edge case-കൾ മനഃപൂർവം പട്ടികപ്പെടുത്തുക: ഇടവിട്ടുള്ള മൂല്യങ്ങൾ, എല്ലാം നെഗറ്റീവ്, അനുവദിച്ചിട്ടുണ്ടെങ്കിൽ ശൂന്യമായ list, ഒരു item, എല്ലാം ഒരേ മൂല്യം, അനുവദിച്ചിട്ടുള്ള ഏറ്റവും വലിയ മൂല്യങ്ങൾ.

4. N 100,000 വരെ ആയാലും മതിയായ വേഗം. ഒരു ഏകദേശ നിയമമായി, ആ വലുപ്പത്തിൽ O(N) അല്ലെങ്കിൽ O(N log N) ലക്ഷ്യമിടുക. O(N squared) എന്നാൽ ഏകദേശം 10 billion steps ആണ്; സാധാരണ time limit-നെക്കാൾ വളരെ കൂടുതലാണത്. കുഴപ്പം: പത്ത് items ഉപയോഗിച്ച് test ചെയ്യുന്നത്. അപ്പോൾ ഏത് രീതിയും ഉടൻ തീരുന്നതായി തോന്നും. N കൂടുന്നതിനനുസരിച്ച് ജോലിയുടെ അളവ് എങ്ങനെ കൂടുമെന്ന് ചിന്തിക്കുക.

5. Limits വായിക്കുക. മൂല്യങ്ങൾ 1,000,000,000 വരെ ആകാമെന്നും N 100,000 ആണെന്നും കരുതുക. അപ്പോൾ തുക 100 trillion വരെ എത്താം. Python-ന്റെ integers അത് കൈകാര്യം ചെയ്യും. എന്നാൽ നിശ്ചിത വലുപ്പമുള്ള integers ഉപയോഗിക്കുന്ന ഭാഷകളിൽ overflow സംഭവിക്കും. കുഴപ്പം: മൂല്യങ്ങളുടെ പരിധി അവഗണിക്കുന്നത്. Overflow ഉണ്ടാകാനുള്ള സാധ്യതയും counting array പോലുള്ള മാർഗങ്ങൾ ഉപയോഗിക്കാനാകുമോ എന്നതും ഈ പരിധി വ്യക്തമാക്കുന്നു.

എങ്ങനെ തയ്യാറെടുക്കാം

1. ആദ്യം ക്ഷണക്കത്ത് വായിക്കുക. എത്ര tasks ഉണ്ട്, ആകെ എത്ര സമയമുണ്ട്, ഏതെല്ലാം ഭാഷകൾ അനുവദനീയമാണ് എന്നിവ ശ്രദ്ധിക്കുക. ഇവ തീരുമാനിക്കുന്നത് തൊഴിലുടമകളാണ്, അതിനാൽ ഊഹിക്കരുത്.
2. നന്നായി അറിയാവുന്ന ഒരു ഭാഷ ഉപയോഗിക്കുക. അതിലെ lists, dictionaries, sets, sorting, string methods എന്നിവ നോക്കാതെ ഉപയോഗിക്കാൻ അറിയണം.
3. കോഡ് എഴുതുന്നതിന് മുമ്പ് പരിധികൾ വായിക്കുക. ഒരു task-ിലെ input വലുപ്പവും value range-ുകളും പരിഹാരം എത്ര വേഗത്തിലായിരിക്കണം, ഏത് edge cases ആണ് പ്രധാനമെന്ന് വ്യക്തമാക്കും. Codility-യുടെ സ്വന്തം lesson tasks-ലും ഇതുതന്നെയാണ് കാണുന്നത് (Codility).
4. ആദ്യം ശരിയാക്കുക, പിന്നെ വേഗത്തിലാക്കുക. ആദ്യം ലളിതവും ശരിയുമായ ഒരു പതിപ്പ് എഴുതുക. അത് O(N squared) ആണെങ്കിൽ, N 100,000 വരെ എത്തുമെങ്കിൽ, running total, dictionary, set അല്ലെങ്കിൽ sorting ഉപയോഗിച്ച് വേഗം കൂട്ടാനുള്ള വഴി നോക്കുക.
5. Edge cases സ്വയം പരീക്ഷിക്കുക. ഒരു task-ിലെ ഉദാഹരണം ഒരേയൊരു case മാത്രമാണ്. അനുവദനീയമാണെങ്കിൽ ശൂന്യമായ input, ഒരു item, എല്ലാം തുല്യമായ values, നെഗറ്റീവ് values, ഏറ്റവും ചെറുതും വലുതുമായ values, ഏറ്റവും വലിയ N എന്നിവ പരീക്ഷിക്കുക.
6. സാധാരണ patterns പഠിക്കുക. Prefix sums, sliding windows, dictionary ഉപയോഗിച്ചുള്ള counting, two pointers, ആദ്യം sorting ചെയ്യൽ, ലളിതമായ greedy choices എന്നിവ ചെറിയ algorithm tasks-ന്റെ വലിയൊരു ഭാഗത്തിന് ഉപകരിക്കും. ഈ ശൈലി കാണാൻ Codility-യുടെ സൗജന്യ lessons നല്ല ഇടമാണ് (Codility).
7. സമയപരിധിക്കുള്ളിൽ മുഴുവൻ പരിഹാരങ്ങൾ എഴുതുക. ഞങ്ങളുടെ full mocks-ൽ hidden cases-നെതിരെ code എഴുതാനും പ്രവർത്തിപ്പിക്കാനും നിങ്ങൾക്ക് കഴിയും. സമയപരിധിക്കുള്ളിൽ എഴുതുന്നത് സ്വാഭാവികമായി തോന്നാൻ, നിങ്ങളുടേതായ tasks ഉപയോഗിച്ചും ഇതുപോലെ പരിശീലിക്കുക.
8. യഥാർത്ഥ വേഗത്തിൽ പരിശീലിക്കുക. ഒരു സമയപരിധിക്കുള്ളിൽ മൂന്ന് tasks പൂർത്തിയാക്കുന്നത് പരീക്ഷാദിവസം സ്വാഭാവികമായി തോന്നാൻ, മുഴുവൻ timed mocks ചെയ്യുക.

സ്കോറിംഗ് സാധാരണയായി എങ്ങനെ നടക്കുന്നു

ഓരോ തൊഴിലുടമയുമാണ് സ്കോറിംഗ് ക്രമീകരിക്കുന്നത്. ഓരോ ടാസ്ക്കും നിശ്ചിത മാനദണ്ഡങ്ങൾ അനുസരിച്ച് സ്വയമേവ സ്കോർ ചെയ്യപ്പെടുന്നു എന്നാണ് Codility പറയുന്നത് (Codility). ഏത് ഫലമാണ് മതിയായതെന്ന് ഓരോ തൊഴിലുടമയും തീരുമാനിക്കുന്നു. എല്ലാവർക്കും ബാധകമായ ഒരു പാസ് മാർക്ക് ഇല്ല.

ഈ മാനദണ്ഡങ്ങൾ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിനെക്കുറിച്ച് പൊതുവെ റിപ്പോർട്ട് ചെയ്യപ്പെടുന്നത്: മറഞ്ഞിരിക്കുന്ന കൃത്യതാ ടെസ്റ്റുകളിൽ നിന്നും, പല അൽഗോരിതമിക് ടാസ്ക്കുകളിലും വലിയ ഇൻപുട്ടുകളിലെ പ്രകടന ടെസ്റ്റുകളിൽ നിന്നും ഒരു ടാസ്ക്കിന്റെ സ്കോർ ലഭിക്കുന്നു. ഇവ ചേർത്ത് ആ ടാസ്ക്കിനും പിന്നീട് ടെസ്റ്റിനും ശതമാനമായി കണക്കാക്കുന്നു. ചെറിയ ഇൻപുട്ടുകളിൽ ശരിയെങ്കിലും വലിയ ഇൻപുട്ടുകളിൽ വളരെ മന്ദഗതിയിലുള്ള പരിഹാരത്തിന് പ്രകടന പോയിന്റുകൾ നഷ്ടപ്പെടാം. ഒരു edge case പരാജയപ്പെടുന്ന പരിഹാരത്തിന് കൃത്യതാ സ്കോറിന്റെ ഒരു ഭാഗം നഷ്ടമാകും. അതുകൊണ്ടാണ് ഞങ്ങളുടെ mock ടെസ്റ്റുകളിൽ "ഇത് ശരിയാണോ?" എന്നും "ഇത് മതിയായ വേഗതയിലാണോ?" എന്നും പ്രത്യേകം ചോദിക്കുന്നത്.

ഞങ്ങളുടെ പ്രാക്ടീസ് സ്കോർ ഞങ്ങളുടെ ചോദ്യങ്ങളിൽ നിങ്ങൾ ശരിയായി ഉത്തരം നൽകിയവയുടെ എണ്ണമാണ്. ഓരോ ടാസ്ക്ക് അനുസരിച്ചുള്ള വിശദാംശങ്ങളും ഇതിലുണ്ടാകും, അതിനാൽ ഏത് ഭാഗത്താണ് ശ്രദ്ധിക്കേണ്ടതെന്ന് നിങ്ങൾക്ക് മനസ്സിലാക്കാം. ഇതൊരു പ്രാക്ടീസ് സ്കോർ മാത്രമാണ്: ഇത് Codility സ്കോറോ ഏതെങ്കിലും തൊഴിലുടമയുടെ ഫലമോ അല്ല, നിങ്ങൾ വിജയിക്കുമോ എന്നും പ്രവചിക്കുന്നില്ല.

സാധാരണ പിഴവുകൾ

• ഉദാഹരണത്തെ മാത്രം ആശ്രയിക്കൽ. ഒരു ടാസ്കിലെ ഉദാഹരണം, മറഞ്ഞിരിക്കുന്ന നിരവധി കേസുകളിൽ ഒന്ന് മാത്രമാണ്. ഒരു സൊല്യൂഷൻ ആ ഉദാഹരണത്തിൽ ശരിയായ ഫലം നൽകിയാലും മൊത്തം സ്കോറിന്റെ ഭൂരിഭാഗത്തിലും പരാജയപ്പെടാം.
• N അവഗണിക്കൽ. ശരിയായ O(N squared) സൊല്യൂഷൻ പോലും N = 100,000 ആയിരിക്കുമ്പോൾ പ്രകടന പരിശോധനകളിൽ പരാജയപ്പെടാം. ആദ്യം പരിധികൾ പരിശോധിക്കുക.
• ഒരു ലൂപ്പിനുള്ളിലെ മറഞ്ഞിരിക്കുന്ന പ്രവർത്തനങ്ങൾ. ഒരു ലൂപ്പിനുള്ളിൽ ലിസ്റ്റിലെ slice, sum, count, index അല്ലെങ്കിൽ "in" ഉപയോഗിക്കുന്നത് ചെലവ് പലമടങ്ങാക്കും.
• അവസാന ഇനം വിട്ടുപോകൽ. Off-by-one റേഞ്ചുകളും ലിസ്റ്റിന്റെ അവസാനംവരെ നീളുന്ന പ്രവർത്തനങ്ങളും പരാജയത്തിന് സാധാരണ കാരണമാണ്. അവസാന ഘട്ടം കൈകൊണ്ട് പിന്തുടർന്ന് പരിശോധിക്കുക.
• തെറ്റായ ആരംഭ മൂല്യങ്ങൾ. പരമാവധി മൂല്യത്തിന് 0-ൽ നിന്ന് തുടങ്ങുന്നതോ, കുറഞ്ഞ മൂല്യത്തിന് സങ്കൽപ്പിച്ച വലിയൊരു സംഖ്യയിൽ നിന്ന് തുടങ്ങുന്നതോ, നെഗറ്റീവ് അല്ലെങ്കിൽ വളരെ വലിയ മൂല്യങ്ങളുള്ളപ്പോൾ പ്രശ്നമാകും. ആദ്യ ഇനത്തിൽ നിന്ന് തുടങ്ങുക.
• ടാസ്ക് ആശ്രയിക്കുന്ന ക്രമം മാറ്റൽ. Sorting നല്ലൊരു മാർഗമാണ്, പക്ഷേ ഉത്തരം സ്ഥാനങ്ങളെയോ "ലിസ്റ്റിലെ ആദ്യത്തേതിനെയോ" ആശ്രയിക്കുമ്പോൾ അത് ഉപയോഗിക്കരുത്.
• ഒരു ടാസ്കിൽ മുഴുവൻ സമയവും ചെലവഴിക്കൽ. ആദ്യം എല്ലാ ടാസ്കുകളുടെയും ശരിയായ പതിപ്പ് സമർപ്പിക്കുക. സമയം അനുവദിക്കുന്നിടത്ത് വേഗം മെച്ചപ്പെടുത്തുക.