Java કોડિંગ ટેસ્ટ પ્રેક્ટિસ

વાસ્તવિક test સામાન્ય રીતે કેવો હોય છે

Java માટેની કોઈ એક જ કોડિંગ ટેસ્ટ નથી. દરેક નોકરીદાતા ટેસ્ટિંગ પ્લેટફોર્મ પસંદ કરે છે અને પછી પોતાના પ્રશ્નો, કાર્યોની સંખ્યા, સમયમર્યાદા અને મંજૂર પ્રોગ્રામિંગ ભાષાઓ નક્કી કરે છે. તમારી ટેસ્ટનું આમંત્રણ તમને તમારી ટેસ્ટ વિશેની સૌથી સારી માહિતી આપે છે. જાહેરમાં ઉપલબ્ધ ઉદાહરણો આ વિવિધતા દર્શાવે છે:

• HackerRank. HackerRank પોતાની Java (Basic) skills testને 6 questions in 1 hour તરીકે દર્શાવે છે. તેમાં ક્લાસ જેવા વિષયો આવરી લેવાય છે (HackerRank). તેના હેલ્પ સેન્ટરમાં નોકરીદાતા ટેસ્ટમાં કયા પ્રકારના પ્રશ્નો મૂકી શકે તેની યાદી છે. તેમાં કોડિંગ, બહુવિકલ્પી, ડેટાબેઝ, બૅક-એન્ડ ડેવલપર, કોડ રિવ્યૂ અને અભિપ્રાય આધારિત પ્રશ્નોનો સમાવેશ થાય છે. તે જણાવે છે કે નોકરીદાતાઓ HackerRankની લાઇબ્રેરીમાંથી પ્રશ્નો ઉમેરી શકે છે અથવા પોતાના પ્રશ્નો બનાવી શકે છે (HackerRank Help).
• TestGorilla. TestGorillaનું Java coding tests પેજ જણાવે છે કે તેની મોટાભાગની કોડિંગ ટેસ્ટ 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. સૌપ્રથમ તમારું આમંત્રણ વાંચો. તમે કયા પ્લેટફોર્મનો ઉપયોગ કરશો, કેટલાં tasks છે, સમયમર્યાદા કેટલી છે, editorમાં Javaનું કયું version ચાલે છે અને test પર દેખરેખ રાખવામાં આવે છે કે નહીં તે જાણો. ફોર્મેટમાં ઘણો ફેરફાર હોય છે, તેથી કોઈ ધારણા ન રાખો.
2. પ્લેટફોર્મમાં practice area હોય તો અજમાવો. Editor, Run બટન, input કેવી રીતે વાંચવામાં આવે છે અને sample test cases કેવી રીતે દેખાય છે તેની ટેવ પાડો, જેથી testના દિવસે સ્ક્રીન નવી ન લાગે. ઉદાહરણ તરીકે, HackerRank જણાવે છે કે ઉમેદવારો કામ કરતી વખતે test cases ચલાવવા Run પર ક્લિક કરી શકે છે (HackerRank Support).
3. Codeને હાથેથી trace કરો. ટૂંકા snippets માટે દરેક line પછી દરેક variableની value અને type લખો. Integer division, string જોડવી અને referencesમાં જ મોટા ભાગના આશ્ચર્યો છુપાયેલા હોય છે.
4. રોજિંદા ઉપયોગનાં tools જાણો. Arrays, String અને StringBuilder, ArrayList, HashMap, HashSet, Arrays.sort અને Collections.sort, equals અને hashCode, exceptions, તેમજ મૂળભૂત classes અને interfaces.
5. સબમિટ કરતાં પહેલાં edge cases વિશે વિચારો. ખાલી arrays અને strings, એક item, વારંવાર આવતી values, negative numbers, null, અને intની મર્યાદા વટાવી શકે એટલી મોટી values. Hidden test cases ઘણીવાર ખાસ આ જ બાબતો તપાસે છે.
6. સમયમર્યાદામાં code લખવાની પ્રેક્ટિસ કરો. અમારા mocks વાંચન અને debuggingની કુશળતા વિકસાવે છે. સાથે timer લગાવીને વાસ્તવિક editorમાં કેટલીક નાની સમસ્યાઓ ઉકેલો, જેથી દબાણમાં code લખવું, compile કરવું અને ચલાવવું સહજ લાગે.
7. વાસ્તવિક ગતિએ પ્રેક્ટિસ કરો. તમારો test HackerRankના Java (Basic) ઉદાહરણ જેવો હોય, તો 1 કલાકમાં 6 પ્રશ્નો એટલે દરેક પ્રશ્ન માટે લગભગ 10 મિનિટ મળે છે (HackerRank). તમારી ગતિ સંભાળવી સહજ લાગે તે માટે આખા timed mocks આપો.

