JavaScript coding test ಅಭ್ಯಾಸ

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

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

• HackerRank. HackerRank ತನ್ನ JavaScript (Basic) ಕೌಶಲ್ಯ ಪರೀಕ್ಷೆಯಲ್ಲಿ 1 ಗಂಟೆ 30 ನಿಮಿಷಗಳಲ್ಲಿ 2 ಪ್ರಶ್ನೆಗಳು ಇರುತ್ತವೆ ಎಂದು ಪಟ್ಟಿ ಮಾಡಿದೆ. functions‌ನಂತಹ ವಿಷಯಗಳು ಇದರಲ್ಲಿ ಸೇರಿವೆ (HackerRank). ಉದ್ಯೋಗದಾತರು ಪರೀಕ್ಷೆಯಲ್ಲಿ coding, multiple choice, HTML/CSS/JavaScript, front-end developer, code review ಮತ್ತು ವಿವರಣಾತ್ಮಕ ಪ್ರಶ್ನೆಗಳು ಸೇರಿದಂತೆ ಯಾವ ರೀತಿಯ ಪ್ರಶ್ನೆಗಳನ್ನು ಸೇರಿಸಬಹುದು ಎಂಬುದನ್ನು ಅದರ help center ಪಟ್ಟಿ ಮಾಡಿದೆ. ಉದ್ಯೋಗದಾತರು HackerRank‌ನ ಪ್ರಶ್ನೆಗಳ ಸಂಗ್ರಹದಿಂದ ಪ್ರಶ್ನೆಗಳನ್ನು ಸೇರಿಸಬಹುದು ಅಥವಾ ತಾವೇ ಪ್ರಶ್ನೆಗಳನ್ನು ಬರೆಯಬಹುದು ಎಂದೂ ಅದು ತಿಳಿಸುತ್ತದೆ (HackerRank Help).
• TestGorilla. TestGorilla‌ನ JavaScript coding tests ಪುಟದ ಪ್ರಕಾರ, ಪ್ರತ್ಯೇಕ ಪರೀಕ್ಷೆಗಳು 15 ರಿಂದ 45 ನಿಮಿಷಗಳವರೆಗೆ ಇರುತ್ತವೆ. ಆರಂಭಿಕ ಹಂತದ algorithms ಪರೀಕ್ಷೆಯ ಅವಧಿ 15 ನಿಮಿಷ ಎಂದು ಅದು ಪಟ್ಟಿ ಮಾಡಿದೆ. ಅಭ್ಯರ್ಥಿಗಳು ಆನ್‌ಲೈನ್ editor‌ನಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತಾರೆ ಮತ್ತು ಯಾವ ಭಾಷೆಗಳು ಲಭ್ಯವಿರಬೇಕು ಎಂಬುದನ್ನು ಉದ್ಯೋಗದಾತರು ಆಯ್ಕೆಮಾಡುತ್ತಾರೆ ಎಂದೂ ಅದು ತಿಳಿಸುತ್ತದೆ (TestGorilla).

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

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

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

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

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

1. JavaScript ಪರಿಕಲ್ಪನೆಗಳು. let ಮತ್ತು var ನಡುವಿನ ವ್ಯತ್ಯಾಸವೇನು? let ಹತ್ತಿರದ block ಗೆ, ಉದಾಹರಣೆಗೆ loop body ಗೆ, ಸೀಮಿತವಾಗಿರುತ್ತದೆ. ಅದರ ಸಾಲು ಕಾರ್ಯಗತಗೊಳ್ಳುವ ಮೊದಲು ಅದನ್ನು ಬಳಸಲಾಗುವುದಿಲ್ಲ. var ಇಡೀ function ಗೆ ಸೀಮಿತವಾಗಿರುತ್ತದೆ ಮತ್ತು hoist ಆಗುತ್ತದೆ. ಆದ್ದರಿಂದ ಅದರ ಸಾಲು ಬರುವುದಕ್ಕೂ ಮೊದಲು ಅದು undefined ಆಗಿ ಲಭ್ಯವಿರುತ್ತದೆ. ಸಾಮಾನ್ಯ ತಪ್ಪು: const ಬಳಿಸಿದರೆ object ಅಥವಾ array ಬದಲಾಯಿಸಲಾಗದು ಎಂದು ಭಾವಿಸುವುದು. ಇದು ಹೆಸರನ್ನು ಮರುಹೊಂದಿಸುವುದನ್ನು ಮಾತ್ರ ತಡೆಯುತ್ತದೆ.

