Java coding test ಅಭ್ಯಾಸ

ನಿಜವಾದ ಪರೀಕ್ಷೆ ಸಾಮಾನ್ಯವಾಗಿ ಹೇಗಿರುತ್ತದೆ

Java coding ಪರೀಕ್ಷೆ ಎಂಬುದಕ್ಕೆ ಒಂದೇ ಮಾದರಿ ಇಲ್ಲ. ಪ್ರತಿಯೊಬ್ಬ ಉದ್ಯೋಗದಾತರೂ ಪರೀಕ್ಷಾ ವೇದಿಕೆಯನ್ನು ಆಯ್ಕೆಮಾಡಿ, ತಮ್ಮದೇ ಪ್ರಶ್ನೆಗಳು, ಕಾರ್ಯಗಳ ಸಂಖ್ಯೆ, ಸಮಯ ಮಿತಿ ಮತ್ತು ಅನುಮತಿಸಲಾದ ಭಾಷೆಗಳನ್ನು ನಿಗದಿಪಡಿಸುತ್ತಾರೆ. ನಿಮಗೆ ಯಾವ ಪರೀಕ್ಷೆ ಇರಬಹುದು ಎಂಬುದಕ್ಕೆ ಪರೀಕ್ಷೆಯ ಆಹ್ವಾನ ಪತ್ರಿಕೆಯೇ ಅತ್ಯುತ್ತಮ ಮಾರ್ಗದರ್ಶಿ. ಸಾರ್ವಜನಿಕವಾಗಿ ಲಭ್ಯವಿರುವ ಉದಾಹರಣೆಗಳು ಪರೀಕ್ಷೆಗಳ ವ್ಯಾಪ್ತಿಯನ್ನು ತೋರಿಸುತ್ತವೆ:

• HackerRank. HackerRank ತನ್ನ Java (Basic) ಕೌಶಲ್ಯ ಪರೀಕ್ಷೆಯಲ್ಲಿ 1 ಗಂಟೆಯಲ್ಲಿ 6 ಪ್ರಶ್ನೆಗಳು ಇರುತ್ತವೆ ಎಂದು ಪಟ್ಟಿ ಮಾಡಿದೆ. classes‌ನಂತಹ ವಿಷಯಗಳು ಇದರಲ್ಲಿ ಸೇರಿವೆ (HackerRank). ಉದ್ಯೋಗದಾತರು ಪರೀಕ್ಷೆಯಲ್ಲಿ coding, multiple choice, database, back-end developer, code review ಮತ್ತು ವಿವರಣಾತ್ಮಕ ಪ್ರಶ್ನೆಗಳು ಸೇರಿದಂತೆ ಯಾವ ರೀತಿಯ ಪ್ರಶ್ನೆಗಳನ್ನು ಸೇರಿಸಬಹುದು ಎಂಬುದನ್ನು ಅದರ help center ಪಟ್ಟಿ ಮಾಡಿದೆ. ಉದ್ಯೋಗದಾತರು HackerRank‌ನ ಪ್ರಶ್ನೆಗಳ ಸಂಗ್ರಹದಿಂದ ಪ್ರಶ್ನೆಗಳನ್ನು ಸೇರಿಸಬಹುದು ಅಥವಾ ತಾವೇ ಪ್ರಶ್ನೆಗಳನ್ನು ಬರೆಯಬಹುದು ಎಂದೂ ಅದು ತಿಳಿಸುತ್ತದೆ (HackerRank Help).
• TestGorilla. TestGorilla‌ನ Java coding tests ಪುಟದ ಪ್ರಕಾರ, ಅದರ ಹೆಚ್ಚಿನ coding ಪರೀಕ್ಷೆಗಳು 15 ರಿಂದ 35 ನಿಮಿಷಗಳವರೆಗೆ ಇರುತ್ತವೆ. ಆರಂಭಿಕ ಹಂತದ algorithms ಪರೀಕ್ಷೆಯ ಅವಧಿ 15 ನಿಮಿಷ ಎಂದು ಅದು ಪಟ್ಟಿ ಮಾಡಿದೆ. ಅಭ್ಯರ್ಥಿಗಳು ಸಮಸ್ಯೆಯನ್ನು ಓದಿ, ಭಾಷೆಗಳ ಪಟ್ಟಿಯಿಂದ Java ಆಯ್ಕೆಮಾಡಿ, ಆನ್‌ಲೈನ್ editor‌ನಲ್ಲಿ ತಮ್ಮ ಪರಿಹಾರವನ್ನು ಬರೆಯುತ್ತಾರೆ ಎಂದೂ ಅದು ತಿಳಿಸುತ್ತದೆ (TestGorilla).

