లున్ ఆల్గోరిథమ్ కేల్కులేటర్

Luhn ఆల్గోరిథం కాలిక్యులేటర్

పరిచయం

Luhn ఆల్గోరిథం, "మోడులస్ 10" లేదా "మోడు 10" ఆల్గోరిథం అని కూడా పిలువబడుతుంది, క్రెడిట్ కార్డ్ నంబర్లు, కెనడియన్ సోషల్ ఇన్సూరెన్స్ నంబర్లు, IMEI నంబర్లు మరియు యునైటెడ్ స్టేట్స్‌లో నేషనల్ ప్రొవైడర్ ఐడెంటిఫైర్ నంబర్ల వంటి వివిధ గుర్తింపు నంబర్లను ధృవీకరించడానికి ఉపయోగించే సరళమైన చెక్‌సమ్ ఫార్ములా. ఈ కాలిక్యులేటర్ Luhn ఆల్గోరిథం ఉపయోగించి నంబర్లను ధృవీకరించడానికి మరియు Luhn చెక్‌ను పాస్ చేసే చెల్లుబాటు నంబర్లను రూపొందించడానికి అనుమతిస్తుంది.

Luhn ఆల్గోరిథం ఎలా పనిచేస్తుంది

Luhn ఆల్గోరిథం ఈ విధంగా పనిచేస్తుంది:

1. కుడి వైపు చివరి అంకె (చెక్ అంకెను మినహాయించి) ప్రారంభించి, ప్రతి రెండవ అంకె యొక్క విలువను డబుల్ చేయండి.
2. ఈ డబ్లింగ్ ఆపరేషన్ ఫలితం 9 కంటే ఎక్కువ అయితే, ఫలితానికి 9ను తీసివేయండి.
3. ఫలితంగా వచ్చిన క్రమంలో అన్ని అంకెలను జోడించండి.
4. మొత్తం మోడులో 10 0 కు సమానం అయితే (మొత్తం 0తో ముగుస్తే), అప్పుడు Luhn ఫార్ములా ప్రకారం సంఖ్య చెల్లుబాటు అవుతుంది; లేకపోతే, ఇది చెల్లుబాటు కాదు.

Luhn ఆల్గోరిథం యొక్క దృశ్య ప్రాతినిధ్యం ఇక్కడ ఉంది:

ఫార్ములా

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$ అనేది మోడులో ఆపరేషన్.

ఉపయోగాల కేసులు

Luhn ఆల్గోరిథం వివిధ రంగాలలో అనేక అనువర్తనాలు కలిగి ఉంది:

1. క్రెడిట్ కార్డ్ ధృవీకరణ: ఎక్కువ క్రెడిట్ కార్డ్ నంబర్లు Luhn ఆల్గోరిథం ఉపయోగించి ధృవీకరించబడతాయి.
2. కెనడియన్ సోషల్ ఇన్సూరెన్స్ నంబర్లు: ఈ గుర్తింపు నంబర్ల చెల్లుబాటును ధృవీకరించడానికి Luhn ఆల్గోరిథం ఉపయోగించబడుతుంది.
3. IMEI నంబర్లు: మొబైల్ ఫోన్ IMEI నంబర్లు Luhn ఆల్గోరిథం ద్వారా ధృవీకరించబడే చెక్ అంకెను కలిగి ఉంటాయి.
4. నేషనల్ ప్రొవైడర్ ఐడెంటిఫైర్ (NPI) నంబర్లు: యునైటెడ్ స్టేట్స్ ఆరోగ్య సంరక్షణ వ్యవస్థలో ఉపయోగించబడే ఈ నంబర్లు Luhn ఆల్గోరిథం ఉపయోగించి ధృవీకరించబడతాయి.
5. ISBNలు: కొన్ని ISBN-10 నంబర్లు ధృవీకరణ కోసం Luhn ఆల్గోరిథం యొక్క ఒక వేరియంట్‌ను ఉపయోగిస్తాయి.

ప్రత్యామ్నాయాలు

Luhn ఆల్గోరిథం విస్తృతంగా ఉపయోగించబడుతున్నప్పటికీ, వివిధ ప్రయోజనాల కోసం ఇతర చెక్ డిజిట్ ఆల్గోరిథమ్‌లు ఉన్నాయి:

1. Damm ఆల్గోరిథం: అన్ని సింగిల్-డిజిట్ పొరపాట్లను మరియు అన్ని పక్కన మార్పిడి పొరపాట్లను గుర్తించగల మరో చెక్ డిజిట్ ఆల్గోరిథం.
2. Verhoeff ఆల్గోరిథం: అన్ని సింగిల్-డిజిట్ పొరపాట్లను మరియు చాలా మార్పిడి పొరపాట్లను పట్టుకునే మరింత సంక్లిష్టమైన చెక్‌సమ్ ఆల్గోరిథం.
3. ISBN-13 చెక్ డిజిట్: ISBN-10 కంటే వేరే ఆల్గోరిథమ్‌ను ఉపయోగిస్తుంది, ఇది Luhn ఆల్గోరిథం ఆధారంగా ఉంటుంది.

