Codility-ਸ਼ੈਲੀ ਦੇ ਕੋਡਿੰਗ ਟੈਸਟ ਦਾ ਅਭਿਆਸ

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

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

Codility ਕੀ ਦੱਸਦਾ ਹੈ। Codility ਮੁਤਾਬਕ, ਹਰ ਕੰਮ ਨੂੰ ਤੈਅ ਮਾਪਦੰਡਾਂ ਅਨੁਸਾਰ ਆਪਣੇ-ਆਪ ਅੰਕ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ (Codility)। ਪ੍ਰੋਗਰਾਮਰਾਂ ਲਈ ਇਸਦੇ ਮੁਫ਼ਤ ਪਾਠ (Codility) ਕੰਮ ਦਾ ਰੂਪ ਦਿਖਾਉਂਦੇ ਹਨ: ਇੱਕ ਛੋਟੀ ਸਮੱਸਿਆ, ਲਿਖਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਅਤੇ ਇਨਪੁੱਟ ਦੀਆਂ ਦੱਸੀਆਂ ਗਈਆਂ ਸੀਮਾਵਾਂ। ਮਿਸਾਲ ਵਜੋਂ, ਇਸਦੇ BinaryGap ਪਾਠ ਵਿੱਚ 2,147,483,647 ਤੱਕ ਦੇ ਇਨਪੁੱਟ ਲਈ "ਇੱਕ ਕੁਸ਼ਲ ਐਲਗੋਰਿਦਮ" ਬਣਾਉਣ ਲਈ ਕਿਹਾ ਜਾਂਦਾ ਹੈ (Codility), ਅਤੇ ਇੱਕ ਪਾਠ ਦਾ ਸਿਰਲੇਖ Time Complexity ਹੈ (Codility)।

Codility ਟੈਸਟਾਂ ਬਾਰੇ ਆਮ ਤੌਰ 'ਤੇ ਦੱਸੀਆਂ ਜਾਂਦੀਆਂ ਗੱਲਾਂ (ਉਮੀਦਵਾਰਾਂ ਅਤੇ ਗਾਈਡਾਂ ਤੋਂ; ਅਸੀਂ ਜਿਸ Codility ਪੰਨੇ ਨੂੰ ਖੋਲ੍ਹ ਸਕੇ, ਉਸ 'ਤੇ ਇਨ੍ਹਾਂ ਦੀ ਪੁਸ਼ਟੀ ਨਹੀਂ ਸੀ):

• ਇੱਕੋ ਟਾਈਮਰ ਹੇਠ ਕੁਝ ਕੰਮ - ਪੂਰੇ ਟੈਸਟ ਲਈ, ਆਮ ਤੌਰ 'ਤੇ 30 ਮਿੰਟ ਤੋਂ 2 ਘੰਟਿਆਂ ਤੱਕ।
• ਲੁਕਵੇਂ ਸਹੀਪਣ ਟੈਸਟ: ਤੁਹਾਡੇ ਕੋਡ ਦੀ ਜਾਂਚ ਉਹਨਾਂ ਮਾਮਲਿਆਂ ਨਾਲ ਵੀ ਹੁੰਦੀ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਨਹੀਂ ਦਿਖਦੇ, ਕੰਮ ਵਿੱਚ ਦਿੱਤੀ ਮਿਸਾਲ ਤੋਂ ਇਲਾਵਾ।
• ਵੱਡੇ ਇਨਪੁੱਟਾਂ 'ਤੇ ਕਾਰਗੁਜ਼ਾਰੀ - ਐਲਗੋਰਿਦਮ ਵਾਲੇ ਕੰਮਾਂ ਵਿੱਚ: ਸਹੀ ਪਰ ਹੌਲਾ ਹੱਲ ਅੰਕ ਗੁਆ ਸਕਦਾ ਹੈ।
• ਤੁਹਾਡੇ ਵੱਲੋਂ ਲੱਗਣ ਵਾਲਾ ਸਮਾਂ - ਸਮਾਂ-ਸੀਮਾ ਦੇ ਅੰਦਰ ਤੁਸੀਂ ਜਿੰਨਾ ਸਮਾਂ ਲੈਂਦੇ ਹੋ, ਉਹ ਅੰਕਾਂ ਦਾ ਹਿੱਸਾ ਨਹੀਂ ਹੁੰਦਾ।

