चेक अंक एल्गोरिदम: mod-10, mod-11 और mod-97 परिवारों की तुलना

चेक अंक एल्गोरिदम पहली नज़र में बेमेल व्यंजनों की लंबी सूची जैसे लगते हैं, जब तक यह समझ न आए कि वे सब एक ही विचार की भिन्नताएं हैं। हर एल्गोरिदम आखिरी स्थान से पहले के अक्षर उठाता है, हर एक पर वेट लगाता है, परिणामों को जोड़ता है, जोड़ को मॉड्यूलस से भाग देता है, और बचे हुए शेष को अंतिम अक्षर में बदल देता है।

जब यह ढांचा दिखने लगे, तो mod-10, mod-11 और mod-97 में से चुनाव स्वाद का मामला नहीं रह जाता, बल्कि चार पैरामीटरों को काम से मिलाने का मामला बन जाता है। यह लेख उसी स्तर पर तुलना करता है और किसी एकल कार्ड स्कीम का अंकगणित उस लेख पर छोड़ देता है जो उसका असली घर है।

चेक अंक एल्गोरिदम के मुख्य परिवार कौन से हैं?

पारंपरिक विभाजन मॉड्यूलस के आधार पर होता है, क्योंकि मॉड्यूलस ही वह पैरामीटर है जो बाकी सब कुछ गढ़ता है।

mod-10 परिवार भारित जोड़ को दस से भाग देता है, इसलिए शेष हमेशा एक ही दशमलव अंक रहता है और उसे किसी अतिरिक्त रूपांतरण की ज़रूरत नहीं पड़ती। mod-11 परिवार ग्यारह से भाग देता है, जिससे ग्यारह संभव शेष बनते हैं; उनमें से दस एक अंक में समा जाते हैं और ग्यारहवें को किसी और तरीके से दर्शाना पड़ता है। mod-97 परिवार सत्तानवे से भाग देता है, और उसकी ओर तब रुख किया जाता है जब पहचानकर्ता लंबे हों या उनमें अक्षर भी हों।

ISO 7064 वह अंतरराष्ट्रीय मानक है जो इस किस्म के कई प्रकाशित चेक-अक्षर सिस्टमों को एक साथ रखता है, जिनमें सीमाओं के पार जाने वाले खाता पहचानकर्ताओं के लिए इस्तेमाल होने वाली MOD 97-10 व्यवस्था भी शामिल है। परिवार का नाम बताना केवल अंकगणित का आकार बताता है, यह नहीं कि किसी विशेष स्कीम ने कौन से पैरामीटर तय किए — और यह अंतर तभी अहम हो जाता है जब आप इन रूटीनों को उस सत्यापन पाइपलाइन के भीतर रखते हैं जिसे कैरेक्टर सेट और लंबाई भी जांचनी होती है।

mod-10, mod-11 और mod-97 में अंतर

व्यवहार में जो अंतर मायने रखते हैं, वे सब मॉड्यूलस के नतीजे हैं।

जो कार्ड स्कीम अपने नंबरों को दोहराने और जोड़ने वाले mod-10 रूटीन से बंद करती है, वह पहली पंक्ति में आती है। वह रूटीन नाम ओढ़े हुए mod-10 अंकगणित है, और यहां परिवार का नज़रिया ही उपयोगी है: वही अंकगणित लॉयल्टी स्कीमों, आंतरिक पहचानकर्ताओं और कई राष्ट्रीय नंबरिंग सिस्टमों में भी दिखता है, इसीलिए कार्ड के नाम पर बना हेल्पर बाकी जगहों पर गलती करता है। तीसरी पंक्ति उन लंबे सीमा-पार खाता पहचानकर्ताओं के पीछे है जिन्हें IBAN संरचना और mod-97 वाले लेख में चरण दर चरण खोला गया है।

वेटिंग और मॉड्यूलस: एक परिवार के भीतर के पैरामीटर

एक ही परिवार के सदस्य ठीक तीन जगहों पर अलग होते हैं। पहली है वेट का क्रम — कौन से स्थान किस संख्या से गुणा होंगे, और वह पैटर्न दोहराता है या बढ़ता है। दूसरा है मॉड्यूलस स्वयं, जिसे पहचानकर्ता की लंबाई और उसके अक्षर-समूह के अनुसार चुना जाता है। तीसरी है शेष से चेक अक्षर तक की मैपिंग, और दिखने वाली ज़्यादातर विविधता इसी में बसती है।

यह मैपिंग दूसरी नज़र के लायक है, क्योंकि यहीं किसी स्कीम को बचे हुए शेष के बारे में फ़ैसला लेना पड़ता है। mod-10 का शेष बनावट से ही एक अंक होता है। mod-11 का शेष दस भी हो सकता है, और स्कीम को या तो ऐसे संयोजनों पर रोक लगानी पड़ती है, या परिणाम को किसी दूसरी श्रेणी में खिसकाना पड़ता है, या उसके लिए X जैसा कोई चिह्न आरक्षित करना पड़ता है। mod-97 के शेष को उन चेक अक्षरों में फिर से सिकोड़ना पड़ता है जिनकी अनुमति वह स्कीम देती है।

इस फ़ैसले को छोड़ देना ही हाथ से लिखे इम्प्लीमेंटेशन के प्रकाशित नियम से भटकने का सबसे आम रास्ता है। अंकगणित आरामदेह इनपुट पर सही दिखेगा और मुश्किल इनपुट पर विफल हो जाएगा।

कुछ एल्गोरिदम अदल-बदल की गलतियां क्यों पकड़ पाते हैं?