સામાન્ય રીતે ગુણ કેવી રીતે ગણવામાં આવે છે

સ્કોરિંગ પ્લેટફોર્મ અને નોકરીદાતા પર આધારિત છે. કોઈ સર્વસામાન્ય ધોરણ કે પાસ માર્ક નથી. કોડિંગ પ્રશ્નોનો સ્કોર સામાન્ય રીતે test casesના આધારે આપમેળે ગણવામાં આવે છે. બે જાહેર વર્ણનો:

• HackerRank કહે છે કે કોડિંગ પ્રશ્નોનું મૂલ્યાંકન પૂર્વનિર્ધારિત test cases વડે થાય છે, જે ચોકસાઈ અને કાર્યક્ષમતા ચકાસે છે. દરેક test caseનો પોતાનો સ્કોર હોય છે: test case પાસ કરતો કોડ તે test caseનો સંપૂર્ણ સ્કોર મેળવે છે, અને તેમાં નિષ્ફળ જતો કોડ શૂન્ય મેળવે છે. પ્રશ્નનો કુલ સ્કોર પાસ કરેલા test casesના સ્કોરનો સરવાળો હોય છે. તેથી, કેટલાક test cases પાસ કરતો ઉકેલ આંશિક ગુણ મેળવે છે (HackerRank Support). કોડિંગ અને બહુવિકલ્પી પ્રશ્નોનું મૂલ્યાંકન આપમેળે થાય છે, જ્યારે બૅક-એન્ડ પ્રશ્નોનું મૂલ્યાંકન આપમેળે થાય છે અને હાથેથી સમીક્ષા કરવાની ભલામણ કરવામાં આવે છે (HackerRank Help).
• TestGorilla એકંદર ચોકસાઈ પર આધારિત પર્સન્ટાઇલ સ્કોરિંગનું વર્ણન કરે છે. એટલે કે, આપેલા ઇનપુટથી યોગ્ય આઉટપુટ મળે છે કે નહીં તે જોવામાં આવે છે. તે દરેક test caseનું પરિણામ દર્શાવતો અહેવાલ પણ આપે છે (TestGorilla).

સારો પરિણામ કોને કહેવાય તે દરેક નોકરીદાતા નક્કી કરે છે. ઘણા નોકરીદાતાઓ સ્કોરની સાથે તમારો કોડ પણ જુએ છે.

અમારો અભ્યાસ સ્કોર એ અમારા પોતાના પ્રશ્નોમાંથી તમે સાચા જવાબ આપેલા પ્રશ્નોની સંખ્યા છે. તેમાં વિભાગ પ્રમાણે વિગતો આપવામાં આવે છે, જેથી તમે જાણી શકો કે કયા ભાગ પર ધ્યાન આપવું. આ અભ્યાસ સ્કોર છે: તે કોઈ પ્લેટફોર્મના testનો સ્કોર નથી અને તમે પાસ થશો કે નહીં તેની આગાહી કરતો નથી.

સામાન્ય ભૂલો

• == વડે strings સરખાવવી. equals વાપરો, અથવા value null હોઈ શકે ત્યારે "text".equals(value) વાપરો.
• Integer divisionથી decimal મળવાની અપેક્ષા રાખવી. 7 / 2નું પરિણામ 3 છે. 3.5 જોઈતું હોય, તો પહેલાં એક બાજુ double બનાવો.
• Strings બદલી ન શકાય તેવા છે એ ભૂલી જવું. s.trim() અને s.toUpperCase() નવી strings આપે છે; પરિણામને સોંપો.
• Loopsમાં એકની ભૂલ થવી. Index 0થી length - 1 સુધી ચાલે છે, તેથી સામાન્ય loop શરત i < a.length હોય છે.
• For-each loopની અંદર list બદલવી. removeIf અથવા સ્પષ્ટ Iterator અને તેની remove method વાપરો.
• Overflowની અવગણના કરવી. મોટા int મૂલ્યોના સરવાળા અને ગુણાકાર કોઈ સૂચના વિના ફરી શરૂઆતથી ગણાઈ શકે છે. મૂલ્યો મોટા થઈ શકે, ત્યારે long વાપરો.
• માત્ર ઉદાહરણ ચકાસવું. દેખાતું ઉદાહરણ સામાન્ય રીતે પાસ થાય છે. છુપાયેલા test cases ખાલી input, એક item, ડુપ્લિકેટ્સ અને મોટા input ચકાસે છે.
• એક task પર સમય પૂરો થઈ જવો. અટકી ગયા હો, તો કેટલાક test cases પાસ કરે એવું સરળ version સબમિટ કરો, આગળ વધો અને સમય મળે તો પાછા આવો.