Calculadora de l'Algorisme de Luhn - Validació de Targetes de Crèdit i IMEI

Entenent l'Algorisme de Luhn

Necessites verificar un número de targeta de crèdit o validar un IMEI? L'algorisme de Luhn (o "algorisme mod 10") és una fórmula de suma de verificació que ha estat la base de la verificació de pagaments des de 1954. El científic d'IBM Hans Peter Luhn va dissenyar aquest elegant control matemàtic per detectar errors de tipografia i transcripció que afecten l'entrada manual de dades, com quan es canvien accidentalment dos dígits o es tecla incorrectament un número.

Heus aquí el que el fa imprescindible: cada xarxa de targetes de crèdit important (Visa, Mastercard, American Express), números IMEI de dispositius mòbils, Números d'Assegurança Social Canadencs i identificadors de proveïdors de salut dels EUA depenen d'aquest algorisme. Quan escrius un número de targeta en un formulari de pagament i aquest rebutja instantàniament un error, és el control de Luhn qui ho fa.

Aquesta calculadora et permet validar qualsevol seqüència de números o generar dades de prova que passin la verificació, essencial quan estàs construint integracions de pagament o provant sistemes d'identificació sense usar dades reals de clients.

Com Usar aquest Calculador

Validant números existents: Introduïu qualsevol seqüència de números —com una targeta de crèdit de 16 dígits o un IMEI de 15 dígits— i feu clic a "Validar". Veureu immediatament si passa la verificació mod 10, a més d'un desglossament pas a pas de com es va processar cada dígit. Això és especialment útil quan es depuren formularis de pagament o es verifica que la introducció de dades sigui precisa.

Generant dades de prova: Canvieu al mode "Generar" per crear números de prova vàlids de qualsevol longitud. Aquests números passen la verificació de Luhn però no són targetes reals o actives, la qual cosa els fa perfectes per a entorns de desenvolupament on necessiteu casos de prova realistes sense tocar credencials de pagament en viu.

Entenent el procés: La visualització mostra exactament el que passa a cada dígit: quins es dupliquen, quan es resta 9, i com la suma final determina la validesa. He trobat aquest feedback visual inestimable quan explico l'algoritme als companys o depuro problemes d'implementació.

Com funciona l'algorisme de Luhn

L'algorisme processa números des de la dreta cap a l'esquerra, aplicant un patró simple que detecta la majoria dels errors d'entrada de dades:

1. Comença per la dreta: Agafa cada dígit, movent-te cap a l'esquerra. Cada segon dígit es duplica (aquests són els que estan en posicions parells quan es compta des de la dreta).

2. Gestiona grans duplicats: Quan la duplicació produeix un número més gran que 9, resta 9. Això és matemàticament equivalent a sumar els dígits individuals (18 es converteix en 1+8=9).

3. Suma-ho tot: Suma tots els dígits processats, tant els duplicats/ajustats com els sense canvis.

4. Comprova la divisibilitat: Si la suma es divideix uniformement per 10 (acaba en 0), el número és vàlid. Qualsevol altre resultat significa que hi ha un error.

El que és intel·ligent d'aquest enfocament és com detecta errors comuns. Si intercanvies dos dígits adjacents o escrius malament un número, la suma de verificació gairebé sempre canvia. L'algorisme no detectarà tots els errors possibles —errors bessons com canviar 22 per 55 passen desapercebuts— però detecta aproximadament el 98% dels errors aleatoris de dígits individuals i al voltant del 90% de les transposicions adjacents.

Aquí hi ha una representació visual del procés:

Fórmula Matemàtica

Per a aquells que prefereixen una notació formal, aquí hi ha l'expressió matemàtica:

Sigui $d_i$ el $i$-èsim dígit, comptant des del dígit més a la dreta (excloent el dígit de verificació) i movent-se cap a l'esquerra. Llavors el dígit de verificació $d_0$ es tria de manera que:

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

On $\bmod$ és l'operació de mòdul.

Aplicacions del Món Real

Processament de pagaments: Cada gran xarxa de targetes —Visa, Mastercard, American Express, Discover— utilitza la comprovació de Luhn com a primera línia de defensa contra errors de tecleig. Quan es construeix un formulari de pagament, implementar la validació de Luhn al costat del client permet estalviar als usuaris l'enviament de números clarament incorrectes i redueix les crides innecessàries a les passarel·les de pagament.

