Python coding test പരിശീലനം

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

ഒരൊറ്റ Python coding test എന്നില്ല. ഓരോ തൊഴിലുടമയും testing platform തിരഞ്ഞെടുത്ത്, ചോദ്യങ്ങൾ, task-ുകളുടെ എണ്ണം, സമയപരിധി, അനുവദിക്കുന്ന ഭാഷകൾ എന്നിവ തീരുമാനിക്കുന്നു. നിങ്ങളുടെ test invitation ആണ് നിങ്ങളുടെ test സംബന്ധിച്ച ഏറ്റവും നല്ല വിവരം. പൊതുവായി ലഭ്യമായ ഉദാഹരണങ്ങൾ ഇതിന്റെ വ്യത്യാസങ്ങൾ കാണിക്കുന്നു:

• HackerRank. HackerRank-ന്റെ Python (Basic) skills test-ൽ 1 hour 30 minutes-ൽ 2 questions ഉണ്ടെന്നും scalar types പോലുള്ള വിഷയങ്ങൾ ഉൾപ്പെടുന്നുവെന്നും പറയുന്നു (HackerRank). Coding, multiple choice, database, code review, subjective questions എന്നിവയുൾപ്പെടെ തൊഴിലുടമകൾ test-ൽ ഉൾപ്പെടുത്താവുന്ന ചോദ്യങ്ങളുടെ തരങ്ങൾ അതിന്റെ help center പട്ടികപ്പെടുത്തുന്നു. HackerRank-ന്റെ library-യിൽ നിന്ന് ചോദ്യങ്ങൾ ചേർക്കാനോ സ്വന്തം ചോദ്യങ്ങൾ എഴുതാനോ തൊഴിലുടമകൾക്ക് കഴിയുമെന്നും പറയുന്നു (HackerRank സഹായകേന്ദ്രം).
• TestGorilla. TestGorilla-യുടെ Python coding tests പേജ്, അവരുടെ ഓരോ coding test-ും സാധാരണയായി 15 മുതൽ 35 മിനിറ്റ് വരെ എടുക്കുമെന്ന് പറയുന്നു. Entry-level algorithms test-ിന് 15 മിനിറ്റ് എന്നും, തൊഴിലുടമ അനുവദിക്കുന്ന Python അല്ലെങ്കിൽ മറ്റ് ഭാഷകളിൽ ഉദ്യോഗാർഥികൾക്ക് പ്രശ്നങ്ങൾ പരിഹരിക്കാമെന്നും പറയുന്നു (TestGorilla).

തൊഴിലുടമകളുടെ Python test-ുകളിൽ സാധാരണയായി റിപ്പോർട്ട് ചെയ്യപ്പെടുന്ന ഭാഗങ്ങൾ:

• Coding tasks: ഓൺലൈൻ editor-ൽ ഒരു function എഴുതുക, sample inputs ഉപയോഗിച്ച് പ്രവർത്തിപ്പിക്കുക, തുടർന്ന് നിങ്ങൾക്ക് കാണാനാകാത്ത കൂടുതൽ test cases ഉപയോഗിച്ച് പരിശോധിക്കാൻ submit ചെയ്യുക.
• Multiple choice: Python ആശയങ്ങൾ, ഒരു code snippet പ്രവർത്തിപ്പിക്കുമ്പോൾ ലഭിക്കുന്ന output, ശരിയായ code ഏതെന്ന് കണ്ടെത്തൽ.
• Debugging അല്ലെങ്കിൽ code review: മറ്റൊരാൾ എഴുതിയ code-ലെ പ്രശ്നം കണ്ടെത്തി പരിഹരിക്കുക.
• ചിലപ്പോൾ മറ്റു കാര്യങ്ങളും: SQL ചോദ്യം, വലിയ project task, വീട്ടിൽ പൂർത്തിയാക്കി സമർപ്പിക്കേണ്ട assignment, അല്ലെങ്കിൽ test നടക്കുമ്പോൾ webcam, screen എന്നിവ നിരീക്ഷിക്കൽ.

