Python ਕੋਡਿੰਗ ਟੈਸਟ ਦਾ ਅਭਿਆਸ

ਅਸਲ ਟੈਸਟ ਆਮ ਤੌਰ 'ਤੇ ਕਿਹੋ ਜਿਹਾ ਹੁੰਦਾ ਹੈ

Python ਕੋਡਿੰਗ ਟੈਸਟ ਦਾ ਕੋਈ ਇੱਕੋ ਜਿਹਾ ਰੂਪ ਨਹੀਂ ਹੁੰਦਾ। ਹਰ ਨਿਯੋਗਦਾਤਾ ਇੱਕ ਟੈਸਟਿੰਗ ਪਲੇਟਫਾਰਮ ਚੁਣਦਾ ਹੈ ਅਤੇ ਫਿਰ ਆਪਣੇ ਸਵਾਲ, ਕੰਮਾਂ ਦੀ ਗਿਣਤੀ, ਸਮਾਂ ਸੀਮਾ ਅਤੇ ਮਨਜ਼ੂਰਸ਼ੁਦਾ ਭਾਸ਼ਾਵਾਂ ਤੈਅ ਕਰਦਾ ਹੈ। ਤੁਹਾਡੇ ਟੈਸਟ ਦਾ ਸੱਦਾ ਤੁਹਾਡੇ ਟੈਸਟ ਬਾਰੇ ਜਾਣਕਾਰੀ ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਸਰੋਤ ਹੈ। ਜਨਤਕ ਉਦਾਹਰਨਾਂ ਇਸ ਦੀ ਵੱਖ-ਵੱਖਤਾ ਦਿਖਾਉਂਦੀਆਂ ਹਨ:

• HackerRank. HackerRank ਆਪਣੇ Python (Basic) ਹੁਨਰ ਟੈਸਟ ਨੂੰ 1 ਘੰਟਾ 30 ਮਿੰਟ ਵਿੱਚ 2 ਸਵਾਲ ਵਜੋਂ ਦਰਸਾਉਂਦਾ ਹੈ। ਇਸ ਵਿੱਚ scalar types ਵਰਗੇ ਵਿਸ਼ੇ ਸ਼ਾਮਲ ਹਨ (HackerRank). ਇਸ ਦੇ ਮਦਦ ਕੇਂਦਰ ਵਿੱਚ ਉਹ ਸਵਾਲਾਂ ਦੀਆਂ ਕਿਸਮਾਂ ਦਿੱਤੀਆਂ ਗਈਆਂ ਹਨ ਜੋ ਨਿਯੋਗਦਾਤਾ ਟੈਸਟ ਵਿੱਚ ਰੱਖ ਸਕਦੇ ਹਨ, ਜਿਵੇਂ ਕੋਡਿੰਗ, ਬਹੁ-ਵਿਕਲਪੀ, ਡੇਟਾਬੇਸ, ਕੋਡ ਸਮੀਖਿਆ ਅਤੇ ਵਿਸ਼ਲੇਸ਼ਣਾਤਮਕ ਸਵਾਲ। ਇਹ ਵੀ ਦੱਸਿਆ ਗਿਆ ਹੈ ਕਿ ਨਿਯੋਗਦਾਤਾ HackerRank ਦੀ ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚੋਂ ਸਵਾਲ ਸ਼ਾਮਲ ਕਰ ਸਕਦੇ ਹਨ ਜਾਂ ਆਪਣੇ ਸਵਾਲ ਲਿਖ ਸਕਦੇ ਹਨ (HackerRank Help).
• TestGorilla. TestGorilla ਦੇ Python ਕੋਡਿੰਗ ਟੈਸਟਾਂ ਵਾਲੇ ਪੰਨੇ ਮੁਤਾਬਕ, ਇਸ ਦੇ ਜ਼ਿਆਦਾਤਰ ਵੱਖਰੇ ਕੋਡਿੰਗ ਟੈਸਟ 15 ਤੋਂ 35 ਮਿੰਟ ਲੈਂਦੇ ਹਨ। ਇਸ ਵਿੱਚ ਸ਼ੁਰੂਆਤੀ ਪੱਧਰ ਦਾ algorithms ਟੈਸਟ 15 ਮਿੰਟ ਦਾ ਦਿੱਤਾ ਗਿਆ ਹੈ। ਪੰਨੇ ਮੁਤਾਬਕ, ਉਮੀਦਵਾਰ Python ਜਾਂ ਨਿਯੋਗਦਾਤਾ ਵੱਲੋਂ ਮਨਜ਼ੂਰ ਕੀਤੀਆਂ ਹੋਰ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਸਮੱਸਿਆਵਾਂ ਹੱਲ ਕਰ ਸਕਦੇ ਹਨ (TestGorilla).

