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

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

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

• HackerRank. HackerRank ਆਪਣੇ Java (Basic) ਹੁਨਰ ਟੈਸਟ ਵਿੱਚ 6 questions in 1 hour ਦੱਸਦਾ ਹੈ। ਇਸ ਵਿੱਚ ਕਲਾਸਾਂ ਵਰਗੇ ਵਿਸ਼ੇ ਸ਼ਾਮਲ ਹਨ (HackerRank)। ਇਸ ਦਾ ਮਦਦ ਕੇਂਦਰ ਉਨ੍ਹਾਂ ਸਵਾਲਾਂ ਦੀਆਂ ਕਿਸਮਾਂ ਦੱਸਦਾ ਹੈ ਜੋ ਰੁਜ਼ਗਾਰਦਾਤਾ ਟੈਸਟ ਵਿੱਚ ਰੱਖ ਸਕਦੇ ਹਨ, ਜਿਵੇਂ ਕੋਡਿੰਗ, ਬਹੁ-ਵਿਕਲਪੀ, ਡੇਟਾਬੇਸ, ਬੈਕ-ਐਂਡ ਡਿਵੈਲਪਰ, ਕੋਡ ਸਮੀਖਿਆ ਅਤੇ ਵਿਚਾਰ-ਆਧਾਰਿਤ ਸਵਾਲ। ਇਸ ਮੁਤਾਬਕ, ਰੁਜ਼ਗਾਰਦਾਤਾ HackerRank ਦੀ ਲਾਇਬ੍ਰੇਰੀ ਤੋਂ ਸਵਾਲ ਜੋੜ ਸਕਦੇ ਹਨ ਜਾਂ ਆਪਣੇ ਸਵਾਲ ਲਿਖ ਸਕਦੇ ਹਨ (HackerRank Help)।
• TestGorilla. TestGorilla ਦੇ Java ਕੋਡਿੰਗ ਟੈਸਟਾਂ ਵਾਲੇ ਪੰਨੇ ਅਨੁਸਾਰ, ਇਸ ਦੇ ਜ਼ਿਆਦਾਤਰ ਕੋਡਿੰਗ ਟੈਸਟ 15 ਤੋਂ 35 ਮਿੰਟਾਂ ਦੇ ਹੁੰਦੇ ਹਨ। ਇਸ ਵਿੱਚ ਸ਼ੁਰੂਆਤੀ ਪੱਧਰ ਦਾ ਐਲਗੋਰਿਦਮ ਟੈਸਟ 15 ਮਿੰਟ ਦਾ ਦਿੱਤਾ ਗਿਆ ਹੈ। ਪੰਨੇ ਮੁਤਾਬਕ, ਉਮੀਦਵਾਰ ਸਮੱਸਿਆ ਪੜ੍ਹਦੇ ਹਨ, ਭਾਸ਼ਾ ਮੀਨੂ ਵਿੱਚੋਂ Java ਚੁਣਦੇ ਹਨ ਅਤੇ ਆਨਲਾਈਨ ਐਡੀਟਰ ਵਿੱਚ ਆਪਣਾ ਹੱਲ ਲਿਖਦੇ ਹਨ (TestGorilla)।

ਰੁਜ਼ਗਾਰਦਾਤਾਵਾਂ ਦੇ Java ਟੈਸਟਾਂ ਵਿੱਚ ਆਮ ਤੌਰ 'ਤੇ ਦੱਸੇ ਜਾਂਦੇ ਹਿੱਸੇ:

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

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

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

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

1. Java ਦੇ ਸੰਕਲਪ। int ਅਤੇ Integer ਵਿੱਚ ਕੀ ਫ਼ਰਕ ਹੈ? int ਇੱਕ ਮੁੱਢਲਾ ਮੁੱਲ ਹੈ; Integer ਇੱਕ ਆਬਜੈਕਟ ਹੈ ਜੋ ਇਸ ਮੁੱਲ ਨੂੰ ਆਪਣੇ ਅੰਦਰ ਰੱਖਦਾ ਹੈ ਅਤੇ null ਵੀ ਹੋ ਸਕਦਾ ਹੈ। List ਵਰਗੇ ਕਲੈਕਸ਼ਨ Integer ਰੱਖਦੇ ਹਨ, ਅਤੇ Java ਆਪਣੇ ਆਪ ਦੋਵਾਂ ਵਿਚਕਾਰ ਰੂਪਾਂਤਰ ਕਰਦਾ ਹੈ। ਆਮ ਗਲਤੀ: ਦੋ Integer ਆਬਜੈਕਟਾਂ ਦੀ ਤੁਲਨਾ == ਨਾਲ ਕਰਨੀ। ਇਹ ਰੈਫ਼ਰੈਂਸਾਂ ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ ਅਤੇ ਬਰਾਬਰ ਮੁੱਲਾਂ ਲਈ ਵੀ ਨਤੀਜਾ false ਹੋ ਸਕਦਾ ਹੈ; equals ਵਰਤੋ।

