HackerRank-ਸ਼ੈਲੀ ਕੋਡਿੰਗ ਟੈਸਟ ਅਭਿਆਸ

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

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

ਸਵਾਲਾਂ ਦੀਆਂ ਕਿਸਮਾਂ। HackerRank ਆਪਣੇ ਟੈਸਟਾਂ ਲਈ ਕਈ ਕਿਸਮਾਂ ਦੇ ਸਵਾਲ ਦੱਸਦਾ ਹੈ, ਜਿਵੇਂ ਕੋਡਿੰਗ, ਡੇਟਾਬੇਸ, ਬਹੁ-ਵਿਕਲਪੀ, ਫਰੰਟ-ਐਂਡ, ਬੈਕ-ਐਂਡ, ਫੁੱਲ-ਸਟੈਕ, ਕੋਡ ਸਮੀਖਿਆ, ਵਿਅਕਤੀਗਤ ਜਵਾਬ ਵਾਲੇ ਸਵਾਲ ਅਤੇ ਹੋਰ (HackerRank)। ਜ਼ਿਆਦਾਤਰ ਕੋਡਿੰਗ ਟੈਸਟਾਂ ਵਿੱਚ ਇਨ੍ਹਾਂ ਵਿੱਚੋਂ ਕੁਝ ਕਿਸਮਾਂ ਸ਼ਾਮਲ ਹੁੰਦੀਆਂ ਹਨ:

• ਕੋਡਿੰਗ ਸਵਾਲ: ਤੁਸੀਂ ਐਡੀਟਰ ਵਿੱਚ ਹੱਲ ਲਿਖਦੇ ਹੋ। HackerRank ਮੁਤਾਬਕ, ਉਮੀਦਵਾਰ ਆਪਣੇ ਕੋਡ ਨੂੰ ਟੈਸਟ ਕੇਸਾਂ ਨਾਲ ਚਲਾ ਸਕਦੇ ਹਨ। ਇਸ ਤੋਂ ਬਾਅਦ ਕੋਡ ਨੂੰ ਦਿਖਣ ਵਾਲੇ ਨਮੂਨਾ ਕੇਸਾਂ ਅਤੇ ਨਾ ਦਿਖਣ ਵਾਲੇ ਲੁਕਵੇਂ ਕੇਸਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਅੰਕ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ (HackerRank support)।
• ਡੇਟਾਬੇਸ ਸਵਾਲ: ਤੁਸੀਂ SQL ਕਵੈਰੀ ਲਿਖਦੇ ਹੋ ਅਤੇ ਇਸਦੇ ਨਤੀਜੇ ਦੀ ਉਮੀਦ ਕੀਤੇ ਆਉਟਪੁੱਟ ਨਾਲ ਤੁਲਨਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ (HackerRank support)।
• ਬਹੁ-ਵਿਕਲਪੀ: ਧਾਰਨਾਵਾਂ, ਜਟਿਲਤਾ ਅਤੇ ਕੋਡ ਦਾ ਕੋਈ ਹਿੱਸਾ ਕੀ ਕਰਦਾ ਹੈ - ਇਨ੍ਹਾਂ ਦੀ ਆਪਣੇ-ਆਪ ਜਾਂਚ ਕਰਕੇ ਅੰਕ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ (HackerRank)।

ਲੰਬਾਈ ਦੀਆਂ ਜਨਤਕ ਮਿਸਾਲਾਂ। HackerRank ਦੇ ਆਪਣੇ ਹੁਨਰ ਟੈਸਟਾਂ ਤੋਂ ਲੰਬਾਈ ਦਾ ਅੰਦਾਜ਼ਾ ਮਿਲਦਾ ਹੈ: ਇਸਦਾ Python (Basic) ਟੈਸਟ 90 ਮਿੰਟਾਂ ਵਿੱਚ 2 ਸਵਾਲਾਂ ਦਾ ਦਰਜ ਹੈ (HackerRank) ਅਤੇ SQL (Basic) ਟੈਸਟ 30 ਮਿੰਟਾਂ ਵਿੱਚ 2 ਸਵਾਲਾਂ ਦਾ (HackerRank)। ਕਿਸੇ ਰੁਜ਼ਗਾਰਦਾਤਾ ਦਾ ਟੈਸਟ ਇਸ ਤੋਂ ਛੋਟਾ ਜਾਂ ਲੰਮਾ ਹੋ ਸਕਦਾ ਹੈ ਅਤੇ ਇਸ ਵਿੱਚ ਸਵਾਲ ਵੱਧ ਜਾਂ ਘੱਟ ਹੋ ਸਕਦੇ ਹਨ।

