Codility ಶೈಲಿಯ coding test ಅಭ್ಯಾಸ

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

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

Codility ವಿವರಿಸುವ ವಿಷಯಗಳು. ಪ್ರತಿಯೊಂದು ಕಾರ್ಯಕ್ಕೂ ನಿಗದಿತ ಮಾನದಂಡಗಳ ಆಧಾರದಲ್ಲಿ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅಂಕ ನೀಡಲಾಗುತ್ತದೆ ಎಂದು Codility ಹೇಳುತ್ತದೆ (Codility). ಪ್ರೋಗ್ರಾಮರ್‌ಗಳಿಗಾಗಿ ಅದರ ಉಚಿತ ಪಾಠಗಳು (Codility) ಕಾರ್ಯಗಳ ಶೈಲಿಯನ್ನು ತೋರಿಸುತ್ತವೆ: ಒಂದು ಚಿಕ್ಕ ಸಮಸ್ಯೆ, ಬರೆಯಬೇಕಾದ function ಮತ್ತು ತಿಳಿಸಲಾದ input ಮಿತಿಗಳು. ಉದಾಹರಣೆಗೆ, ಅದರ BinaryGap ಪಾಠದ ಕಾರ್ಯವು 2,147,483,647 ವರೆಗಿನ inputs ಗಾಗಿ "an efficient algorithm" ಕೇಳುತ್ತದೆ (Codility), ಮತ್ತು ಒಂದು ಪಾಠದ ಶೀರ್ಷಿಕೆ Time Complexity (Codility).

Codility ಪರೀಕ್ಷೆಗಳ ಬಗ್ಗೆ ಸಾಮಾನ್ಯವಾಗಿ ವರದಿಯಾಗಿರುವುದು (ಅಭ್ಯರ್ಥಿಗಳು ಮತ್ತು ಮಾರ್ಗದರ್ಶಿಗಳಿಂದ ಬಂದ ಮಾಹಿತಿ; ನಾವು ತೆರೆಯಲು ಸಾಧ್ಯವಾದ Codility ಪುಟದಲ್ಲಿ ದೃಢೀಕರಿಸಿಲ್ಲ):

• ಒಂದೇ ಟೈಮರ್‌ನಲ್ಲಿ ಕೆಲವು ಕಾರ್ಯಗಳು - ಇದು ಇಡೀ ಪರೀಕ್ಷೆಗೆ ಅನ್ವಯಿಸುತ್ತದೆ; ಸಾಮಾನ್ಯವಾಗಿ 30 ನಿಮಿಷಗಳಿಂದ 2 ಗಂಟೆಗಳವರೆಗೆ ಇರುತ್ತದೆ.
• ಗುಪ್ತ ಸರಿಯಾಗಿರುವಿಕೆ ಪರೀಕ್ಷೆಗಳು: ಕಾರ್ಯದಲ್ಲಿನ ಉದಾಹರಣೆಯಷ್ಟೇ ಅಲ್ಲದೆ, ನಿಮಗೆ ಕಾಣದ ಪ್ರಕರಣಗಳ ವಿರುದ್ಧವೂ ನಿಮ್ಮ ಕೋಡ್ ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ.
• ದೊಡ್ಡ inputs‌ನಲ್ಲಿನ ಕಾರ್ಯಕ್ಷಮತೆ - algorithmic ಕಾರ್ಯಗಳಿಗೆ: ಸರಿಯಾದರೂ ನಿಧಾನವಾಗಿರುವ ಪರಿಹಾರಕ್ಕೆ ಕಡಿಮೆ ಅಂಕ ಬರಬಹುದು.
• ನೀವು ತೆಗೆದುಕೊಳ್ಳುವ ಸಮಯ - ನಿಗದಿತ ಮಿತಿಯೊಳಗಿನ ಸಮಯವು ಅಂಕದ ಭಾಗವಾಗಿರುವುದಿಲ್ಲ.

