HackerRank ಶೈಲಿಯ coding ಪರೀಕ್ಷಾ ಅಭ್ಯಾಸ

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

ಒಂದೇ ಒಂದು HackerRank test ಇರುವುದಿಲ್ಲ. HackerRank ಒಂದು platform: ಪ್ರತಿಯೊಬ್ಬ employer ತನ್ನದೇ test ಅನ್ನು ರೂಪಿಸಿ, ಪ್ರಶ್ನೆಗಳು, ಅನುಮತಿಸಲಾದ languages ಮತ್ತು ಸಮಯದ ಮಿತಿಯನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತಾರೆ. ನಿಮಗೆ ನೀಡಿರುವ test ಬಗ್ಗೆ ತಿಳಿಯಲು employer ಕಳುಹಿಸಿದ ಆಹ್ವಾನವೇ ಅತ್ಯುತ್ತಮ ಮಾರ್ಗದರ್ಶಿ.

ಪ್ರಶ್ನೆಗಳ ವಿಧಗಳು. HackerRank ತನ್ನ tests‌ಗಳಲ್ಲಿ coding, database, multiple choice, front-end, back-end, full-stack, code review, subjective ಮತ್ತು ಇತರ ಹಲವು ಪ್ರಶ್ನೆಗಳ ವಿಧಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ (HackerRank). ಹೆಚ್ಚಿನ coding tests‌ಗಳಲ್ಲಿ ಇವುಗಳಲ್ಲಿ ಕೆಲವು ವಿಧಗಳಿರುತ್ತವೆ:

• Coding ಪ್ರಶ್ನೆಗಳು: ನೀವು editor‌ನಲ್ಲಿ solution ಬರೆಯುತ್ತೀರಿ. ಅಭ್ಯರ್ಥಿಗಳು ತಮ್ಮ code ಅನ್ನು test cases‌ಗಳ ವಿರುದ್ಧ run ಮಾಡಬಹುದು ಎಂದು, ನಂತರ ಅವರು ನೋಡಬಹುದಾದ sample cases ಮತ್ತು ನೋಡಲಾಗದ hidden cases‌ಗಳ ವಿರುದ್ಧ ಅದಕ್ಕೆ score ನೀಡಲಾಗುತ್ತದೆ ಎಂದು HackerRank ಹೇಳುತ್ತದೆ (HackerRank support).
• Database ಪ್ರಶ್ನೆಗಳು: ನೀವು SQL query ಬರೆಯುತ್ತೀರಿ, ಮತ್ತು ಅದರ result ಅನ್ನು ನಿರೀಕ್ಷಿತ output‌ನೊಂದಿಗೆ ಹೋಲಿಸಲಾಗುತ್ತದೆ (HackerRank support).
• Multiple choice: concepts, complexity ಮತ್ತು code‌ನ ಒಂದು ಭಾಗ ಏನು ಮಾಡುತ್ತದೆ ಎಂಬ ಪ್ರಶ್ನೆಗಳು. ಇವುಗಳಿಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ score ನೀಡಲಾಗುತ್ತದೆ (HackerRank).

ಸಾರ್ವಜನಿಕವಾಗಿ ಲಭ್ಯವಿರುವ ಅವಧಿಯ ಉದಾಹರಣೆಗಳು. HackerRank‌ನ ಸ್ವಂತ skills tests ಅವಧಿಯ ವ್ಯಾಪ್ತಿಯ ಬಗ್ಗೆ ತಿಳಿಸುತ್ತವೆ: ಅದರ Python (Basic) test‌ನಲ್ಲಿ 90 ನಿಮಿಷಗಳಲ್ಲಿ 2 ಪ್ರಶ್ನೆಗಳು ಇವೆ ಎಂದು ಪಟ್ಟಿ ಮಾಡಲಾಗಿದೆ (HackerRank), ಹಾಗೆಯೇ SQL (Basic) test‌ನಲ್ಲಿ 30 ನಿಮಿಷಗಳಲ್ಲಿ 2 ಪ್ರಶ್ನೆಗಳು ಇವೆ (HackerRank). Employer‌ನ test ಕಡಿಮೆ ಅಥವಾ ಹೆಚ್ಚು ಅವಧಿಯದ್ದಾಗಿರಬಹುದು, ಹಾಗೆಯೇ ಅದರಲ್ಲಿ ಪ್ರಶ್ನೆಗಳ ಸಂಖ್ಯೆ ಹೆಚ್ಚಿರಬಹುದು ಅಥವಾ ಕಡಿಮೆಯಿರಬಹುದು.