ਸਾਡੇ ਮੌਕ ਟੈਸਟਾਂ ਵਿੱਚ ਕੀ ਸ਼ਾਮਲ ਹੈ। ਹਰ ਪੂਰਾ ਮੌਕ ਟੈਸਟ 90 ਮਿੰਟਾਂ ਵਿੱਚ ਤਿੰਨ ਕੋਡਿੰਗ ਕੰਮਾਂ ਦਾ ਹੁੰਦਾ ਹੈ। ਕੰਮ ਆਸਾਨ ਤੋਂ ਔਖੇ ਵੱਲ ਜਾਂਦੇ ਹਨ। ਤੁਸੀਂ Python, JavaScript, Java ਜਾਂ C++ ਵਿੱਚ ਹੱਲ ਲਿਖਦੇ ਅਤੇ ਚਲਾਉਂਦੇ ਹੋ। ਫਿਰ ਲੁਕਵੇਂ ਟੈਸਟ ਕੇਸਾਂ ਨਾਲ ਉਸਦੀ ਜਾਂਚ ਹੁੰਦੀ ਹੈ ਅਤੇ ਹਰ ਪਾਸ ਕੀਤੇ ਕੇਸ ਲਈ ਅੰਕ ਮਿਲਦੇ ਹਨ। ਲੈਪਟਾਪ ਵਰਤਣ ਦੀ ਸਿਫ਼ਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਜਮ੍ਹਾਂ ਕਰਨ ਤੱਕ ਤੁਸੀਂ ਵਾਪਸ ਜਾ ਕੇ ਹੱਲ ਬਦਲ ਸਕਦੇ ਹੋ।

ਸਾਡੇ ਮੌਕ ਟੈਸਟਾਂ ਵਿੱਚ ਕੀ ਵੱਖਰਾ ਹੈ। ਆਮ ਤੌਰ 'ਤੇ ਦੱਸਿਆ ਜਾਂਦਾ ਹੈ ਕਿ ਅਸਲ Codility ਕੰਮਾਂ ਦੀ ਸਹੀਪਣ ਲਈ ਅਤੇ ਕਈ ਕੰਮਾਂ ਵਿੱਚ ਵੱਡੇ ਇਨਪੁੱਟਾਂ 'ਤੇ ਕਾਰਗੁਜ਼ਾਰੀ ਲਈ ਜਾਂਚ ਹੁੰਦੀ ਹੈ। ਸਾਡੇ ਲੁਕਵੇਂ ਕੇਸ ਛੋਟੇ ਹੁੰਦੇ ਹਨ ਅਤੇ ਸਹੀਪਣ ਤੇ ਸੀਮਾਵਰਤੀ ਮਾਮਲਿਆਂ ਦੀ ਜਾਂਚ ਕਰਦੇ ਹਨ, ਇਸ ਲਈ ਹੌਲੇ ਹੱਲ ਦਾ ਸਮਾਂ ਖ਼ਤਮ ਨਹੀਂ ਹੁੰਦਾ; ਹਰ ਕੰਮ ਦੀ ਵਿਆਖਿਆ ਦੱਸਦੀ ਹੈ ਕਿ ਵੱਡੇ ਇਨਪੁੱਟ ਲਈ ਕਿੰਨੀ ਜਟਿਲਤਾ ਵਾਲਾ ਹੱਲ ਚਾਹੀਦਾ ਹੋਵੇਗਾ। 10 ਮੁਫ਼ਤ ਸਵਾਲ ਬਹੁ-ਵਿਕਲਪੀ ਹਨ। ਇਨ੍ਹਾਂ ਵਿੱਚ ਸਹੀਪਣ, ਜਟਿਲਤਾ, ਸੀਮਾਵਰਤੀ ਮਾਮਲਿਆਂ ਅਤੇ ਗਤੀ ਬਾਰੇ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ - ਯਾਨੀ ਉਹ ਸੋਚ ਜਿਸ ਨਾਲ ਇਹ ਜਾਂਚਾਂ ਪਾਸ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ।

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

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