ਨਿਯੋਗਦਾਤਾਵਾਂ ਦੇ Python ਟੈਸਟਾਂ ਵਿੱਚ ਆਮ ਤੌਰ 'ਤੇ ਦੱਸੇ ਜਾਂਦੇ ਹਿੱਸੇ:

• ਕੋਡਿੰਗ ਦੇ ਕੰਮ: ਔਨਲਾਈਨ ਐਡੀਟਰ ਵਿੱਚ ਇੱਕ ਫੰਕਸ਼ਨ ਲਿਖੋ, ਇਸ ਨੂੰ ਨਮੂਨਾ ਇਨਪੁੱਟਾਂ ਨਾਲ ਚਲਾਓ, ਫਿਰ ਇਸ ਨੂੰ ਹੋਰ ਟੈਸਟ ਕੇਸਾਂ ਨਾਲ ਜਾਂਚ ਲਈ ਜਮ੍ਹਾਂ ਕਰੋ, ਜੋ ਸ਼ਾਇਦ ਤੁਹਾਨੂੰ ਦਿਖਾਈ ਨਾ ਦੇਣ।
• ਬਹੁ-ਵਿਕਲਪੀ ਸਵਾਲ: Python ਦੇ ਸੰਕਲਪ, ਕੋਡ ਦਾ ਛੋਟਾ ਹਿੱਸਾ ਕੀ ਨਤੀਜਾ ਦਿਖਾਉਂਦਾ ਹੈ ਅਤੇ ਕਿਹੜਾ ਕੋਡ ਸਹੀ ਹੈ।
• ਡੀਬੱਗਿੰਗ ਜਾਂ ਕੋਡ ਸਮੀਖਿਆ: ਕਿਸੇ ਹੋਰ ਵੱਲੋਂ ਲਿਖੇ ਕੋਡ ਵਿੱਚ ਸਮੱਸਿਆ ਲੱਭੋ ਅਤੇ ਠੀਕ ਕਰੋ।
• ਕਈ ਵਾਰ ਹੋਰ ਵੀ: SQL ਦਾ ਸਵਾਲ, ਵੱਡੇ ਪ੍ਰੋਜੈਕਟ ਦਾ ਕੰਮ, ਘਰ ਲਿਜਾਣ ਵਾਲਾ ਅਸਾਈਨਮੈਂਟ, ਜਾਂ ਟੈਸਟ ਦੌਰਾਨ ਵੈੱਬਕੈਮ ਅਤੇ ਸਕ੍ਰੀਨ ਦੀ ਨਿਗਰਾਨੀ।