Coding tests‌ಗಳಲ್ಲಿ ಸಾಮಾನ್ಯವಾಗಿ ವರದಿಯಾಗುವ ವಿಷಯಗಳು: arrays ಮತ್ತು strings, hash maps ಮತ್ತು sets, sorting ಮತ್ತು searching, time complexity, ಖಾಲಿ ಅಥವಾ ಋಣಾತ್ಮಕ input‌ನಂತಹ edge cases, ಮತ್ತು ಮೂಲಭೂತ SQL.

ನಮ್ಮ mocks ಒಳಗೊಂಡಿರುವ ವಿಷಯಗಳು. ಪ್ರತಿಯೊಂದು ಪೂರ್ಣ mock‌ನಲ್ಲಿ ಮೂರು ವಿಭಾಗಗಳಲ್ಲಿ 90 ನಿಮಿಷಗಳಲ್ಲಿ 14 ಪ್ರಶ್ನೆಗಳು ಇರುತ್ತವೆ: concepts ಮತ್ತು code ಓದುವುದು (10), coding problems (3) ಮತ್ತು database problem (1). Coding problems‌ಗಾಗಿ ನೀವು Python, JavaScript, Java ಅಥವಾ C++ ಬಳಸಿ solution ಬರೆಯುತ್ತೀರಿ ಮತ್ತು run ಮಾಡುತ್ತೀರಿ; database problem‌ಗಾಗಿ SQL query ಬರೆಯುತ್ತೀರಿ. ಪ್ರತಿಯೊಂದನ್ನೂ hidden test cases‌ಗಳ ವಿರುದ್ಧ ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಉತ್ತೀರ್ಣವಾಗುವ ಪ್ರತಿಯೊಂದು case‌ಗೆ ಅಂಕಗಳು ದೊರೆಯುತ್ತವೆ. Laptop ಬಳಸಲು ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ. ನೀವು ಹಿಂದಕ್ಕೆ ಹೋಗಿ ಪ್ರಶ್ನೆಗಳನ್ನು flag ಮಾಡಬಹುದು.

ನಮ್ಮ ಉಚಿತ sample‌ನಲ್ಲಿರುವ ವ್ಯತ್ಯಾಸ. 10 ಉಚಿತ ಪ್ರಶ್ನೆಗಳು multiple choice ಆಗಿವೆ: coding ಪ್ರಶ್ನೆಗಳು ಯಾವ solution ಉತ್ತೀರ್ಣವಾಗುತ್ತದೆ ಅಥವಾ ಯಾವ input ಅದನ್ನು ವಿಫಲಗೊಳಿಸುತ್ತದೆ ಎಂದು ಕೇಳುತ್ತವೆ. ಇವು ಉತ್ತೀರ್ಣವಾಗುವ code ಬರೆಯಲು ಅಗತ್ಯವಿರುವ ಕೌಶಲ್ಯಗಳನ್ನು ಪರೀಕ್ಷಿಸುತ್ತವೆ. ಪೂರ್ಣ mocks‌ನಲ್ಲಿ ನೀವು code ಬರೆಯುತ್ತೀರಿ ಮತ್ತು run ಮಾಡುತ್ತೀರಿ. ನಮ್ಮ hidden cases ಚಿಕ್ಕದಾಗಿದ್ದು, ಸರಿಯಾದ ಫಲಿತಾಂಶ ಮತ್ತು edge cases‌ಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತವೆ. ಆದ್ದರಿಂದ ಕೆಲವು ನೈಜ tests‌ಗಳಂತೆ ದೊಡ್ಡ inputs‌ನಲ್ಲಿ ನಿಧಾನವಾದ solution‌ಗೆ ಸಮಯದ ಒತ್ತಡ ನೀಡುವುದಿಲ್ಲ; ವೇಗ ಎಲ್ಲಿ ಮುಖ್ಯವಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ವಿವರಣೆಗಳು ತಿಳಿಸುತ್ತವೆ.

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