1. ਕਿਹੜਾ ਹੱਲ ਸਹੀ ਹੈ। ਕੰਮ: ਸੂਚੀ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਮੁੱਲਾਂ ਦੀ ਗਿਣਤੀ ਵਾਪਸ ਕਰਨੀ। ਹੱਲ: len(set(A))। ਇਹ ਹਰ ਸੂਚੀ ਲਈ ਸਹੀ ਹੈ, ਖਾਲੀ ਸੂਚੀ ਲਈ ਵੀ, ਜਿਸ ਦਾ ਨਤੀਜਾ 0 ਹੁੰਦਾ ਹੈ। ਗਲਤੀ: sort ਕੀਤੀ ਸੂਚੀ ਨਾਲ ਆਪਣਾ ਲੂਪ ਲਿਖਣਾ ਅਤੇ ਪਹਿਲੀ ਜਾਂ ਆਖ਼ਰੀ ਆਈਟਮ ਭੁੱਲ ਜਾਣਾ। ਜਦੋਂ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ ਕੰਮ ਕਰਦਾ ਹੋਵੇ, ਤਾਂ ਪਹਿਲਾਂ ਜਾਂਚੋ ਕਿ ਉਹ ਕਿਨਾਰੇ ਵਾਲੇ ਕੇਸ ਸੰਭਾਲਦਾ ਹੈ, ਫਿਰ ਉਸ ਦੀ ਵਰਤੋਂ ਕਰੋ।

2. ਸਮੇਂ ਦੀ ਜਟਿਲਤਾ। ਇੱਕ ਹੱਲ A ਉੱਤੇ ਲੂਪ ਚਲਾਉਂਦਾ ਹੈ ਅਤੇ ਲੂਪ ਦੇ ਅੰਦਰ max(A[:i]) ਕਾਲ ਕਰਦਾ ਹੈ। ਸਲਾਈਸ ਅਤੇ max ਦੋਵੇਂ ਵੱਧ ਤੋਂ ਵੱਧ i ਆਈਟਮਾਂ ਨੂੰ ਵੇਖਦੇ ਹਨ, ਇਸ ਲਈ ਕੁੱਲ ਲਗਭਗ N squared ਨੂੰ 2 ਨਾਲ ਭਾਗ ਦੇ ਬਰਾਬਰ ਕਦਮ, ਯਾਨੀ O(N squared), ਹਨ। ਇਸ ਦੀ ਬਜਾਏ ਚੱਲਦਾ ਵੱਧ ਤੋਂ ਵੱਧ ਮੁੱਲ ਰੱਖਣ ਨਾਲ ਜਟਿਲਤਾ O(N) ਹੋ ਜਾਂਦੀ ਹੈ। ਗਲਤੀ: ਇੱਕ ਲੂਪ ਦੇਖ ਕੇ ਇਸ ਨੂੰ O(N) ਕਹਿ ਦੇਣਾ। ਲੂਪ ਦੇ ਅੰਦਰ ਸਲਾਈਸ, ਜੋੜ, ਗਿਣਤੀਆਂ ਅਤੇ ਖੋਜਾਂ ਵੀ ਵੇਖੋ।

