Algoritmo para obtener la letra del NIF

De Wikilibros, la colección de libros de texto de contenido libre.

El número de identificación fiscal (NIF) español es un código único que identifica a todos los ciudadanos españoles a efectos fiscales. Partiendo del tradicional DNI, añade a éste una letra que actúa como elemento verificador.

[editar] Algoritmo

La letra del NIF se obtiene a partir de un algoritmo conocido como módulo 23. El algoritmo consiste en aplicar la operación aritmética de módulo 23 al número del DNI (Documento Nacional de Identidad). El módulo 23 es el número entero obtenido como resto de la división entera del número del DNI entre 23. El resultado es un número comprendido entre el 0 y el 22. En base a una tabla conocida se asigna una letra. La combinación del DNI con esa letra es el NIF.

Este mismo algoritmo también puede utilizarse para el calculo del NIE. En el caso que el NIE empiece por X, se calcula despreciando la X y utilizando los 7 dígitos, si el NIE empieza por Y, se sustituye la letra Y por el número 1, si el NIE empieza por Z, se sustituye la letra Z por el número 2 y se realiza el mismo cálculo.

El algoritmo no se aplica para obtener el Código de Identificación Fiscal (CIF), que es el "NIF" propio de las personas jurídicas, pues la letra que tiene no se basa en una fórmula, sino que identifica el tipo de entidad (p.e. B para Sociedades Limitadas; G para Asociaciones sin ánimo de lucro y otros tipos no definidos, etc.).

[editar] Tabla de asignación

No se utilizan las letras: I, Ñ, O, U

La I y la O se evitan para evitar confusiones con otros caracteres, como 1, l ó 0.

Se usan veintitrés letras por ser éste un número primo.

[editar] Ejemplos

Algunos ejemplos de la implementación de este algoritmo para distintos lenguajes de programación son:

[editar] Ada

function Letra_Nif (Dni : Positive) return Character is
   Letras : constant String := "TRWAGMYFPDXBNJZSQVHLCKE";
