Luhn Algorithm Calculator

Introduction

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

How the Luhn Algorithm Works

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

1. उजव्या बाजूच्या सर्वात उजवीच्या अंकापासून (चेक अंक वगळता) सुरुवात करा आणि प्रत्येक दुसऱ्या अंकाचे मूल्य दुप्पट करा.
2. जर या दुप्पट ऑपरेशनचा परिणाम 9 पेक्षा जास्त असेल, तर परिणामातून 9 वजा करा.
3. परिणामी अनुक्रमातील सर्व अंकांची बेरीज करा.
4. जर एकूण modulo 10 0 च्या समकक्ष असेल (जर एकूण शून्यावर संपत असेल), तर संख्या Luhn फॉर्म्युलानुसार वैध आहे; अन्यथा, ती वैध नाही.

Luhn अल्गोरिदमचे दृश्य प्रतिनिधित्व येथे आहे:

Formula

Luhn अल्गोरिदम गणितीयदृष्ट्या खालीलप्रमाणे व्यक्त केला जाऊ शकतो:

$(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$ हा मॉड्युलो ऑपरेशन आहे.

Use Cases

Luhn अल्गोरिदमचे विविध क्षेत्रांमध्ये अनेक अनुप्रयोग आहेत:

1. क्रेडिट कार्ड वैधता: बहुतेक क्रेडिट कार्ड क्रमांक Luhn अल्गोरिदम वापरून वैध केले जातात.
2. कॅनेडियन सोशल इन्शुरन्स क्रमांक: या ओळख क्रमांकांची वैधता तपासण्यासाठी Luhn अल्गोरिदमचा वापर केला जातो.
3. IMEI क्रमांक: मोबाइल फोन IMEI क्रमांक एक चेक अंक समाविष्ट करतो जो Luhn अल्गोरिदमद्वारे वैध केला जातो.
4. राष्ट्रीय प्रदाता ओळख (NPI) क्रमांक: युनायटेड स्टेट्सच्या आरोग्य प्रणालीमध्ये वापरले जाणारे, या क्रमांकांची वैधता Luhn अल्गोरिदम वापरून तपासली जाते.
5. ISBNs: काही ISBN-10 क्रमांक वैधतेसाठी Luhn अल्गोरिदमचा एक प्रकार वापरतात.

Alternatives

Luhn अल्गोरिदम सामान्यतः वापरला जात असला तरी, विविध उद्देशांसाठी इतर चेकसम अल्गोरिदम आहेत:

1. Damm अल्गोरिदम: एक अन्य चेक अंक अल्गोरिदम जो सर्व एकल अंक त्रुटी आणि सर्व शेजारील ट्रान्स्पोजिशन त्रुटी शोधतो.
2. Verhoeff अल्गोरिदम: एक अधिक जटिल चेकसम अल्गोरिदम जो सर्व एकल अंक त्रुटी आणि बहुतेक ट्रान्स्पोजिशन त्रुटी पकडतो.
3. ISBN-13 चेक अंक: ISBN-10 पेक्षा भिन्न अल्गोरिदम वापरतो, जो Luhn अल्गोरिदमवर आधारित आहे.

History

Luhn अल्गोरिदम 1954 मध्ये IBM च्या संगणक शास्त्रज्ञ हंस पीटर लुहनने तयार केला. लुहन माहिती विज्ञानाच्या क्षेत्रातील एक पायनियर होते आणि KWIC (की वर्ड इन कॉन्टेक्स्ट) अनुक्रमणिका प्रणालीसह अनेक नवकल्पनांसाठी श्रेय दिले जाते.

हा अल्गोरिदम आकस्मिक त्रुटींविरुद्ध संरक्षण करण्यासाठी डिझाइन केला गेला होता, दुष्ट हल्ल्यांविरुद्ध नाही. हे लक्षात घेणे महत्त्वाचे आहे की, जरी Luhn अल्गोरिदम अनेक सामान्य त्रुटी शोधू शकतो, तरीही हे डेटा सुरक्षा उद्देशांसाठी सुरक्षित स्वरूप नाही आणि यावर अवलंबून राहू नये.

त्याच्या वयाच्या बाबतीत, Luhn अल्गोरिदम त्याच्या साधेपणामुळे आणि सामान्य ट्रान्सक्रिप्शन त्रुटी पकडण्यात प्रभावी असल्यामुळे व्यापकपणे वापरला जातो.

Implementation Examples

येथे विविध प्रोग्रामिंग भाषांमध्ये Luhn अल्गोरिदम लागू करण्याचे काही कोड उदाहरणे आहेत:

1import random
2
3def luhn_validate(number):
4    digits = [int(d) for d in str(number)]
5    checksum = 0
6    for i in range(len(digits) - 1, -1, -1):
7        d = digits[i]
8        if (len(digits) - i) % 2 == 0:
9            d = d * 2
10            if d > 9:
11                d -= 9
12        checksum += d
13    return checksum % 10 == 0
14
15def generate_valid_number(length):
16    digits = [random.randint(0, 9) for _ in range(length - 1)]
17    checksum = sum(digits[::2]) + sum(sum(divmod(d * 2, 10)) for d in digits[-2::-2])
18    check_digit = (10 - (checksum % 10)) % 10
19    return int(''.join(map(str, digits + [check_digit])))
20
21## Example usage:
22print(luhn_validate(4532015112830366))  # True
23print(luhn_validate(4532015112830367))  # False
24print(generate_valid_number(16))  # Generates a valid 16-digit number
25

1function luhnValidate(number) {
2    const digits = number.toString().split('').map(Number);
3    let checksum = 0;
4    for (let i = digits.length - 1; i >= 0; i--) {
5        let d = digits[i];
6        if ((digits.length - i) % 2 === 0) {
7            d *= 2;
8            if (d > 9) d -= 9;
9        }
10        checksum += d;
11    }
12    return checksum % 10 === 0;
13}
14
15function generateValidNumber(length) {
16    const digits = Array.from({length: length - 1}, () => Math.floor(Math.random() * 10));
17    const checksum = digits.reduce((sum, digit, index) => {
18        if ((length - 1 - index) % 2 === 0) {
19            digit *= 2;
20            if (digit > 9) digit -= 9;
21        }
22        return sum + digit;
23    }, 0);
24    const checkDigit = (10 - (checksum % 10)) % 10;
25    return parseInt(digits.join('') + checkDigit);
26}
27
28// Example usage:
29console.log(luhnValidate(4532015112830366));  // true
30console.log(luhnValidate(4532015112830367));  // false
31console.log(generateValidNumber(16));  // Generates a valid 16-digit number
32

1import java.util.Random;
2
3public class LuhnValidator {
4    public static boolean luhnValidate(long number) {
5        String digits = String.valueOf(number);
6        int checksum = 0;
7        boolean isEven = true;
8        for (int i = digits.length() - 1; i >= 0; i--) {
9            int digit = Character.getNumericValue(digits.charAt(i));
10            if (isEven) {
11                digit *= 2;
12                if (digit > 9) digit -= 9;
13            }
14            checksum += digit;
15            isEven = !isEven;
16        }
17        return checksum % 10 == 0;
18    }
19
20    public static long generateValidNumber(int length) {
21        Random random = new Random();
22        long[] digits = new long[length - 1];
23        for (int i = 0; i < length - 1; i++) {
24            digits[i] = random.nextInt(10);
25        }
26        long checksum = 0;
27        for (int i = digits.length - 1; i >= 0; i--) {
28            long digit = digits[i];
29            if ((length - 1 - i) % 2 == 0) {
30                digit *= 2;
31                if (digit > 9) digit -= 9;
32            }
33            checksum += digit;
34        }
35        long checkDigit = (10 - (checksum % 10)) % 10;
36        long result = 0;
37        for (long digit : digits) {
38            result = result * 10 + digit;
39        }
40        return result * 10 + checkDigit;
41    }
42
43    public static void main(String[] args) {
44        System.out.println(luhnValidate(4532015112830366L));  // true
45        System.out.println(luhnValidate(4532015112830367L));  // false
46        System.out.println(generateValidNumber(16));  // Generates a valid 16-digit number
47    }
48}
49

Edge Cases and Special Considerations

Luhn अल्गोरिदम लागू करताना, खालील कड्यांवर आणि विशेष विचारांवर लक्ष द्या:

1. इनपुट वैधता: सुनिश्चित करा की इनपुट एक वैध संख्या स्ट्रिंग आहे. नॉन-डिजिट वर्ण योग्यरित्या हाताळले पाहिजेत (किंवा काढले पाहिजेत किंवा अमान्य इनपुट म्हणून विचारले पाहिजेत).

2. लीडिंग झिरोज: अल्गोरिदम लीडिंग झिरो असलेल्या क्रमांकांसह योग्यरित्या कार्य करावा.

3. मोठे क्रमांक: काही प्रोग्रामिंग भाषांमध्ये मानक पूर्णांक प्रकारांच्या क्षमतेसाठी ओलांडणारे खूप लांब क्रमांक हाताळण्यासाठी तयार रहा.

4. रिक्त इनपुट: तुमच्या अंमलबजावणीने रिक्त स्ट्रिंग किंवा नल इनपुट कसे हाताळावे हे परिभाषित करा.

5. नॉन-स्टँडर्ड कॅरेक्टर सेट: काही अनुप्रयोगांमध्ये, तुम्हाला मानक 0-9 श्रेणीच्या बाहेर वर्णांसह दर्शविलेले क्रमांक आढळू शकतात. हे कसे हाताळले जावे हे परिभाषित करा.

6. कार्यक्षमता विचार: ज्या अनुप्रयोगांना जलदपणे मोठ्या संख्येच्या इनपुट्सची वैधता तपासण्याची आवश्यकता आहे, त्यांच्यासाठी अल्गोरिदमची अंमलबजावणी ऑप्टिमाइझ करण्याचा विचार करा.

Numerical Examples

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

   • क्रमांक: 4532015112830366
   • Luhn चेक: वैध

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

   • क्रमांक: 4532015112830367
   • Luhn चेक: अमान्य

3. वैध कॅनेडियन सोशल इन्शुरन्स क्रमांक:

   • क्रमांक: 046 454 286
   • Luhn चेक: वैध

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

   • क्रमांक: 490154203237518
   • Luhn चेक: अमान्य

Test Cases

Luhn अल्गोरिदमची अंमलबजावणी सत्यापित करण्यासाठी, तुम्ही खालील चाचणी प्रकरणांचा वापर करू शकता:

1def test_luhn_algorithm():
2    assert luhn_validate(4532015112830366) == True
3    assert luhn_validate(4532015112830367) == False
4    assert luhn_validate(79927398713) == True
5    assert luhn_validate(79927398714) == False
6    
7    # Test generated numbers
8    for _ in range(10):
9        assert luhn_validate(generate_valid_number(16)) == True
10    
11    print("All tests passed!")
12
13test_luhn_algorithm()
14

References

1. Luhn, H. P. (1960). "Computer for Verifying Numbers". US Patent 2,950,048.
2. Gallian, Joseph. "The Mathematics of Identification Numbers." The College Mathematics Journal, vol. 22, no. 3, 1991, pp. 194–202. JSTOR, www.jstor.org/stable/2686878.
3. "ISO/IEC 7812-1:2017". International Organization for Standardization. Retrieved August 2, 2024.
4. Knuth, Donald. "The Art of Computer Programming, Volume 2: Seminumerical Algorithms". Addison-Wesley, 1997.