लुहन एल्गोरिदम कैलकुलेटर

लुहन एल्गोरिदम कैलकुलेटर

परिचय

लुहन एल्गोरिदम, जिसे "मॉड्यूलस 10" या "मोड 10" एल्गोरिदम के रूप में भी जाना जाता है, एक सरल चेकसम फॉर्मूला है जिसका उपयोग विभिन्न पहचान नंबरों, जैसे कि क्रेडिट कार्ड नंबर, कनाडाई सामाजिक बीमा नंबर, IMEI नंबर, और संयुक्त राज्य अमेरिका में राष्ट्रीय प्रदाता पहचानकर्ता नंबरों को मान्य करने के लिए किया जाता है। यह कैलकुलेटर आपको लुहन एल्गोरिदम का उपयोग करके नंबरों को मान्य करने और वैध नंबर उत्पन्न करने की अनुमति देता है जो लुहन जांच पास करते हैं।

लुहन एल्गोरिदम कैसे काम करता है

लुहन एल्गोरिदम इस प्रकार काम करता है:

1. सबसे दाहिनी ओर के अंक (चेक अंक को छोड़कर) से शुरू करके बाईं ओर बढ़ते हुए, हर दूसरे अंक के मान को दोगुना करें।
2. यदि इस दोगुनी ऑपरेशन का परिणाम 9 से अधिक है, तो परिणाम से 9 घटाएं।
3. परिणामी अनुक्रम में सभी अंकों का योग करें।
4. यदि कुल का मॉड्यूलो 10 0 के बराबर है (यदि कुल शून्य में समाप्त होता है), तो संख्या लुहन सूत्र के अनुसार वैध है; अन्यथा, यह वैध नहीं है।

यहां लुहन एल्गोरिदम का एक दृश्य प्रतिनिधित्व है:

सूत्र

लुहन एल्गोरिदम को गणितीय रूप से इस प्रकार व्यक्त किया जा सकता है:

मान लीजिए $d_i$ $i$-वां अंक है, सबसे दाहिनी ओर के अंक से (चेक अंक को छोड़कर) बाईं ओर बढ़ते हुए। फिर चेक अंक $d_0$ इस प्रकार चुना जाता है कि:

$(2d_{2n} \bmod 9 + d_{2n-1} + 2d_{2n-2} \bmod 9 + d_{2n-3} + \cdots + 2d_2 \bmod 9 + d_1 + d_0) \bmod 10 = 0$

जहां $\bmod$ मॉड्यूलो ऑपरेशन है।

उपयोग के मामले

लुहन एल्गोरिदम के विभिन्न क्षेत्रों में कई अनुप्रयोग हैं:

1. क्रेडिट कार्ड मान्यता: अधिकांश क्रेडिट कार्ड नंबरों को लुहन एल्गोरिदम का उपयोग करके मान्य किया जाता है।
2. कनाडाई सामाजिक बीमा नंबर: इन पहचान नंबरों की वैधता की जांच करने के लिए लुहन एल्गोरिदम का उपयोग किया जाता है।
3. IMEI नंबर: मोबाइल फोन IMEI नंबरों में एक चेक अंक होता है जिसे लुहन एल्गोरिदम द्वारा मान्य किया जाता है।
4. राष्ट्रीय प्रदाता पहचानकर्ता (NPI) नंबर: ये नंबर संयुक्त राज्य अमेरिका के स्वास्थ्य प्रणाली में उपयोग किए जाते हैं और इन्हें लुहन एल्गोरिदम का उपयोग करके मान्य किया जाता है।
5. ISBNs: कुछ ISBN-10 नंबरों में मान्यता के लिए लुहन एल्गोरिदम का एक रूपांकित उपयोग होता है।

विकल्प

हालांकि लुहन एल्गोरिदम का व्यापक उपयोग होता है, लेकिन विभिन्न उद्देश्यों के लिए अन्य चेकसम एल्गोरिदम भी हैं:

