Python કોડિંગ testની પ્રેક્ટિસ

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

એક જ Python coding test નથી. દરેક નોકરીદાતા testing platform પસંદ કરે છે અને પછી પોતાના પ્રશ્નો, કાર્યોની સંખ્યા, સમયમર્યાદા અને મંજૂર ભાષાઓ નક્કી કરે છે. તમને મળેલું test invitation તમારા test વિશેની શ્રેષ્ઠ માહિતી આપે છે. જાહેરમાં ઉપલબ્ધ ઉદાહરણો વિવિધતા દર્શાવે છે:

• HackerRank. HackerRank તેના Python (Basic) skills testમાં 1 કલાક 30 મિનિટમાં 2 પ્રશ્નો હોવાનું જણાવે છે. તેમાં scalar types જેવા વિષયો આવરી લેવાય છે (HackerRank). તેના help centerમાં નોકરીદાતા testમાં મૂકી શકે એવા પ્રશ્નોના પ્રકારોની યાદી છે, જેમાં coding, multiple choice, database, code review અને subjective questionsનો સમાવેશ થાય છે. તેમાં એમ પણ જણાવાયું છે કે નોકરીદાતાઓ HackerRankની libraryમાંથી પ્રશ્નો ઉમેરી શકે છે અથવા પોતાના પ્રશ્નો બનાવી શકે છે (HackerRank Help).
• TestGorilla. TestGorillaના Python coding tests પેજ મુજબ, તેના મોટાભાગના વ્યક્તિગત coding tests 15થી 35 મિનિટના હોય છે. તેમાં entry-level algorithms test 15 મિનિટનો દર્શાવાયો છે. ઉમેદવારો Pythonમાં અથવા નોકરીદાતા મંજૂરી આપે તેવી બીજી ભાષાઓમાં સમસ્યાઓ ઉકેલી શકે છે (TestGorilla).

નોકરીદાતાઓના Python testsમાં સામાન્ય રીતે જોવા મળતા ભાગો:

• Coding tasks: online editorમાં function લખો, તેને sample inputs સામે ચલાવો અને પછી એવા વધુ test cases સામે તપાસવા માટે submit કરો જે કદાચ તમને દેખાય નહીં.
• Multiple choice: Pythonના ખ્યાલો, code snippet ચલાવતાં શું output આવે છે અને કયો code સાચો છે તે અંગેના પ્રશ્નો.
• Debugging અથવા code review: બીજા કોઈએ લખેલા codeમાં સમસ્યા શોધીને તેને સુધારો.
• ક્યારેક વધુ પણ: SQLનો પ્રશ્ન, મોટું project task, take-home assignment અથવા test દરમિયાન webcam અને screen monitoring.

અમારા mocksમાં શું આવરી લેવાય છે. અમારા સંપૂર્ણ mocksમાં ચાર વિભાગોમાં 60 મિનિટમાં 20 પ્રશ્નો હોય છે: Pythonના ખ્યાલો (6), codeનું output શું આવે છે (6), bug શોધવો (5) અને solution બનાવવું (3). બધો code Python 3માં છે. Submit કરો ત્યાં સુધી તમે પાછા જઈ શકો છો, જવાબ બદલી શકો છો અને પ્રશ્નોને flag કરી શકો છો. અમારા mocksમાં code વાંચવાની, તેનું પગલું-દર-પગલું અનુસરણ કરવાની, debugging કરવાની અને code પસંદ કરવાની પ્રેક્ટિસ થાય છે. તમે લખેલો code તે ચલાવતા નથી. ઘણા વાસ્તવિક assessmentsમાં તમને એવો code લખવાનું કહેવામાં આવે છે જે છુપાયેલા test cases સામે ચાલે. આ પ્રેક્ટિસ તે માટે જરૂરી વાંચન, codeનું પગલું-દર-પગલું અનુસરણ અને debuggingની કુશળતા વિકસાવે છે. તેથી વાસ્તવિક editorમાં સમયમર્યાદા સાથે પણ પ્રેક્ટિસ કરો. અમારા mocksમાં proctoring, plagiarism checks, video interviews, take-home અને project tasks, તેમજ નોકરીદાતાનો pass mark સામેલ નથી.

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