ਕੋਡਿੰਗ ਟੈਸਟਾਂ ਵਿੱਚ ਆਮ ਤੌਰ 'ਤੇ ਦੱਸੇ ਜਾਂਦੇ ਵਿਸ਼ੇ: ਐਰੇ ਅਤੇ ਸਟਰਿੰਗ, ਹੈਸ਼ ਮੈਪ ਅਤੇ ਸੈੱਟ, ਛਾਂਟਣਾ ਅਤੇ ਖੋਜਣਾ, ਸਮਾਂ ਜਟਿਲਤਾ, ਖਾਲੀ ਜਾਂ ਨੈਗੇਟਿਵ ਇਨਪੁੱਟ ਵਰਗੇ ਸੀਮਾਵਰਤੀ ਮਾਮਲੇ ਅਤੇ ਮੁੱਢਲੀ SQL।

ਸਾਡੇ ਮੌਕ ਟੈਸਟਾਂ ਵਿੱਚ ਕੀ ਸ਼ਾਮਲ ਹੈ। ਹਰ ਪੂਰਾ ਮੌਕ ਟੈਸਟ 90 ਮਿੰਟਾਂ ਵਿੱਚ 14 ਸਵਾਲਾਂ ਦਾ ਹੁੰਦਾ ਹੈ ਅਤੇ ਇਸਦੇ ਤਿੰਨ ਹਿੱਸੇ ਹਨ: ਧਾਰਨਾਵਾਂ ਅਤੇ ਕੋਡ ਪੜ੍ਹਨਾ (10), ਕੋਡਿੰਗ ਸਮੱਸਿਆਵਾਂ (3) ਅਤੇ ਇੱਕ ਡੇਟਾਬੇਸ ਸਮੱਸਿਆ (1)। ਕੋਡਿੰਗ ਸਮੱਸਿਆਵਾਂ ਲਈ ਤੁਸੀਂ Python, JavaScript, Java ਜਾਂ C++ ਵਿੱਚ ਹੱਲ ਲਿਖਦੇ ਅਤੇ ਚਲਾਉਂਦੇ ਹੋ, ਅਤੇ ਡੇਟਾਬੇਸ ਸਮੱਸਿਆ ਲਈ SQL ਕਵੈਰੀ ਲਿਖਦੇ ਹੋ। ਹਰ ਹੱਲ ਦੀ ਲੁਕਵੇਂ ਟੈਸਟ ਕੇਸਾਂ ਨਾਲ ਜਾਂਚ ਹੁੰਦੀ ਹੈ ਅਤੇ ਹਰ ਪਾਸ ਕੀਤੇ ਕੇਸ ਲਈ ਅੰਕ ਮਿਲਦੇ ਹਨ। ਲੈਪਟਾਪ ਵਰਤਣ ਦੀ ਸਿਫ਼ਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਤੁਸੀਂ ਵਾਪਸ ਜਾ ਕੇ ਸਵਾਲਾਂ 'ਤੇ ਨਿਸ਼ਾਨ ਲਾ ਸਕਦੇ ਹੋ।

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

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

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

1. ਸਮੇਂ ਦੀ ਜਟਿਲਤਾ। ਸੂਚੀ ਉੱਤੇ ਚੱਲਦਾ ਇੱਕ ਲੂਪ ਹਰ ਵਾਰ "x in other_list" ਕਰਦਾ ਹੈ। ਦੋਵਾਂ ਸੂਚੀਆਂ ਵਿੱਚ n ਆਈਟਮਾਂ ਹਨ। ਲੂਪ n ਵਾਰ ਚੱਲਦਾ ਹੈ ਅਤੇ ਹਰ ਵਾਰ ਮੈਂਬਰਸ਼ਿਪ ਦੀ ਜਾਂਚ ਵੱਧ ਤੋਂ ਵੱਧ n ਆਈਟਮਾਂ ਵੇਖਦੀ ਹੈ, ਇਸ ਲਈ ਪੂਰੀ ਕਾਰਵਾਈ O(n squared) ਹੈ। other_list ਨੂੰ set ਵਿੱਚ ਬਦਲਣ ਨਾਲ ਹਰ ਜਾਂਚ ਔਸਤਨ O(1) ਅਤੇ ਲੂਪ O(n) ਹੋ ਜਾਂਦਾ ਹੈ। ਗਲਤੀ: ਸਿਰਫ਼ ਦਿਖਾਈ ਦੇ ਰਹੇ ਲੂਪ ਦੀ ਗਿਣਤੀ ਕਰਨਾ। ਸੂਚੀ ਉੱਤੇ "in", list.index ਅਤੇ slicing ਵਰਗੀਆਂ ਬਿਲਟ-ਇਨ ਕਾਲਾਂ ਵੀ ਕੰਮ ਕਰਦੀਆਂ ਹਨ।

