Luhno algoritmo skaičiuotuvas - Kredito kortelių ir IMEI numerių tikrinimas

Luhn algoritmo supratimas

Ar reikia patikrinti kredito kortelės numerį arba patvirtinti IMEI? Luhn algoritmas (arba „mod 10 algoritmas") yra kontrolinės sumos formulė, kuri nuo 1954 metų yra mokėjimų tikrinimo pagrindas. IBM mokslininkas Hans Peter Luhn sukūrė šį elegantišką matematinį patikrinimą, kad būtų galima aptikti rašybos klaidas ir transkripcijos klaidas, kurios kyla dėl rankinio duomenų įvedimo – pavyzdžiui, kai netyčia sukeičiami du skaitmenys arba neteisingai įvedamas vienas skaitmuo.

Štai kas daro jį neįkainojamu: kiekvienas pagrindinis kredito kortelių tinklas (Visa, Mastercard, American Express), mobilių įrenginių IMEI numeriai, Kanados socialinio draudimo numeriai ir JAV sveikatos priežiūros teikėjų identifikatoriai remiasi šiuo algoritmu. Kai įvedate kortelės numerį mokėjimo formoje ir jis iš karto atmeta klaidą, tai Luhn patikrinimas veikia.

Šis skaičiuotuvas leidžia patvirtinti bet kokią skaitmenų seką arba generuoti testavimo duomenis, kurie praeina patikrinimą – tai būtina kuriant mokėjimų integracijas arba testuojant identifikavimo sistemas nenaudojant tikrų kliento duomenų.

Kaip naudotis šiuo kalkuliatoriumi

Esamų numerių tikrinimas: Įveskite bet kokią skaitmenų seką – pvz., 16 skaitmenų kredito kortelės ar 15 skaitmenų IMEI – ir spustelėkite „Tikrinti". Iš karto pamatysite, ar ji praeina mod 10 patikrą, taip pat išsamų žingsnių, kaip buvo apdorotas kiekvienas skaitmuo, aprašymą. Tai ypač naudinga derinant mokėjimo formas ar tikrinant, ar duomenys įvesti tiksliai.

Bandomųjų duomenų generavimas: Perjunkite į „Generuoti" režimą, kad sukurtumėte galiojančius bandomuosius numerius bet kokio ilgio. Šie numeriai praeina Luhn patikrą, tačiau nėra tikros, aktyvios kortelės – todėl puikiai tinka kūrimo aplinkoms, kur reikia realistinių bandomųjų atvejų neliečiant gyvų mokėjimo duomenų.

Proceso supratimas: Vizualizacija tiksliai parodo, kas vyksta su kiekvienu skaitmeniu: kurie yra dvigubinami, kada atimama 9, ir kaip galutinė suma nustato galiojimą. Šį vaizdinį grįžtamąjį ryšį aš radau neįkainojamu aiškinant algoritmą komandos nariams ar derinant įgyvendinimą.

Kaip veikia Luhn algoritmas

Algoritmas apdoroja skaičius iš dešinės į kairę, taikydamas paprastą modelį, kuris aptinka daugumą duomenų įvedimo klaidų:

1. Pradėkite nuo dešinės: Paimkite kiekvieną skaitmenį, judėdami į kairę. Kiekvieną antrą skaitmenį padauginkite (tai yra skaičiai lyginėse pozicijose, skaičiuojant nuo dešinės).

2. Tvarkykite didelius daugiklius: Kai dauginimas sukuria skaičių didesnį nei 9, atimkite 9. Tai matematiškai lygiavertė atskirų skaitmenų sumai (18 tampa 1+8=9).

3. Sudėkite viską: Sudėkite visus apdorotus skaitmenis - tiek padaugintus/pakoreguotus, tiek nepakeistus.

4. Patikrinkite dalijamumą: Jei suma dalosi iš 10 (baigiasi 0), skaičius yra teisingas. Bet koks kitas rezultatas reiškia klaidą.

Šio metodo išmintingumas yra tai, kaip jis aptinka įprastas klaidas. Jei sukeičiate du gretimus skaitmenis arba neteisingai įvedate vieną skaičių, kontrolinė suma beveik visada pasikeičia. Algoritmas neaptiks visų įmanomų klaidų - dvigubos klaidos, pvz., keičiant 22 į 55, praeina pro šalį - tačiau jis aptinka maždaug 98% atsitiktinių vieno skaitmens klaidų ir apie 90% gretimų permainų.

Štai vizualus proceso vaizdavimas:

Matematinė formulė

Tiems, kurie mėgsta formalią notaciją, štai matematinis išreiškimas:

Tegul $d_i$ yra $i$-asis skaitmuo, skaičiuojant nuo dešiniausio skaitmens (išskyrus kontrolinį skaitmenį) ir judant į kairę. Tada kontrolinis skaitmuo $d_0$ pasirenkamas taip, kad:

$(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$ yra modulio operacija.

Realaus pasaulio taikymai

Mokėjimų apdorojimas: Kiekvienas pagrindinis kortelių tinklas—Visa, Mastercard, American Express, Discover—naudoja Luhn patikrą kaip pirminę gynybą prieš spausdinimo klaidas. Kurdami atsiskaitymo formą, klientų pusės Luhn patvirtinimas padeda vartotojams išvengti akivaizdžiai neteisingų numerių pateikimo ir sumažina nereikalingus API kreipimosi į mokėjimo tarpininkus.

Mobilių įrenginių sekimas: IMEI numeriai telefonuose ir planšetėse apima Luhn kontrolinį skaitmenį. Tai tampa itin svarbiu elementu tiekimo grandinės valdyme ir įrenginių autentifikavimo sistemose—esu matęs sandėlio sistemas, kurios akimirksniu atmeta neteisingus IMEI nuskaitymus, užkertant kelią siuntimo klaidoms dar prieš joms įvykstant.

Sveikatos priežiūros identifikatoriai: JAV Nacionalinė teikėjų identifikavimo (NPI) sistema patvirtina teikėjų numerius naudodama šį algoritmą. Kasdien vykdant milijonus sveikatos priežiūros operacijų, klaidų aptikimas teikėjų ID srityje padeda išvengti sąskaitų vėlavimo ir sumažina pretenzijų atmetimą.

Vyriausybiniai identifikatoriai: Kanados socialinio draudimo numeriai apima Luhn patvirtinimą. Algoritmas suteikia greitą patikrinimą be duomenų bazės paieškos, todėl yra efektyvus didelės apimties tikrinimo scenarijuose.

Senesnės knygų sistemos: Kai kurios ISBN-10 realizacijos naudoja Luhn variantą. Nors ISBN-13 naudoja kitokį kontrolinio skaitmens algoritmą, senesės bibliotekų ir inventoriaus sistemos vis dar pasikliauja Luhn-pagrindu paremtu patvirtinimu.

Žingsniniai Pavyzdžiai

Kredito Kortelės Numerio Tikrinimas

Patikrinkime numerį 4532015112830366:

1. Pradedant nuo dešinės: 6, 6, 3, 0, 3, 8, 2, 1, 1, 5, 1, 0, 2, 3, 5, 4
2. Padvigubinkime kiekvieną antrą skaitmenį (nuo dešinės): 6, 12, 3, 0, 3, 16, 2, 2, 1, 10, 1, 0, 2, 6, 5, 8
3. Atimkime 9 nuo skaičių > 9: 6, 3, 3, 0, 3, 7, 2, 2, 1, 1, 1, 0, 2, 6, 5, 8
4. Suma: 6+3+3+0+3+7+2+2+1+1+1+0+2+6+5+8 = 50
5. 50 % 10 = 0 ✓ Galiojantis!

Netinkamo IMEI Numerio Aptikimas

Testuojame 490154203237518 (paskutinis skaitmuo tyčia neteisingas):

1. Po dvigubinimo ir apdorojimo: Suma = 57
2. 57 % 10 = 7 ✗ Negaliojantis!

Suma nesibaigia nuliu, todėl algoritmas tai pažymi kaip neteisingą. Kad būtų galiojantis, paskutinis skaitmuo turėtų būti 1, kas sudarytų sumą 60 – idealiai dalomą iš 10. Būtent taip algoritmas aptinka įrenginio identifikatorių perrašymo klaidas.

Alternatyvūs Kontrolinės Sumos Algoritmai

Luhno algoritmas populiarus dėl paprastos realizacijos, tačiau egzistuoja sudėtingesni variantai, kai reikia stipresnės klaidų aptikimo:

Verhoeff algoritmas: Aptinka visas vieno skaitmens klaidas ir beveik visas skaičių sukeitimo klaidas, įskaitant dvigubų skaitmenų atvejus, kurių Luhno algoritmas nepastebėtų (pvz., 22↔55). Kompromisas - didesnė sudėtingumo kaina - reikalauja naudoti daugybos ir permutacijos operacijų lenteles. Naudokite, kai duomenų tikslumas yra kritiškai svarbus ir skaičiavimų našta nėra problema.

Damm algoritmas: Aptinka visas vieno skaitmens klaidas ir visus gretutinių skaičių sukeitimus be išimčių. Pagrįstas specialiai sukonstruota kvazigrupės operacija, užtikrinančia visapusišką padengimą. Realizacija naudoja vieną paieškos lentelę, todėl yra paprastesnė už Verhoeff, bet vis dar sudėtingesnė už Luhno algoritmą.

ISBN-13 kontrolinis skaitmuo: Naudoja svertinį modulo 10 algoritmą, skirtingą nuo Luhno ir ISBN-10. Svoriai kaitaliojasi tarp 1 ir 3, kas užtikrina gerą klaidų aptikimą konkrečiai knygų identifikatoriams. Šis algoritmas pakeitė senesnę ISBN-10 sistemą (kuri naudojo Luhno algoritmą), kai pramonei prireikė daugiau identifikatorių erdvės.

Istorija ir kontekstas

Hansas Peteris Luhnas sukūrė šį algoritmą IBM kompanijoje 1954 metais, ankstyvaisiais automatizuoto duomenų apdorojimo laikais. Luhnas jau buvo žinomas dėl pionierinio darbo informacijos paieškoje — jo KWIC (Raktinius Žodžius Kontekste) indeksavimo sistema iki šiol veikia dokumentų paieškos principus — tačiau mod 10 algoritmas tapo jo reikšmingiausiu indėliu.

Štai esminis skirtumas: Luhnas sukūrė šį algoritmą klaidų aptikimui, o ne saugumui. 1950-aisiais problema buvo kortelių skylučių klaidos ir rankinio perrašymo klaidos, o ne skaitmeninis sukčiavimas. Algoritmas puikiai pagauna atsitiktines rašybos klaidas — tačiau tai nėra kriptografija. Galiojantis Luhno numeris nereiškia, kad kortelė yra aktyvi, finansuojama ar priklauso ją naudojančiam asmeniui.

Nuostabi yra tai, kaip gerai 70 metų senumo algoritmas vis dar atlieka savo pirminę paskirtį. Mokėjimų apdorojimo sistemos prideda šiuolaikines saugumo priemones (tokenizaciją, CVV patikrinimą, 3D Secure), tačiau pradinis Luhno patikrinimas vis dar kasdien sustabdo milijonus akivaizdžių klaidų dar prieš kreipiantis į mokėjimų sąsają.

Įgyvendinimo Pavyzdžiai

Štai kaip įgyvendinti Luhn validaciją ir generavimą Python, JavaScript ir Java kalbomis. Šie pavyzdžiai prioritetą teikia skaitomumui, išlaikant efektyvumą:

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## Naudojimo pavyzdys:
22
23print(luhn_validate(4532015112830366))  # Tiesa
24print(luhn_validate(4532015112830367))  # Netiesa
25print(generate_valid_number(16))  # Generuoja galiojantį 16 skaitmenų numerį
26

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// Naudojimo pavyzdys:
29console.log(luhnValidate(4532015112830366));  // tiesa
30console.log(luhnValidate(4532015112830367));  // netiesa
31console.log(generateValidNumber(16));  // Generuoja galiojantį 16 skaitmenų numerį
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));  // tiesa
45        System.out.println(luhnValidate(4532015112830367L));  // netiesa
46        System.out.println(generateValidNumber(16));  // Generuoja galiojantį 16 skaitmenų numerį
47    }
48}
49

