Codility-શૈલીની કોડિંગ ટેસ્ટ પ્રેક્ટિસ

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

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

Codility શું જણાવે છે. Codility કહે છે કે દરેક taskનું મૂલ્યાંકન નિશ્ચિત માપદંડો અનુસાર આપમેળે થાય છે (Codility). પ્રોગ્રામર્સ માટેના તેના મફત પાઠ (Codility) taskની શૈલી બતાવે છે: એક ટૂંકી સમસ્યા, લખવાનું function અને જણાવેલી input મર્યાદાઓ. ઉદાહરણ તરીકે, તેના BinaryGap પાઠમાં 2,147,483,647 સુધીના inputs માટે "કાર્યક્ષમ algorithm" લખવાનું કહેવામાં આવે છે (Codility). એક પાઠનું શીર્ષક Time Complexity છે (Codility).

Codility tests વિશે સામાન્ય રીતે જણાવાતી બાબતો (ઉમેદવારો અને માર્ગદર્શિકાઓના આધારે; અમે ખોલી શક્યા એવી Codility પેજ પર આની પુષ્ટિ થઈ નથી):

• એક જ timer હેઠળ થોડા tasks: આખા test માટે સામાન્ય રીતે 30 મિનિટથી 2 કલાકનો સમય હોય છે.
• છુપાયેલા ચોકસાઈ tests: taskમાં આપેલા ઉદાહરણ ઉપરાંત, તમારો code એવા cases સામે ચકાસવામાં આવે છે જે તમને દેખાતા નથી.
• મોટા inputs પર કામગીરી: algorithm આધારિત tasksમાં સાચો પણ ધીમો solution પોઈન્ટ ગુમાવી શકે છે.
• તમે કેટલો સમય લો છો: મર્યાદામાં લીધેલો સમય scoreનો ભાગ નથી.

અમારા mocksમાં શું સામેલ છે. દરેક સંપૂર્ણ mockમાં 90 મિનિટમાં ત્રણ coding tasks હોય છે, જેમાં એક સરળ taskથી વધુ મુશ્કેલ task તરફ આગળ વધો છો. તમે Python, JavaScript, Java અથવા C++માં solution લખો અને ચલાવો છો. પછી તેને છુપાયેલા test cases સામે ચકાસવામાં આવે છે અને તે પાસ કરેલા દરેક case માટે ક્રેડિટ મળે છે. Laptopની ભલામણ કરવામાં આવે છે. Submit કરો ત્યાં સુધી પાછા જઈને solution બદલી શકો છો.

અમારા mocksમાં શું અલગ છે. સામાન્ય રીતે જણાવવામાં આવે છે કે વાસ્તવિક Codility tasksમાં ચોકસાઈ અને ઘણા tasksમાં મોટા inputs પરની કામગીરી ચકાસવામાં આવે છે. અમારા છુપાયેલા cases નાના છે અને ચોકસાઈ તથા edge cases ચકાસે છે, તેથી ધીમા solution માટે સમય પૂરો થતો નથી; દરેક taskની સમજૂતીમાં મોટા input માટે કેટલી complexity જરૂરી છે તે જણાવવામાં આવે છે. 10 મફત પ્રશ્નો multiple choice છે અને તેમાં ચોકસાઈ, complexity, edge cases તથા ઝડપ વિશે પૂછવામાં આવે છે. આ checks પાસ કરવા માટે જે વિચારસરણી જોઈએ છે તેનો તેમાં અભ્યાસ થાય છે.

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

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

1. કયું solution સાચું છે. Task: listમાં રહેલા અલગ-અલગ મૂલ્યોની સંખ્યા આપવી. Solution: len(set(A)). ખાલી list સહિત દરેક list માટે આ સાચું છે; ખાલી list માટે જવાબ 0 મળે છે. ધ્યાન રાખો: sorted list સાથે પોતાનો loop લખતાં પહેલો કે છેલ્લો item ભૂલી જવો. Built-inથી કામ થતું હોય તો તે edge cases સંભાળે છે કે નહીં તે તપાસો અને પછી તેનો ઉપયોગ કરો.

