Python ಕೋಡಿಂಗ್ ಪರೀಕ್ಷೆಯ ಅಭ್ಯಾಸ

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

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

• HackerRank. HackerRank ತನ್ನ Python (Basic) ಕೌಶಲ್ಯ ಪರೀಕ್ಷೆಯಲ್ಲಿ 1 ಗಂಟೆ 30 ನಿಮಿಷಗಳಲ್ಲಿ 2 ಪ್ರಶ್ನೆಗಳು ಇರುತ್ತವೆ ಎಂದು ತಿಳಿಸಿದೆ. ಇದರಲ್ಲಿ scalar types ನಂತಹ ವಿಷಯಗಳಿವೆ (HackerRank). ಉದ್ಯೋಗದಾತರು ಪರೀಕ್ಷೆಯಲ್ಲಿ ಸೇರಿಸಬಹುದಾದ ಪ್ರಶ್ನೆಗಳ ಪ್ರಕಾರಗಳನ್ನು ಅದರ ಸಹಾಯ ಕೇಂದ್ರ ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ. ಅವುಗಳಲ್ಲಿ coding, multiple choice, database, code review ಮತ್ತು ಮುಕ್ತ ಉತ್ತರದ ಪ್ರಶ್ನೆಗಳು ಸೇರಿವೆ. ಉದ್ಯೋಗದಾತರು HackerRank ಲೈಬ್ರರಿಯಿಂದ ಪ್ರಶ್ನೆಗಳನ್ನು ಸೇರಿಸಬಹುದು ಅಥವಾ ತಾವೇ ಪ್ರಶ್ನೆಗಳನ್ನು ಬರೆಯಬಹುದು ಎಂದೂ ಅದು ತಿಳಿಸುತ್ತದೆ (HackerRank Help).
• TestGorilla. TestGorilla Python coding tests ಪುಟದ ಪ್ರಕಾರ, ಅದರ ಪ್ರತ್ಯೇಕ coding tests ಬಹುತೇಕ 15ರಿಂದ 35 ನಿಮಿಷಗಳವರೆಗೆ ಇರುತ್ತವೆ. ಆರಂಭಿಕ ಹಂತದ algorithms ಪರೀಕ್ಷೆಗೆ 15 ನಿಮಿಷ ಎಂದು ಪಟ್ಟಿ ಮಾಡಿದೆ. ಉದ್ಯೋಗದಾತರು ಅನುಮತಿಸುವ Python ಅಥವಾ ಇತರ ಭಾಷೆಗಳಲ್ಲಿ ಅಭ್ಯರ್ಥಿಗಳು ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಬಹುದು ಎಂದೂ ಹೇಳುತ್ತದೆ (TestGorilla).

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

• Coding ಕಾರ್ಯಗಳು: online editor ನಲ್ಲಿ function ಬರೆಯುವುದು, ಮಾದರಿ inputs ಬಳಸಿ ಅದನ್ನು ಚಲಾಯಿಸುವುದು, ನಂತರ ನಿಮಗೆ ಕಾಣದಿರಬಹುದಾದ ಇನ್ನಷ್ಟು test cases ಗಳ ಮೂಲಕ ಪರಿಶೀಲಿಸಲು ಸಲ್ಲಿಸುವುದು.
• Multiple choice: Python ಪರಿಕಲ್ಪನೆಗಳು, ಒಂದು code snippet ಏನನ್ನು ಮುದ್ರಿಸುತ್ತದೆ ಮತ್ತು ಯಾವ code ಸರಿಯಾಗಿದೆ ಎಂಬ ಪ್ರಶ್ನೆಗಳು.
• Debugging ಅಥವಾ code review: ಬೇರೆಯವರು ಬರೆದ code ನಲ್ಲಿರುವ ಸಮಸ್ಯೆಯನ್ನು ಕಂಡುಹಿಡಿದು ಸರಿಪಡಿಸುವುದು.
• ಕೆಲವೊಮ್ಮೆ ಇನ್ನಷ್ಟು: SQL ಪ್ರಶ್ನೆ, ದೊಡ್ಡ project ಕಾರ್ಯ, ಮನೆಯಿಂದ ಮಾಡಿ ಸಲ್ಲಿಸುವ assignment ಅಥವಾ ಪರೀಕ್ಷೆಯ ಸಮಯದಲ್ಲಿ webcam ಮತ್ತು screen ಮೇಲ್ವಿಚಾರಣೆ.

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

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

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

