Rol Único Tributario

De Wikipedia, la enciclopedia libre
Saltar a: navegación, búsqueda

El Rol Único Tributario, conocido también por el acrónimo RUT, es un número único implantado en Chile, que fue establecido como identificación tributaria por el Decreto con Fuerza de Ley N° 3 del 29 de enero de 1969.[1] La identificación tributaria anterior era el Rol General de Contribuyentes (1959-1969).

La asignación del Rol respectivo está a cargo de dos organismos estatales, según la naturaleza del asignatario:

El formato del RUT es igual al del RUN; por lo tanto, obedece a la forma XX.XXX.XXX - Y.

Tanto el RUT como el RUN son personalísimos e intransferibles, por lo tanto:

  • Un mismo Rol solamente será asignado a una persona determinada, sea natural o jurídica.
  • Un titular de RUN o RUT mantendrá el mismo Rol durante toda su existencia legal.
  • Terminada la existencia legal del titular de RUN o RUT, nunca es vuelto a asignar.

Algoritmo[editar]

El algoritmo para obtener el dígito verificador corresponde al método para validar el RUN o RUT. El Rol Único Nacional (RUN) y el Rol Único Tributario (RUT) chilenos (ambos coinciden en el RUN si se trata de personas naturales) poseen un dígito verificador que evita engaños y suplantaciones de identidad.

El dígito verificador se obtiene a partir de un algoritmo conocido como Módulo 11. Existen otras maneras de obtener el dígito verificador de los números de identificación del mundo, pero en Chile se aplica exclusivamente el Módulo 11. El Módulo 11 consiste en la aplicación de operaciones aritméticas a cada dígito del número del RUT.

Procedimiento para obtener el dígito verificador[editar]

El RUT consta de dos partes: el número y el dígito verificador separados por un guion. En el siguiente ejemplo se toma como RUT el número 30.686.957-X, donde 30.686.957 es el número del RUT y X es el dígito verificador que no conocemos o que queremos verificar.

- Se procede a tomar el número de RUT de derecha a izquierda, multiplicando cada dígito por los números que componen la serie numérica 2, 3, 4, 5, 6, y 7; y sumando el resultado de estos productos. Si se ha aplicado la serie hasta el final y quedan dígitos por multiplicar, se comienza la serie nuevamente:

7 × 2 = 14,

5 × 3 = 15,

9 × 4 = 36,

6 × 5 = 30,

8 × 6 = 48,

6 × 7 = 42,

0 × 2 = 0,

3 × 3 = 9,

entonces la suma de los productos es: 14+15+36+30+48+42+0+9 = 194

- Al número obtenido por la suma del producto de cada dígito por la serie ya mencionada, se le aplica módulo 11, o sea, se divide por 11 y se determina el resto de la división:

parte entera de (194 : 11) = 17

resto de la división entera: (194 - 11 * 17) = 7

- Ahora a 11 se le resta el resto calculado antes:

11 - 7 = 4

- Al resultado final, se le convierte a una letra o número, siguiendo estas reglas:

  • Si el resultado es 11, el dígito verificador será 0 (cero).
  • Si el resultado es 10, el dígito verificador será K.
  • En otro caso, el resultado será el propio dígito verificador.

Como en el ejemplo el resultado de la resta es 4, el dígito verificador es 4.

Por ende, el RUT del ejemplo es el 30.686.957-4.

Ejemplos[editar]

Objective-C

//validation with parse logic from RUT string format XX.XXX.XXX-Y
+ (BOOL)validRUT:(NSString*)rut{
 
    //remove any dots or signs from RUT string with format XX.XXX.XXX-Y
    //http://es.wikipedia.org/wiki/Rol_%C3%9Anico_Tributario
 
    rut = [rut stringByReplacingOccurrencesOfString:@"." withString:@""];
    rut = [rut stringByReplacingOccurrencesOfString:@"-" withString:@""];
 
    //get rut validator digit (Y)
    char dv = [rut characterAtIndex:[rut length]-1];
    NSLog(@"DV: %c", dv);
 
    //get rut numeric value from (XX.XXX.XXX)
    int rutnumber = [[rut substringToIndex:[rut length]-1] integerValue];
    NSLog(@"RUT NUMBER: %d", rutnumber);
 
    //check valid RUT number (XX.XXX.XXX) with validator digit (Y)
    return [self validRUT:rutnumber with:dv];
}
 