చరిత్ర

Luhn ఆల్గోరిథం 1954లో IBM కంప్యూటర్ శాస్త్రవేత్త హాన్స్ పీటర్ లున్ ద్వారా సృష్టించబడింది. Luhn సమాచార శాస్త్రంలో పాయనీర్ మరియు KWIC (కీ వర్డ్ ఇన్ కాంటెక్స్) సూచిక వ్యవస్థ వంటి అనేక ఆవిష్కరణలకు క్రెడిట్ ఇవ్వబడింది.

ఈ ఆల్గోరిథం యాదృచ్ఛిక పొరపాట్లను రక్షించడానికి రూపొందించబడింది, దుష్ట దాడులకు కాదు. Luhn ఆల్గోరిథం అనేక సాధారణ పొరపాట్లను గుర్తించగలిగినా, ఇది భద్రతా సంకేతీకరణకు ఒక భద్రతా రూపం కాదు మరియు డేటా భద్రతా ఉద్దేశాల కోసం నమ్మకంగా ఉండకూడదు.

దాని వయస్సు ఉన్నప్పటికీ, Luhn ఆల్గోరిథం సాధారణ పునరావృత పొరపాట్లను పట్టుకోవడంలో దాని సరళత మరియు ప్రభావిత్వం కారణంగా విస్తృతంగా ఉపయోగించబడుతుంది.

అమలు ఉదాహరణలు

వివిధ ప్రోగ్రామింగ్ భాషలలో Luhn ఆల్గోరిథం అమలుకు కొన్ని కోడ్ ఉదాహరణలు ఇక్కడ ఉన్నాయి:

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-అంకెల సంఖ్యను రూపొందిస్తుంది
    }
}

అంచనా కేసులు మరియు ప్రత్యేక పరిగణనలు

Luhn ఆల్గోరిథం అమలులో, ఈ క్రింది అంచనా కేసులు మరియు ప్రత్యేక పరిగణనలను పరిగణించండి:

1. ఇన్‌పుట్ ధృవీకరణ: ఇన్‌పుట్ ఒక చెల్లుబాటు అయ్యే సంఖ్యా స్ట్రింగ్ అని నిర్ధారించండి. నాన్-డిజిట్ అక్షరాలను సరైన రీతిలో నిర్వహించాలి (తొలగించబడాలి లేదా చెల్లుబాటు కాని ఇన్‌పుట్‌గా పరిగణించాలి).

2. ముందున్న జీరోలు: ముందున్న జీరోలతో ఉన్న సంఖ్యలతో ఆల్గోరిథం సరిగ్గా పనిచేయాలి.

3. పెద్ద సంఖ్యలు: కొన్ని ప్రోగ్రామింగ్ భాషలలో ప్రమాణిత అంకెల రకాలను మించిపోయే చాలా పొడవైన సంఖ్యలను నిర్వహించడానికి సిద్ధంగా ఉండండి.

4. ఖాళీ ఇన్‌పుట్: ఖాళీ స్ట్రింగ్స్ లేదా నల్ ఇన్‌పుట్‌లను మీ అమలుకు ఎలా నిర్వహించాలో నిర్వచించండి.

5. నాన్-స్టాండర్డ్ అక్షర సముదాయాలు: కొన్ని అనువర్తనాలలో, మీరు ప్రమాణిత 0-9 పరిధి వెలుపల అక్షరాలతో ప్రతినిధి చేసిన సంఖ్యలను ఎదుర్కొనవచ్చు. వీటిని ఎలా నిర్వహించాలో నిర్వచించండి.

6. పనితీరు పరిగణనలు: వేగంగా చాలా సంఖ్యల ఇన్‌పుట్‌లను ధృవీకరించాల్సిన అనువర్తనాల కోసం, ఆల్గోరిథం అమలును ఆప్టిమైజ్ చేయాలని పరిగణించండి.

సంఖ్యా ఉదాహరణలు

1. చెల్లుబాటు అయ్యే క్రెడిట్ కార్డ్ నంబర్:

   • సంఖ్య: 4532015112830366
   • Luhn చెక్: చెల్లుబాటు

2. చెల్లుబాటు కాని క్రెడిట్ కార్డ్ నంబర్:

   • సంఖ్య: 4532015112830367
   • Luhn చెక్: చెల్లుబాటు కాదు

3. చెల్లుబాటు అయ్యే కెనడియన్ సోషల్ ఇన్సూరెన్స్ నంబర్:

   • సంఖ్య: 046 454 286
   • Luhn చెక్: చెల్లుబాటు

4. చెల్లుబాటు కాని IMEI నంబర్:

   • సంఖ్య: 490154203237518
   • Luhn చెక్: చెల్లుబాటు కాదు

పరీక్షా కేసులు

Luhn ఆల్గోరిథం అమలును ధృవీకరించడానికి, మీరు క్రింది పరీక్షా కేసులను ఉపయోగించవచ్చు:

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. 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.