Luhn-algoritmens kalkylator

Introduktion

Luhn-algoritmen, även känd som "modulus 10" eller "mod 10"-algoritmen, är en enkel kontrollsummaformel som används för att validera en mängd identifieringsnummer, såsom kreditkortsnummer, kanadensiska socialförsäkringsnummer, IMEI-nummer och nationella leverantörsidentifieringsnummer i USA. Denna kalkylator gör det möjligt för dig att validera nummer med hjälp av Luhn-algoritmen och generera giltiga nummer som passerar Luhn-kontrollen.

Hur Luhn-algoritmen fungerar

Luhn-algoritmen fungerar enligt följande:

1. Från den högra siffran (exklusive kontrollsiffran) och rör dig åt vänster, dubbla värdet av varje andra siffra.
2. Om resultatet av denna dubbleringsoperation är större än 9, subtrahera 9 från resultatet.
3. Summera alla siffror i den resulterande sekvensen.
4. Om totalen modulo 10 är lika med 0 (om totalen slutar på noll), då är numret giltigt enligt Luhn-formeln; annars är det inte giltigt.

Här är en visuell representation av Luhn-algoritmen:

Formel

Luhn-algoritmen kan uttryckas matematiskt enligt följande:

Låt $d_i$ vara den $i$:te siffran, räknat från den högra siffran (exklusive kontrollsiffran) och rörande sig åt vänster. Då väljs kontrollsiffran $d_0$ så att:

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

Där $\bmod$ är modulo-operationen.

Användningsområden

Luhn-algoritmen har olika tillämpningar inom olika områden:

1. Validering av kreditkort: De flesta kreditkortsnummer valideras med hjälp av Luhn-algoritmen.
2. Kanadensiska socialförsäkringsnummer: Luhn-algoritmen används för att verifiera giltigheten av dessa identifieringsnummer.
3. IMEI-nummer: Mobiltelefonens IMEI-nummer innehåller en kontrollsiffra som valideras av Luhn-algoritmen.
4. Nationella leverantörsidentifieringsnummer (NPI): Används inom det amerikanska sjukvårdssystemet, dessa nummer valideras med hjälp av Luhn-algoritmen.
5. ISBN: Vissa ISBN-10-nummer använder en variant av Luhn-algoritmen för validering.

Alternativ

Även om Luhn-algoritmen är allmänt använd, finns det andra kontrollsumma-algoritmer för olika syften:

1. Damm-algoritmen: En annan kontrollsiffra-algoritm som upptäcker alla enstaka sifferfel och alla intilliggande transpositionsfel.
2. Verhoeff-algoritmen: En mer komplex kontrollsumma-algoritm som fångar alla enstaka sifferfel och de flesta transpositionsfel.
3. ISBN-13 kontrollsiffra: Använder en annan algoritm än ISBN-10, som baseras på Luhn-algoritmen.

Historia

Luhn-algoritmen skapades av Hans Peter Luhn, en IBM-datorforskare, 1954. Luhn var en pionjär inom informationsvetenskap och krediteras med flera innovationer, inklusive KWIC (Key Word In Context) indexeringssystem.

Algoritmen designades ursprungligen för att skydda mot oavsiktliga fel, inte illvilliga attacker. Det är viktigt att notera att även om Luhn-algoritmen kan upptäcka många vanliga fel, är det inte en säker form av kryptering och bör inte förlita sig på för dataskydd.

Trots sin ålder förblir Luhn-algoritmen allmänt använd på grund av sin enkelhet och effektivitet i att fånga vanliga transkriptionsfel.

Implementeringsexempel

Här är några kodexempel för att implementera Luhn-algoritmen i olika programmeringsspråk:

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## Exempel på användning:
22print(luhn_validate(4532015112830366))  # True
23print(luhn_validate(4532015112830367))  # False
24print(generate_valid_number(16))  # Genererar ett giltigt 16-siffrigt nummer
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// Exempel på användning:
29console.log(luhnValidate(4532015112830366));  // true
30console.log(luhnValidate(4532015112830367));  // false
31console.log(generateValidNumber(16));  // Genererar ett giltigt 16-siffrigt nummer
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));  // Genererar ett giltigt 16-siffrigt nummer
47    }
48}
49

Kantsituationer och särskilda överväganden

När du implementerar Luhn-algoritmen, överväg följande kantsituationer och särskilda överväganden:

1. Inmatningsvalidering: Säkerställ att inmatningen är en giltig nummerserie. Icke-siffriga tecken bör hanteras på lämpligt sätt (antingen tas bort eller behandlas som ogiltig inmatning).

2. Ledande nollor: Algoritmen bör fungera korrekt med nummer som har ledande nollor.

3. Stora nummer: Var beredd att hantera mycket långa nummer som kan överskrida kapaciteten för standard heltalstyper i vissa programmeringsspråk.

4. Tom inmatning: Definiera hur din implementation ska hantera tomma strängar eller null-inmatningar.

5. Icke-standard teckenuppsättningar: I vissa applikationer kan du stöta på nummer som representeras med tecken utanför standard 0-9-intervallet. Definiera hur dessa ska hanteras.

6. Prestandaöverväganden: För applikationer som behöver validera stora mängder inmatningar snabbt, överväg att optimera algoritmimplementationen.

Numeriska exempel

1. Giltigt kreditkortsnummer:

   • Nummer: 4532015112830366
   • Luhn-kontroll: Giltig

2. Ogiltigt kreditkortsnummer:

   • Nummer: 4532015112830367
   • Luhn-kontroll: Ogiltig

3. Giltigt kanadensiskt socialförsäkringsnummer:

   • Nummer: 046 454 286
   • Luhn-kontroll: Giltig

4. Ogiltigt IMEI-nummer:

   • Nummer: 490154203237518
   • Luhn-kontroll: Ogiltig

Testfall

För att verifiera implementeringen av Luhn-algoritmen kan du använda följande testfall:

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    # Testa genererade nummer
8    for _ in range(10):
9        assert luhn_validate(generate_valid_number(16)) == True
10    
11    print("Alla tester passerade!")
12
13test_luhn_algorithm()
14

Referenser

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. Hämtad 2 augusti 2024.
4. Knuth, Donald. "The Art of Computer Programming, Volume 2: Seminumerical Algorithms". Addison-Wesley, 1997.