Los 100 fuegos

UNIVERSIDAD CENTRAL DEL ECUADOR
INGENIERÍA MATEMÁTICA
PROGRAMACIÓN I
PROYECTO:
VERIFICAR CÉDULA DE IDENTIDAD
INTEGRANTES:
 ROY TORRES
 ANDRÉS IPIALES
 JESSY CANCÁN
 BRYAN FERNÁNDEZ
QUITO, 22 DE JULIO DEL 2015

VERIFICADOR DE CÉDULA
2
ÍNDICE
ÍNDICE............................................................................................................................................2
RESUMEN.......................................................................................................................................3
CAPÍTULO I....................................................................................................................................4
EL PROBLEMA...........................................................................................................................4
PLANTEAMIENTO DEL PROBLEMA...................................................................................4
OBJETIVOS.............................................................................................................................5
JUSTIFICACIÓN .....................................................................................................................6
CAPÍTULO II ..................................................................................................................................7
MARCO TEÓRICO .....................................................................................................................7
RECOMENDACIONES.................................................................................................................26

3
RESUMEN
El presente proyecto académico, muestra algunos ejemplos de programas relacionados con la
teoría vista en clases. Además mostramos un poco de conceptos básicos relacionados también
con los ciclos, contadores, acumuladores y vectores, que nos ayudan como una herramienta extra
para comprender mejor la programación, por lo cual en nuestro trabajo se presentará un
algoritmo que nos ayude a realizar procesos matemáticos los mismos que indicarán si una cédula
que ingresamos es verdadera o no mediante la verificación del último dígito.

4
CAPÍTULO I
EL PROBLEMA
PLANTEAMIENTO DEL PROBLEMA
El proyecto académico está dirigido a estudiar y comprender la forma en cómo se trabaja
en programación con ciclos repetitivos, acumuladores y contadores.
La verificación de cédulas usando métodos matemáticos es de mucha importancia, la cual
se origina al querer verificar cédulas para que la presentación de la información sea más clara,
entendible y estética, este es un abrebocas para las personas que están iniciándose en este ámbito
de la programación.
La utilización de vectores, cadenas y ciclos repetitivos constituye actualmente una parte
esencial en los lenguajes de programación, ya que la mayoría de los datos se introducen en los
recursos ya mencionados.
El concepto de vectores ha ayudado a ordenar y resolver diversos problemas de la vida
real por lo que su estudio es de gran importancia siendo esta la que ayudará en el presente
proyecto a resolver el objetivo propuesto.
Se realizarán tres diferentes lenguajes de programación los cuales son Visual Basic, C++
y Java, estos lenguajes presentarán un mismo algoritmo pero con características diferentes en sus
lenguajes de códigos e interpretación de los mismos.

5
OBJETIVOS
Objetivo General:
 Estudiar y comprender los ciclos repetitivos, contadores, acumuladores y vectores, su uso
para poder tener mayores facilidades a la hora de resolver ciertos algoritmos que
requieren de estas estructuras.
Objetivos Específicos:
 Conocer que es un vector.
 Crear un programa que facilite el registro de números de cedula y verificar si estos son o
no reales.
 Codificar una tarea sencilla convenientemente especificada utilizando lo estudiado.

6
JUSTIFICACIÓN
El presente trabajo es de gran importancia ya que con este se pretende dar una facilidad
en lo que es el registro y validación de cédulas de identidad.
Los aspectos novedosos a investigarse en el presente trabajo son: como ingresar cadenas
tipo char para que los datos ingresados sean leídos como una cadena y no por partes.
Al ser este una investigación interesante y distractora tendrá gran acogida puesto que es
fácil de utilizarla, solo se necesita el número de cédula de la persona a la cual se desea verificar.