1. Python ಪರಿಕಲ್ಪನೆಗಳು. a == b ಮತ್ತು a is b ನಡುವಿನ ವ್ಯತ್ಯಾಸವೇನು? ಮೊದಲನೆಯದು ಎರಡು ಮೌಲ್ಯಗಳು ಸಮವೇ ಎಂದು ಕೇಳುತ್ತದೆ; ಎರಡನೆಯದು ಅವು ಒಂದೇ object ಆಗಿವೆಯೇ ಎಂದು ಕೇಳುತ್ತದೆ. ಪ್ರತ್ಯೇಕವಾದ ಎರಡು [1, 2] lists ಮೌಲ್ಯದಲ್ಲಿ ಸಮವಾಗಿದ್ದರೂ ಒಂದೇ object ಅಲ್ಲ. ಸಾಮಾನ್ಯ ತಪ್ಪು: ಸಂಖ್ಯೆಗಳು ಅಥವಾ strings ಹೋಲಿಸಲು is ಬಳಸುವುದು. ಸಣ್ಣ ಮೌಲ್ಯಗಳಿಗೆ ಇದು ಕೆಲಸ ಮಾಡಿದಂತೆ ಕಂಡರೂ, ನಂತರ ವಿಫಲವಾಗಬಹುದು.

2. ಕೋಡ್ ಏನನ್ನು ಮುದ್ರಿಸುತ್ತದೆ. ಮೊದಲು x = [0] * 3, ನಂತರ x[1] = 5 ಮತ್ತು print(x). ಹಂತ ಹಂತವಾಗಿ ನೋಡಿ: [0, 0, 0] ಎಂಬುದು [0, 5, 0] ಆಗುತ್ತದೆ. ಈಗ grid = [[0] * 2] * 2, ನಂತರ grid[0][0] = 1 ಪ್ರಯತ್ನಿಸಿ. ಎರಡೂ ಸಾಲುಗಳು ಒಂದೇ ಒಳಗಿನ list ಆಗಿರುವುದರಿಂದ ಇದು [[1, 0], [1, 0]] ಅನ್ನು ಮುದ್ರಿಸುತ್ತದೆ. ಸಾಮಾನ್ಯ ತಪ್ಪು: Python ಕೋಡ್ ಅನ್ನು ಹೇಗೆ ಚಲಾಯಿಸುತ್ತದೆ ಎಂಬುದರ ಬದಲು, ಅದು ಹೇಗೆ ಕೆಲಸ ಮಾಡಬೇಕೆಂದು ನೀವು ನಿರೀಕ್ಷಿಸುತ್ತೀರೋ ಹಾಗೆ ಓದುವುದು. ಪ್ರತಿ ಸಾಲಿನ ನಂತರ ಪ್ರತಿ variable ನ ಮೌಲ್ಯವನ್ನು ಬರೆದುಕೊಳ್ಳಿ.

3. ದೋಷವನ್ನು ಪತ್ತೆಹಚ್ಚುವುದು. for i in range(len(items) - 1): loop ಪ್ರತಿಯೊಂದು item ಅನ್ನು ಮುದ್ರಿಸಬೇಕಿದೆ, ಆದರೆ ಕೊನೆಯದನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ. ದೋಷ - 1 ನಲ್ಲಿದೆ: range(len(items)) ಉದ್ದಕ್ಕಿಂತ ಮುಂಚೆಯೇ ನಿಲ್ಲುತ್ತದೆ. ಸಾಮಾನ್ಯ ತಪ್ಪು: ತಪ್ಪಾದ ಫಲಿತಾಂಶಕ್ಕೆ ಕಾರಣವಾಗುವ ಸಾಲಿನ ಬದಲು, crash ಆಗುವ ಅಥವಾ ವಿಚಿತ್ರವಾಗಿ ಕಾಣುವ ಸಾಲನ್ನು ಸರಿಪಡಿಸುವುದು. ಎರಡು items ಇರುವ list ನಂತಹ ಚಿಕ್ಕ input ಬಳಸಿ, ಮನಸ್ಸಿನಲ್ಲಿ ಕೋಡ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಿ.

4. ಪರಿಹಾರವನ್ನು ರೂಪಿಸುವುದು. list ನಲ್ಲಿನ ಪ್ರತಿ ಪದದ ಎಣಿಕೆ ಬೇಕಿದೆ. collections.Counter(words) ಇದನ್ನು ಒಂದೇ ಹಂತದಲ್ಲಿ ಮಾಡುತ್ತದೆ. loop ಒಳಗೆ counts[w] = counts.get(w, 0) + 1 ಬಳಸುವ dictionary ಮೂಲಕವೂ ಇದನ್ನು ಕೈಯಾರೆ ಮಾಡಬಹುದು. ಸಾಮಾನ್ಯ ತಪ್ಪು: ಸಾಮಾನ್ಯ ಸಂದರ್ಭಕ್ಕೆ ಕೆಲಸ ಮಾಡುವ, ಆದರೆ ಅಂಚಿನ ಸಂದರ್ಭಗಳಿಗೆ ಕೆಲಸ ಮಾಡದ ಆಯ್ಕೆಯನ್ನು ಆರಿಸುವುದು. ಖಾಲಿ list, ಒಂದು item, ಪುನರಾವರ್ತಿತ ಮೌಲ್ಯಗಳು ಮತ್ತು ಋಣಾತ್ಮಕ ಸಂಖ್ಯೆಗಳೊಂದಿಗೆ ಪ್ರತಿಯೊಂದು ಆಯ್ಕೆಯನ್ನೂ ಪರಿಶೀಲಿಸಿ.

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