ਸਾਡੇ ਮੌਕ ਟੈਸਟਾਂ ਵਿੱਚ ਕੀ ਸ਼ਾਮਲ ਹੈ। ਸਾਡੇ ਪੂਰੇ ਮੌਕ ਟੈਸਟਾਂ ਵਿੱਚ ਚਾਰ ਭਾਗਾਂ ਵਿੱਚ 60 ਮਿੰਟਾਂ ਵਿੱਚ 20 ਸਵਾਲ ਹੁੰਦੇ ਹਨ: Python ਦੇ ਸੰਕਲਪ (6), ਕੋਡ ਦਾ ਨਤੀਜਾ (6), ਬੱਗ ਲੱਭਣਾ (5) ਅਤੇ ਹੱਲ ਤਿਆਰ ਕਰਨਾ (3)। ਸਾਰਾ ਕੋਡ Python 3 ਵਿੱਚ ਹੈ। ਜਮ੍ਹਾਂ ਕਰਨ ਤੱਕ ਤੁਸੀਂ ਪਿੱਛੇ ਜਾ ਸਕਦੇ ਹੋ, ਜਵਾਬ ਬਦਲ ਸਕਦੇ ਹੋ ਅਤੇ ਸਵਾਲਾਂ ਨੂੰ ਫਲੈਗ ਕਰ ਸਕਦੇ ਹੋ। ਸਾਡੇ ਮੌਕ ਟੈਸਟ ਕੋਡ ਪੜ੍ਹਨ, ਉਸ ਦੇ ਕੰਮ ਕਰਨ ਦੇ ਤਰੀਕੇ ਦਾ ਪਤਾ ਲਗਾਉਣ, ਡੀਬੱਗ ਕਰਨ ਅਤੇ ਕੋਡ ਚੁਣਨ ਦੀ ਅਭਿਆਸ ਕਰਵਾਉਂਦੇ ਹਨ। ਇਹ ਤੁਹਾਡੇ ਲਿਖੇ ਕੋਡ ਨੂੰ ਚਲਾਉਂਦੇ ਨਹੀਂ ਹਨ। ਕਈ ਅਸਲ ਮੁਲਾਂਕਣਾਂ ਵਿੱਚ ਤੁਹਾਨੂੰ ਅਜਿਹਾ ਕੋਡ ਲਿਖਣਾ ਪੈਂਦਾ ਹੈ ਜੋ ਲੁਕਵੇਂ ਟੈਸਟ ਕੇਸਾਂ ਨਾਲ ਚੱਲਦਾ ਹੈ। ਇਹ ਅਭਿਆਸ ਇਸ ਦੇ ਪਿੱਛੇ ਲੋੜੀਂਦੇ ਕੋਡ ਪੜ੍ਹਨ, ਉਸ ਦੇ ਕੰਮ ਕਰਨ ਦੇ ਤਰੀਕੇ ਦਾ ਪਤਾ ਲਗਾਉਣ ਅਤੇ ਡੀਬੱਗ ਕਰਨ ਦੇ ਹੁਨਰ ਬਣਾਉਂਦਾ ਹੈ, ਇਸ ਲਈ ਅਸਲ ਐਡੀਟਰ ਵਿੱਚ ਸਮਾਂਬੱਧ ਅਭਿਆਸ ਵੀ ਕਰੋ। ਸਾਡੇ ਮੌਕ ਟੈਸਟਾਂ ਵਿੱਚ ਨਿਗਰਾਨੀ, ਸਾਹਿਤਕ ਚੋਰੀ ਦੀ ਜਾਂਚ, ਵੀਡੀਓ ਇੰਟਰਵਿਊ, ਘਰ ਲਿਜਾਣ ਵਾਲੇ ਅਤੇ ਪ੍ਰੋਜੈਕਟ ਦੇ ਕੰਮ, ਅਤੇ ਨਿਯੋਗਦਾਤਾ ਵੱਲੋਂ ਨਿਰਧਾਰਤ ਪਾਸ ਅੰਕ ਸ਼ਾਮਲ ਨਹੀਂ ਹਨ.

ਹੱਲ ਸਮੇਤ ਉਦਾਹਰਨਾਂ ਵਾਲੇ ਸਵਾਲਾਂ ਦੀਆਂ ਕਿਸਮਾਂ

