पायथन में NZEC एरर क्या है?

NZEC (Non-Zero Exit Code) का अर्थ है प्रोग्राम का असामान्य समाप्ति (क्रैश) होना। कंपेटिटिव प्रोग्रामिंग प्लेटफॉर्म्स (CodeChef, Codeforces, HackerRank, आदि) पर यह आम त्रुटि है।

एग्जिट कोड्स

• 0 - सफल समाप्ति
• Non-zero (1, 2, 139, आदि) - त्रुटि/क्रैश

पायथन में सामान्य NZEC कारण

1. अनकॉट एक्सेप्शन्स

# खराब: अनहैंडल्ड एक्सेप्शन
n = int(input())
arr = list(map(int, input().split()))
print(arr[n])  # IndexError यदि n >= len(arr)

# अच्छा: ट्राई-एक्सेप्ट
try:
    n = int(input())
    arr = list(map(int, input().split()))
    print(arr[n])
except Exception as e:
    pass  # या उचित हैंडलिंग

2. इनपुट पार्सिंग त्रुटियां

# खराब: स्प्लिट के बिना
x, y = map(int, input())  # ValueError यदि स्पेस नहीं

# अच्छा: स्प्लिट के साथ
x, y = map(int, input().split())

# खराब: EOF पर क्रैश
for i in range(n):
    x = int(input())  # EOFError यदि इनपुट कम

# अच्छा: सभी इनपुट एक साथ पढ़ें
import sys
data = sys.stdin.read().strip().split()
# फिर data से पार्स करें

3. अनंत रिकर्सन / स्टैक ओवरफ्लो

# खराब: बेस केस गायब
def factorial(n):
    return n * factorial(n-1)

# अच्छा: बेस केस
def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n-1)

# या इटरेटिव (बेहतर)
def factorial(n):
    result = 1
    for i in range(2, n+1):
        result *= i
    return result

4. बड़ी संख्या / मेमोरी इश्यूज

# खराब: बड़ी फैक्टोरियल डायरेक्टली
import math
print(math.factorial(100000))  # MemoryError संभव

# अच्छा: मॉड्यूलर अरिथमेटिक या स्ट्रीमिंग
# समस्या अनुसार एल्गोरिदम चुनें

5. ज़ीरो से विभाजन

# खराब
result = 10 / (x - 5)  # यदि x=5 तो ZeroDivisionError

# अच्छा
if x != 5:
    result = 10 / (x - 5)
else:
    result = 0  # या उचित हैंडलिंग

6. बड़े लूप्स में धीमा I/O

# खराब: बड़े इनपुट के लिए धीमा
for _ in range(100000):
    x = int(input())

# अच्छा: फास्ट I/O
import sys
data = sys.stdin.buffer.read().split()
# या
input = sys.stdin.readline

डीबगिंग चेकलिस्ट

1. एज केस टेस्ट करें: खाली इनपुट, सिंगल एलिमेंट, अधिकतम सीमा
2. इनपुट फॉर्मेट: स्पेस, न्यूलाइन, एक्स्ट्रा व्हाइटस्पेस
3. आउटपुट फॉर्मेट: एक्स्ट्रा स्पेस, न्यूलाइन, केस सेंसिटिविटी
4. वेरिएबल ओवरफ्लो: पायथन में अनलिमिटेड इंट, लेकिन मेमोरी लिमिट
5. रिकर्सन लिमिट: sys.setrecursionlimit(10**6) यदि आवश्यक

सही इनपुट पैटर्न्स

# पैटर्न 1: सभी इंटीजर्स एक लाइन में
arr = list(map(int, input().split()))

# पैटर्न 2: मल्टीपल लाइन्स, प्रत्येक में एक इंट
arr = [int(input()) for _ in range(n)]

# पैटर्न 3: मल्टीपल लाइन्स, प्रत्येक में मल्टीपल इंट्स
matrix = [list(map(int, input().split())) for _ in range(n)]

# पैटर्न 4: पूरा इनपुट एक साथ (सबसे तेज)
import sys
data = sys.stdin.read().split()
it = iter(data)
n = int(next(it))
arr = [int(next(it)) for _ in range(n)]

प्लेटफॉर्म-विशिष्ट नोट्स

• CodeChef: NZEC दिखाता है, स्टडरआउट/स्टडरएर नहीं
• Codeforces: "Runtime error" दिखाता है, एक्जिट कोड देता है
• HackerRank: "Runtime Error" + स्टैक ट्रेस (कभी-कभी)
• LeetCode: "Runtime Error" + लाइन नंबर

सारांश: NZEC से बचने के टिप्स

• हमेशा try-except से मेन लपेटें
• sys.stdin.buffer.read() उपयोग करें फास्ट I/O के लिए
• इनपुट वैलिडेशन करें
• रिकर्सन के बजाय इटरेशन प्रेफर करें
• लोकल टेस्टिंग में एज केस कवर करें