Luhn Algoritme Calculator

Luhn Algoritme Calculator

Introductie

Het Luhn-algoritme, ook wel bekend als het "modulus 10" of "mod 10" algoritme, is een eenvoudige controleformule die wordt gebruikt om een verscheidenheid aan identificatienummers te valideren, zoals creditcardnummers, Canadese sociale verzekeringsnummers, IMEI-nummers en nationale zorgverlenersidentificatienummers in de Verenigde Staten. Deze calculator stelt je in staat om nummers te valideren met behulp van het Luhn-algoritme en geldige nummers te genereren die de Luhn-controle doorstaan.

Hoe het Luhn-algoritme werkt

Het Luhn-algoritme werkt als volgt:

1. Begin vanaf het rechtercijfer (uitgezonderd het controlecijfer) en ga naar links, verdubbel de waarde van elk tweede cijfer.
2. Als het resultaat van deze verdubbelingsoperatie groter is dan 9, trek dan 9 van het resultaat af.
3. Tel alle cijfers in de resulterende reeks bij elkaar op.
4. Als de som modulo 10 gelijk is aan 0 (als de som eindigt op nul), dan is het nummer geldig volgens de Luhn-formule; anders is het niet geldig.

Hier is een visuele weergave van het Luhn-algoritme:

Formule

Het Luhn-algoritme kan wiskundig worden uitgedrukt als volgt:

Laat $d_i$ het $i$-de cijfer zijn, tellend vanaf het rechtercijfer (uitgezonderd het controlecijfer) en ga naar links. Dan wordt het controlecijfer $d_0$ gekozen zodat:

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

Waar $\bmod$ de modulo-operatie is.

Toepassingen

Het Luhn-algoritme heeft verschillende toepassingen in verschillende velden:

1. Validatie van creditcardnummers: De meeste creditcardnummers worden gevalideerd met behulp van het Luhn-algoritme.
2. Canadese sociale verzekeringsnummers: Het Luhn-algoritme wordt gebruikt om de geldigheid van deze identificatienummers te verifiëren.
3. IMEI-nummers: Mobiele telefoon IMEI-nummers bevatten een controlecijfer dat wordt gevalideerd door het Luhn-algoritme.
4. Nationale zorgverlenersidentificatienummers (NPI): Gebruikt in het Amerikaanse gezondheidssysteem, deze nummers worden gevalideerd met behulp van het Luhn-algoritme.
5. ISBN's: Sommige ISBN-10-nummers gebruiken een variant van het Luhn-algoritme voor validatie.

Alternatieven

Hoewel het Luhn-algoritme veel wordt gebruikt, zijn er andere controle-algoritmen voor verschillende doeleinden:

1. Damm-algoritme: Een ander controlecijferalgoritme dat alle enkele cijferfouten en alle aangrenzende transpositie-fouten detecteert.
2. Verhoeff-algoritme: Een complexer controle-algoritme dat alle enkele cijferfouten en de meeste transpositie-fouten opvangt.
3. ISBN-13 controlecijfer: Gebruikt een ander algoritme dan ISBN-10, dat is gebaseerd op het Luhn-algoritme.

Geschiedenis

Het Luhn-algoritme werd in 1954 gemaakt door Hans Peter Luhn, een IBM-computerwetenschapper. Luhn was een pionier op het gebied van informatiekunde en wordt gecrediteerd met verschillende innovaties, waaronder het KWIC (Key Word In Context) indexeringssysteem.

Het algoritme was oorspronkelijk ontworpen om te beschermen tegen accidentele fouten, niet tegen kwaadwillige aanvallen. Het is belangrijk op te merken dat hoewel het Luhn-algoritme veel voorkomende fouten kan detecteren, het geen veilige vorm van encryptie is en niet moet worden vertrouwd voor gegevensbeveiligingsdoeleinden.

Ondanks zijn leeftijd blijft het Luhn-algoritme veel gebruikt vanwege de eenvoud en effectiviteit bij het opvangen van veelvoorkomende transcriptiefouten.

Implementatie Voorbeelden

Hier zijn enkele codevoorbeelden om het Luhn-algoritme te implementeren in verschillende programmeertalen:

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

## Voorbeeld gebruik:
print(luhn_validate(4532015112830366))  # True
print(luhn_validate(4532015112830367))  # False
print(generate_valid_number(16))  # Genereert een geldig 16-cijferig nummer

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

// Voorbeeld gebruik:
console.log(luhnValidate(4532015112830366));  // true
console.log(luhnValidate(4532015112830367));  // false
console.log(generateValidNumber(16));  // Genereert een geldig 16-cijferig nummer

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));  // Genereert een geldig 16-cijferig nummer
    }
}

Randgevallen en Speciale Overwegingen

Bij het implementeren van het Luhn-algoritme, overweeg de volgende randgevallen en speciale overwegingen:

1. Invoer Validatie: Zorg ervoor dat de invoer een geldige nummerreeks is. Niet-cijfertekens moeten op de juiste manier worden behandeld (ofwel verwijderd of als ongeldige invoer behandeld).

2. Voorloopnullen: Het algoritme moet correct werken met nummers die voorloopnullen hebben.

3. Grote Nummers: Wees voorbereid om zeer lange nummers te verwerken die mogelijk de capaciteit van standaard integer-typen in sommige programmeertalen overschrijden.

4. Lege Invoer: Definieer hoe jouw implementatie moet omgaan met lege strings of null-invoeren.

5. Niet-standaard Tekenreeksen: In sommige toepassingen kun je nummers tegenkomen die worden weergegeven met tekens buiten het standaard 0-9 bereik. Definieer hoe deze moeten worden behandeld.

6. Prestatie Overwegingen: Voor toepassingen die een groot aantal invoeren snel moeten valideren, overweeg om de algoritme-implementatie te optimaliseren.

Numerieke Voorbeelden

1. Geldig Creditcardnummer:

   • Nummer: 4532015112830366
   • Luhn Controle: Geldig

2. Ongeldig Creditcardnummer:

   • Nummer: 4532015112830367
   • Luhn Controle: Ongeldig

3. Geldig Canadees Sociaal Verzekeringsnummer:

   • Nummer: 046 454 286
   • Luhn Controle: Geldig

4. Ongeldig IMEI-nummer:

   • Nummer: 490154203237518
   • Luhn Controle: Ongeldig

Testgevallen

Om de implementatie van het Luhn-algoritme te verifiëren, kun je de volgende testgevallen gebruiken:

def test_luhn_algorithm():
    assert luhn_validate(4532015112830366) == True
    assert luhn_validate(4532015112830367) == False
    assert luhn_validate(79927398713) == True
    assert luhn_validate(79927398714) == False
    
    # Test gegenereerde nummers
    for _ in range(10):
        assert luhn_validate(generate_valid_number(16)) == True
    
    print("Alle tests geslaagd!")

test_luhn_algorithm()

Referenties

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