ਹਰ ਭਾਗ ਲਈ ਇੱਕ ਹੱਲ ਸਮੇਤ ਉਦਾਹਰਨ, ਨਾਲ ਹੀ ਉਹ ਆਮ ਗਲਤੀ ਜਿਸ ਵਿੱਚ ਜ਼ਿਆਦਾਤਰ ਲੋਕ ਫਸ ਜਾਂਦੇ ਹਨ।

1. Python ਦੇ ਸੰਕਲਪ। a == b ਅਤੇ a is b ਵਿੱਚ ਕੀ ਫ਼ਰਕ ਹੈ? ਪਹਿਲਾ ਪੁੱਛਦਾ ਹੈ ਕਿ ਕੀ ਦੋ ਮੁੱਲ ਬਰਾਬਰ ਹਨ; ਦੂਜਾ ਪੁੱਛਦਾ ਹੈ ਕਿ ਕੀ ਉਹ ਇੱਕੋ ਆਬਜੈਕਟ ਹਨ। ਵੱਖ-ਵੱਖ [1, 2] ਲਿਸਟਾਂ ਦੇ ਮੁੱਲ ਬਰਾਬਰ ਹਨ, ਪਰ ਉਹ ਇੱਕੋ ਆਬਜੈਕਟ ਨਹੀਂ ਹਨ। ਆਮ ਗਲਤੀ: ਨੰਬਰਾਂ ਜਾਂ ਸਤਰਾਂ ਦੀ ਤੁਲਨਾ ਲਈ is ਵਰਤਣਾ। ਛੋਟੇ ਮੁੱਲਾਂ ਲਈ ਇਹ ਠੀਕ ਲੱਗ ਸਕਦਾ ਹੈ, ਪਰ ਬਾਅਦ ਵਿੱਚ ਗਲਤ ਹੋ ਸਕਦਾ ਹੈ।

2. ਕੋਡ ਕੀ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ। ਪਹਿਲਾਂ x = [0] * 3, ਫਿਰ x[1] = 5 ਅਤੇ print(x)। ਕਦਮਾਂ ਨੂੰ ਵੇਖੋ: [0, 0, 0] ਬਦਲ ਕੇ [0, 5, 0] ਬਣਦਾ ਹੈ। ਹੁਣ grid = [[0] * 2] * 2 ਅਤੇ ਫਿਰ grid[0][0] = 1 ਅਜ਼ਮਾਓ। ਇਹ [[1, 0], [1, 0]] ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ, ਕਿਉਂਕਿ ਦੋਵੇਂ ਕਤਾਰਾਂ ਇੱਕੋ ਅੰਦਰੂਨੀ ਲਿਸਟ ਹਨ। ਆਮ ਗਲਤੀ: ਕੋਡ ਨੂੰ ਇਸ ਆਧਾਰ 'ਤੇ ਪੜ੍ਹਨਾ ਕਿ ਤੁਸੀਂ ਇਸ ਤੋਂ ਕੀ ਕਰਨ ਦੀ ਉਮੀਦ ਕਰਦੇ ਹੋ, ਨਾ ਕਿ Python ਇਸ ਨੂੰ ਕਿਵੇਂ ਚਲਾਉਂਦਾ ਹੈ। ਹਰ ਲਾਈਨ ਤੋਂ ਬਾਅਦ ਹਰ ਵੇਰੀਏਬਲ ਦਾ ਮੁੱਲ ਲਿਖੋ।