2. ਕੋਡ ਪੜ੍ਹਨਾ। print([x * 2 for x in range(3)]) ਕੀ ਦਿਖਾਉਂਦਾ ਹੈ? range(3) ਤੋਂ 0, 1 ਅਤੇ 2 ਮਿਲਦੇ ਹਨ, ਇਸ ਲਈ ਜਵਾਬ [0, 2, 4] ਹੈ। ਗਲਤੀ: 1 ਤੋਂ ਸ਼ੁਰੂ ਕਰਨਾ ਜਾਂ 3 ਨੂੰ ਸ਼ਾਮਲ ਕਰਨਾ। range ਆਪਣੀ ਅੰਤਿਮ ਕੀਮਤ ਤੋਂ ਪਹਿਲਾਂ ਰੁਕ ਜਾਂਦਾ ਹੈ।

3. ਕਿਹੜਾ ਹੱਲ ਪਾਸ ਹੁੰਦਾ ਹੈ। ਇੱਕ ਸਮੱਸਿਆ ਵਿੱਚ ਵੱਧ ਤੋਂ ਵੱਧ 100,000 ਆਈਟਮਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। O(n squared) ਹੱਲ ਨੂੰ ਲਗਭਗ 10 billion ਕਦਮ ਲੱਗਣਗੇ, ਜੋ ਆਮ ਸਮਾਂ-ਸੀਮਾ ਲਈ ਬਹੁਤ ਹੌਲੀ ਹੈ, ਜਦਕਿ O(n) ਜਾਂ O(n log n) ਆਰਾਮ ਨਾਲ ਚੱਲੇਗਾ। ਗਲਤੀ: ਉਹ ਹੱਲ ਚੁਣਨਾ ਜੋ ਲਿਖਣ ਵਿੱਚ ਸਭ ਤੋਂ ਛੋਟਾ ਲੱਗਦਾ ਹੈ। ਪਹਿਲਾਂ ਦਿੱਤੇ ਆਕਾਰ ਦੇ ਮੁਕਾਬਲੇ ਉਸ ਦੀ ਜਟਿਲਤਾ ਜਾਂਚੋ।

4. ਕਿਹੜੀ ਇਨਪੁੱਟ ਇਸ ਨੂੰ ਫੇਲ੍ਹ ਕਰਦੀ ਹੈ। ਇੱਕ ਫੰਕਸ਼ਨ sum(nums) / len(nums) ਰਾਹੀਂ ਸੂਚੀ ਦੀ ਔਸਤ ਦਿੰਦਾ ਹੈ। ਕਿਹੜੀ ਇਨਪੁੱਟ ਇਸ ਨੂੰ ਫੇਲ੍ਹ ਕਰਦੀ ਹੈ? ਖਾਲੀ ਸੂਚੀ, ਜਿਸ ਨਾਲ ਜ਼ੀਰੋ ਨਾਲ ਭਾਗ ਹੁੰਦਾ ਹੈ। ਗਲਤੀ: ਸਿਰਫ਼ ਆਮ ਇਨਪੁੱਟ ਦੀ ਜਾਂਚ ਕਰਨਾ। ਖਾਲੀ ਸੂਚੀ, ਇੱਕ ਆਈਟਮ, ਸਾਰੀਆਂ ਬਰਾਬਰ ਆਈਟਮਾਂ, ਨਕਾਰਾਤਮਕ ਮੁੱਲ ਅਤੇ ਮਨਜ਼ੂਰਸ਼ੁਦਾ ਸਭ ਤੋਂ ਵੱਡਾ ਆਕਾਰ ਅਜ਼ਮਾਓ।