ഞങ്ങളുടെ mock test-ുകളിൽ ഉൾപ്പെടുന്നത്. ഞങ്ങളുടെ full mock test-ുകളിൽ നാല് വിഭാഗങ്ങളിലായി 60 minutes-ൽ 20 questions ഉണ്ട്: Python ആശയങ്ങൾ (6), code എന്ത് output നൽകുന്നു (6), bug കണ്ടെത്തൽ (5), solution നിർമിക്കൽ (3). എല്ലാ code-ും Python 3 ആണ്. Submit ചെയ്യുന്നതുവരെ മുൻപുള്ള ചോദ്യങ്ങളിലേക്ക് മടങ്ങാനും, ഉത്തരം മാറ്റാനും, ചോദ്യങ്ങൾ flag ചെയ്യാനും കഴിയും. ഞങ്ങളുടെ mock test-ുകൾ code വായിക്കാനും, അതിന്റെ പ്രവർത്തനം ഘട്ടംഘട്ടമായി മനസ്സിലാക്കാനും, debugging ചെയ്യാനും, code തിരഞ്ഞെടുക്കാനുമുള്ള പരിശീലനം നൽകുന്നു. നിങ്ങൾ എഴുതുന്ന code അവ പ്രവർത്തിപ്പിക്കില്ല. മറച്ചുവെച്ചിരിക്കുന്ന test cases ഉപയോഗിച്ച് പരിശോധിക്കപ്പെടുന്ന code എഴുതാൻ പല യഥാർത്ഥ assessment-ുകളും ആവശ്യപ്പെടാറുണ്ട്. അതിന് ആവശ്യമായ വായന, code-ന്റെ പ്രവർത്തനം മനസ്സിലാക്കൽ, debugging എന്നീ കഴിവുകൾ ഈ പരിശീലനം വളർത്തും. അതിനൊപ്പം ഒരു യഥാർത്ഥ editor-ലും സമയം നിശ്ചയിച്ച് പരിശീലിക്കുക. ഞങ്ങളുടെ mock test-ുകളിൽ proctoring, plagiarism checks, video interviews, വീട്ടിൽ പൂർത്തിയാക്കേണ്ടതോ project-നുമായി ബന്ധപ്പെട്ടതോ ആയ tasks, തൊഴിലുടമയുടെ pass mark എന്നിവയും ഉൾപ്പെടുന്നില്ല.

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

ഓരോ വിഭാഗത്തിനും ഒരു ഉദാഹരണം, മിക്കവരും വീഴുന്ന കെണിയോടൊപ്പം.

1. Python ആശയങ്ങൾ. a == b-ഉം a is b-ഉം തമ്മിലുള്ള വ്യത്യാസം എന്താണ്? രണ്ട് values തുല്യമാണോ എന്നാണ് ആദ്യത്തേത് പരിശോധിക്കുന്നത്; അവ ഒരേ object ആണോ എന്നാണ് രണ്ടാമത്തേത് പരിശോധിക്കുന്നത്. വേറിട്ട രണ്ട് [1, 2] lists തുല്യമാണ്, പക്ഷേ ഒരേ object അല്ല. കെണി: numbers-നെയോ strings-നെയോ താരതമ്യം ചെയ്യാൻ is ഉപയോഗിക്കുന്നത്. ചെറിയ values-ൽ ഇത് ശരിയെന്ന് തോന്നാം, പക്ഷേ പിന്നീട് പരാജയപ്പെടാം.

2. Code എന്താണ് പ്രിന്റ് ചെയ്യുന്നത്. x = [0] * 3, തുടർന്ന് x[1] = 5, പിന്നെ print(x). ഓരോ ഘട്ടവും പിന്തുടരുക: [0, 0, 0] എന്നത് [0, 5, 0] ആകുന്നു. ഇനി grid = [[0] * 2] * 2, തുടർന്ന് grid[0][0] = 1 എന്ന് പരീക്ഷിക്കുക. ഇത് [[1, 0], [1, 0]] പ്രിന്റ് ചെയ്യും, കാരണം രണ്ട് rows-ഉം ഒരേ inner list ആണ്. കെണി: Python പ്രവർത്തിപ്പിക്കുന്ന രീതിക്ക് പകരം, code പ്രവർത്തിക്കുമെന്ന് നിങ്ങൾ പ്രതീക്ഷിക്കുന്ന രീതിയിൽ വായിക്കുന്നത്. ഓരോ വരിയിലും ഓരോ variable-ന്റെ value കുറിച്ചുവയ്ക്കുക.