3. ਬੱਗ ਲੱਭਣਾ। for i in range(len(items) - 1): ਲੂਪ ਦਾ ਮਕਸਦ ਹਰ ਆਈਟਮ ਪ੍ਰਿੰਟ ਕਰਨਾ ਹੈ, ਪਰ ਇਹ ਆਖ਼ਰੀ ਆਈਟਮ ਛੱਡ ਦਿੰਦਾ ਹੈ। ਬੱਗ - 1 ਹੈ: range(len(items)) ਪਹਿਲਾਂ ਹੀ ਲੰਬਾਈ ਤੱਕ ਪਹੁੰਚਣ ਤੋਂ ਪਹਿਲਾਂ ਰੁਕ ਜਾਂਦਾ ਹੈ। ਆਮ ਗਲਤੀ: ਗਲਤ ਨਤੀਜੇ ਦਾ ਕਾਰਨ ਬਣਨ ਵਾਲੀ ਲਾਈਨ ਦੀ ਬਜਾਏ, ਕਰੈਸ਼ ਹੋਣ ਵਾਲੀ ਜਾਂ ਅਜੀਬ ਲੱਗਣ ਵਾਲੀ ਲਾਈਨ ਨੂੰ ਠੀਕ ਕਰਨਾ। ਮਨ ਵਿੱਚ ਛੋਟੇ ਇਨਪੁੱਟ ਨਾਲ ਕੋਡ ਦੀ ਜਾਂਚ ਕਰੋ, ਜਿਵੇਂ ਦੋ ਆਈਟਮਾਂ ਵਾਲੀ ਲਿਸਟ।

4. ਹੱਲ ਤਿਆਰ ਕਰਨਾ। ਤੁਹਾਨੂੰ ਲਿਸਟ ਵਿੱਚ ਹਰ ਸ਼ਬਦ ਦੀ ਗਿਣਤੀ ਚਾਹੀਦੀ ਹੈ। collections.Counter(words) ਇਹ ਕੰਮ ਇੱਕ ਕਦਮ ਵਿੱਚ ਕਰਦਾ ਹੈ; ਲੂਪ ਵਿੱਚ counts[w] = counts.get(w, 0) + 1 ਵਾਲੀ ਡਿਕਸ਼ਨਰੀ ਨਾਲ ਇਹ ਹੱਥੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਆਮ ਗਲਤੀ: ਉਹ ਵਿਕਲਪ ਚੁਣਨਾ ਜੋ ਆਮ ਹਾਲਾਤ ਵਿੱਚ ਤਾਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਪਰ ਸੀਮਾਵੀ ਹਾਲਾਤਾਂ ਵਿੱਚ ਨਹੀਂ। ਹਰ ਵਿਕਲਪ ਨੂੰ ਖਾਲੀ ਲਿਸਟ, ਇੱਕ ਆਈਟਮ, ਦੁਹਰਾਏ ਮੁੱਲਾਂ ਅਤੇ ਨਕਾਰਾਤਮਕ ਨੰਬਰਾਂ ਨਾਲ ਜਾਂਚੋ।

ਤਿਆਰੀ ਕਿਵੇਂ ਕਰੀਏ

1. ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਆਪਣਾ ਸੱਦਾ ਪੜ੍ਹੋ। ਪਤਾ ਕਰੋ ਕਿ ਤੁਸੀਂ ਕਿਹੜਾ ਪਲੇਟਫਾਰਮ ਵਰਤੋਗੇ, ਕਿੰਨੇ ਕੰਮ ਹਨ, ਸਮਾਂ ਸੀਮਾ ਕੀ ਹੈ, ਕੀ ਤੁਸੀਂ Python 3 ਚੁਣ ਸਕਦੇ ਹੋ, ਅਤੇ ਕੀ ਟੈਸਟ ਦੀ ਨਿਗਰਾਨੀ ਕੀਤੀ ਜਾਵੇਗੀ। ਫਾਰਮੈਟਾਂ ਵਿੱਚ ਇੰਨਾ ਫ਼ਰਕ ਹੁੰਦਾ ਹੈ ਕਿ ਪਹਿਲਾਂ ਤੋਂ ਅੰਦਾਜ਼ਾ ਨਹੀਂ ਲਗਾਇਆ ਜਾ ਸਕਦਾ।
2. ਜੇ ਪਲੇਟਫਾਰਮ 'ਤੇ ਅਭਿਆਸ ਵਾਲਾ ਹਿੱਸਾ ਹੈ, ਤਾਂ ਉਸਨੂੰ ਅਜ਼ਮਾਓ। Editor, Run ਬਟਨ ਅਤੇ ਨਮੂਨਾ test cases ਦਿਖਾਉਣ ਦੇ ਤਰੀਕੇ ਨਾਲ ਜਾਣੂ ਹੋ ਜਾਓ, ਤਾਂ ਜੋ ਟੈਸਟ ਵਾਲੇ ਦਿਨ ਸਕ੍ਰੀਨ ਨਵੀਂ ਨਾ ਲੱਗੇ। ਮਿਸਾਲ ਵਜੋਂ, HackerRank ਦੱਸਦਾ ਹੈ ਕਿ ਉਮੀਦਵਾਰ ਕੰਮ ਕਰਦੇ ਸਮੇਂ test cases ਚਲਾਉਣ ਲਈ Run 'ਤੇ ਕਲਿੱਕ ਕਰਦੇ ਹਨ (HackerRank Support).
3. ਕੋਡ ਨੂੰ ਹੱਥ ਨਾਲ ਸਮਝੋ। ਛੋਟੇ code snippets ਲਈ ਹਰ ਲਾਈਨ ਤੋਂ ਬਾਅਦ ਹਰ variable ਦੀ value ਲਿਖੋ। Output ਅਤੇ debugging ਵਾਲੇ ਸਵਾਲਾਂ ਦਾ ਇਹ ਮੁੱਖ ਹੁਨਰ ਹੈ, ਅਤੇ ਇਸੇ ਤਰ੍ਹਾਂ ਤੁਸੀਂ ਆਪਣਾ ਕੋਡ ਚਲਾਏ ਬਿਨਾਂ ਜਾਂਚ ਸਕਦੇ ਹੋ।
4. ਰੋਜ਼ਮਰ੍ਹਾ ਦੇ tools ਜਾਣੋ। Lists, dictionaries, sets, strings, slicing, sorted ਅਤੇ list.sort ਦਾ ਫ਼ਰਕ, enumerate, zip, list ਅਤੇ dictionary comprehensions, ਅਤੇ collections.Counter।
5. ਜਵਾਬ ਜਮ੍ਹਾਂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਖ਼ਾਸ ਹਾਲਾਤਾਂ ਬਾਰੇ ਸੋਚੋ। ਖਾਲੀ input, ਇੱਕ item, ਦੁਹਰਾਈਆਂ values, ਨੈਗੇਟਿਵ ਨੰਬਰ ਅਤੇ ਬਹੁਤ ਵੱਡੇ inputs। ਲੁਕੇ ਹੋਏ test cases ਅਕਸਰ ਇਨ੍ਹਾਂ ਦੀ ਹੀ ਜਾਂਚ ਕਰਦੇ ਹਨ।
6. ਸਮੇਂ ਦੀ ਪਾਬੰਦੀ ਹੇਠ ਕੁਝ ਕੋਡ ਲਿਖੋ। ਸਾਡੇ mock tests ਪੜ੍ਹਨ ਅਤੇ debugging ਦਾ ਅਭਿਆਸ ਕਰਵਾਉਂਦੇ ਹਨ। ਨਾਲ ਹੀ timer ਲਗਾ ਕੇ ਅਸਲ editor ਵਿੱਚ ਕੁਝ ਛੋਟੀਆਂ ਸਮੱਸਿਆਵਾਂ ਹੱਲ ਕਰੋ, ਤਾਂ ਜੋ ਦਬਾਅ ਹੇਠ ਕੋਡ ਲਿਖਣਾ ਅਤੇ ਚਲਾਉਣਾ ਆਮ ਲੱਗੇ।
7. ਅਸਲ ਰਫ਼ਤਾਰ ਨਾਲ ਅਭਿਆਸ ਕਰੋ। ਜੇ ਤੁਹਾਡਾ ਟੈਸਟ HackerRank ਦੇ Python (Basic) ਉਦਾਹਰਨ ਵਰਗਾ ਹੈ, ਤਾਂ 1 ਘੰਟਾ 30 ਮਿੰਟਾਂ ਵਿੱਚ 2 ਸਵਾਲਾਂ ਲਈ ਹਰ ਸਮੱਸਿਆ 'ਤੇ ਲਗਭਗ 45 ਮਿੰਟ ਮਿਲਦੇ ਹਨ (HackerRank). ਪੂਰੇ ਸਮੇਂ-ਬੱਧ mock tests ਦਿਓ, ਤਾਂ ਜੋ ਆਪਣੀ ਰਫ਼ਤਾਰ ਸੰਭਾਲਣਾ ਆਮ ਲੱਗੇ।

