Luhn-Algorithmus Rechner

Luhn-Algorithmus Rechner

Einführung

Der Luhn-Algorithmus, auch bekannt als "Modulus 10" oder "mod 10" Algorithmus, ist eine einfache Prüfziffernformel, die verwendet wird, um eine Vielzahl von Identifikationsnummern zu validieren, wie z.B. Kreditkartennummern, kanadische Sozialversicherungsnummern, IMEI-Nummern und National Provider Identifier-Nummern in den Vereinigten Staaten. Dieser Rechner ermöglicht es Ihnen, Zahlen mithilfe des Luhn-Algorithmus zu validieren und gültige Zahlen zu generieren, die den Luhn-Test bestehen.

Funktionsweise des Luhn-Algorithmus

Der Luhn-Algorithmus funktioniert wie folgt:

1. Beginnen Sie mit der rechtsstehenden Ziffer (ohne die Prüfziffer) und bewegen Sie sich nach links, verdoppeln Sie den Wert jeder zweiten Ziffer.
2. Wenn das Ergebnis dieser Verdopplungsoperation größer als 9 ist, ziehen Sie 9 vom Ergebnis ab.
3. Addieren Sie alle Ziffern in der resultierenden Sequenz.
4. Wenn die Summe modulo 10 gleich 0 ist (wenn die Summe mit null endet), dann ist die Zahl gemäß der Luhn-Formel gültig; andernfalls ist sie ungültig.

Hier ist eine visuelle Darstellung des Luhn-Algorithmus:

Formel

Der Luhn-Algorithmus kann mathematisch wie folgt ausgedrückt werden:

Sei $d_i$ die $i$-te Ziffer, gezählt von der rechtsstehenden Ziffer (ohne die Prüfziffer) und nach links bewegend. Dann wird die Prüfziffer $d_0$ so gewählt, dass:

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

Wobei $\bmod$ die Modulo-Operation ist.

Anwendungsfälle

Der Luhn-Algorithmus hat verschiedene Anwendungen in unterschiedlichen Bereichen:

1. Kreditkartenvalidierung: Die meisten Kreditkartennummern werden mit dem Luhn-Algorithmus validiert.
2. Kanadische Sozialversicherungsnummern: Der Luhn-Algorithmus wird verwendet, um die Gültigkeit dieser Identifikationsnummern zu überprüfen.
3. IMEI-Nummern: Mobiltelefon-IMEI-Nummern enthalten eine Prüfziffer, die durch den Luhn-Algorithmus validiert wird.
4. National Provider Identifier (NPI) Nummern: Diese Nummern werden im Gesundheitssystem der Vereinigten Staaten verwendet und mit dem Luhn-Algorithmus validiert.
5. ISBNs: Einige ISBN-10-Nummern verwenden eine Variante des Luhn-Algorithmus zur Validierung.

Alternativen

Obwohl der Luhn-Algorithmus weit verbreitet ist, gibt es andere Prüfziffernalgorithmen für verschiedene Zwecke:

1. Damm-Algorithmus: Ein weiterer Prüfziffernalgorithmus, der alle einstelligen Fehler und alle benachbarten Transpositionsfehler erkennt.
2. Verhoeff-Algorithmus: Ein komplexerer Prüfziffernalgorithmus, der alle einstelligen Fehler und die meisten Transpositionsfehler erkennt.
3. ISBN-13 Prüfziffer: Verwendet einen anderen Algorithmus als ISBN-10, der auf dem Luhn-Algorithmus basiert.

Geschichte

Der Luhn-Algorithmus wurde 1954 von Hans Peter Luhn, einem IBM-Computerwissenschaftler, entwickelt. Luhn war ein Pionier auf dem Gebiet der Informationswissenschaft und wird mit mehreren Innovationen, einschließlich des KWIC (Key Word In Context) Indizierungssystems, in Verbindung gebracht.

Der Algorithmus wurde ursprünglich entwickelt, um gegen versehentliche Fehler zu schützen, nicht gegen böswillige Angriffe. Es ist wichtig zu beachten, dass der Luhn-Algorithmus viele häufige Fehler erkennen kann, jedoch keine sichere Form der Verschlüsselung ist und nicht für Datensicherheitszwecke verwendet werden sollte.

Trotz seines Alters bleibt der Luhn-Algorithmus aufgrund seiner Einfachheit und Effektivität bei der Erkennung häufiger Transkriptionsfehler weit verbreitet.

Implementierungsbeispiele

Hier sind einige Codebeispiele zur Implementierung des Luhn-Algorithmus in verschiedenen Programmiersprachen:

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

## Beispielverwendung:
print(luhn_validate(4532015112830366))  # True
print(luhn_validate(4532015112830367))  # False
print(generate_valid_number(16))  # Generiert eine gültige 16-stellige Zahl

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

// Beispielverwendung:
console.log(luhnValidate(4532015112830366));  // true
console.log(luhnValidate(4532015112830367));  // false
console.log(generateValidNumber(16));  // Generiert eine gültige 16-stellige Zahl

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));  // Generiert eine gültige 16-stellige Zahl
    }
}

Randfälle und besondere Überlegungen

Bei der Implementierung des Luhn-Algorithmus sollten Sie die folgenden Randfälle und besonderen Überlegungen berücksichtigen:

1. Eingangsvalidierung: Stellen Sie sicher, dass die Eingabe eine gültige Zahlenzeichenfolge ist. Nicht-Ziffernzeichen sollten angemessen behandelt werden (entweder entfernt oder als ungültige Eingabe behandelt).

2. Führende Nullen: Der Algorithmus sollte korrekt mit Zahlen funktionieren, die führende Nullen haben.

3. Große Zahlen: Seien Sie darauf vorbereitet, sehr lange Zahlen zu verarbeiten, die die Kapazität von Standard-Integer-Typen in einigen Programmiersprachen überschreiten könnten.

4. Leere Eingabe: Definieren Sie, wie Ihre Implementierung mit leeren Zeichenfolgen oder null-Eingaben umgehen sollte.

5. Nicht-standardisierte Zeichensätze: In einigen Anwendungen könnten Sie Zahlen antreffen, die mit Zeichen außerhalb des Standardbereichs 0-9 dargestellt werden. Definieren Sie, wie diese behandelt werden sollen.

6. Leistungsüberlegungen: Für Anwendungen, die eine große Anzahl von Eingaben schnell validieren müssen, sollten Sie die Implementierung des Algorithmus optimieren.

Numerische Beispiele

1. Gültige Kreditkartennummer:

   • Nummer: 4532015112830366
   • Luhn-Check: Gültig

2. Ungültige Kreditkartennummer:

   • Nummer: 4532015112830367
   • Luhn-Check: Ungültig

3. Gültige kanadische Sozialversicherungsnummer:

   • Nummer: 046 454 286
   • Luhn-Check: Gültig

4. Ungültige IMEI-Nummer:

   • Nummer: 490154203237518
   • Luhn-Check: Ungültig

Testfälle

Um die Implementierung des Luhn-Algorithmus zu überprüfen, können Sie die folgenden Testfälle verwenden:

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 generierte Zahlen
    for _ in range(10):
        assert luhn_validate(generate_valid_number(16)) == True
    
    print("Alle Tests bestanden!")

test_luhn_algorithm()

Referenzen

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