3. ਕਿਹੜੀ ਇਨਪੁੱਟ ਇਸ ਨੂੰ ਫੇਲ੍ਹ ਕਰਦੀ ਹੈ। ਕੰਮ: A ਵਿੱਚ ਨਾ ਹੋਣ ਵਾਲਾ ਸਭ ਤੋਂ ਛੋਟਾ ਧਨਾਤਮਕ ਪੂਰਨ ਅੰਕ ਵਾਪਸ ਕਰਨਾ। ਇੱਕ ਹੱਲ max(A) + 1 ਵਾਪਸ ਕਰਦਾ ਹੈ। A = [1, 2, 3] ਅਜ਼ਮਾਓ: ਇਹ 4 ਦਿੰਦਾ ਹੈ, ਜੋ ਸਹੀ ਹੈ। A = [1, 3] ਅਜ਼ਮਾਓ: ਇਹ 4 ਦਿੰਦਾ ਹੈ, ਪਰ 2 ਮੌਜੂਦ ਨਹੀਂ, ਇਸ ਲਈ ਜਵਾਬ 2 ਹੈ। A = [-3, -1] ਅਜ਼ਮਾਓ: ਇਹ 0 ਦਿੰਦਾ ਹੈ, ਪਰ ਜਵਾਬ 1 ਹੈ। ਗਲਤੀ: ਇੱਕ ਸਹੀ ਕੇਸ ਤੋਂ ਬਾਅਦ ਜਾਂਚ ਰੋਕ ਦੇਣਾ। ਕਿਨਾਰੇ ਵਾਲੇ ਕੇਸ ਜਾਣ-ਬੁੱਝ ਕੇ ਸੂਚੀਬੱਧ ਕਰੋ: ਵਿਚਕਾਰਲੇ ਖਾਲੀ ਪਾੜੇ, ਸਾਰੇ ਨਕਾਰਾਤਮਕ ਮੁੱਲ, ਇਜਾਜ਼ਤ ਹੋਣ 'ਤੇ ਖਾਲੀ ਸੂਚੀ, ਇੱਕ ਆਈਟਮ, ਸਾਰੇ ਬਰਾਬਰ ਮੁੱਲ ਅਤੇ ਮਨਜ਼ੂਰਸ਼ੁਦਾ ਸਭ ਤੋਂ ਵੱਡੇ ਮੁੱਲ।

4. N 100,000 ਤੱਕ ਹੋਣ 'ਤੇ ਕਾਫ਼ੀ ਤੇਜ਼। ਇੱਕ ਆਮ ਨਿਯਮ ਵਜੋਂ, ਇਸ ਆਕਾਰ ਲਈ O(N) ਜਾਂ O(N log N) ਦਾ ਟੀਚਾ ਰੱਖੋ। O(N squared) ਦਾ ਮਤਲਬ ਲਗਭਗ 10 billion ਕਦਮ ਹੈ, ਜੋ ਆਮ ਸਮਾਂ-ਸੀਮਾ ਤੋਂ ਕਿਤੇ ਵੱਧ ਹੈ। ਗਲਤੀ: ਸਿਰਫ਼ ਦਸ ਆਈਟਮਾਂ ਨਾਲ ਜਾਂਚ ਕਰਨਾ, ਜਿੱਥੇ ਹਰ ਤਰੀਕਾ ਤੁਰੰਤ ਚੱਲਦਾ ਲੱਗਦਾ ਹੈ। ਸੋਚੋ ਕਿ N ਵਧਣ ਨਾਲ ਕੰਮ ਕਿੰਨਾ ਵਧਦਾ ਹੈ।