ನಮ್ಮ mock ಪರೀಕ್ಷೆಗಳು ಒಳಗೊಂಡಿರುವುದು. ಪ್ರತಿಯೊಂದು ಪೂರ್ಣ mock ಪರೀಕ್ಷೆಯಲ್ಲೂ 90 ನಿಮಿಷಗಳಲ್ಲಿ ಮೂರು coding ಕಾರ್ಯಗಳು ಇರುತ್ತವೆ; ಸುಲಭವಾದ ಕಾರ್ಯದಿಂದ ಕಠಿಣವಾದ ಕಾರ್ಯದವರೆಗೆ. ನೀವು Python, JavaScript, Java ಅಥವಾ C++ ನಲ್ಲಿ ಪರಿಹಾರವನ್ನು ಬರೆದು ರನ್ ಮಾಡಬಹುದು. ಅದನ್ನು ಗುಪ್ತ test cases ವಿರುದ್ಧ ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ತೇರ್ಗಡೆಯಾದ ಪ್ರತಿಯೊಂದು ಪ್ರಕರಣಕ್ಕೂ ಅಂಕ ಸಿಗುತ್ತದೆ. ಲ್ಯಾಪ್‌ಟಾಪ್ ಬಳಸುವುದು ಸೂಕ್ತ. ಸಲ್ಲಿಸುವವರೆಗೆ ಹಿಂದಕ್ಕೆ ಹೋಗಿ ಪರಿಹಾರವನ್ನು ಬದಲಾಯಿಸಬಹುದು.

ನಮ್ಮ mock ಪರೀಕ್ಷೆಗಳು ಭಿನ್ನವಾಗಿರುವುದು. ನೈಜ Codility ಕಾರ್ಯಗಳಲ್ಲಿ ಸರಿಯಾಗಿರುವಿಕೆಗಾಗಿ ಮತ್ತು ಹಲವು ಕಾರ್ಯಗಳಲ್ಲಿ ದೊಡ್ಡ inputs‌ನಲ್ಲಿನ ಕಾರ್ಯಕ್ಷಮತೆಗಾಗಿ ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ ಎಂದು ಸಾಮಾನ್ಯವಾಗಿ ವರದಿಯಾಗಿದೆ. ನಮ್ಮ ಗುಪ್ತ ಪ್ರಕರಣಗಳು ಚಿಕ್ಕದಾಗಿದ್ದು, ಸರಿಯಾಗಿರುವಿಕೆ ಮತ್ತು edge cases ಅನ್ನು ಪರಿಶೀಲಿಸುತ್ತವೆ; ಆದ್ದರಿಂದ ನಿಧಾನವಾದ ಪರಿಹಾರಕ್ಕೆ ಸಮಯ ಮೀರಿದಂತಾಗುವುದಿಲ್ಲ. ದೊಡ್ಡ input ಗೆ ಯಾವ complexity ಬೇಕು ಎಂಬುದನ್ನು ಪ್ರತಿ ಕಾರ್ಯದ ವಿವರಣೆ ತಿಳಿಸುತ್ತದೆ. 10 ಉಚಿತ ಪ್ರಶ್ನೆಗಳು ಸರಿಯಾಗಿರುವಿಕೆ, complexity, edge cases ಮತ್ತು speed ಕುರಿತ multiple-choice ಪ್ರಶ್ನೆಗಳಾಗಿವೆ; ಈ ಪರಿಶೀಲನೆಗಳಲ್ಲಿ ತೇರ್ಗಡೆಯಾಗಲು ಬೇಕಾದ ಆಲೋಚನಾ ವಿಧಾನವನ್ನೂ ಅವು ಪರೀಕ್ಷಿಸುತ್ತವೆ.

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

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

1. ಯಾವ solution ಸರಿಯಾಗಿದೆ. ಕಾರ್ಯ: list ನಲ್ಲಿರುವ ವಿಭಿನ್ನ ಮೌಲ್ಯಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂದಿರುಗಿಸಿ. Solution: len(set(A)). ಖಾಲಿ list ಸೇರಿ ಎಲ್ಲ lists ಗೂ ಇದು ಸರಿಯಾಗಿದೆ; ಖಾಲಿ list ಗೆ 0 ಸಿಗುತ್ತದೆ. ತಪ್ಪಾಗುವ ಸಾಧ್ಯತೆ: sorted list ಬಳಸಿ ನಿಮ್ಮದೇ loop ಬರೆಯುವಾಗ ಮೊದಲ ಅಥವಾ ಕೊನೆಯ item ಅನ್ನು ಮರೆತುಬಿಡುವುದು. Built-in function ಕೆಲಸ ಮಾಡಿದರೆ, ಅದು edge cases ಗಳನ್ನೂ ಸರಿಯಾಗಿ ನಿಭಾಯಿಸುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ, ನಂತರ ಅದನ್ನೇ ಬಳಸಿ.

