Luhn algoritma kalkulators

Luhn algoritma kalkulators

Ievads

Luhn algoritms, pazīstams arī kā "modulus 10" vai "mod 10" algoritms, ir vienkārša kontrolsumma, ko izmanto, lai validētu dažādas identifikācijas numurus, piemēram, kredītkaršu numurus, Kanādas sociālās apdrošināšanas numurus, IMEI numurus un Nacionālo pakalpojumu identifikatoru numurus Amerikas Savienotajās Valstīs. Šis kalkulators ļauj jums validēt numurus, izmantojot Luhn algoritmu, un ģenerēt derīgus numurus, kas iztur Luhn pārbaudi.

Kā darbojas Luhn algoritms

Luhn algoritms darbojas šādi:

1. Sākot no labējā malējā cipara (izņemot kontrolciparu) un virzoties pa kreisi, divkāršojiet katra otra cipara vērtību.
2. Ja šī divkāršošanas operācija ir lielāka par 9, no rezultāta atņemiet 9.
3. Saskaitiet visus ciparus iegūtajā secībā.
4. Ja kopējā summa modulo 10 ir vienāda ar 0 (ja kopējā summa beidzas ar nulli), tad numurs ir derīgs saskaņā ar Luhn formulu; pretējā gadījumā tas nav derīgs.

Šeit ir vizuāls Luhn algoritma attēlojums:

Formula

Luhn algoritmu var izteikt matemātiski šādi:

Lai $d_i$ būtu $i$-tais cipars, skaitot no labējā malējā cipara (izņemot kontrolciparu) un virzoties pa kreisi. Tad kontrolcipars $d_0$ tiek izvēlēts tā, lai:

$(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$

Kur $\bmod$ ir modulo operācija.

Lietošanas gadījumi

Luhn algoritmam ir dažādas pielietošanas jomas dažādās nozarēs:

1. Kredītkaršu validācija: Lielākā daļa kredītkaršu numuru tiek validēti, izmantojot Luhn algoritmu.
2. Kanādas sociālās apdrošināšanas numuri: Luhn algoritms tiek izmantots, lai pārbaudītu šo identifikācijas numuru derīgumu.
3. IMEI numuri: Mobilā telefona IMEI numuri ietver kontrolciparu, ko validē Luhn algoritms.
4. Nacionālo pakalpojumu identifikatora (NPI) numuri: Lietots ASV veselības aprūpes sistēmā, šie numuri tiek validēti, izmantojot Luhn algoritmu.
5. ISBN: Daži ISBN-10 numuri izmanto Luhn algoritma variantu validācijai.

Alternatīvas

Lai gan Luhn algoritms ir plaši izmantots, ir arī citi kontrolciparu algoritmi dažādiem mērķiem:

1. Damm algoritms: Vēl viens kontrolciparu algoritms, kas atklāj visas vienciparu kļūdas un visas blakus transpozīcijas kļūdas.
2. Verhoeff algoritms: Sarežģītāks kontrolciparu algoritms, kas atklāj visas vienciparu kļūdas un lielāko daļu transpozīcijas kļūdu.
3. ISBN-13 kontrolcipars: Izmanto citu algoritmu nekā ISBN-10, kas balstās uz Luhn algoritmu.

Vēsture

Luhn algoritmu izveidoja Hanss Pēters Luhns, IBM datorzinātnieks, 1954. gadā. Luhns bija informācijas zinātnes jomas pionieris un ir kredīts vairākiem jauninājumiem, tostarp KWIC (Key Word In Context) indeksēšanas sistēmai.

Algoritms sākotnēji tika izstrādāts, lai pasargātu no nejaušām kļūdām, nevis ļaunprātīgiem uzbrukumiem. Ir svarīgi atzīmēt, ka, lai gan Luhn algoritms var atklāt daudzus izplatītus kļūdu gadījumus, tas nav droša šifrēšanas forma un to nedrīkst izmantot datu drošības nolūkiem.

Neskatoties uz savu vecumu, Luhn algoritms joprojām ir plaši izmantots, pateicoties tā vienkāršībai un efektivitātei, atklājot izplatītas transkripcijas kļūdas.

Ieviešanas piemēri

Šeit ir daži koda piemēri, kā ieviest Luhn algoritmu dažādās programmēšanas valodās:

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])))

