HackerRank-style coding test પ્રેક્ટિસ

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

એક જ HackerRank test નથી. HackerRank એક પ્લેટફોર્મ છે: દરેક નોકરીદાતા પોતાના પ્રશ્નો, મંજૂર ભાષાઓ અને સમયમર્યાદા પસંદ કરીને પોતાનો test બનાવે છે. તમારા test વિશે જાણવા માટે નોકરીદાતા તરફથી મળેલું આમંત્રણ સૌથી શ્રેષ્ઠ માર્ગદર્શન છે.

પ્રશ્નોના પ્રકાર. HackerRank તેના testsમાં coding, database, multiple choice, front-end, back-end, full-stack, code review, subjective અને અન્ય સહિતના અનેક પ્રકારના પ્રશ્નો દર્શાવે છે (HackerRank). મોટાભાગના coding testsમાં આમાંથી કેટલાક પ્રકારો હોય છે:

• Coding પ્રશ્નો: તમે editorમાં solution લખો છો. HackerRank કહે છે કે ઉમેદવારો test cases સામે પોતાનો code ચલાવી શકે છે અને પછી તે દેખાતા sample cases તથા ન દેખાતા છુપાયેલા cases સામે મૂલવાય છે (HackerRank support).
• Database પ્રશ્નો: તમે SQL query લખો છો અને તેનું પરિણામ અપેક્ષિત output સાથે સરખાવવામાં આવે છે (HackerRank support).
• Multiple choice: concepts, complexity અને codeનો કોઈ ભાગ શું કરે છે તે વિશેના પ્રશ્નોનું મૂલ્યાંકન આપમેળે થાય છે (HackerRank).

લંબાઈનાં જાહેર ઉદાહરણો. HackerRankના પોતાના skills testsથી સમયની શ્રેણીનો અંદાજ મળે છે: Python (Basic) testમાં 90 મિનિટમાં 2 પ્રશ્નો દર્શાવ્યા છે (HackerRank) અને SQL (Basic) testમાં 30 મિનિટમાં 2 પ્રશ્નો (HackerRank). નોકરીદાતાનો test ટૂંકો કે લાંબો હોઈ શકે છે અને તેમાં પ્રશ્નો વધુ કે ઓછા હોઈ શકે છે.

Coding testsમાં સામાન્ય રીતે જણાવાતા વિષયો: arrays અને strings, hash maps અને sets, sorting અને searching, time complexity, ખાલી અથવા નકારાત્મક input જેવા edge cases અને મૂળભૂત SQL.

અમારા mocksમાં શું સામેલ છે. દરેક સંપૂર્ણ mockમાં ત્રણ વિભાગમાં 90 મિનિટમાં 14 પ્રશ્નો હોય છે: concepts અને code વાંચવું (10), coding problems (3) અને એક database problem (1). Coding problems માટે તમે Python, JavaScript, Java અથવા C++માં solution લખો અને ચલાવો છો, તથા database problem માટે SQL query લખો છો. દરેકને છુપાયેલા test cases સામે ચકાસવામાં આવે છે અને પાસ કરેલા દરેક case માટે ક્રેડિટ મળે છે. Laptopની ભલામણ કરવામાં આવે છે. તમે પાછા જઈને પ્રશ્નોને flag કરી શકો છો.

અમારા મફત sampleમાં શું અલગ છે. 10 મફત પ્રશ્નો multiple choice છે: coding પ્રશ્નોમાં પૂછવામાં આવે છે કે કયો solution પાસ થશે અથવા કયું input તેને નિષ્ફળ બનાવશે. આ પાસ થતો code લખવા માટેની આવડતો છે. સંપૂર્ણ mocksમાં તમે code લખો અને ચલાવો છો. અમારા છુપાયેલા cases નાના છે અને ચોકસાઈ તથા edge cases ચકાસે છે, તેથી કેટલાક વાસ્તવિક testsની જેમ મોટા inputs પર ધીમા solution માટે સમયમર્યાદા પૂરી થતી નથી; સમજૂતીઓમાં જણાવવામાં આવે છે કે ઝડપ ક્યાં મહત્ત્વની બને છે.

ઉકેલ સાથેના ઉદાહરણો ધરાવતા પ્રશ્નોના પ્રકાર

દરેક પ્રકારના પ્રશ્ન માટે એક ઉદાહરણ, અને મોટા ભાગના લોકો જે ભૂલ કરે છે તેની સમજ.

