Codility-शैलीतील कोडिंग चाचणीचा सराव

खरी परीक्षा सहसा कशी असते

Codility ची एकच ठरलेली चाचणी नाही. Codility हे एक प्लॅटफॉर्म आहे: प्रत्येक employer आपल्या चाचणीतील tasks, परवानगी असलेल्या programming languages आणि वेळेची मर्यादा ठरवतो. तुमच्या चाचणीबाबत employer कडून आलेले invitation हा सर्वात चांगला मार्गदर्शक आहे.

Codility काय सांगते. Codility नुसार, प्रत्येक task चे ठरावीक निकषांनुसार स्वयंचलितपणे गुणांकन केले जाते (Codility). प्रोग्रामर्ससाठीचे त्यांचे मोफत धडे (Codility) task चे स्वरूप दाखवतात: एक छोटी समस्या, लिहायचे function आणि input च्या नमूद केलेल्या मर्यादा. उदाहरणार्थ, BinaryGap या धड्यातील task मध्ये 2,147,483,647 पर्यंतच्या inputs साठी "an efficient algorithm" मागितले आहे (Codility). एका धड्याचे शीर्षक Time Complexity आहे (Codility).

Codility चाचण्यांबद्दल सामान्यतः सांगितल्या जाणाऱ्या गोष्टी (उमेदवार आणि मार्गदर्शकांकडून मिळालेल्या माहितीवर आधारित; आम्ही पाहू शकलेल्या Codility पेजवर याची पुष्टी झालेली नाही):

• एकाच timer मध्ये काही tasks: संपूर्ण चाचणीसाठी एक timer असतो; वेळ अनेकदा 30 minutes ते 2 hours असतो.
• लपवलेल्या correctness चाचण्या: task मधील उदाहरणापलीकडे, तुम्हाला न दिसणाऱ्या cases वर तुमचा code तपासला जातो.
• मोठ्या inputs वरील कामगिरी: algorithmic tasks मध्ये योग्य पण धीमे solution मुळे गुण कमी होऊ शकतात.
• तुम्ही घेतलेला वेळ: दिलेल्या मर्यादेत तुम्हाला लागलेला वेळ गुणांकनाचा भाग नसतो.

आमच्या mock tests मध्ये काय असते. प्रत्येक पूर्ण mock test मध्ये 90 minutes मध्ये three coding tasks असतात. त्यात सोप्या task पासून कठीण task पर्यंतचा समावेश असतो. तुम्ही Python, JavaScript, Java किंवा C++ मध्ये solution लिहून चालवता. ते लपवलेल्या test cases वर तपासले जाते आणि पास झालेल्या प्रत्येक case साठी गुण मिळतात. Laptop वापरण्याची शिफारस आहे. Submit करेपर्यंत तुम्ही मागे जाऊन solution बदलू शकता.

आमच्या mock tests मध्ये काय वेगळे आहे. वास्तविक Codility tasks मध्ये correctness आणि अनेक tasks मध्ये मोठ्या inputs वरील performance तपासली जाते, असे सामान्यतः सांगितले जाते. आमचे hidden cases छोटे असतात आणि correctness तसेच edge cases तपासतात. त्यामुळे धीमे solution साठी वेळ संपत नाही; मोठ्या input साठी कोणती complexity आवश्यक असेल, हे प्रत्येक task च्या स्पष्टीकरणात सांगितलेले असते. 10 मोफत प्रश्न multiple choice स्वरूपाचे असून त्यांत correctness, complexity, edge cases आणि speed यांचा समावेश आहे. या तपासण्या पास करण्यामागचा विचार समजून घेण्यासाठी ते उपयुक्त आहेत.

सोडवून दाखवलेल्या उदाहरणांसह प्रश्नांचे प्रकार

प्रत्येक प्रकारच्या प्रश्नाचे एक सोडवून दाखवलेले उदाहरण, आणि बहुतेक जण ज्या सापळ्यात अडकतात तोही.