2. Time complexity. A ಮೇಲಿನ loop дотор solution max(A[:i]) гэж ಕರೆಯುತ್ತದೆ. Slice ಮತ್ತು max ಎರಡೂ ಗರಿಷ್ಠ i items ಅನ್ನು ಪರಿಶೀಲಿಸುತ್ತವೆ. ಆದ್ದರಿಂದ ಒಟ್ಟು ಹಂತಗಳು ಸುಮಾರು N squared ಭಾಗ 2, ಅಂದರೆ O(N squared). ಅದರ ಬದಲು ಗರಿಷ್ಠ ಮೌಲ್ಯವನ್ನು ನಿರಂತರವಾಗಿ ಉಳಿಸಿಕೊಂಡರೆ O(N) ಆಗುತ್ತದೆ. ತಪ್ಪಾಗುವ ಸಾಧ್ಯತೆ: ಒಂದು loop ಕಂಡು ಅದನ್ನು O(N) ಎಂದು ಕರೆಯುವುದು. ಅದರ ಒಳಗೆ slices, sums, counts ಮತ್ತು searches ಇದೆಯೇ ಎಂದು ನೋಡಿ.

3. ಯಾವ input ಇದನ್ನು ವಿಫಲಗೊಳಿಸುತ್ತದೆ. ಕಾರ್ಯ: A ಯಲ್ಲಿ ಇಲ್ಲದ ಅತಿ ಚಿಕ್ಕ ಧನ ಪೂರ್ಣಾಂಕವನ್ನು ಹಿಂದಿರುಗಿಸಿ. ಒಂದು solution max(A) + 1 ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. A = [1, 2, 3] ಪ್ರಯತ್ನಿಸಿ: ಅದು 4 ನೀಡುತ್ತದೆ, ಅದು ಸರಿಯಾಗಿದೆ. A = [1, 3] ಪ್ರಯತ್ನಿಸಿ: ಅದು 4 ನೀಡುತ್ತದೆ, ಆದರೆ 2 ಇಲ್ಲ. ಆದ್ದರಿಂದ ಉತ್ತರ 2. A = [-3, -1] ಪ್ರಯತ್ನಿಸಿ: ಅದು 0 ನೀಡುತ್ತದೆ, ಆದರೆ ಉತ್ತರ 1. ತಪ್ಪಾಗುವ ಸಾಧ್ಯತೆ: ಸರಿಯಾದ ಒಂದು case ಕಂಡ ಕೂಡಲೇ ನಿಲ್ಲಿಸುವುದು. Edge cases ಗಳನ್ನು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಪಟ್ಟಿ ಮಾಡಿ: ಮಧ್ಯೆ ಕಾಣೆಯಾದ ಮೌಲ್ಯಗಳು, ಎಲ್ಲವೂ ಋಣಾತ್ಮಕವಾಗಿರುವುದು, ಅನುಮತಿಸಿದರೆ ಖಾಲಿ list, ಒಂದೇ item, ಎಲ್ಲವೂ ಒಂದೇ ಮೌಲ್ಯ ಮತ್ತು ಅನುಮತಿಸಲಾದ ಗರಿಷ್ಠ ಮೌಲ್ಯಗಳು.

4. N ಗರಿಷ್ಠ 100,000 ಇದ್ದರೂ ಸಾಕಷ್ಟು ವೇಗವಾಗಿರುವುದು. ಸಾಮಾನ್ಯ ನಿಯಮವಾಗಿ, ಆ ಗಾತ್ರಕ್ಕೆ O(N) ಅಥವಾ O(N log N) ಗುರಿಯಾಗಿರಲಿ. O(N squared) ಎಂದರೆ ಸುಮಾರು 10 billion ಹಂತಗಳು; ಇದು ಸಾಮಾನ್ಯ time limit ಗಿಂತ ಬಹಳ ಹೆಚ್ಚು. ತಪ್ಪಾಗುವ ಸಾಧ್ಯತೆ: ಹತ್ತು items ಬಳಸಿ ಪರೀಕ್ಷಿಸುವುದು. ಆಗ ಎಲ್ಲ ವಿಧಾನಗಳೂ ತಕ್ಷಣ ಮುಗಿಯುವಂತೆ ಕಾಣುತ್ತವೆ. N ಹೆಚ್ಚಾದಂತೆ ಕೆಲಸದ ಪ್ರಮಾಣ ಹೇಗೆ ಹೆಚ್ಚುತ್ತದೆ ಎಂದು ಯೋಚಿಸಿ.