દરેક વિભાગ માટે એક ઉકેલ સાથેનું ઉદાહરણ, જેમાં લોકો સામાન્ય રીતે જે ભૂલ કરે છે તે પણ બતાવી છે.

1. Pythonના ખ્યાલો. a == b અને a is b વચ્ચે શું તફાવત છે? પહેલું પૂછે છે કે બે મૂલ્યો સરખાં છે કે નહીં; બીજું પૂછે છે કે બંને એક જ ઑબ્જેક્ટ છે કે નહીં. અલગ-અલગ [1, 2] લિસ્ટનાં મૂલ્યો સરખાં છે, પણ તે એક જ ઑબ્જેક્ટ નથી. ધ્યાન રાખો: સંખ્યાઓ કે સ્ટ્રિંગની સરખામણી માટે is વાપરવું. નાનાં મૂલ્યો માટે તે કામ કરતું લાગે, પણ પછી નિષ્ફળ થઈ શકે છે.

2. કોડ શું પ્રિન્ટ કરે છે. પહેલાં x = [0] * 3, પછી x[1] = 5 અને print(x). પગલાં અનુસરો: [0, 0, 0] બદલાઈને [0, 5, 0] થાય છે. હવે grid = [[0] * 2] * 2 અને પછી grid[0][0] = 1 અજમાવો. તે [[1, 0], [1, 0]] પ્રિન્ટ કરે છે, કારણ કે બંને પંક્તિઓ એક જ અંદરની લિસ્ટ છે. ધ્યાન રાખો: Python કોડ ચલાવે છે તે રીતે વાંચવાને બદલે, કોડ તમારી ધારણા મુજબ ચાલશે એમ માનીને વાંચવો. દરેક લાઇન પછી દરેક વેરિએબલનું મૂલ્ય લખો.

3. બગ શોધવો. for i in range(len(items) - 1): લૂપનો હેતુ દરેક આઇટમ પ્રિન્ટ કરવાનો છે, પણ તે છેલ્લી આઇટમ છોડી દે છે. બગ - 1 છે: range(len(items)) પહેલેથી જ લંબાઈ સુધી પહોંચે તે પહેલાં અટકી જાય છે. ધ્યાન રાખો: ખોટું પરિણામ આપતી લાઇનને બદલે ક્રેશ થતી કે વિચિત્ર લાગતી લાઇન સુધારવી. મનમાં નાનું ઇનપુટ લઈને કોડ ચકાસો, જેમ કે બે આઇટમની લિસ્ટ.

4. ઉકેલ તૈયાર કરવો. લિસ્ટમાં દરેક શબ્દ કેટલી વાર આવે છે તેની ગણતરી કરવી છે. collections.Counter(words) આ કામ એક જ પગલામાં કરે છે; અથવા લૂપમાં counts[w] = counts.get(w, 0) + 1 ધરાવતી ડિક્શનરી વડે ગણતરી જાતે કરી શકાય છે. ધ્યાન રાખો: સામાન્ય સ્થિતિમાં કામ કરે, પણ ખાસ કિસ્સાઓમાં નહીં, એવો વિકલ્પ પસંદ કરવો. દરેક વિકલ્પને ખાલી લિસ્ટ, એક આઇટમ, પુનરાવર્તિત આઇટમ અને નકારાત્મક સંખ્યાઓ સાથે ચકાસો.

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