Kraštiniai atvejai ir realizacijos spąstai

Įgyvendinant Luhn validaciją gamybinėse sistemose, atkreipkite dėmesį į šias dažniausias problemas:

Įvesties sanitizavimas: Realiame pasaulyje įvestis dažnai apima tarpus, brūkšnelius ar kitus formatavimo simbolius (pvz., "4532-0151-1128-3036"). Pašalinkite juos prieš validaciją, o ne atmeskite įvestį — vartotojai dažnai kopijuoja suformatuotus numerius. Tačiau nedelsdami atmeskite abėcėlinius simbolius, nes jie rodo akivaizdžiai neteisingą įvestį.

Pradiniai nuliai yra svarbūs: Skaičius "0123456789" skiriasi nuo "123456789" Luhn tikrinimo požiūriu. Pradiniai nuliai turi būti išsaugoti validacijos metu. Tai suklaidina programuotojus, kurie pirmiausia konvertuoja į sveikuosius skaičius — vietoj to naudokite eilučių operacijas.

Kalbos sveikųjų skaičių ribos: Kredito kortelės paprastai turi ne daugiau kaip 19 skaitmenų, kas telpa į 64 bitų sveikąjį skaičių. Tačiau jei tikrinate bet kokio ilgio identifikatorius, vengkite konvertavimo į sveikuosius skaičius. Apdorokite kaip eilutes arba skaitmenų masyvus, kad išvengtumėte perpildymo.