2. ਕੋਡ ਕੀ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ। System.out.println(1 + 2 + "3" + 4 + 5); 3345 ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ। Java ਖੱਬੇ ਤੋਂ ਸੱਜੇ ਕੰਮ ਕਰਦਾ ਹੈ: 1 + 2 ਦਾ ਨਤੀਜਾ 3 ਹੁੰਦਾ ਹੈ, ਫਿਰ "3" ਜੋੜਨ ਨਾਲ ਸਤਰ "33" ਬਣਦੀ ਹੈ, ਅਤੇ ਉਸ ਤੋਂ ਬਾਅਦ ਹਰ + ਟੈਕਸਟ ਨੂੰ ਜੋੜਦਾ ਹੈ। ਆਮ ਗਲਤੀ: ਪਹਿਲਾਂ ਸਾਰੀ ਗਣਿਤ ਕਰ ਲੈਣਾ। ਇੱਕ ਵਾਰ ਵਿੱਚ ਇੱਕ ਆਪਰੇਟਰ ਨੂੰ ਵੇਖੋ ਅਤੇ ਹਰ ਕਦਮ ਤੋਂ ਬਾਅਦ ਕਿਸਮ ਨੋਟ ਕਰੋ।

3. ਬੱਗ ਲੱਭਣਾ। ਇੱਕ ਮੈਥਡ ਵਿੱਚ if (status == "done") ਹੈ ਅਤੇ ਇਹ ਕਦੇ ਵੀ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ, ਭਾਵੇਂ status "done" ਹੀ ਕਿਉਂ ਨਾ ਹੋਵੇ। ਇਸ ਦਾ ਹੱਲ "done".equals(status) ਹੈ, ਜੋ ਅੱਖਰਾਂ ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ ਅਤੇ null status ਨੂੰ ਵੀ ਸੰਭਾਲਦਾ ਹੈ। ਆਮ ਗਲਤੀ: ਪਹਿਲੀ ਅਜੀਬ ਲੱਗਦੀ ਲਾਈਨ ਨੂੰ ਠੀਕ ਕਰਨਾ। ਕੋਡ ਵਿੱਚੋਂ ਇੱਕ ਛੋਟਾ ਜਿਹਾ ਇਨਪੁੱਟ ਲੰਘਾ ਕੇ ਵੇਖੋ ਅਤੇ ਉਹ ਪਹਿਲੀ ਲਾਈਨ ਲੱਭੋ ਜਿੱਥੇ ਮੁੱਲ ਗਲਤ ਹੋ ਜਾਂਦਾ ਹੈ।

4. ਹੱਲ ਤਿਆਰ ਕਰਨਾ। ਤੁਹਾਨੂੰ ਗਿਣਨਾ ਹੈ ਕਿ ਹਰ ਸ਼ਬਦ ਕਿੰਨੀ ਵਾਰ ਆਉਂਦਾ ਹੈ। ਲੂਪ ਵਿੱਚ counts.merge(word, 1, Integer::sum) ਵਾਲਾ HashMap ਹਰ ਸ਼ਬਦ ਲਈ ਇੱਕ ਲਾਈਨ ਵਿੱਚ ਇਹ ਕੰਮ ਕਰਦਾ ਹੈ। ਆਮ ਗਲਤੀ: ਉਹ ਵਿਕਲਪ ਚੁਣਨਾ ਜੋ ਆਮ ਹਾਲਾਤ ਵਿੱਚ ਤਾਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਪਰ ਸੀਮਾਵੀ ਹਾਲਾਤਾਂ ਵਿੱਚ ਨਹੀਂ। ਹਰ ਵਿਕਲਪ ਨੂੰ ਖਾਲੀ ਐਰੇ, ਇੱਕ ਆਈਟਮ, ਦੁਹਰਾਏ ਮੁੱਲਾਂ, ਨਕਾਰਾਤਮਕ ਨੰਬਰਾਂ ਅਤੇ null ਨਾਲ ਜਾਂਚੋ।

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

1. ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਆਪਣਾ ਸੱਦਾ ਪੜ੍ਹੋ। ਪਤਾ ਕਰੋ ਕਿ ਤੁਸੀਂ ਕਿਹੜਾ ਪਲੇਟਫਾਰਮ ਵਰਤੋਗੇ, ਕਿੰਨੇ ਕੰਮ ਹਨ, ਸਮਾਂ ਸੀਮਾ ਕੀ ਹੈ, editor ਵਿੱਚ Java ਦਾ ਕਿਹੜਾ version ਚੱਲਦਾ ਹੈ, ਅਤੇ ਕੀ ਟੈਸਟ ਦੀ ਨਿਗਰਾਨੀ ਕੀਤੀ ਜਾਵੇਗੀ। ਫਾਰਮੈਟਾਂ ਵਿੱਚ ਇੰਨਾ ਫ਼ਰਕ ਹੁੰਦਾ ਹੈ ਕਿ ਪਹਿਲਾਂ ਤੋਂ ਅੰਦਾਜ਼ਾ ਨਹੀਂ ਲਗਾਇਆ ਜਾ ਸਕਦਾ।
2. ਜੇ ਪਲੇਟਫਾਰਮ 'ਤੇ ਅਭਿਆਸ ਵਾਲਾ ਹਿੱਸਾ ਹੈ, ਤਾਂ ਉਸਨੂੰ ਅਜ਼ਮਾਓ। Editor, Run ਬਟਨ, input ਪੜ੍ਹਨ ਦੇ ਤਰੀਕੇ ਅਤੇ ਨਮੂਨਾ test cases ਦਿਖਾਉਣ ਦੇ ਢੰਗ ਨਾਲ ਜਾਣੂ ਹੋ ਜਾਓ, ਤਾਂ ਜੋ ਟੈਸਟ ਵਾਲੇ ਦਿਨ ਸਕ੍ਰੀਨ ਨਵੀਂ ਨਾ ਲੱਗੇ। ਮਿਸਾਲ ਵਜੋਂ, HackerRank ਦੱਸਦਾ ਹੈ ਕਿ ਉਮੀਦਵਾਰ ਕੰਮ ਕਰਦੇ ਸਮੇਂ test cases ਚਲਾਉਣ ਲਈ Run 'ਤੇ ਕਲਿੱਕ ਕਰਦੇ ਹਨ (HackerRank Support).
3. ਕੋਡ ਨੂੰ ਹੱਥ ਨਾਲ ਸਮਝੋ। ਛੋਟੇ code snippets ਲਈ ਹਰ ਲਾਈਨ ਤੋਂ ਬਾਅਦ ਹਰ variable ਦੀ value ਅਤੇ type ਲਿਖੋ। Integer division, strings ਨੂੰ ਜੋੜਨਾ ਅਤੇ references ਵਿੱਚ ਅਕਸਰ ਅਣਉਮੀਦ ਨਤੀਜੇ ਸਾਹਮਣੇ ਆਉਂਦੇ ਹਨ।
4. ਰੋਜ਼ਮਰ੍ਹਾ ਦੇ tools ਜਾਣੋ। Arrays, String ਅਤੇ StringBuilder, ArrayList, HashMap, HashSet, Arrays.sort ਅਤੇ Collections.sort, equals ਅਤੇ hashCode, exceptions, ਅਤੇ ਬੁਨਿਆਦੀ classes ਤੇ interfaces।
5. ਜਵਾਬ ਜਮ੍ਹਾਂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਖ਼ਾਸ ਹਾਲਾਤਾਂ ਬਾਰੇ ਸੋਚੋ। ਖਾਲੀ arrays ਅਤੇ strings, ਇੱਕ item, ਦੁਹਰਾਈਆਂ values, ਨੈਗੇਟਿਵ ਨੰਬਰ, null, ਅਤੇ ਇੰਨੇ ਵੱਡੇ values ਜੋ int ਦੀ ਸੀਮਾ ਤੋਂ ਵੱਧ ਸਕਦੇ ਹਨ। ਲੁਕੇ ਹੋਏ test cases ਅਕਸਰ ਇਨ੍ਹਾਂ ਦੀ ਹੀ ਜਾਂਚ ਕਰਦੇ ਹਨ।
6. ਸਮੇਂ ਦੀ ਪਾਬੰਦੀ ਹੇਠ ਕੁਝ ਕੋਡ ਲਿਖੋ। ਸਾਡੇ mock tests ਪੜ੍ਹਨ ਅਤੇ debugging ਦਾ ਅਭਿਆਸ ਕਰਵਾਉਂਦੇ ਹਨ। ਨਾਲ ਹੀ timer ਲਗਾ ਕੇ ਅਸਲ editor ਵਿੱਚ ਕੁਝ ਛੋਟੀਆਂ ਸਮੱਸਿਆਵਾਂ ਹੱਲ ਕਰੋ, ਤਾਂ ਜੋ ਦਬਾਅ ਹੇਠ ਕੋਡ ਲਿਖਣਾ, compile ਕਰਨਾ ਅਤੇ ਚਲਾਉਣਾ ਆਮ ਲੱਗੇ।
7. ਅਸਲ ਰਫ਼ਤਾਰ ਨਾਲ ਅਭਿਆਸ ਕਰੋ। ਜੇ ਤੁਹਾਡਾ ਟੈਸਟ HackerRank ਦੇ Java (Basic) ਉਦਾਹਰਨ ਵਰਗਾ ਹੈ, ਤਾਂ 1 ਘੰਟੇ ਵਿੱਚ 6 ਸਵਾਲਾਂ ਲਈ ਹਰ ਸਵਾਲ 'ਤੇ ਲਗਭਗ 10 ਮਿੰਟ ਮਿਲਦੇ ਹਨ (HackerRank). ਪੂਰੇ ਸਮੇਂ-ਬੱਧ mock tests ਦਿਓ, ਤਾਂ ਜੋ ਆਪਣੀ ਰਫ਼ਤਾਰ ਸੰਭਾਲਣਾ ਆਮ ਲੱਗੇ।

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

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

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

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

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