1. कोणते solution योग्य आहे. काम: list मधील वेगवेगळ्या values ची संख्या परत द्या. Solution: len(set(A)). रिकाम्या list साठीही हे प्रत्येक list वर योग्य उत्तर देते. रिकाम्या list साठी उत्तर 0 असते. सापळा: sorted list वापरून स्वतःचा loop लिहिणे आणि पहिली किंवा शेवटची item विसरणे. Built-in ने काम होत असल्यास, ते edge cases हाताळते का ते तपासा आणि मग ते वापरा.

2. Time complexity. एक solution A मधील items वर loop चालवतो आणि loop च्या आत max(A[:i]) call करतो. Slice आणि max या दोन्हीमध्ये प्रत्येकी i पर्यंत items तपासल्या जातात. त्यामुळे एकूण काम सुमारे N squared ला 2 ने भागल्याइतके steps, म्हणजे O(N squared), असते. त्याऐवजी running maximum ठेवल्यास ते O(N) होते. सापळा: एक loop दिसताच त्याला O(N) म्हणणे. Loop मध्ये slices, sums, counts आणि searches आहेत का ते तपासा.

3. कोणत्या input मुळे अडचण येते. काम: 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 मुद्दाम तपासा: मधल्या values नसणे, सर्व values negative असणे, परवानगी असल्यास रिकामी list, एक item, सर्व values सारख्या असणे आणि परवानगी असलेल्या सर्वात मोठ्या values.

4. N ची मर्यादा 100,000 पर्यंत असताना पुरेसे वेगवान. सर्वसाधारण नियम म्हणून, त्या size साठी O(N) किंवा O(N log N) चे लक्ष्य ठेवा. O(N squared) म्हणजे सुमारे 10 billion steps, जे नेहमीच्या time limit पेक्षा खूप जास्त आहे. सापळा: दहा items वर test करणे. त्यावर प्रत्येक पद्धत लगेच पूर्ण झाल्यासारखी वाटते. N वाढल्यावर काम किती वाढते ते पाहा.

5. मर्यादा समजून घ्या. Values 1,000,000,000 पर्यंत आणि N 100,000 पर्यंत असू शकत असल्यास, बेरीज 100 trillion पर्यंत जाऊ शकते. Python चे integers हे हाताळतात; पण ठरावीक आकाराचे integers असलेल्या languages मध्ये overflow होईल. सापळा: values ची range दुर्लक्षित करणे. ती overflow होऊ शकते का आणि counting array सारख्या युक्त्या वापरणे शक्य आहे का हे सांगते.

तयारी कशी करावी

1. सर्वप्रथम तुमचे invitation वाचा. Tasks ची संख्या, एकूण वेळ आणि परवानगी असलेल्या languages नोंदवा. हे employer ठरवतात, त्यामुळे गृहीत धरू नका.
2. तुम्हाला चांगली अवगत असलेली एक language वापरा. तिच्या lists, dictionaries, sets, sorting आणि string methods यांची माहिती शोधावी न लागेल इतकी तयारी ठेवा.
3. Code लिहिण्यापूर्वी मर्यादा वाचा. Task मधील input sizes आणि values च्या मर्यादांवरून solution किती वेगवान असायला हवे आणि कोणते edge cases महत्त्वाचे आहेत हे समजते. Codility च्या स्वतःच्या lesson tasks मध्येही हे दिसते (Codility).
4. आधी solution अचूक करा, मग वेगवान. आधी सोपी आणि योग्य आवृत्ती लिहा. ती O(N squared) असेल आणि N 100,000 पर्यंत जाऊ शकत असेल, तर complexity कमी करण्यासाठी running total, dictionary, set किंवा sorting वापरता येईल का ते पाहा.
5. Edge cases स्वतः तपासा. Task मधील उदाहरण हे फक्त एक case असते. परवानगी असल्यास रिकामा input, एक item, सर्व values सारख्या असणे, negative values, सर्वात लहान आणि मोठ्या values, तसेच सर्वात मोठा N वापरून पाहा.
6. सामान्य patterns शिका. Prefix sums, sliding windows, dictionary वापरून counting, two pointers, सुरुवातीला sorting आणि सोप्या greedy निवडी यांमुळे अनेक लहान algorithm tasks सोडवता येतात. Codility चे मोफत धडे task चे स्वरूप समजून घेण्यासाठी चांगले आहेत (Codility).
7. वेळेत पूर्ण solutions लिहिण्याचा सराव करा. आमच्या पूर्ण mock tests मध्ये तुम्ही code लिहून hidden cases वर चालवता. वेळेत लिहिणे सहज वाटावे म्हणून स्वतःच्या tasks वरही असाच सराव करा.
8. चाचणीच्या खऱ्या गतीने सराव करा. पूर्ण timed mock tests द्या, म्हणजे चाचणीच्या दिवशी एकाच timer मध्ये तीन tasks सोडवणे नेहमीचे वाटेल.