3. Bug കണ്ടെത്തൽ. for i in range(len(items) - 1): എന്ന loop എല്ലാ items-ഉം പ്രിന്റ് ചെയ്യാനാണ്, പക്ഷേ അവസാനത്തേത് ഒഴിവാക്കുന്നു. Bug - 1 ആണ്: range(len(items)) തന്നെ length-ന് മുമ്പ് നിർത്തും. കെണി: തെറ്റായ ഫലമുണ്ടാക്കുന്ന വരിക്ക് പകരം, crash ചെയ്യുന്ന അല്ലെങ്കിൽ വിചിത്രമായി തോന്നുന്ന വരി തിരുത്തുന്നത്. രണ്ട് items ഉള്ള list പോലുള്ള ചെറിയ input മനസ്സിൽ വെച്ച് code പരീക്ഷിക്കുക.

4. പരിഹാരം തയ്യാറാക്കൽ. ഒരു list-ലുള്ള ഓരോ വാക്കിന്റെയും എണ്ണം കണ്ടെത്തണം. collections.Counter(words) ഉപയോഗിച്ച് ഒറ്റ ഘട്ടത്തിൽ ഇത് ചെയ്യാം. ഒരു loop-ൽ counts[w] = counts.get(w, 0) + 1 ഉപയോഗിക്കുന്ന dictionary വഴി ഇത് കൈകൊണ്ടും ചെയ്യാം. കെണി: സാധാരണ സാഹചര്യത്തിൽ പ്രവർത്തിക്കുമെങ്കിലും അതിരുസാഹചര്യങ്ങൾ കൈകാര്യം ചെയ്യാത്ത ഓപ്ഷൻ തിരഞ്ഞെടുക്കുന്നത്. ഓരോ ഓപ്ഷനും empty list, ഒരു item, ആവർത്തിക്കുന്നവ, നെഗറ്റീവ് സംഖ്യകൾ എന്നിവ ഉപയോഗിച്ച് പരിശോധിക്കുക.

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

