लुहन अल्गोरिदम कॅल्क्युलेटर

लुहन अल्गोरिदम कॅल्क्युलेटर

परिचय

लुहन अल्गोरिदम, ज्याला "मॉड्युलस 10" किंवा "मॉड 10" अल्गोरिदम म्हणूनही ओळखले जाते, हा एक साधा चेकसम सूत्र आहे जो विविध ओळख क्रमांकांचे प्रमाणित करण्यासाठी वापरला जातो, जसे की क्रेडिट कार्ड क्रमांक, कॅनेडियन सोशल इन्शुरन्स क्रमांक, IMEI क्रमांक, आणि अमेरिकेत राष्ट्रीय प्रदाता ओळख क्रमांक. हा कॅल्क्युलेटर तुम्हाला लुहन अल्गोरिदमचा वापर करून क्रमांकांची वैधता तपासण्याची आणि लुहन चेक पास करणारे वैध क्रमांक तयार करण्याची परवानगी देतो.

लुहन अल्गोरिदम कसा कार्य करतो

लुहन अल्गोरिदम खालीलप्रमाणे कार्य करतो:

1. उजव्या बाजूच्या सर्वात उजव्या अंकापासून (चेक अंक वगळून) सुरुवात करून, प्रत्येक दुसऱ्या अंकाचे मूल्य दुप्पट करा.
2. जर या दुप्पट ऑपरेशनचा परिणाम 9 पेक्षा जास्त असेल, तर परिणामातून 9 वजा करा.
3. परिणामी अनुक्रमातील सर्व अंकांची बेरीज करा.
4. जर एकूण % 10 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 मध्ये IBM च्या संगणक शास्त्रज्ञ हंस पीटर लुहनने तयार केला. लुहन माहिती विज्ञानाच्या क्षेत्रात एक पायनियर होता आणि 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))  # True
print(luhn_validate(4532015112830367))  # False
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));  // true
console.log(luhnValidate(4532015112830367));  // false
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));  // true
        System.out.println(luhnValidate(4532015112830367L));  // false
        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.