1. Time complexity. List પરનો loop દર વખતે "x in other_list" ચલાવે છે. બંને listsમાં n items છે. Loop n વખત ચાલે છે અને membershipની દરેક તપાસમાં વધુમાં વધુ n items scan થાય છે, તેથી આખી પ્રક્રિયા O(n squared) છે. other_listને setમાં ફેરવવાથી સરેરાશ દરેક તપાસ O(1) થાય છે અને loop O(n) રહે છે. ધ્યાન રાખો: ફક્ત દેખાતા loopની ગણતરી કરવી. List પરનું "in", list.index અને slicing જેવી built-in પ્રક્રિયાઓ પણ કામ કરે છે.

2. Code વાંચવું. print([x * 2 for x in range(3)]) શું બતાવે છે? range(3) 0, 1 અને 2 આપે છે, તેથી જવાબ [0, 2, 4] છે. ધ્યાન રાખો: 1થી શરૂ કરવું અથવા 3નો સમાવેશ કરવો. range તેની છેલ્લી કિંમત પહેલાં જ અટકે છે.

3. કયું solution સફળ થાય. એક problemમાં વધુમાં વધુ 100,000 items હોઈ શકે છે. O(n squared) solutionને લગભગ 10 billion steps લાગે છે, જે સામાન્ય time limit માટે ખૂબ ધીમું છે. જ્યારે O(n) અથવા O(n log n) સરળતાથી ચાલે છે. ધ્યાન રાખો: ટૂંકું દેખાતું solution પસંદ કરવું. પહેલાં તેની complexity આપેલા size સામે તપાસો.

4. કયો input તેને નિષ્ફળ બનાવે. એક function sum(nums) / len(nums) વડે listની સરેરાશ આપે છે. કયો input તેને નિષ્ફળ બનાવે? ખાલી list, કારણ કે તેમાં શૂન્ય વડે ભાગાકાર થાય છે. ધ્યાન રાખો: ફક્ત સામાન્ય inputથી test કરવો. ખાલી list, એક item, બધા સમાન મૂલ્યો, negative મૂલ્યો અને મંજૂર સૌથી મોટા size સાથે પણ અજમાવો.

5. Database problem. દરેક customerનો કુલ ખર્ચ જોઈએ છે, જેમાં કશું ખર્ચ્યું ન હોય તેવા customers પણ સામેલ હોવા જોઈએ. customers LEFT JOIN orders વાપરો, customer પ્રમાણે group કરીને amountનો સરવાળો કરો, પછી COALESCE વડે NULLને 0માં ફેરવો. ધ્યાન રાખો: inner join વાપરવાથી orders ન ધરાવતા customers જાણ બહાર પરિણામમાંથી નીકળી જાય છે.

તૈયારી કેવી રીતે કરવી

1. સૌપ્રથમ તમારું આમંત્રણ વાંચો. સમયમર્યાદા, પ્રશ્નોની સંખ્યા અને પ્રકાર તથા મંજૂર ભાષાઓ નોંધો. આ બધું નોકરીદાતા નક્કી કરે છે, તેથી ધારણા ન બાંધો.
2. એક ભાષા પસંદ કરો અને તેનો જ ઉપયોગ કરો. Coding પ્રશ્નો માટે તમને સૌથી સારી રીતે આવડતી ભાષા વાપરો. તેમાં રહેલી lists, dictionaries, sets, sorting અને string methods એટલી સારી રીતે જાણો કે શોધવા ન પડે.
3. Inputના કદ પ્રમાણે complexity સમજો. Code લખતાં પહેલાં જણાવેલી મર્યાદાઓ તપાસો. લગભગ 1,000 items સુધી O(n squared) સામાન્ય રીતે યોગ્ય છે; 100,000 કે તેથી વધુ હોય ત્યારે O(n) અથવા O(n log n)નો લક્ષ્ય રાખો.
4. Edge casesનો ઇરાદાપૂર્વક અભ્યાસ કરો. Empty input, એક item, duplicates, negative values, બહુ મોટી values અને મહત્તમ કદ અજમાવો. Coding પ્રશ્નોનું મૂલ્યાંકન છુપાયેલા test casesના આધારે થાય છે (HackerRank support), અને તેમાંના મોટા ભાગના આ પ્રકારના cases હોય છે.
5. Sample cases ચલાવો, પછી તમારા cases test કરો. દેખાતા samples પાસ કરવું શરૂઆત છે, અંત નહીં. Submit કરતાં પહેલાં તમારા થોડા cases ઉમેરો.
6. મૂળભૂત SQL ફરીથી યાદ કરો. Joins, GROUP BY, HAVING, NULLs અને sorting મોટાભાગના database પ્રશ્નો માટે ઉપયોગી છે. પરિણામને row પ્રમાણે તપાસો, કારણ કે databaseના જવાબો અપેક્ષિત output સાથે સરખાવવામાં આવે છે (HackerRank support).
7. સમયમર્યાદામાં સંપૂર્ણ solutions લખો. અમારા સંપૂર્ણ mocksમાં તમે code લખો અને છુપાયેલા cases સામે ચલાવો છો. તમારા પોતાના problems સાથે પણ આવું કરો, જેથી સમયમર્યાદામાં સંપૂર્ણ solution લખવું સામાન્ય લાગે.
8. વાસ્તવિક ગતિએ અભ્યાસ કરો. સંપૂર્ણ timed mocks આપો, જેથી testના દિવસે 90 મિનિટ સુધી ધ્યાનપૂર્વક કામ કરવું સામાન્ય લાગે.

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