## Piemēra izmantošana:
print(luhn_validate(4532015112830366))  # True
print(luhn_validate(4532015112830367))  # False
print(generate_valid_number(16))  # Ģenerē derīgu 16 ciparu numuru

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);
}

// Piemēra izmantošana:
console.log(luhnValidate(4532015112830366));  // true
console.log(luhnValidate(4532015112830367));  // false
console.log(generateValidNumber(16));  // Ģenerē derīgu 16 ciparu numuru

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));  // Ģenerē derīgu 16 ciparu numuru
    }
}

Malu gadījumi un īpašas apsvērumi

Izmantojot Luhn algoritmu, ņemiet vērā šādus malu gadījumus un īpašas apsvērumus:

1. Ievades validācija: Pārliecinieties, ka ievade ir derīgs ciparu virkne. Ne-ciparu rakstzīmes jāapstrādā atbilstoši (vai nu jānoņem, vai arī jāuzskata par nederīgu ievadi).

2. Vadošie nulles: Algoritmam vajadzētu pareizi darboties ar numuriem, kuriem ir vadošās nulles.

3. Lieli numuri: Esiet gatavi apstrādāt ļoti garus numurus, kas var pārsniegt dažās programmēšanas valodās standarta veselo skaitļu tipu jaudu.

4. Tukša ievade: Definējiet, kā jūsu ieviešana rīkosies ar tukšām virknēm vai nulles ievadēm.

5. Ne-standarta rakstzīmju kopas: Dažās lietojumprogrammās jūs varat sastapt numurus, kas attēloti ar rakstzīmēm ārpus standarta 0-9 diapazona. Definējiet, kā šos jāapstrādā.

6. Veiktspējas apsvērumi: Lietojumprogrammām, kas ātri jāvalidē liels skaits ievades, apsveriet algoritma ieviešanas optimizāciju.

Ciparu piemēri

1. Derīgs kredītkaršu numurs:

   • Numurs: 4532015112830366
   • Luhn pārbaude: Derīgs

2. Nederīgs kredītkaršu numurs:

   • Numurs: 4532015112830367
   • Luhn pārbaude: Nederīgs

3. Derīgs Kanādas sociālās apdrošināšanas numurs:

   • Numurs: 046 454 286
   • Luhn pārbaude: Derīgs

4. Nederīgs IMEI numurs:

   • Numurs: 490154203237518
   • Luhn pārbaude: Nederīgs

Testa gadījumi

Lai pārbaudītu Luhn algoritma ieviešanu, varat izmantot šādus testa gadījumus:

def test_luhn_algorithm():
    assert luhn_validate(4532015112830366) == True
    assert luhn_validate(4532015112830367) == False
    assert luhn_validate(79927398713) == True
    assert luhn_validate(79927398714) == False
    
    # Testa ģenerētie numuri
    for _ in range(10):
        assert luhn_validate(generate_valid_number(16)) == True
    
    print("Visi testi izturēti!")

test_luhn_algorithm()

Atsauces

1. Luhn, H. P. (1960). "Dators numuru pārbaudei". ASV patents 2,950,048.
2. Gallian, Joseph. "Identifikācijas numuru matemātika." Koledžas matemātikas žurnāls, vol. 22, nr. 3, 1991, pp. 194–202. JSTOR, www.jstor.org/stable/2686878.
3. "ISO/IEC 7812-1:2017". Starptautiskā standartizācijas organizācija. Iegūts 2024. gada 2. augustā.
4. Knuth, Donald. "Datoru programmēšanas māksla, 2. sējums: Seminumera algoritmi". Addison-Wesley, 1997.