हाथ से टाइप करते समय पड़ोसी अक्षर लगातार बदल जाते हैं, इसलिए इस किस्म की चूक पकड़ना लक्ष्य है, कोई बोनस नहीं।

इसका तंत्र वेट हैं। जब कोई स्कीम हर स्थान को अलग मान से गुणा करती है, तो दो पड़ोसियों को बदलने से यह बदल जाता है कि हर एक कितना योगदान दे रहा है, और कुल जोड़ उसके साथ हिल जाता है। जब वेट सममित हों — जोड़े के दोनों ओर एक ही मान — तो दोनों योगदान आपस में जगह बदल लेते हैं और कुल अपरिवर्तित रहता है, इसलिए चेक उस अदल-बदल को पार कर जाने देता है।

यही वजह है कि mod-10 परिवार में दोहराने वाला सदस्य मौजूद है। बारी-बारी स्थानों को दोहराने से हर अंक का वेट उसकी जगह पर निर्भर हो जाता है, और अदल-बदल पहचानने की क्षमता लौट आती है। यह फिर भी पूर्ण नहीं है: कुछ जोड़ियों का कुल योग बदलने से पहले और बाद में एक जैसा रह जाता है। किसी भी चेक अंक का सही वर्णन यही है कि वह हर एकल-अक्षर त्रुटि पकड़ता है और ज़्यादातर, पर सभी नहीं, पड़ोसी अदल-बदल।

एल्गोरिदम चुनने से पहले चार सवाल

चुनाव तब आसान हो जाता है जब उसे पसंद का विषय मानने के बजाय ठोस सवालों का छोटा सेट माना जाए।

1. पहचानकर्ता कितना लंबा हो सकता है, और लंबाई तय है या बदलती है?
2. कौन से अक्षर वैध हैं — केवल अंक, या अक्षर भी?
3. अपेक्षित गलतियां लोगों के टाइप करने से आती हैं, मशीनों के बनाने से, या दोनों से?
4. जब अंकगणित ऐसा चेक अक्षर निकाले जो प्रारूप में फ़िट न हो, तब क्या होगा?

चौथा सवाल वही है जिसे टीमें छोड़ देती हैं। जो स्कीम एक अंक वाले स्थान पर दो अंकों का शेष बना सकती है, उसे या तो अपवादों का नियम चाहिए या ऐसा मॉड्यूलस जो उनसे बचे, और यह देर से पता चलना नियम समायोजित करने के बजाय उसे दोबारा लिखवा देता है।

इससे दो आदतें बनती हैं। पैरामीटर गढ़ें नहीं: जो स्कीम प्रकाशित करती है वही लागू करें, और फिर इम्प्लीमेंटेशन को उसी स्कीम की प्रकाशित सामग्री पर परखें। और जब एक ही उत्पाद की दो स्कीमें अपना ज़्यादातर अंकगणित साझा करती हों, तो इम्प्लीमेंटेशन साझा करें और पैरामीटरों को अलग रहने दें, बजाय इसके कि रूटीन की नकल बनाई जाए और दोनों प्रतियां अलग-अलग भटक जाएं।

डेवलपर के लिए: पूरे परिवार के लिए एक ही इम्प्लीमेंटेशन

परिवार का नज़रिया कोड में अपनी कीमत वसूल कर लेता है। वेट क्रम, मॉड्यूलस और मैपिंग से पैरामीटरित एक ही रूटीन हर सदस्य को संभाल लेता है, और हर नई स्कीम नई फ़ाइल के बजाय एक कॉन्फ़िगरेशन बन जाती है। इससे समीक्षा छोटी रहती है, क्योंकि अंकगणित एक बार समीक्षित होता है और पैरामीटर पंक्ति दर पंक्ति जांचे जाते हैं।

दो डिज़ाइन विवरण ज़्यादातर तकलीफ़ रोक देते हैं। बूलियन के बजाय निकाला गया चेक अक्षर लौटाएं, ताकि कॉलर यह छाप सके कि अंकगणित ने क्या अपेक्षित किया; तब गलत मान और असमर्थित स्कीम के बीच का अंतर ऊपर तक दिखता रहता है। और रीमैपिंग का चरण कॉन्फ़िगरेशन में स्पष्ट रखें, क्योंकि वही हिस्सा स्कीमों के बीच बदलता है और वही किसी को याद नहीं रहता।

इस लेख में उदाहरण के लिए जो भी अंक दिए गए हैं, वे सब काल्पनिक हैं — बताए गए पैरामीटर सार्वजनिक जानकारी हैं, जबकि उदाहरण स्ट्रिंग केवल प्रदर्शन के लिए बनाई गई हैं और किसी स्कीम द्वारा जारी किसी वास्तविक नंबर को नहीं दर्शाती हैं।

आगे के कदम

कुछ और लिखने से पहले उन सभी नंबरिंग स्कीमों की सूची बनाएं जिन्हें आपका उत्पाद संभालता है, और हर एक को किसी परिवार में रखें। फिर कोई मान बनाएं, एक अक्षर बदलें और पड़ोसी अक्षरों की एक जोड़ी बदलें, और पुष्टि करें कि दोनों ही विफल होते हैं; नंबर सत्यापन टूल वे नतीजे दिखाता है जिन्हें एक सत्यापनकर्ता को अलग-अलग पहचानना आना चाहिए, IBAN और mod-97 वाला लेख लंबे पहचानकर्ताओं के परिवार का हल किया हुआ उदाहरण है, और नंबर सत्यापन कैसे काम करता है वाला लेख उन तीन परतों तक लौट जाता है जिनके भीतर ये एल्गोरिदम बैठे हैं।