//algorithm module 11 based on the Java version
+ (BOOL)validRUT:(int)rut with:(char)dv
{
    //to accept 'k' lowercase to avoid issues with "K" clients
    dv = (dv == 'k')?'K':dv;
    NSLog(@"RUT DV: %c", dv);
 
    int m = 0, s = 1;
    for (; rut != 0; rut /= 10) {
        s = (s + rut % 10 * (9 - m++ % 6)) % 11;
    }
 
    //generate DV to check
    char dvcheck = (char) (s != 0 ? s + 47 : 75);
 
    NSLog(@"RUT DV: %c", dv);
    NSLog(@"GEN DV: %c", dvcheck);
 
    return dv == dvcheck;
}

C++

char digito_verificador_rut(unsigned rut)
{
   unsigned sum = 0, factor = 2;
   while(rut)
   {
       sum += (rut%10)*factor;
       rut/=10;
       factor = factor==7 ? 2 : factor+1;
   }
   const unsigned res = 11 - sum%11;
 
   return res == 11? '0' : res == 10? 'k' : res+'0';
}

Visual Basic MS Excel

Public Function RutDigito(ByVal Rut As Long) As String
    Dim Digito      As Integer
    Dim Contador    As Integer
    Dim Multiplo    As Integer
    Dim Acumulador  As Integer
    Contador = 2
    Acumulador = 0
    While Rut <> 0
      Multiplo = (Rut Mod 10) * Contador
      Acumulador = Acumulador + Multiplo
      Rut = Rut \ 10
      Contador = Contador + 1
      If Contador > 7 Then
        Contador = 2
      End If
    Wend
    Digito = 11 - (Acumulador Mod 11)
    RutDigito = CStr(Digito)
    If Digito = 10 Then RutDigito = "K"
    If Digito = 11 Then RutDigito = "0"
  End Function

C#

private string digitoVerificador(int rut)
{
      int Digito;
      int Contador;
      int Multiplo;
      int Acumulador;
      string RutDigito;
 
      Contador = 2;
      Acumulador = 0;
 
      while (rut != 0)
      {
      Multiplo = (rut % 10) * Contador;
      Acumulador = Acumulador + Multiplo;
      rut = rut/10;
      Contador = Contador + 1;
      if (Contador == 8)
            {
             Contador = 2;
            }
 
      }
 
      Digito = 11 - (Acumulador % 11);
      RutDigito = Digito.ToString().Trim();
      if (Digito == 10 )
      {
            RutDigito = "K";
      }
      if (Digito == 11)
      {
            RutDigito = "0";
      }
      return (RutDigito);
      }
 
      }
 }
 
/// Una versión mas corta
public static string Dv(string r)
{
    int suma = 0;
    for (int x = r.Length - 1; x >= 0; x--)
        suma += int.Parse(char.IsDigit(r[x])?r[x].ToString():"0") * (((r.Length - (x + 1)) % 6) + 2);
    int numericDigito = (11 - suma % 11);
    string digito = numericDigito == 11 ? "0" : numericDigito == 10 ? "K" : numericDigito.ToString();
    return digito;
}
 
/// Una versión funcional
public static char GenerarDV (int num)
{
    return "0K987654321" [  
        Enumerable.Range (0, (int) Math.Floor (Math.Log10 (num)) + 2)  
            .Select (i =>  
                ((i % 6) + 2) *  
                ((num / (int) Math.Pow (10, i)) % 10))  
            .Sum () % 11];
}

Perl 6

    #!/usr/bin/perl6
    my ($RUT, @RUT, $digito);
 
    $RUT = @*ARGS;                          # leemos el argumento pasado al programa
    @RUT = $RUT.split('').reverse;          # lo pasamos a array y le damos la vuelta
 
    $digito = [+](@RUT <<*>> (2..7));       # cálculo del dígito verificador
    $digito = 11 - $digito % 11;
    $digito = ( 0 .. 9, 'K', 0 )[$digito];
 
    say "$RUT-$digito";                     # salida

Javascript

  dv = function(T) {
     var M=0,S=1;
     for(;T;T=Math.floor(T/10))
        S=(S+T%10*(9-M++%6))%11;
     return S?S-1:'K';
  }
  alert('El digito verificador del rut ingresado es '+
         dv(prompt('Ingrese rut para mostrar su digito verificador:')));