7
CAPÍTULO II
MARCO TEÓRICO
CICLOS REPETITIVOS
Los ciclos repetitivos también llamados lazos o bucles permiten repetir una operación o
secuencia de operaciones en función de ciertas condiciones. Es un segmento de un algoritmo o
programa cuyas instrucciones se repiten un número determinado de veces mientras se cumpla
una determinada condición. Dentro de los ciclos se utilizan contadores y acumuladores, que
regulan que el ciclo llegue a su fin.
Contador: Es un tipo de variable que incrementa o decrementa su valor en un valor constante
Cuando decimos incrementa estamos sumando. Ejemplo: Veces = Veces + 1
Como se puede observar a la variable veces se le está incrementando un valor constante (1); es
decir a su contenido le sumas el valor y se vuelve a guardar en la misma variable.
Acumulador: Es una variable que incrementa o decrementa su contenido en cantidades
variables.
Ejemplo: Nomina = Nomina + sueldo
Las estructuras de control iterativas se clasifican en tres tipos:
Mientras: (While-do) - el ciclo mientras es la estructura básica que permite repetir varias veces
una secuencia de operaciones, mientras se cumpla una determina condición.
Repetir: (repeat-until) - las operaciones de lazo repetir son ejecutadas hasta que la condición sea
cierta.
Para: (for) se utiliza cuando se puede determinar el número de veces que hay que ejecutar las
instrucciones.

8
Ilustración 1: CICLO PARA
Ilustración 2: CICLO MIENTRAS Y REPEAT
ACUMULADORES
El concepto de acumulador guarda relación estrecha con el de contador. Podríamos decir que el
contador es un tipo específico de acumulador. Definiremos acumulador como un elemento cuyo
contenido actual se genera a partir de su contenido precedente.
En general, los valores del acumulador se van generando a través de sumas (o restas) sucesivas.
Casos particulares serían los de generación de valores a partir de multiplicaciones (o divisiones)
u otras operaciones matemáticas.
La expresión genérica de la evolución de un acumulador A sería:

9
Sumas sucesivas Restas sucesivas Multiplicaciones sucesivas Divisiones sucesivas
A = A + B
A = A + C
A = A + D
.
A = A + X
A = A – B
A = A – C
A = A – D
.
A = A – X
A = A * B
A = A * C
A = A * D
.
A = A * X
A = A / B
A = A / C
A = A / D
.
A = A / X
Ilustración 3: ACUMULADORES
HERRAMIENTAS PARA LA PROGRAMACIÓN
Llamaremos herramienta a una parte del código cuyo fin es apoyar una construcción más amplia
y que resulta efectiva en distintos programas. Un martillo es una herramienta que nos será útil
para construir una casa de madera, resultando además efectivo para otro tipo de construcciones
como una casa de bloques, un garaje, un edificio, un centro comercial, etc. Así herramientas
podrían ser: una variable, un bucle, una serie de instrucciones... que podemos usar en distintos
programas para cumplir un fin.
[Pseudocódigo Mientras ... Hacer aprenderaprogramar.com]
Mientras i < límite Hacer
Instrucción 1
Instrucción 2
i = i + 1
Repetir
Ilustración 4: HERRAMIENTAS

10
Por supuesto se pueden introducir variantes en la condición (i <= límite, i > límite, i >= límite...)
o en el contador (i = i + 2, i = i + 3, i = i + 15, i = i – 1, i = i – 2, i = i – 15, etc.). Es decir, el
contador puede funcionar sumando o restando, contando hacia adelante o hacia atrás, y de uno en
uno, de dos en dos o lo que se desee.
Se ha de tener en cuenta que una mala definición del contador, límite y progresión puede dar
lugar a un bucle infinito. Por ejemplo si límite > i, progresión es i = i – 1 y condición es i <
límite, el bucle no se acabará nunca ya que la progresión da lugar a que la variable i siempre siga
siendo menor que el límite.
VECTORES, ARRAYS O ARREGLOS
 En C a los vectores también se les llama arrays o arreglos.
 Los arrays son:
o Conjuntos de variables del mismo tipo.
o Que tienen el mismo nombre.
o Y se diferencian en el índice.
 Es un modo de manejar una gran cantidad de datos del mismo tipo bajo un mismo
nombre o identificador.
DECLARACIÓN DE UN ARRAY
tipo nombre[tamaño];
 Tipo: Tipo que tienen el conjunto de variables int, float, double,…
 Nombre: Identificador con el nombre del array
 Tamaño: Cantidad de espacios de memoria que queremos reservar para este array
