Java coding test പരിശീലനം

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

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

• HackerRank. ക്ലാസുകൾ പോലുള്ള വിഷയങ്ങൾ ഉൾക്കൊള്ളുന്ന Java (Basic) skills test-ൽ 1 മണിക്കൂറിൽ 6 ചോദ്യങ്ങൾ ഉണ്ടെന്ന് HackerRank പറയുന്നു (HackerRank). coding, multiple choice, database, back-end developer, code review, subjective ചോദ്യങ്ങൾ എന്നിവയുൾപ്പെടെ ഒരു തൊഴിലുടമയ്ക്ക് ടെസ്റ്റിൽ ഉൾപ്പെടുത്താവുന്ന ചോദ്യങ്ങളുടെ തരങ്ങൾ അതിന്റെ help center പട്ടികപ്പെടുത്തുന്നു. HackerRank-ന്റെ library-യിൽ നിന്ന് ചോദ്യങ്ങൾ ചേർക്കാനോ സ്വന്തം ചോദ്യങ്ങൾ തയ്യാറാക്കാനോ തൊഴിലുടമകൾക്ക് കഴിയുമെന്നും പറയുന്നു (HackerRank Help).
• TestGorilla. മിക്ക coding tests-നും 15 മുതൽ 35 മിനിറ്റ് വരെ ദൈർഘ്യമുണ്ടെന്ന് TestGorilla-യുടെ Java coding tests പേജ് പറയുന്നു. entry-level algorithms test-ന് 15 മിനിറ്റ് എന്നും പട്ടികപ്പെടുത്തിയിട്ടുണ്ട്. ഉദ്യോഗാർഥികൾ പ്രശ്നം വായിച്ച്, language menu-യിൽ നിന്ന് Java തിരഞ്ഞെടുത്ത്, online editor-ൽ പരിഹാരം എഴുതുമെന്നും പറയുന്നു (TestGorilla).

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

• Coding tasks: online editor-ൽ ഒരു method എഴുതുക, sample inputs ഉപയോഗിച്ച് പ്രവർത്തിപ്പിക്കുക, തുടർന്ന് നിങ്ങൾക്ക് കാണാനാകാത്ത കൂടുതൽ test cases ഉപയോഗിച്ച് പരിശോധിക്കാനായി സമർപ്പിക്കുക.
• Multiple choice: types, classes, collections, exceptions തുടങ്ങിയ Java ആശയങ്ങൾ; ഒരു code snippet എന്താണ് print ചെയ്യുന്നത്; ശരിയായ code ഏതാണെന്നത്.
• Debugging അല്ലെങ്കിൽ code review: മറ്റൊരാൾ എഴുതിയ code-ലെ പ്രശ്നം കണ്ടെത്തി പരിഹരിക്കുക.
• ചിലപ്പോൾ ഇതിലധികവും: SQL ചോദ്യം, framework അല്ലെങ്കിൽ back-end project, വീട്ടിൽ പൂർത്തിയാക്കി സമർപ്പിക്കേണ്ട assignment, അല്ലെങ്കിൽ ടെസ്റ്റിനിടെ webcam, screen നിരീക്ഷണം.

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

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

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

1. Java ആശയങ്ങൾ. int-ഉം Integer-ഉം തമ്മിലുള്ള വ്യത്യാസം എന്താണ്? int ഒരു primitive value ആണ്; Integer അതിനെ പൊതിഞ്ഞു സൂക്ഷിക്കുന്നതും null ആകാവുന്നതുമായ ഒരു object ആണ്. List പോലുള്ള collections-ൽ Integer സൂക്ഷിക്കാം. ഇവ രണ്ടിനും ഇടയിൽ Java സ്വയം പരിവർത്തനം നടത്തും. കെണി: രണ്ട് Integer objects-നെ == ഉപയോഗിച്ച് താരതമ്യം ചെയ്യുന്നത്. ഇത് references ആണ് താരതമ്യം ചെയ്യുന്നത്; മൂല്യങ്ങൾ ഒരുപോലെയായാലും ഫലം false ആകാം. equals ഉപയോഗിക്കുക.

2. Code എന്താണ് പ്രിന്റ് ചെയ്യുന്നത്. System.out.println(1 + 2 + "3" + 4 + 5); 3345 പ്രിന്റ് ചെയ്യും. Java ഇടത്തുനിന്ന് വലത്തോട്ടാണ് പ്രവർത്തിക്കുന്നത്: 1 + 2 എന്നത് 3 എന്ന സംഖ്യയാണ്. തുടർന്ന് "3" ചേർക്കുമ്പോൾ "33" എന്ന string ഉണ്ടാകുന്നു. അതിനുശേഷം ഓരോ +-ഉം text കൂട്ടിച്ചേർക്കുന്നു. കെണി: ആദ്യം എല്ലാ കണക്കുകളും ചെയ്യുമെന്ന് കരുതുന്നത്. ഓരോ operator-ഉം ക്രമമായി പിന്തുടർന്ന്, ഓരോ ഘട്ടത്തിനുശേഷവും type കുറിച്ചുവയ്ക്കുക.