1. डैम एल्गोरिदम: एक अन्य चेक अंक एल्गोरिदम जो सभी एकल अंक की त्रुटियों और सभी सन्निकट स्थानांतरण त्रुटियों का पता लगाता है।
2. वेरहॉफ़ एल्गोरिदम: एक अधिक जटिल चेकसम एल्गोरिदम जो सभी एकल अंक की त्रुटियों और अधिकांश स्थानांतरण त्रुटियों को पकड़ता है।
3. ISBN-13 चेक अंक: ISBN-10 की तुलना में एक अलग एल्गोरिदम का उपयोग करता है, जो लुहन एल्गोरिदम पर आधारित है।

इतिहास

लुहन एल्गोरिदम का निर्माण 1954 में आईबीएम के कंप्यूटर वैज्ञानिक हंस पीटर लुहन द्वारा किया गया था। लुहन सूचना विज्ञान के क्षेत्र में एक अग्रणी थे और उन्हें कई नवाचारों का श्रेय दिया जाता है, जिसमें KWIC (की वर्ड इन कॉन्टेक्स्ट) अनुक्रमण प्रणाली शामिल है।

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

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

कार्यान्वयन उदाहरण

यहां विभिन्न प्रोग्रामिंग भाषाओं में लुहन एल्गोरिदम को लागू करने के कुछ कोड उदाहरण दिए गए हैं:

import random

def luhn_validate(number):
    digits = [int(d) for d in str(number)]
    checksum = 0
    for i in range(len(digits) - 1, -1, -1):
        d = digits[i]
        if (len(digits) - i) % 2 == 0:
            d = d * 2
            if d > 9:
                d -= 9
        checksum += d
    return checksum % 10 == 0

def generate_valid_number(length):
    digits = [random.randint(0, 9) for _ in range(length - 1)]
    checksum = sum(digits[::2]) + sum(sum(divmod(d * 2, 10)) for d in digits[-2::-2])
    check_digit = (10 - (checksum % 10)) % 10
    return int(''.join(map(str, digits + [check_digit])))

## उदाहरण उपयोग:
print(luhn_validate(4532015112830366))  # सत्य
print(luhn_validate(4532015112830367))  # असत्य
print(generate_valid_number(16))  # एक वैध 16-अंक संख्या उत्पन्न करता है

function luhnValidate(number) {
    const digits = number.toString().split('').map(Number);
    let checksum = 0;
    for (let i = digits.length - 1; i >= 0; i--) {
        let d = digits[i];
        if ((digits.length - i) % 2 === 0) {
            d *= 2;
            if (d > 9) d -= 9;
        }
        checksum += d;
    }
    return checksum % 10 === 0;
}

function generateValidNumber(length) {
    const digits = Array.from({length: length - 1}, () => Math.floor(Math.random() * 10));
    const checksum = digits.reduce((sum, digit, index) => {
        if ((length - 1 - index) % 2 === 0) {
            digit *= 2;
            if (digit > 9) digit -= 9;
        }
        return sum + digit;
    }, 0);
    const checkDigit = (10 - (checksum % 10)) % 10;
    return parseInt(digits.join('') + checkDigit);
}

// उदाहरण उपयोग:
console.log(luhnValidate(4532015112830366));  // सत्य
console.log(luhnValidate(4532015112830367));  // असत्य
console.log(generateValidNumber(16));  // एक वैध 16-अंक संख्या उत्पन्न करता है

import java.util.Random;

public class LuhnValidator {
    public static boolean luhnValidate(long number) {
        String digits = String.valueOf(number);
        int checksum = 0;
        boolean isEven = true;
        for (int i = digits.length() - 1; i >= 0; i--) {
            int digit = Character.getNumericValue(digits.charAt(i));
            if (isEven) {
                digit *= 2;
                if (digit > 9) digit -= 9;
            }
            checksum += digit;
            isEven = !isEven;
        }
        return checksum % 10 == 0;
    }

    public static long generateValidNumber(int length) {
        Random random = new Random();
        long[] digits = new long[length - 1];
        for (int i = 0; i < length - 1; i++) {
            digits[i] = random.nextInt(10);
        }
        long checksum = 0;
        for (int i = digits.length - 1; i >= 0; i--) {
            long digit = digits[i];
            if ((length - 1 - i) % 2 == 0) {
                digit *= 2;
                if (digit > 9) digit -= 9;
            }
            checksum += digit;
        }
        long checkDigit = (10 - (checksum % 10)) % 10;
        long result = 0;
        for (long digit : digits) {
            result = result * 10 + digit;
        }
        return result * 10 + checkDigit;
    }