o Importante: Debe ser un entero constante, conocido en tiempo de compilación.

11
INICIALIZACIÓN DE UN ARRAY
tipo nombre[tamaño] = {a, b, c,…};
 El número de valores entre llaves tiene que ser menor o igual al tamaño.
o Si es menor el resto de los valores se quedan sin inicializar.
 Existe una forma alternativa:
tipo nombre[] = {a, b, c,…};
 Si no se especifica el tamaño se reservarán tantos espacios como elementos haya entre
llaves.
ACCESO A LOS ELEMENTOS DE UN ARRAY
Para un array de tamaño N y nombre V accederemos al elemento i como V[i].
Ese valor puede ser leído (imprimido, asignado a otra variable,…) o modificado (dándole un
valor) como cualquier otra variable.
V[i] = valor;
Importante: Los índices en los arrays de C van desde 0 hasta (N-1)
Ilustración 5: ACCESO A LOS ELEMENTOS DE UN ARRAY

12
ARRAYS MULTIDIMENSIONALES
 Declaración
tipo nombre[N1][N2][…];
 Utilización
Nombre[i1][i2]
– 0 < i1 < N1
– 0 < i2 < N2
– …
USO DEL SWITCH
Una instrucción switch (alternativa múltiple) permite seleccionar, por medio de una expresión, el
siguiente bloque de instrucciones a ejecutar de entre varios posibles. En lenguaje C, para escribir
una instrucción alternativa múltiple (switch) se utiliza la sintaxis:
switch ( <expresión> )
{
case <expresión_1> : [ <bloque_de_instrucciones_1> ]
[ break; ]
case <expresión_2> : [ <bloque_de_instrucciones_2> ]
[ break; ]
...
case <expresión_n> : [ <bloque_de_instrucciones_n> ]
[ break; ]
[ default : <bloque_de_instrucciones_n+1> ]
}

13
El resultado de evaluar la <expresión> debe ser un valor perteneciente a un tipo de dato finito y
ordenado, es decir, entero, lógico, carácter, enumerado o subrango.
Dependiendo del valor obtenido al evaluar la <expresión>, se ejecutará un bloque de
instrucciones u otro.
Opcionalmente, se puede escribir un <bloque_de_instrucciones_n+1> después de “default:”. Este
bloque de instrucciones se ejecutará en el caso de que el valor obtenido al evaluar la
<expresión>, no se encuentre en ninguna de las expresiones después de cada case.
El algoritmo completo se presenta enseguida.
CÓDIGO EN VISUAL BASIC:
1.- Definiremos las variables q vamos a necesitar
Sub Macro1()
Dim str As String, dest As String
Dim digito(20) As Integer
Dim asci As Integer
Dim i As Integer
Dim coeficientes(10) As Integer
Dim acumulador As Integer
Dim a As Integer
Dim b As Integer
Dim c As Integer
Dim verificador As Integer
Dim opciones(24) As Integer
2.-Declaramos la cadena coeficientes 1*1
coeficientes(1) = 2
coeficientes(2) = 1
coeficientes(3) = 2
coeficientes(4) = 1
coeficientes(5) = 2
coeficientes(6) = 1
coeficientes(7) = 2
coeficientes(8) = 1
coeficientes(9) = 2
coeficientes(10) = 0