2. ಕೋಡ್ ಏನನ್ನು log ಮಾಡುತ್ತದೆ. console.log(typeof null, typeof []) object object ಎಂದು log ಮಾಡುತ್ತದೆ. typeof ಪ್ರಕಾರ ಇವೆರಡೂ objects. array ಇದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲು Array.isArray ಬಳಸಿ. async code ನಲ್ಲಿ ಈ ಕ್ರಮವನ್ನು ನೆನಪಿಡಿ: ಮೊದಲು ಸಾಮಾನ್ಯ code, ನಂತರ promise callbacks, ಆಮೇಲೆ timers. ಸಾಮಾನ್ಯ ತಪ್ಪು: setTimeout(fn, 0) ಅನ್ನು "ಈಗಲೇ ಚಲಾಯಿಸು" ಎಂದು ಓದುವುದು. ಪ್ರಸ್ತುತ code ಮತ್ತು ಬಾಕಿ ಇರುವ promise callbacks ಮುಗಿಯುವವರೆಗೆ ಇದು ಯಾವಾಗಲೂ ಕಾಯುತ್ತದೆ.

3. ದೋಷವನ್ನು ಪತ್ತೆಹಚ್ಚುವುದು. ಒಂದು function ಒಟ್ಟು ಮೊತ್ತದ ಬದಲು undefined ಹಿಂತಿರುಗಿಸುತ್ತದೆ. braces ಇವೆ, ಆದರೆ return ಇಲ್ಲದ arrow function ಇದೆಯೇ ನೋಡಿ: (a, b) => { a + b } undefined ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಆದರೆ (a, b) => a + b ಮೊತ್ತವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಸಾಮಾನ್ಯ ತಪ್ಪು: ವಿಚಿತ್ರವಾಗಿ ಕಾಣುವ ಮೊದಲ ಸಾಲನ್ನೇ ಸರಿಪಡಿಸುವುದು. ಚಿಕ್ಕ input ಅನ್ನು ಕೋಡ್ ಮೂಲಕ ಅನುಸರಿಸಿ, ಮೌಲ್ಯ ತಪ್ಪಾಗುವ ಮೊದಲ ಸಾಲನ್ನು ಪತ್ತೆಹಚ್ಚಿ.

4. ಪರಿಹಾರವನ್ನು ರೂಪಿಸುವುದು. cart ನ ಒಟ್ಟು ಬೆಲೆ ಬೇಕಿದೆ. items.reduce((sum, item) => sum + item.price, 0) ಇದನ್ನು ಮಾಡುತ್ತದೆ. ಕೊನೆಯಲ್ಲಿರುವ 0 ಇಲ್ಲದಿದ್ದರೆ, ಖಾಲಿ cart TypeError ಉಂಟುಮಾಡುತ್ತದೆ. ಸಾಮಾನ್ಯ ತಪ್ಪು: ಉದಾಹರಣೆಗೆ ಕೆಲಸ ಮಾಡುವ, ಆದರೆ ಅಂಚಿನ ಸಂದರ್ಭಗಳಿಗೆ ಕೆಲಸ ಮಾಡದ ಆಯ್ಕೆಯನ್ನು ಆರಿಸುವುದು. ಖಾಲಿ array, ಒಂದು item, ಪುನರಾವರ್ತಿತ ಮೌಲ್ಯಗಳು ಮತ್ತು ಕಾಣೆಯಾದ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಪ್ರತಿಯೊಂದು ಆಯ್ಕೆಯನ್ನೂ ಪರಿಶೀಲಿಸಿ.

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