ಉದ್ಯೋಗದಾತರ Java ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ಸಾಮಾನ್ಯವಾಗಿ ವರದಿಯಾಗಿರುವ ಭಾಗಗಳು:

• Coding ಕಾರ್ಯಗಳು: ಆನ್‌ಲೈನ್ editor‌ನಲ್ಲಿ method ಬರೆಯಿರಿ, ಮಾದರಿ inputs ಬಳಸಿ ಅದನ್ನು ಚಲಾಯಿಸಿ, ನಂತರ ನೀವು ನೋಡದಿರಬಹುದಾದ ಇನ್ನಷ್ಟು test cases ಬಳಸಿ ಪರಿಶೀಲಿಸಲು ಸಲ್ಲಿಸಿ.
• Multiple choice: types, classes, collections ಮತ್ತು exceptions‌ನಂತಹ Java ಪರಿಕಲ್ಪನೆಗಳು, code snippet ಚಲಾಯಿಸಿದಾಗ ಏನು ಕಾಣಿಸುತ್ತದೆ ಮತ್ತು ಯಾವ code ಸರಿಯಾಗಿದೆ ಎಂಬ ಪ್ರಶ್ನೆಗಳು.
• Debugging ಅಥವಾ code review: ಬೇರೊಬ್ಬರು ಬರೆದ code‌ನಲ್ಲಿರುವ ಸಮಸ್ಯೆಯನ್ನು ಪತ್ತೆಹಚ್ಚಿ ಸರಿಪಡಿಸುವುದು.
• ಕೆಲವೊಮ್ಮೆ ಹೆಚ್ಚುವರಿಯಾಗಿ: SQL ಪ್ರಶ್ನೆ, framework ಅಥವಾ back-end project, ಮನೆಗೆ ತೆಗೆದುಕೊಂಡು ಹೋಗಿ ಮಾಡುವ assignment, ಅಥವಾ ಪರೀಕ್ಷೆಯ ಸಮಯದಲ್ಲಿ webcam ಮತ್ತು screen ಮೇಲ್ವಿಚಾರಣೆ.

ನಮ್ಮ mock ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ಏನಿದೆ. ನಮ್ಮ ಸಂಪೂರ್ಣ mock ಪರೀಕ್ಷೆಗಳಲ್ಲಿ 60 ನಿಮಿಷಗಳಲ್ಲಿ 20 ಪ್ರಶ್ನೆಗಳು ಇರುತ್ತವೆ. ಅವು ನಾಲ್ಕು ವಿಭಾಗಗಳಾಗಿವೆ: Java ಪರಿಕಲ್ಪನೆಗಳು (6), code ಚಲಾಯಿಸಿದಾಗ ಕಾಣಿಸುವ ಫಲಿತಾಂಶ (6), bug ಪತ್ತೆಹಚ್ಚುವುದು (5) ಮತ್ತು ಪರಿಹಾರ ರೂಪಿಸುವುದು (3). ಎಲ್ಲ code Java 17‌ನಲ್ಲಿದೆ. ಸಲ್ಲಿಸುವವರೆಗೆ ನೀವು ಹಿಂದಿನ ಪ್ರಶ್ನೆಗಳಿಗೆ ಮರಳಬಹುದು, ಉತ್ತರ ಬದಲಾಯಿಸಬಹುದು ಮತ್ತು ಪ್ರಶ್ನೆಗಳನ್ನು ಗುರುತಿಸಬಹುದು. ನಮ್ಮ mock ಪರೀಕ್ಷೆಗಳು code ಓದುವುದು, ಅದರ ಹಂತಗಳನ್ನು ಅನುಸರಿಸುವುದು, ದೋಷ ಸರಿಪಡಿಸುವುದು ಮತ್ತು ಸರಿಯಾದ code ಆಯ್ಕೆಮಾಡುವುದನ್ನು ಅಭ್ಯಾಸ ಮಾಡಿಸುತ್ತವೆ. ನೀವು ಬರೆಯುವ code ಅನ್ನು ಅವು ಚಲಾಯಿಸುವುದಿಲ್ಲ. ಅನೇಕ ನೈಜ ಮೌಲ್ಯಮಾಪನಗಳಲ್ಲಿ ಕಾಣದ test cases ವಿರುದ್ಧ ಚಲಾಯಿಸಬಹುದಾದ code ಬರೆಯಲು ಕೇಳಲಾಗುತ್ತದೆ. ಈ ಅಭ್ಯಾಸವು ಅದಕ್ಕೆ ಬೇಕಾದ ಓದುವ, code‌ನ ಹಂತಗಳನ್ನು ಅನುಸರಿಸುವ ಮತ್ತು debugging ಕೌಶಲ್ಯಗಳನ್ನು ಬೆಳೆಸುತ್ತದೆ. ಆದ್ದರಿಂದ ನೈಜ editor‌ನಲ್ಲಿಯೂ ಸಮಯ ಮಿತಿಯೊಂದಿಗೆ ಅಭ್ಯಾಸ ಮಾಡಿ. ನಮ್ಮ mock ಪರೀಕ್ಷೆಗಳಲ್ಲಿ proctoring, ಕೃತಿಚೌರ್ಯ ಪರಿಶೀಲನೆ, video ಸಂದರ್ಶನಗಳು, ಮನೆಗೆ ತೆಗೆದುಕೊಂಡು ಹೋಗುವ ಅಥವಾ project ಕಾರ್ಯಗಳು ಮತ್ತು ಉದ್ಯೋಗದಾತರ pass mark ಇರುವುದಿಲ್ಲ.