14
3.-Mensaje de inicialización del programa
MsgBox ("************PROGRAMA VERIFICADOR DE LA CEDULA DE
IDENTIDAD***********")
Worksheets("Hoja1").Cells(1, 5).Value = ("PROGRAMA VERIFICADOR DE LA CEDULA DE
IDENTIDAD")
4.-Desplazamos el siguiente mensaje
dest = ""
str = InputBox("Ingrese el numero de cedula")
5.-Ciclo para generar la verificación de la cedula de identidad
For i = 1 To Len(str)
digito(i) = Mid(str, i, 1)
multiplicacion = digito(i) * coeficientes(i)
If (multiplicacion > 9) Then
multiplicacion = multiplicacion - 9
End If
acumulador = acumulador + multiplicacion
Worksheets("Hoja1").Cells(2, 2).Value = ("PROYECTO DE LA VERIFICACION DE LA
CEDULA ")
Worksheets("Hoja1").Cells(3, 2).Value = ("NUMERO DE CEDULA VERIFICADO")
5.1.-Impresión del número de cedula en las celdas de Excel
Worksheets("Hoja1").Cells(4, i).Value = digito(i)
Next i
5.3.-Ciclos de acumulación y verificación de la cedula de identidad
a = (acumulador / 10)
b = a + 1
c = b * 10
verificador = c – acumulador
5.2.- Desplazamos el siguiente mensaje con sus respectivas impresiones en las celdas de Excel
MsgBox ("LA SUMA DE LOS DIGITOS DE SU CEDULA ES:" & acumulador)

15
Worksheets("Hoja1").Cells(5, 1).Value = ("LA SUMA DE LA CEDULA VERIFICADA")
Worksheets("Hoja1").Cells(5, 4).Value = " " & acumulador
MsgBox ("EL DIJITO VERIFICADOR ES:" & verificador)
Worksheets("Hoja1").Cells(6, 1).Value = ("DIGITO VERIFICADOR")
Worksheets("Hoja1").Cells(6, 4).Value = verificador
6.-If de condiciones para ver si la cedula de identidad es falsa o verdadera
If (digito(10) = verificador) Then
MsgBox ("La cedula es verdadera")
Worksheets("Hoja1").Cells(7, 1).Value = ("LA CEDULA DE IDENTIDAD INGRESA ES
VERDADERA")
Else
MsgBox ("La cedula es falsa")
Worksheets("Hoja1").Cells(7, 1).Value = ("LA CEDULA DE IDENTIDAD INGRESA ES
FALSA")
Worksheets("Hoja1").Cells(8, 1).Value = ("USTED IRA A LA CARCEL")
7.-Fin Del algoritmo
End Sub
AHORA PROCEDEREMOS A REALIZAR LAS DIFERENTES PRUEBAS Y ASÍ
VERIFICAR LA VALIDEZ DEL ALGORITMO:
*Verificador de la cedula en Visual Basic *
a) Cuando la cedula de identidad es verdadera
1.-Ejecutacion del programa

16
2.-Inicializacion del programa
3.-Ingreso de la cedula de identidad
4.-Ventanas de resultado
*Suma de los dígitos de la cedula
*Digito verificador
*Validez de la cedula de identidad (VERDADERA)

17
5.-Impresión en las celdas de Excel
b) Cuando la cedula de identidad es falsa
1.-Ejecutacion del programa
2.-Inicializacion del programa
3.-Ingreso de la cedula

18
4.- Ventanas de resultados
*La suma de los dígitos de la cedula son igual a 0
*El digito verificar es 10 (ERROR)
*Validez de la cedula de identidad(FALSA)
5.-Impresión en las celdas de Excel

19
CÓDIGO EN C:
#include "stdafx.h"
#include "stdafx.h"
#include "string.h"
#include <stdio.h>
#include <stdlib.h>
int _tmain(int argc, _TCHAR* argv[])
{
int coeficientes[10] = { 2, 1, 2, 1, 2, 1, 2, 1, 2, 0 };
char cedula[20];
int i, temporal[20], multiplicacion, acumulador, verificador, a, b, c, j, dimension;
printf("***********PROGRAMA VERIFICADOR DE CEDULAS***********");
printf("n");
printf("INGRESE CON CUANTAS CEDULAS DESEA TRABAJAR");
scanf_s("%d", &dimension);
fflush(stdin);
system("cls");
for (j = 0; j < dimension; j++)
{
printf("POR FAVOR INGRESE EL NUMERO DE CEDULA QUE DESEE
COMPROBAR");
gets_s(cedula);
acumulador = 0;
i = 0;
while (i<10)
{
temporal[i] = int(cedula[i] - 48);
multiplicacion = temporal[i] * coeficientes[i];
if (multiplicacion>9)
{
multiplicacion = multiplicacion - 9;
}
acumulador = acumulador + multiplicacion;
i = i + 1;
}
a = (acumulador / 10);
b = a + 1;
c = b * 10;
verificador = c - acumulador;
printf("n");

20
printf("LA SUMA DE LOS DIGITOS DE SU CEDULA ES:t%dn",
acumulador);
printf("n");
printf("EL DIGITO VERIFICADOR ES:t%dn", verificador);
printf("n");
if (int(cedula[9] - 48) == verificador)
{
printf("LA CEDULA ES VALIDA n");
printf("n");
if (int(cedula[0] - 48) == 1)
{
switch (cedula[1] - 48)
{
case 0:
printf("USTED PERTENECE A LA PROVINCIA DE
IMBABURA");
break;
case 1:
LOJA");
break;
case 2:
printf("USTED PERTENECE A LA PROVINCIA DE LOS
RIOS");
break;
case 3:
MANABI");
break;
case 4:
MORONA SANTIAGO");
break;
case 5:
NAPO");
break;
case 6:
PASTAZA");
break;
case 7:
PICHINCHA");

21
break;
case 8:
TUNGURAHUA");
break;
case 9:
ZAMORA CHINCHIPE");
break;
}
}
else
{
if (int(cedula[0] - 48) == 2)
{
{
case 0:
printf("USTED PERTENECE A LA PROVINCIA
DE GALAPAGOS");
break;
case 1:
DE SUCUMBIOS");
break;
case 2:
DE ORELLANA");
break;
case 3:
DE SANTO DOMINGO");
break;
case 4:
DE SANTA ELENA");
break;
}
}
else
{
if (int(cedula[0] - 48) == 0)
{
{

22
case 1:
printf("USTED PERTENECE A LA
PROVINCIA DE AZUAY");
break;
case 2:
PROVINCIA DE BOLIVAR");
break;
case 3:
PROVINCIA DE CAÑAR");
break;
case 4:
PROVINCIA DE CARCHI");
break;
case 5:
PROVINCIA DE COTOPAXI");
break;
case 6:
PROVINCIA DE CHIMBORAZO");
break;
case 7:
PROVINCIA DEL ORO");
break;
case 8:
PROVINCIA DE ESMERALDAS");
break;
case 9:
PROVINCIA DE GUAYAS");
break;
}
}
}
}
printf("n");
printf("-----------------------------------------------------------------------------");
}
else
{

23
printf("LA CEDULA QUE INGRESO ES ES FALSA");
printf("n");
}
}
printf("n");
getchar();
getchar();
return 0;
}
CÓDIGO JAVA:
package javaapplication21;
import java.util.*;
public class JavaApplication21 {
public static void main(String[] args)
{
int i,k,divi,cedula,s,A,d,resta,suma,t,p,v;
int[] vector=new int[100];
int [] coe=new int[100];
int [] multi=new int [100];
Scanner dato = new Scanner(System.in);
System.out.print("cuantas cedulas va a ingresar");
k = dato.nextInt();
for(i=1;i<k+1;i++)
{
System.out.print("Ingrese la cedula " + i + ":");
cedula= dato.nextInt();
divi = cedula / 100000000 ;
if (divi < 24)
{
switch (divi)
{
case 1: System.out.print("la cedula " + i + " pertenece a azuay");
break;
case 2: System.out.print("la cedula " + i + " pertenece a Bolivar");
break;
case 3: System.out.print("la cedula " + i + " pertenece a Cañar");
break;
case 4: System.out.print("la cedula " + i + " pertenece a Manabi");
break;
case 5: System.out.print("la cedula " + i + " pertenece a Carchi");
break;

24
case 6: System.out.print("la cedula " + i + " pertenece a Cotopaxi");
break;
case 7: System.out.print("la cedula " + i + " pertenece a Chimborazo ");
break;
case 8: System.out.print("la cedula " + i + " pertenece a El Oro");
break;
case 9: System.out.print("la cedula " + i + " pertenece a Esmeraldas");
break;
case 10: System.out.print("la cedula " + i + " pertenece a Imbabura");
break;
case 11: System.out.print("la cedula " + i + " pertenece a Loja");
break;
case 12: System.out.print("la cedula " + i + " pertenece a Los Ríos");
break;
case 13: System.out.print("la cedula " + i + " pertenece a Manabi");
break;
case 14: System.out.print("la cedula " + i + " pertenece a Morona Santiago");
break;
case 15: System.out.print("la cedula " + i + " pertenece a Napo");
break;
case 16: System.out.print("la cedula " + i + " pertenece a Pastaza");
break;
case 17: System.out.print("la cedula " + i + " pertenece a Picincha");
break;
case 18: System.out.print("la cedula " + i + " pertenece a Tunguragua");
break;
case 19: System.out.print("la cedula " + i + " pertenece a Zamora Chinchipe");
break;
case 20: System.out.print("la cedula " + i + " pertenece a Galápagos");
break;
case 21: System.out.print("la cedula " + i + " pertenece a Sucumbios");
break;
case 22: System.out.print("la cedula " + i + " pertenece a Orellana");
break;
case 23: System.out.print("la cedula " + i + " pertenece a Santo Domingo de los
Tsáchilas");
break;
case 24: System.out.print("la cedula " + i + " pertenece a Santa Elena");
break;
}
if (divi > 24)
{
System.out.print("lacedula no es valida");
}
System.out.print("n");
A=1000000000;

25
coe[1]=2;
coe[2]=1;
coe[3]=2;
coe[4]=1;
coe[5]=2;
coe[6]=1;
coe[7]=2;
coe[8]=1;
coe[9]=2;
t=0;
for(i=1;i<11;i++)
{
vector[i]=(cedula/A);
d=(A*vector[i]);
resta=(cedula-d);
cedula=resta;
s = A/10;
multi[i]=(vector[i]*coe[i]);
A=s;
multi[i]=(vector[i]*coe[i]);
if(multi[i]>10)
{
multi[i]=multi[i]-9;
}
System.out.print(multi[i]);
}
suma=multi[1]+multi[2]+multi[3]+multi[4]+multi[5]+multi[6]+multi[7]+multi[8]
+multi[9];
System.out.print("la suma es:");
System.out.print(suma);
d=(suma/10);
p=(d+1);
resta=(p*10);
v=(resta - suma);
System.out.print("el último dígito verificador es:");
System.out.print(v);
}
}
}

26
CONCLUSIONES
 En nuestra época la tecnología ocupa un papel muy importante en la sociedad ya que se
ha convertido en una de las herramientas más utilizadas por la sociedad.
 La programación es inevitable en la vida diaria de las personas para cada cosa que
hacemos hay un orden o una sucesión de pasos para llegar a un objetivo.
RECOMENDACIONES
 Se deberá usar la tecnología como medio de información para la investigación sin
embargo se recomienda utilizar correctamente
 Es necesario tener claro el concepto de matriz, para poder utilizarlo en cualquier ámbito
de la programación, en este caso como algoritmo.
 Se recomienda tener cuidado a la hora de realizar programas de este tipo, ya que estos
cuentan con muchos ciclos de for, if y else, entonces al estructurar el programa se deben
inicializar y finalizar correctamente estos ciclos repetitivos.
 En el momento que se necesite cambiar el programa a otro lenguaje será algo difícil, ya
que la mayoría de programas están hechos en lenguaje Java, entonces para poder realizar
el cambio se necesita de un amplio conocimiento sobre este lenguaje.
BIBLIOGRAFÍA
Objetivo aprender a programar, recuperado el 22 de julio el 2015
http://www.aprenderaprogramar.com/index.php?option=com_attachments&task=download&i
https://www.emaze.com/@ALRWOFQR/informatica
Estudios y Trayectoria Profesional de Carlos Pes
Ingeniero Técnico en Informática de Gestión por la Universidad Politécnica de Valencia (UPV),
terminó sus estudios universitarios en el año 2000. Recuperado el 22 de julio del 2015
http://www.carlospes.com/curso_de_lenguaje_c/02_03_alternativa_multiple.php

Los 100 fuegos

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (18)

Destacado

Destacado (11)

Similar a Los 100 fuegos

Similar a Los 100 fuegos (20)

Más de Brenda Jazmin

Más de Brenda Jazmin (6)

Último

Último (20)

Los 100 fuegos