ਅੰਕ ਦੇਣ ਦਾ ਤਰੀਕਾ ਆਮ ਤੌਰ 'ਤੇ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ

ਸਕੋਰਿੰਗ ਪਲੇਟਫਾਰਮ ਅਤੇ ਨਿਯੋਗਤਾ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ। ਸਭ ਲਈ ਕੋਈ ਇੱਕੋ ਜਿਹਾ ਪੈਮਾਨਾ ਜਾਂ ਪਾਸ ਅੰਕ ਨਹੀਂ ਹਨ। ਕੋਡਿੰਗ ਸਵਾਲਾਂ ਦਾ ਸਕੋਰ ਆਮ ਤੌਰ 'ਤੇ ਟੈਸਟ ਕੇਸਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਆਪਣੇ ਆਪ ਤੈਅ ਹੁੰਦਾ ਹੈ। ਇਸ ਬਾਰੇ ਦੋ ਜਨਤਕ ਵੇਰਵੇ:

• HackerRank ਦੱਸਦਾ ਹੈ ਕਿ ਕੋਡਿੰਗ ਸਵਾਲਾਂ ਦਾ ਮੁਲਾਂਕਣ ਪਹਿਲਾਂ ਤੋਂ ਤੈਅ ਕੀਤੇ ਟੈਸਟ ਕੇਸਾਂ ਨਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜੋ ਕੋਡ ਦੀ ਸਹੀਪਣ ਅਤੇ ਕੁਸ਼ਲਤਾ ਮਾਪਦੇ ਹਨ। ਹਰ ਟੈਸਟ ਕੇਸ ਦਾ ਆਪਣਾ ਸਕੋਰ ਹੁੰਦਾ ਹੈ: ਜੇ ਕੋਡ ਟੈਸਟ ਕੇਸ ਪਾਸ ਕਰੇ ਤਾਂ ਉਸ ਕੇਸ ਦੇ ਪੂਰੇ ਅੰਕ ਮਿਲਦੇ ਹਨ, ਅਤੇ ਫੇਲ੍ਹ ਹੋਣ 'ਤੇ ਜ਼ੀਰੋ। ਸਵਾਲ ਦਾ ਕੁੱਲ ਸਕੋਰ ਪਾਸ ਕੀਤੇ ਟੈਸਟ ਕੇਸਾਂ ਦੇ ਅੰਕਾਂ ਦਾ ਜੋੜ ਹੁੰਦਾ ਹੈ। ਇਸ ਲਈ ਕੁਝ ਟੈਸਟ ਕੇਸ ਪਾਸ ਕਰਨ ਵਾਲੇ ਹੱਲ ਨੂੰ ਅੰਸ਼ਕ ਅੰਕ ਮਿਲਦੇ ਹਨ (HackerRank Support). ਕੋਡਿੰਗ ਅਤੇ ਬਹੁ-ਵਿਕਲਪੀ ਸਵਾਲਾਂ ਦਾ ਮੁਲਾਂਕਣ ਆਪਣੇ ਆਪ ਹੁੰਦਾ ਹੈ, ਜਦਕਿ ਕੁਝ ਕਿਸਮਾਂ, ਜਿਵੇਂ ਵਿਅਕਤੀਗਤ ਵਿਚਾਰ ਵਾਲੇ ਜਵਾਬ ਅਤੇ ਫ਼ਾਈਲ ਅੱਪਲੋਡ, ਹੱਥੀਂ ਜਾਂਚੇ ਜਾਂਦੇ ਹਨ (HackerRank Help).
• TestGorilla ਦੱਸਦਾ ਹੈ ਕਿ ਸਕੋਰਿੰਗ ਕੁੱਲ ਸਹੀਪਣ ਦੇ ਆਧਾਰ 'ਤੇ ਪ੍ਰਤੀਸ਼ਤਕ੍ਰਮ ਵਿੱਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਦਿੱਤੇ ਇਨਪੁੱਟਾਂ ਤੋਂ ਸਹੀ ਆਉਟਪੁੱਟ ਮਿਲਦਾ ਹੈ ਜਾਂ ਨਹੀਂ। ਰਿਪੋਰਟ ਵਿੱਚ ਹਰ ਟੈਸਟ ਕੇਸ ਦੇ ਨਤੀਜੇ ਵੀ ਦਿਖਾਏ ਜਾਂਦੇ ਹਨ (TestGorilla).