Tuščia arba nulinė įvestis: Aiškiai apibrėžkite savo elgseną: mesti išimtį, grąžinti klaidą ar tvarkyti sklandžiai? Radau, kad grąžinant klaidą validacijos funkcijoms atrodo logiškiausia, tačiau API galūnės gali norėti grąžinti 400 klaidą su aprašomuoju pranešimu.

Našumas dideliu mastu: Atliekant grupinę validaciją (pvz., apdorojant įkeltus CSV failus su tūkstančiais kortelių numerių), pagrindinis algoritmas jau yra pakankamai greitas — O(n), kur n yra skaitmenų skaičius. Siauras vietas paprastai sudaro I/O, o ne skaičiavimai. Optimizavimą sutelkite į failo analizę ir klaidų pranešimą, o ne į validacijos logiką.

Greitas žinynas: Tikrinimo numeriai

Naudokite šiuos numerius testuodami savo realizaciją:

Galiojantys numeriai:

• 4532015112830366 — Visa formatas (16 skaitmenų)
• 046454286 — Kanadietiškas SIN formatas (9 skaitmenys)
• 79927398713 — Bendras galiojantis numeris

Negaliojantys numeriai:

• 4532015112830367 — Skiriasi vienu skaitmeniu
• 490154203237518 — Neteisingas kontrolinis skaitmuo
• 79927398714 — Paskutinis skaitmuo neteisingas