2. Time complexity. એક solution A પર loop ચલાવે છે અને loopની અંદર max(A[:i]) ચલાવે છે. Slice અને max બંને વધુમાં વધુ i items જુએ છે, તેથી કુલ કામ લગભગ N squared divided by 2 steps, એટલે O(N squared), થાય છે. તેના બદલે ચાલતી maximum કિંમત રાખવાથી complexity O(N) થાય છે. ધ્યાન રાખો: એક loop જોઈને તેને O(N) ગણવો. તેની અંદર slices, sums, counts અને searches છે કે નહીં તે જુઓ.

3. કયો input તેને નિષ્ફળ બનાવે. Task: Aમાં ન હોય એવી સૌથી નાની positive integer આપવી. એક solution max(A) + 1 આપે છે. A = [1, 2, 3] અજમાવો: જવાબ 4 આવે છે, જે સાચો છે. A = [1, 3] અજમાવો: જવાબ 4 આવે છે, પરંતુ 2 ગાયબ છે, તેથી સાચો જવાબ 2 છે. A = [-3, -1] અજમાવો: જવાબ 0 આવે છે, પરંતુ સાચો જવાબ 1 છે. ધ્યાન રાખો: એક સાચા case પછી અટકી જવું. Edge cases જાણીજોઈને લખો: વચ્ચેની ખાલી જગ્યાઓ, બધા negative મૂલ્યો, મંજૂર હોય તો ખાલી list, એક item, બધા સમાન મૂલ્યો અને મંજૂર સૌથી મોટા મૂલ્યો.

4. N 100,000 સુધી હોય ત્યારે પૂરતી ઝડપ. સામાન્ય નિયમ તરીકે આ size માટે O(N) અથવા O(N log N) લક્ષ્ય રાખો. O(N squared) એટલે લગભગ 10 billion steps, જે સામાન્ય time limit કરતાં ઘણું વધારે છે. ધ્યાન રાખો: દસ items સાથે test કરવું, જ્યાં દરેક રીત તરત ચાલતી લાગે છે. N વધે તેમ કામ કેટલું વધે છે તે વિચારો.

5. મર્યાદાઓ વાંચવી. મૂલ્યો 1,000,000,000 સુધીના હોઈ શકે અને N 100,000 હોય, તો સરવાળો 100 trillion સુધી પહોંચી શકે છે. Pythonના integers આ સંખ્યા સંભાળી શકે છે, પરંતુ fixed-size integers ધરાવતી languagesમાં overflow થશે. ધ્યાન રાખો: મૂલ્યોની range અવગણવી. તે overflowની શક્યતા અને counting array જેવી કઈ રીતો વાપરી શકાય તે સમજાવે છે.

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