5. ਸੀਮਾਵਾਂ ਪੜ੍ਹਨਾ। ਜੇ ਮੁੱਲ 1,000,000,000 ਤੱਕ ਹੋ ਸਕਦੇ ਹਨ ਅਤੇ N 100,000 ਹੈ, ਤਾਂ ਜੋੜ 100 trillion ਤੱਕ ਪਹੁੰਚ ਸਕਦਾ ਹੈ। Python ਦੇ ਪੂਰਨ ਅੰਕ ਇਸ ਨੂੰ ਸੰਭਾਲ ਲੈਂਦੇ ਹਨ, ਪਰ ਨਿਸ਼ਚਿਤ ਆਕਾਰ ਵਾਲੇ ਪੂਰਨ ਅੰਕਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਵਾਲੀਆਂ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਓਵਰਫਲੋ ਹੋ ਜਾਵੇਗਾ। ਗਲਤੀ: ਮੁੱਲਾਂ ਦੀ ਹੱਦ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਨਾ। ਇਸ ਤੋਂ ਪਤਾ ਲੱਗਦਾ ਹੈ ਕਿ ਓਵਰਫਲੋ ਹੋ ਸਕਦਾ ਹੈ ਜਾਂ ਨਹੀਂ ਅਤੇ ਗਿਣਤੀ ਵਾਲੀ ਐਰੇ ਵਰਗੀਆਂ ਕਿਹੜੀਆਂ ਤਕਨੀਕਾਂ ਵਰਤੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ।

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

1. ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਸੱਦਾ ਪੜ੍ਹੋ। ਕੰਮਾਂ ਦੀ ਗਿਣਤੀ, ਕੁੱਲ ਸਮਾਂ ਅਤੇ ਮਨਜ਼ੂਰਸ਼ੁਦਾ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਨੋਟ ਕਰੋ। ਇਹ ਫ਼ੈਸਲੇ ਰੁਜ਼ਗਾਰਦਾਤਾ ਕਰਦੇ ਹਨ, ਇਸ ਲਈ ਅੰਦਾਜ਼ਾ ਨਾ ਲਗਾਓ।
2. ਇੱਕ ਅਜਿਹੀ ਭਾਸ਼ਾ ਵਰਤੋ ਜਿਸ ਵਿੱਚ ਤੁਸੀਂ ਚੰਗੇ ਹੋ। ਇਸ ਦੀਆਂ ਲਿਸਟਾਂ, ਡਿਕਸ਼ਨਰੀਆਂ, ਸੈੱਟਾਂ, ਛਾਂਟਣ ਅਤੇ ਸਟਰਿੰਗ ਵਿਧੀਆਂ ਜਾਣੋ, ਤਾਂ ਜੋ ਤੁਹਾਨੂੰ ਉਹਨਾਂ ਨੂੰ ਲੱਭਣਾ ਨਾ ਪਵੇ।
3. ਕੋਡ ਲਿਖਣ ਤੋਂ ਪਹਿਲਾਂ ਸੀਮਾਵਾਂ ਪੜ੍ਹੋ। ਕੰਮ ਵਿੱਚ ਦਿੱਤੇ ਇਨਪੁੱਟ ਦਾ ਆਕਾਰ ਅਤੇ ਮੁੱਲਾਂ ਦੀਆਂ ਹੱਦਾਂ ਦੱਸਦੀਆਂ ਹਨ ਕਿ ਹੱਲ ਕਿੰਨਾ ਤੇਜ਼ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਕਿਹੜੇ ਸੀਮਾਵਰਤੀ ਮਾਮਲੇ ਅਹਿਮ ਹਨ। Codility ਦੇ ਆਪਣੇ ਪਾਠਾਂ ਵਿੱਚ ਵੀ ਇਹੀ ਗੱਲ ਦਿਖਦੀ ਹੈ (Codility)।
4. ਪਹਿਲਾਂ ਹੱਲ ਸਹੀ ਬਣਾਓ, ਫਿਰ ਤੇਜ਼ ਕਰੋ। ਪਹਿਲਾਂ ਸੌਖਾ ਅਤੇ ਸਹੀ ਹੱਲ ਲਿਖੋ। ਜੇ ਇਸਦੀ ਜਟਿਲਤਾ O(N squared) ਹੈ ਅਤੇ N ਦੀ ਗਿਣਤੀ 100,000 ਤੱਕ ਪਹੁੰਚ ਸਕਦੀ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਘਟਾਉਣ ਲਈ ਚੱਲਦਾ ਕੁੱਲ, ਡਿਕਸ਼ਨਰੀ, ਸੈੱਟ ਜਾਂ ਛਾਂਟਣ ਵਰਤਣ ਬਾਰੇ ਸੋਚੋ।
5. ਸੀਮਾਵਰਤੀ ਮਾਮਲਿਆਂ ਦੀ ਖੁਦ ਜਾਂਚ ਕਰੋ। ਕੰਮ ਵਿੱਚ ਦਿੱਤੀ ਮਿਸਾਲ ਸਿਰਫ਼ ਇੱਕ ਕੇਸ ਹੈ। ਜੇ ਮਨਜ਼ੂਰ ਹੋਵੇ ਤਾਂ ਖਾਲੀ ਇਨਪੁੱਟ, ਇੱਕ ਆਈਟਮ, ਸਾਰੇ ਇੱਕੋ ਜਿਹੇ ਮੁੱਲ, ਨੈਗੇਟਿਵ ਮੁੱਲ, ਸਭ ਤੋਂ ਛੋਟੇ ਅਤੇ ਸਭ ਤੋਂ ਵੱਡੇ ਮੁੱਲ, ਅਤੇ ਸਭ ਤੋਂ ਵੱਡਾ N ਅਜ਼ਮਾਓ।
6. ਆਮ ਤਰੀਕੇ ਸਿੱਖੋ। ਪ੍ਰੀਫਿਕਸ ਜੋੜ, ਸਲਾਈਡਿੰਗ ਵਿੰਡੋ, ਡਿਕਸ਼ਨਰੀ ਨਾਲ ਗਿਣਤੀ, ਦੋ ਪੁਆਇੰਟਰ, ਪਹਿਲਾਂ ਛਾਂਟਣਾ ਅਤੇ ਸਧਾਰਨ ਗ੍ਰੀਡੀ ਚੋਣਾਂ - ਇਹ ਛੋਟੇ ਐਲਗੋਰਿਦਮ ਵਾਲੇ ਬਹੁਤ ਸਾਰੇ ਕੰਮਾਂ ਵਿੱਚ ਮਦਦ ਕਰਦੇ ਹਨ। Codility ਦੇ ਮੁਫ਼ਤ ਪਾਠ ਇਸ ਤਰੀਕੇ ਨੂੰ ਸਮਝਣ ਲਈ ਚੰਗੀ ਥਾਂ ਹਨ (Codility)।
7. ਸਮਾਂ-ਸੀਮਾ ਵਿੱਚ ਪੂਰੇ ਹੱਲ ਲਿਖੋ। ਸਾਡੇ ਪੂਰੇ ਮੌਕ ਟੈਸਟਾਂ ਵਿੱਚ ਤੁਸੀਂ ਲੁਕਵੇਂ ਕੇਸਾਂ ਦੇ ਮੁਕਾਬਲੇ ਕੋਡ ਲਿਖਦੇ ਅਤੇ ਚਲਾਉਂਦੇ ਹੋ। ਆਪਣੇ ਚੁਣੇ ਕੰਮਾਂ ਨਾਲ ਵੀ ਇਹੀ ਕਰੋ, ਤਾਂ ਜੋ ਸਮਾਂ-ਸੀਮਾ ਵਿੱਚ ਲਿਖਣਾ ਆਮ ਲੱਗੇ।
8. ਅਸਲ ਰਫ਼ਤਾਰ ਨਾਲ ਅਭਿਆਸ ਕਰੋ। ਪੂਰੇ ਸਮੇਂਬੱਧ ਮੌਕ ਟੈਸਟ ਦਿਓ, ਤਾਂ ਜੋ ਟੈਸਟ ਵਾਲੇ ਦਿਨ ਇੱਕੋ ਟਾਈਮਰ ਹੇਠ ਤਿੰਨ ਕੰਮ ਕਰਨ ਦੀ ਆਦਤ ਹੋਵੇ।

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