5. ਡਾਟਾਬੇਸ ਦੀ ਸਮੱਸਿਆ। ਤੁਹਾਨੂੰ ਹਰ ਗਾਹਕ ਦਾ ਕੁੱਲ ਖਰਚਾ ਚਾਹੀਦਾ ਹੈ, ਉਨ੍ਹਾਂ ਗਾਹਕਾਂ ਸਮੇਤ ਜਿਨ੍ਹਾਂ ਨੇ ਕੁਝ ਵੀ ਖਰਚ ਨਹੀਂ ਕੀਤਾ। customers LEFT JOIN orders ਵਰਤੋ, ਗਾਹਕ ਦੇ ਆਧਾਰ 'ਤੇ ਗਰੁੱਪ ਬਣਾਓ ਅਤੇ ਰਕਮ ਦਾ ਜੋੜ ਕੱਢੋ, ਫਿਰ COALESCE ਨਾਲ NULL ਨੂੰ 0 ਵਿੱਚ ਬਦਲੋ। ਗਲਤੀ: inner join ਵਰਤਣਾ, ਜੋ ਬਿਨਾਂ ਆਰਡਰ ਵਾਲੇ ਗਾਹਕਾਂ ਨੂੰ ਬਿਨਾਂ ਦੱਸੇ ਹਟਾ ਦਿੰਦਾ ਹੈ।

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

1. ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਸੱਦਾ ਪੜ੍ਹੋ। ਸਮਾਂ-ਸੀਮਾ, ਸਵਾਲਾਂ ਦੀ ਗਿਣਤੀ ਅਤੇ ਕਿਸਮ, ਅਤੇ ਮਨਜ਼ੂਰਸ਼ੁਦਾ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਨੋਟ ਕਰੋ। ਇਹ ਸਾਰੀਆਂ ਗੱਲਾਂ ਰੁਜ਼ਗਾਰਦਾਤਾ ਤੈਅ ਕਰਦੇ ਹਨ, ਇਸ ਲਈ ਅੰਦਾਜ਼ਾ ਨਾ ਲਗਾਓ।
2. ਇੱਕ ਭਾਸ਼ਾ ਚੁਣੋ ਅਤੇ ਉਸੇ 'ਤੇ ਟਿਕੇ ਰਹੋ। ਕੋਡਿੰਗ ਸਵਾਲਾਂ ਲਈ ਉਹ ਭਾਸ਼ਾ ਵਰਤੋ ਜਿਸ ਵਿੱਚ ਤੁਸੀਂ ਸਭ ਤੋਂ ਵੱਧ ਜਾਣਕਾਰ ਹੋ। ਇਸ ਦੀਆਂ ਬਿਲਟ-ਇਨ ਲਿਸਟਾਂ, ਡਿਕਸ਼ਨਰੀਆਂ, ਸੈੱਟਾਂ, ਛਾਂਟਣ ਅਤੇ ਸਟਰਿੰਗ ਵਿਧੀਆਂ ਇੰਨੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਜਾਣੋ ਕਿ ਤੁਹਾਨੂੰ ਉਹਨਾਂ ਨੂੰ ਲੱਭਣਾ ਨਾ ਪਵੇ।
3. ਇਨਪੁੱਟ ਦੇ ਆਕਾਰ ਮੁਤਾਬਕ ਜਟਿਲਤਾ ਸਮਝੋ। ਕੋਡ ਲਿਖਣ ਤੋਂ ਪਹਿਲਾਂ ਦਿੱਤੀਆਂ ਸੀਮਾਵਾਂ ਵੇਖੋ। ਲਗਭਗ 1,000 ਆਈਟਮਾਂ ਤੱਕ O(n squared) ਆਮ ਤੌਰ 'ਤੇ ਠੀਕ ਹੁੰਦਾ ਹੈ; 100,000 ਜਾਂ ਇਸ ਤੋਂ ਵੱਧ ਲਈ O(n) ਜਾਂ O(n log n) ਦਾ ਟੀਚਾ ਰੱਖੋ।
4. ਸੀਮਾਵਰਤੀ ਮਾਮਲਿਆਂ ਦਾ ਜਾਣ-ਬੁੱਝ ਕੇ ਅਭਿਆਸ ਕਰੋ। ਖਾਲੀ ਇਨਪੁੱਟ, ਇੱਕ ਆਈਟਮ, ਦੁਹਰਾਏ ਮੁੱਲ, ਨੈਗੇਟਿਵ ਮੁੱਲ, ਬਹੁਤ ਵੱਡੇ ਮੁੱਲ ਅਤੇ ਵੱਧ ਤੋਂ ਵੱਧ ਆਕਾਰ। ਕੋਡਿੰਗ ਸਵਾਲਾਂ ਦੇ ਅੰਕ ਲੁਕਵੇਂ ਟੈਸਟ ਕੇਸਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ (HackerRank support), ਅਤੇ ਅਕਸਰ ਇਹੀ ਉਹ ਥਾਂ ਹੁੰਦੀ ਹੈ ਜਿੱਥੇ ਅਜਿਹੇ ਕੇਸ ਲੁਕੇ ਹੁੰਦੇ ਹਨ।
5. ਨਮੂਨਾ ਕੇਸ ਚਲਾਓ, ਫਿਰ ਆਪਣੇ ਕੇਸਾਂ ਦੀ ਜਾਂਚ ਕਰੋ। ਦਿਖਣ ਵਾਲੇ ਨਮੂਨੇ ਪਾਸ ਕਰਨਾ ਸ਼ੁਰੂਆਤ ਹੈ, ਅੰਤ ਨਹੀਂ। ਜਮ੍ਹਾਂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਆਪਣੇ ਕੁਝ ਕੇਸ ਵੀ ਸ਼ਾਮਲ ਕਰੋ।
6. ਮੁੱਢਲੀ SQL ਦੁਹਰਾਓ। Joins, GROUP BY, HAVING, NULLs ਅਤੇ ਛਾਂਟਣਾ ਜ਼ਿਆਦਾਤਰ ਡੇਟਾਬੇਸ ਸਵਾਲਾਂ ਲਈ ਕਾਫ਼ੀ ਹੁੰਦੇ ਹਨ। ਨਤੀਜੇ ਦੀ ਹਰ ਕਤਾਰ ਜਾਂਚੋ, ਕਿਉਂਕਿ ਡੇਟਾਬੇਸ ਦੇ ਜਵਾਬਾਂ ਦੀ ਉਮੀਦ ਕੀਤੇ ਆਉਟਪੁੱਟ ਨਾਲ ਤੁਲਨਾ ਹੁੰਦੀ ਹੈ (HackerRank support)।
7. ਸਮਾਂ-ਸੀਮਾ ਵਿੱਚ ਪੂਰੇ ਹੱਲ ਲਿਖੋ। ਸਾਡੇ ਪੂਰੇ ਮੌਕ ਟੈਸਟਾਂ ਵਿੱਚ ਤੁਸੀਂ ਲੁਕਵੇਂ ਕੇਸਾਂ ਦੇ ਮੁਕਾਬਲੇ ਕੋਡ ਲਿਖਦੇ ਅਤੇ ਚਲਾਉਂਦੇ ਹੋ। ਆਪਣੇ ਚੁਣੇ ਸਵਾਲਾਂ ਨਾਲ ਵੀ ਇਹੀ ਕਰੋ, ਤਾਂ ਜੋ ਸਮਾਂ-ਸੀਮਾ ਵਿੱਚ ਪੂਰਾ ਹੱਲ ਲਿਖਣਾ ਆਮ ਲੱਗੇ।
8. ਅਸਲ ਰਫ਼ਤਾਰ ਨਾਲ ਅਭਿਆਸ ਕਰੋ। ਪੂਰੇ ਸਮੇਂਬੱਧ ਮੌਕ ਟੈਸਟ ਦਿਓ, ਤਾਂ ਜੋ ਟੈਸਟ ਵਾਲੇ ਦਿਨ 90 ਮਿੰਟ ਧਿਆਨ ਨਾਲ ਕੰਮ ਕਰਨਾ ਆਮ ਲੱਗੇ।

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

