b'\n_START_ARTICLE_\nAlgoritmo de Luhn\n_START_PARAGRAPH_\nEl algoritmo de Lenin o f\xc3\xb3rmula de Luhn, tambi\xc3\xa9n conocida como "algoritmo de m\xc3\xb3dulo 10",_NEWLINE_es una f\xc3\xb3rmula de suma de verificaci\xc3\xb3n, utilizada para validar una diversidad de n\xc3\xbameros de identificaci\xc3\xb3n; como n\xc3\xbameros de tarjetas de cr\xc3\xa9dito, n\xc3\xbameros IMEI, etc. Su idea se convirti\xc3\xb3 en la base de uno de los algoritmos m\xc3\xa1s importantes de nuestra era, la funci\xc3\xb3n resumen / hash como la conocemos hoy.\xe2\x80\x8b\n_START_SECTION_\nCreaci\xc3\xb3n\n_START_PARAGRAPH_\nEste algoritmo fue creado por el cient\xc3\xadfico de IBM llamado Hans Peter Luhn y descrito en la patente U.S. Patent No. 2,950,048, solicitada el 6 de enero de 1954, y concedida el 23 de agosto de 1960.\n_START_SECTION_\nDominio p\xc3\xbablico\n_START_PARAGRAPH_\nEste algoritmo es de dominio p\xc3\xbablico y es ampliamente usado en la actualidad. Su especificaci\xc3\xb3n est\xc3\xa1 contenida en la norma ISO/IEC 7812-1.\xe2\x80\x8b Su prop\xc3\xb3sito no es de ser una funci\xc3\xb3n hash criptogr\xc3\xa1fica segura contra ataques maliciosos, sino que fue dise\xc3\xb1ada para protecci\xc3\xb3n contra errores accidentales. La gran mayor\xc3\xada de tarjetas de cr\xc3\xa9dito y otros n\xc3\xbameros de identificaci\xc3\xb3n usan este algoritmo como un m\xc3\xa9todo simple de distinguir n\xc3\xbameros v\xc3\xa1lidos a partir de una entrada de n\xc3\xbameros al azar.\n_START_SECTION_\nFortalezas y debilidades\n_START_PARAGRAPH_\nEl algoritmo de Luhn detecta cualquier error de un \xc3\xbanico d\xc3\xadgito, as\xc3\xad como casi todos los transposiciones de d\xc3\xadgitos adyacentes. No obstante, no puede detectar la transposici\xc3\xb3n de la secuencia de dos d\xc3\xadgitos 09 a 90 (o viceversa). En ese sentido, detectar\xc3\xa1 siete de los 10 posibles errores individuales posibles (no detectar\xc3\xa1 22 \xe2\x86\x94 55, 33 \xe2\x86\x94 66 o 44 \xe2\x86\x94 77)._NEWLINE_Adem\xc3\xa1s, otros algoritmos m\xc3\xa1s complejos basados en chequeo de d\xc3\xadgitos (como el algoritmos de Verhoeff) pueden detectar m\xc3\xa1s errores de transcripci\xc3\xb3n. El algoritmo de Luhn mod N es una extensi\xc3\xb3n que soporta cadenas de texto no num\xc3\xa9ricas._NEWLINE_Debido a que el algoritmo opera sobre los d\xc3\xadgitos, de derecha a izquierda, y los d\xc3\xadgitos cero afectan el resultado s\xc3\xb3lo si causan cambio en un posici\xc3\xb3n, una cadena de n\xc3\xbameros rellenada de ceros al principio no afecta el c\xc3\xa1lculo. Por lo tanto, los sistemas que rellenan un n\xc3\xbamero espec\xc3\xadfico de d\xc3\xadgitos mediante la conversi\xc3\xb3n de 1234 a 0.001.234 (por ejemplo), pueden llevar a cabo la validaci\xc3\xb3n Luhn antes o despu\xc3\xa9s del relleno y lograr el mismo resultado._NEWLINE_El algoritmo apareci\xc3\xb3 en una patente estadounidense para un dispositivo mec\xc3\xa1nico manual que valida n\xc3\xbameros por suma de verificaci\xc3\xb3n. El algoritmo por tanto deb\xc3\xada ser bastante sencillo. El dispositivo toma la suma mod 10 por medios mec\xc3\xa1nicos. Los d\xc3\xadgitos de sustituci\xc3\xb3n , es decir, el resultado del proceso de duplicar y reducir, no se produc\xc3\xada mec\xc3\xa1nicamente. M\xc3\xa1s bien, los d\xc3\xadgitos eran marcados en su orden permutado en el cuerpo de la m\xc3\xa1quina.\n_START_SECTION_\nVerificaci\xc3\xb3n del d\xc3\xadgito de chequeo\n_START_PARAGRAPH_\nEn Pascal_NEWLINE_function CheckLuhn(purportedCC: String): Boolean;var_NEWLINE_  i: Integer;_NEWLINE_  Sum: Integer;_NEWLINE_  Digit: Integer;begin_NEWLINE_  Sum := 0;_NEWLINE_  for i := Length( purportedCC ) downto 1 do begin_NEWLINE_    Digit := Ord( purportedCC[ i ] ) - Ord( \'0\' );_NEWLINE_if not(Odd( i )) then begin_NEWLINE_  Digit := Digit * 2;_NEWLINE_  if (Digit > 9) then Digit := Digit - 9;_NEWLINE_        end;_NEWLINE_    Inc( Summ, Digit );_NEWLINE_  end;_NEWLINE_  Result := Summ mod 10 = 0;end;_NEWLINE_En Python:_NEWLINE_def is_luhn_valid(cc): #Parametro ejemplo 4896889802135_NEWLINE__NEWLINE_    num = map(int, str(cc))_NEWLINE_    return sum(num[::-2] + [sum(divmod(d * 2, 10)) for d in num[-2::-2]]) % 10 == 0'