3. Bug കണ്ടെത്തൽ. ഒരു method-ൽ if (status == "done") എന്ന് എഴുതിയിട്ടും status "done" ആയിരിക്കുമ്പോൾ പോലും അത് ഒരിക്കലും match ചെയ്യുന്നില്ല. പരിഹാരം "done".equals(status) ആണ്. ഇത് characters താരതമ്യം ചെയ്യുകയും status null ആയാലും കൈകാര്യം ചെയ്യുകയും ചെയ്യും. കെണി: അസാധാരണമായി തോന്നുന്ന ആദ്യ വരി തിരുത്തുന്നത്. ചെറിയൊരു input code-ലൂടെ പിന്തുടർന്ന്, value തെറ്റുന്ന ആദ്യ വരി കണ്ടെത്തുക.

4. പരിഹാരം തയ്യാറാക്കൽ. ഓരോ വാക്കും എത്ര തവണ വരുന്നു എന്ന് എണ്ണണം. ഒരു loop-ൽ counts.merge(word, 1, Integer::sum) ഉപയോഗിക്കുന്ന HashMap വഴി ഓരോ വാക്കിനും ഒരൊറ്റ വരിയിൽ ഇത് ചെയ്യാം. കെണി: സാധാരണ സാഹചര്യത്തിൽ പ്രവർത്തിക്കുമെങ്കിലും അതിരുസാഹചര്യങ്ങൾ കൈകാര്യം ചെയ്യാത്ത ഓപ്ഷൻ തിരഞ്ഞെടുക്കുന്നത്. ഓരോ ഓപ്ഷനും empty array, ഒരു item, ആവർത്തിക്കുന്നവ, നെഗറ്റീവ് സംഖ്യകൾ, null എന്നിവ ഉപയോഗിച്ച് പരിശോധിക്കുക.

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