Seguiment de dispositius mòbils: Els números IMEI en telèfons i tauletes inclouen un dígit de verificació de Luhn. Això es torna crucial en la gestió de la cadena de subministrament i els sistemes d'autenticació de dispositius: he vist sistemes de magatzem rebutjar escanejos IMEI invàlids instantàniament, prevenint errors d'enviament abans que succeeixin.

Identificadors sanitaris: El sistema de Número de Proveïdor Nacional (NPI) dels EUA valida els números de proveïdor mitjançant aquest algoritme. Amb milions de transaccions sanitàries diàries, detectar errors de transcripció en els ID de proveïdors prevé retards de facturació i redueix el rebuig de reclamacions.

Identificació governamental: Els Números d'Assegurança Social canadencs incorporen validació de Luhn. L'algoritme proporciona una comprovacióràpida sense requerir consultes a bases de dades, la qual cosa el fa eficient per a escenaris de verificació d'alt volum.

Sistemes de llibres antics: Algunes implementacions d'ISBN-10 utilitzen una variant de Luhn. Mentre que ISBN-13 utilitza un algoritme de dígit de verificació diferent, els sistemes antics de biblioteques i inventari encara es basen en la validació basada en Luhn.

Exemples pas a pas

Validació d'un número de targeta de crèdit

Validem el número 4532015112830366:

1. Començant des de la dreta: 6, 6, 3, 0, 3, 8, 2, 1, 1, 5, 1, 0, 2, 3, 5, 4
2. Doblar cada segon dígit (des de la dreta): 6, 12, 3, 0, 3, 16, 2, 2, 1, 10, 1, 0, 2, 6, 5, 8
3. Restar 9 dels números > 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 ✓ Vàlid!

Detectant un número IMEI invàlid

Provant 490154203237518 (l'últim dígit és intencionadament incorrecte):

1. Després de doblar i processar: Suma = 57
2. 57 % 10 = 7 ✗ Invàlid!

La suma no acaba en zero, per la qual cosa l'algoritme ho marca com a incorrecte. Per fer-lo vàlid, l'últim dígit hauria de ser 1, la qual cosa portaria la suma a 60, perfectament divisible per 10. Així és exactament com l'algoritme detecta errors de transcripció en identificadors de dispositius.

Algorismes Alternatius de Suma de Comprovació

L'algorisme de Luhn és popular perquè és senzill d'implementar, però existeixen alternatives més sofisticades quan es necessita una detecció d'errors més robusta:

Algorisme de Verhoeff: Detecta tots els errors de dígit únic i gairebé tots els errors de transposició, incloent els casos de dígits bessons que Luhn no detecta (com 22↔55). La contrapartida és una major complexitat: requereix taules de cerca amb operacions de multiplicació i permutació. Feu servir aquest algorisme quan la precisió de les dades sigui crítica i la sobrecàrrega computacional no sigui un problema.

Algorisme de Damm: Detecta tots els errors de dígit únic i totes les transposicions adjacents sense excepció. Es basa en una operació de quasigroup especialment construïda que garanteix una cobertura completa. La implementació utilitza una única taula de cerca, cosa que el fa més senzill que Verhoeff però encara més complex que Luhn.

Dígit de comprovació ISBN-13: Utilitza un algorisme de mòdul 10 amb pesos diferent tant de Luhn com d'ISBN-10. Els pesos alternen entre 1 i 3, la qual cosa proporciona una bona detecció d'errors per a identificadors de llibres específicament. Aquest va substituir l'antic sistema ISBN-10 (que feia servir Luhn) quan la indústria necessitava més espai per a identificadors.

Història i Context

Hans Peter Luhn va desenvolupar aquest algoritme a IBM el 1954, durant els primers dies del processament de dades automatitzat. Luhn ja era conegut per treballs pioners en recuperació d'informació —el seu sistema d'indexació KWIC (Key Word In Context) va influir en com cerquem documents fins i tot avui— però l'algoritme mod 10 es va convertir en la seva contribució més duradora.

Aquí hi ha la distinció crucial: Luhn va dissenyar això per a detecció d'errors, no per seguretat. Als anys 50, el problema eren errors de targetes perforades i errors de transcripció manual, no frau digital. L'algoritme detecta errors accidentals brillantment —però no és criptografia. Un número Luhn vàlid no significa que la targeta estigui activa, finançada o pertanyi a la persona que l'utilitza.

El que és remarcable és com un algoritme de 70 anys encara serveix al seu propòsit original. Els processadors de pagament hi afegeixen seguretat moderna (tokenització, verificació CVV, 3D Secure), però aquella verificació inicial de Luhn encara atura milions d'errors obvis diàriament abans que malmetin l'amplada de banda en trucades a passarel·les de pagament.

Exemples d'implementació

Aquí hi ha com implementar la validació i generació de Luhn en Python, JavaScript i Java. Aquests exemples prioritzen la llegibilitat mentre mantenen l'eficiència:

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## Exemple d'ús:
22
23print(luhn_validate(4532015112830366))  # Cert
24print(luhn_validate(4532015112830367))  # Fals
25print(generate_valid_number(16))  # Genera un número vàlid de 16 dígits
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// Exemple d'ús:
29console.log(luhnValidate(4532015112830366));  // cert
30console.log(luhnValidate(4532015112830367));  // fals
31console.log(generateValidNumber(16));  // Genera un número vàlid de 16 dígits
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));  // cert
45        System.out.println(luhnValidate(4532015112830367L));  // fals
46        System.out.println(generateValidNumber(16));  // Genera un número vàlid de 16 dígits
47    }
48}
49