1. સૌપ્રથમ તમારું આમંત્રણ વાંચો. Tasksની સંખ્યા, કુલ સમય અને મંજૂર ભાષાઓ નોંધો. આ બધું નોકરીદાતા નક્કી કરે છે, તેથી ધારણા ન બાંધો.
2. તમને સારી રીતે આવડતી એક ભાષા વાપરો. તેની lists, dictionaries, sets, sorting અને string methods જાણો, જેથી શોધવા ન પડે.
3. Code લખતાં પહેલાં મર્યાદાઓ વાંચો. Taskમાં inputનું કદ અને valuesની શ્રેણી જણાવે છે કે solution કેટલું ઝડપી હોવું જોઈએ અને કયા edge cases મહત્ત્વના છે. Codilityના પોતાના પાઠના tasksમાં પણ આવું જ જોવા મળે છે (Codility).
4. પહેલાં સાચું બનાવો, પછી ઝડપી. પહેલાં સરળ અને સાચું version લખો. જો તે O(N squared) હોય અને N 100,000 સુધી પહોંચી શકે, તો તેને વધુ કાર્યક્ષમ બનાવવા running total, dictionary, set અથવા sortingનો ઉપયોગ કરો.
5. Edge cases જાતે test કરો. Taskમાંનું ઉદાહરણ ફક્ત એક case છે. મંજૂરી હોય તો empty input, એક item, બધી સમાન values, negative values, સૌથી નાની અને મોટી values તથા સૌથી મોટું N અજમાવો.
6. સામાન્ય patterns શીખો. Prefix sums, sliding windows, dictionary વડે ગણતરી, two pointers, પહેલાં sorting અને સરળ greedy પસંદગીઓ ટૂંકા algorithm tasksના મોટા ભાગમાં કામ લાગે છે. Codilityના મફત પાઠ તેની શૈલી જોવા માટે સારી જગ્યા છે (Codility).
7. સમયમર્યાદામાં સંપૂર્ણ solutions લખો. અમારા સંપૂર્ણ mocksમાં તમે code લખો અને છુપાયેલા cases સામે ચલાવો છો. તમારા પોતાના tasks સાથે પણ આવું કરો, જેથી સમયમર્યાદામાં લખવું સામાન્ય લાગે.
8. વાસ્તવિક ગતિએ અભ્યાસ કરો. સંપૂર્ણ timed mocks આપો, જેથી testના દિવસે એક જ timer હેઠળ ત્રણ tasks ઉકેલવાનું સામાન્ય લાગે.

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

સ્કોરિંગ દરેક એમ્પ્લોયર નક્કી કરે છે. Codility કહે છે કે દરેક ટાસ્કનું નિશ્ચિત માપદંડો સામે આપમેળે સ્કોરિંગ થાય છે (Codility), અને કયો પરિણામ પૂરતો સારો છે તે દરેક એમ્પ્લોયર નક્કી કરે છે. પાસ થવા માટેનો કોઈ એક સર્વમાન્ય ગુણાંક નથી.

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

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

સામાન્ય ભૂલો

• ઉદાહરણ પર ભરોસો રાખવો. Taskનું ઉદાહરણ ઘણા છુપાયેલા casesમાંથી એક છે. ઉકેલ તેમાં પાસ થાય છતાં કુલ ગુણના મોટા ભાગમાં નિષ્ફળ થઈ શકે છે.
• Nની અવગણના કરવી. સાચો O(N squared) ઉકેલ N = 100,000 પર performance checksમાં નિષ્ફળ થઈ શકે છે. પહેલાં મર્યાદાઓ તપાસો.
• Loopની અંદર છુપાયેલું કામ. Loopની અંદર list પર slice, sum, count, index અથવા "in" વાપરવાથી ખર્ચ અનેકગણો વધે છે.
• છેલ્લો item ચૂકી જવો. એકની ભૂલવાળા ranges અને listના અંતે પૂરા થતા loops સામાન્ય ભૂલ છે. છેલ્લું પગલું જાતે કરીને તપાસો.
• શરૂઆતનાં ખોટાં મૂલ્યો. મહત્તમ મૂલ્ય 0થી અથવા લઘુત્તમ મૂલ્ય મનસ્વી મોટા આંકડાથી શરૂ કરવાથી નેગેટિવ અથવા ખૂબ મોટા મૂલ્યોમાં ભૂલ થાય છે. પહેલા itemથી શરૂ કરો.
• Taskને જરૂરી હોય તે ક્રમ બદલી નાખવો. Sorting ઉપયોગી છે, પણ જવાબ positions અથવા "listમાં પહેલો" હોવા પર આધારિત હોય ત્યારે નહીં.
• બધો સમય એક task પર ખર્ચી નાખવો. દરેક taskનો સાચો version સબમિટ કરો, પછી સમય મળે ત્યાં તેની ઝડપ સુધારો.