ਆਮ ਗਲਤੀਆਂ

• == ਨਾਲ strings ਦੀ ਤੁਲਨਾ ਕਰਨਾ। equals ਵਰਤੋ। ਜੇ ਮੁੱਲ null ਹੋ ਸਕਦਾ ਹੈ, ਤਾਂ "text".equals(value) ਵਰਤੋ।
• Integer division ਤੋਂ ਦਸ਼ਮਲਵ ਦੀ ਉਮੀਦ ਕਰਨਾ। 7 / 2 ਦਾ ਨਤੀਜਾ 3 ਹੁੰਦਾ ਹੈ। ਜੇ 3.5 ਚਾਹੀਦਾ ਹੈ, ਤਾਂ ਪਹਿਲਾਂ ਕਿਸੇ ਇੱਕ ਪਾਸੇ ਨੂੰ double ਬਣਾਓ।
• ਇਹ ਭੁੱਲ ਜਾਣਾ ਕਿ strings ਬਦਲੀਆਂ ਨਹੀਂ ਜਾ ਸਕਦੀਆਂ। s.trim() ਅਤੇ s.toUpperCase() ਨਵੀਆਂ strings ਦਿੰਦੇ ਹਨ; ਨਤੀਜਾ ਕਿਸੇ variable ਵਿੱਚ ਸੰਭਾਲੋ।
• Loops ਵਿੱਚ ਇੱਕ ਦੀ ਗਿਣਤੀ ਅੱਗੇ-ਪਿੱਛੇ ਹੋ ਜਾਣਾ। Index 0 ਤੋਂ length - 1 ਤੱਕ ਹੁੰਦੇ ਹਨ, ਇਸ ਲਈ ਆਮ loop ਸ਼ਰਤ i < a.length ਹੁੰਦੀ ਹੈ।
• For-each loop ਦੇ ਅੰਦਰ list ਬਦਲਣਾ। removeIf ਜਾਂ ਸਪਸ਼ਟ Iterator ਅਤੇ ਉਸਦਾ remove method ਵਰਤੋ।
• Overflow ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਨਾ। ਵੱਡੀਆਂ int values ਦੇ ਜੋੜ ਅਤੇ ਗੁਣਾ ਚੁੱਪਚਾਪ ਗਲਤ ਨਤੀਜੇ ਦੇ ਸਕਦੇ ਹਨ। ਜਦੋਂ ਮੁੱਲ ਵੱਡੇ ਹੋ ਸਕਦੇ ਹੋਣ, ਤਾਂ long ਵਰਤੋ।
• ਸਿਰਫ਼ ਉਦਾਹਰਨ ਦੀ ਜਾਂਚ ਕਰਨਾ। ਦਿਖਾਈ ਗਈ ਉਦਾਹਰਨ ਆਮ ਤੌਰ 'ਤੇ ਪਾਸ ਹੋ ਜਾਂਦੀ ਹੈ। ਲੁਕੇ ਹੋਏ ਟੈਸਟਾਂ ਵਿੱਚ ਖਾਲੀ input, ਇੱਕ item, ਦੁਹਰਾਏ ਹੋਏ ਮੁੱਲ ਅਤੇ ਵੱਡੇ input ਜਾਂਚੇ ਜਾਂਦੇ ਹਨ।
• ਇੱਕ ਕੰਮ 'ਤੇ ਸਮਾਂ ਮੁੱਕ ਜਾਣਾ। ਜੇ ਤੁਸੀਂ ਫਸ ਜਾਓ, ਤਾਂ ਅਜਿਹਾ ਸੌਖਾ ਹੱਲ ਜਮ੍ਹਾਂ ਕਰੋ ਜੋ ਕੁਝ ਟੈਸਟ ਪਾਸ ਕਰੇ, ਅਗਲੇ ਕੰਮ 'ਤੇ ਜਾਓ ਅਤੇ ਸਮਾਂ ਬਚੇ ਤਾਂ ਮੁੜ ਆਓ।