Archivo

Entradas Etiquetadas ‘numero’

Algoritmos: Validar un DNI en C

Miércoles, 4 de Abril de 2012 Gaspar Fernández Sin comentarios

En España, para identificar de forma única a cada ciudadano se utiliza el número del Documento Nacional de Identidad (DNI). Como es costumbre, en muchos datos numéricos, como este, un número de cuenta corriente, códigos ISBN, etc existe un algoritmo de verificación que comprueba que el número es válido. En este caso, la comprobación se realiza con la letra que acompaña el número.

El algoritmo es sencillo, puede que a la hora de implementarlo no nos acordemos del orden de las letras (para eso lo pongo, y podemos hacer Copia y Pega rápidamente).

Tal vez si estás empezando con la programación y no domines el uso de Arrays te resulte algo complicado, pero es un buen momento para empezar a programar Arrays, te ayudarán mucho y te ahorrarán en casos como este muchísimo código.

Presento primero una función que genera la letra del DNI a partir del número:

1
2
3
4
5
6
char letraDNI(int dni)
{
  char letra[] = "TRWAGMYFPDXBNJZSQVHLCKE";

  return letra[dni%23];
}

En definitiva, necesitamos averiguar el resto de el número del DNI entre 23 (lo cual nos dará una cifra entre 0 y 22), cada cifra corresponderá con una letra: el 0 con la T, el 1 con la R, el 2 con la W…

Podemos utilizar esta función, no para generar, sino para validar un DNI almacenado en una cadena de caracteres:

1
2
3
4
5
6
7
short verificaDNI(char *dni)
{
  if (strlen(dni)!=9)
      return 0;
  else
    return (letraDNI(atoi(dni))==dni[8]);
}

En ella, convertimos el número a entero (después de verificar que hay 9 caracteres), y se lo pasamos a letraDNI() para que genere una letra, luego comparamos la letra generada con la letra introducida por el usuario.

Aquí vemos el código completo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/**
*************************************************************
* @file dni.c
* @brief Comprueba la letra del DNI (España)
*
* @author Gaspar Fernández <blakeyed@totaki.com>
* http://totaki.com/poesiabinaria/algoritmos/
*************************************************************/


#include <stdlib.h>
#include <stdio.h>
#include <string.h>

char letraDNI(int dni)
{
  char letra[] = "TRWAGMYFPDXBNJZSQVHLCKE";

  return letra[dni%23];
}

short verificaDNI(char *dni)
{
  if (strlen(dni)!=9)
      return 0;
  else
    return (letraDNI(atoi(dni))==dni[8]);
}

int main(int argc, char *argv[])
{
  char dni[20];
 
  printf ("Introduce tu DNI con letra (sin espacios): ");
  scanf("%s", dni);

  if (verificaDNI(dni))
    printf ("El DNI es correcto\n");
  else
    printf ("El DNI no es correcto\n");
   
  return EXIT_SUCCESS;
}

Descargar: dni.c (838bytes)

Curioso e interesante V: Windows phone VS SD, Cubo en 3D con HTML5+CSS3,Curiosidades de la sangre, número PI y frigoríficos linuxeros y más

Sábado, 27 de Noviembre de 2010 Gaspar Fernández 2 comentarios

Capicúa recursivo en C

Viernes, 11 de Diciembre de 2009 Gaspar Fernández 8 comentarios
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <stdio.h>
#include <stdlib.h>

int alreves(int n, int digitos)
{
  int resto, cocie;

  if (n<10)     // Si tenemos un número de dígitos menor a 2, devolvemos n
    return n;
  else
    {
      resto = n % 10;
      cocie = n / 10;
      return resto*digitos + alreves(cocie, digitos/10);
    }
}

int main()
{
  int num, rev;
  int digitos = 1;
  int tmp;
  printf("Dame un numero: ");
  scanf("%d", &num);
  // Hacemos un número 10^(numero de cifras-1) con esto alreves determinará el
  // número de cifras que tiene el número dado.
  tmp =num;
  while (tmp>=10)
    {
      tmp=tmp/10;
      digitos=digitos*10;
    }

  rev = alreves(num, digitos);

  // Capicúa o no ?
  if (rev==num)
    printf("\nEs capicua");
  else
    printf("\nNO es capicua");

  return 0;
}

Una posible solución al cálculo de números capicúa en C. La verdad es que tenemos muchas soluciones a este problema, ésta es una de ellas. El tema es, ¿acarreamos el número de cifras? podemos calcularlo a cada recursión (al principio de alreves()), o en lugar de este número tan raro (1 para 1 cifra, 10 para 2 cifras, 100 para 3 cifras…), poner un número del tipo 1, 2, 3… éste sería capaz de dar la vuelta a número más grandes.

En fin, sólo es una de las 10.000 posibles soluciones al problema :)

Categories: C/C++ Tags: , , ,

Visita otras webs de la red