Casos Extrems i Problemes d'Implementació

Quan s'implementa la validació de Luhn en sistemes de producció, vigileu amb aquests problemes comuns:

Sanejament d'entrada: Les entrades del món real sovint inclouen espais, guions o altres caràcters de format (com "4532-0151-1128-3036"). Elimineu-los abans de la validació en lloc de rebutjar l'entrada—els usuaris sovint copien números amb format. Tanmateix, rebutgeu immediatament els caràcters alfabètics ja que indiquen una entrada realment invàlida.

Els zeros inicials importen: Un número com "0123456789" és diferent de "123456789" als efectes de Luhn. Els zeros inicials han de preservar-se durant la validació. Això sol confondre els desenvolupadors que primer converteixen a enters—feu servir operacions de cadenes en el seu lloc.

Límits d'enters del llenguatge: Les targetes de crèdit solen tenir un màxim de 19 dígits, que caben en un enter de 64 bits. Però si valideu identificadors de longitud arbitrària, eviteu convertir a enters. Processeu com a cadenes o matrius de dígits per prevenir desbordaments.

Entrada buida o nul·la: Definiu explícitament el vostre comportament: llançar una excepció, retornar fals, o gestionar-ho amb elegància? He trobat que retornar fals té més sentit per a funcions de validació, però els punts finals d'API potser volen retornar un error 400 amb un missatge descriptiu.

Rendiment a escala: Per a validació per lots (com processar fitxers CSV pujats amb milers de números de targeta), l'algoritme bàsic ja és prou ràpid—O(n) on n és el recompte de dígits. L'ampolla de coll sol ser l'E/S, no el còmput. Centreu l'optimització en l'analitzador de fitxers i l'informe d'errors més que en la lògica de validació.

Referència ràpida: Números de prova

Utilitza aquests per provar la teva implementació:

Números vàlids:

• 4532015112830366 — Format Visa (16 dígits)
• 046454286 — Format SIN canadenc (9 dígits)
• 79927398713 — Número vàlid genèric

Números invàlids:

• 4532015112830367 — Un dígit fora de lloc
• 490154203237518 — Dígit de verificació incorrecte
• 79927398714 — Últim dígit incorrecte

Aquests casos de prova cobreixen escenaris comuns: números vàlids estàndard, errors d'un sol dígit i dígits de verificació incorrectes.

Conjunt de Proves Automatitzades

Aquí hi ha un conjunt de proves exhaustiu per validar la vostra implementació:

1def test_luhn_algorithm():
2    # Proves de validació bàsiques
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    # Provar que els números generats passin realment la validació
9    for _ in range(10):
10        generated = generate_valid_number(16)
11        assert luhn_validate(generated) == True, f"El número generat {generated} ha fallat la validació"
12
13    # Cas límit: un sol dígit
14    assert luhn_validate(0) == True  # 0 mod 10 = 0
15
16    # Cas límit: zeros inicials preservats
17    assert luhn_validate("0000000000000000") != luhn_validate(0)
18
19    print("Totes les proves han passat!")
20
21test_luhn_algorithm()
22

Preguntes Freqüents

Per a què s'utilitza l'algoritme de Luhn?

L'algoritme de Luhn valida números d'identificació, incloent targetes de crèdit (Visa, Mastercard, Amex), números IMEI de dispositius mòbils, Números de Seguretat Social canadencs i números NPI de salut dels EUA. Detecta errors comuns d'entrada de dades, com ara dígits mal escrits o números intercanviats accidentalment, abans que causin errors de processament o transaccions fallides.

Quina precisió té l'algoritme de Luhn per detectar errors?