ਹਰ ਰੋਜ਼ਗਾਰਦਾਤਾ ਆਪਣੀ ਸਕੋਰਿੰਗ ਤੈਅ ਕਰਦਾ ਹੈ। Codility ਦੱਸਦਾ ਹੈ ਕਿ ਹਰ ਟਾਸਕ ਨੂੰ ਨਿਰਧਾਰਤ ਮਾਪਦੰਡਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਆਪਣੇ ਆਪ ਸਕੋਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ (Codility), ਅਤੇ ਹਰ ਰੋਜ਼ਗਾਰਦਾਤਾ ਫ਼ੈਸਲਾ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹੜਾ ਨਤੀਜਾ ਕਾਫ਼ੀ ਚੰਗਾ ਹੈ। ਪਾਸ ਹੋਣ ਲਈ ਕੋਈ ਇੱਕੋ ਜਿਹਾ ਮਾਪਦੰਡ ਨਹੀਂ ਹੈ।

ਇਨ੍ਹਾਂ ਮਾਪਦੰਡਾਂ ਦੇ ਕੰਮ ਕਰਨ ਬਾਰੇ ਆਮ ਤੌਰ 'ਤੇ ਦੱਸਿਆ ਜਾਂਦਾ ਹੈ: ਕਿਸੇ ਟਾਸਕ ਦਾ ਸਕੋਰ ਲੁਕੇ ਹੋਏ ਸਹੀਪਣ ਦੇ ਟੈਸਟਾਂ ਤੋਂ ਬਣਦਾ ਹੈ ਅਤੇ, ਕਈ ਐਲਗੋਰਿਦਮ ਵਾਲੇ ਟਾਸਕਾਂ ਲਈ, ਵੱਡੇ ਇਨਪੁੱਟਾਂ 'ਤੇ ਕਾਰਗੁਜ਼ਾਰੀ ਦੇ ਟੈਸਟਾਂ ਤੋਂ ਵੀ। ਇਨ੍ਹਾਂ ਨੂੰ ਜੋੜ ਕੇ ਪਹਿਲਾਂ ਟਾਸਕ ਲਈ ਅਤੇ ਫਿਰ ਟੈਸਟ ਲਈ ਪ੍ਰਤੀਸ਼ਤ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ। ਛੋਟੇ ਇਨਪੁੱਟਾਂ 'ਤੇ ਸਹੀ ਪਰ ਵੱਡੇ ਇਨਪੁੱਟਾਂ 'ਤੇ ਬਹੁਤ ਹੌਲੀ ਚੱਲਣ ਵਾਲਾ ਹੱਲ ਕਾਰਗੁਜ਼ਾਰੀ ਦੇ ਅੰਕ ਗੁਆ ਸਕਦਾ ਹੈ, ਅਤੇ ਜਿਹੜਾ ਹੱਲ ਕਿਸੇ ਖ਼ਾਸ ਮਾਮਲੇ ਵਿੱਚ ਅਸਫਲ ਹੁੰਦਾ ਹੈ, ਉਹ ਸਹੀਪਣ ਦੇ ਸਕੋਰ ਦਾ ਕੁਝ ਹਿੱਸਾ ਗੁਆ ਦਿੰਦਾ ਹੈ। ਇਸੇ ਲਈ ਸਾਡੇ ਮੌਕ ਟੈਸਟਾਂ ਵਿੱਚ ਵਾਰ-ਵਾਰ ਇਹ ਸਵਾਲ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਪੁੱਛੇ ਜਾਂਦੇ ਹਨ: "ਕੀ ਇਹ ਸਹੀ ਹੈ?" ਅਤੇ "ਕੀ ਇਹ ਕਾਫ਼ੀ ਤੇਜ਼ ਹੈ?"

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

ਆਮ ਗਲਤੀਆਂ