5. ಮಿತಿಗಳನ್ನು ಓದುವುದು. ಮೌಲ್ಯಗಳು 1,000,000,000 ವರೆಗೆ ಇರಬಹುದು ಮತ್ತು N 100,000 ಆಗಿದ್ದರೆ, ಮೊತ್ತ 100 trillion ತಲುಪಬಹುದು. Python ನ integers ಇದನ್ನು ನಿಭಾಯಿಸುತ್ತವೆ. ಆದರೆ ನಿಗದಿತ ಗಾತ್ರದ integers ಇರುವ ಭಾಷೆಗಳಲ್ಲಿ overflow ಆಗುತ್ತದೆ. ತಪ್ಪಾಗುವ ಸಾಧ್ಯತೆ: ಮೌಲ್ಯಗಳ ವ್ಯಾಪ್ತಿಯನ್ನು ಕಡೆಗಣಿಸುವುದು. ಇದು overflow ಬಗ್ಗೆ ಮತ್ತು counting array ನಂತಹ ಯಾವ ವಿಧಾನಗಳನ್ನು ಬಳಸಬಹುದು ಎಂಬುದರ ಬಗ್ಗೆ ತಿಳಿಸುತ್ತದೆ.

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

1. ಮೊದಲು ನಿಮ್ಮ ಆಹ್ವಾನವನ್ನು ಓದಿ. ಕಾರ್ಯಗಳ ಸಂಖ್ಯೆ, ಒಟ್ಟು ಸಮಯ ಮತ್ತು ಅನುಮತಿಸಲಾದ ಭಾಷೆಗಳನ್ನು ಗಮನಿಸಿ. ಇವುಗಳನ್ನು ಉದ್ಯೋಗದಾತರು ನಿರ್ಧರಿಸುತ್ತಾರೆ, ಆದ್ದರಿಂದ ಊಹಿಸಬೇಡಿ.
2. ನಿಮಗೆ ಚೆನ್ನಾಗಿ ತಿಳಿದಿರುವ ಒಂದು ಭಾಷೆಯನ್ನು ಬಳಸಿ. ಅದರ lists, dictionaries, sets, sorting ಮತ್ತು string methods ಅನ್ನು ಹುಡುಕದೆ ಬಳಸುವಷ್ಟು ತಿಳಿದಿರಲಿ.
3. ಕೋಡ್ ಬರೆಯುವ ಮೊದಲು ಮಿತಿಗಳನ್ನು ಓದಿ. ಕಾರ್ಯದಲ್ಲಿನ input ಗಾತ್ರಗಳು ಮತ್ತು value range ಗಳು ಪರಿಹಾರ ಎಷ್ಟು ವೇಗವಾಗಿರಬೇಕು ಮತ್ತು ಯಾವ edge case ಗಳು ಮುಖ್ಯ ಎಂಬುದನ್ನು ತಿಳಿಸುತ್ತವೆ. Codilityಯ ಸ್ವಂತ ಪಾಠಗಳಲ್ಲಿಯೂ ಹೀಗೆಯೇ ಇರುತ್ತದೆ (Codility).
4. ಮೊದಲು ಸರಿಯಾಗಿ ಮಾಡಿ, ನಂತರ ವೇಗ ಹೆಚ್ಚಿಸಿ. ಆರಂಭದಲ್ಲಿ ಸರಳವಾದ, ಸರಿಯಾದ ಆವೃತ್ತಿಯನ್ನು ಬರೆಯಿರಿ. ಅದು O(N squared) ಆಗಿದ್ದು N 100,000 ವರೆಗೆ ಹೋಗಬಹುದಾದರೆ, ಅದನ್ನು ಕಡಿಮೆ ಮಾಡಲು running total, dictionary, set ಅಥವಾ sorting ಬಳಸಿ.
5. edge case ಗಳನ್ನು ನೀವೇ ಪರೀಕ್ಷಿಸಿ. ಕಾರ್ಯದಲ್ಲಿನ ಉದಾಹರಣೆ ಕೇವಲ ಒಂದು ಪ್ರಕರಣ. ಅನುಮತಿಸಿದ್ದರೆ ಖಾಲಿ input, ಒಂದು item, ಎಲ್ಲವೂ ಒಂದೇ ಮೌಲ್ಯವಾಗಿರುವುದು, ಋಣಾತ್ಮಕ ಮೌಲ್ಯಗಳು, ಅತಿ ಚಿಕ್ಕ ಮತ್ತು ಅತಿ ದೊಡ್ಡ ಮೌಲ್ಯಗಳು ಹಾಗೂ ಅತಿ ದೊಡ್ಡ N ಇವುಗಳನ್ನು ಪ್ರಯತ್ನಿಸಿ.
6. ಸಾಮಾನ್ಯ ವಿಧಾನಗಳನ್ನು ಕಲಿಯಿರಿ. Prefix sums, sliding windows, dictionary ಬಳಸಿ ಎಣಿಸುವುದು, two pointers, ಮೊದಲು sorting ಮಾಡುವುದು ಮತ್ತು ಸರಳ greedy ಆಯ್ಕೆಗಳು - ಇವು ಚಿಕ್ಕ algorithm ಕಾರ್ಯಗಳ ದೊಡ್ಡ ಭಾಗಕ್ಕೆ ಸಾಕಾಗುತ್ತವೆ. ಈ ಶೈಲಿಯನ್ನು ನೋಡಲು Codilityಯ ಉಚಿತ ಪಾಠಗಳು ಒಳ್ಳೆಯ ಸ್ಥಳ (Codility).
7. ಸಮಯದ ಮಿತಿಯೊಳಗೆ ಪೂರ್ಣ ಪರಿಹಾರಗಳನ್ನು ಬರೆಯಿರಿ. ನಮ್ಮ full mocks ನಲ್ಲಿ ನೀವು ಗುಪ್ತ ಪ್ರಕರಣಗಳ ವಿರುದ್ಧ ಕೋಡ್ ಬರೆದು ಚಲಾಯಿಸುತ್ತೀರಿ; ಸಮಯದ ಮಿತಿಯೊಳಗೆ ಬರೆಯುವುದು ಸಹಜವೆನಿಸಲು, ನಿಮ್ಮದೇ ಕಾರ್ಯಗಳಲ್ಲಿಯೂ ಅದೇ ರೀತಿ ಮಾಡಿ.
8. ನೈಜ ಪರೀಕ್ಷೆಯ ವೇಗದಲ್ಲಿ ಅಭ್ಯಾಸ ಮಾಡಿ. ಒಂದು ಸಮಯಮಿತಿಯೊಳಗೆ ಮೂರು ಕಾರ್ಯಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸುವುದು ಪರೀಕ್ಷೆಯ ದಿನ ಸಹಜವೆನಿಸಲು, ಪೂರ್ಣ timed mocks ತೆಗೆದುಕೊಳ್ಳಿ.

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

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