1. ആദ്യം നിങ്ങളുടെ ക്ഷണക്കത്ത് വായിക്കുക. ഏത് പ്ലാറ്റ്‌ഫോമാണ് ഉപയോഗിക്കേണ്ടത്, എത്ര tasks ഉണ്ട്, സമയപരിധി എത്രയാണ്, editor-ൽ ഏത് Java version ആണ് പ്രവർത്തിക്കുന്നത്, test നിരീക്ഷിക്കപ്പെടുമോ എന്നിവ കണ്ടെത്തുക. ഫോർമാറ്റുകൾ തമ്മിൽ വളരെയധികം വ്യത്യാസമുള്ളതിനാൽ മുൻകൂട്ടി ഊഹിക്കരുത്.
2. പ്ലാറ്റ്‌ഫോമിൽ practice area ഉണ്ടെങ്കിൽ അത് പരീക്ഷിക്കുക. Editor, Run button, input വായിക്കുന്ന രീതി, sample test cases കാണിക്കുന്ന രീതി എന്നിവയുമായി പരിചയപ്പെടുക. അങ്ങനെ test നടക്കുന്ന ദിവസം സ്ക്രീൻ അപരിചിതമായി തോന്നില്ല. ഉദാഹരണത്തിന്, ജോലി ചെയ്യുമ്പോൾ test cases പ്രവർത്തിപ്പിക്കാൻ ഉദ്യോഗാർഥികൾ Run ക്ലിക്ക് ചെയ്യുന്നതായി HackerRank വിവരിക്കുന്നു (HackerRank Support).
3. Code കൈകൊണ്ട് പരിശോധിക്കുക. ചെറിയ code ഭാഗങ്ങൾക്ക്, ഓരോ വരിക്ക് ശേഷവും ഓരോ variable-ന്റെയും value-ഉം type-ഉം എഴുതുക. Integer division, string joining, references എന്നിവിടങ്ങളിലാണ് പല അപ്രതീക്ഷിത കാര്യങ്ങളും ഉണ്ടാകുന്നത്.
4. ദൈനംദിനമായി ഉപയോഗിക്കുന്ന tools പരിചയപ്പെടുക. Arrays, String, StringBuilder, ArrayList, HashMap, HashSet, Arrays.sort, Collections.sort, equals, hashCode, exceptions, അടിസ്ഥാന classes, interfaces എന്നിവ പഠിക്കുക.
5. സമർപ്പിക്കുന്നതിന് മുമ്പ് edge cases ചിന്തിക്കുക. ശൂന്യമായ arrays, strings, ഒറ്റ item, ആവർത്തിക്കുന്ന values, നെഗറ്റീവ് numbers, null, int-ന്റെ പരിധി കടക്കാവുന്നത്ര വലിയ values എന്നിവ പരിഗണിക്കുക. Hidden test cases പലപ്പോഴും ഇതുതന്നെയാണ് പരിശോധിക്കുന്നത്.
6. സമയപരിധിക്കുള്ളിൽ കുറച്ച് code എഴുതുക. ഞങ്ങളുടെ mocks വായനയും debugging-ഉം പരിശീലിപ്പിക്കുന്നു. സമ്മർദത്തിൽ code എഴുതുന്നതും compile ചെയ്ത് പ്രവർത്തിപ്പിക്കുന്നതും പരിചിതമാകാൻ, timer ഉപയോഗിച്ച് യഥാർത്ഥ editor-ൽ കുറച്ച് ചെറിയ പ്രശ്നങ്ങളും പരിഹരിക്കുക.
7. യഥാർത്ഥ സമയവേഗത്തിൽ പരിശീലിക്കുക. നിങ്ങളുടെ test HackerRank-ന്റെ Java (Basic) ഉദാഹരണം പോലെയാണെങ്കിൽ, 1 മണിക്കൂറിൽ 6 ചോദ്യങ്ങൾ എന്നത് ഓരോ ചോദ്യത്തിനും ഏകദേശം 10 മിനിറ്റാണ് (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 ചോദ്യങ്ങൾ സ്വയമേവ വിലയിരുത്തും. കൈകൊണ്ട് പരിശോധിക്കാനും ശുപാർശ ചെയ്യുന്ന രീതിയിൽ back-end ചോദ്യങ്ങൾ സ്വയമേവ വിലയിരുത്തും (HackerRank Help).
• നൽകിയ inputs ശരിയായ outputs സൃഷ്ടിക്കുന്നുണ്ടോ എന്നതുൾപ്പെടെയുള്ള മൊത്തത്തിലുള്ള ശരിതനിമയെ അടിസ്ഥാനമാക്കിയാണ് percentile രീതിയിൽ സ്കോർ നൽകുന്നതെന്നും ഓരോ test case-ന്റെയും ഫലം കാണിക്കുന്ന റിപ്പോർട്ട് ലഭിക്കുമെന്നും TestGorilla വിവരിക്കുന്നു (TestGorilla).

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

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

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

• == ഉപയോഗിച്ച് strings താരതമ്യം ചെയ്യുന്നത്. equals ഉപയോഗിക്കുക. അല്ലെങ്കിൽ value null ആയിരിക്കാമെങ്കിൽ "text".equals(value) ഉപയോഗിക്കുക.
• integer division-ൽ നിന്ന് decimal ലഭിക്കുമെന്ന് പ്രതീക്ഷിക്കുന്നത്. 7 / 2 എന്നത് 3 ആണ്. 3.5 ആവശ്യമുള്ളപ്പോൾ, ഒരു വശം ആദ്യം double ആക്കുക.
• strings മാറ്റാനാകില്ലെന്ന കാര്യം മറക്കുന്നത്. s.trim() ഉം s.toUpperCase() ഉം പുതിയ strings തിരികെ നൽകും; ഫലം ഒരു variable-ൽ സൂക്ഷിക്കുക.
• loops-ൽ one-off പിശകുകൾ വരുത്തുന്നത്. Index-ുകൾ 0 മുതൽ length - 1 വരെയാണ്. അതിനാൽ സാധാരണ loop condition i < a.length ആണ്.
• for-each loop-ിനുള്ളിൽ list മാറ്റുന്നത്. removeIf അല്ലെങ്കിൽ വ്യക്തമായി സൃഷ്ടിച്ച Iteratorയും അതിന്റെ remove method-ഉം ഉപയോഗിക്കുക.
• overflow അവഗണിക്കുന്നത്. വലിയ int മൂല്യങ്ങളുടെ തുകയും ഗുണനഫലവും അറിയാതെ മാറിപ്പോകാം. മൂല്യങ്ങൾ വലുതാകാൻ സാധ്യതയുണ്ടെങ്കിൽ long ഉപയോഗിക്കുക.
• ഉദാഹരണം മാത്രം പരിശോധിക്കുന്നത്. കാണുന്ന ഉദാഹരണം സാധാരണയായി വിജയിക്കും. Hidden test cases ശൂന്യമായ input, ഒറ്റ item, ആവർത്തിക്കുന്നവ, വലിയ input എന്നിവ പരിശോധിക്കും.
• ഒരു task-ൽ അധികം സമയം ചെലവഴിച്ച് തീർന്നുപോകുന്നത്. കുടുങ്ങിയാൽ, ചില test cases വിജയിക്കുന്ന ലളിതമായ പതിപ്പ് സമർപ്പിച്ച് അടുത്തതിലേക്ക് പോകുക. സമയം അനുവദിച്ചാൽ പിന്നീട് മടങ്ങിവരാം.