• ਉਦਾਹਰਨ 'ਤੇ ਭਰੋਸਾ ਕਰਨਾ। ਕਿਸੇ ਕੰਮ ਦੀ ਉਦਾਹਰਨ ਕਈ ਲੁਕੇ ਹੋਏ cases ਵਿੱਚੋਂ ਸਿਰਫ਼ ਇੱਕ ਹੁੰਦੀ ਹੈ। ਕੋਈ ਹੱਲ ਇਸਨੂੰ ਪਾਸ ਕਰ ਸਕਦਾ ਹੈ ਪਰ ਫਿਰ ਵੀ ਜ਼ਿਆਦਾਤਰ ਅੰਕ ਗੁਆ ਸਕਦਾ ਹੈ।
• N ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਨਾ। ਸਹੀ O(N squared) ਹੱਲ, N = 100,000 'ਤੇ performance ਜਾਂਚਾਂ ਵਿੱਚ ਫੇਲ੍ਹ ਹੋ ਸਕਦਾ ਹੈ। ਪਹਿਲਾਂ ਹੱਦਾਂ ਜਾਂਚੋ।
• Loop ਦੇ ਅੰਦਰ ਲੁਕਿਆ ਕੰਮ। Loop ਦੇ ਅੰਦਰ list 'ਤੇ slice, sum, count, index ਜਾਂ "in" ਵਰਤਣ ਨਾਲ ਕੁੱਲ ਲਾਗਤ ਕਈ ਗੁਣਾ ਹੋ ਜਾਂਦੀ ਹੈ।
• ਆਖ਼ਰੀ item ਛੱਡ ਦੇਣਾ। ਇੱਕ ਦੀ ਗਿਣਤੀ ਅੱਗੇ-ਪਿੱਛੇ ਵਾਲੀਆਂ ranges ਅਤੇ list ਦੇ ਅੰਤ ਤੱਕ ਚੱਲਣ ਵਾਲੇ runs ਆਮ ਗਲਤੀਆਂ ਹਨ। ਆਖ਼ਰੀ ਕਦਮ ਨੂੰ ਹੱਥੀਂ trace ਕਰੋ।
• ਸ਼ੁਰੂਆਤੀ ਮੁੱਲ ਗਲਤ ਰੱਖਣਾ। Maximum ਨੂੰ 0 ਤੋਂ ਜਾਂ minimum ਨੂੰ ਕਿਸੇ ਮਨਘੜਤ ਵੱਡੇ ਮੁੱਲ ਤੋਂ ਸ਼ੁਰੂ ਕਰਨ ਨਾਲ ਨਕਾਰਾਤਮਕ ਜਾਂ ਬਹੁਤ ਵੱਡੇ ਮੁੱਲਾਂ 'ਤੇ ਗਲਤੀ ਹੁੰਦੀ ਹੈ। ਪਹਿਲੇ item ਤੋਂ ਸ਼ੁਰੂ ਕਰੋ।
• ਕੰਮ ਲਈ ਲੋੜੀਂਦਾ ਕ੍ਰਮ ਬਦਲ ਦੇਣਾ। Sorting ਬਹੁਤ ਲਾਭਦਾਇਕ ਹੈ, ਪਰ ਉਦੋਂ ਨਹੀਂ ਜਦੋਂ ਜਵਾਬ positions ਜਾਂ "list ਵਿੱਚ ਪਹਿਲਾਂ" ਵਾਲੀ ਸ਼ਰਤ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੋਵੇ।
• ਸਾਰਾ ਸਮਾਂ ਇੱਕ ਕੰਮ 'ਤੇ ਲਾਉਣਾ। ਪਹਿਲਾਂ ਹਰ ਕੰਮ ਦਾ ਸਹੀ ਹੱਲ ਜਮ੍ਹਾਂ ਕਰੋ, ਫਿਰ ਸਮਾਂ ਬਚੇ ਤਾਂ ਗਤੀ ਸੁਧਾਰੋ।