ಸಾಮಾನ್ಯವಾಗಿ ವರದಿಯಾಗಿರುವ ಪ್ರಕಾರ, ಈ ಮಾನದಂಡಗಳು ಹೀಗೆ ಕೆಲಸ ಮಾಡುತ್ತವೆ: ಒಂದು ಕೆಲಸದ ಅಂಕವು, ಕಾಣದ correctness ಪರೀಕ್ಷೆಗಳಿಂದ ಮತ್ತು ಹಲವು algorithmic ಕೆಲಸಗಳಲ್ಲಿ ದೊಡ್ಡ input‌ಗಳ ಮೇಲಿನ performance ಪರೀಕ್ಷೆಗಳಿಂದ ಬರುತ್ತದೆ. ಇವುಗಳನ್ನು ಸೇರಿಸಿ ಮೊದಲು ಆ ಕೆಲಸಕ್ಕೆ, ನಂತರ ಪರೀಕ್ಷೆಗೆ ಶೇಕಡಾವಾರು ಅಂಕ ಲೆಕ್ಕ ಹಾಕಲಾಗುತ್ತದೆ. ಸಣ್ಣ input‌ಗಳಲ್ಲಿ ಸರಿಯಾಗಿದ್ದರೂ ದೊಡ್ಡ input‌ಗಳಲ್ಲಿ ತುಂಬಾ ನಿಧಾನವಾದ solution ತನ್ನ performance ಅಂಕಗಳನ್ನು ಕಳೆದುಕೊಳ್ಳಬಹುದು. edge case‌ನಲ್ಲಿ ವಿಫಲವಾದ solution ತನ್ನ correctness ಅಂಕದ ಒಂದು ಭಾಗವನ್ನು ಕಳೆದುಕೊಳ್ಳುತ್ತದೆ. ಅದಕ್ಕಾಗಿಯೇ ನಮ್ಮ mock ಪರೀಕ್ಷೆಗಳಲ್ಲಿ “ಇದು ಸರಿಯೇ?” ಮತ್ತು “ಇದು ಸಾಕಷ್ಟು ವೇಗವಾಗಿದೆಯೇ?” ಎಂಬ ಪ್ರಶ್ನೆಗಳನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಕೇಳುತ್ತೇವೆ.

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

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