ಪ್ರತಿಯೊಂದು ಬಗೆಯ ಪ್ರಶ್ನೆಗೆ, ಹೆಚ್ಚಿನವರು ಮಾಡುವ ತಪ್ಪಿನ ಬಗ್ಗೆ ತಿಳಿಸುವ ಒಂದು ಬಿಡಿಸಿ ತೋರಿಸಿದ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ.

1. Time complexity. ಒಂದು list ಮೇಲಿನ loop ಪ್ರತಿ ಬಾರಿ "x in other_list" ಅನ್ನು ಕರೆಯುತ್ತದೆ. ಎರಡೂ lists ನಲ್ಲಿ n items ಇವೆ. Loop n ಬಾರಿ ನಡೆಯುತ್ತದೆ ಮತ್ತು ಪ್ರತಿ membership check ಗರಿಷ್ಠ n items ಅನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡುತ್ತದೆ. ಹೀಗಾಗಿ ಒಟ್ಟು ಕಾರ್ಯಾಚರಣೆ O(n squared). other_list ಅನ್ನು set ಆಗಿ ಪರಿವರ್ತಿಸಿದರೆ, ಸರಾಸರಿಯಾಗಿ ಪ್ರತಿ check O(1) ಆಗುತ್ತದೆ ಮತ್ತು loop O(n) ಆಗುತ್ತದೆ. ತಪ್ಪಾಗುವ ಸಾಧ್ಯತೆ: ಕಾಣುವ loop ಅನ್ನು ಮಾತ್ರ ಎಣಿಸುವುದು. list ಮೇಲಿನ "in", list.index ಮತ್ತು slicing ನಂತಹ built-in calls ಕೂಡ ಕೆಲಸ ಮಾಡುತ್ತವೆ.

2. ಕೋಡ್ ಓದುವುದು. print([x * 2 for x in range(3)]) ಏನನ್ನು ತೋರಿಸುತ್ತದೆ? range(3) 0, 1 ಮತ್ತು 2 ನೀಡುತ್ತದೆ. ಆದ್ದರಿಂದ ಉತ್ತರ [0, 2, 4]. ತಪ್ಪಾಗುವ ಸಾಧ್ಯತೆ: 1 ರಿಂದ ಪ್ರಾರಂಭಿಸುವುದು ಅಥವಾ 3 ಅನ್ನು ಸೇರಿಸುವುದು. range ಅಂತಿಮ ಮೌಲ್ಯಕ್ಕೆ ಮುನ್ನವೇ ನಿಲ್ಲುತ್ತದೆ.

3. ಯಾವ solution ಪಾಸ್ ಆಗುತ್ತದೆ. ಒಂದು ಸಮಸ್ಯೆ ಗರಿಷ್ಠ 100,000 items ಅನ್ನು ಅನುಮತಿಸುತ್ತದೆ. O(n squared) solution ಗೆ ಸುಮಾರು 10 billion ಹಂತಗಳು ಬೇಕಾಗುತ್ತವೆ. ಸಾಮಾನ್ಯ time limit ಒಳಗೆ ಇದು ತುಂಬಾ ನಿಧಾನ; O(n) ಅಥವಾ O(n log n) ಸಾಕಷ್ಟು ವೇಗವಾಗಿರುತ್ತದೆ. ತಪ್ಪಾಗುವ ಸಾಧ್ಯತೆ: ನೋಡಲು ಚಿಕ್ಕದಾಗಿರುವ solution ಆರಿಸುವುದು. ಮೊದಲು ಹೇಳಿರುವ ಗಾತ್ರದ ಜೊತೆ ಅದರ complexity ಹೋಲಿಸಿ.