1. ആദ്യം നിങ്ങളുടെ ക്ഷണക്കത്ത് വായിക്കുക. ഏത് പ്ലാറ്റ്‌ഫോമാണ് ഉപയോഗിക്കേണ്ടത്, എത്ര tasks ഉണ്ട്, സമയപരിധി എത്രയാണ്, Python 3 തിരഞ്ഞെടുക്കാമോ, test നിരീക്ഷിക്കപ്പെടുമോ എന്നിവ കണ്ടെത്തുക. ഫോർമാറ്റുകൾ തമ്മിൽ വളരെയധികം വ്യത്യാസമുള്ളതിനാൽ മുൻകൂട്ടി ഊഹിക്കരുത്.
2. പ്ലാറ്റ്‌ഫോമിൽ practice area ഉണ്ടെങ്കിൽ അത് പരീക്ഷിക്കുക. Editor, Run button, sample test cases കാണിക്കുന്ന രീതി എന്നിവയുമായി പരിചയപ്പെടുക. അങ്ങനെ test നടക്കുന്ന ദിവസം സ്ക്രീൻ അപരിചിതമായി തോന്നില്ല. ഉദാഹരണത്തിന്, ജോലി ചെയ്യുമ്പോൾ test cases പ്രവർത്തിപ്പിക്കാൻ ഉദ്യോഗാർഥികൾ Run ക്ലിക്ക് ചെയ്യുന്നതായി HackerRank വിവരിക്കുന്നു (HackerRank Support).
3. Code കൈകൊണ്ട് പരിശോധിക്കുക. ചെറിയ code ഭാഗങ്ങൾക്ക്, ഓരോ വരിക്ക് ശേഷവും ഓരോ variable-ന്റെയും value എഴുതുക. Output, debugging ചോദ്യങ്ങൾക്ക് പിന്നിലെ പ്രധാന കഴിവാണിത്. Code പ്രവർത്തിപ്പിക്കാതെ തന്നെ അത് പരിശോധിക്കാനും ഈ രീതി സഹായിക്കും.
4. ദൈനംദിനമായി ഉപയോഗിക്കുന്ന tools പരിചയപ്പെടുക. Lists, dictionaries, sets, strings, slicing, sorted, list.sort എന്നിവ തമ്മിലുള്ള വ്യത്യാസം, enumerate, zip, list, dictionary comprehensions, collections.Counter എന്നിവ പഠിക്കുക.
5. സമർപ്പിക്കുന്നതിന് മുമ്പ് edge cases ചിന്തിക്കുക. ശൂന്യമായ input, ഒറ്റ item, ആവർത്തിക്കുന്ന values, നെഗറ്റീവ് numbers, വളരെ വലിയ inputs എന്നിവ പരിഗണിക്കുക. Hidden test cases പലപ്പോഴും ഇതുതന്നെയാണ് പരിശോധിക്കുന്നത്.
6. സമയപരിധിക്കുള്ളിൽ കുറച്ച് code എഴുതുക. ഞങ്ങളുടെ mocks വായനയും debugging-ഉം പരിശീലിപ്പിക്കുന്നു. സമ്മർദത്തിൽ code എഴുതുന്നതും പ്രവർത്തിപ്പിക്കുന്നതും പരിചിതമാകാൻ, timer ഉപയോഗിച്ച് യഥാർത്ഥ editor-ൽ കുറച്ച് ചെറിയ പ്രശ്നങ്ങളും പരിഹരിക്കുക.
7. യഥാർത്ഥ സമയവേഗത്തിൽ പരിശീലിക്കുക. നിങ്ങളുടെ test HackerRank-ന്റെ Python (Basic) ഉദാഹരണം പോലെയാണെങ്കിൽ, 1 മണിക്കൂർ 30 മിനിറ്റിൽ 2 ചോദ്യങ്ങൾ എന്നത് ഓരോ പ്രശ്നത്തിനും ഏകദേശം 45 മിനിറ്റാണ് (HackerRank). സമയം ക്രമീകരിച്ച് മുന്നോട്ടുപോകുന്നത് പരിചിതമാകാൻ മുഴുവൻ timed mocks ചെയ്യുക.

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

സ്കോറിംഗ് പ്ലാറ്റ്‌ഫോമിനെയും തൊഴിലുടമയെയും ആശ്രയിച്ചിരിക്കുന്നു. എല്ലാവർക്കും ബാധകമായ ഏകീകൃത സ്കെയിലോ പാസ് മാർക്കോ ഇല്ല. Coding ചോദ്യങ്ങൾക്ക് സാധാരണയായി test cases ഉപയോഗിച്ച് സ്വയമേവ സ്കോർ നൽകും. ഇതിന്റെ രണ്ട് പ്രസിദ്ധീകരിച്ച വിവരണങ്ങൾ:

• ശരിതനിമയും കാര്യക്ഷമതയും അളക്കുന്ന മുൻകൂട്ടി നിശ്ചയിച്ച test cases ഉപയോഗിച്ചാണ് coding ചോദ്യങ്ങൾ വിലയിരുത്തുന്നതെന്ന് HackerRank പറയുന്നു. ഓരോ test case-നും സ്വന്തമായി ഒരു സ്കോറുണ്ട്: ഒരു test case പാസാകുന്ന code-ന് ആ test case-ന്റെ മുഴുവൻ സ്കോറും ലഭിക്കും; പരാജയപ്പെട്ടാൽ പൂജ്യം. പാസായ test cases-ന്റെ സ്കോറുകൾ ചേർത്താണ് ചോദ്യത്തിന്റെ ആകെ സ്കോർ കണക്കാക്കുന്നത്. അതിനാൽ ചില test cases പാസാകുന്ന പരിഹാരത്തിന് ഭാഗികമായി പോയിന്റുകൾ ലഭിക്കും (HackerRank Support). Coding, multiple choice ചോദ്യങ്ങൾ സ്വയമേവ വിലയിരുത്തും. അഭിപ്രായാധിഷ്ഠിത ഉത്തരങ്ങളും ഫയൽ അപ്‌ലോഡുകളും പോലുള്ള ചില ചോദ്യങ്ങൾ കൈകൊണ്ട് വിലയിരുത്തും (HackerRank Help).
• നൽകിയ inputs ശരിയായ output സൃഷ്ടിക്കുന്നുണ്ടോ എന്നതുൾപ്പെടെയുള്ള മൊത്തത്തിലുള്ള ശരിതനിമയെ അടിസ്ഥാനമാക്കി percentile രീതിയിൽ സ്കോർ നൽകുന്നതെന്നും ഓരോ test case-ന്റെയും ഫലങ്ങൾ കാണിക്കുന്ന റിപ്പോർട്ട് ലഭിക്കുമെന്നും TestGorilla വിവരിക്കുന്നു (TestGorilla).