1. સૌપ્રથમ તમારું આમંત્રણ વાંચો. તમે કયા પ્લેટફોર્મનો ઉપયોગ કરશો, કેટલાં tasks છે, સમયમર્યાદા કેટલી છે, તમે Python 3 પસંદ કરી શકો છો કે નહીં અને test પર દેખરેખ રાખવામાં આવે છે કે નહીં તે જાણો. ફોર્મેટમાં ઘણો ફેરફાર હોય છે, તેથી કોઈ ધારણા ન રાખો.
2. પ્લેટફોર્મમાં practice area હોય તો અજમાવો. Editor, Run બટન અને sample test cases કેવી રીતે દેખાય છે તેની ટેવ પાડો, જેથી testના દિવસે સ્ક્રીન નવી ન લાગે. ઉદાહરણ તરીકે, HackerRank જણાવે છે કે ઉમેદવારો કામ કરતી વખતે test cases ચલાવવા Run પર ક્લિક કરી શકે છે (HackerRank Support).
3. Codeને હાથેથી trace કરો. ટૂંકા snippets માટે દરેક line પછી દરેક variableની value લખો. Output અને debuggingના પ્રશ્નો માટે આ પાયાની કુશળતા છે, અને code ચલાવ્યા વિના પોતાનો code તપાસવાની આ રીત છે.
4. રોજિંદા ઉપયોગનાં tools જાણો. Lists, dictionaries, sets, strings, slicing, sorted અને list.sort વચ્ચેનો તફાવત, enumerate, zip, list અને dictionary comprehensions, તથા collections.Counter.
5. સબમિટ કરતાં પહેલાં edge cases વિશે વિચારો. ખાલી input, એક item, વારંવાર આવતી values, negative numbers અને ખૂબ મોટા inputs. Hidden test cases ઘણીવાર ખાસ આ જ બાબતો તપાસે છે.
6. સમયમર્યાદામાં code લખવાની પ્રેક્ટિસ કરો. અમારા mocks વાંચન અને debuggingની કુશળતા વિકસાવે છે. સાથે timer લગાવીને વાસ્તવિક editorમાં કેટલીક નાની સમસ્યાઓ ઉકેલો, જેથી દબાણમાં code લખવું અને ચલાવવું સહજ લાગે.
7. વાસ્તવિક ગતિએ પ્રેક્ટિસ કરો. તમારો test HackerRankના Python (Basic) ઉદાહરણ જેવો હોય, તો 1 કલાક 30 મિનિટમાં 2 પ્રશ્નો એટલે દરેક સમસ્યા માટે લગભગ 45 મિનિટ મળે છે (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નો સ્કોર નથી અને તમે પાસ થશો કે નહીં તેની આગાહી કરતો નથી.

સામાન્ય ભૂલો

• List બદલતી methods અને નવી list આપતાં functionsને ગૂંચવવી. list.sort() અને list.append() None આપે છે; sorted() નવી list આપે છે.
• Assignmentથી objects વહેંચાય છે એ ભૂલી જવું. b = a list કે dictionaryની copy કરતું નથી. Copy જોઈતી હોય, ત્યારે a[:], list(a) અથવા copy.deepcopy(a) વાપરો.
• Ranges અને slicesમાં એકની ભૂલ થવી. range(n) n પહેલાં અટકે છે અને s[1:3] ત્રણ નહીં, બે items લે છે.
• મનસ્વી મૂલ્યથી શોધ શરૂ કરવી. મહત્તમ મૂલ્ય 0થી અથવા લઘુત્તમ મૂલ્ય 1000થી શરૂ કરવાથી અસામાન્ય inputમાં ભૂલ થાય છે. પહેલા itemથી અથવા float("-inf")થી શરૂ કરો.
• માત્ર ઉદાહરણ ચકાસવું. દેખાતું ઉદાહરણ સામાન્ય રીતે પાસ થાય છે. છુપાયેલા test cases ખાલી input, એક item, ડુપ્લિકેટ્સ અને મોટા input ચકાસે છે.
• એક task પર સમય પૂરો થઈ જવો. અટકી ગયા હો, તો કેટલાક test cases પાસ કરે એવું સરળ version સબમિટ કરો, આગળ વધો અને સમય મળે તો પાછા આવો.