ಪರಿಹಾರ ಸಹಿತ ಉದಾಹರಣೆಗಳಿರುವ ಪ್ರಶ್ನೆಗಳ ವಿಧಗಳು

ಪ್ರತಿ ವಿಭಾಗಕ್ಕೂ ಒಂದು ಬಿಡಿಸಿ ತೋರಿಸಿದ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ. ಹೆಚ್ಚಿನವರು ಮಾಡುವ ತಪ್ಪನ್ನೂ ಗಮನಿಸಿ.

1. Java ಪರಿಕಲ್ಪನೆಗಳು. int ಮತ್ತು Integer ನಡುವಿನ ವ್ಯತ್ಯಾಸವೇನು? int ಒಂದು ಮೂಲಭೂತ ಮೌಲ್ಯ; Integer ಅದನ್ನು ಒಳಗೊಂಡಿರುವ ವಸ್ತು, ಮತ್ತು ಅದರ ಮೌಲ್ಯ null ಆಗಿರಬಹುದು. List ನಂತಹ collections Integer ಮೌಲ್ಯಗಳನ್ನು ಇಡುತ್ತವೆ. Java ಇವೆರಡರ ನಡುವೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ. ಸಾಮಾನ್ಯ ತಪ್ಪು: ಎರಡು Integer ವಸ್ತುಗಳನ್ನು == ಬಳಸಿ ಹೋಲಿಸುವುದು. ಇದು ಮೌಲ್ಯಗಳನ್ನು ಅಲ್ಲ, references ಅನ್ನು ಹೋಲಿಸುತ್ತದೆ. ಮೌಲ್ಯಗಳು ಒಂದೇ ಆಗಿದ್ದರೂ ಫಲಿತಾಂಶ false ಆಗಬಹುದು. equals ಬಳಸಿ.

2. ಕೋಡ್ ಏನನ್ನು ಮುದ್ರಿಸುತ್ತದೆ. System.out.println(1 + 2 + "3" + 4 + 5); 3345 ಅನ್ನು ಮುದ್ರಿಸುತ್ತದೆ. Java ಎಡದಿಂದ ಬಲಕ್ಕೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ: 1 + 2 ಎಂದರೆ ಸಂಖ್ಯೆ 3. ನಂತರ "3" ಸೇರಿಸಿದಾಗ "33" ಎಂಬ string ಆಗುತ್ತದೆ. ಆಮೇಲೆ ಪ್ರತಿಯೊಂದು + ಪಠ್ಯವನ್ನು ಜೋಡಿಸುತ್ತದೆ. ಸಾಮಾನ್ಯ ತಪ್ಪು: ಮೊದಲು ಎಲ್ಲಾ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಮಾಡುವುದು. ಒಂದೊಂದೇ operator ಅನ್ನು ಅನುಸರಿಸಿ, ಪ್ರತಿ ಹಂತದ ನಂತರದ type ಅನ್ನು ಗಮನಿಸಿ.