1. ಮೊದಲು ನಿಮ್ಮ ಆಹ್ವಾನವನ್ನು ಓದಿ. ನೀವು ಯಾವ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಬಳಸುತ್ತೀರಿ, ಎಷ್ಟು tasks ಇವೆ, ಸಮಯದ ಮಿತಿ ಎಷ್ಟು, Python 3 ಆಯ್ಕೆಮಾಡಬಹುದೇ ಮತ್ತು test ಅನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲಾಗುತ್ತದೆಯೇ ಎಂಬುದನ್ನು ತಿಳಿದುಕೊಳ್ಳಿ. ಪರೀಕ್ಷೆಯ ಸ್ವರೂಪಗಳು ತುಂಬಾ ವಿಭಿನ್ನವಾಗಿರುವುದರಿಂದ ಊಹಿಸಬೇಡಿ.
2. ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿ practice ವಿಭಾಗವಿದ್ದರೆ ಅದನ್ನು ಪ್ರಯತ್ನಿಸಿ. Editor, Run button ಮತ್ತು ಮಾದರಿ test cases ಹೇಗೆ ತೋರಿಸಲಾಗುತ್ತದೆ ಎಂಬುದಕ್ಕೆ ಒಗ್ಗಿಕೊಳ್ಳಿ. ಆಗ ಪರೀಕ್ಷೆಯ ದಿನ ಆ screen ಹೊಸದಾಗಿ ಅನಿಸುವುದಿಲ್ಲ. ಉದಾಹರಣೆಗೆ, ಕೆಲಸ ಮಾಡುವಾಗ candidates Run ಕ್ಲಿಕ್ ಮಾಡಿ test cases ಚಲಾಯಿಸುತ್ತಾರೆ ಎಂದು HackerRank ತಿಳಿಸುತ್ತದೆ (HackerRank Support).
3. Code ಅನ್ನು ಕೈಯಿಂದಲೇ ಕ್ರಮವಾಗಿ ಪರಿಶೀಲಿಸಿ. ಚಿಕ್ಕ code snippets ಗಾಗಿ, ಪ್ರತಿ ಸಾಲಿನ ನಂತರ ಪ್ರತಿಯೊಂದು variable ನ ಮೌಲ್ಯವನ್ನು ಬರೆಯಿರಿ. Output ಮತ್ತು debugging ಪ್ರಶ್ನೆಗಳಿಗೆ ಇದು ಮೂಲ ಕೌಶಲ್ಯ. ನಿಮ್ಮ code ಅನ್ನು ಚಲಾಯಿಸದೆಯೇ ಪರಿಶೀಲಿಸಲು ಇದು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
4. ದೈನಂದಿನ ಬಳಕೆಯ tools ತಿಳಿದುಕೊಳ್ಳಿ. Lists, dictionaries, sets, strings, slicing, sorted ಮತ್ತು list.sort ನಡುವಿನ ವ್ಯತ್ಯಾಸ, enumerate, zip, list ಮತ್ತು dictionary comprehensions, ಹಾಗೂ collections.Counter.
5. Submit ಮಾಡುವ ಮೊದಲು edge cases ಬಗ್ಗೆ ಯೋಚಿಸಿ. ಖಾಲಿ input, ಒಂದೇ item, ಪುನರಾವರ್ತಿತ values, ಋಣಾತ್ಮಕ ಸಂಖ್ಯೆಗಳು ಮತ್ತು ತುಂಬಾ ದೊಡ್ಡ inputs. Hidden test cases ಸಾಮಾನ್ಯವಾಗಿ ಇವನ್ನೇ ಪರಿಶೀಲಿಸುತ್ತವೆ.
6. ಸಮಯದ ಮಿತಿಯೊಳಗೆ code ಬರೆಯಿರಿ. ನಮ್ಮ mock tests ಓದುವ ಮತ್ತು debugging ಕೌಶಲ್ಯ ಬೆಳೆಸುತ್ತವೆ. ಒತ್ತಡದಲ್ಲಿ code ಬರೆಯುವುದು ಮತ್ತು ಚಲಾಯಿಸುವುದು ಸಹಜವೆನಿಸುವಂತೆ, timer ಬಳಸಿ ನೈಜ editor ನಲ್ಲಿ ಕೆಲವು ಚಿಕ್ಕ problems ಕೂಡ ಪರಿಹರಿಸಿ.
7. ನೈಜ ವೇಗದಲ್ಲಿ ಅಭ್ಯಾಸ ಮಾಡಿ. ನಿಮ್ಮ test, HackerRank ನ Python (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 ಮತ್ತು ಬಹು ಆಯ್ಕೆಯ ಪ್ರಶ್ನೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮೌಲ್ಯಮಾಪನ ಮಾಡಲಾಗುತ್ತದೆ. ಆದರೆ ವಿವರಣಾತ್ಮಕ ಉತ್ತರಗಳು ಮತ್ತು file uploadಗಳಂತಹ ಕೆಲವು ಪ್ರಕಾರಗಳನ್ನು ಕೈಯಾರೆ ಮೌಲ್ಯಮಾಪನ ಮಾಡಲಾಗುತ್ತದೆ (HackerRank Help).
• TestGorilla ನೀಡಿದ inputಗಳು ಸರಿಯಾದ output ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತವೆಯೇ ಎಂಬುದನ್ನು ಒಳಗೊಂಡ ಒಟ್ಟಾರೆ ಸರಿಯಾಗಿರುವಿಕೆಯ ಆಧಾರದ ಮೇಲೆ percentile ಅಂಕ ನೀಡುವ ವಿಧಾನ ಮತ್ತು ಪ್ರತಿ test caseನ ಫಲಿತಾಂಶ ತೋರಿಸುವ ವರದಿಯನ್ನು ವಿವರಿಸುತ್ತದೆ (TestGorilla).

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

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

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

• List ಅನ್ನು ಬದಲಿಸುವ methods ಮತ್ತು ಹೊಸ list ಹಿಂತಿರುಗಿಸುವ functions ಅನ್ನು ಗೊಂದಲಗೊಳಿಸುವುದು. list.sort() ಮತ್ತು list.append() None ಹಿಂತಿರುಗಿಸುತ್ತವೆ; sorted() ಹೊಸ list ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
• Assignment ಮಾಡಿದಾಗ objects ಹಂಚಿಕೆಯಾಗುತ್ತವೆ ಎಂಬುದನ್ನು ಮರೆತರೆ. b = a ಒಂದು list ಅಥವಾ dictionary ಅನ್ನು copy ಮಾಡುವುದಿಲ್ಲ. Copy ಬೇಕಾದರೆ a[:], list(a) ಅಥವಾ copy.deepcopy(a) ಬಳಸಿ.
• Ranges ಮತ್ತು slices ನಲ್ಲಿ ಒಂದರಷ್ಟು ತಪ್ಪುಗಳು. range(n) ಎಂಬುದು n ಗಿಂತ ಮೊದಲು ನಿಲ್ಲುತ್ತದೆ ಮತ್ತು s[1:3] ಮೂರು ಅಲ್ಲ, ಎರಡು items ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.
• ಕಲ್ಪಿತ ಮೌಲ್ಯದಿಂದ ಹುಡುಕಾಟ ಆರಂಭಿಸುವುದು. Maximum ಅನ್ನು 0 ರಿಂದ ಅಥವಾ minimum ಅನ್ನು 1000 ರಿಂದ ಆರಂಭಿಸಿದರೆ ಅಪರೂಪದ input ಗಳಲ್ಲಿ ತಪ್ಪಾಗುತ್ತದೆ. ಮೊದಲ item ನಿಂದ ಅಥವಾ float("-inf") ನಿಂದ ಆರಂಭಿಸಿ.
• ಉದಾಹರಣೆಯನ್ನು ಮಾತ್ರ ಪರೀಕ್ಷಿಸುವುದು. ಕಾಣುವ ಉದಾಹರಣೆ ಸಾಮಾನ್ಯವಾಗಿ ಪಾಸ್ ಆಗುತ್ತದೆ. ಖಾಲಿ input, ಒಂದೇ item, ನಕಲಿ ಮೌಲ್ಯಗಳು ಮತ್ತು ದೊಡ್ಡ input ಗಳನ್ನು ಗುಪ್ತ test cases ಪರಿಶೀಲಿಸುತ್ತವೆ.
• ಒಂದು ಕೆಲಸದಲ್ಲೇ ಸಮಯ ಮುಗಿಸಿಕೊಳ್ಳುವುದು. ಅಡಚಣೆಯಾದರೆ, ಕೆಲವು test cases ಪಾಸ್ ಆಗುವ ಸರಳ ಆವೃತ್ತಿಯನ್ನು ಸಲ್ಲಿಸಿ, ಮುಂದಿನದಕ್ಕೆ ಹೋಗಿ, ಸಮಯವಿದ್ದರೆ ಮತ್ತೆ ಬನ್ನಿ.