4. ಯಾವ input ನಲ್ಲಿ ಇದು ವಿಫಲವಾಗುತ್ತದೆ. ಒಂದು function list ನ ಸರಾಸರಿಯನ್ನು sum(nums) / len(nums) ಎಂದು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಯಾವ input ಇದನ್ನು ವಿಫಲಗೊಳಿಸುತ್ತದೆ? ಖಾಲಿ list. ಅದರಲ್ಲಿ ಶೂನ್ಯದಿಂದ ಭಾಗಿಸಬೇಕಾಗುತ್ತದೆ. ತಪ್ಪಾಗುವ ಸಾಧ್ಯತೆ: ಸಾಮಾನ್ಯ input ಮಾತ್ರ ಪರೀಕ್ಷಿಸುವುದು. ಖಾಲಿ list, ಒಂದೇ item, ಎಲ್ಲವೂ ಸಮಾನವಾಗಿರುವುದು, ಋಣಾತ್ಮಕ ಮೌಲ್ಯಗಳು ಮತ್ತು ಅನುಮತಿಸಿರುವ ಗರಿಷ್ಠ ಗಾತ್ರವನ್ನು ಪ್ರಯತ್ನಿಸಿ.

5. Database ಸಮಸ್ಯೆ. ಏನನ್ನೂ ಖರ್ಚು ಮಾಡದ ಗ್ರಾಹಕರನ್ನೂ ಒಳಗೊಂಡಂತೆ, ಪ್ರತಿಯೊಬ್ಬ ಗ್ರಾಹಕರ ಒಟ್ಟು ಖರ್ಚು ಬೇಕು. customers LEFT JOIN orders ಬಳಸಿ, customer ಮೂಲಕ group ಮಾಡಿ, amount ಮೊತ್ತವನ್ನು ಲೆಕ್ಕ ಹಾಕಿ. ನಂತರ COALESCE ಬಳಸಿ NULL ಅನ್ನು 0 ಆಗಿ ಬದಲಿಸಿ. ತಪ್ಪಾಗುವ ಸಾಧ್ಯತೆ: inner join ಬಳಸುವುದು. ಅದು order ಇಲ್ಲದ ಗ್ರಾಹಕರನ್ನು ಮೌನವಾಗಿ ಹೊರಗಿಡುತ್ತದೆ.

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