ਹਰ ਰੋਜ਼ਗਾਰਦਾਤਾ ਆਪਣੀ ਸਕੋਰਿੰਗ ਤੈਅ ਕਰਦਾ ਹੈ। HackerRank ਦੱਸਦਾ ਹੈ ਕਿ ਇਸ ਦੇ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੇ ਸਵਾਲਾਂ ਨੂੰ ਕਿਵੇਂ ਸਕੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਹਰ ਰੋਜ਼ਗਾਰਦਾਤਾ ਫ਼ੈਸਲਾ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹੜਾ ਨਤੀਜਾ ਕਾਫ਼ੀ ਚੰਗਾ ਹੈ। ਪਾਸ ਹੋਣ ਲਈ ਕੋਈ ਇੱਕੋ ਜਿਹਾ ਮਾਪਦੰਡ ਨਹੀਂ ਹੈ।

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

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

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

ਆਮ ਗਲਤੀਆਂ

• Samples ਪਾਸ ਹੋਣ 'ਤੇ ਹੀ ਰੁਕ ਜਾਣਾ। ਦਿਖਾਏ ਗਏ samples, ਸਾਰੇ test cases ਦਾ ਛੋਟਾ ਜਿਹਾ ਹਿੱਸਾ ਹੁੰਦੇ ਹਨ। ਖਾਲੀ input, ਇੱਕ item, ਨਕਾਰਾਤਮਕ ਮੁੱਲ ਅਤੇ ਸਭ ਤੋਂ ਵੱਡੇ ਆਕਾਰ ਦੀ ਖੁਦ ਜਾਂਚ ਕਰੋ।
• Input ਦੀਆਂ ਹੱਦਾਂ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਨਾ। ਸਹੀ ਪਰ ਹੌਲੀ solution ਵੱਡੇ ਲੁਕੇ ਹੋਏ cases ਵਿੱਚ ਫੇਲ੍ਹ ਹੋ ਸਕਦੀ ਹੈ। ਤਰੀਕਾ ਚੁਣਨ ਤੋਂ ਪਹਿਲਾਂ ਹੱਦਾਂ ਪੜ੍ਹੋ।
• Maximum ਨੂੰ 0 ਤੋਂ ਸ਼ੁਰੂ ਕਰਨਾ। ਪਹਿਲੇ item ਤੋਂ ਸ਼ੁਰੂ ਕਰੋ, ਨਹੀਂ ਤਾਂ ਨਕਾਰਾਤਮਕ numbers ਨਾਲ ਗਲਤੀ ਹੋਵੇਗੀ।
• ਜਿਸ list 'ਤੇ loop ਚੱਲ ਰਿਹਾ ਹੈ, ਉਸਨੂੰ ਬਦਲਣਾ। Iteration ਦੌਰਾਨ items ਹਟਾਉਣ ਨਾਲ ਕੁਝ elements ਛੱਡੇ ਜਾ ਸਕਦੇ ਹਨ। ਇਸ ਦੀ ਬਜਾਏ ਨਵੀਂ list ਬਣਾਓ।
• Ranges ਵਿੱਚ ਇੱਕ ਦੀ ਗਿਣਤੀ ਅੱਗੇ-ਪਿੱਛੇ ਹੋਣਾ। range(a, b) b ਤੋਂ ਪਹਿਲਾਂ ਰੁਕਦਾ ਹੈ ਅਤੇ slices ਵੀ ਇਸੇ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦੇ ਹਨ। ਛੋਟੀ ਉਦਾਹਰਨ ਨਾਲ ਪਹਿਲਾ ਅਤੇ ਆਖ਼ਰੀ index ਜਾਂਚੋ।
• ਵਾਧੂ output ਛਾਪਣਾ। Coding ਦੇ ਜਵਾਬਾਂ ਦੀ expected output ਨਾਲ ਤੁਲਨਾ ਹੁੰਦੀ ਹੈ, ਇਸ ਲਈ ਵਾਧੂ debug prints ਜਾਂ spaces ਕਾਰਨ ਕੋਈ case ਫੇਲ੍ਹ ਹੋ ਸਕਦਾ ਹੈ।
• ਇੱਕ ਸਮੱਸਿਆ 'ਤੇ ਬਹੁਤ ਜ਼ਿਆਦਾ ਸਮਾਂ ਲਾਉਣਾ। ਪਹਿਲਾਂ ਕੰਮ ਕਰਨ ਵਾਲਾ ਹੱਲ ਜਮ੍ਹਾਂ ਕਰੋ, ਫਿਰ ਸਮਾਂ ਬਚੇ ਤਾਂ ਉਸਨੂੰ ਸੁਧਾਰੋ।