Luhn detecta aproximadament el 98% dels errors de dígit únic i al voltant del 90% dels errors de transposició adjacents (com escriure "12" en lloc de "21"). Tanmateix, passa per alt els errors bessons on els dos dígits són iguals (22→55) i les transposicions de salt (101→404). Per a la majoria de les aplicacions pràctiques que impliquen entrada de dades manual, aquesta taxa de detecció és suficient.

Puc validar targetes de crèdit sense connexió amb l'algoritme de Luhn?

Sí, la validació de Luhn funciona completament sense connexió: és matemàtica pura que no requereix cerques de bases de dades ni crides a API. Això el fa perfecte per a la validació del costat del client en formularis web, reduint la càrrega del servidor i proporcionant retroalimentació instantània als usuaris. Però recordeu: un número Luhn vàlid no significa que la targeta estigui activa o tingui crèdit disponible.

És l'algoritme de Luhn segur per al processament de pagaments?

No: Luhn és detecció d'errors, no seguretat. Només verifica el format matemàtic. Un control de Luhn que passa no confirma que la targeta sigui real, activa, finançada o pertanyi a l'usuari. La seguretat de pagaments moderna requereix múltiples capes: verificació CVV/CVC, validació d'adreça (AVS), autenticació 3D Secure i tokenització. Luhn és només la primera comprovació de sentit.

Quins llenguatges de programació admeten la implementació de Luhn?

Cada llenguatge de propòsit general pot implementar Luhn: és un algoritme simple que només requereix aritmètica bàsica i bucles. Python, JavaScript, Java, C++, C#, PHP, Ruby, Go, Rust i Swift ho gestionen fàcilment en 10-20 línies de codi. Alguns llenguatges tenen biblioteques de tercers, però l'algoritme és prou senzill perquè la majoria dels desenvolupadors l'implementin directament.

Per què s'anomena algoritme mod 10?

El pas final comprova si la suma de dígits és divisible per 10 mitjançant l'operació de mòdul (suma % 10 == 0). "Mod 10" es refereix a aquesta comprovació de mòdul 10. Si el residu és zero en dividir per 10, el número passa; en cas contrari, falla. Aquesta propietat matemàtica és el que fa funcionar l'algoritme.

Puc generar números de targeta de crèdit de prova amb Luhn?

Sí: podeu generar números que passin la validació de Luhn per provar formularis de pagament durant el desenvolupament. No són targetes reals o actives; només satisfan el format matemàtic. Això és legal i necessari per a proves, però intentar usar números generats per a compres reals és frau. La majoria de les passarel·les de pagament ofereixen números de targeta de prova oficials per a entorns d'allotjament.

Quines limitacions té l'algoritme de Luhn?

Luhn no detectarà: errors bessons (22↔55), transposicions de salt (101↔404), errors fonètics (60↔06 en alguns casos) o múltiples errors simultanis. Tampoc proporciona seguretat criptogràfica: un format vàlid no significa una targeta vàlida. Malgrat aquestes limitacions, la seva simplicitat i taxa de detecció d'errors superior al 90% el fan pràctic per a sistemes de pagament del món real quan es combina amb altres mètodes de verificació.

Comença a Validar Números

Utilitza la calculadora anterior per validar números de targetes de crèdit, generar dades de proves per a entorns de desenvolupament, o explorar com l'algoritme mod 10 processa cada dígit. La visualització pas a pas ajuda a depurar problemes d'implementació i explica els resultats de validació a parts interessades no tècniques.

Tant si estàs construint un formulari de pagament, depurant un sistema de validació IMEI, o simplement aprenent sobre algoritmes de suma de control, aquesta eina proporciona la retroalimentació instantània i la transparència tècnica que necessites.

Referències i Lectures Addicionals

1. Luhn, H. P. (1960). "Ordinador per Verificar Números". Patent dels EUA 2.950.048 - La patent original que descriu l'algorisme.

2. ISO/IEC 7812-1:2017 - Targetes d'identificació - Estàndard internacional per a sistemes de numeració de targetes d'identificació, que especifica l'ús de Luhn per a targetes de pagament.

3. Gallian, Joseph (1991). "Les Matemàtiques dels Números d'Identificació" - Anàlisi acadèmica de diversos algorismes de dígits de verificació, incloent Luhn, publicat al Journal of College Mathematics.

4. Estàndard de Seguretat de Dades de la Indústria de Targetes de Pagament (PCI DSS) - Estàndards de seguretat que regeixen com s'han de gestionar les dades de targetes de pagament, proporcionant context sobre on s'ubica Luhn en la pila de seguretat.