    public static void main(String[] args) {
        System.out.println(luhnValidate(4532015112830366L));  // सत्य
        System.out.println(luhnValidate(4532015112830367L));  // असत्य
        System.out.println(generateValidNumber(16));  // एक वैध 16-अंक संख्या उत्पन्न करता है
    }
}

किनारे के मामले और विशेष विचार

जब लुहन एल्गोरिदम को लागू करते समय, निम्नलिखित किनारे के मामलों और विशेष विचारों पर विचार करें:

1. इनपुट मान्यता: सुनिश्चित करें कि इनपुट एक वैध संख्या स्ट्रिंग है। गैर-अंक वर्णों को उपयुक्त रूप से संभाला जाना चाहिए (या तो हटा दिया जाए या अमान्य इनपुट के रूप में माना जाए)।

2. अग्रणी शून्य: एल्गोरिदम को उन संख्याओं के साथ सही ढंग से काम करना चाहिए जिनमें अग्रणी शून्य हैं।

3. बड़े नंबर: कुछ प्रोग्रामिंग भाषाओं में मानक पूर्णांक प्रकारों की क्षमता से अधिक लंबी संख्याओं को संभालने के लिए तैयार रहें।

4. खाली इनपुट: परिभाषित करें कि आपकी कार्यान्वयन को खाली स्ट्रिंग या शून्य इनपुट को कैसे संभालना चाहिए।

5. गैर-मानक वर्ण सेट: कुछ अनुप्रयोगों में, आप उन संख्याओं का सामना कर सकते हैं जो मानक 0-9 सीमा से बाहर के वर्णों के साथ प्रस्तुत की जाती हैं। परिभाषित करें कि इन्हें कैसे संभाला जाना चाहिए।

6. प्रदर्शन विचार: उन अनुप्रयोगों के लिए जो तेजी से बड़ी संख्या में इनपुट की मान्यता की आवश्यकता होती है, एल्गोरिदम कार्यान्वयन को अनुकूलित करने पर विचार करें।

संख्यात्मक उदाहरण

1. वैध क्रेडिट कार्ड नंबर:

   • संख्या: 4532015112830366
   • लुहन जांच: वैध

2. अमान्य क्रेडिट कार्ड नंबर:

   • संख्या: 4532015112830367
   • लुहन जांच: अमान्य

3. वैध कनाडाई सामाजिक बीमा नंबर:

   • संख्या: 046 454 286
   • लुहन जांच: वैध

4. अमान्य IMEI नंबर:

   • संख्या: 490154203237518
   • लुहन जांच: अमान्य

परीक्षण मामले

लुहन एल्गोरिदम के कार्यान्वयन को सत्यापित करने के लिए, आप निम्नलिखित परीक्षण मामलों का उपयोग कर सकते हैं:

def test_luhn_algorithm():
    assert luhn_validate(4532015112830366) == True
    assert luhn_validate(4532015112830367) == False
    assert luhn_validate(79927398713) == True
    assert luhn_validate(79927398714) == False
    
    # उत्पन्न की गई संख्याओं का परीक्षण
    for _ in range(10):
        assert luhn_validate(generate_valid_number(16)) == True
    
    print("सभी परीक्षण पास हुए!")

test_luhn_algorithm()

संदर्भ

1. लुहन, एच. पी. (1960). "संख्याओं की पुष्टि करने के लिए कंप्यूटर". यूएस पेटेंट 2,950,048।
2. गैलियन, जोसेफ। "पहचान नंबरों की गणित।" कॉलेज गणित जर्नल, खंड 22, संख्या 3, 1991, पृष्ठ 194–202। JSTOR, www.jstor.org/stable/2686878।
3. "ISO/IEC 7812-1:2017"। अंतर्राष्ट्रीय मानक संगठन। 2 अगस्त, 2024 को पुनः प्राप्त किया।
4. क्नुथ, डोनाल्ड। "कंप्यूटर प्रोग्रामिंग की कला, खंड 2: सेमिन्यूमेरिकल एल्गोरिदम"। एडिसन-वेस्ली, 1997।