1. ಮೊದಲು ನಿಮ್ಮ ಆಹ್ವಾನವನ್ನು ಓದಿ. ಸಮಯ ಮಿತಿ, ಪ್ರಶ್ನೆಗಳ ಸಂಖ್ಯೆ ಮತ್ತು ಪ್ರಕಾರ, ಹಾಗೆಯೇ ಅನುಮತಿಸಲಾದ ಭಾಷೆಗಳನ್ನು ಗಮನಿಸಿ. ಇವೆಲ್ಲವನ್ನೂ ಉದ್ಯೋಗದಾತರು ನಿಗದಿಪಡಿಸುತ್ತಾರೆ, ಆದ್ದರಿಂದ ಊಹಿಸಬೇಡಿ.
2. ಒಂದು ಭಾಷೆಯನ್ನು ಆಯ್ಕೆಮಾಡಿ, ಅದನ್ನೇ ಬಳಸಿ. ಕೋಡಿಂಗ್ ಪ್ರಶ್ನೆಗಳಿಗೆ ನಿಮಗೆ ಚೆನ್ನಾಗಿ ತಿಳಿದಿರುವ ಭಾಷೆಯನ್ನು ಬಳಸಿ. ಅದರ built-in lists, dictionaries, sets, sorting ಮತ್ತು string methods ಅನ್ನು ಹುಡುಕದೆ ಬಳಸುವಷ್ಟು ಚೆನ್ನಾಗಿ ತಿಳಿದುಕೊಳ್ಳಿ.
3. ಇನ್‌ಪುಟ್ ಗಾತ್ರಕ್ಕೆ ಅನುಗುಣವಾದ complexity ಕಲಿಯಿರಿ. ಕೋಡ್ ಬರೆಯುವ ಮೊದಲು ನೀಡಿರುವ ಮಿತಿಗಳನ್ನು ಪರಿಶೀಲಿಸಿ. ಸುಮಾರು 1,000 items ವರೆಗೆ O(n squared) ಸಾಮಾನ್ಯವಾಗಿ ಸಾಕಾಗುತ್ತದೆ; 100,000 ಅಥವಾ ಅದಕ್ಕಿಂತ ಹೆಚ್ಚು ಇದ್ದರೆ, O(n) ಅಥವಾ O(n log n) ಗುರಿಯಾಗಿರಲಿ.
4. ವಿಶೇಷ ಸಂದರ್ಭಗಳನ್ನು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಅಭ್ಯಾಸ ಮಾಡಿ. ಖಾಲಿ ಇನ್‌ಪುಟ್, ಒಂದೇ item, ನಕಲಿ ಮೌಲ್ಯಗಳು, ಋಣಾತ್ಮಕ ಸಂಖ್ಯೆಗಳು, ತುಂಬಾ ದೊಡ್ಡ ಮೌಲ್ಯಗಳು ಮತ್ತು ಗರಿಷ್ಠ ಗಾತ್ರ. Coding ಪ್ರಶ್ನೆಗಳಿಗೆ ಗುಪ್ತ test cases ಆಧರಿಸಿ ಅಂಕ ನೀಡಲಾಗುತ್ತದೆ (HackerRank ಬೆಂಬಲ), ಮತ್ತು ಅವುಗಳಲ್ಲಿ ಹೆಚ್ಚಿನವು ಇಂತಹ ಸಂದರ್ಭಗಳಲ್ಲೇ ಅಡಗಿರುತ್ತವೆ.
5. ಮಾದರಿ cases ರನ್ ಮಾಡಿ, ನಂತರ ನಿಮ್ಮದೇ ಪರೀಕ್ಷಿಸಿ. ಕಾಣುವ ಮಾದರಿಗಳನ್ನು ಪಾಸ್ ಮಾಡುವುದು ಪ್ರಾರಂಭ ಮಾತ್ರ, ಕೊನೆಯಲ್ಲ. ಸಲ್ಲಿಸುವ ಮೊದಲು ನಿಮ್ಮದೇ ಕೆಲವು cases ಸೇರಿಸಿ.
6. ಮೂಲಭೂತ SQL ಅನ್ನು ಪುನಃ ಅಭ್ಯಾಸ ಮಾಡಿ. Joins, GROUP BY, HAVING, NULLs ಮತ್ತು sorting ಹೆಚ್ಚಿನ database ಪ್ರಶ್ನೆಗಳಿಗೆ ಸಾಕಾಗುತ್ತವೆ. ಫಲಿತಾಂಶವನ್ನು ಸಾಲುಸಾಲಾಗಿ ಪರಿಶೀಲಿಸಿ, ಏಕೆಂದರೆ database ಉತ್ತರಗಳನ್ನು ನಿರೀಕ್ಷಿತ output ಜೊತೆ ಹೋಲಿಸಲಾಗುತ್ತದೆ (HackerRank ಬೆಂಬಲ).
7. ಸಮಯದೊಳಗೆ ಪೂರ್ಣ ಪರಿಹಾರಗಳನ್ನು ಬರೆಯಿರಿ. ನಮ್ಮ ಪೂರ್ಣ mock ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ನೀವು ಗುಪ್ತ cases ವಿರುದ್ಧ ಕೋಡ್ ಬರೆದು ರನ್ ಮಾಡುತ್ತೀರಿ; ನಿಮ್ಮದೇ ಸಮಸ್ಯೆಗಳಲ್ಲೂ ಹಾಗೆಯೇ ಮಾಡಿ, ಸಮಯದೊಳಗೆ ಪೂರ್ಣ ಪರಿಹಾರ ಬರೆಯುವುದು ಸಹಜವೆನಿಸುವಂತೆ ಅಭ್ಯಾಸ ಮಾಡಿ.
8. ನಿಜವಾದ ಪರೀಕ್ಷೆಯ ವೇಗದಲ್ಲಿ ಅಭ್ಯಾಸ ಮಾಡಿ. ಪೂರ್ಣ ಸಮಯಮಿತಿಯ mock ಪರೀಕ್ಷೆಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಿ, ಇದರಿಂದ ಪರೀಕ್ಷೆಯ ದಿನ 90 ನಿಮಿಷಗಳ ಏಕಾಗ್ರ ಕೆಲಸ ಸಹಜವೆನಿಸುತ್ತದೆ.

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