PHP

  function dv($r){
     $s=1;
     for($m=0;$r!=0;$r/=10)
         $s=($s+$r%10*(9-$m++%6))%11;
     echo 'El digito verificador del rut ingresado es ',chr($s?$s+47:75);
  }

Transact-SQL

CREATE FUNCTION RutDigito
   (@Rut as integer)
RETURNS varchar(1)
AS
BEGIN
     declare @Digito as integer
     declare @Contador as integer
     declare @Multiplo as integer
     declare @Acumulador as integer
     declare @retorno as varchar(1)
 
     set @Contador = 2
     set @Acumulador = 0
 
     WHILE @Rut <> 0
     BEGIN
          set @Multiplo = (@Rut % 10) * @Contador
          set @Acumulador = @Acumulador + @Multiplo
          set @Rut = @Rut / 10
          set @Contador = @Contador + 1                
          If @Contador > 7  set @Contador = 2
     END
 
     set @Digito = 11 - (@Acumulador % 11)
 
     select @retorno = case when @Digito = 10 then 'K' 
                              when @Digito = 11 then '0'
                              else cast(@Digito as varchar(1))
                       end
 
      return @retorno
 
END

MATLAB

r=input('Ingrese rut:');
 
a=floor(r/10^7);
b=floor(r/10^6)-(10*a);
c=floor(r/10^5)-(100*a+10*b);
d=floor(r/10^4)-(10^3*a+100*b+10*c);
e=floor(r/10^3)-(10^4*a+10^3*b+100*c+10*d);
f=floor(r/10^2)-(10^5*a+10^4*b+10^3*c+100*d+10*e);
g=floor(r/10^1)-(10^6*a+10^5*b+10^4*c+10^3*d+100*e+10*f);
h=r-(10^7*a+10^6*b+10^5*c+10^4*d+10^3*e+100*f+10*g);
 
sum=h*2+g*3+f*4+e*5+d*6+c*7+b*2+a*3;
resto=sum-floor(sum/11)*11;
 
verif=11-resto;
 
disp('El numero verificador es:')
if (verif<10) 
    disp(verif) 
end
if (verif==11) 
    disp('0') 
end
if (verif==10) 
    disp('K') 
end

PSeInt

Proceso digito_verificador
        Definir rut, a1, pa, c, sum, di, digi Como Enteros;
       	Escribir "Este programa define su dígito verificador ";
	Escribir "Ingrese su rut sin el dígito verificador ";
	Leer rut;
	pa<-rut;
	c<-2;
	sum<-0;
	Mientras rut>0 Hacer
		a1<-rut%10;
		rut<-trunc(rut/10);
		sum<-sum+(a1*c);
		c<-c+1;
		Si c=8 Entonces
			c<-2;
		FinSi
	FinMientras
	di<-sum%11;
	digi<-11-di;
	Si digi=11 Entonces
		Escribir "El dígito verificador es 0";
		Escribir pa,"-0";		
	Sino
		Si digi=10 Entonces
			Escribir "El dígito verificador es K";
			Escribir pa,"-K";
		Sino
			Escribir "El dígito verificador es ",digi;
			Escribir pa,"-",digi;
		FinSi
	FinSi
FinProceso

Python

def digito_verificador(rut):
    value = 11 - sum([ int(a)*int(b)  for a,b in zip(str(rut).zfill(8), '32765432')])%11
    return {10: 'K', 11: '0'}.get(value, str(value))

Ruby

def digito_verificador(rut)
  total = rut.to_s.rjust(8,'0').split(//).zip(%w(3 2 7 6 5 4 3 2)).collect{|a,b| a.to_i*b.to_i}.inject(:+)
  (11 - total % 11).to_s.gsub(/10/,'k').gsub(/11/,'0')
end

Java

    public static boolean ValidarRut(int rut, char dv)
    {
        int m = 0, s = 1;
        for (; rut != 0; rut /= 10)
        {
            s = (s + rut % 10 * (9 - m++ % 6)) % 11;
        }
        return dv == (char) (s != 0 ? s + 47 : 75);
    }

Referencias[editar]

  1. «CREA EL ROL UNICO TRIBUTARIO Y ESTABLECE NORMAS PARA SU APLICACIÓN» (1969). Consultado el 9 de Octubre de 2012.

Enlaces externos[editar]