3. ದೋಷವನ್ನು ಪತ್ತೆಹಚ್ಚುವುದು. ಒಂದು method ನಲ್ಲಿ if (status == "done") ಇದೆ. status "done" ಆಗಿದ್ದರೂ ಇದು ಎಂದಿಗೂ ಹೊಂದಿಕೆಯಾಗುವುದಿಲ್ಲ. ಇದನ್ನು "done".equals(status) ಎಂದು ಸರಿಪಡಿಸಿ. ಇದು ಅಕ್ಷರಗಳನ್ನು ಹೋಲಿಸುತ್ತದೆ ಮತ್ತು null status ಇದ್ದರೂ ಸುರಕ್ಷಿತವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಸಾಮಾನ್ಯ ತಪ್ಪು: ವಿಚಿತ್ರವಾಗಿ ಕಾಣುವ ಮೊದಲ ಸಾಲನ್ನೇ ಸರಿಪಡಿಸುವುದು. ಚಿಕ್ಕ input ಅನ್ನು ಕೋಡ್ ಮೂಲಕ ಅನುಸರಿಸಿ, ಮೌಲ್ಯ ತಪ್ಪಾಗುವ ಮೊದಲ ಸಾಲನ್ನು ಪತ್ತೆಹಚ್ಚಿ.

4. ಪರಿಹಾರವನ್ನು ರೂಪಿಸುವುದು. ಪ್ರತಿ ಪದ ಎಷ್ಟು ಬಾರಿ ಬರುತ್ತದೆ ಎಂದು ಎಣಿಸಬೇಕಿದೆ. loop ಒಳಗೆ counts.merge(word, 1, Integer::sum) ಬಳಸುವ HashMap ಮೂಲಕ ಪ್ರತಿ ಪದಕ್ಕೂ ಒಂದೇ ಸಾಲಿನಲ್ಲಿ ಇದನ್ನು ಮಾಡಬಹುದು. ಸಾಮಾನ್ಯ ತಪ್ಪು: ಸಾಮಾನ್ಯ ಸಂದರ್ಭಕ್ಕೆ ಕೆಲಸ ಮಾಡುವ, ಆದರೆ ಅಂಚಿನ ಸಂದರ್ಭಗಳಿಗೆ ಕೆಲಸ ಮಾಡದ ಆಯ್ಕೆಯನ್ನು ಆರಿಸುವುದು. ಖಾಲಿ array, ಒಂದು item, ಪುನರಾವರ್ತಿತ ಮೌಲ್ಯಗಳು, ಋಣಾತ್ಮಕ ಸಂಖ್ಯೆಗಳು ಮತ್ತು null ಬಳಸಿ ಪ್ರತಿಯೊಂದು ಆಯ್ಕೆಯನ್ನೂ ಪರಿಶೀಲಿಸಿ.

ತಯಾರಿ ಮಾಡುವುದು ಹೇಗೆ