• ಉದಾಹರಣೆಯನ್ನು ನಂಬುವುದು. ಒಂದು ಕೆಲಸದ ಉದಾಹರಣೆ ಅನೇಕ ಗುಪ್ತ cases ಗಳಲ್ಲಿ ಒಂದು ಮಾತ್ರ. Solution ಅದರಲ್ಲಿ ಪಾಸ್ ಆದರೂ ಒಟ್ಟು ಅಂಕಗಳಲ್ಲಿ ಹೆಚ್ಚಿನದನ್ನು ಕಳೆದುಕೊಳ್ಳಬಹುದು.
• N ಅನ್ನು ಕಡೆಗಣಿಸುವುದು. ಸರಿಯಾದ O(N squared) solution ಕೂಡ N = 100,000 ಆಗಿರುವಾಗ performance ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ವಿಫಲವಾಗಬಹುದು. ಮೊದಲು ಮಿತಿಗಳನ್ನು ಪರಿಶೀಲಿಸಿ.
• Loop ಒಳಗೆ ಅಡಗಿರುವ ಕೆಲಸ. Loop ಒಳಗೆ list ಮೇಲೆ slice, sum, count, index ಅಥವಾ "in" ಬಳಸಿದರೆ ವೆಚ್ಚ ಹೆಚ್ಚುತ್ತದೆ.
• ಕೊನೆಯ item ತಪ್ಪಿಸುವುದು. ಒಂದರಷ್ಟು ತಪ್ಪಿರುವ ranges ಮತ್ತು list ನ ಕೊನೆಯಲ್ಲಿ ಮುಗಿಯುವ runs ಸಾಮಾನ್ಯ ತಪ್ಪುಗಳು. ಕೊನೆಯ ಹಂತವನ್ನು ಕೈಯಿಂದ ಅನುಸರಿಸಿ ನೋಡಿ.
• ತಪ್ಪಾದ ಆರಂಭಿಕ ಮೌಲ್ಯಗಳು. Maximum ಅನ್ನು 0 ರಿಂದ ಅಥವಾ minimum ಅನ್ನು ಕಲ್ಪಿತ ದೊಡ್ಡ ಸಂಖ್ಯೆಯಿಂದ ಆರಂಭಿಸಿದರೆ negative ಅಥವಾ ಅತಿ ದೊಡ್ಡ ಮೌಲ್ಯಗಳಲ್ಲಿ ತಪ್ಪಾಗುತ್ತದೆ. ಮೊದಲ item ನಿಂದ ಆರಂಭಿಸಿ.
• ಕೆಲಸ ಅವಲಂಬಿಸಿರುವ ಕ್ರಮವನ್ನು ಬದಲಿಸುವುದು. Sorting ಉತ್ತಮ ಸಾಧನ, ಆದರೆ ಉತ್ತರವು ಸ್ಥಾನಗಳು ಅಥವಾ "list ನಲ್ಲಿನ ಮೊದಲನೆಯದು" ಎಂಬುದರ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದ್ದರೆ ಅದನ್ನು ಬಳಸಬೇಡಿ.
• ಒಂದು ಕೆಲಸದಲ್ಲೇ ಎಲ್ಲ ಸಮಯ ಕಳೆಯುವುದು. ಮೊದಲು ಪ್ರತಿಯೊಂದು ಕೆಲಸಕ್ಕೂ ಸರಿಯಾದ ಆವೃತ್ತಿಯನ್ನು ಸಲ್ಲಿಸಿ; ನಂತರ ಸಮಯವಿದ್ದರೆ ವೇಗವನ್ನು ಸುಧಾರಿಸಿ.