Šie testavimo atvejai apima įprastas situacijas: standartinius galiojančius numerius, vieno skaitmens klaidas ir neteisingus kontrolinius skaitmenis.

Automatizuotas Testavimo Rinkinys

Čia pateikiamas išsamus testavimo rinkinys, skirtas patikrinti jūsų realizaciją:

1def test_luhn_algoritmas():
2    # Pagrindiniai validavimo testai
3    assert luhn_validate(4532015112830366) == True
4    assert luhn_validate(4532015112830367) == False
5    assert luhn_validate(79927398713) == True
6    assert luhn_validate(79927398714) == False
7
8    # Patikrinti, ar sugeneruoti skaičiai praeina validaciją
9    for _ in range(10):
10        sugeneruotas = generate_valid_number(16)
11        assert luhn_validate(sugeneruotas) == True, f"Sugeneruotas {sugeneruotas} nepraėjo validacijos"
12
13    # Ribinis atvejis: vienas skaitmuo
14    assert luhn_validate(0) == True  # 0 mod 10 = 0
15
16    # Ribinis atvejis: išlaikomi pradiniai nuliai
17    assert luhn_validate("0000000000000000") != luhn_validate(0)
18
19    print("Visi testai sėkmingai įvykdyti!")
20
21test_luhn_algoritmas()
22

Dažniausiai užduodami klausimai

Kam naudojamas Luhn algoritmas?

Luhn algoritmas tikrina identifikavimo numerius, įskaitant kredito korteles (Visa, Mastercard, Amex), mobilių įrenginių IMEI numerius, Kanados socialinio draudimo numerius ir JAV sveikatos priežiūros NPI numerius. Jis aptinka įprastas duomenų įvedimo klaidas — tokias kaip neteisingai įvesti skaitmenys ar atsitiktinai sukeisti numeriai — prieš jiems sukeliant apdorojimo klaidas ar nepavykusius sandorius.

Koks tikslus Luhn algoritmas yra aptinkant klaidas?

Luhn aptinka apytiksliai 98% vieno skaitmens klaidų ir apie 90% gretimų permutacijų klaidų (pvz., renkant „12" vietoj „21"). Tačiau jis praleižia dvynių klaidas, kai abu skaitmenys yra tokie patys (22→55) ir šuolinius perkėlimus (101→404). Daugumai praktinių programų, susijusių su rankiniu duomenų įvedimu, šis aptikimo lygis yra pakankamas.

Ar galiu tikrinti kredito korteles neprisijungus naudodamas Luhn algoritmą?

Taip, Luhn tikrinimas veikia visiškai neprisijungus — tai grynai matematinis metodas, nereikalaujantis duomenų bazės paieškų ar API iškvietimų. Tai daro jį idealiu klientų pusės tikrinimui žiniatinklio formose, sumažinant serverio apkrovą ir teikiant momentinį grįžtamąjį ryšį vartotojams. Tačiau atminkite: galiojantis Luhn numeris nereiškia, kad kortelė yra aktyvi ar turi prieinamą kreditą.

