लुहान एल्गोरिथ्म

लुहान एल्गोरिथ्म या लुहान सूत्र, जिसे मॉड्यूलर अंकगणित 10 या मॉड 10 एल्गोरिदम के रूप में भी जाना जाता है, इसका नाम इसके निर्माता, आईबीएम वैज्ञानिक उनके पीटर लुहान के नाम पर रखा गया है, सरल संख्या जांचें सूत्र है जिसका उपयोग विभिन्न प्रकार की पहचान संख्याओं को मान्य करने के लिए किया जाता है, जैसे भुगतान कार्ड नंबर, अंतर्राष्ट्रीय मोबाइल उपकरण पहचान, संयुक्त राज्य अमेरिका में राष्ट्रीय प्रदाता पहचानकर्ता, कनाडा सामाजिक बीमा संख्या, इज़राइली पहचान पत्र आईडी संख्या, दक्षिण अफ्रीका आईडी संख्या, स्वीडन राष्ट्रीय पहचान संख्या, स्वीडन कॉर्पोरेट पहचान संख्या (ऑर्गएनआर), यूनान ट्रैक्टर सप्लाई कंपनी की रसीदें है। इसका वर्णन 23 अगस्त 1960 को दिए गए अमेरिकी पेटेंट संख्या 2,950,048 में किया गया है।

एल्गोरिदम सार्वजनिक डोमेन में है और आज व्यापक उपयोग में है। यह आईएसओ/आईईसी 7812-1 में निर्दिष्ट है। इसका उद्देश्य क्रिप्टोग्राफ़िक हैश फ़ंक्शन होना नहीं है; इसे दुर्भावनापूर्ण आक्रमण से नहीं, किन्तु आकस्मिक त्रुटियों से बचाने के लिए डिज़ाइन किया गया था। अधिकांश क्रेडिट कार्ड और विभिन्न सरकारी पहचान संख्याएं वैध संख्याओं को गलत टाइप की गई या अन्यथा गलत संख्याओं से पृथक करने की सरल विधि के रूप में एल्गोरिदम का उपयोग करती हैं।

विवरण

चेक अंक की गणना इस प्रकार की जाती है:

1. यदि संख्या में पहले से ही चेक अंक है, तो पेलोड बनाने के लिए उस अंक को छोड़ दें। चेक अंक प्रायः अंतिम अंक होता है।
2. पेलोड के साथ, सबसे दाएँ अंक से प्रारंभ करें। बाईं ओर बढ़ते हुए, प्रत्येक दूसरे अंक (सबसे दाएँ अंक सहित) का मान दोगुना करें।
3. परिणामी अंकों के मानों का योग करें.
4. चेक अंक की गणना $10-(s\operatorname {mod} 10)$ द्वारा की जाती है . यह वह न्यूनतम संख्या (संभवतः शून्य) है जिसे 10 का गुणज बनाने के लिए $s$ में जोड़ा जाना चाहिए समान मान देने वाले अन्य मान्य सूत्र हैं $(10-s)\operatorname {mod} 10$ और $10\lceil s/10\rceil -s$.

चेक अंक की गणना के लिए उदाहरण

खाता संख्या 7992739871 का उदाहरण मानें (सिर्फ पेलोड, चेक अंक अभी तक सम्मिलित नहीं है):

	7	9	9	2	7	3	9	8	7	1
मल्टीप्लायर	1	2	1	2	1	2	1	2	1	2
	=	=	=	=	=	=	=	=	=	=
	7	18	9	4	7	6	9	16	7	2
अंकों का योग	7	9 (1+8)	9	4	7	6	9	7 (1+6)	7	2

परिणामी अंकों का योग 67 है।

चेक अंक $10-(67\operatorname {mod} 10)=3$ के बराबर है .

इससे पूरा खाता नंबर 79927398713 पढ़ जाता है।

चेक अंक को मान्य करने के लिए उदाहरण

1. सत्यापित करने के लिए नंबर का चेक अंक (अंतिम अंक) छोड़ें। (उदा. 79927398713 -> 7992739871)
2. चेक अंक की गणना करें (ऊपर देखें)
3. अपने परिणाम की तुलना मूल चेक अंक से करें। यदि दोनों संख्याएँ मेल खाती हैं, तो परिणाम मान्य है। (उदा.$(givenCheckDigit=calculatedCheckDigit)\Leftrightarrow (isValidCheckDigit)$).

सशक्तता और अशक्तता

लुहान एल्गोरिथ्म सभी एकल-अंकीय त्रुटियों के साथ-साथ आसन्न अंकों के लगभग सभी स्थानान्तरण का पता लगाएगा। चूँकि, यह दो अंकों के अनुक्रम 09 से 90 (या इसके विपरीत) के स्थानान्तरण का पता नहीं होता है। यह अधिकांश संभावित जुड़वां त्रुटियों का पता लगाएगा (यह 22 ↔ 55, 33 ↔ 66 या 44 ↔ 77 का पता नहीं लगाएगा)।

अन्य, अधिक सम्मिश्र चेक-डिजिट एल्गोरिदम (जैसे वेरहॉफ एल्गोरिथम और डैम एल्गोरिथ्म) अधिक ट्रांसक्रिप्शन त्रुटियों का पता लगा सकते हैं। लुहान मॉड एन एल्गोरिदम एक्सटेंशन है जो गैर-संख्यात्मक स्ट्रिंग का समर्थन करता है।

क्योंकि एल्गोरिदम अंकों पर दाएं से बाएं विधि से कार्य करता है और शून्य अंक परिणाम को केवल तभी प्रभावित करते हैं जब वे स्थिति में परिवर्तन का कारण बनते हैं, संख्याओं की स्ट्रिंग की प्रारंभ में शून्य-पैडिंग गणना को प्रभावित नहीं करती है। इसलिए, सिस्टम जो अंकों की विशिष्ट संख्या को पैड करते हैं (उदाहरण के लिए 1234 को 0001234 में परिवर्तित करके) पैडिंग से पहले या पश्चात् में लुहान सत्यापन कर सकते हैं और समान परिणाम प्राप्त कर सकते हैं।

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

स्यूडोकोड कार्यान्वयन

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

function isValid(cardNumber[1..length])                                                                            
    sum := 0                                                                                                   
    parity := length mod 2                                                                                    
    for i from 1 to length do                                                                                  
        if i mod 2 != parity then                                                        
            sum := sum + cardNumber[i]                                                                       
        elseif cardNumber[i] > 4 then                                                                      
            sum := sum + 2 * cardNumber[i] - 9                                                                        
        else
            sum := sum + 2 * cardNumber[i]
        end if
    end for
    return cardNumber[length] == (10 - (sum mod 10))
end function

कोड कार्यान्वयन

C#

bool IsValidLuhn(in int[] digits)
{
    int check_digit = 0;
    for (int i = digits.Length - 2; i >= 0; --i)
        check_digit += ((i & 1) is 0) switch
        {
            true  => digits[i] > 4 ? digits[i] * 2 - 9 : digits[i] * 2,
            false => digits[i]
        };

    return 10 - (check_digit % 10) == digits.Last();
}

बाहरी संबंध

• Implementation in 150 languages on the Rosetta Code project