परीक्षा के लिए प्रोग्रामिंग: Python उत्तर जो अंक लाते हैं

परीक्षा के मूल्यांनकर्ता आपके कोड को बीस मिनट के लिए debugger के माध्यम से नहीं चलाते। वे इसे एक बार पढ़ते हैं, शायद दो बार, और एक rubric के विरुद्ध जांचते हैं। एक काम करने वाला समाधान जो rubric को नज़रअंदाज़ करता है अभी भी अंक खो सकता है, जबकि एक थोड़ा मोटा जो हर checkpoint को हिट करता है उच्च अंक स्कोर कर सकता है। परीक्षा के लिए Python लिखना एक वास्तविक प्रकल्प के लिए Python लिखने से एक अलग कौशल है, और इसे अलग से अभ्यास करने के लायक है।

समस्या को दो बार पढ़ने से पहले rubric पढ़ें

अधिकांश प्रोग्रामिंग परीक्षा — AP CS A शैली free-response प्रश्न, विश्वविद्यालय midterms, coding bootcamp मूल्यांकन — आंशिक-क्रेडिट नियम प्रकाशित करते हैं। एक विशिष्ट rubric लाइन इस तरह दिखती है: "सही loop संरचना के लिए 1 अंक, सही return value के लिए 1 अंक, खाली list case को संभालने के लिए 1 अंक।" यदि आप एक घना one-liner लिखते हैं जो सही उत्तर प्राप्त करता है लेकिन एक explicit loop को छोड़ता है, तो कुछ graders आपको dock कर सकते हैं भले ही output सही हो।

कुछ भी type करने से पहले, उन टुकड़ों की पहचान करें जो एक grader अलग से जांचने की संभावना रखता है:

• Function signature ठीक उसी तरह से मेल खाता है जैसा पूछा गया था (नाम, parameter क्रम, return प्रकार)
• Base case और recursive case, यदि recursion की अपेक्षा की जाती है
• Loop bounds (off-by-one त्रुटियां सबसे आम point loss हैं)
• Edge cases: खाली input, single-element input, नकारात्मक संख्याएं, duplicates

पहले इन्हें comments के रूप में लिखें। # handle empty list, # base case: n == 0। यह दस सेकंड का समय लेता है और गारंटी देता है कि आप उस case को नहीं भूलते जिसे एक grader विशेष रूप से ढूंढ रहा है।

कोड को संरचित करें ताकि partial credit दिखाई दे

"एक function लिखें जो list में दूसरी सबसे बड़ी संख्या return करता है" के दो उत्तरों की तुलना करें:

def second_largest(nums):
    return sorted(nums)[-2]

def second_largest(nums):
    if len(nums) < 2:
        return None
    largest = second = float('-inf')
    for n in nums:
        if n > largest:
            second = largest
            largest = n
        elif n > second and n != largest:
            second = n
    return second

पहला well-formed input के लिए सही है लेकिन दो से कम elements वाली list पर crash करता है और [5, 5, 3] जैसे duplicates पर गलत उत्तर देता है (5 return करता है, spec पर निर्भर करते हुए संभवतः गलत)। दूसरा लंबा है लेकिन हर rubric लाइन — edge case, सही logic, सही return — explicit है और एक grader की अपनी लाइन प्राप्त करता है जांचने के लिए। एक timed परीक्षा पर, दूसरा संस्करण लगभग हर बार उच्च अंक स्कोर करता है, भले ही इसे type करने में अधिक समय लगता है।

समय से पहले optimize न करें, स्पष्ट बग न छोड़ें

परीक्षा के प्रश्न शायद ही कभी Big-O ज्ञान का परीक्षण करते हैं जब तक वे directly न कहें। यदि prompt कहता है "एक function लिखें जो duplicates ढूंढता है," तो O(n²) पर एक nested loop ठीक है जब तक prompt बड़े input को निर्दिष्ट न करे या एक efficient समाधान के लिए न पूछे। परीक्षा के समय को set-based O(n) approach में बदलने में बिताना जब इसके लिए नहीं पूछा गया था वह समय है जो आपको वापस नहीं मिलता।

यह कहा जा रहा है, कुछ त्रुटियां हमेशा आपको खर्च करेंगी भले ही rubric कुछ भी हो:

• == के बजाय is का उपयोग करना असंगत रूप से logic bugs का कारण बनता है (Python परीक्षा में दुर्लभ लेकिन comparison-heavy प्रश्नों में दिखाई देता है)
• एक list को iterate करते समय mutate करना — for x in lst: lst.remove(x) एक क्लासिक परीक्षा trap है जो silently गलत output का निर्माण करता है
• return को भूलना और print करना — कई autograders return values जांचते हैं, stdout नहीं
• range() में off-by-one — range(len(nums)) vs range(len(nums) - 1) हर बार जब आप इसे लिखते हैं दोहरी जांच के लायक है

Submit करने से पहले अपने कोड को हाथ से trace करें

कागज़ की परीक्षाओं और अधिकांश in-browser coding परीक्षाओं पर, आपको कोड run नहीं करने को मिलता। एक छोटा उदाहरण चुनें और इसे line by line trace करें, जैसे-जैसे आप जाते हैं variable मान लिखते जाएं। यह दो मिनट से कम में logic त्रुटियों का शायद 80% पकड़ता है, और यह leftover समय के साथ करने के लिए सबसे high-value चीज़ है।

Recursive functions के लिए विशेष रूप से, कम से कम दो स्तर गहरे trace करें और explicitly base case को hit करते हुए लिखें। Graders अक्सर एक बिंदु देते हैं सिर्फ base case के सही ढंग से terminate होने का प्रदर्शन करने के लिए, recursive case के सही होने के बिंदु से अलग।

घड़ी को एक resource की तरह प्रबंधित करें, afterthought नहीं

यदि एक free-response अनुभाग तीन sub-questions में 9 अंकों के लायक है, तो मोटे तौर पर समान समय budget करें और यदि आप उस budget से आगे फंस गए हैं तो आगे बढ़ें — एक half-written लेकिन लगभग सही part (b) एक परिपूर्ण part (a) और एक blank part (c) से अधिक raw अंक के लायक है। सही signature और एक pass या एक अनुमान के साथ एक stub function लिखें भले ही आप logic को finish न कर सकें; एक सही signature अकेला कभी-कभी अपने आप में एक rubric point के लायक है।

परीक्षा के बाहर clean, testable Python लिखने के बारे में अधिक जानकारी के लिए, और data structures पर जो इन प्रश्नों में लगातार दिखाई देते हैं, Korra Studio पर संबंधित Python और Computer Science segments देखें।