Codility-स्टाइल coding test की तैयारी

असली test आम तौर पर कैसा होता है

Codility का कोई एक तय test नहीं होता। Codility एक platform है: हर employer अपने test के लिए tasks, इस्तेमाल की जा सकने वाली languages और समय-सीमा तय करता है। आपके test के बारे में सबसे अच्छी जानकारी employer के invitation से मिलती है।

Codility क्या बताता है। Codility के अनुसार, हर task को तय मानदंडों के आधार पर अपने-आप score किया जाता है (Codility)। Programmers के लिए इसके free lessons (Codility) में tasks का अंदाज़ दिखता है: एक छोटी problem, लिखने के लिए एक function और input की दी गई सीमाएँ। उदाहरण के लिए, इसके BinaryGap lesson task में 2,147,483,647 तक के inputs के लिए "an efficient algorithm" माँगा जाता है (Codility), और एक lesson का शीर्षक Time Complexity है (Codility)।

Codility tests के बारे में आम तौर पर बताई जाने वाली बातें (candidates और guides से मिली जानकारी; जिस Codility पेज को हम खोल सके, उस पर इसकी पुष्टि नहीं हुई):

• पूरे test के लिए एक ही timer में कुछ tasks, अक्सर 30 मिनट से 2 घंटे के बीच।
• छिपे हुए correctness tests: task में दिए example के अलावा, आपका code ऐसे cases पर भी जाँचा जाता है जिन्हें आप नहीं देख सकते।
• Algorithm वाले tasks में बड़े inputs पर performance: सही लेकिन धीमे solution के points कम हो सकते हैं।
• आप कितना समय लेते हैं, समय-सीमा के भीतर, यह score का हिस्सा नहीं होता।

हमारे mocks में क्या शामिल है। हर full mock में 90 मिनट में तीन coding tasks होते हैं, आसान task से लेकर कठिन task तक। आप Python, JavaScript, Java या C++ में solution लिखकर run करते हैं। इसे hidden test cases पर जाँचा जाता है और हर पास किए गए case के लिए credit मिलता है। Laptop इस्तेमाल करने की सलाह दी जाती है। Submit करने तक आप वापस जाकर solution बदल सकते हैं।

हमारे mocks में क्या अलग है। आम तौर पर बताया जाता है कि असली Codility tasks में correctness और कई tasks में बड़े inputs पर performance जाँची जाती है। हमारे hidden cases छोटे होते हैं और correctness तथा edge cases जाँचते हैं, इसलिए धीमे solution का समय खत्म नहीं होता; हर task की explanation बताती है कि बड़े input के लिए किस complexity की ज़रूरत होगी। 10 free questions में correctness, complexity, edge cases और speed पर multiple-choice सवाल होते हैं। इनमें उन checks को पास करने के लिए ज़रूरी सोच की practice होती है।

हल किए गए उदाहरणों के साथ सवालों के प्रकार

हर तरह के सवाल के लिए एक हल किया हुआ उदाहरण, साथ में वह आम गलती जिसमें ज़्यादातर लोग फँसते हैं।

1. कौन-सा solution सही है। काम: list में अलग-अलग values की संख्या लौटाएँ। Solution: len(set(A))। यह हर list के लिए सही है, खाली list के लिए भी, जिसका नतीजा 0 होगा। ध्यान दें: sorted list के साथ अपना loop लिखना और पहली या आखिरी item भूल जाना। जब built-in से काम हो जाता है, तो पहले जाँचें कि वह edge cases संभालता है, फिर उसका इस्तेमाल करें।

2. Time complexity। एक solution, A पर loop चलाता है और loop के अंदर max(A[:i]) call करता है। Slice और max, दोनों में अधिकतम i items तक देखे जाते हैं, इसलिए कुल steps लगभग N squared को 2 से भाग देने जितने, यानी O(N squared) हैं। इसके बजाय running maximum रखने से complexity O(N) हो जाती है। ध्यान दें: एक loop देखकर उसे O(N) मान लेना। उसके अंदर slices, sums, counts और searches देखें।

3. कौन-सा input इसे fail करेगा। काम: वह सबसे छोटा positive integer लौटाना जो A में नहीं है। एक solution max(A) + 1 लौटाता है। A = [1, 2, 3] आज़माएँ: यह 4 लौटाता है, जो सही है। A = [1, 3] आज़माएँ: यह 4 लौटाता है, लेकिन 2 मौजूद नहीं है, इसलिए सही जवाब 2 है। A = [-3, -1] आज़माएँ: यह 0 लौटाता है, लेकिन सही जवाब 1 है। ध्यान दें: एक सही case के बाद जाँच रोक देना। जान-बूझकर edge cases की सूची बनाएँ: बीच के छूटे हुए numbers, सभी negative values, अनुमति हो तो खाली 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. Limits पढ़ना। अगर values 1,000,000,000 तक हो सकती हैं और N 100,000 है, तो sum 100 trillion तक पहुँच सकता है। Python के integers इसे संभाल लेते हैं, लेकिन fixed-size integers वाली languages में overflow होगा। ध्यान दें: values की range को नज़रअंदाज़ करना। इससे पता चलता है कि overflow हो सकता है या नहीं और कौन-से तरीके, जैसे counting array, इस्तेमाल किए जा सकते हैं।