ಪ್ರತಿ ಉದ್ಯೋಗದಾತರೂ ತಮ್ಮದೇ ಆದ ಸ್ಕೋರಿಂಗ್ ವ್ಯವಸ್ಥೆಯನ್ನು ನಿಗದಿಪಡಿಸುತ್ತಾರೆ. HackerRank ತನ್ನ ಪ್ರಶ್ನೆಗಳ ಪ್ರಕಾರಗಳಿಗೆ ಹೇಗೆ ಅಂಕ ನೀಡಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ. ಯಾವ ಫಲಿತಾಂಶ ಸಾಕಷ್ಟು ಉತ್ತಮ ಎಂಬುದನ್ನು ಪ್ರತಿ ಉದ್ಯೋಗದಾತರೂ ನಿರ್ಧರಿಸುತ್ತಾರೆ. ಎಲ್ಲರಿಗೂ ಅನ್ವಯಿಸುವ ಒಂದೇ ಪಾಸ್ ಅಂಕವಿಲ್ಲ.

• Coding ಪ್ರಶ್ನೆಗಳು: ಪ್ರತಿಯೊಂದು test case‌ನಲ್ಲೂ ನಿಮ್ಮ code ಅನ್ನು ರನ್ ಮಾಡಿ, ಅದರ output ಅನ್ನು ನಿರೀಕ್ಷಿತ output‌ನೊಂದಿಗೆ ಹೋಲಿಸಲಾಗುತ್ತದೆ ಎಂದು HackerRank ಹೇಳುತ್ತದೆ. ಪ್ರತಿ test case‌ಗೆ ನಿಗದಿತ ಅಂಕ ಇರುತ್ತದೆ: ಪಾಸ್ ಆದರೆ ಪೂರ್ಣ ಅಂಕ, ವಿಫಲವಾದರೆ ಅಂಕವಿಲ್ಲ. test case ಒಂದರೊಳಗೆ ಭಾಗಶಃ ಅಂಕ ನೀಡುವುದಿಲ್ಲ. ನೀವು ಪಾಸ್ ಮಾಡಿದ test case‌ಗಳ ಒಟ್ಟು ಅಂಕವೇ ಆ ಪ್ರಶ್ನೆಯ ನಿಮ್ಮ ಅಂಕ. ನೀವು ನೋಡಬಹುದಾದ ಮಾದರಿ test case‌ಗಳಿಗೆ 0 ಅಂಕ ಇರಬಹುದು; ಅಂಕಗಳು ಕಾಣದ test case‌ಗಳಿಗೆ ಸೇರಿರುತ್ತವೆ (HackerRank support).
• Database ಪ್ರಶ್ನೆಗಳು: ನಿಮ್ಮ query ಫಲಿತಾಂಶವನ್ನು ನಿರೀಕ್ಷಿತ output‌ನೊಂದಿಗೆ ಹೋಲಿಸಲಾಗುತ್ತದೆ. ಹೊಂದಿಕೆಯಾದರೆ ಪೂರ್ಣ ಅಂಕ, ಇಲ್ಲದಿದ್ದರೆ ಶೂನ್ಯ ಅಂಕ. ಆದರೆ ಉದ್ಯೋಗದಾತರು ಕೈಯಾರೆ ಪರಿಶೀಲಿಸಿ ಭಾಗಶಃ ಅಂಕ ನೀಡಬಹುದು (HackerRank support).
• Multiple choice: ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅಂಕ ನೀಡಲಾಗುತ್ತದೆ (HackerRank).

