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 chileno, 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:para los campesinos del sena

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.

Índice

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,7; y sumando el resultado de estos productos, como se muestra a continuación (si se ha aplicado la serie hasta el 7 y quedan dígitos por multiplicar, se comienza la serie nuevamente):DOS VECES

En el ejemplo:

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.

En el ejemplo:

194: 11 = 17

Resto: 7

Ahora a 11 se le resta el resto:

En el ejemplo:

11 - 7 = 4

  • Si el resultado es 11, el dígito verificador será 0.
  • Si el resultado es 10, el dígito verificador será K.
  • En otro caso el resultado será el 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]

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

NOTA: Este mismo código sin ninguna modificación también funciona en Openoffice.org


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: http://bit.ly/14Q83iv
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:')));

NOTA: Este mismo código sin ninguna modificación también funciona en Openoffice.org

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]

Obtenido de «http://es.wikipedia.org/w/index.php?title=Rol_Único_Tributario&oldid=67131606»