तैयारी कैसे करें

1. सबसे पहले अपना invitation पढ़ें। Tasks की संख्या, कुल समय और इस्तेमाल की जा सकने वाली languages नोट करें। इन्हें employers तय करते हैं, इसलिए अंदाज़ा न लगाएँ।
2. एक ऐसी language चुनें जिसे आप अच्छी तरह जानते हों। उसकी lists, dictionaries, sets, sorting और string methods बिना खोजे इस्तेमाल कर सकें।
3. Code लिखने से पहले limits पढ़ें। किसी task में input का आकार और values की range बताती है कि solution कितना तेज़ होना चाहिए और कौन-से edge cases मायने रखते हैं। Codility के अपने lesson tasks में भी ऐसा ही है (Codility)।
4. पहले सही करें, फिर तेज़ बनाएँ। पहले एक आसान और सही version लिखें। अगर उसकी complexity O(N squared) है और N 100,000 तक जा सकता है, तो इसे कम करने के लिए running total, dictionary, set या sorting का इस्तेमाल करें।
5. Edge cases खुद test करें। Task में दिया example सिर्फ एक case होता है। अगर अनुमति हो तो खाली input, एक item, सभी समान values, negatives, सबसे छोटी और सबसे बड़ी values, और सबसे बड़े N के साथ test करें।
6. आम patterns सीखें। Prefix sums, sliding windows, dictionary से counting, two pointers, पहले sorting करना और आसान greedy choices, छोटे algorithm tasks के बड़े हिस्से में काम आते हैं। Codility के free lessons में इस शैली को देख सकते हैं (Codility)।
7. समय-सीमा में पूरे solutions लिखें। हमारे full mocks में आप code लिखकर hidden cases पर run करते हैं; अपने चुने हुए tasks के साथ भी ऐसा करें, ताकि समय के दबाव में लिखना सामान्य लगे।
8. Test जैसी गति से practice करें। पूरे timed mocks दें, ताकि test के दिन एक ही timer में तीन tasks हल करना सामान्य लगे।

आमतौर पर scoring कैसे होती है

स्कोरिंग हर employer तय करता है। Codility का कहना है कि हर task को तय मानदंडों के आधार पर अपने-आप स्कोर किया जाता है (Codility), और हर employer तय करता है कि कौन-सा नतीजा पर्याप्त है। पास होने का कोई एक तय मानदंड नहीं है।

आम तौर पर बताई गई जानकारी के अनुसार, ये मानदंड इस तरह काम करते हैं: किसी task का स्कोर छिपे हुए correctness tests और, कई algorithmic tasks में, बड़े inputs पर performance tests से बनता है। इन्हें मिलाकर पहले task का और फिर पूरे test का प्रतिशत निकाला जाता है। कोई solution छोटे inputs पर सही हो, लेकिन बड़े inputs पर बहुत धीमा हो, तो उसके performance points कम हो सकते हैं। वहीं, किसी edge case पर fail होने से उसके correctness score का कुछ हिस्सा कम हो जाता है। इसीलिए हमारे mocks में बार-बार अलग-अलग पूछा जाता है, "क्या यह सही है?" और "क्या यह पर्याप्त तेज़ है?"

हमारा practice score बताता है कि आपने हमारे अपने कितने सवालों के सही जवाब दिए, और इसमें task के हिसाब से विवरण भी होता है, ताकि आप तय कर सकें कि किस पर ध्यान देना है। यह सिर्फ एक practice score है: यह Codility का score या किसी employer का नतीजा नहीं है और इससे यह अनुमान नहीं लगाया जा सकता कि आप पास होंगे या नहीं।

आम गलतियां

• उदाहरण पर भरोसा कर लेना। किसी task का उदाहरण, कई छिपे हुए cases में से एक होता है। Solution उस case को पास करके भी ज़्यादातर score में fail हो सकता है।
• N को नज़रअंदाज़ करना। सही O(N squared) solution भी N = 100,000 पर performance checks में fail हो सकता है। पहले limits जाँचें।
• Loop के अंदर छिपा हुआ काम। Loop के अंदर list पर slice, sum, count, index या "in" इस्तेमाल करने से कुल लागत कई गुना बढ़ जाती है।
• आखिरी item छूट जाना। एक की गिनती की गलती वाले ranges और list के अंत तक चलने वाले loops अक्सर असफलता का कारण बनते हैं। आखिरी कदम को हाथ से जाँचें।
• शुरुआत के लिए गलत values चुनना। Maximum को 0 से या minimum को मनमानी बड़ी संख्या से शुरू करने पर negative या बहुत बड़ी values के साथ गलती होती है। पहली item से शुरू करें।
• Task के लिए ज़रूरी क्रम बदल देना। Sorting एक बेहतरीन तरीका है, लेकिन तब नहीं जब जवाब positions या "list में सबसे पहले" पर निर्भर करता हो।
• पूरा समय एक task पर लगा देना। पहले हर task का सही version जमा करें, फिर समय मिले तो रफ़्तार बेहतर बनाएँ।