ಆದ್ದರಿಂದ ಸ್ವಲ್ಪ ತಪ್ಪಿರುವ ಅಥವಾ ಸರಿಯಾಗಿದ್ದರೂ ತುಂಬಾ ನಿಧಾನವಾದ solution ತನ್ನ ಹೆಚ್ಚಿನ ಅಂಕಗಳನ್ನು ಕಳೆದುಕೊಳ್ಳಬಹುದು: ಪ್ರತಿ ಕಾಣದ test case‌ನಲ್ಲಿ ಪಾಸ್ ಅಥವಾ ಫೇಲ್ ಆಗುತ್ತದೆ.

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

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

• Samples ಪಾಸ್ ಆದಾಗಲೇ ನಿಲ್ಲಿಸುವುದು. ಕಾಣುವ samples ಎಲ್ಲಾ cases ಗಳಲ್ಲಿ ಒಂದು ಸಣ್ಣ ಭಾಗ ಮಾತ್ರ. ಖಾಲಿ input, ಒಂದೇ item, negative ಸಂಖ್ಯೆಗಳು ಮತ್ತು ಅತಿ ದೊಡ್ಡ ಗಾತ್ರವನ್ನು ನೀವೇ ಪರೀಕ್ಷಿಸಿ.
• Input ಮಿತಿಗಳನ್ನು ಕಡೆಗಣಿಸುವುದು. ಸರಿಯಾದರೂ ನಿಧಾನವಾದ solution ದೊಡ್ಡ ಗುಪ್ತ cases ಗಳಲ್ಲಿ ವಿಫಲವಾಗಬಹುದು. ವಿಧಾನ ಆಯ್ಕೆಮಾಡುವ ಮೊದಲು ಮಿತಿಗಳನ್ನು ಓದಿ.
• Maximum ಅನ್ನು 0 ರಿಂದ ಆರಂಭಿಸುವುದು. ಮೊದಲ item ನಿಂದ ಆರಂಭಿಸಿ; ಇಲ್ಲದಿದ್ದರೆ negative ಸಂಖ್ಯೆಗಳು ತಪ್ಪು ಫಲಿತಾಂಶ ಕೊಡುತ್ತವೆ.
• Loop ಮಾಡುತ್ತಿರುವ list ಅನ್ನು ಬದಲಿಸುವುದು. Iterate ಮಾಡುವಾಗ items ತೆಗೆದುಹಾಕಿದರೆ ಕೆಲವು ಅಂಶಗಳು ಬಿಟ್ಟುಹೋಗುತ್ತವೆ. ಬದಲಿಗೆ ಹೊಸ list ರಚಿಸಿ.
• Ranges ನಲ್ಲಿ ಒಂದರಷ್ಟು ತಪ್ಪು. range(a, b) ಎಂಬುದು b ಗಿಂತ ಮೊದಲು ನಿಲ್ಲುತ್ತದೆ; slices ಕೂಡ ಇದೇ ರೀತಿ ಕೆಲಸ ಮಾಡುತ್ತವೆ. ಸಣ್ಣ ಉದಾಹರಣೆಯಲ್ಲಿ ಮೊದಲ ಮತ್ತು ಕೊನೆಯ index ಪರಿಶೀಲಿಸಿ.
• ಹೆಚ್ಚುವರಿ output ಮುದ್ರಿಸುವುದು. Coding ಉತ್ತರಗಳನ್ನು ನಿರೀಕ್ಷಿತ output ಜೊತೆ ಹೋಲಿಸಲಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ ಅನಗತ್ಯ debug prints ಅಥವಾ ಹೆಚ್ಚುವರಿ spaces ಇದ್ದರೆ case ವಿಫಲವಾಗಬಹುದು.
• ಒಂದು ಸಮಸ್ಯೆಗೆ ಹೆಚ್ಚು ಸಮಯ ಕಳೆಯುವುದು. ಮೊದಲು ಕೆಲಸ ಮಾಡುವ solution ಸಲ್ಲಿಸಿ, ಸಮಯ ಉಳಿದರೆ ಅದನ್ನು ಸುಧಾರಿಸಿ.