നല്ല ഫലം എന്നതിന്റെ അർഥം ഓരോ തൊഴിലുടമയും തീരുമാനിക്കുന്നതാണ്. പലരും സ്കോറിനൊപ്പം നിങ്ങളുടെ code-ഉം പരിശോധിക്കും.

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

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

• ലിസ്റ്റ് മാറ്റുന്ന രീതികളും പുതിയ ലിസ്റ്റ് നൽകുന്ന ഫങ്ഷനുകളും തമ്മിൽ കുഴയ്ക്കുന്നത്. list.sort()-ഉം list.append()-ഉം None നൽകുന്നു; sorted() ഒരു പുതിയ ലിസ്റ്റ് നൽകുന്നു.
• അസൈൻമെന്റ് ഒബ്ജക്റ്റുകൾ പങ്കിടുന്ന കാര്യം മറക്കുന്നത്. b = a ഒരു ലിസ്റ്റിന്റെയോ ഡിക്ഷണറിയുടെയോ കോപ്പി ഉണ്ടാക്കുന്നില്ല. കോപ്പി ആവശ്യമുള്ളപ്പോൾ a[:], list(a) അല്ലെങ്കിൽ copy.deepcopy(a) ഉപയോഗിക്കുക.
• റേഞ്ചുകളിലും സ്ലൈസുകളിലും ഒന്ന് അധികമോ കുറവോ വരുന്ന പിശകുകൾ. range(n)-ൽ n ഉൾപ്പെടില്ല; s[1:3] മൂന്ന് ഇനങ്ങളല്ല, രണ്ട് ഇനങ്ങളാണ് എടുക്കുന്നത്.
• സങ്കൽപ്പിച്ചെടുത്ത ഒരു മൂല്യം ഉപയോഗിച്ച് തിരച്ചിൽ തുടങ്ങുന്നത്. പരമാവധി മൂല്യം 0-ൽ നിന്നോ കുറഞ്ഞ മൂല്യം 1000-ൽ നിന്നോ തുടങ്ങുന്നത് അസാധാരണ ഇൻപുട്ടുകളിൽ തെറ്റായ ഫലം നൽകും. ആദ്യ ഇനത്തിൽ നിന്ന് തുടങ്ങുക, അല്ലെങ്കിൽ float("-inf") ഉപയോഗിക്കുക.
• ഉദാഹരണം മാത്രം പരിശോധിക്കുന്നത്. കാണിച്ചിരിക്കുന്ന ഉദാഹരണം സാധാരണയായി വിജയിക്കും. ശൂന്യമായ ഇൻപുട്ട്, ഒറ്റ ഇനങ്ങൾ, ആവർത്തിക്കുന്ന ഇനങ്ങൾ, വലിയ ഇൻപുട്ടുകൾ എന്നിവ മറഞ്ഞിരിക്കുന്ന ടെസ്റ്റ് കേസുകൾ പരിശോധിക്കും.
• ഒരു ടാസ്കിൽ തന്നെ സമയം തീർക്കുന്നത്. കുടുങ്ങിയാൽ, ചില ടെസ്റ്റ് കേസുകളിലെങ്കിലും വിജയിക്കുന്ന ലളിതമായൊരു പതിപ്പ് സമർപ്പിച്ച് അടുത്തതിലേക്ക് പോകുക. സമയം അനുവദിച്ചാൽ പിന്നീട് ഇതിലേക്ക് മടങ്ങിവരാം.