Código cuenta cliente

El Código Cuenta Cliente (CCC) es un código utilizado en España por las entidades financieras ( bancos, cajas y cooperativas de crédito) para la identificación de las cuentas de sus clientes. Consta de veinte dígitos.

Estructura del CCC

Los veinte dígitos del CCC están divididos en cuatro bloques distintos de acuerdo con la siguiente estructura: EEEE OOOO DD NNNNNNNNNN.[1]

  • Los primeros cuatro dígitos son el Código de la Entidad, que coincide con el Número de Registro de Entidades del Banco de España (NRBE).[2]
  • Los siguientes cuatro dígitos identifican la oficina.
  • Los siguientes dos dígitos son los llamados dígitos de control, que sirven para validar el CCC.
  • Los últimos diez dígitos identifican unívocamente la cuenta.

Dígitos de control

Los dígitos situados en las posiciones novena y décima se generan a partir de los demás dígitos del CCC, permitiendo comprobar la validez del mismo y reducir la posibilidad de errores de manipulación. El primero de ellos valida conjuntamente los códigos de entidad y de oficina; el segundo, valida el número de cuenta.

Para obtener cada uno de los dígitos de control se realiza el procedimiento siguiente:

  • Para el primer dígito: puesto que el código conjunto de Entidad y de Oficina tiene tan solo ocho cifras, se completa con dos ceros (00) por la izquierda para hacer la comprobación.
  • Cada uno de los dígitos que componen el código se multiplica por un factor asociado a su posición en el código. Los factores para cada posición, de izquierda a derecha, son: 1, 2, 4, 8, 5, 10, 9, 7, 3, 6. (Estos factores son mod 11 para . Como 11 es primo, esto genera una secuencia de 10 números distintos. Este producto se hace para detectar trasposiciones de números, por ejemplo 47 en lugar de 74.)
  • A continuación, se suman los diez productos obtenidos.
  • El resultado de esta suma se divide por 11 y se anota el resto que produce la división.
  • Este resto se resta de 11 para obtener el dígito de control correspondiente a cada uno de los códigos.
  • Puesto que estamos interesados en obtener solo una cifra, si la cantidad resultante fuese 10, se tomará en su lugar el dígito 1; y si fuese 11, el 0.

Cálculo de los dígitos de control

Existen programas y códigos para calcular los dígitos de control del CCC.[3]

En C++ Builder

AnsiString __fastcall TForm1::CalculaDigito(AnsiString Entidad, AnsiString Oficina, AnsiString Numero)
{
     AnsiString Cadena;
     int nResto;
     int aPesos[10] = {6,3,7,9,10,5,8,4,2,1};
     
     Cadena = "";
     nResto = 0;
     for (int nItem = 1; nItem <= (Entidad + Oficina).Length(); nItem ++)
          nResto += StrToInt((Entidad + Oficina).SubString(nItem, 1)) * aPesos[8 - nItem];

     nResto = 11 - (nResto % 11);
     if (nResto == 11)
          nResto = 0;
     else if (nResto == 10)
          nResto = 1;
     Cadena = FormatFloat("0", nResto);

     nResto = 0;
     for (int nItem = 1; nItem <= Numero.Length(); nItem ++)
          nResto += StrToInt(Numero.SubString(nItem, 1)) * aPesos[10 - nItem];

     nResto = 11 - (nResto % 11);
     if (nResto == 11)
          nResto = 0;
     else if (nResto == 10)
          nResto = 1;
     Cadena = Cadena + FormatFloat("0", nResto);
     return (Cadena);
}
//---------------------------------------------------------------------------

En Perl

use strict;
use warnings;

sub calcula_dc {
  my ($entidad, $oficina, $cuenta) = @_;

  my $calcula_digito = sub {
    my @digitos  = split //, shift;
    my @factores = (1, 2, 4, 8, 5, 10, 9, 7, 3, 6);
    my $suma = 0;
    foreach my $i (0..9) {
      $suma += $digitos[$i] * $factores[$i];
    }
    my $digito = (11 - $suma % 11) < 10
                  ? (11 - $suma % 11)
                  : 11 - (11 - $suma % 11);
    return $digito;
  };

  return $calcula_digito->("00${entidad}${oficina}")
       . $calcula_digito->($cuenta);
}

sub valida_dc {
  my ($entidad, $oficina, $dc, $cuenta) = @_;
  return $dc == calcula_dc($entidad, $oficina, $cuenta);
}

En PHP

function valcuenta_bancaria($cuenta1,$cuenta2,$cuenta3,$cuenta4){
if (strlen($cuenta1)!=4) return false;
if (strlen($cuenta2)!=4) return false;
if (strlen($cuenta3)!=2) return false;
if (strlen($cuenta4)!=10) return false;

if (mod11_cuenta_bancaria("00".$cuenta1.$cuenta2)!=$cuenta3{0}) return false;
if (mod11_cuenta_bancaria($cuenta4)!=$cuenta3{1}) return false;
return true;
}
//////////////////////////////////////////////////////////////////////////////////////

function mod11_cuenta_bancaria($numero){
if (strlen($numero)!=10) return "?";

$cifras = Array(1,2,4,8,5,10,9,7,3,6);
$chequeo=0;
for ($i=0; $i < 10; $i++)
    $chequeo += substr($numero,$i,1) * $cifras[$i];

$chequeo = 11 - ($chequeo % 11);
if ($chequeo == 11) $chequeo = 0;
if ($chequeo == 10) $chequeo = 1;
return $chequeo;
}

En Python

def digitos_control(entidad, oficina, cuenta):
    def proc(digitos):
        resultado = 11 - sum(int(d) * 2**i for i,d in enumerate(digitos)) % 11
        return resultado if resultado < 10 else 11 - resultado
    return '%d%d' % (proc('00'+entidad+oficina), proc(cuenta))

donde las variables de entrada son strings de 4, 4 y 10 caracteres respectivamente, y se tiene en cuenta que sum(... 2**i % 11 ...) % 11 es igual a sum(... 2**i ...) % 11.

De forma más explícita y con ciertas comprobaciones, la descripción del algoritmo correspondería a este programa:

def digitos_control(entidad, oficina, cuenta):
    def proc(digitos):
        if not digitos.isdigit() or len(digitos) != 10:
            raise ValueError('Debe ser número de 10 digitos: %s' % digitos)
        factores = [1, 2, 4, 8, 5, 10, 9, 7, 3, 6]
        resultado = 11 - sum(int(d)*f for d,f in zip(digitos, factores)) % 11
        if resultado == 10:  return 1
        if resultado == 11:  return 0
        return resultado
    return '%d%d' % (proc('00'+entidad+oficina), proc(cuenta))
Other Languages