गुणांकन साधारणपणे कसे केले जाते

प्रत्येक नियोक्ता स्वतः गुणांकन ठरवतो. Codility सांगते की प्रत्येक task चे ठरावीक निकषांनुसार आपोआप गुणांकन केले जाते (Codility), आणि कोणता निकाल पुरेसा चांगला आहे हे प्रत्येक नियोक्ता ठरवतो. सर्वांसाठी लागू होणारी एकच उत्तीर्ण गुणमर्यादा नाही.

हे निकष कसे काम करतात याबद्दल सामान्यतः सांगितले जाते: एखाद्या task चे गुण लपवलेल्या correctness tests वर आणि अनेक algorithmic tasks साठी मोठ्या inputs वरील performance tests वर आधारित असतात. हे गुण task साठी आणि नंतर संपूर्ण test साठी टक्केवारीत मोजले जातात. लहान inputs वर योग्य असलेला, पण मोठ्या inputs वर खूप धीमा असलेला solution performance गुण गमावू शकतो. एखाद्या edge case मध्ये अयशस्वी झाल्यास correctness गुणांचा काही भाग गमावतो. म्हणूनच आमच्या mock tests मधील प्रश्न वारंवार "हे योग्य आहे का?" आणि "हे पुरेसे वेगवान आहे का?" असे वेगवेगळे विचारतात.

आमचा सराव गुण म्हणजे तुम्ही आमच्या प्रश्नांपैकी किती प्रश्नांची योग्य उत्तरे दिली, आणि task नुसार त्याचा तपशील. त्यामुळे कुठे लक्ष द्यायचे हे तुम्हाला समजते. हा सरावाचा गुण आहे: तो Codility चा गुण किंवा कोणत्याही नियोक्त्याचा निकाल नाही आणि तुम्ही उत्तीर्ण व्हाल की नाही हे सांगत नाही.

सामान्य चुका

• उदाहरणावरच विश्वास ठेवणे. एखाद्या task चे उदाहरण हे अनेक लपवलेल्या उदाहरणांपैकी एक असते. एखादे solution त्यात पास होऊ शकते, पण तरीही एकूण गुणांपैकी बहुतेक गुण गमावू शकते.
• N कडे दुर्लक्ष करणे. O(N squared) असलेले योग्य solution देखील N = 100,000 असताना performance checks मध्ये अपयशी ठरू शकते. आधी limits तपासा.
• लूपमध्ये लपलेले काम. लूपमध्ये list वर slice, sum, count, index किंवा "in" वापरल्यास खर्च अनेक पटींनी वाढतो.
• शेवटचा item चुकवणे. Off-by-one ranges आणि list च्या शेवटी संपणाऱ्या runs मुळे अनेकदा चुका होतात. शेवटची पायरी हाताने तपासा.
• चुकीची सुरुवातीची मूल्ये. maximum ची सुरुवात 0 पासून करणे किंवा minimum साठी अंदाजाने मोठी संख्या घेणे, ऋण किंवा खूप मोठ्या मूल्यांच्या बाबतीत चुकीचे ठरते. पहिल्या item पासून सुरुवात करा.
• Task ला महत्त्वाचा असलेला क्रम बदलणे. Sorting हे उत्तम साधन आहे, पण उत्तर positions वर किंवा "first in the list" वर अवलंबून असेल, तर ते वापरू नका.
• सगळा वेळ एका task वर घालवणे. आधी प्रत्येक task ची योग्य आवृत्ती सबमिट करा, मग वेळ मिळेल तिथे speed सुधारा.