1. ಮೊದಲು ನಿಮ್ಮ ಆಹ್ವಾನವನ್ನು ಓದಿ. ನೀವು ಯಾವ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಬಳಸುತ್ತೀರಿ, ಎಷ್ಟು tasks ಇವೆ, ಸಮಯದ ಮಿತಿ ಎಷ್ಟು, JavaScript ಆಯ್ಕೆಮಾಡಬಹುದೇ, front-end tasks ಸೇರಿವೆಯೇ ಮತ್ತು test ಅನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲಾಗುತ್ತದೆಯೇ ಎಂಬುದನ್ನು ತಿಳಿದುಕೊಳ್ಳಿ. ಪರೀಕ್ಷೆಯ ಸ್ವರೂಪಗಳು ತುಂಬಾ ವಿಭಿನ್ನವಾಗಿರುವುದರಿಂದ ಊಹಿಸಬೇಡಿ.
2. ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿ practice ವಿಭಾಗವಿದ್ದರೆ ಅದನ್ನು ಪ್ರಯತ್ನಿಸಿ. Editor, Run button ಮತ್ತು ಮಾದರಿ test cases ಹೇಗೆ ತೋರಿಸಲಾಗುತ್ತದೆ ಎಂಬುದಕ್ಕೆ ಒಗ್ಗಿಕೊಳ್ಳಿ. ಆಗ ಪರೀಕ್ಷೆಯ ದಿನ ಆ screen ಹೊಸದಾಗಿ ಅನಿಸುವುದಿಲ್ಲ. ಉದಾಹರಣೆಗೆ, ಕೆಲಸ ಮಾಡುವಾಗ candidates Run ಕ್ಲಿಕ್ ಮಾಡಿ test cases ಚಲಾಯಿಸುತ್ತಾರೆ ಎಂದು HackerRank ತಿಳಿಸುತ್ತದೆ (HackerRank Support).
3. Code ಅನ್ನು ಕೈಯಿಂದಲೇ ಕ್ರಮವಾಗಿ ಪರಿಶೀಲಿಸಿ. ಚಿಕ್ಕ code snippets ಗಾಗಿ, ಪ್ರತಿ ಸಾಲಿನ ನಂತರ ಪ್ರತಿಯೊಂದು variable ನ ಮೌಲ್ಯವನ್ನು ಬರೆಯಿರಿ. Async code ಗಾಗಿ ಮೂರು ಪಟ್ಟಿಗಳನ್ನು ಇಡಿ: ಈಗಲೇ ನಡೆಯುವುದು, promise callbacks ಮತ್ತು timers.
4. ದೈನಂದಿನ ಬಳಕೆಯ tools ತಿಳಿದುಕೊಳ್ಳಿ. Arrays ಮತ್ತು ಅವುಗಳ methods (map, filter, reduce, some, find, sort), objects, Map ಮತ್ತು Set, strings, destructuring, spread, template literals, async ಮತ್ತು await.
5. Submit ಮಾಡುವ ಮೊದಲು edge cases ಬಗ್ಗೆ ಯೋಚಿಸಿ. ಖಾಲಿ arrays ಮತ್ತು strings, ಒಂದೇ item, ಪುನರಾವರ್ತಿತ values, null ಮತ್ತು undefined, strings ಆಗಿ ನೀಡಿರುವ ಸಂಖ್ಯೆಗಳು. Hidden test cases ಸಾಮಾನ್ಯವಾಗಿ ಇವನ್ನೇ ಪರಿಶೀಲಿಸುತ್ತವೆ.
6. ಸಮಯದ ಮಿತಿಯೊಳಗೆ code ಬರೆಯಿರಿ. ನಮ್ಮ mock tests ಓದುವ ಮತ್ತು debugging ಕೌಶಲ್ಯ ಬೆಳೆಸುತ್ತವೆ. ಒತ್ತಡದಲ್ಲಿ code ಬರೆಯುವುದು ಮತ್ತು ಚಲಾಯಿಸುವುದು ಸಹಜವೆನಿಸುವಂತೆ, timer ಬಳಸಿ ನೈಜ editor ನಲ್ಲಿ ಕೆಲವು ಚಿಕ್ಕ problems ಕೂಡ ಪರಿಹರಿಸಿ.
7. ನೈಜ ವೇಗದಲ್ಲಿ ಅಭ್ಯಾಸ ಮಾಡಿ. ನಿಮ್ಮ test, HackerRank ನ JavaScript (Basic) ಉದಾಹರಣೆಯಂತಿದ್ದರೆ, 1 ಗಂಟೆ 30 ನಿಮಿಷಗಳಲ್ಲಿ 2 ಪ್ರಶ್ನೆಗಳು ಎಂದರೆ ಪ್ರತಿ problem ಗೆ ಸುಮಾರು 45 ನಿಮಿಷ ಸಿಗುತ್ತದೆ (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 ಮತ್ತು ಬಹು ಆಯ್ಕೆಯ ಪ್ರಶ್ನೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮೌಲ್ಯಮಾಪನ ಮಾಡಲಾಗುತ್ತದೆ. HTML/CSS/JavaScript ಪ್ರಶ್ನೆಗಳನ್ನು ಕೈಯಾರೆ ಮೌಲ್ಯಮಾಪನ ಮಾಡಲಾಗುತ್ತದೆ. Front-end ಪ್ರಶ್ನೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮೌಲ್ಯಮಾಪನ ಮಾಡಿದರೂ, ಕೈಯಾರೆ ಪರಿಶೀಲಿಸುವಂತೆ ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ (HackerRank Help).
• TestGorilla ಒಟ್ಟಾರೆ ಉತ್ತರಗಳ ಸರಿಯಾಗಿರುವಿಕೆಯನ್ನು ಆಧರಿಸಿದ percentile ಅಂಕ ನೀಡುವ ವಿಧಾನ ಮತ್ತು ಪ್ರತಿ test caseನ ಫಲಿತಾಂಶ ತೋರಿಸುವ ವರದಿಯನ್ನು ವಿವರಿಸುತ್ತದೆ (TestGorilla).

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

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

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

• Compare function ಇಲ್ಲದೆ numbers sort ಮಾಡುವುದು. [10, 9, 1].sort() ಅನ್ನು text ಆಗಿ sort ಮಾಡುತ್ತದೆ. sort((a, b) => a - b) ಬಳಸಿ.
• == ಬಳಸಿ type conversion ನಿಂದ ಆಶ್ಚರ್ಯಗೊಳ್ಳುವುದು. ಬೇರೆ ಕಾರಣವಿಲ್ಲದಿದ್ದರೆ === ಬಳಸಿ.
• forEach ಕಾಯುವುದಿಲ್ಲ ಎಂಬುದನ್ನು ಮರೆತರೆ. forEach callback ಒಳಗಿನ await ಹೊರಗಿನ function ಅನ್ನು ನಿಲ್ಲಿಸುವುದಿಲ್ಲ. for...of ಅಥವಾ Promise.all ಬಳಸಿ.
• === ಬಳಸಿ objects ಅಥವಾ arrays ಹೋಲಿಸುವುದು. ಎರಡು objects ಒಂದೇ object ಆಗಿದ್ದರೆ ಮಾತ್ರ ಸಮಾನ. ನಿಮಗೆ ಮುಖ್ಯವಾದ fields ಹೋಲಿಸಿ.
• ಉಳಿಸಬೇಕೆಂದಿದ್ದ array ಅನ್ನು ಬದಲಿಸುವುದು. sort, reverse ಮತ್ತು splice array ಅನ್ನು ಸ್ಥಳದಲ್ಲೇ ಬದಲಿಸುತ್ತವೆ. ಮೂಲವನ್ನು ಉಳಿಸಬೇಕಾದರೆ ಮೊದಲು [...arr] ಬಳಸಿ copy ಮಾಡಿ.
• ಉದಾಹರಣೆಯನ್ನು ಮಾತ್ರ ಪರೀಕ್ಷಿಸುವುದು. ಕಾಣುವ ಉದಾಹರಣೆ ಸಾಮಾನ್ಯವಾಗಿ ಪಾಸ್ ಆಗುತ್ತದೆ. ಖಾಲಿ input, ಒಂದೇ item, ನಕಲಿ ಮೌಲ್ಯಗಳು ಮತ್ತು ದೊಡ್ಡ input ಗಳನ್ನು ಗುಪ್ತ test cases ಪರಿಶೀಲಿಸುತ್ತವೆ.
• ಒಂದು ಕೆಲಸದಲ್ಲೇ ಸಮಯ ಮುಗಿಸಿಕೊಳ್ಳುವುದು. ಅಡಚಣೆಯಾದರೆ, ಕೆಲವು test cases ಪಾಸ್ ಆಗುವ ಸರಳ ಆವೃತ್ತಿಯನ್ನು ಸಲ್ಲಿಸಿ, ಮುಂದಿನದಕ್ಕೆ ಹೋಗಿ, ಸಮಯವಿದ್ದರೆ ಮತ್ತೆ ಬನ್ನಿ.