begin
   return Letras ((Dni mod Letras'Length) + 1);
end Letra_Nif;

[editar] AppleScript

    on LetraDNI(dni)
         return character (1 + (dni as integer) mod 23) of "TRWAGMYFPDXBNJZSQVHLCKE"
    end LetraDNI

[editar] ASP 3.0 VBScript

    Function sacaLetra(ByVal dni)
        Dim tabla,pos
        tabla = Array("T","R","W","A","G","M","Y","F","P","D","X","B","N","J","Z","S","Q","V","H","L","C","K","E")
        pos = dni mod 23
        sacaLetra = tabla(pos)
    End Function
 
Y para Validar el NIF:
 
    Function validaNIF(ByVal nif)
        Dim dni
        If Len(nif)<7 Then
                validaNIF = false
        Else
                dni = Left(nif,Len(nif)-1)
                validaNIF = UCase(nif)=dni&sacaLetra(dni)
        End If
    End Function
                                 by [THC]Fever

[editar] Bourne shell script

    echo TRWAGMYFPDXBNJZSQVHLCKE | cut -c $(( $(( $1 % 23 )) + 1 ))

otra forma más moderna, sin usar comandos externos

    LETRANIF="TRWAGMYFPDXBNJZSQVHLCKE"
    DNI=12345678
    echo ${LETRANIF:$DNI % 23:1}

[editar] C

   #include <stdlib.h>
   #include <string.h>
   #include <stdio.h>
   
   /* numero de cifras para el DNI */
   #define kTAM 8
   
   int main (int argc, char *argv[])
   {
       int     dni;
       char    letra[] = "TRWAGMYFPDXBNJZSQVHLCKE";
   
       if (argc != 2)
            printf("Uso: %s <DNI>\n", argv[0]);
       else
       {
           if (strlen(argv[1]) != kTAM)
               puts("DNI no valido.");
           else
           {
               dni = atoi (argv[1]);
               dni %= 23;
               printf("%s-%c\n", argv[1],letra[dni]);
            }
       }
   }

[editar] C++

 #include <iostream>
 using namespace std;
 
 int main(int argc, char *argv[])
 {
 	if (argc > 1)
 		cout << "TRWAGMYFPDXBNJZSQVHLCKE"[atoi(argv[1]) % 23] << endl;
     return 0;
 }

[editar] C#

/// <summary> Tabla de asignación. </summary>
public const string Correspondencia = "TRWAGMYFPDXBNJZSQVHLCKET";
 
/// <summary> Genera la letra correspondiente a un DNI. </summary>
/// <param name="dni"> DNI a procesar. </param>
/// <returns> Letra correspondiente al DNI. </returns>
public char LetraNIF(string dni)
{
	int n;
 
	if ((dni == null) || (dni.Length != 8) || (!int.TryParse(dni, out n)))
	{
		throw new ArgumentException("El DNI debe contener 8 dígitos.");
	}
 
	return Correspondencia[n % 23];
}
 
/// <summary> Genera la letra correspondiente a un NIE. </summary>
/// <param name="nie"> NIE a procesar. </param>
/// <returns> Letra correspondiente al NIE. </returns>
public char LetraNIE(string nie)
{
	int n;
 
	if ((nie == null) || (nie.Length != 8) || ((char.ToUpper(nie[0]) != 'X') && (char.ToUpper(nie[0]) != 'Y') && (char.ToUpper(nie[0]) != 'Z')) || (!int.TryParse(nie.Substring(1), out n)))
	{
		throw new ArgumentException("El NIE debe comenzar con la letra X, Y o Z seguida de 7 dígitos.");
	}
 
	switch (char.ToUpper(nie[0]))
	{
		case 'X':
			return Correspondencia[n % 23];
		case 'Y':
			return Correspondencia[(10000000 + n) % 23];
                case 'Z':
			return Correspondencia[(20000000 + n) % 23];
		default:
			return '\0';
	}
}

[editar] Fortran

program dni
implicit none
integer :: numero
character(len=23) :: string='TRWAGMYFPDXBNJZSQVHLCKE'
integer :: nif
    
    write(*,'(a)') 'Este programa calcula su letra del NIF a partir de su numero de DNI'
    write(*,'(a)') 'Introduzca su DNI'
    read(*,*) numero
    
    nif=mod(numero,23)+1
    
    write(*,'(a,2x,a)') 'Su letra del NIF es:', string(nif:nif) 
    
end program dni

[editar] Java

 public static final String NIF_STRING_ASOCIATION = "TRWAGMYFPDXBNJZSQVHLCKET";
 
 /**
  * Devuelve un NIF completo a partir de un DNI. Es decir, añade la letra del NIF
  * @param dni dni al que se quiere añadir la letra del NIF
  * @return NIF completo.
  */
 public static String nifFromDni(int dni) {
   return String.valueOf(dni) + NIF_STRING_ASOCIATION.charAt(dni % 23);
 }

[editar] JavaScript/EcmaScript

 // devuelve la letra correspondiente a un número DNI
 function letraDni(dni) {
   var lockup = 'TRWAGMYFPDXBNJZSQVHLCKE';
   return lockup.charAt(dni % 23);
 }

Ejecutable en navegador:

Javascript:function letraDni() {var lookup = 'TRWAGMYFPDXBNJZSQVHLCKE';var dni = prompt("Introduce un DNI:");alert(dni + '-' + lookup.charAt(dni % 23));}letraDni();

[editar] Pascal/Delphi

program dni;
{$APPTYPE CONSOLE}
 uses SysUtils;
 const letra='TRWAGMYFPDXBNJZSQVHLCKE'; //esta cadena de caracteres corresponde a las letras en orden del dni
 var n:string[8];
 e:integer;
 begin
   writeln('Programa que calcula la letra del DNI');
   writeln; writeln; writeln; writeln;
   write('Introduzca su numero de dni: ');
   readln(n);
   writeln; writeln; writeln; writeln; writeln;
   write ('su dni es ',n,letra[((strtoint(n)) mod 23)+1]);
   readln;
 end.

[editar] Perl

   sub LetraDNI {
       my $dni = shift;
       return substr( 'TRWAGMYFPDXBNJZSQVHLCKE', $dni % 23, 1);
   }

[editar] PHP

    $numero = "12345678"; //asignación del número de DNI
    function letra_nif($dni) {return substr("TRWAGMYFPDXBNJZSQVHLCKE",$dni%23,1);}
    echo 'El NIF del DNI "'.$numero.'" es "'.$numero.letra_nif($numero).'"';

[editar] Python

    DNI=12345678
    NIF='TRWAGMYFPDXBNJZSQVHLCKE'
    print "El NIF del DNI es", NIF[DNI%23]

[editar] Ruby

    puts "TRWAGMYFPDXBNJZSQVHLCKE"[gets.to_i % 23].chr

[editar] Visual Basic

    Private Function NIF(DNI As Long)
         NIF = DNI & "-" & Mid$("TRWAGMYFPDXBNJZSQVHLCKE", (DNI Mod 23) + 1, 1)
    End Function

[editar] Excel

  =CONCATENAR(A1;EXTRAE("TRWAGMYFPDXBNJZSQVHLCKE";RESIDUO(A1;23)+1;1))
  =CONCATENATE(A1,MID("TRWAGMYFPDXBNJZSQVHLCKE",MOD(A1,23)+1,1))  

Siendo A1 la celda de origen del DNI sin letra.

[editar] PL-SQL

 declare @nif varchar(9)
 declare @dni int 
 
 set @dni = 12345678
 
 set @nif = CONVERT(varchar(8),@dni) + SUBSTRING('TRWAGMYFPDXBNJZSQVHLCKE', @dni % 23 + 1, 1)
 print @nif 

en sentencias SELECT:

 SELECT CONVERT(varchar(8),tablaPersonas.dni) + SUBSTRING('TRWAGMYFPDXBNJZSQVHLCKE', tablaPersonas.dni % 23 + 1, 1)
 FROM tablaPersonas

o más simple para ORACLE:

SELECT dni||SUBSTR('TRWAGMYFPDXBNJZSQVHLCKET',MOD(dni,23)+1,1)
FROM tablaPersonas

siendo tablaPersonas la tabla con el dato de usuario y el campo dni el origen del DNI y en formato entero (int).

[editar] SAP

 FORM resultado USING VALUE(GV_NUMBER)
   DATA GV_result(9) TYPE c.
   DATA lt_letters(24) TYPE c VALUE 'TRWAGMYFPDXBNJZSQVHLCKE'.
   DATA lv_num TYPE i.
   DATA lv_number(8) type n.
   lv_number = gv_number.
   lv_num = gv_number MOD 23.
   gv_character = lt_letters+lv_num(1).
   CONCATENATE lv_number gv_character INTO gv_result.
 ENDFORM.                    " resultado 

Siendo gv_result el nº de nif con la letra.

[editar] Enlaces externos

• LetraNIF.com - Calcula la Letra del NIF
• Página 'DNIe' de Glosario de Tecnología que permite calcular la letra del DNI/NIF.
• Herramienta desarrollada en C que genera DNIs, valida NIFs, verifica DNIs, etc.
• Algoritmo de cálculo de la letra del CIF. Incluye validación.
• Programas en Javascript para calcular la letra del NIF.
• Letra del NIF en Excel