ਚੰਗਾ ਨਤੀਜਾ ਕਿਸ ਨੂੰ ਮੰਨਿਆ ਜਾਵੇ, ਇਹ ਹਰ ਨਿਯੋਗਤਾ ਤੈਅ ਕਰਦਾ ਹੈ। ਕਈ ਨਿਯੋਗਤਾ ਸਕੋਰ ਦੇ ਨਾਲ ਤੁਹਾਡਾ ਕੋਡ ਵੀ ਦੇਖਦੇ ਹਨ।

ਸਾਡਾ ਅਭਿਆਸ ਸਕੋਰ ਦੱਸਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਸਾਡੇ ਕਿੰਨੇ ਸਵਾਲਾਂ ਦੇ ਸਹੀ ਜਵਾਬ ਦਿੱਤੇ ਹਨ। ਇਸ ਵਿੱਚ ਭਾਗ ਅਨੁਸਾਰ ਵੇਰਵਾ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਜੋ ਤੁਸੀਂ ਦੇਖ ਸਕੋ ਕਿ ਕਿੱਥੇ ਧਿਆਨ ਦੇਣਾ ਹੈ। ਇਹ ਸਿਰਫ਼ ਅਭਿਆਸ ਸਕੋਰ ਹੈ: ਇਹ ਕਿਸੇ ਪਲੇਟਫਾਰਮ ਦੇ ਟੈਸਟ ਦਾ ਸਕੋਰ ਨਹੀਂ ਹੈ ਅਤੇ ਇਹ ਨਹੀਂ ਦੱਸਦਾ ਕਿ ਤੁਸੀਂ ਪਾਸ ਹੋਵੋਗੇ ਜਾਂ ਨਹੀਂ।

ਆਮ ਗਲਤੀਆਂ

• 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 ਜਾਂਚੇ ਜਾਂਦੇ ਹਨ।
• ਇੱਕ ਕੰਮ 'ਤੇ ਸਮਾਂ ਮੁੱਕ ਜਾਣਾ। ਜੇ ਤੁਸੀਂ ਫਸ ਜਾਓ, ਤਾਂ ਅਜਿਹਾ ਸੌਖਾ ਹੱਲ ਜਮ੍ਹਾਂ ਕਰੋ ਜੋ ਕੁਝ ਟੈਸਟ ਪਾਸ ਕਰੇ, ਅਗਲੇ ਕੰਮ 'ਤੇ ਜਾਓ ਅਤੇ ਸਮਾਂ ਬਚੇ ਤਾਂ ਮੁੜ ਆਓ।