Ar Luhn algoritmas saugus mokėjimų apdorojimui?

Ne — Luhn yra klaidų aptikimas, o ne saugumas. Jis tikrina tik matematinį formatą. Sėkmingas Luhn patikrinimas nepatvirtina, kad kortelė yra tikra, aktyvi, finansuojama ar priklauso vartotojui. Šiuolaikinis mokėjimų saugumas reikalauja kelių sluoksnių: CVV/CVC tikrinimo, adreso patvirtinimo (AVS), 3D Secure autentifikavimo ir tokenizacijos. Luhn yra tik pirmasis sveikatos patikrinimas.

Kokios programavimo kalbos palaiko Luhn įgyvendinimą?

Kiekviena bendrosios paskirties kalba gali įgyvendinti Luhn — tai paprastas algoritmas, reikalaujantis tik pagrindinių aritmetinių veiksmų ir ciklų. Python, JavaScript, Java, C++, C#, PHP, Ruby, Go, Rust ir Swift lengvai tvarko jį 10-20 kodo eilučių. Kai kurios kalbos turi trečiųjų šalių bibliotekas, tačiau algoritmas yra pakankamai paprastas, kad dauguma kūrėjų jį įgyvendintų tiesiogiai.

Kodėl jis vadinamas mod 10 algoritmu?

Paskutinis žingsnis tikrina, ar skaitmenų suma dalijasi iš 10 naudojant modulio operaciją (suma % 10 == 0). „Mod 10" nurodo šį modulio 10 patikrinimą. Jei likutis yra nulis dalijant iš 10, numeris praeina — priešingu atveju jis nepavyksta. Šis matematinis požymis yra tai, kas daro algoritmą veikiantį.

Ar galiu generuoti bandomuosius kredito kortelių numerius su Luhn?

Taip — galite generuoti numerius, kurie praeina Luhn patikrinimą, testuojant mokėjimų formas kūrimo metu. Tai nėra tikros, aktyvios kortelės; jos tiesiog atitinka matematinį formatą. Tai yra teisėta ir būtina testavimui, tačiau bandymas naudoti sugeneruotus numerius faktiniams pirkimams yra sukčiavimas. Dauguma mokėjimų tarpininkų siūlo oficialius bandomuosius kortelių numerius bandomosioms aplinkoms.

Kokios Luhn algoritmo ribos?

Luhn neaptiks: dvynių klaidų (22↔55), šuolinių permutacijų (101↔404), fonetinių klaidų (60↔06 kai kuriais atvejais) ar kelių vienu metu įvykstančių klaidų. Jis taip pat nesuteikia jokios kriptografinės apsaugos — galiojantis formatas nereiškia galiojančios kortelės. Nepaisant šių apribojimų, jo paprastumas ir daugiau nei 90% klaidų aptikimo lygis daro jį praktiška realiųjų mokėjimų sistemose, kai jis derinamas su kitais tikrinimo metodais.

Pradėkite Skaičių Tikrinimą

Naudokite aukščiau esantį skaičiuotuvą kredito kortelių numerių tikrinimui, testinių duomenų generavimui kūrimo aplinkoms arba mod 10 algoritmo skaitmenų apdorojimo tyrimui. Žingsnis po žingsnio vizualizacija padeda derinti realizacijos problemas ir paaiškina tikrinimo rezultatus netechniniams suinteresuotiems asmenims.

Nesvarbu, ar kuriate mokėjimo formą, deriate IMEI tikrinimo sistemą, ar tiesiog mokotės apie kontrolinių sumų algoritmus, šis įrankis suteikia momentinį grįžtamąjį ryšį ir techninį skaidrumą, kurio jums reikia.

Nuorodos ir papildoma literatūra

1. Luhn, H. P. (1960). "Kompiuteris numerių tikrinimui". JAV patentas 2,950,048 - Originalus patentas, aprašantis algoritmą.

2. ISO/IEC 7812-1:2017 - Identifikavimo kortelės - Tarptautinis standartas identifikavimo kortelių numeravimo sistemoms, nurodantis Luhn naudojimą mokėjimo kortelėse.

3. Gallian, Joseph (1991). "Identifikavimo numerių matematika" - Akademinė įvairių kontrolinių skaitmenų algoritmų, įskaitant Luhn, analizė, publikuota žurnale "The College Mathematics Journal".

4. Mokėjimo kortelių pramonės duomenų saugumo standartas (PCI DSS) - Saugumo standartai, reglamentuojantys mokėjimo kortelių duomenų tvarkymo būdą, suteikiantys kontekstą, kur Luhn algoritmas taikomas saugumo sistemoje.