1. ಮೊದಲು ನಿಮ್ಮ ಆಹ್ವಾನವನ್ನು ಓದಿ. ನೀವು ಯಾವ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಬಳಸುತ್ತೀರಿ, ಎಷ್ಟು tasks ಇವೆ, ಸಮಯದ ಮಿತಿ ಎಷ್ಟು, editor ನಲ್ಲಿ ಯಾವ Java version ಇದೆ ಮತ್ತು test ಅನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲಾಗುತ್ತದೆಯೇ ಎಂಬುದನ್ನು ತಿಳಿದುಕೊಳ್ಳಿ. ಪರೀಕ್ಷೆಯ ಸ್ವರೂಪಗಳು ತುಂಬಾ ವಿಭಿನ್ನವಾಗಿರುವುದರಿಂದ ಊಹಿಸಬೇಡಿ.
2. ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿ practice ವಿಭಾಗವಿದ್ದರೆ ಅದನ್ನು ಪ್ರಯತ್ನಿಸಿ. Editor, Run button, input ಅನ್ನು ಹೇಗೆ ಓದಲಾಗುತ್ತದೆ ಮತ್ತು ಮಾದರಿ test cases ಹೇಗೆ ತೋರಿಸಲಾಗುತ್ತದೆ ಎಂಬುದಕ್ಕೆ ಒಗ್ಗಿಕೊಳ್ಳಿ. ಆಗ ಪರೀಕ್ಷೆಯ ದಿನ ಆ screen ಹೊಸದಾಗಿ ಅನಿಸುವುದಿಲ್ಲ. ಉದಾಹರಣೆಗೆ, ಕೆಲಸ ಮಾಡುವಾಗ candidates Run ಕ್ಲಿಕ್ ಮಾಡಿ test cases ಚಲಾಯಿಸುತ್ತಾರೆ ಎಂದು HackerRank ತಿಳಿಸುತ್ತದೆ (HackerRank Support).
3. Code ಅನ್ನು ಕೈಯಿಂದಲೇ ಕ್ರಮವಾಗಿ ಪರಿಶೀಲಿಸಿ. ಚಿಕ್ಕ code snippets ಗಾಗಿ, ಪ್ರತಿ ಸಾಲಿನ ನಂತರ ಪ್ರತಿಯೊಂದು variable ನ ಮೌಲ್ಯ ಮತ್ತು type ಅನ್ನು ಬರೆಯಿರಿ. Integer division, strings ಜೋಡಿಸುವಿಕೆ ಮತ್ತು references ನಲ್ಲಿ ಹೆಚ್ಚಿನ ಅನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶಗಳು ಎದುರಾಗುತ್ತವೆ.
4. ದೈನಂದಿನ ಬಳಕೆಯ tools ತಿಳಿದುಕೊಳ್ಳಿ. Arrays, String ಮತ್ತು StringBuilder, ArrayList, HashMap, HashSet, Arrays.sort ಮತ್ತು Collections.sort, equals ಮತ್ತು hashCode, exceptions, ಹಾಗೂ ಮೂಲಭೂತ classes ಮತ್ತು interfaces.
5. Submit ಮಾಡುವ ಮೊದಲು edge cases ಬಗ್ಗೆ ಯೋಚಿಸಿ. ಖಾಲಿ arrays ಮತ್ತು strings, ಒಂದೇ item, ಪುನರಾವರ್ತಿತ values, ಋಣಾತ್ಮಕ ಸಂಖ್ಯೆಗಳು, null, ಮತ್ತು int ಮಿತಿಯನ್ನು ಮೀರಿಸುವಷ್ಟು ದೊಡ್ಡ values. Hidden test cases ಸಾಮಾನ್ಯವಾಗಿ ಇವನ್ನೇ ಪರಿಶೀಲಿಸುತ್ತವೆ.
6. ಸಮಯದ ಮಿತಿಯೊಳಗೆ code ಬರೆಯಿರಿ. ನಮ್ಮ mock tests ಓದುವ ಮತ್ತು debugging ಕೌಶಲ್ಯ ಬೆಳೆಸುತ್ತವೆ. ಒತ್ತಡದಲ್ಲಿ code ಬರೆಯುವುದು, compile ಮಾಡುವುದು ಮತ್ತು ಚಲಾಯಿಸುವುದು ಸಹಜವೆನಿಸುವಂತೆ, timer ಬಳಸಿ ನೈಜ editor ನಲ್ಲಿ ಕೆಲವು ಚಿಕ್ಕ problems ಕೂಡ ಪರಿಹರಿಸಿ.
7. ನೈಜ ವೇಗದಲ್ಲಿ ಅಭ್ಯಾಸ ಮಾಡಿ. ನಿಮ್ಮ test, HackerRank ನ Java (Basic) ಉದಾಹರಣೆಯಂತಿದ್ದರೆ, 1 ಗಂಟೆಯಲ್ಲಿ 6 ಪ್ರಶ್ನೆಗಳು ಎಂದರೆ ಪ್ರತಿ ಪ್ರಶ್ನೆಗೆ ಸುಮಾರು 10 ನಿಮಿಷ ಸಿಗುತ್ತದೆ (HackerRank). ಸಮಯವನ್ನು ಸರಿಯಾಗಿ ಹಂಚಿಕೊಳ್ಳುವುದು ಸಹಜವೆನಿಸುವಂತೆ ಪೂರ್ಣ timed mock tests ತೆಗೆದುಕೊಳ್ಳಿ.

ಸಾಮಾನ್ಯವಾಗಿ ಅಂಕಗಳನ್ನು ಹೇಗೆ ನೀಡಲಾಗುತ್ತದೆ