સ્કોરિંગ દરેક એમ્પ્લોયર નક્કી કરે છે. HackerRank સમજાવે છે કે તેના વિવિધ પ્રકારના પ્રશ્નોનું સ્કોરિંગ કેવી રીતે થાય છે, અને કયો પરિણામ પૂરતો સારો છે તે દરેક એમ્પ્લોયર નક્કી કરે છે. પાસ થવા માટેનો કોઈ એક સર્વમાન્ય ગુણાંક નથી.

• કોડિંગ પ્રશ્નો: HackerRank કહે છે કે સિસ્ટમ તમારા કોડને દરેક ટેસ્ટ કેસ સામે ચલાવે છે અને દરેક આઉટપુટની અપેક્ષિત આઉટપુટ સાથે સરખામણી કરે છે. દરેક ટેસ્ટ કેસ માટે નક્કી કરેલો સ્કોર હોય છે: પાસ થવા પર આખા ગુણ મળે છે અને નિષ્ફળ જવા પર કોઈ ગુણ મળતા નથી. ટેસ્ટ કેસ માટે આંશિક સ્કોરિંગ થતું નથી. પ્રશ્નનો તમારો સ્કોર એટલે તમે પાસ કરેલા ટેસ્ટ કેસના કુલ ગુણ. તમને દેખાતા નમૂના કેસ માટે 0 ગુણ હોઈ શકે છે, જ્યારે છુપાયેલા કેસ માટે ગુણ હોય છે (HackerRank support).
• ડેટાબેઝ પ્રશ્નો: તમારી ક્વેરીના પરિણામની અપેક્ષિત આઉટપુટ સાથે સરખામણી થાય છે: પરિણામ મેળ ખાતું હોય તો આખો સ્કોર મળે છે અને અન્યથા શૂન્ય મળે છે. જોકે, એમ્પ્લોયર જાતે તપાસીને આંશિક ગુણ આપે તો અલગ વાત છે (HackerRank support).
• બહુવિકલ્પી પ્રશ્નો: સ્કોરિંગ આપમેળે થાય છે (HackerRank).

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

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

સામાન્ય ભૂલો

• Samples પાસ થાય એટલે અટકી જવું. દેખાતા samples તમામ casesનો નાનો ભાગ છે. ખાલી input, એક item, નેગેટિવ મૂલ્યો અને સૌથી મોટું કદ જાતે ચકાસો.
• Inputની મર્યાદાઓ અવગણવી. સાચો પણ ધીમો ઉકેલ મોટા છુપાયેલા casesમાં નિષ્ફળ થઈ શકે છે. રીત પસંદ કરતાં પહેલાં મર્યાદાઓ વાંચો.
• મહત્તમ મૂલ્ય 0થી શરૂ કરવું. પહેલા itemથી શરૂ કરો, નહીં તો નેગેટિવ સંખ્યાઓમાં ભૂલ થશે.
• જે list પર loop ચલાવો છો તેને જ બદલવી. Iterate કરતાં items કાઢવાથી કેટલાક elements છૂટી જાય છે. તેના બદલે નવી list બનાવો.
• Rangesમાં એકની ભૂલ. range(a, b) b પહેલાં અટકે છે અને slices પણ એ જ રીતે કામ કરે છે. નાના ઉદાહરણમાં પહેલો અને છેલ્લો index તપાસો.
• વધારાનું output છાપવું. Codingના જવાબોની અપેક્ષિત output સાથે સરખામણી થાય છે, તેથી વધારાના debug prints અથવા spacesને કારણે case નિષ્ફળ થઈ શકે છે.
• એક problem પર વધુ પડતો સમય આપવો. પહેલાં ચાલે એવો ઉકેલ સબમિટ કરો, પછી સમય બચે તો તેને સુધારો.