லூன் அல்கொரிதம் கணக்கீட்டாளர்

லூன் அல்கொரிதம் கணக்கீட்டாளர்

அறிமுகம்

லூன் அல்கொரிதம், "மாடுலஸ் 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. ISBN-கள்: சில 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.