ಅಂಕ ನೀಡುವುದು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಮತ್ತು ಉದ್ಯೋಗದಾತರನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಎಲ್ಲರಿಗೂ ಅನ್ವಯಿಸುವ ಅಂಕಗಳ ಮಾನದಂಡವೂ ಇಲ್ಲ, ಉತ್ತೀರ್ಣತಾ ಮಿತಿಯೂ ಇಲ್ಲ. Coding ಪ್ರಶ್ನೆಗಳಿಗೆ ಸಾಮಾನ್ಯವಾಗಿ test cases ಆಧರಿಸಿ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅಂಕ ನೀಡಲಾಗುತ್ತದೆ. ಸಾರ್ವಜನಿಕವಾಗಿ ಲಭ್ಯವಿರುವ ಎರಡು ವಿವರಣೆಗಳು:

• HackerRank ಪ್ರಕಾರ, ಸರಿಯಾಗಿರುವಿಕೆ ಮತ್ತು ದಕ್ಷತೆಯನ್ನು ಅಳೆಯುವ ಪೂರ್ವನಿರ್ಧರಿತ test cases ಬಳಸಿ coding ಪ್ರಶ್ನೆಗಳನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲಾಗುತ್ತದೆ. ಪ್ರತಿಯೊಂದು test caseಗೂ ಪ್ರತ್ಯೇಕ ಅಂಕ ಇರುತ್ತದೆ: test caseನಲ್ಲಿ ತೇರ್ಗಡೆಯಾಗುವ codeಗೆ ಆ test caseನ ಪೂರ್ಣ ಅಂಕ ಸಿಗುತ್ತದೆ. ಅದರಲ್ಲಿ ವಿಫಲವಾದ codeಗೆ ಶೂನ್ಯ ಅಂಕ ಸಿಗುತ್ತದೆ. ಪ್ರಶ್ನೆಯ ಒಟ್ಟು ಅಂಕವೆಂದರೆ ತೇರ್ಗಡೆಯಾದ test casesಗಳ ಅಂಕಗಳ ಮೊತ್ತ. ಹೀಗಾಗಿ ಕೆಲವು test casesಗಳಲ್ಲಿ ತೇರ್ಗಡೆಯಾಗುವ ಪರಿಹಾರಕ್ಕೆ ಭಾಗಶಃ ಅಂಕ ಸಿಗುತ್ತದೆ (HackerRank Support). Coding ಮತ್ತು ಬಹು ಆಯ್ಕೆಯ ಪ್ರಶ್ನೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮೌಲ್ಯಮಾಪನ ಮಾಡಲಾಗುತ್ತದೆ. Back-end ಪ್ರಶ್ನೆಗಳನ್ನೂ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮೌಲ್ಯಮಾಪನ ಮಾಡಲಾಗುತ್ತದೆ, ಆದರೆ ಕೈಯಾರೆ ಪರಿಶೀಲಿಸುವಂತೆ ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ (HackerRank Help).
• TestGorilla ನೀಡಿದ inputಗಳು ಸರಿಯಾದ outputಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತವೆಯೇ ಎಂಬುದನ್ನು ಒಳಗೊಂಡ ಒಟ್ಟಾರೆ ಸರಿಯಾಗಿರುವಿಕೆಯ ಆಧಾರದ ಮೇಲೆ percentile ಅಂಕ ನೀಡುವ ವಿಧಾನ ಮತ್ತು ಪ್ರತಿ test caseನ ಫಲಿತಾಂಶ ತೋರಿಸುವ ವರದಿಯನ್ನು ವಿವರಿಸುತ್ತದೆ (TestGorilla).

ಉತ್ತಮ ಫಲಿತಾಂಶ ಯಾವುದು ಎಂಬುದನ್ನು ಪ್ರತಿಯೊಬ್ಬ ಉದ್ಯೋಗದಾತರೂ ನಿರ್ಧರಿಸುತ್ತಾರೆ. ಅನೇಕ ಉದ್ಯೋಗದಾತರು ಅಂಕದ ಜೊತೆಗೆ ನಿಮ್ಮ codeನ್ನೂ ಪರಿಶೀಲಿಸುತ್ತಾರೆ.

ನಮ್ಮ ಅಭ್ಯಾಸದ ಅಂಕ ಎಂದರೆ ನಮ್ಮದೇ ಪ್ರಶ್ನೆಗಳಲ್ಲಿ ನೀವು ಸರಿಯಾಗಿ ಉತ್ತರಿಸಿದ ಪ್ರಶ್ನೆಗಳ ಸಂಖ್ಯೆ. ವಿಭಾಗವಾರು ವಿವರದಿಂದ ಎಲ್ಲಿ ಗಮನಹರಿಸಬೇಕು ಎಂಬುದನ್ನು ತಿಳಿಯಬಹುದು. ಇದು ಅಭ್ಯಾಸದ ಅಂಕ ಮಾತ್ರ. ಯಾವುದೇ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನ ಪರೀಕ್ಷೆಯ ಅಂಕವಲ್ಲ ಮತ್ತು ನೀವು ಉತ್ತೀರ್ಣರಾಗುತ್ತೀರಾ ಎಂದು ಮುನ್ಸೂಚಿಸುವುದಿಲ್ಲ.

ಸಾಮಾನ್ಯ ತಪ್ಪುಗಳು

• == ಬಳಸಿ strings ಹೋಲಿಸುವುದು. equals ಬಳಸಿ. ಮೌಲ್ಯ null ಆಗಿರುವ ಸಾಧ್ಯತೆ ಇದ್ದರೆ "text".equals(value) ಬಳಸಿ.
• Integer division ನಿಂದ ದಶಮಾಂಶ ನಿರೀಕ್ಷಿಸುವುದು. 7 / 2 ಫಲಿತಾಂಶ 3. ನಿಮಗೆ 3.5 ಬೇಕಾದರೆ, ಮೊದಲು ಒಂದು ಬದಿಯನ್ನು double ಆಗಿ ಪರಿವರ್ತಿಸಿ.
• Strings ಬದಲಿಸಲಾಗದವು ಎಂಬುದನ್ನು ಮರೆತರೆ. s.trim() ಮತ್ತು s.toUpperCase() ಹೊಸ strings ಹಿಂತಿರುಗಿಸುತ್ತವೆ; ಫಲಿತಾಂಶವನ್ನು assign ಮಾಡಿ.
• Loops ನಲ್ಲಿ ಒಂದರಷ್ಟು ತಪ್ಪುಗಳು. Indexes 0 ರಿಂದ length - 1 ವರೆಗೆ ಇರುತ್ತವೆ. ಆದ್ದರಿಂದ ಸಾಮಾನ್ಯ loop ಪರೀಕ್ಷೆ i < a.length ಆಗಿರುತ್ತದೆ.
• for-each loop ಒಳಗೆ list ಬದಲಿಸುವುದು. removeIf ಅಥವಾ ಸ್ಪಷ್ಟವಾದ Iterator ಮತ್ತು ಅದರ remove ವಿಧಾನ ಬಳಸಿ.
• Overflow ಅನ್ನು ಕಡೆಗಣಿಸುವುದು. ದೊಡ್ಡ int ಮೌಲ್ಯಗಳ ಮೊತ್ತ ಮತ್ತು ಗುಣಲಬ್ಧ ಮೌನವಾಗಿ ಮಿತಿ ಮೀರಿ ಸುತ್ತಿಕೊಳ್ಳಬಹುದು. ಮೌಲ್ಯಗಳು ದೊಡ್ಡದಾಗಬಹುದಾದರೆ long ಬಳಸಿ.
• ಉದಾಹರಣೆಯನ್ನು ಮಾತ್ರ ಪರೀಕ್ಷಿಸುವುದು. ಕಾಣುವ ಉದಾಹರಣೆ ಸಾಮಾನ್ಯವಾಗಿ ಪಾಸ್ ಆಗುತ್ತದೆ. ಖಾಲಿ input, ಒಂದೇ item, ನಕಲಿ ಮೌಲ್ಯಗಳು ಮತ್ತು ದೊಡ್ಡ input ಗಳನ್ನು ಗುಪ್ತ test cases ಪರಿಶೀಲಿಸುತ್ತವೆ.
• ಒಂದು ಕೆಲಸದಲ್ಲೇ ಸಮಯ ಮುಗಿಸಿಕೊಳ್ಳುವುದು. ಅಡಚಣೆಯಾದರೆ, ಕೆಲವು test cases ಪಾಸ್ ಆಗುವ ಸರಳ ಆವೃತ್ತಿಯನ್ನು ಸಲ್ಲಿಸಿ, ಮುಂದಿನದಕ್ಕೆ ಹೋಗಿ, ಸಮಯವಿದ್ದರೆ ಮತ್ತೆ ಬನ್ನಿ.