Lenguaje de Programacion Borland

Lenguaje de programacin estructurada y sus aplicaciones en Borland C++ 5.0.
Teodoro Luciano Crdova Neri
Lenguaje de programacin
estructurada
y sus aplicaciones en Borland C++ 5.02
Universidad Nacional de Ingeniera

Editorial Universitaria
Rector Dr. Ing. Aurelio Padilla Ros

Primer Vicerrector Geol. Jos S. Martnez Talledo
Segundo Vicerrector Msc. Ing. Walter Zaldvar lvarez
Primera edicin, mayo de 2012
Lenguaje de programacin estructurada y sus aplicaciones en Borland C++ 5.0.2
Impreso en el Per / Printed in Peru
Derechos reservados
Derechos de edicin
Editorial Universitaria
Av. Tpac Amaru 210, Rmac Lima

Pabelln Central / Stano
Telfs. 4814196 / 4811070 anexo 215
Correo-e: eduni@uni.edu.pe
Jefe EDUNI: Prof. lvaro Montao Freire
Coordinador Editorial: Nilton Zelada Minaya
Impreso en la Imprenta de la Editorial Universitaria de la
ISBN 978-612-4072-23-9
Hecho el Depsito Legal en la Biblioteca Nacional del Per
N 2011-13203
Prohibida la reproduccin de este libro por cualquier medio,
total o parcialmente, sin permiso expreso del autor.
II
Palabras liminares
Me complace felicitar a los docentes de nuestra Universidad ganadores del II
Concurso para la Publicacin de Libros de Texto convocado por el Rectorado
y realizado en cada una de las Facultades. Una de las polticas medulares del
Rectorado es la permanente mejora en la calidad acadmica, y en ese sentido nos
interesa que cada docente tenga la oportunidad de convertir su labor cotidiana
de enseanza en textos para uso de los estudiantes universitarios de todo el pas.
Los autores han hecho un meritorio esfuerzo para organizar los temas de sus
exposiciones, realizando investigaciones y consultando fuentes peruanas y
extranjeras, as como recogiendo el fruto del dilogo con sus colegas y los propios
estudiantes. Asimismo, se han esmerado en presentar sus cursos de manera que
facilita el acceso por parte de los interesados.
La publicacin de textos acadmicos es una de las obligaciones de toda
universidad y uno de los ndices que se toma en cuenta para la evaluacin de
la calidad acadmica. Por ende, seguiremos apoyando la publicacin de libros
y revistas a travs de nuestra Editorial Universitaria, cuya meta es formar parte
del liderazgo peruano en la industria editorial dedicada a ingeniera, ciencia y
arquitectura.
Es responsabilidad de la Universidad Nacional de Ingeniera aportar al Per
un liderazgo de base tecnolgica que trabaje en estrecha asociacin con las
autoridades gubernamentales, los dirigentes empresariales y la sociedad civil
en su conjunto, lo cual requiere de una poltica editorial y de publicaciones que
estamos impulsando.
Dr. Ing. Aurelio Padilla Ros

Rector
III
IV
A mis padres Luis y Gliceria, gracias

por todo.
A Mara, mi compaera de siempre.
A mis tres hijos, frutos del amor y
compromiso con la vida...
VI
Reconocimiento y gratitud a todos mis maestros

por su importante apoyo Profesional.
Y en especial al Decano FIIS Mg. Luis Acua P.
y al Ing. Carlos Chafloque E. por su apoyo
VII
VIII
ndice
Presentacin................................................................................................................XIII
Introduccin.................................................................................................................XV
Captulo I
Generalidades................................................................................................................ 1
1.1 Introduccin......................................................................................................... .1
1.2 Introduccin a la programacin......................................................................... 1
1.3 Caractersticas de un algoritmo de computador.............................................. 2
1.4 Lenguajes de programacin................................................................................ 2
1.5 Lenguajes de mquina......................................................................................... 3
1.6 Lenguaje de bajo nivel.......................................................................................... 3
1.7 Lenguaje de alto nivel.......................................................................................... 3
1.8 Programa ejecutable............................................................................................. 3
1.9 Compilador............................................................................................................ 3
1.10 Palabras reservadas.............................................................................................. 3
1.11 Identificadores....................................................................................................... 4
1.12 Comentarios........................................................................................................... 4
1.13 Tipos de datos....................................................................................................... 5
1.14 Carcter (char)....................................................................................................... 5
1.15 Declaracin de constantes simblicas................................................................ 6
Captulo II
Estructuras de control................................................................................................. 11
2.1 Estructuras secuenciales ................................................................................... 11
2.2 Estructuras selectivas condicionales................................................................ 16
2.2.1 Estructura selectiva simple............................................................................... .16
2.2.2 Estructura selectiva compuesta........................................................................ 18
2.2.3 Estructura condicional con anidamiento......................................................... 19
2.3 Estructuras mltiples......................................................................................... 21
IX
2.4 Estructuras repetitivas....................................................................................... 29

2.4.1 Estructura repetitiva con pretest de prueba................................................... 29
2.4.2 Estructura repetitiva con postest de prueba.................................................. 37
2.4.3 Estructura repetitiva cuando se conoce el nmero de iteraciones ............. 44
2.4.4 Estructuras mltiples mdulo de operaciones aritmticas....................... 85
Captulo III
Estructuras de datos arrays...................................................................................... 123
3.1
3.2
3.3

3.4
Introduccin a las estructuras de datos......................................................... 124

Arraysunidimensionales: los vectores........................................................... 124
Operaciones con vectores: mtodos de ordenacin, insercin,
eliminacin, bsquedas, crear sublistas, etc. Aplicaciones......................... 126
Arrays bidimensionales................................................................................... 149
Captulo IV
Las cadenas de caracteres......................................................................................... 199
4.1 Introduccin...................................................................................................... 199
4.2 Punteros a cadenas........................................................................................... 200
4.3 Funciones para el tratamiento de cadenas:strlen(), strcat()........................ 202
4.4 Copia de cadenas:stpcpy(), strcpy(), strncpy()............................................. 204
4.5 Funciones para buscar un carcter en una cadena:strchr(), strrchr()........ 206
4.6 Funcin para reconocimiento de una porcin de cadena: strspn(),

strcspn(), strpbrk() y strtok().......................................................................... 208
4.7 Funciones para la comparacin de cadenas: strcmp(), strnicmp(),
stricmp()............................................................................................................. 210
4.8 Transformacin de cadenas: strset(), strnset().............................................. 213
4.9 Funciones para invertir cadenas:strxfrm(), strrev()..................................... 214
4.10 Conversin a maysculas y minsculas: strupr(),strlwr().......................... 215
4.11 Inclusin de una cadena en otra cadena........................................................ 215
Captulo V
Programacin modular............................................................................................. 221
5.1 Introduccin...................................................................................................... 221
5.2 Funciones definidas por el usuario................................................................ 222
5.3 Declaracin y definicin de funciones........................................................... 224
5.4 Lista de parmetros y sus tipos de datos...................................................... 225
5.5 Variables locales y globales............................................................................. 226
5.6 Parmetros por defecto, valor......................................................................... 227
5.7 Funciones que llaman a funciones................................................................. 246
5.8 Funciones recursivas........................................................................................ 259
X
Captulo VI
Registros..................................................................................................................... 273
6.1
6.2
6.3
6.4
6.5
6.6
Introduccin. Definiciones.............................................................................. 273

Definicin y declaracin de una estructura.................................................. 275
Variables registro (instancias)......................................................................... 275
Anidamiento de registros................................................................................ 276
Acceso a los elementos de una estructura..................................................... 276
Aplicaciones....................................................................................................... 277
Captulo VII
Archivos (File)........................................... 307
7.1 Introduccin...................................................................................................... 308
7.2 Caractersticas de los archivos........................................................................ 308
7.3 Archivos (file).................................................................................................... 308
7.4 Apertura de archivos........................................................................................ 308
7.5 Clasificacin de archivos por tipo de contenido: texto, binarios............... 309
7.5.1 Archivos de texto.............................................................................................. 309
7.5.2 Archivos binarios.............................................................................................. 309
7.6 Clasificacin de archivos por tipo de acceso................................................. 310
7.6.1 Archivos secuenciales....................................................................................... 310
7.6.2 Archivos directos: acceso aleatorio ............................................................... 310
7.7 Direcciones lgicas y direcciones fsicas........................................................ 310
7.8 Clculo de direcciones fsicas.......................................................................... 311
7.9 Funciones para el manejo de archivos........................................................... 311
7.10 Declaracin de la variable lgica (alias) del archivo................................ 311
7.11 Funcin para procesar archivos...................................................................... 311
7.12 Validar la apertura de un archivo................................................................... 312
7.13 Cierre de archivos usando fclose() y fcloseall()............................................ 312
7.14 Escritura de registros usando fwrite()........................................................... 313
7.15 Vaciando los buffers usando fflush ()........................................................... 313
7.16 Lectura de registros usando fread ().............................................................. 313
7.17 Funcin para acceso de archivo...................................................................... 313
7.18 Conocer posicin del apuntador del archivo:funcin ftell()...................... 314
7.19 Posicionando apuntador al inicio del archivo: rewind()............................. 314
7.20 Detectando el final del archivo con feof()...................................................... 314
7.21 Cambio de nombre de archivo rename()....................................................... 314
7.22 Eliminando archivos con la funcin remove().............................................. 315
XI
Captulo VIII
Programacin dinmica........................................................................................... 327
8.1 Programacin dinmica:punteros.................................................................. 327
8.2 Creacin de un puntero................................................................................... 328
8.3 Operadores........................................................................................................ 328
8.4 Inicializacin de un puntero............................................................................ 329
8.5 Lista..................................................................................................................... 332
8.6 Pila....................................................................................................................... 332
8.7 Punteros nivel RAM......................................................................................... 336
8.8 Punteros y archivos......................................................................................... 346
8.9 Compendio de problemas............................................................................... 349
Bibliografa.................................................................................................................. 357
ndice temtico. ............. 359
XII
Presentacin
En el milenio pasado, como en el actual, se exige constantemente a la universidad
elevar su calidad acadmica, especialmente la formacin profesional que est
relacionada directamente con la formacin del docente universitario.
En general, el paradigma de la docencia universitaria est ligado a dos variables:
el dominio y experiencia de la especialidad profesional y el conocimiento y praxis
del proceso de enseanza - aprendizaje en sus asignaturas correspondientes.
Dentro de este contexto, felicito a las autoridades de la Universidad y al ente
normativo de promocionar actividades estratgicas en el sector acadmico, tales
como la publicacin de textos universitarios, actividad estratgica que beneficia a
la universidad como al docente, debido que en conjunto se est cumpliendo con
el perfil de la universidad: Ciencia Tecnologa y Sociedad (CTS).
Respecto al docente, estamos en la responsabilidad de proporcionar un conjunto
de enfoques didcticos relacionados con nuestro rol universitario, donde el
proceso de enseanza - aprendizaje, mtodos, tcnicas y evaluacin, engloben las
TICS buscando mejoras continuas. En este sentido, como docente de la asignatura
Lenguaje de Programacin Estructurada, asignatura obligatoria que forma
parte del plan curricular de vuestra Facultad, presento el texto denominado
Aplicaciones en Borland C++ 5.02 Programacion Estructurada, organizado
y diseado con base en la experiencia de ms de 20 aos comprometido con el
concepto de programacin en lenguajes estructurados.
Esperando que la lectura, anlisis y reflexin de la antologa que presento sirva
para acrecentar el espritu de renovacin institucional, de innovacin profesional
continua y que obviamente trascender al mejor aprendizaje y alta calidad
acadmica de nuestros alumnos, cuando adems de la enseanza presencial,
tambin se dispongan de herramientas didcticas: libros, clases on line, etc.
El autor
XIII
XIV
Introduccin
El comit para el estndar ANSI C se form en el ao 1983 con el objetivo de
crear un lenguaje uniforme a partir del Lenguaje de Programacin C original,
desarrollado por Kernighan y Ritchie en 1972, en la ATT. Respecto a C++ comenz
a desarrollarse en 1980 por B. Stroustrup. Al comienzo era una extensin del
lenguaje C, que fue denominada C with classes. Este nuevo lenguaje comenz
a ser utilizado fuera de la AT&T en 1983. Ante la gran difusin y xito que iba
obteniendo en el mundo de los programadores, la AT&T comenz a estandarizarlo
internamente en 1987. En 1989 se form un comit ANSI para estandarizarlo a
nivel internacional.
En la actualidad, el C++ es un lenguaje verstil, potente y general. Su xito
entre los programadores permite ocupar el primer puesto como herramienta
de desarrollo de aplicaciones, pues mantiene las ventajas del C en cuanto a
riqueza de operadores y expresiones, flexibilidad, conciso y eficiencia. Adems,
ha eliminado muchas de las dificultades y limitaciones que tiene C original. La
evolucin de C++ ha continuado con la aparicin de Java, un lenguaje creado
simplificando algunas partes de C++ y aadiendo otras, que se utiliza en la
presente dcada para realizar aplicaciones en internet.
El C++ se presenta como:
1. Lenguaje de programacin procedural (orientado a algoritmos) y por cumplir
con las normas de poseer las tres estructuras de control (secuenciales, condicionales/
mltiples y repetitivas).
2. Lenguaje orientado a objetos (objectoriented programming, OOP). Como
lenguaje procesal se asemeja al C y es compatible con l. Este nivel de programacin
admite una filosofa completamente diferente, que exige del programador un
completo cambio de mentalidad. Las caractersticas propias de la programacin
orientada a objetos, este tema es el ms fascinante, pues C++ cambia radicalmente
su pensamiento de programacin.
Cabe notar que un programa fuente diseado a nivel C++, no compila en C,
pero lo contrario s se cumple. Adems de las estructuras del control, tambin
disponen de estructuras de datos en forma legible al usuario, tales como: listas o
XV
vectores, tablas o matrices, etc. Asimismo, los registros (struct), uniones, archivos
(FILE), programacin dinmica (punteros), procesamiento de cadenas basadas
fuertemente en funciones (strcmp, struppr, etc.).
El presente texto est basado en experiencias obtenidas por ms de dcada y media,
dictando asignaturas en las escuelas de Ingeniera de Sistemas, Computacin e
Informtica de las diferentes universidad del Per (Universidad Nacional de
Ingeniera - Facultad de Ingeniera Industrial y de Sistemas), Universidad de
San Martn, Universidad Antnez de Mayolo, Universidad Tecnolgica del Per,
Universidad San Martn de Porres, etc.).
Me es grato agradecer las sugerencias de colegas que, en su debida oportunidad,
aportaron con sus opiniones para la mejora del presente libro.
El autor
XVI
Captulo 1
Generalidades
Objetivos
- Conocer la biblioteca standard de
Borland C++ 5.02.
- Dar fundamentos para el estudio de
otros lenguajes de programacin en
general y aplicarlos para java, etc.
- Comprender la programacin de nivel estructurada.
- Comprender las tcnicas bsicas para
resolver problemas.
- Desarrollar programas usando las
tcnicas de tipo top-down (de arriba
abajo)
- Usar los operadores lgicos, relacionales, funciones resto y parte entera.
- Usar los tipos de datos enteros, reales, cadenas, booleanos.
1.2 Introduccin a la programacin

1.2.1 Definiciones
Computadora. Una computadora (PC) se puede definir como una mquina
electrnica digital capaz de procesar informacin y producir datos de salida, para
lo cual requiere de datos de entrada. El trmino digital se debe al hecho de que
la informacin almacenada y procesada por la computadora est representada
mediante cdigos numricos binarios formados por ceros y unos (0 y 1) conocidos
como bits , los mismos que con 8 bits, se forma un byte (una palabra).
Debo aclarar, que para los informticos hay una diferencia entre datos e
informacin.
Dato. Es la representacin de algn hecho, concepto o entidad real.

Informacin. Es el resultado del procesamiento de los datos.
Observacin. Para este curso no haremos distincin entre dato e informacin
sino que hablaremos de datos de entrada y datos de salida.
Proceso de informacin en una computadora
Una computadora est compuesta por dos elementos fundamentales: hardware
y software.
Hardware. Est constituido por la parte fsica de la computadora. Es aquello que
podemos ver y tocar. Est formado por el monitor, el teclado, el mouse, la unidad
del sistema, la impresora, etc.
Software. Es la parte lgica de la computadora y est formado por el conjunto de
programas que controlan el funcionamiento de la computadora.
Organizacin fsica de una computadora
El software es el conjunto de datos y programas que usa la computadora y se
guardan en algn dispositivo del hardware, por ejemplo, un disco duro.
Programa. Es un conjunto detallado de instrucciones que instruyen al procesador
para realizar determinados procesos. Los datos pueden ser cualquier informacin
que necesite el programa: caracteres, nmeros, imgenes, etc.
Algoritmo. Es un conjunto de reglas o procedimientos que permiten obtener un
resultado determinado a partir de ciertas reglas definidas por el programador.
1.3 Caractersticas de un algoritmo de computador

Ser algoritmo: tiene que consistir en una secuencia de instrucciones claras y
finitas.
Ser correcto: el algoritmo ha de resolver el problema planteado en todas sus
facetas.
Ser legible: el usuario o usuarios deben comprender la sintaxis.
Ser eficiente: es relativa, porque depende de la mquinas en la que lo ejecutemos.
Existen ejemplos de algoritmos eficientes que ocupan demasiado espacio para
ser aplicados sin almacenamiento secundario lento, lo cual puede anular la
eficiencia.
1.4 Lenguajes de programacin

Sirven para editar programas (instrucciones). Las instrucciones escritas en la
mayora de los lenguajes de programacin no son entendibles directamente
2
por el procesador, sino que requieren de pasos intermedios de traduccin e

interpretacin para convertir.
Estas instrucciones al lenguaje del procesador, conocido como lenguaje mquina.
Podemos citar como lenguajes de programacin a Pascal, borlandc++ 5.02, etc.
1.5 Lenguajes de mquina

Permiten escribir instrucciones directamente entendibles por el procesador. Una
instruccin mquina consiste en una secuencia de dgitos binarios (0 y 1) en la
memoria principal, que le indica al procesador qu operacin mquina debe
realizar. Una coleccin de instrucciones mquina en la memoria principal se
denomina programa en lenguaje mquina.
1.6 Lenguajes de bajo nivel

Los lenguajes de bajo nivel representan un paso hacia la humanizacin de los
lenguajes de programacin, son ms fciles que los lenguajes mquina pero, al
igual que ellos, son dependientes de la mquina. Los lenguajes de bajo nivel son
lenguajes simblicos, siendo el ms importante el lenguaje ensamblador.
1.7 Lenguajes de alto nivel

Los lenguajes de alto nivel son lenguajes humanizados en los que las instrucciones
se escriben utilizando frases del ingls cotidiano (o una mezcla de ingls y otro
idioma) y contienen notaciones matemticas de uso comn, facilitando as el
aprendizaje del lenguaje y la escritura de programas.
1.8 Programa ejecutable

Un programa ejecutable tiene, normalmente, millones de instrucciones y no
necesitan del lenguaje de programacin para ejecutarse, pues solo basta ejecutar
desde el sistema operativo (DOS).
1.9 Compilador
Es una herramienta bsica en el mantenimiento y mejora del sistema operativo.
Por ello este producto est en constante evolucin, ya que de su buen rendimiento
depende en parte el del sistema.
1.10 Palabras reservadas

Llamadas tambin palabras clave, son aquellas que tienen significado especial
para el compilador y se utilizan para declarar variables, estructuras, clases, hacer
operaciones, definir estructuras de control, etc.
Ejemplos:
break do enum int typedef
bool double for
private while
case else if sizeof
1.11 Identificadores
Son secuencias de caracteres que representan a las variables, constantes, tipos,
funciones, clases y etiquetas en un programa. En C++, un identificador vlido
debe cumplir con lo siguiente:
Reglas
13.1. Debe estar formado solamente por letras maysculas (de la A a la Z), o
letras minsculas (de la a a la z) Adicionalmente puede combinarse con el
carcter subrayado ( _ ).
Ejemplo : pc, prom_pc, cont, _nombre.
13.2. Usar dgitos del 0 al 9. Debe comenzar con una letra o letras (nunca con
nmeros).
Ejemplo: pc_01, prom_pc, cont, Lab1, etc.
13.3. Puede comenzar con un subrayado, pero las palabras que comienzan con
dos subrayados son reservadas para el uso interno del compilador.
13.4. No debe contener espacios en blanco, use el subrayado ( _ ) en vez de blancos.
13.5. No usar palabras reservadas del compilador.
Ejemplos de identificadores no vlidos:
3pc:
comienza con un nmero
nombre apellidos: contiene un espacio en blanco
_i_y:
comienza con dos subrayados
x*y:
contiene un carcter no vlido (*)
do:
es una palabra reservada
Nota: C++ es sensible al uso de las maysculas y minsculas. As, A es diferente
de a.
1.12 Comentarios
Son explicaciones literales que sirven para aumentar la legibilidad de los
programas. Estas son ignoradas totalmente por el compilador. En C++, se puede
colocar comentarios en cualquier parte del programa donde sea posible, de dos
maneras:
14.1 Mediante dos barras inclinadas (//), para comentarios de una lnea.
4
14.2 Por los delimitadores (/*..*/) para comentarios de una o ms lneas.

Ejemplo:// comenta respecto a una linea:
/* Comenta respecto a una lnea o varias lneas:
1.13 Tipos de datos

En la siguiente tabla se ilustra los diferentes tipos de datos:
Tipo
Tamao
Lgico
bool
1 bit
true o false
Enteros
unsigned char
8 bits
0 .. 255
char
8 bits
128 .. 127
enum
16 bits
32 768 .. 32 767
unsigned int
16 bits
0 .. 65 535
short int
16 bits
32 768 .. 32 767
int
16 bits
32 768 .. 32 767
unsigned long
32 bits
0 .. 4 294 967 295
long
32 bits
2 147 483 648 .. 2 147 483 647
float
32 bits
3.4E38 .. 3.4E+38
double
64 bits
1.7E308 .. 1.7E+308
long double
80 bits
3.4E4932 .. 1.1E+4932
Reales
Rango
1.14 Carcter (char)

Las constantes que representan a caracteres o acciones especiales. Ejemplos: s,
A, -,|
\a
alerta (bip sonoro)
\b
retroceso (backspace)
\f
salto de pgina en la impresora (formfeed)
\n
nueva lnea (newline)
\r
retorno de carro (carriagereturn)
\t
tabulacin horizontal
\v
tabulacin vertical
\\
barra invertida (backslash)
Constantes cadena (char * o char[])

Son secuencias de caracteres encerrados entre comillas:

Lenguajes de Programacion, Borland C++ 5.0.2
Tambin se pueden incluir secuencias de escape:

\tEstudiar, es una etapa de sabidurias \n
1.15 Declaracin de constantes simblicas

Mediante una directiva #define:
Sintaxis:

#define
nombre
valor
Ejemplos:
# define pi 3.141
# define linea ---------------------------------------------------------------
Puede hacer que una constante tome un valor en funcin de otras:
# define pi 3.141,
# define doble_pi 2*pi
Mediante tipos enumerados:
El tipo enum es til cuando se crean constantes simblicas con valores enteros.
Ejemplo:
enumdias = {lunes=1,martes,miercoles,jueves,viernes,sabado,domingo}
Adems, se puede alterar el orden consecutivo, por ejemplo:
enum colores = {blanco,amarillo,rojo,azul,anterior=64 }
Variables.- Una variable es un identificador vlido cuyo valor puede cambiar
temporalmente durante la ejecucin de un programa. Las variables deben ser
declaradas antes de ser utilizadas.
Sintaxis:
Tipo_de_dato
nombre_de_variable;
en donde tipo_de_dato es cualquier tipo vlido en C++.

Ejemplos
float prom;
// prom es un datos de tipo real.
Operadores.- Tienen una gran utilidad durante la programacin, considerando

su prioridad de evaluacin de operadores y su significado. En la siguiente
grfica, se ilustra la sintaxis y el uso respectivo.

Categora
Operador
Significado
Ejemplo
Negacin
Negacin lgica
(NOT)
!(n<11)
//si n es menor
que 11,devuelve falso (0)
Contador
Incremento
++
Preincremento o
posincremento
n++ usa n y luego incrementa en 1

++n // incrementa n en 1 y luego lo usa n
Contador
Disminuir
--
Predecremento o
posdecremento
--n//
Multiplicar
Multiplicacin
a * b //Multiplica a por b.
Dividir
Divisin
a/b // divide a entre b
Resto
Mdulo (resto)
a%b // devuelve el mdulo de la divisin

entera de a y b (que deben ser enteros)
Operadores
relacionales
<
Menor que
a 
Mayor que
>=
Mayor o igual que d >= e
==
Igualdad
5 == 3 // devuelve falso
!=
Desigualdad
a!=13
&&
y Lgico (AND)
((5<13)&&(5>=4)) //Devuelve verdadero
||
oLgico (OR)
(mivar==hola) || (3<5)
//Devuelve verdadero
Condicional
?:
Condicional
abreviado
(a<b) ? a++:a-- //Si a<b, a se aumenta en

1 Sino se disminuye en 1
Asignacin
Asignacin
x = 5 //A x se le asigna el valor entero 5

(x5)
Asignar producto
m*=3 //Equivale a m = m * 3
/=
Asignar divisin
e/=d //Equivale a e = e / d
%=
Asignar mdulo
t%=2//Equivale a t = t % 2
+=
Asignar suma
g+=7 //Equivale a g = g + 7
Igualdad
Expresiones: *=
n disminuye en 1
c>d
Estructura bsica de un programa

// directivas o libreras
# include<iostream.h>
# define pi 3.14
// Prototipo de funciones
tipo_datonomb_ funcion (lista_argumentos);
.................................................
// Declaracion de variables globales
inta,b,c;
// Declaracin y definicin de funciones: Implementacin
tipo_datonomb_funcion(lista__de_argumentos)
{ Declaraciones locales
<Instrucciones >;
return(expresin_de_tipo_dato);
}
tipo_nfuncion_n(lista_de_argumentos)

{ <dem caso de la funcion1>;
}
/
/Programa principal
voidmain()
{ Declaraciones sobre variables locales al proceso principal
<Instrucciones>;
Nomb_funcion(lista_de_argumentos);
-------------------------------------------- funcion_n(lista_de_argumentos);
return(0);
}
Como se observa el esquema ms empleado para un programa en C++ se compone
bsicamente por:
1. Directivas
2. Declaracin y definicin de funciones secundarias definidas por el usuario
3. Una funcin principal main()
Notas:
1. La funcin principal o main() regresa un valor 0 al sistema operativo para indicar que el proceso termin exitosamente, cuando ocurre algn tipo de error
regresar algn otro valor entero. Si no se requiere que main devuelva algn
valor, se escribe voidmain() y se omite return0;
2. Si desea retornar un valor entero, entonces defina el tipo de dato delante de
la funcin respectiva.
intmain()

{ return 0;
}
Las dems funciones, por lo general son llamadas a ejecucin dentro del mbito
de nuestra funcin principal y por consiguiente, ah pueden regresar valores.
Observacin:
Durante el diseo de los programas solo especificar una librera de entrada y
de salida:
Las dems libreras el usuario definir segn su requerimiento.
10
CAPTULO II
Estructuras de control
Objetivos
- Comprender la seleccin a travs de la
instruccin de condicional if (simple,
compuesta y con anidamiento).
- Como definir estructuras mltiples o
de seleccin Switch (selector).
- Utilizar las instrucciones de control
con pretest de prueba (while).
- Utilizar las instrucciones de control
con posprueba (do, while).
- Utilizar las estructuras de control de
programas break y continue.
- Combinar las estructuras selectivas,
mltiples y repetitivas.
- Hacer aplicaciones que representen problemas reales, tales como validacin
de cdigos de alumnos, empleados, DNI, cdigo de productos, etc.
2.1 Estructuras secuenciales

Son aquellas que se escriben lnea a lnea y son ejecutadas en el orden en que
se encuentran, desde el inicio hasta el final del programa. En C++ estas son solo
sentencias simples que terminan en un punto y coma (;):
Sintaxis
<instruccin_1>;
< instruccin _2>;
...........................
< instruccin _ n>;
Sentencia nula: En C++ existe, adems, la sentencia nula (una instruccin que no
hace nada), est representada por un punto y coma (;).
11
Su aplicacin se da a las estructuras repetitivas, cuando se quieren ignorar ciertos

valores y procesar otros en funcin de una condicin lgica.
Problema 1. Escribir un programa que calcule el permetro y el rea de un
tringulo, dados como datos las longitudes de sus tres lados (suponer que
siempre se cumple la desigualdad triangular).
Solucin // area.cpp
#include<iostream.h>
#include<iomanip.h> //para setiosflags
void main()
{
float a,b,c,p,area;
clrscr();

gotoxy(8,2);cout<<Ingrese
los lados del triangulo;
gotoxy(10,4);cout<<a = ; cin>>a;
gotoxy(10,5);cout<>b;
gotoxy(10,6);cout<<c = ; cin>>c;
p=(a+b+c)/2;
gotoxy(10,8);cout<<El permetro
es <<setw(10)<<setprecision(2)<<
2*p;
area=float(sqrt(p*(p-a)*(pb)*(p-c)));//moldeo de datos
gotoxy(10,10);
cout<<El rea es <<setw(15)<<setprecision(4)<<area<< metros ;
gotoxy(10,14);system(pause);
}
Problema 2. Disear un programa que permita leer datos de un trabajador
consistentes en: nombre, cdigo, sueldo bsico y bonificacin. Considere tambin
que:
-
-
-
-
Los descuentos son: AFP: 8%, invalidez: 1.44%;

Las aportaciones son: Fonavi: 5%, seguro nacional de pensiones: 11%, Senati: 1%
Existe un aumento de: 0.125
El programa debe mostrar el total de su boleta del empleado
Solucin: //simula_planilla.cpp
void main()
{ float s_basico,bonif,dscto,aumento,s_neto,s_real,fon,afp,snp,
float inval,senati,aport; char nom[20],cod[5];
clrscr();
12
gotoxy(24,1),cout<< SISTEMA DE PLANILLAS ;

gotoxy(24,3),cout<< Ingrese datos del trabajador:;

gotoxy(5,5),cout<<Nombre
:;cin>>nom;

gotoxy(5,6),cout<<Cdigo
:;cin>>cod;

gotoxy(5,7),cout<<Sueldo Bsico :;cin>>s_basico;

gotoxy(5,8),cout<<Bonificacin :;cin>>bonif;
//descuentos

afp=s_basico*0.08; //8%

inval=s_basico*0.0114; //1.44%

dscto=(afp+inval);
//aportaciones

fon=s_basico*0.05; //5%

snp=s_basico*0.011; //11%

senati=s_basico*0.001; //1%

aport=(fon+snp+senati);
//Clculos
s_real=(s_basico+bonif)-dscto;
aumento=s_basico*0.125;
s_neto=s_real+aumento;//Reportes
clrscr();
gotoxy(2,1),cout<<-------------------------------------------------------------------;
gotoxy(38,2),cout<<Planilla del trabajador ;
g
o
t
o
x
y
(
2
,
3
)
,
c
o
ut<<---------------------------------------------------------------------;
gotoxy(2,4),cout<<Sr. <<nom;

gotoxy(20,4),cout<<Cod. <<cod;

gotoxy(44,4),cout<<rea: SISTEMAS;
gotoxy(2,5),cout<<----------------------------------------------------------------------------;
gotoxy(2,8),cout<<----------------------------------------------------------------------------;
gotoxy(3,7),cout<<BSICO; gotoxy(4,9),cout<<s_basico;
gotoxy(11,7),cout<<BONIF; gotoxy(11,9),cout<<bonif;
gotoxy(19,6),cout<<DESCUENTOS; gotoxy(19,7),cout<<AFP;
gotoxy(19,9),cout<<afp; gotoxy(25,7),cout<<INVAL;
gotoxy(26,9),cout<<inval;
gotoxy(30,6),cout<< TOTAL;
gotoxy(30,7),cout<< DSCTOS; gotoxy(31,9),cout<<dscto;
gotoxy(42,6),cout<<APORTACIONES; gotoxy(39,7),cout<<FONAVI;
gotoxy(39,9),cout<<fon; gotoxy(47,7),cout<<SNP;
gotoxy(48,9),cout<<snp; gotoxy(51,7),cout<<SENATI;
gotoxy(53,9),cout<<senati; gotoxy(58,6),cout<<TOTAL;
gotoxy(58,7),cout<<APORT; gotoxy(59,9),cout<<aport;
gotoxy(65,7),cout<<BRUTO; gotoxy(65,9),cout<<s_real;
gotoxy(71,7),cout<<AUMENTO; gotoxy(73,9),cout<<aumento<<endl;
gotoxy(2,11),cout<<--------------------------------------------------------------------------;
gotoxy(65,12),cout<<TOTAL: S/.; gotoxy(65,13),cout<<=====;
gtoxy(72,12),cout<<s_neto;
getche(); }
13
Problema 3. Disear un programa que permita leer tres nmeros enteros y

luego usando operadores relaciones con operadores lgicos, mostrar resultado
booleano de las siguientes expresiones (entrada; 2, 3, 4):
- resp=(a<b)&&(b<c);// 2<3 y 3<4 ==> V y V==> resp=V=1
- resp=(a<b)&&(!(b>c));//2<3 y not(3>4) ==>V y V ==>resp= V= 1
- resp=(a==b)|| (!(b>c));//2=3 o not(3>4) ==> F o not(F)==> resp=V=1
- resp=(a==b) &&( b>c);//2=3 y(3>4) ==> F y F = 0
- resp=(a==b) || (b>c);//2=3 o (3>4) F o F = 0
- resp=((a!=b)&&(b<c)); // V y V = 1
- resp=a;Valida veracidad de entrada de a
- letra=letra1<letra2;
//Solucin: Operadores_Relac.cpp
#include <iostream.h>
#define linea ______________________
void main()
{ int a,b,c;
char letra1,letra2;bool resp, letra;
gotoxy(8,1);cout<< Operadores Relacionales y Lgicos(V=1,F=0);
gotoxy(8,2);cout<<linea;
gotoxy(10,3);cout<< Ingrese a = ;cin>>a;
gotoxy(10,4);cout<< Ingrese
b =
;cin>>b;
gotoxy(10,5);cout<< Ingrese
c =
;cin>>c;
resp=(a<b)&&(b<c);//2 3 4 2<3 y 3<4
==> V y V==> resp=V=1
gotoxy(10,7);cout<<a<<<<<b<<
y
<<b<<< <<c << ==> resp = <<
resp; getche();
resp=(a<b)&&(!(b>c));//2<3 y not(3>4)
==>V y V ==>resp= V= 1
gotoxy(10,8);cout<<a<<<<<b<<
y not <<b<< > << c << ==> res =
<<resp; getche();
14
resp=(a==b)|| (!(b>c));//2=3 o not(3>4) ==> F o not(F)==> resp=V=1

gotoxy(10,9);cout<<a<< = <<b<< o not <<b<< > << c << ==> resp =
<<resp;getche();
resp=(a==b) &&( b>c);//2=3 y(3>4) ==> F y F = 0; gotoxy(10,10);
cout<<a<< = <<b<< y <<b<< > << c << ==> resp = <<resp; getche();
resp=(a==b) || (b>c);//2=3 o (3>4) F o F = 0
gotoxy(10,11);
cout<<a<< = <<b<< o <<b<< > << c << ==> resp = <<resp;getche();
resp=((a!=b)&&(b<c));
gotoxy(10,12); cout<<a<< diferente de = <<b<< y <<b<< < << c << ==> resp
= <<resp;
getch(); resp=a;
gotoxy(10,13);cout<<Valida veracidad de entrada de <<a<<=>resp= <<resp;
getche();
gotoxy(10,15);cout<<Ingrese Primera letra = ; cin>>letra1;
gotoxy(10,16);cout<<Ingrese Segunda letra = ; cin>>letra2;
letra=letra1<letra2; gotoxy(10,18);
cout<<letra1<<es<en valor ASCII que <<letra2<<resp= <<resp;getche();
}
Problema 4. Disear un programa que permita ingresar un nmero entero
positivo y compuesto por tres dgitos, luego mostrarlo en forma invertida.
Solucin //while_prg_03.cpp
#define linea_____________________
void main()
{ int n, dig_01,parte_ente_01,dig_02,parte_ente_02;
gotoxy(12,2);cout<< ESTRUCTURA SECUENCIAL ;
gotoxy(12,4);cout<< ===> INVERTIR UN NMERO <===;
gotoxy(12,6);cout<< Ingrese nmero = ;cin>>n;
dig_01=n%10; parte_ente_01=n/10; dig_02=parte_ente_01%10;
parte_ente_02=parte_ente_01/10;
gotoxy(12,9);cout<<n<< invertido=
<< dig_01<< dig_02<<parte_ente_02;
gotoxy(8,10);cout<<linea; getche();
}
15
2.2 Estructuras selectivas condicionales

Permiten evaluar condiciones de proposiciones, comparaciones de tipos de
datos que pueden ser nmeros, cadenas, letras, etc. y devuelven resultados tipo
booleanos V:1 o F:0 y, dependiendo las instrucciones, a ejecutar cuando es V o
cuando es F.
Presentan tres tipos de:
- Estructuras condiciones simples
- Estructuras condiciones compuestas y
- Estructuras condiciones con anidamiento
2.2.1 Estructura selectiva simple

Son aquellas que realizan una determinada secuencia de instrucciones, de
acuerdo a determinada condicin lgica. Si esta es verdadera, la secuencia se
ejecuta, si no lo es, contina el programa con la instruccin siguiente.
Sintaxis:
Cuando se ejecuta una sola sentencia
dentro de la estructura
if (<condicin>)
{ intrucciones;
}
Cuando se ejecutan varias sentencias

dentro de la estructura

If (<condicin>)
{ instruccin_1;

instruccin_2;
...
Instruccin_n;
}
Observaciones:
a. <condicion> es la condicin valor numrico o funcin que ser evaluada como
verdadera (distinta de cero) o falsa (cero). Esta puede ser simple (un solo valor
o condicin) o compuesta, la cual est formada por varias condiciones simples
conectadas por los operadores lgicos vistos anteriormente: && (y), || (o) y !
(negacin).
b. Siempre se usa parntesis encerrando a la expresin a evaluarse.
Problema 1. Disear un programa que permita leer un nmero n entero positivo
y mayor que 9. Si la lectura es correcta entonces se debe obtener el ltimo dgito.
Si la lectura es incorrecta el programa no realiza ninguna tarea.
16
Solucin // if_resto.cpp
#include <conio.h>
#include <stdlib.h>
void main()
{int n, ult_dig,dato;
clrscr();gotoxy(10,2);
cout<<Sr. ingrese nmero :;cin>>n;
dato=n;
if(n>9)
{ ult_dig=dato%10;
gotoxy(10,5);cout<<ltimo dgito de << n<< es = <<ult_dig;
}
getche();
}
Problema 2. Disear un programa que permita leer un nmero n entero positivo
y mayor que 99. Si le lectura es correcta, entonces obtener sus dos ltimos dgitos.
Si la lectura es incorrecta el programa no realiza ninguna tarea.
Solucin
void main()
{int n, dos_dig,dato; clrscr();
gotoxy(10,2);
cout<<Sr. ingrese nmero :;cin>>n;
dato=n;
if(n>99) {dos_dig=dato%100;
gotoxy(10,5);cout<<
Dos
ltimos
dgitos de << n<< es = <<dos_dig;
if(dos_dig%2==0)
{ gotoxy(10,7);cout<< Y adems, <<
dos_dig<< es un nmero PAR ; }}
getche();}
Comentario. Los resultados de los
problemas 1, 2 y 3 se obtiene toda vez
que la condicin lgica es verdadera. Si
usted ingresa nmeros que no satisfacen
la condicin, el programa no enva
ningn resultado.
17
2.2.2 Estructura selectiva compuesta: sentencia if - else

Es aquella que realiza dos acciones distintas, ambas mutuamente excluyentes, de
acuerdo al valor lgico de una expresin, es decir, se ejecuta solo una instruccin.
Sintaxis
Cuando las instrucciones a ejecutarse son simples
if (<Condicin>) instruccin_1;
else
instruccin_2;
Si en cada instruccin existe solo una, no se usa { .. }, en otro casi si.
Problema 1. Disear un programa que permita leer datos de usuario por: cdigo
= 10 y clave = 12, luego, si los datos son correctos, el programa solicita que ingrese
un nmero entero positivo, inmediatamente el programa debe enviar un reporte
si el nmero ingresado es par, en otro caso es impar. Si los datos del usuario son
incorrectos, el programa envia el mensaje Datos incorrectos y finaliza.
Solucin: // Sielse.cpp
void main() {int cod, clave,p; clrscr();
cout<<ingrese cdigo :; cin>>cod;
cout<<ingrese clave :; cin>>clave;
if((cod==10) && (clave==12))
{ cout<<Ingrese prctica:; cin>>p;
if(p%2==0); cout<<p<<es nmero
Par;
else
cout<<p<< es nmero impar; }
else
cout<< Datos incorrectos ;getche();
}
Tambin se puede usar la expresin
condicional abreviada equivalente:
(expresin) instruccin1: instruccin2;
Cuando las instrucciones a ejecutarse son compuestas

if (expresin) {instruccion_1; instruccion_2;
.......
instruccion_n;
}

else {instruccion_1; instruccion_2;
.........
instruccion_n;

}
}
18
Si < expresin > es verdadera, se ejecuta el bloque <instrucciones >, en otro caso
se ejecuta las <instrucciones> del bloque else.
Problema 1. Disear un programa
que permita leer un nmero y luego
averiguar si es capica.
Solucin // if_capicua.cpp
void main()
{int num,c,r1,d,u,inv;
clrscr();
gotoxy(10,4);
cout<< Ingrese Nmero: ;cin>>num;
c=num/100; // obtiene primer dgito
r1=num%100; //obtiene dos ltimos dgitos
d=r1/10; u=r1%10;
inv=u*100+d*10+u;
if (num==inv) { clrscr();

gotoxy(10,4);cout<< El nmero<<num << Es capica;

gotoxy(10,5);cout<< su primer dgito es=<<c;
}
else { clrscr();

gotoxy(10,4);cout<<El nmero<<num << No capica;

gotoxy(10,5);cout<<Sus ltimos dos dgitos es=<<r1;
}
getch();
}
2.2.3. Estructura condicional con anidamiento

.
if ( < condicion 1 >)
<instruccion_1;>
else
if (< condicion 2 >)
< instruccion_1;>
...
else
if (< condicion n >)
<instruccion_n;>
else<instruccion_x;>
Aqu el programa realiza una sola <instruccion_x> para un <valor_x > de una
expresin (numrica o lgica). Si el valor que toma la expresin no figura entre
los especificados, se ejecutar el bloque de instrucciones_else.(sino...).
19
Observacin. Si el bloque de <instrucciones_x> est formado por varias

instrucciones estas debern agruparse con llaves { }.
Problema 1. Disear un programa que permita leer tres nmeros enteros a, b y c
(a, b, c 0) y que verifique si se cumplen algunas de las siguientes relaciones: a =
b + c; b = a + c; c = a + b; a = b = c
Solucin //:
void main()
{ int a,b,c; clrscr();
gotoxy(10,1);cout<< VERIFICANDO SUMA DE NMEROS;
gotoxy(10,2);cout<< Ingrese a = ; cin>>a;
gotoxy(10,3);cout<< Ingrese b = ; cin>>b;
gotoxy(10,4);cout<< Ingrese c = ; cin>>c;
if (a==b+c)
{ gotoxy(10,6); cout<< Se cumple que <<a<< = << b<< + << c;
}
else
if (b==a+c)
{ gotoxy(10,6);cout<< Se cumple
que <<b<< = << a<< + << c;
}
else
if (c==a+b)
{gotoxy(10,6); cout<< Se cumple
que <<c<< = << a<< + << b
}
else
if((a==b)&&(b==c))
{ gotoxy(10,6); cout<< Se cumple que <<a<<=<<b<<=<< c
}
else
{ gotoxy(10,7);cout<< No se cumple ninguna relacin ;
} getche();
Problema 2. Disear un programa que permita ingresar datos de un usuario por

apellidos = CORDOVA y clave = TCN , si los datos son correctos el sistema
enva un mensaje de saludos y solicita que ingrese tres nmeros enteros y luego
devuelve el mayor de ellos. Si el usuario ingreso sus datos con error, el sistema
enva el mensaje indicando el error respectivo.
Solucin
//if_mayor_tres_num.cpp
# define linea ----------------------------------------;
void main()
20
{ char apell[10],clave[10],e=0;
int a,b,c,mayor, tresd;
gotoxy(10,2); cout<< Ingrese Apellido = ;gets(apell);
gotoxy(10,3); cout<< Ingrese Clave = ;gets(clave);
gotoxy(10,4); cout<<linea;
if ((strcmp(strupr(apell),CORDOVA)==0) && (strcmp(strupr(clave),T
CN)==0))
{ gotoxy(10,6);cout<< Saludos, Sr..<< apell<< y Bienvenido ;
gotoxy(10,7);cout<< Ingrese 3 nmeros ;
gotoxy(10,8);cout<< a= ;cin>>a;
gotoxy(10,9);cout<< b= ;cin>>b ;
gotoxy(10,10);cout<< c= ;cin>>c;
if ((a>b)&&(a>c))
{mayor=a; gotoxy(10,13);cout<<El mayor nmero es = <<mayor;
}
else
if((b>a)&&(b>c))
{mayor=b; gotoxy(10,13);
cout<<El mayor nmero es = <<mayor;
}
else
if((c>a)&&(c>b))
{mayor=c;

gotoxy(10,13);cout<<El mayor
nmero es = <<mayor;

}

else

{ gotoxy(10,13);cout<< Los
nmeros son iguales...;

}
}
else
{ gotoxy(10,5); cout<< Sr. sus datos son incorrectos ;
}getche();
}
2.3 Estructuras mltiples

Es aquella en la cual el usuario puede realizar una determinada accin para cada
tipo de valor que pueda tomar una expresin. Cada accin a realizarse excluye a
las dems, de modo que solamente una de ellas es ejecutada.
switch (expresin) {
case valor1:
<instrucciones_1>;
break;
21
case valor2:
<instrucciones_2>;
break;
.....
case valor_n:
<instrucciones_n>;

break;
default: < instrucciones_X>; break;
} //fin de switch()
Observaciones
1. La etiqueta default indica al programa
lo mismo que el else en la secuencia de if anidado, es decir; se ejecuta cuando
el usuario edita un valor que no est en la lista de valores.
2. La sentencia break permite que el
programa abandone la estructura
switch omitiendo los dems casos.
3. La variable selector no puede ser
tipo: real, cadena de dgitos, cadenas.
4. Cuando se quiere realizar una misma
accin para distintos valores de la
expresin evaluada, se coloca una
sentencia case por cada valor, sin
ninguna accin y la accin comn
se pone al final del ltimo valor. Por
ejemplo, el segmento de cdigo:

switch (a) {
case 1:case 2:case 3: cout<<Accin para 1, 2 y 3;
break;
case 4: cout<<Accin para 4; break;
default: cout<<Accin para cualquier otro valor; break;
}
Problema 1. Disear un programa que permita disponer de tres alternativas:
- Alternativa 1: permite leer la base y el exponente para calcular la potencia de
un nmero.
- Alternativa 2: permite leer un nmero n positivo y luego calcula la raz
cuadrada.
- Alternativa 3: permite ingresar un nmero de tres dgitos y luego este nmero
mostrarlo en forma invertida sin usar estructuras de control repetitivas.
- Alternativa 4: permite salir del modo compilacin al programa fuente.
22
Asimismo, el programa debe enviar el mensaje Fuera de rango, cuando el

usuario digita un nmero que no est dentro de la lista disponible.
Solucin // case1.cpp
# define linea -----------------------------------------------
void main(){int n,raiz,pot,poten,base;
int parte_entera2,parte_entera1,ult_dig,pult_dig; char opc; clrscr();
gotoxy(15,3);cout<< Bienvenidos al Men;
gotoxy(15,5);cout<< [P] Potencia;
gotoxy(15,6);cout<< [R] Raiz cuadrada;
gotoxy(15,7); cout<< [I] Invertir Nmero;
gotoxy(15,8);cout<< [S] Salir;
gotoxy(15,11);cout<< Ingrese opcin: ;cin>>opc;
switch(opc)
{ case P:case p: clrscr();
gotoxy(15,4);cout<< Ingrese la base :; cin>>base;

gotoxy(15,5);cout<< Ingrese la potencia:; cin>>pot;
poten=pow(base,pot);
gotoxy(15,7);
cout<< El nmero << base<< elevado a <<pot << es =<<poten;
break;
caseR:case r: clrscr();
gotoxy(15,4);cout<< Ingrese un nmero :; cin>>n;
raiz=sqrt(n);
gotoxy(15,5);cout<< La raz cuadrada de << n<< es =<<raiz;
getche();
break;
caseI:case i: clrscr();
gotoxy(10,2);cout<<NMERO INVERTIDO ;
gotoxy(15,4);cout<< Ingrese un nmero = ; cin>>n;
if((n>99)&& (n<1000))
{ult_dig=n%10;
parte_entera1=n/10;
pult_dig=parte_entera1%10; parte_entera2=parte_entera1/10;
gotoxy(15,6);
cout<< Nmero Invertido = <<ult_dig<<pult_dig<<parte_
entera2;
gotoxy(4,8);
23
cout<<linea;
getche();
else
{ gotoxy(15,6); cout<< El nmero no satisface condicin ;
}
break;
caseS:case s: clrscr(); gotoxy(2,8);cout<<linea;
gotoxy(10,12);cout<< Ud saldr del Sistema, hasta luego.. ;
gotoxy(2,14);cout<<linea; getche(); exit(1);
default: gotoxy(10,12);cout<< Ud NO seleccion su opcin correcta.. ;
}
getche();
}
Problema 2. Disear un programa que permita validar datos de usuario por

apellido = CORDOVA y clave = 8481100D, si los datos son correctos el
sistema presenta un men de opciones para:
< O > Ordenadores Impresoras < L > Lectoras y < S > Salir.
Si edita O, el sistema presenta un submen mostrando los tipos de marcas por
cada ordenador:
 Ibm, <C> Compac y <O> Olivetti.
Por cada opcin que usted ingrese, el nmero de ordenadores a comprar y luego
el precio por unidad y calcula el monto a pagar.
Anlogamente sucede para las dems opciones: para impresoras y lectoras.
Si usted ingreso sus datos de validacin incorrectos, el sistema enva el mensaje:
Sr. usuario, sus Datos son incorrectos, hasta pronto;
Solucin // programa case.cpp
#include <stdlib.h>
# define linea ----------------------------------------------------
void main()
{ int nibm,pibm,monto,montoc,ncomp,pcomp,noliv,poliv,montooliv;
int montolasser,nimpl,pimpl, int montomat,nimpm,pimpm;
int montolcre,nlcre,plcre,
int montolhp,nlhp,plhp;
24
char apell[10],clave[10], char opc,imp; clrscr();

gotoxy(25,8);cout<<MDULO DE VALIDACIN;
gotoxy(20,12);cout<< Ingrese apellido :,gets(apell);
gotoxy(20,13);cout<< Ingrese clave : ,gets(clave);
if (strcmp(apell,cordova)==0&& strcmp(clave,tcn)==0)
{clrscr();
gotoxy(15,12);cout<< Bienvenidos al sistema de Ventas;
gotoxy(15,5);cout<< [O] Ordenadores;
gotoxy(15,6);cout<< [I] Impresoras;
gotoxy(15,7);cout<< [L] Lectoras;
gotoxy(16,14);cout<< Ingrese opcin :; cin>>opc;
switch(opc)
{ case o:case O: clrscr();gotoxy(4,2);cout<<linea;
gotoxy(15,4);cout<< IBM :;
gotoxy(15,5);cout<< <C> Compact;
gotoxy(15,6);cout<< <O> Olivetti;
gotoxy(15,7);cout<< Edite opcin;cin>>imp;
switch(imp)
{ case i:case I: { clrscr();
cout<<\nOrdenadores marca IBM;

cout<<\ningrese nmero de ordenadores a comprar:;cin>>nibm;

cout<<\ningrese precio por unidad:; cin>>pibm;

monto=nibm*pibm;

cout<< \nUd. debe pagar :<<monto;
getche();
}
break;

case c:case C: {clrscr(); cout<<\nOrdenadores marca Compac;

cout<<\ningrese nmero de ordenadores a comprar:;cin>>ncomp;

cout<<\ningrese precio por unidad:; cin>>pcomp;
montoc=ncomp*pcomp;

cout<< \nUd. debe pagar :<<montoc;
getche();
}

break;
case o:case O: {clrscr();

cout<<\nOrdenadores marca OLIVETTI;

cout<<\ningrese nmero de ordenadores a comprar:;cin>>noliv;

cout<<\ningrese precio por unidad:; cin>>poliv;
montooliv=noliv*poliv;
cout<< \nUd. debe pagar :<<montooliv; getche();
}
25
break;
default:cout<<No existe Marca de tal Ordenador, hasta luego;
getche();
exit(1);
// fin de alternativas de ordenadores :O : Ordenadores
break;
case i:case I:// Opcin de case principal :I : Impresoras
clrscr();
gotoxy(15,2); cout<<Impresoras;
gotoxy(15,4);cout<<<L> Lasse :;
gotoxy(15,5);cout<<<M> Matricial;
switch(imp)
{ case l:case L:
clrscr();

cout<<\ningrese nmero de impresoras Lasser:;cin>>nimpl;

cout<<\ningrese precio por unidad:; cin>>pimpl;
montolasser=nimpl*pimpl;

cout<< \nUd. debe pagar :<<montolasser; getche();
break;
case m:case M: clrscr();

cout<<\ningrese nmero de impresoras Matricial:;cin>>nimpm;

cout<<\ningrese precio por unidad:; cin>>pimpm;
montomat=nimpm*pimpm;

cout<< \nUd. debe pagar :<<montomat;
getche();
break;
default:cout<<No existe Impresoras; getche();
exit(1);

}// fin de alternativas de Impresoras :I: Impresoras
break;
case l:case L:// Opcin de case principal :L : Lectoras
clrscr();
gotoxy(15,2); cout<<Lectoras;
gotoxy(15,4);cout<<<C> Creative :;
gotoxy(15,5);cout<<<H> HP;
switch(imp)
{ case c:case C: clrscr();
cout<<\ningrese nmero de Lectoras Creative: ;cin>>nlcre;
cout<<\ningrese precio por unidad:; cin>>plcre;
montolcre=nlcre*plcre;
cout<< \nUd. debe pagar :<<montolcre;
getche(); break;
case h:case H: clrscr();
cout<< \ningrese nmero de Lectoras HP: ;cin>>nlhp;
cout<< \ningrese precio por unidad:; cin>>plhp;
montolhp=nlhp*plhp;
26
cout<< \nUd. debe pagar

:<<montolhp; getche();
break;
default: cout<<No existe Marca de
lectoras;
getche();
exit(1);
}
break;
case s:case S: cout<< Salida del
sistema, presione ENTER; getche();
exit(1); default:clrscr();gotoxy
(20,8);cout<< No existe Marca de
Producto;
} //fin switc(opc)} // alternativa de if
else
cout<< Sr. usuario, sus Datos son incorrectos, hasta pronto; getche();
Si los datos son ingresados correctamente, se muestra las alternativas:
Usted dispone de las alternativas, cada una

dispone de otras alternativas (submens),
por ejemplo si edita O, entonces se
obtiene el submen correspondiente a los
tipos de ordenadores:
Ahora, si usted edita la opcin C, de
Compac, el programa le solicita que
ingrese nmero de ordenadores y
precio por unidad, luego calcula el
monto a pagar. As puede continuar con las dems opciones correspondientes a
impresoras y lectoras.
Problema 4. Disear un programa que permita leer la letra inicial del mes (enero,
febrero, marzo o abril) y luego se visualice el mensaje indicando el mes respectivo:
Mes de ......................
Observacin
27
En el siguiente programa se ilustra que usando la estructura mltiple o la

estructura if con anidamiento se puede obtener el mismo resultado
Solucin
a) Mediante Case (..)
//case_if_anidados.cpp
void main() { char mes;
clrscr();
gotoxy(24,1),cout<<Meses del Ao;
gotoxy(23,2),cout<<==============;
gotoxy(5,3),cout<<Ingrese letra inicial del mes:;cin>>mes;
switch(mes)

{ case E:case e: gotoxy(20,5),cout<< Mes de Enero;break;

case F:case f: gotoxy(20,5),cout<< Mes de Febrero;break;

case M:case m: gotoxy(20,5),cout<< Mes de Marzo;break;

case A:case a: gotoxy(20,5),cout<< Mes de Abril;break;

default: gotoxy(20,5),cout<< Letra fuera de rango......!;
} getche(); }
b) Mediante If
#include<conio.h>
void main() {char mes[10]; clrscr();
gotoxy(20,1),cout<< Meses del Ao;
g o t o x y ( 2 1 , 2 ) , c o
ut<<================;
gotoxy(20,4),cout<<Ingrese
letra
inical del mes:;gets(mes);
if(strcmp(mes,E)==0||strcmp(mes
,e)==0)
{ gotoxy(20,6);cout<< Mes de Enero;
}
else
if(strcmp(mes,F)==0||strcmp(mes,
f)==0)
{gotoxy(20,6);cout<< Mes de Febrero;
}
else

if(strcmp(mes,M)==0||strcmp(mes,m)==0)
{ gotoxy(20,6);cout<< Mes de Marzo
}
else

if(strcmp(mes,A)==0||strcmp(mes,a)==0)
{gotoxy(20,6);cout<< Mes de Abril;
}
else
{gotoxy(20,5);
28
}
getche()
}
cout<< El valor ingresado esta disponible......!;
2.4 Estructuras repetitivas

Permiten realizar instrucciones ms de una vez, formando bucles. A cada
repeticin se le llama tambin iteracin, por lo cual las estructuras repetitivas se
denominan tambin iterativas. Para las estructuras repetitivas se suelen utilizar
dos tipos de variables especiales:
Contadores: los cuales incrementan o disminuyen su valor en una cantidad
constante. Deben inicializarse en un valor constante.
Sintaxis
cont = cont + 1
inicialice : cont =1
Acumuladores: los cuales acumulan o disminuyen su valor en una cantidad

variable. Tambin deben inicializarse.
Sintaxis
suma = suma + cont
inicialice: suma=0
Cabe destacar que todas las estructuras repetitivas se pueden anidar.
Tipos de estructuras repetitivas:

2.4.1 Estructura repetitiva con pretest de prueba: while {<instrs > }
Llamado tambin bucle con entrada controlada, es aquel que repite un grupo
de acciones mientras que el resultado de la condicin lgica sea verdadera (o
distinta de cero). En otros trminos, si el resultado de evaluar la condicin es
verdadera se ejecuta por lo menos UNA instruccin o ms. En otro caso NO se
ejecuta ninguna instruccin.
Sintaxis:

while (< condicin >)
{ <instrucciones>;
}
Hay que tener especial cuidado para
conseguir, en algn momento, una
forma de que la <condicin> a evaluar
sea falsa. Es muy fcil escribir bucles
que se repiten indefinidamente hasta
agotar la memoria y hacer colapsar al
sistema.
Problema 1. Escribir un programa
29
que lea una cadena y determine en ella la frecuencia de aparicin de cada vocal.
Solucin // while_vocal.cpp
#define linea ____________________________________
void main() {
int na=0,ne=0,ni=0,no=0,nu=0; char c=\0;
gotoxy(10,2);cout<<Ingrese texto :<<endl ;
while (c!=\n) {
c=toupper(getchar());
switch (c) {
case A: na++; break;
case E: ne++; break;
case I: ni++; break;
case O: no++; break;
case U: nu++; break;
} // fin de while }
gotoxy(10,5);cout<<
===>
RESULTADOS <=== ;
gotoxy(8,7);cout<<Cracter
# de
repeticiones ;
gotoxy(10,9);cout<< a\t\t<<na<<
veces;
gotoxy(10,10);cout<< e\t\t<<ne<<
veces;
gotoxy(10,11);cout<< i\t\t<<ni<< veces;
gotoxy(10,12);cout<< o\t\t<<no<< veces;
gotoxy(10,13);cout<< u\t\t<<nu<< veces;
getch();
}
Problema 2. Escribir un programa que permita leer un nmero compuesto por
ms de un dgito y luego mostrar:
Total de dgitos, total de dgitos pares e impares, nmero invertido, total de suma
de dgitos pares e impares respectivamente. El programa debe ser interactivo, es
decir; despus de cada ejecucin, el sistema enva el mensaje Desea continuar..?
(S / N). Si edita S contina ejecutando el programa, en otro caso finaliza.
Solucin // while_digitos.cpp
void main()
{ int r,d,n,inv=0,par=0,impar=0, nd,sump=0,sumimpar=0;
char resp=s;
while(resp==s)
30
{ gotoxy(8,3);cout<<Ingrese un nmero con mas de 1 dgito : ; cin>>n;

r = n; nd=0;// inicializ contador de dgitos
while(n>0) // descompongo el nmero n ingresado
{ d=n%10;
nd=nd+1;
If (d%2==0) { par++;
sump+=d; }
else { impar++; sumimpar+=d; }
inv=inv*10+d;
n=n/10; }

gotoxy(8,5); cout<< El nmero <<r<< tiene :;

gotoxy(12,7); cout<< << nd<< dgitos ;

gotoxy(12,8); cout<< Invertido es = <<inv;

gotoxy(12,9); cout<< Tiene <<par<< dgitos pares;

gotoxy(12,10); cout<< La suma de los nmeros pares es = <<sump;

gotoxy(12,11); cout<< Tiene <<impar<< dgitos impares;
gotoxy(12,12); cout<< La suma de los nmeros impares es = <<sumimpar;
gotoxy(20,16); cout<<Desea continuar..(s/n);cin>>resp; }
getche(); }
Problema 3. Disear un programa que permita leer dos nmeros comprendidos

entre 10 y 99. Luego mostrar el producto respectivo. Si el usuario edita nmeros
que no estn en el rango especificado, el sistema enva el mensaje: Sr. sus nmeros
deben estar en el rango <10..99>. Asimismo, el programa debe ser interactivo, es
decir; despus del error, el sistema enva el mensaje Desea continuar..? (s /
n).
Solucin // while_producto.cpp
void main() { int n,d,p,i=0,a,b; char resp; resp=s; clrscr();
31
while(resp==s){ gotoxy(10,3);cout<< MULTIPLICACIN DE NMEROS ;

gotoxy(14,6);cout<<Ingrese multiplicando : ;cin>>a;
gotoxy(14,7);cout<<Ingrese multiplicador :; cin>>b;
if((a>9) &&(a<99)&& (b>9)&&(b<99))
{ n=b;
while(n>0) //para mensajes de productos parciales

{ d=n%10;
p=d*a;
i++;

cout<<\nEl <<i<< producto parcial es :<<p<<endl;
n=n/10;
}
p=a*b;
gotoxy(14,13);cout<< El producto de <<a<< * <<b<< es = <<p; getche(); }
else {clrscr();
gotoxy(20,12);
cout<<Sr. sus nmeros deben estar en el rango <10..99>;getche(); } clrscr();
gotoxy(20,10);cout<<Desea continuar..?(s/n);cin>>resp; clrscr(); } getche();
}
Si el usuario ingres los dgitos en el rango solicitado, el sistema calcula el
producto, tal como se mustra en la siguiente grfica:
Problema 4. Disear un programa que permita validar datos del usuario
usando solo un carcter para cdigo y uno para clave (codigo =a, clave=b).
Si los datos son correctos, el sistema solicita que ingrese dos elementos de la
serie 1+2+3+4+.......+n. Los elementos son lado izquierdo (ladi): indicando primer
elemento y lado derecho (ladd) indicando segundo elemento; es decir; definimos
un rango de elementos a sumar. Luego, generar reportes que permita saber la
32
suma acumulada y el total de dgitos que tiene este resultado. Si los datos son
incorrectos, el sistema enva el mensaje de error.
Solucin //while_if.cpp
void main() {int acum=0,ladi,ladd,li; char codigo, clave;
gotoxy(12,6);cout<< Ingrese cdigo : ;cin>>codigo;
gotoxy(12,7); cout<< Ingrese clave : ;cin>>clave;
if((codigo==a)&& (clave==b)) {clrscr();
gotoxy(12,6); cout<<Ingrese lado izquierdo : ;cin>>ladi;
gotoxy(12,7); cout<<Ingrese lado derecho : ;cin>>ladd;
clrscr();
li=ladi;
while (ladi<=ladd) { acum+=lad ladi++;

}
gotoxy(6,6);cout<< La suma
desde <<li<< hasta <<ladd<<
es= <<acum;
if ((acum>=0)&&(acum<10))
{ gotoxy(6,7);cout<< La
suma tiene 1 dgito ;
}
else { if ((acum>9)&&(acum<
100))
{ gotoxy(6,8);cout<< La suma
tiene 2 dgitos;
}
else
{ if ((acum>99)&&(acum< 999))
{ gotoxy(6,9);cout<< La suma tiene
3 dgitos;
}
}
}
} // fin del if
else {clrscr();
gotoxy(12,12); cout<< Sus datos no
se registraron, hasta luego :;
}
getche();
}
Problema 5. Disear un programa que
permita leer un nmero n entero positivo, luego calcular su factorial e imprir su
resultado.
Solucin // while_fact.cpp
#include<conio.h>
void main()
33
{ double fact=1.0,n,minumero;
gotoxy(8,4);
cout<<Ingrese un nmero : ;
cin>>n;
minumero=n;
while (minumero >0)
{ fact=fact* minumero;
minumero--;
}
gotoxy(15,6);cout<<El factorial
de <<n << es =<<fact; getche();
}
que permita mostrar la tabla de multiplicar de n filas y m columnas, donde el
usuario ingresar nmero de filas y columnas.
Solucin //while_mult.cpp
void main() { int n,m,i=1,j=1;
gotoxy(12,3);cout<<TABLA DE MULTIPLICAR;
gotoxy(4,5);
cout<<ingrese nmero de fila :;cin>>n;
gotoxy(4,6);
cout<<ingrese nmero de columna; cin>>m;
while(i<=n )
{ cout<<Para fila :<<i<<endl;
while ( j <= m )
{cout<<\ti= <<i<< y <<j=<<j<< se tiene <<i<<*<<j<<=<<i*j<<endl;
j++;
} cout<<\n;
i++; j = 1;
}
system(pause);
}
Problema 7. Disear un programa que permita calcular la suma acumulada de la
SERIE = 1+x+x*x/2 ! +.......+ x^n / n !
Para lo cual se debe ingresar el valor de x y el nmero de trminos a sumar.
Solucin //while_sum_fact.cpp
void main() { int x,n,i=1;
float r=0.0; clrscr();
gotoxy(8,2);cout<<SUMA DE SERIE = 1+X+X*X/2!+...+X^n/n! ;
gotoxy(8,4);cout<<Ingrese el valor de x : ;cin>>x;
gotoxy(8,5);cout<<Ingrese el valor de n : ;cin>>n;
34
while(i<=n)
{ float fact=1,g=1;int j=1;
while(j<=i)
{ g=x*g;
fact=fact*j;
j++;
}
r=r+g/fact;
i++;
}
gotoxy(8,7);
cout<<La suma Acumulada es
=
;cout<<(r+1)<<endl<<endl;
system(pause);}
Problema 8. Disear un programa que permita leer n nmeros enteros y para
finalizar la lectura, edite 0 (cero). Asimismo, el programa debe permitir :
a. La suma de nmeros pares positivos.
b. La suma de nmeros impares positivos.
c. Los resultados de a) y b), mostrarlos en forma concatenada.
d. Al resultado de c) y de derecha a izquierda, es decir; si el dgito es par y la
posicin que ocupa y si es impar y la posicin que ocupa, respectivamente.
e. Segn los datos ingresados, genere reportes del: total de dgitos pares e
impares positivos, dgitos negativos pares e impares, al mayor dgito par y el
mayor dgito impar negativo.
Solucin //while_if_uni.cpp
void main (){int i=0,n,pp=0,spp=0,mpp=0,ip=0,in=0,sin=0,sip=0;
int min=0,ud,o,num,s=0,y,x,p1=0;
gotoxy(40,2);cout<<Edite 0(cero) para finalizar:;
gotoxy(10,2);cout<<Ingrese nmero : ;cin>>num;
while(num!=0)
{ if (num!=0)
{ if(num>0)
{ if (num%2==0)
{ pp++; spp+=num;
}
if(num>mpp)
{mpp=num;
}
}
Else
{ip++; sip+=num;
35
}
}
else if (num %2!=0)
{in++;
sin+=num;
}
{ min=num;
}
if (num>>min)
}
i++;
}
gotoxy(10,4+i+1); cout<<ingrese nmero:;cin>>num;
}
cout<< \nSuma de pares positivos :<<spp<<endl;
cout<< \nSuma de impares positivos:<<sip<<endl;getche();
y=sip;
while(y>0)
{y=y/10;p1++;
}
x=(spp*pow(10,p1))+ sip; o= x;
while (o>0)
{ o=o/10; s++;
}
o=x;
cout<<\n el resultado concatenado es <<o<<endl;getche();
while (o>0) { ud= o%10;
if (ud%2==0)
{cout<<\n <<ud<< es par, su posicin es <<s<<endl;
s--;
} else
{ cout<<\n <<ud<< es impar,su posicin es <<s<<endl;
s--;
}
o=o/10;
}
getche();
gotoxy(35,18);cout<<el total de pares positivos es
:<<pp;
gotoxy(35,19);cout<<el total de impares positivos es :<<ip;
gotoxy(35,20);cout<<el total de impares negativos es :<<in;
gotoxy(35,21);cout<<el mayor de los pares positivos es :<<mpp;
gotoxy(35,22);cout<<el mayor de los impares negativos es : <<min;
getche();
}
36
2.4.2 Estructura repetitiva con postest de prueba: do { <insts>} while

(<cond>)
Llamado bucle con salida controlada, ejecuta <instrucciones> lo mismo que la
estructura while, con la diferencia que primero ejecuta una <instruccin> y luego
verifica la <condicin>, a partir de esta ejecucin, se comporta como la estructura
while. Por este motivo la estructura se ejecuta por lo menos una vez.
Sintaxis
do {<instrucciones>
} while (expresin) ;
Este tipo de secuencias es muy utilizada en procesos de validacin de
datos (cuando se quiere que el usuario del programa introduzca siempre
datos correctos). Es decir, se repite un
proceso de lectura hasta que la expresin (que indica su invalidez) sea
falsa.
Problema 1. Disear un programa que permita calcular la suma acumulada
de la serie: 1+2+3+4+.+n. El usuario ingresa el nmero de trminos a sumar,
validando que el nmero de trminos no sea negativo.
Solucin //do_sum.cpp
# include <iostream.h>
# define linea ---------------------------------------
void main()
{ int cont=1,suma=0,n,dato;
gotoxy(8,2); cout<< SUMANDO TRMINOS
DE SERIE ;
Obs. La condicin de prueba

puede ser tambin
do {
}while(!(cont>n));
37
gotoxy(10,4); cout<< 1 + 2 + 3 + .....+

n;
do{gotoxy(10,6);
clreol();cout<<Ingrese nmero de
trminos = ; cin>>n;
}while(n<1);
gotoxy(10,8);
cout<< Ud sumar << n <<
terminos de la serie;
dato=cont;
do { suma+=cont;
cont++;
} while (cont<=n);
gotoxy(10,10);
cout<<La suma desde << dato << hasta << n<< es = <<suma;
getche();
}
Problema 2. Disear un programa que permita calcular la suma acumulada de
la serie:
11+22+33+44+.+nn
El usuario ingresa el nmero de
trminos a sumar. Despus del
resultado el sistema enva el mensaje
Desea continuar..? (s/n) .
Solucin// do_suma_rep.cpp
# define linea --------------------------------------
void main(){ int cont=1,suma=0,n,dato;
char resp; clrscr();
do //mdulo para repetir el programa
{clrscr();
gotoxy(8,2); cout<< SUMANDO TRMINOS DE SERIE ;
gotoxy(12,4);
cout<<1 2 3..........n;
gotoxy(10,5); cout<< 1 + 2 + 3 + .....+ n;
do{ gotoxy(10,8); clreol();cout<<Ingrese nmero de trminos = ; cin>>n;
}while(n<1);
gotoxy(10,10); cout<< Ud. sumar << n << trminos de la serie;
dato=cont;
38
do { suma+=pow(cont,cont);
cont++;
} while (cont<=n);
gotoxy(10,12);
cout<<La suma desde << dato
<< hasta << n<< es = <<suma;
gotoxy(14,15); cout<<Desea
continuar..?(s/n);cin>>resp;
suma=0 ; cont=1;
} while(resp==s|| resp==S);
}
getche();
}
la
SERIE = 1/(1+2^2+3^2 +4^2.......+ x^n)
Para un error de e =10 exp(-2) ingresado por el usuario.
Solucin //do_whi_serie.cpp
# define linea ----------------------------------------------------
void main () { int n=1; float s=0.0,e;
gotoxy(10,2);cout<<Ingrese precisin(error) :;cin>>e; cout<<linea;
do
{ s=s+(1.0/(pow(n,2)));
gotoxy(10,3+n);
cout<<setw(10)<<setprecision(2)<<valor de s=<<s<<en iteracin <<n;
n++;
}while(!(1.0/(n*n)<e));
gotoxy(10,n+7);
cout<<Valor aproximado final: ;cout<<setw(6)<<setprecision(3)
<<s<< en iteracin <<n<<endl;
gotoxy(10,n+9);cout<<Sesatisface que:;cout<<setw(6)<<setprecision(3)<<p
<<<<<e<< en iteracin <<n<<endl;
getche(); }
Problema 4. Disear un programa que permita validar prcticas calificadas
definidas en el rango:0..20. El sistema solo acepta tres intentos, los cuales le van
informando y, superado este valor, finaliza el programa.
Solucin // validar.cpp
void main() { int i=0,pc1;
clrscr(); gotoxy(10,4); cout<< Sr. usuario, tiene Ud. solo 3 opciones;
39
do { i++;
gotoxy(10,8); cout<< Le quedan <<(4-i)<<
intentos:;clreol();cin>>pc1;
gotoxy(10,12);cout<< La prctica pc1= << pc1<< esta fuera de rango ;
if(i>=3 ) {clrscr();
gotoxy(12,8);cout<<Sr. se agotaron sus opciones, hasta luego: ;getche();
exit(1);}
}while ((pc1<0)||(pc1>20)); clrscr();
gotoxy(12,8);cout<<Sr. Bienvenidos al sistema: ; getche(); }
Problema 5. Disear un programa que valida, si desea o no, finalizar con la

ejecucin del programa despus de mostrar los resultados de calcular el resto de
dos nmeros, donde los nmeros son ingresados por el usuario.
Solucin //do_while_si.cpp
void main() { int a,b; char resp;
float k;
do{cout<<ingresar el valor de
a:;cin>>a;
cout<<ingresar el
valor de b:;cin>>b;
k=a%b;
cout<<El resto de <<a<<entre <>resp; clrscr();
} while((resp==s) && (resp==n));
} while ( resp ==n); getch();
}
40
Problema 6. Disear un programa que permita ingresar una cantidad de dinero y

luego el programa debe descomponer el billete ingresado en cantidades menores
es decir en:
Billetes de 100, de 50, de 20 de 10 de 5 y de 1 sol
Solucin // while_Billete.cpp
void main()
{ int s,b100,b50,b20,b10,b5,b1,r1,r2
,r3,r4,r5;
clrscr();
char op=y;
while(op==y) { do
{ cout<<\nIngrese la Cantidad de
Soles, en el rango 0.. 1000;cin>>s;
}
while (!(s>=1000));
b100=int(s/100);r1=s%100; b50=int(r1/50);r2=r1%50;
b20=int(r2/20);r3=r2%20;
b10=int(r3/10);r4=r3%10;
b5=int(r4/5);r5=r4%5; b1=r5;
cout<<\nHay<<b100<<billetes de 100;
cout<<\nHay <<b50<< billetes de 50;
cout<<\n\n\t\tDESEA CONTINUAR (y/n): ;cin>>op; cout<<\n;
clrscr();
} getch(); }
Problema 7. Disear un programa que permita leer n nmeros enteros y luego
generar reportes para conocer:
Total de nmeros PARES POSITIVOS, suma de nmeros PARES POSITIVOS, total
de nmeros PARES NEGATIVOS, suma de nmeros PARES NEGATIVOS, total de
nmeros IMPARES POSITIVOS, suma de nmeros IMPARES POSITIVOS, total
de nmeros IMPARES NEGATIVOS, suma de nmeros IMPARES NEGATIVOS.
El programa permite leer nmeros hasta que usted presiona 0 (cero).
Solucin //do_digitos_p_i.cpp
void main() {int n,i=4,npp=0,npn=0,nip=0,nin=0;
int sumanpp=0,sumanpn=0,sumanip=0,sumanin=0;
do { i++; gotoxy(15,i);cout<<Ingrese un nmero: ;cin>>n;
if(n%2==0) { gotoxy(42,i);cout<<nmero par;
41
if (n>0)
{ gotoxy(42,i);cout<<nmero par positivo;
sumanpp+=n; npp++;
}
else
{ gotoxy(42,i);cout<<nmero par negativo;
sumanpn+=n;
npn++;
}
}
else
{ gotoxy(42,i);cout<<nmero impar;
if (n>0) { gotoxy(42,i);cout<<nmero impar positivo;
sumanip+=n;
nip++;
}
else
{gotoxy(42,i);cout<<nmero impar negativo;
sumanin+=n;
nin++;
}
}
} while(n!=0);
clrscr();
gotoxy(20,4);cout<< ............... RESULTADOS................. ;
gotoxy(10,9);cout<< Total de Nmeros PARES POSITIVOS =<<npp;
gotoxy(10,13);cout<<Suma de Nmeros PARES POSITIVOS =<<sumanpp;
gotoxy(10,10);cout<<Total de Nmeros PARES NEGATIVOS =<<npn-1;
gotoxy(10,14);cout<<Suma de Nmeros PARES NEGATIVOS =<<sumanpn;
gotoxy(10,11);cout<<Total de Nmeros IMPARES POSITIVOS =<<nip;
gotoxy(10,15);cout<<Suma de Nmeros IMPARES POSITIVOS =<<sumanip;
gotoxy(10,12);cout<<Total de Nmeros IMPARES NEGATIVOS =<<nin;
gotoxy(10,16);
cout<<Suma de Nmeros IMPARES NEGATIVOS =<<sumanin; getche();
}
Problema 8. En la siguiente figura, se ilustra la funcionalidad del mdulo de
validacin y nmero de intentos por parte del usuario, es decir, debe ingresar la
cantidad de dgitos que se desea procesar, que para nuestro caso el rango es como
mnimo cinco dgitos (puede ser: 6, 7 ,8, etc.). Por cada error, el sistema enva el
mensaje de error (ver figura) y, asimismo, el nmero de intentos que le quedan.
Si el nmero de intentos supera los tres, entonces el sistema finaliza.
Cuando se ingres correctamente la cantidad de dgitos en el rango establecido,
(en nuestro caso cinco) entra a funcionar el Mdulo de Validacin de Dgitos
definidos como cadenas, el cual solicita que usted ingrese dgito por dgito y
si ingresa una letra en forma automtica, elimina la letra y presenta los dgitos
anteriores para que contine ingresando ms datos hasta cumplir con la condicin
inicial (cinco dgitos). Ejemplo: edito 43 U, entonces el sistema elimina la letra
(carcter U y devuelve solo el nmero 43, donde usted contina ingresando
nuevos datos (ver figura).
42
Es un clsico problema en la cual se usa estructuras de control repetitivas, donde

la condicin de prueba est basada en letras o caracteres y especialmente en
caracteres que son los dgitos de 0 a 9, motivo por la cual se debe declarar, en la
sesin de variables, el tipo de dato char como un vector de caracteres.
Despus de completar de editar los cinco dgitos entra a funcionar el mdulo de
reportes, para lo cual adicionalmente usted debe contestar lo siguiente:
a. Reporte para conocer la cadena expresada en nmeros enteros.
(Usted ingres la cadena: 43256 entonces cadena en enteros: 43256)
b. Reporte de la cadena numrica en forma invertida: 65234
c. Reporte de los ltimos 2 dgitos: 34.
d. Reporte del factorial del ltimo dgito, segn c) 4! = 24.
e. Reporte del total de dgitos pares, segn c).
f. Reporte del total de dgitos impares, segn c).
Solucin // for_cadena_digitos1.cpp
#define max 100
void main()
{ char cad[max]; int i,j,x,nrovec=0,dosd,fact=1,ndp=0,ndi=0;
do
{nrovec++;
gotoxy(20,2);cout<<MDULO DE VALIDACIN: ;
gotoxy(10,4);cout<<Ingrese total
de dgitos(x>4): ;clreol(); cin>>x;
cout<<\nSr. el nmero:<<x<< no
esta en el rango solicitado, ingrese
nuevo nmero :<<endl<<endl;
if (nrovec>3)
exit(1);
else
cout<<Le quedan
<<(3-nrovec)<< oportunidades
:<<endl<<endl;
} while(x<5); clrscr();
cout<<<<endl;
cout<<\nGracias por Verificar
el mdulo de Validacin,ahora
validar SLO DGITOS <<endl;
cout<<\nIngrese cadena de slo nmeros, si edita letras estas se eliminan: ;
for(i=0;i<x; i++)
{ cad[i]=getche();
while((cad[i]!=0) &&(cad[i]!=1)&&(cad[i]!=2)&&(cad[i]!=3)&&(cad[i]!=4)&
&(cad[i]!=5)&&(cad[i]!=6)&&(cad[i]!=7)&&(cad[i]!=8)&&(cad[i]!=9))
{ cout<<endl<<Error!!!.Sr.debe ingresar slo dgitos :<<endl;
43
cout<<\nHe eliminado el
carcter:<<cad[i]<<endl;
cout<<;
cout<<\nFavor continue ingresando
nuevo dato :;
for(j=0; j<i; j++)
cout<<cad[j];
cad[i]=getche();
} }
cad[i]=\0; //para que al final asigne
todo blanco
int p=atoi(cad);
cout<<\n La cadena convertida en
nmero es :<<p<<endl;
int inv=0,d,tt=p;
while(p>0)
{d=p%10; inv=inv*10+d; p=p/10;
}
cout<<\nEl nmero <<tt << invertido es : <<inv<<endl;
dosd=inv%100;
cout<<Los dos ltimos dgitos del nmero invertido <<inv<< es <<dosd<<endl;
int uld=dosd%10; cout<<\nEl ltimo dgito de :<<dosd<< es <<uld<<endl;
for(i=1;i<=uld; i++)
fact=fact*i; cout<<\nEl factorial del ltimo dgito es :<<fact<<endl;
int vi=fact;
while(fact>0) { d=fact%10;
if (d%2==0) {ndp++; }
else { ndi++; }
fact=fact/10;
}
cout<<\nEl total de dgitos pares de <<vi<< es = <<ndp;
cout<<\nEl total de dgitos impares de <<vi<< es =<<ndi; getche(); }
2.4.3 Estructura repetitiva cuando se conoce el nmero de iteraciones: for
( <instrs >)
Permite realizar instrucciones conociendo el nmero de iteraciones.
Sintaxis:
for(inicializar;<condicin>; contador)
{ <instrucciones>;
}
donde:
1. inicializar: indica valor donde inicia el bucle.
2. <condicin>: se evala antes de cada iteracin. Si es verdadera, se ejecuta el
bloque de <instrs>, en caso contrario se termina la estructura y se salta a la
instruccin siguiente.
44
3. Contador: es la instruccin a ejecutarse cuando se termina cada iteracin

Tradicionalmente esta sentencia es utilizada para hacer que un grupo de
instrucciones se repita un nmero de veces conocido, utilizando un contador:
for (i=valor_inicial; i<=valorfinal; i++)
<intrucciones>;
Observacin. Se puede declarar una variable dentro de la inicializacin:
for (int i=valor_inicial; i<=valorfinal; i++)
<instrucciones>;
Pero la potencia del bucle for radica en que pueden omitirse tanto la inicializacin
como la expresin a evaluarse y/o el proceso de actualizacin, de tal manera
que se pueden generar los for infinitos o los for solamente condicionados (no
actualizados automticamente), de tal manera que pueden reemplazar a una
secuencia while<cond> { } o do {...} while<cond>;
//for solamente condicionado
for (;expresin;)
{<instrucciones>;
}
//for infinito
for (;;)
{ instrucciones>;
}
Para salir de esta ltima estructura,
en algn lugar dentro de ella debe
figurar la instruccin break, vista
anteriormente, sometida al valor de
una determinada expresin.
Si en un bucle for solamente
condicionado, la instruccin break se
ejecuta de todas maneras al final (no
est sometida a ninguna condicin), entonces el for puede actuar como si fuera
un if:

for (;expresin;) {
<instrucciones>;
break;
}
Sin embargo, este uso reduce la legibilidad del cdigo y por lo tanto, no es
recomendable.
Problema 1. Disear un programa que permita leer el nmero de trminos de la
serie:
1/1 ^2 +1/2 ^2 +1/3 ^2 +1/4 ^2 +............................+1/n ^2
45
y luego mostrar la suma acumulada.

Solucin //for_serie.cpp
# define linea -----------------------------
void main()
{ int i,n,u=1; float s=0;
clrscr();
gotoxy(5,4);
cout<<Ingrese cantidad de trminos:;cin>>n;
cout<<\n;
for(i=1;i<=n;i++)
{ s=s+(u/pow(i,2));
cout<< ;cout<< 1/ <<i<< ^2 + ;}
cout<<<<endl; gotoxy(5,9);cout<<linea;
gotoxy(7,10);cout<<La Suma de la Serie es ----> <<s;
getche(); }
Problema 2. Disear un programa que permita generar una tabla de multiplicar
de orden 12 *12 y luego:
a. Dar un reporte del total de nmeros dentro de la tabla con un dgito.
b. Dar un reporte del total de nmeros dentro de la tabla con dos dgitos.
c. Dar un reporte del total de nmeros dentro de la tabla con tres dgitos.
d. Calcular el nmero mayor y mostrarlo en forma invertida (144 441).
e. Usando respuesta en d), calcular el total de dgitos pares y mostrar su suma
acumulada.
f. Usando respuesta en d), calcular el total de dgitos impares y mostrar su suma
acumulada.
Solucin: for_tabla_Mult.cpp
void main()
{ int i,j, mult, und=0, dosd=0, tresd=0, may=0, u, inv=0, dp=0, di=0, sdp=0, sdi=0;
for (i=1;i<=12;i++)
for (j=1;j<=12;j++)
{ mult=i*j;
gotoxy(15+4*i,j);cout<<mult;
if (mult<10) und++;
else if ((mult<100)&(mult>=10)) dosd++;
else
{ if (mult>may) may=mult;
tresd++;
}
}
gotoxy(19,16);cout<<En la tabla hay : <<und<< nmeros de 1 dgito. ;
gotoxy(19,17);cout<<En la tabla hay: <<dosd<< nmeros de 2 dgitos.;
gotoxy(19,18);cout<<En la tabla hay: <<tres<< nmeros de 3 dgitos.;
gotoxy(19,19);cout<<El mayor nmero de 3 dgitos es: <<may;
46
do
{u=may%10;
if (u%2==0)

{ dp++;
sdp+=u;
}
else
{di++; sdi+=u;
}
inv=inv*10+u;may=may/10;
}while(may/10!=0);
inv=inv*10+may;
if (may%2==0)
{dp++; sdp+=may;
}
else { di++; sdi+=may; }
gotoxy(19,21);cout<<El inverso del mayor nmero de tres cifras es = <<inv;
gotoxy(19,22);cout<<El nmero de dgitos pares es =<<dp;
gotoxy(19,23);cout<<El nmero de dgitos impares es =: <<di;
gotoxy(19,24);cout<<La suma de los dgitos pares es = <<sdp;
gotoxy(19,25);cout<<La suma de los dgitos impares es= <<sdi; getch();}
Problema 3. Disear un programa que permita primero validar sus datos de
usuario por c_pasword = tcn100 y clave = ****. Si los datos son correctos
el sistema solicita que ingrese el nmero de trabajadores por: nombre, cdigo,
sueldo bsico, bonificacin, descuento, categora y estado civil. Para categora
47
existen tres: profesional, tcnico o auxiliar, y para estado civil: soltero, casado,
viudo o divorciado. El sueldo neto se calcula usando: s_n = (s_basico + bonif) dscto; los reportes consisten en:
a. Promedio general de sueldo de trabajadores.
b. Promedio por categoras: profesional, tcnico y auxiliar.
c. Promedio por estado civil.
d. Reporte por nombre y sueldo de cada trabajador.
Si sus datos de validacin son incorrectos, el sistema enva el mensaje:
Sr. usuario, sus Datos son incorrectos, hasta pronto;
Solucin // sue_gen.cpp
# define linea -----------------------------------------------------------
void main() { float
pp,i,n,s_basico,bonif,dscto,acu_pg=0,p_sn,s_neto,s_n1,a_pgp=0,a_p=0,s_n2,a_
pgt=0,a_t,pt,s_n3,a_pga=0,a_a=0,pa,
s_n4,a_pgs=0,a_s=0,ps,s_n5,a_pgc=0,a_
c=0,pc,s_n6,a_pgv=0,a_v=0,pv,s_n7,a_pgd=0,a_d=0,pd;
char nomb[30],cod[10],r,cat,est_civ, c_pasw[10],clave[10];clrscr();
gotoxy(14,4);
cout<< BIENVENIDOS AL SISTEMA DE VALIDACIN DE DATOS;
gotoxy(24,8);cout<<Ingrese pasword :;gets(c_pasw);
gotoxy(24,9);cout<<Ingrese clave :;gets(clave);
if (strcmp(c_pasw,tcn100)==0 && strcmp(clave,****)==0)
{clrscr();gotoxy(24,1),cout<< SISTEMA DE PLANILLAS ;
gotoxy(5,3),cout<<# de Trabajadores: ;cin>>n;
for (i=0;i<n;i++)
{gotoxy(23,4);clreol();gotoxy(5,4),cout<<Nombre Trabajador:;cin>>nomb;
gotoxy(23,5);clreol();gotoxy(5,5),cout<<Codigo Trabajador:;cin>>cod;
gotoxy(23,6);clreol();gotoxy(5,6),cout<<Sueldo Bsico :;cin>>s_basico;
gotoxy(23,7);clreol();gotoxy(5,7),cout<<Bonificacin :;cin>>bonif;
gotoxy(23,8);clreol();gotoxy(5,8),cout<<Descuento
:;cin>>dscto;
gotoxy(30,9), cout<<[P] Profesional;
gotoxy(30,10),cout<<[T] Tcnico;
gotoxy(30,11),cout<<[A] Auxiliar;
gotoxy(5,9),cout<<Categoria
:;cin>>cat;
if (cat==P)
{ s_n1=(s_basico+bonif)-dscto;
a_pgp=a_pgp+s_n1;
a_p=a_p+1;

if (a_p >0) pp=a_pgp/a_p;

else pp=0; }
if (a_p >0)
pp=a_pgp/a_p;
else pp=0; if (cat==T) { s_n2=(s_basico+bonif)-dscto;
48
a_pgt=a_pgt+s_n2;
a_t=a_t+1;

if (a_t >0)
pt=a_pgt/a_t;

else pt=0;

}
else if (a_t >0) pt=a_pgt/a_t;

else pt=0;

if (cat==A) {s_n3=(s_basico+bonif)-dscto;

a_pga=a_pga+s_n3;

a_a=a_a+1;

if (a_a >0)
pa=a_pga/a_a;

else
pa=0;
}

else

if (a_a >0)
pa=a_pga/a_a;

else pa=0;

gotoxy(30,13),cout<<[S] Soltero;

gotoxy(30,14),cout<<[C] Casado;

gotoxy(30,15),cout<<[V] Viudo;

gotoxy(30,16),cout<<[D] Divorciado;

gotoxy(5,11),cout<<Estado Civil
:;cin>>est_civ;
if (est_civ==S)
{ s_n4=(s_basico+bonif)-dscto;

a_pgs=a_pgs+s_n4;
a_s=a_s+1;

if (a_s >0)
ps=a_pgs/a_s;

else ps=0;
}

if (a_s >0) ps=a_pgs/a_s;

else ps=0;

if (est_civ==C) {s_n5=(s_basico+bonif)-dscto;

a_pgc=a_pgc+s_n5; a_c=a_c+1;

if (a_c >0) pc=a_pgc/a_c;

else pc=0;
}

if (a_c >0) pc=a_pgc/a_c;

else pc=0;

if (est_civ==V)
{s_n6=(s_basico+bonif)-dscto;
a_pgv=a_pgv+s_n6;

a_v=a_v+1;

if (a_v >0)
pv=a_pgv/a_v;

else pv=0;

}

if (a_v >0)
pv=a_pgv/a_v;
else
pv=0;

if (est_civ==D) {s_n7=(s_basico+bonif)-dscto;
49
a_pgd=a_pgd+s_n7;
a_d=a_d+1;

if (a_d >0) pd=a_pgd/a_d;
else
pd=0;
}

if (a_d >0)
pd=a_pgd/a_d;

else pd=0;
s_neto=(s_basico+bonif)-dscto;
gotoxy(44,20+i);cout<<Sueldo Neto del Trab. <<nomb<< es: <<s_neto;
acu_pg=acu_pg+s_neto; }
p_sn=acu_pg/n; gotoxy(10,17),cout<<ESTADISTICAS DE SUELDOS ;
gotoxy(,18),cout<<Promedio General
:<<p_sn;

gotoxy(3,19),cout<<Promedio Categoria Profesional:<<pp;

gotoxy(3,20),cout<<Promedio Categoria Tcnico :<<pt;

gotoxy(3,21),cout<<Promedio Categoria Auxiliar :<<pa;

gotoxy(3,22),cout<<Promedio Soltero
:<<ps;

gotoxy(3,23),cout<<Promedio Casado
:<<pc;

gotoxy(3,24),cout<<Promedio Viudo
:<<pv;

gotoxy(3,25),cout<<Promedio Divorciado
:<<pd;
}
else{clrscr(); gotoxy(20,12);cout<<Sr. sus datos son incorrectos, hasta luego;
}
getche(); }
Primero: El usuario ingresa sus datos de acceso al sistema. Si los datos son
correctos, el sistema presenta el siguiente men. Debe iniciar ingresando el
nmero de trabajadores luego sus datos solicitados por cada trabajador.
Segundo: Ingreso de datos por cada trabajador y luego genera los reportes
solicitados:
Problema 4. Disear un programa que permita leer un nmero n de alumnos por
cdigo, edad, peso, sexo (masculino: M / femenino: F) luego generar reportes
que permita conocer: promedio de alumnos por sexo y de acuerdo a: talla, edad
y peso.
50
Solucin //pro_sexo.cpp
#include<conio.h>
void main() { int a_m=0,a_f=0,n,i,edad;
float peso,talla,p_talla_m,p_edad_m,p_peso_m,p_talla_f,p_edad_f,p_peso_f,
a_talla_m=0,a_peso_m=0,a_edad_m=0,a_talla_f=0,a_peso_f=0,a_edad_f=0;
char sexo[10],codigo[10]; clrscr();
gotoxy(24,1),cout<<Clculo de Promedios;
gotoxy(23,2),cout<<=====================;
gotoxy(23,3);clreol();cout<< Ingrese nmero de Alumnos : ; cin>>n;
for (i=1;i<=n;i++)

{
gotoxy(23,4);cout<<Alumno #:<<i;

gotoxy(5,5),cout<<Cdigo del alumno:;gets(codigo);

gotoxy(5,6),cout<<Edad del alumno :;cin>>edad;

gotoxy(5,7),cout<<Peso del alumno :;cin>>peso;

gotoxy(5,8),cout<<Talla del alumno :;cin>>talla;

gotoxy(5,9),cout<<Sexo [M/F]
:;gets(sexo);

if (strcmp(sexo,M)==0 ||strcmp(sexo,m)==0)
{a_m = a_m+1;
a_edad_m =a_edad_m+edad;
a_talla_m =a_talla_m+talla;
a_peso_m =a_peso_m+peso;
}
else
{a_f=a_f+1;
a_edad_f=a_edad_f+edad;
a_talla_f=a_talla_f+talla;
a_peso_f=a_peso_f+peso;
}
clrscr();
}
51

//Calculando promedio de alumnos de sexo masculino
p_edad_m=a_edad_m/a_m; p_talla_m=a_talla_m/a_m;
p_peso_m=a_peso_m/a_m; p_edad_f=a_edad_f/a_f;

p_talla_f=a_talla_f/a_f;

p_peso_f=a_peso_f/a_f;
clrscr();
gotoxy(14,2);cout<<REPORTES ESTADSTICOS;
for(i=1;i<=n;i++)
{gotoxy(12,3);cout<<Total de alumnos <<n;
gotoxy(15,5);cout<<Promedio de Talla [M]: <<p_talla_m;

gotoxy(15,6);cout<<Promedio de Talla [F]: <<p_talla_f;

gotoxy(15,7);cout<<Promedio de Edad [M]: <<p_edad_m;

gotoxy(15,8);cout<<Promedio de Edad [F]: <<p_edad_f;

gotoxy(15,9);cout<<Promedio de Peso [M]: <<p_peso_m;

gotoxy(15,10);cout<<Promedio de Peso [F]: <<p_peso_f;
} getche();
}
Problema 5. Disear un programa que permita encontrar todas las soluciones de
la siguiente expresin, donde cada carcter represente dgito (s)
SEND + MORE = MONEY
Solucin //for_send_more.cpp
#include<conio.h>
void main()
{ int d,e,y,n,r,o,s,a=0;
clrscr();
cout<<\tPrograma que busca todas las soluciones de:SEND+MORE=MONEY:
\n;
s=9;
for(d=1;d<=9;d++){
for(e=1;e<=9;e++){
52
for(y=1;y<=9;y++){
for(n=1;n<=9;n++){
for(r=1;r<=9;r++){
for(o=0;o<=1;o++){
if(d+e==y){
if(n+r==e){
if(e+o==n){
if(s+1==10+o){

cout<<SEND = <<9<<e<<n<<d<< ;
cout<<MORE = <<1<<o<<r<<e<<\n;
a=a+1;
}break;
}
else{
if(e+o==10+n){
if(s+1+1==10+o){

cout<<SEND = <<9<<e<<n<<d<< ;

a=a+1;
}break;
}
}
}
else{
if(n+r==10+e){
if(e+o+1==n){
if(s+1==10+o){

cout<<SEND = <<9<<e<<n<<d<< ;

a=a+1;
}break;
}
else{
if(e+o+1==10+n){
if(s+1+1==10+o){

cout<<SEND = <<9<<e<<n<<d<< ;

a=a+1;
}break;

}
} }
}
}
else{ if(d+e==10+y){
if(n+r+1==e){
if(e+o==n){
if(s+1==10+o){

cout<<SEND = <<9<<e<<n<<d<< ;
53
a=a+1;
}break;
}
else{
if(e+o==10+n){
if(s+1+1==10+o){

cout<<SEND = <<9<<e<<n<<d<< ;

a=a+1;
} break;
} } }
else{
if(n+r+1==10+e){
if(e+o+1==n){
if(s+1==10+o){

cout<<SEND = <<9<<e<<n<<d<< ;

a=a+1;
}break;
}
else{
if(e+o+1==10+n){
if(s+1+1==10+o){

cout<<SEND = <<9<<e<<n<<d<< ;

a=a+1;
}break;
}
}
} } } } } } } } } }
cout<<----------------------------------;
cout<<\nTodas las soluciones son : <<a;
getch();}
Problema 6. Disear un programa que permita leer un nmero n positivo
comprendido dentro del intervalo del 10 al 999 y luego mostrar su factorial.
Solucin // factoria.cpp
void main()
{ long int n, factorial=1,i;
clrscr();
gotoxy(10,4);cout<< CALCULANDO FACTORIAL;
do{gotoxy(12,6);clreol(); cout<< Ingrese un nmero : ;cin>>n;
54
} while (n<10 ||n>999);

for(i=1;i<=n;i++)
factorial=factorial*i;
gotoxy(12,8);cout<<el factorial e
<<n<< es = <<factorial; getche();
}
que permita leer un nmero entero
(nmero de filas) comprendido en
el rango:1al 9 y luego mostrar la
formacin de una pirmide tal como se ilustra en la figura adjunta. El programa
debe solictar confirmacin si desea continuar imprimiendo nuevas pirmides y
dependiendo del nmero de filas.
Solucin //for_piramide.cpp
void main() {int i,j,k; char opcin;
do {int n=2;
do {if (n!=2)
{cout<<Error;getch();
}; clrscr();
cout<<CONSTRUCCIN DE UNA PIRAMIDE\n\nIngrese el nmero de filas
de la piramide: ;
cin>>n;
} while (!((n<=9)&&(n>=1)));
clrscr();
for(i=1;i<=n;i++)
{gotoxy(n-i+1,i);
for (j=1;j<=i;j++)
{cout<<j;};
for (k=j-2;k>=1;k--)
{cout<<k;};
};
cout<<\n\nDesea seguir?...<s/
n>;
do { opcion=toupper(getch());}
while
((opcion!=S)&&(opcion!=N));
} while (opcion==S);}
Problema 8. Una persona invierte 1000 soles en una cuenta de ahorros, la cuenta
da como interes el 10% anual. Suponiendo que todos los interes se quedan
depositados en la cuenta. Calcular e imprimir la cantidad que tendr la cuenta al
final de cada ao y durante 10 aos.
55
Usar a = p*( 1 + r ) ^ n
Donde
p: cantidad invertida inicialmente
r : tasa de inters
n: cantidad de aos
a: cantidad en depsito al final de cada
ao
Solucin // for_banco.cpp
# define linea -------------------------------------------
main() {float principal=1000.0,interes
=0.1,cantdep;
gotoxy(20,3);cout<<
CUENTA
BANCARIA;
gotoxy(15,5);cout<< ANNOS
CANTIDAD;
for(int anno=1;anno<=10;anno++)
{ cantdep=principal*pow(1.0+interes,anno);
gotoxy(17,6+anno);cout<<anno;
gotoxy(30,6+anno); cout<<S/. <<cantdep;
} getche();}
Problema 9. Disear un programa que permita leer un nmero entero (nmero
de filas) y luego mostrar la formacin de una pirmide tal como se ilustra en la
figura adjunta.
Solucin //for_piramide.cpp
void main() { int nl,lt,i; clrscr();
gotoxy(3,2);cout<<Ingrese nmero
de lineas:; cin>>nl;
for (lt=1;lt<=nl;lt++)
{for (i=1;i<=(nl-lt);i++) cout<< ;
for (i=lt;i<=2*lt-1;i++) cout<<i%10;
for (i=i-2;i>lt-1;i--) cout<<i%10;
cout<<\n;
}
cout<<endl;system(pause); }
Sentencia continue
Se utiliza con las instrucciones for, while y dowhile para avanzar a la siguiente
iteracin del bucle, abandonando la actual.
56
Por ejemplo, el segmento de cdigo siguiente imprimir solo los valores enteros
mltiplos de 5 en el intervalo 1100:

For (int i=1;i<=100;i++) {
if (i%5) continue;

cout<<i<< es mltiplo de 5<<endl;
NOTA: Existe otro tipo de sentencia de control llamada incondicional, la cual,

como dice su nombre, bifurca a un lugar especfico del programa marcado por
una etiqueta (label) incondicionalmente. En C++ esta estructura est representada
por la palabra reservada goto, que tiene la siguiente sintaxis:
etiqueta:
.................
goto etiqueta;
Cuando el programa llega a la lnea que contiene la instruccin goto, el flujo del
programa se bifurca a la lnea marcada por etiqueta, sin condicin alguna. La
instruccin goto, para evitar bucles infinitos, deber estar colocada dentro de una
estructura condicional, o en todo caso debe haber una instruccin de salida exit o
return entre la etiqueta y goto.
Problema 10. Disear un programa que permita leer un nmero entero positivo
comprendido entre 99 y 999999. Si el ingreso es correcto el programa solicita
que ingrese un dgito a buscar dentro del nmero ingresado, si existe genera el
reporte del nmero de veces que se repite.
Si el nmero ingresado no est en el rango, el sistema enva el mensaje:Nmero
no esta en rango
Solucin //do_if_uni.cpp
void main(){
int cont=0, digito,num,busca_dig;
cout<<\n Ingrese un nmero
:;cin>>num;
if ((num>99) && (num<999999))
{ cout<<ingrese el dgito a
buscar:;cin>>busca_dig;
do { digito=num%10;
num=num/10;
if (digito==busca_dig)
{cont++;
}
}while(num>0);
cout<< El nmero de veces es:
<<cont; } //fin del if
else cout<<nmero fuera de rango<<endl; getche();}
57
Compendio de problemas
Problema 1. Escribir un programa que lea cinco nmeros enteros, dos de ellos
por lo menos negativos. Luego, el programa deber ordenar en forma ascendente
los nmeros positivos, siempre y cuando existan por lo menos dos.
Solucin: posneg.cpp
void main() {
int num,pos,neg,max,min,med; clrscr();
do {pos=0, neg=0;

cout<<Ingrese 5 nmeros enteros no nulos<<endl;

for (int i=1;i<=5;i++) {
do {cout<<i<< nmero: ; cin>>num;
if (!num) cout<<\aError. ;
} while (!num);
if (num>0) {
pos++;
if (pos==1) max=min=med=num;
elseif (num>max) max=num;
elseif (num<min) min=num;
else med=num; }
else neg++;

} //for i=1
if (neg<2)
cout<<\nError, debe haber por lo menos 2 nmeros negativos<<endl;
} while (neg<2);
if (pos>1) {cout<<Los nmeros positivos ordenados son: <<endl;
cout<<setw(8)<<min;

if (pos==3) cout<<setw(8)<<med; cout<<setw(8)<<max;
}getch(); }
58
Problema 2. Se tienen dos relojes defectuosos, cada uno de los cuales sufre un
cierto adelanto u atraso por hora (en minutos). Si en un determinado momento
sus agujas marcan la misma hora (la correcta), determinar el da y la hora
correctos en que los dos relojes volvern a marcar esa misma hora. Considerar
que el programa lee el adelanto o atraso de cada reloj y la fecha, hora y minutos
en los cuales los tres relojes estn sincronizados.
Solucin: relojes.cpp
main() {int aa,mm,dd, h,m, a1,a2, correcto;
clrscr();

cout<<Hora y Fecha de sincronizacin;

do {correcto=1; cout<<endl<<Fecha (dd mm aa) ;
cin>>dd>>mm>>aa;
if (mm>12||mm<1) correcto=0;

else {
switch (mm) {
case 4:case 6:case 9:case 11:
if (dd>30) {correcto=0;}
break;
case 2:
if (aa%4==0 && aa%100!=0 || aa%400!=0){
if (dd>29) correcto=0;
}
elseif (dd>28) correcto=0;
break; default:

if (dd>31) correcto=0;
break;

} }
if (!correcto) cout<<\aFecha incorrecta\n;
} while (!correcto);
do {
correcto=1; cout<<Hora exacta (hh min) ;
cin>>h>>m;
if (h<0||h>23||m<0||m>59) {
correcto=0;
cout<<\aHora incorrecta\n;
}

cout<<Adelantos/atrasos de los relojes en minutos por hora;

do {

correcto=1;

cout<<endl<<\tReloj 1: ; cin>>a1;

cout<<\tReloj 2: ; cin>>a2;
if (abs(a1)>59||abs(a2)>59||a1*a1==0) {
correcto=0;

cout<<\aUno de los adelantos es incorrecto\n;
}
59
float m1=m, m2=m, mi=m; int h1=h, h2=h, hi=h;

for (;;) {
m++;
m1+=(60.0+a1)/60.0;
m2+=(60.0+a2)/60.0;
if (int(m1)==60) {m1=0.0; h1++;}
if (int(m2)==60) {m2=0.0; h2++;}
if (h1==24) h1=0;
if (h2==24) h2=0;
if (m==60) {m=0; h++;
}
if (h==24) {h=0; dd++;
}

switch (mm) {

c a s e 4 :
case 6: case 9: case 11:
i f
(dd==31) {dd=1; mm++;}

break;
case 2:

if (aa%4==0 && aa%100!=0 ||
aa%400!=0) {

if (dd==30) {dd=1; mm++;}
}
else
if (dd==29) {dd=1; mm++;}
break;
default:
if (dd==32) {dd=1; mm++;} break;
}
if (mm==13) {mm=1; aa++;}
if ((h1==h2)&&(h1==hi))
if ((int(m1)==int(m2))&&(int(m1)==int(mi))) break;
}
cout<<endl<<Los relojes volvern a sincronizarse el ;
cout<<dd<</<<mm<</<<aa<<endl;
cout<<A
la
hora
<<h<<:<<m;getch(); }
exacta:
Problema 3. Disear un programa que solicita el ingreso de un nmero entre

-999,999 y 999,999 a continuacin imprima el nombre en letras de dicho nmero.
60
Solucin //Prg_1.cpp.
void main() {int num,k,num1,r,valor,num2,num3,num4,num5,num6,num7,num
8,num9,num10;
char op;
gotoxy(12,2),cout<< CONVERSIN DE NMEROS A LETRAS<<endl;
do{ do{ cout<< \nIngrese un nmero entre -999..999 : ;cin>>num;
}while(num<-999999 || num>999999);
k=0;
num1=num; num3=num; num4=num;
num5=num; num6=num; num7=num;
do{
num=num/10 ;

k++ ;
} while(num!=0);
valor=0;

if(num1<0){ cout<<Menos ; num1=num1*-1 ;
}

do {
r=num1/pow10(k-1);

if (valor==1) { r=r%10;
}
switch(r){
case 9:
switch(k){
case 6: cout<<Novecientos ;break;
case 5:num9=num9%10000;

if(num9==0)

cout<<Noventa ;

else cout<<Noventay ;

break;
case 4: num5=num5/10000;

num5=num5%10;

num6=num6/10000;

if (num5==0 || num5!=1||num6==0){

cout<<Nueve Mil ;}break;

case 3: cout<<Novecientos ;break;

case 2: num8=num8%10;

if(num8==0)

cout<<Noventa ;

else

cout<<Noventay ; break;


num1=num1/10;
num3=num3/10;

if(num1!=1 && num1!=0||num3==0)

{ cout<<Nueve ;} break;

}

break;
61

case 8:
switch(k) {

case 6: cout<<Ochocientos ;break;
if(num9==0)
cout<<Ochenta ;
else
cout<<Ochentay ;
break;

num5=num5%10;
num6=num6/10000;

if (num5==0 || num5!=1||num6==0){

cout<<Ocho Mil ; } break;

case 3: cout<<Ochocientos ;break;

if(num8==0)
cout<<Ochenta ;
else
cout<<Ochentay ;
break;


num1=num1/10;
num3=num3/10;

if(num1!=1 && num1!=0||num3==0){

cout<<Ocho ;} break;

}
break;

case 7:

switch(k){

case 6: cout<<Setecientos ;break;


if(num9==0)

cout<<Setenta ;

else
cout<<Setentay ;
break;

num5=num5%10; num6=num6/10000;

if (num5==0 || num5!=1||num6==0){

cout<<Siete Mil ;}break;

case 3: cout<<Setecientos ;break;


if(num8==0)

cout<<Setenta ;

else

cout<<Setentay ;
break;


num1=num1/10;
num3=num3/10;

if(num1!=1 && num1!=0||num3==0){
62

cout<<Siete ;} break;
} break;

case 6:

switch(k){

case 6: cout<<Seiscientos ;break;


if(num9==0)

cout<<Sesenta ;

else

cout<<Sesentay ;
break;



if (num5==0 || num5!=1||num6==0){

cout<<Seis Mil ;}break;
case 3: cout<<Seiscientos ;break;

if(num8==0)

cout<<Sesenta ;

else

cout<<Sesentay ;
break;
num1=num1/10;
num3=num3/10;
if(num1!=1 && num1!=0||num3==0){
cout<<Seis ;} break;
}
break;
case 5:
switch(k) {
case 6: cout<<Quinientos ;break;
if(num9==0) cout<<Cincuenta ;
else
cout<<Cincuentay ;
break;
if (num5==0 || num5!=1||num6==0){
cout<<Cinco Mil ;}break;
case 3: cout<<Quinientos ;break;
if (num8==0)
cout<<Cincuenta ;
else
cout<<Cincuentay ; break;
63
num1=num1/10;
num3=num3/10;
if (num1!=1 && num1!=0||num3==0){
cout<<Cinco ;} break;
}
break;
case 4:
switch(k) {
case 6: cout<<Cuatrocientos ;break;
if(num9==0) cout<<Cuarenta ;
else
cout<<cuarentay ; break;
num5=num5%10;
num6=num6/10000;
if (num5==0 || num5!=1||num6==0){
cout<<Cuatro Mil ;}break;
case 3: cout<<Cuatrocientos ;break;
if(num8==0) cout<<Cuarenta ;
else cout<<cuarentay ;
break;
num1=num1/10;
num3=num3/10;
if(num1!=1 || num1!=0||num3==0){
cout<<Cuatro ;} break;
}
break;
case 3: switch(k) { case 6: cout<<Trecientos ;break;


if(num9==0)cout<<Treinta ;

else cout<<Treintay ;
break;


if (num5==0 || num5!=1||num6==0){

cout<<Tres Mil ;}break;

case 3: cout<<Trecientos ;break;


if(num8==0)cout<<Treinta ;

else cout<<Treintay ;
break;

num1=num1/10;
num3=num3/10;

if(num1!=1 && num1!=0||num3==0){

cout<<Tres ;} break;

}
break;
64
case 2:
switch(k) { case 6: cout<<Doscientos ;break;


if (num9==0) cout<<Veinte ;

else cout<<Veinty ;
break;

num5=num5%10;
num6=num6/10000;

if (num5==0 || num5!=1||num6==0){

cout<<Dos Mil ;}break;

case 3: cout<<Doscientos ;break;


if(num8==0)
cout<<Veinte ;

else cout<<Veinty ; break;


num1=num1/10; num3=num3/10;

if(num1!=1 && num1!=0||num3==0){
cout<<Dos;} break;

}

break;
case 1:

switch(k) {
case 6: num10=num10%100000;

if(num10==0)cout<<Cien ;

else cout<<Ciento ;break;

num4=num4%10;
switch(num4){

case 9:cout<<Diecinueve Mil ; break;

case 8:cout<<Dieciocho Mil ; break;
case 7:cout<<Diecisiete Mil ;break;

case 6:cout<<Dieciseis Mil ; break;
case 5:cout<<Quince Mil ; break;

case 4:cout<<Catorce Mil ;break;

case 3:cout<<Trece Mil ; break;

case 2:cout<<Doce Mil ; break;

case 1:cout<<Once Mil ; break;

case 0:cout<<Diez Mil ; break;
}break;

num5=num5%10;
num6=num6/10000;

if (num5==0 || num5!=1||num6==0){

cout<<Un Mil ;}break;

65

if(num7==0)cout<<Cien ;
else
cout<<Ciento ; break;

switch(num2){

case 9:cout<<Diecinueve ; break;

case 8:cout<<Dieciocho ; break;

case 7:cout<<Diecisiete ;break;

case 6:cout<<Dieciseis ; break;
case 5:cout<<Quince ; break;

case 4:cout<<Catorce ;break;

case 3:cout<<Trece ; break;

case 2:cout<<Doce ; break;

case 1:cout<<Once ; break;

case 0:cout<<Diez ; break;

} break;
num1=num1/10;
num3=num3/10;
if(num1!=1 && num1!=0||num3==0){ cout<<Uno ;} break; }
break;
case 0: switch(k) { case 6: break; case 5:break; case 4: break;
case 3: break;
switch(num2){

case 9 : cout<<Nueve ;break;

case 8 : cout<<Ocho ;break;

case 7 : cout<<Siete ;break;

case 6 : cout<<Seis ;break;

case 5 : cout<<Cinco ;break;

case 4 : cout<<Cuatro ;break;

case 3 : cout<<Tres ;break;

case 2 : cout<<Dos ;break;

case 1 : cout<<Uno ;break;

case 0 : break;

}

case 1:

num3=num3*num3;

if(num3==0){ cout<<Cero ;} break;

} break;

}
k--;
valor=1 ;
}while(k>0);
gotoxy(20,8);cout<<\nQuiere seguir en el programa(s/n): ; cin>>op;clrscr();
} while(op==s); getche();}
66
Problema 4. Negociar un prstamo de consumidor no siempre es sencillo. Una

forma de prstamo es el prstamo a plazos con documento, que funciona de la
siguiente manera:
Supongamos que un prstamo tiene un valor nominal de S/. 1000, que la tasa
de inters es de 15% anual y que la duracin es de 18 meses. Los intereses se
calculan multiplicando el valor nominal de S/. 1000 por 0.15, para dar S/. 150.
Luego esta cifra se multiplica por el periodo de prstamo de 1.5 aos para dar
un inters total a pagar de S/. 225, esa cantidad de inmediato se resta el valor
nominal, de modo que al consumidor solo le queda S/. 775, la restitucin del
prstamo se efecta con pagos mensuales iguales basados en el valor nominal.
As pues, el pago mensual del prstamo ser de S/. 1000 dividido, entre 18 lo
que queda S/. 55.56. En este mtodo de clculo, podra no ser tan malo, si el
consumidor necesita S/. 775, pero el clculo es ms complicado si el consumidor
necesita S/.1000.
Escribir el programa que lea
la cantidad que el consumidor
necesita recibir, la tasa de inters
y la duracin del prstamo en
meses.
El programa deber
calcular entonces el valor
nominal requerido para que el
consumidor reciba la cantidad
que necesita. Tambin se deber
calcular el pago mensual.
El programa debe permitir que
el usuario repita este clculo
cuantas veces crea necesario.
Solucin //do_pc1_prg02_.cpp
void main() {int t; float pm, ti, vn, cnr; char resp; clrscr();
do { clrscr(); gotoxy(10,4);cout<<Ingresar la cantidad que necesita recibir : ;
cin>>cnr; gotoxy(10,5);cout<<Ingrese la tasa de inters : ; cin>>ti; gotoxy(10,6);
cout<<Ingrese el tiempo en meses de duracin del prstamo :;cin>>t;
vn=cnr/(1-(ti*t)/12);
pm=vn/t;
gotoxy(10,8);cout<<El valor nominal es : <<vn;
gotoxy(10,9);cout<<El pago mensual es : << pm;
gotoxy (10, 10); cout<<Desea continuar...? (S/N) ;
cin>>resp;
} while( (resp == S)||(resp ==s));
getche();
}
Problema 5. Suponiendo que un par de conejos tiene un par de cras cada mes y
67
cada nueva pareja se hace frtil a la edad de un mes. Si se dispone de una pareja
frtil y ninguno de los conejos muertos. Cuntas parejas habr despus de un
ao?
Mejorar el problema calculando el nmero de meses necesarios para producir un
nmero dado de parejas de conejos.
Solucin // while_conejos.cpp
Void main()
{int mes1,mes2,mes_tot,meses;
int numero_parejas;
mes1=1;
mes2=2;
mes_tot=2; meses=1;
while (meses<12)
{mes_tot=mes1+mes2;
mes1=mes2;
mes2=mes_tot;
meses=meses+1;
}
gotoxy(5,1);cout<<CRIA DE
CONEJOS;
gotoxy(5,2);cout<<Total de perejas despues de un ao :<<mes_tot;
gotoxy(5,4);cout<<ingrese nmero de parejas=;cin>>numero_parejas;
mes1=1; mes2=2;
mes_tot=2; meses=1;
while (mes_tot<numero_parejas)
{mes_tot=mes1+mes2;
mes1=mes2;
mes2=mes_tot;
meses+=1;
}
gotoxy(5,6);cout<<el nmero de meses necesarios es=<<meses; getche();}
Problema 6. Disear un programa que permita calcular e imprimir la suma de
los siete primeros trminos de la serie de fibonaci: 1,1,2,3,5,8,13. Asimismo, el
programa debe ir mostrando las sumas parciales.
Solucin. //while_fibo.cpp
void main() { int anterior=1,nuevonum,actual=1,i=3,total=2;
gotoxy(6,i+1);cout<<anterior<<+<<actual<<endl;
while(i<8) { nuevonum=anterior+actual;
total=total+nuevonum;
i++;
anterior=actual;
actual=nuevonum;
gotoxy(6,i+1); cout<<anterior<<+<<actual<<endl;
}
gotoxy(6,i+4);cout<<El total es: <<total; getche(); }
68

la serie:
1
1
1
1
1
+ 2 + 2 + 4 + ........ + 2
2
1
2
3
4
n
para un error (precisin) de 10-2. (seor lector, puede generalizar para lectura
de cualquier grado de error).
Solucin //do_whi_serie.cpp
# define linea ----------------------------------------------------
void main () { int n=1; float s=0.0,e;
gotoxy(10,2);cout<<Ingrese precisin(error) :;cin>>e;
cout<<linea;
do {
s=s+(1.0/(pow(n,2)));
gotoxy(10,3+n);cout<<setw(10)<<setprecision(2)<<valor de s = <<s<< en
iteracin <<n<<endl;
n++;
} while(!(1.0/(n*n)<e)) ;
double p=1.0/(n*n);
gotoxy(10,n+7);
cout<<Valor aproximado final : ;
cout<<setw(6)<<setprecision(3)<<s<< en iteracin <<n<<endl;
gotoxy(10,n+9);
cout<<Se satisface que:;
cout<<setw(6)<<setprecision(3)<<p<<<<<e<< en iteracin <<n<<endl; getche();
}
69
Problema 8. El calendario gregoriano, el cual utilizamos actualmente, fue

una correccin hecha al calendario romano (de 365 das y 6 horas) por el
Papa Gregorio XIII, debido a que un ao astronmico realmente se compona
de 365 das, 5 horas, 49 minutos y 12 segundos.
Dicha correccin consisti en adelantar la fecha del 05/10/1582 al 14/10/1582 y
establecer que los aos bisiestos sean aquellos que son mltiplos de 4, pero no de
100, a menos que lo sean tambin de 400 (1900 no fue bisiesto, 1800 s lo fue). Ms
tarde, un monje estableci que el primer da en este calendario correspondi al
Lunes 1/1/4713 a.C., fecha en la cual se crey que Dios cre al mundo.
Con estos datos, implementar un programa que lea una fecha determinada
y determine su da correspondiente (lunes, martes, ...) segn el calendario
gregoriano.
Solucin //do_while_gregoriano.cpp
void main(){
int a,m,d,p,r,b=0,xxx,g;
int i,j; cout<<
Da segun calendario Gregoriano:<<endl;
cout<<Ingrese ano(D.C): ;cin>>a;
cout<<Ingrese mes : ;cin>>m;
cout<<Ingrese da : ;cin>>d;
g=a;
r=a*365;
do
{if ( ( (a%4==0) && (a%100!=0) ) || (a%400==0) )
r++;
a--;
}
while(a!=0);
switch(m){
case 1:{break;}
case 2:{r=r+31;break;}
case 3:{r=r+31+28;break;}
case 4:{r=r+31+28+31;break; }
case 5:{r=r+31+28+31+30;break; }
case 6:{r=r+31+28+31+30+31;break; }
case 7:{r=r+31+28+31+30+31+30;break; }
case 8:{r=r+31+28+31+30+31+30+31;break; }
case 9:{r=r+31+28+31+30+31+30+31+31;break; }
case 10:{r=r+31+28+31+30+31+30+31+31+30;break; }
case 11:{r=r+31+28+31+30+31+30+31+31+30+31;break; }
case 12:{r=r+31+28+31+30+31+30+31+31+30+31+30;break; } }
r=r+d; xxx=r; r=4713*365; a=4713;
do { if( ( (a%4==0) && (a%100!=0) ) || (a%400==0) )
70
r++; a--; }
while(a!=0);
r++;
xxx=xxx+r;
xxx++;
if( ( (g%4==0) && (g%100!=0) ) || (g%400==0) )
if(m<=2) xxx--; clrscr(); cout<<Corresponde al da: ; xxx=(xxx%7);
switch(xxx){ case 1:{cout<<Martes;break;}
case 2:{cout<<Miercoles;break;} case 3:{cout<<Jueves;break;}
case 4:{cout<<Viernes;break;}
case 5:{cout<<Sbado;break;}
case 6:{cout<<Domingo;break;} case 7:{cout<<Lunes;break;}
case 0:{cout<<Lunes;break;} } getch();}
Problema 9.- Un virus desconocido aumenta su poblacin de acuerdo a la
siguiente ley:
n = ni*t/(ni+t*exp(t))
en donde ni es el nmero inicial de unidades virales, t es el tiempo en minutos.
Escribir un programa que lea la cantidad inicial del virus y determine cuntos
minutos sern necesarios para que ste alcance su poblacin mxima. Indicar
dicha cantidad.
Solucin //while_virus.cpp
void main(){ int t,tt,ni,i;
float n,max; char h[100];
textcolor(11) ;
gotoxy(10,20) ;cout<<;
for (i=11 ;i <=69 ; i++)
{ gotoxy(i,4) ;cout<<; gotoxy(i,20) ;cout<<;
}
gotoxy(70,4) ;cout<< gotoxy(70,20) ;cout<<;
for(i=5;i<=19;i++)
{ gotoxy(10,i) ;cout<<; gotoxy(70,i );cout<<; }
71
gotoxy(18,2);cout<<************* VIRUS INFORMTICO ************ ;

time_t tiemp; time(&tiemp);
gotoxy(30,22);cout<<Fecha de Consultas: <<ctime(&tiemp);
gotoxy(12,6);cout<<Ingrese ni(nmero inicial de unidades virales): ;cin>>h;
ni=atoi(h);
while(ni<=0)
{ gotoxy(12,7); cout<<Error...Vuelva a ingresar valor de ni: ; cin>>h;ni=atoi(h);}
t=0; max=0;
do
{ t++;
n=ni*t/(ni+(t * pow(2.718,t) ) );
if(n>max)
{max=n; tt=t;
}
} while(n!=0);
gotoxy(13,9);cout<<los minutos necesarios son: <<tt<<endl;
gotoxy(13,11);cout<<El aumento n es: <<max<<endl;
gotoxy(13,16);cout<<La poblacin mxima ser n+ni: <<float(max+ni); getch(); }
Problema 10. Se tiene las notas de la 1ra. PC del curso de algoritmos de un
grupo de alumnos que pertenecen a diferentes secciones (U, V , W). Disear un
algoritmo para ingresar la nota y seccin de dichos alumnos (el ingreso de datos
termina cuando se ingresa como nota el nmero - 10) y luego determine:
- El porcentaje de aprobados por seccin (si existen alumnos en dicha seccin).
- La nota promedio general (de todas las secciones).
- La mayor nota y el nmero de alumnos que la poseen (de todas las secciones).
Solucin. Usando las siguientes evaluaciones, se mostrara el diseo del programa
U
V
W
Pc1
12
10
05
Pc2
10
8
18
Pc3
14
12
12
Pc4
14
12
18
Pc5
08
05
13
1.- Diseo del bucle repetitivo para ingreso de nota y seccin.- Usted ingresa
notas hasta que edite -10 mientras, tal como se ilustra en la siguiente grfica. Las
notas deben estar validadas en el rango de 0. . 20, as como las secciones solo u,
U, v, V, w, W.
//Preg_01_algo_SOLUCION.cpp
void main(){ char secc;
int nota,notamax=-1,nmax=-1,nu=0,nw=0,nv=0;
int sumav=0,sumaw=0,nau=0,nav=0,naw=0,sumau=0;
72
float pg,pv,pu,pw, promv,promu,promw;

gotoxy(5,1);cout<< El programa finaliza con nota =-10 ;
gotoxy(5,2);cout<< Ingrese nota = ;cin>>nota;
while(nota!=-10)
{ gotoxy(5,3);cout<< seccin= ;cin>>secc;
if(nota==notamax ) {nmax++; }
else
{ if(nota>notamax)
{notamax=nota; nmax=1; }
}
switch(secc)
{ case u:case U:clrscr();
sumau=sumau+nota; nu++;
if(nota>=10) {nau++; }
promu=float(sumau)/nu;
break;
case v:case V:clrscr();
sumav=sumav+nota; nv++;
if(nota>=10) {nav++; }
promv=float(sumav)/nv;break;
case w:case W:clrscr();sumaw=s
umaw+nota; nw++;
if(nota>=10) {naw++;
}
promw=float(sumaw)/nw; break;
}// fin del case
gotoxy(5,1);cout<< El programa
finaliza con nota =-10 ;
gotoxy(5,2);cout<< ingrese nota
= ;cin>>nota;
} //fin del while
//clculo de porcentaje por seccin
if(nu==0)
{
g o t o x y ( 5 , 5 ) ;
cout<<Seccin
U
no
tiene
alumnos; }
else { pu=float(nau*100)/nu; }
gotoxy(5,6);cout<< Promedio de la seccin U = <<promu;
gotoxy(5,7);cout<< Porcentaje de Aprobados = <<pu<< % ;
//clculo de porcentaje por seccin V
if(nv==0)
{gotoxy(5,9);cout<<Seccin v no tiene alumnos;}
else { pv=float(nav*100)/nv;}
gotoxy(5,10);cout<< Promedio de la seccin V = <<promv;
gotoxy(5,11);cout<< Porcentaje de Aprobados = <<pv<< % ;
//clculo de porcentaje por seccin w
if(nw==0) {gotoxy(5,13);cout<<Seccin w no tiene alumnos;
}
else
73
{
pw=float(naw*100)/nw;
}
gotoxy(5,14);cout<< Promedio de la seccin W = <<promw;
gotoxy(5,15);cout<< Porcentaje de aprobados = <<pw<< % ;
//clculo delpromedio general
pg=float(promu+promv+promw)/3;
gotoxy(5,17); cout<< Promedio de las 3 Secciones = <<pg;
//mostrar la nota mxima y cuantos la poseen
gotoxy(5,19);
cout<<la nota mxima es=<<notamax<< y la poseen <<nmax<<Alumnos;
getche();
}
Problema 11. Disear un algoritmo que realice las siguientes tareas: remita al
usuario validar sus datos de ingreso (cdigo y clave). Si el cdigo es 221 y la clave
es 999, el usuario puede ingresar al sistema, caso contrario se vuelve a pedir los
datos hasta un mximo de 3 intentos (si supera los 3 intentos el sistema enva el
mensaje No puede usar el sistema y termina el proceso). Si el usuario ingresa
al sistema, le debe solicitar un nmero entero positivo n para luego calcular la
siguiente suma de n trminos:
S = 15 + 35 + 55 + 75 + 115+ .
Luego debe mostrar el dgito mayor del nmero S y el nmero SI (SI es el nmero
invertido de S).
Ejemplo:
Para n = 2 S = 244 y SI = 442
Solucin
Mdulo I. Verificacin de usuario
autorizado a ingresar al sistema
a realizar operaciones. Aqu se
aplica la estructura de control
Repetir (do..), validando el Cdigo
= 221 de usuario (CLAVE = 999, ES
ANLOGO) y por cada error se
incrementa el contador de errores y
mediante la estructura condicional
Si se verifica que no se supere los
tres errores.
Mdulo II. Verificacin del nmero de consultas (interactivo),
el usuario puede continuar
realizando consultas (este es el
74
modo interactivo de usuario con

el sistema) cuando se aplica la
estructura de control mientras
(while..). Para lo cual, se ha
diseado la pregunta Sr. desea
continuar..? (S/N) y por cada
respuesta de S, el sistema usa un
contador (n_cons) denominado
nmero de consultas. Si supera
tres consultas el sistema finaliza.
Procedimientos
1. Verificar que el usuario (Cdigo = 221) solo tiene tres alternativas para realizar
sus consultas. Por cada error que comete, el sistema le enva mensajes de
usuario no registrado en el sistema, as como el nmero de oportunidades que
le quedan (en este caso usuario 222, no est registrado en el sistema). Tal como
se ilustra en la figura 1.
2. Si el nmero de errores es igual a 4, entonces el sistema enva el siguiente
mensaje, indicando que el usuario no tiene ms oportunidades (ver figura 2) o
fin de sesin.
Se deja constancia que el nmero de consultas no cambia, pero s el contador
de errores, el cual aceptar como mximo tres.
3. En la siguiente interfase, el usuario ingresa correctamente su cdigo 221,
entonces el sistema le da la bienvenida, as como le muestra el total (1) de
errores cometidos y luego calcula la suma de S.
4. Despus del ingreso correcto de datos del usuario, se calcula la suma
acumulada de la Serie = 1^5 + 3^5 + 5^5 + 7^5 + ... + , se debe ingresar el
nmero de trminos y luego se obtiene las respuestas mostradas en las

siguientes interfaces.
//Preg_02_algo_SOLUCION.cpp
#define linea ____________________________
void main()
75
{ int m,ner=0,ncons=0,n,sum=0,menor=999,mayor=-1,d,inv=0;
char nombre[10],apell[10],resp=s; clrscr();
while(resp==s) // para bucle si resp=s
{ ncons++; //maximo 3
if(ncons<=3)
{ ///***************************************************
do //para validar mximo 3 errores, no dependen de consultas
{ ner++; clrscr() ;
if(ner<=3)
{ clrscr(); gotoxy(10,1);cout<< Validacin de Datos de Usuario;

gotoxy(10,3);cout<<Ingrese Cdigo = ;gets(nombre);
if(strcmp(strupr(nombre),221)!=0)
{ gotoxy(7,5);cout<<linea;
gotoxy(10,6);
cout<< Codigo < << nombre << > No esta registrado ;

gotoxy(10,7);cout<< Le quedan [ <<(3-ner)<< ] oportunidades;

getche();
}
else

{ clrscr();

gotoxy(10,2); cout<< Sr. < << nombre << > Bienvenido...;
}
} //fin del del if ner<=3
else
{ gotoxy(10,2);
cout<<Sr.<<nombre << Fin de sesin, debido a [ << ner << ] Errores ;
getche();exit(0);
}
} while(strcmp(strupr(nombre),221)!=0);
gotoxy(10,4); cout<< Ud. cometio [ <<(ner-1)<< ] Errore(s) ;
gotoxy(7,5);cout<<linea; getche(); ner=0;// para cada nueva consulta
gotoxy(10,8); cout<< Serie = 1^5 + 3^5 + 5^5 + 7^5 + ... + ;
gotoxy(10,10); cout<< Ingrese nmero de trminos a sumar ;cin>>n;
for(int i=1;i<=n;i++) sum=sum+pow(2*i-1,5);
gotoxy(10,12); cout<< La suma hasta el trmino <<n<< es = <<sum; getche();
m= sum;
while(m!=0)
{ d=m%10;

if(menor>d)
{ menor=d; }

if (mayor<d) {mayor=d;
}

inv=inv*10+d;
m=m/10;
} //fin del while
} clrscr();
76
gotoxy(10,3);cout<< RESULTADOS ;
gotoxy(10,6); cout<< Serie = 1^5 + 3^5 + 5^5 + 7^5 + ... + ;
gotoxy(10,8); cout<< La suma hasta el trmino <<n<< es = <<sum;
gotoxy(10,10);cout<< * El dgito menor es = <<menor;
gotoxy(10,11);cout<< * El dgito mayor es = <<mayor;
gotoxy(10,12);cout<< * El Nmero Invertido es = <<inv;
gotoxy(10,15); cout<< Gracias por su consulta Nmero : <<ncons;
gotoxy(10,18); cout<<Sr.desea hacer nueva consulta..? (S/N);cin>>resp;
if (resp==n) //depende de resp=n
{ clrscr();gotoxy(6,5);cout<<linea; gotoxy(7,6);
cout<<Sr.<<<nombre <<>gracias por hacer <<ncons<<consulta(s) ;
gotoxy(7,7);cout<<linea; getche();exit(0);
} ///****** fin del if de nmero de consultas... mximo ncons <= 3
else
{ gotoxy(10,2);
cout<<No esta autorizado para hacer ms de<<(ncons-1)<<
consultas,adios...;
getche();exit(0);
} clrscr();//para borra ltimo reporte de consultas
//fin del while resp=s
} }
Problema 12. El siguiente programa tiene como objetivo mezclar las estructuras
de control: Repetir (do..), mientras (while ) y desde (for..) con la estructura
condicional si (if). Asimismo solicita que ingrese un nmero y calcule el
factorial respectivo.
Anlisis
- Se disear los siguientes dos mdulos principales:
Mdulo I. Verificacin de usuario autorizado a ingresar al sistema a realizar
operaciones. Aqu se aplica la estructura de control Repetir (do.. ), validando
el nombre del usuario y, por cada error, incrementa el contador de errores y
mediante la estructura condicional Si se verifica que no se supere los tres errores.
Mdulo II. Verificacin del nmero de consultas (interactivo), el usuario puede
continuar realizando consultas (este es el modo interactivo de usuario con el
sistema) cuando se aplica la estructura de control mientras (while..). Para lo cual,
se ha diseado la pregunta Sr. desea continuar..? (S/N) y por cada respuesta de
si (S),el sistema usa un contador (n_cons) denominado nmero de consultas. Si
supera tres consultas el sistema finaliza.
Procedimientos
1. Verificar que el usuario (Nombre = LUIS) solo tiene tres alternativas para
77
realizar sus consultas. Por cada error que comete, el sistema le enva mensajes
de usuario no registrado en el sistema, as como el nmero de oportunidades
que le quedan (en este caso usuario PEDRO, no est registrado en el sistema).
Tal como se ilustra en las figuras adjuntas
2. Si el nmero de errores es igual a 4, entonces el sistema enva el siguiente mensaje,
indicando que el usuario no

tiene ms oportunidades (ver
figura 2)
Se deja constancia que el nmero
de consultas NO cambia, pero
s el contador de errores, el cual
solo aceptar como mximo tres
oportunidades.
3. En la siguiente interfase, el usuario ingresa correctamente su nombre luis
(observe que est en letras minsculas), entonces el sistema le da la bienvenida,
as como le muestra el total (2) de errores cometidos y solicita que ingrese un
nmero.
4. Despus de ingresar el nmero (en nuestro caso 7), el sistema debe validar
descartando los negativos y los nmeros mayores a 50. Luego debe calcular el
factorial del nmero ingresado y mostrar los siguientes resultados: el factorial
y, a este resultado, tambien identificar: el total de dgitos, total de dgitos
nulos, total de dgitos diferentes de cero, dgito menor y dgito mayor), tal
como se ilustra en la figura. Asimismo, enva el nmero de consulta y busca
entrar al bucle interactivo de Usuario Sistema, para lo cual basta responder
a la pregunta con s o S y usted intentar realizar la consulta nmero 2,
pero antes debe verificar nuevamente el dato de usuario (luis), el resultado
indica que no se ha cometido error al validar nombre, tal como se ilustra en
la siguiente figura. (Pero puede que cometa tres errores, entonces el sistema
saldra registrando solo una consulta).
5. En la siguiente figura, se ilustra cundo el usuario realiz tres consultas
(modo interactivo) y cuando se desea hacer la consulta nmero 4, entonces se
finalizar, tal como se ilustra en la figura con el mensaje indicando que no se
puede realizar ms de tres consultas.
78
6.
Si en el paso 6, el usuario
responde
a
la
pregunta
con n, el sistema envia la
siguiente interfase, indicando
los agradecimientos por las
diferentes consultas, as como el
total de consultas realizadas.
Solucin
//while_do_if_valida_2006_Set.
cpp
# define linea ________________
____________________________
_
void main()
{ int ner=0,ncons=0,n;
char
nombre[10],resp=s;clrscr();
while(resp==s) // para bucle si
resp=s
{ ncons++; //mximo 3
if(ncons<=3){// do para validar
mximo 3 errores, no dependen
de consultas
do { ner++; clrscr() ;
if(ner<=3)
{ clrscr(); gotoxy(10,1);cout<< Validacin de Datos de Usuario;
Nombre = ;gets(nombre);
if(strcmp(strupr(nombre),LUIS)!=0)
{ gotoxy(7,5);cout<<linea;
gotoxy(10,6);
cout<< Nombre < << nombre << > No esta registrado ;
gotoxy(10,7);cout<< Le quedan [ <<(3-ner)<< ] oportunidades;
getche();
}
else { clrscr();
gotoxy(10,2); cout<< Sr. < << nombre << > Bienvenido...; }
} //fin del del if ner<=3
else { gotoxy(10,2);
cout<<Sr.<<nombre << Fin de sesin, debido a [ << ner << ] Errores ;
getche();exit(0); }
} while(strcmp(strupr(nombre),LUIS)!=0);
gotoxy(10,4); cout<< Ud. cometio [ <<(ner-1)<< ] Errore(s) ;
gotoxy(7,5);cout<<linea; getche(); ner=0;// para cada nueva consulta
do { gotoxy(10,6); clreol();cout<<Ingrese nmero = ;cin>>n;
}while(n<0 || n>50 );
79
clrscr(); int fact=1;

for(int i=1;i<=n;i++)
{fact=fact*i; }
long int m,d,nd=0,ndnocero=0,ndnulos=0,menor=999,mayor=-1; m= fact;
while(m !=0)
{ d=m%10; nd++;
if(d==0)
{ndnulos++; }
else { ndnocero++;
if(menor>d)
{ menor=d; }
if (mayor<d) {mayor=d;
}
}//fin del else
m=m/10;
} //fin del while para descomponer resultado de factorial clrscr();
gotoxy(10,2); cout<<Factorial de <<n<< = <<fact;

gotoxy(10,4);cout<< OTROS RESULTADOS ; gotoxy(7,5);cout<<linea;
gotoxy(10,7);cout<< * El factorial <<fact<< tiene <<nd<< dgito(s);
gotoxy(10,8);cout<< * Dgito(s) nulo(s) = <<ndnulos ;
gotoxy(10,9);cout<< * Dgito(s) no nulo(s) = <<ndnocero;
gotoxy(10,10);cout<< * El dgito menor es = <<menor;
gotoxy(10,11);cout<< * El dgito mayor es = <<mayor; gotoxy(7,12);cout<<linea;
gotoxy(10,14); cout<< Gracias por su consulta Nmero : <<ncons;
gotoxy(10,16); cout<<Sr.desea hacer nueva consulta..? (S/N);cin>>resp;
if (resp==n) //depende de resp=n
{clrscr();gotoxy(6,5);cout<<linea;gotoxy(7,6);
cout<<Sr.<<<nombre <<>gracias por hacer <<ncons<<consulta(s) ;
gotoxy(7,7);cout<<linea; getche();exit(0);
}}
else { gotoxy(10,2);
cout<<No esta autorizado para hacer ms de <<(ncons-1)<< consultas, adios...; getche();exit(0);
} clrscr();
}
}//fin principal
Problema 13. Las siguientes grficas (interfaces) permiten ilustrar una aplicacin
de las ESTRUCTURAS CONDICIONALES: simples, compuestas y anidadas a
un problema real de CALCULAR EL PROMEDIO FINAL de una asignatura.
Describir paso a paso los procesos a realizar:
1. Mdulo de validacin para ingresar al sistema: para este mdulo se debe
disear la instruccin que permita comparar dos cadenas, la cadena 1 o dato
ingresado por usuario = CRDOVA y cadena 2 el passWord = ***. Los
valores iniciales de la cadena estn registradas en el programa fuente en letras
80
maysculas, razn por la cual la instruccin debe ser capaz de convertir letras
minsculas a maysculas (ver figura 1). Para la comparacin y conversin use
las funciones: strcmp() y strupr(). Para simular este proceso, ver figura 1).
Interface de validacin
(Fig. 1)
Interface cuando existe error de datos

(Fig. 2)
2. Cuando el usuario ingres en forma incorrecta sus datos, el sistema enva el

mensaje mostrado en la figura2), indicando la salida del modo compilacin al
programa fuente.
3. Cuando el usuario ingres en forma correcta sus datos, el sistema solicita que
ingrese prcticas, las cuales deben estar en el rango 0..20. Si una o ms notas
no cumple con esta condicin, ver figura 3 (notas que no corresponden a la
realidad).
Error que permite salir del modo compilacin al programa fuente. Entonces
debe reiniciar la compilacin del programa y despus de usar paso 1), se
ingresa las notas y se calcula el promedio de prcticas eliminando la menor
nota (ver figura 5).
4. Si el promedio de prcticas fuera mayor a 6.5 (es nuestro caso), el alumno
puede rendir examen parcial y final (valores solo en el rango 0 al 20). En otro
caso debe volver al paso 1 y 3.
Usando estos datos, ms el promedio de prcticas, se calcula el promedio
final, (ver figura 6). Para obtener el mensaje de Alumno APROBADO ,
se debe cumplir que el promedio final sea mayor a 10.0, con lo cual finaliza
81
el proceso. Ahora, si el promedio final es menor a 10.0, el sistema brinda la

oportunidad que el alumno rinda un examen sustitutorio.
La nota de este examen, debe reemplazar al examen parcial o final, para lo cual
debe comparar examen parcial con examen final y, dependiendo del resultado,
se reemplaza al parcial o al final, y luego se procede a calcular el promedio
final, tal como se ilustra en la figura 7.
En la siguiente figura se ilustra el caso cuando el examen parcial es menor que
el examen final, debe reemplazar parcial por examen sustitutorio. Resultados
finales:
5. Ahora veremos el caso cuando el promedio de prcticas es menor a 6,5. Se

calcula el promedio eliminando la menor nota y se obtiene el mensaje (figura
8). Proceso que finaliza con el siguiente mensaje (figura 9)
Solucin // If_valida_prom_2006.cpp
#define max 20
#define linea _____________________________________________
void main()
{ int p1,p2,p3,p4,min,exs;
char usuario[10],pass[10];
float pp; clrscr();
time_t t; //t=time(&t);
gotoxy(20,8);cout<<La hora es <<ctime(&t);
gotoxy(20,11);cout<<linea; gotoxy(20,14);cout<<linea;
gotoxy(30,12);cout<< Ingrese Usuario =; gets(usuario);
82
gotoxy(30,13);cout<< Ingrese password =; gets(pass);

if((strcmp(strupr(usuario),CORDOVA)==0&&strcmp(strupr(pass),ABC)
==0))
{ clrscr(); gotoxy(10,1); cout<<Bienvenidos...Sr. <<usuario;
gotoxy(10,3);cout<< pc1=;cin>>p1;
if((p1>0)&&(p2>0)&&(p3>0)&&(p4>0)&&
(p1<=20)&&(p2<=20)&&(p3<=20)&&(p4<=20))
{ gotoxy(10,8); cout<< Satisfaciendo condicin de prcticas ;
min=p1;
if(min>p2)
{min=p2; }
else
if(min>p3) {min=p3; }
else
if(min>p4) { min=p4; }
pp=float((p1+p2+p3+p4)-min)/3;
gotoxy(10,10);cout<< La Menor prctica es = <<min<< y se elimin;
gotoxy(10,12);cout<< ===> Promedios de Prcticas <=== <<pp;
getche();
if(pp>6.5)
{clrscr();
int exp,exf;
float pf;
gotoxy(10,2);cout<< Alumno puede rendir Exmenes ;

gotoxy(10,4);cout<< Examen parcial = ;cin>>exp;

gotoxy(10,5);cout<< Examen final = ;cin>>exf;
if((exp>=0) && (exp<=20)&& (exf>=0)&&(exf<=20))
{ pf=float(pp+exp+exf)/3;
gotoxy(10,8);
cout<< Promedio final sin rendir Sustitutorio =<<pf; getche();
if(pf>10.0)
{gotoxy(10,10);
83
cout<< Promedio Final = <<pf<< => Alumno APROBADO <=;

pf=0;//para usar esta variable en un siguiente reporte
getche();
}
else//para leer sustitutorio
{ /// clrscr();
int exs;
gotoxy(12,12);cout<< ==> Alumno DESAPROBADO <== ;
gotoxy(12,14); cout<< Ingrese Examen Sustitutorio = ;cin>>exs;
int examf=exf, examp=exp;
if(exp>exf)
{ exf=exs;
gotoxy(12,16);cout<<examen final <<examf<< es reemplazado por sustitutorio
;
getche();
}
else
{ exp=exs;
gotoxy(12,16);
cout<<examen parcial <<examp<< es reemplazado por sustitutorio ;
getche();
}
pf=float(pp+exp+exf)/3;
gotoxy(20,18);cout<< Promedio final con Sustitutorio = <<pf;
if ( pf>10.0 )
{gotoxy(20,20);cout<< ==> Alumno APROBADO <== ;
}
else
{ gotoxy(20,20);cout<< ==> Alumno DESAPROBADO <== ;
}
}//fin del else par if>10.0
}// fin de validar exmenes
else
{clrscr();
gotoxy(15,12);cout<< Ingreso de Exmenes fuera de rango... ;
}
}//fin exp>0
else {clrscr(); gotoxy(3,11);
cout<<Sr.su Promedio de prcticas es menor a 6.5, no puede rendir exmenes;
gotoxy(5,12); cout<< Hasta el proximo ciclo!!!!!!;
}
} //fin 6.5
else
{ clrscr();
gotoxy(10,8);cout<< Error en el ingreso de prcticas...;
}
84
}
else
{ clrscr();
gotoxy(20,12); cout<<Sr. sus datos tienen error !!! ;
}
getche();
2.4.4 Estructuras mltiple - mdulo de operaciones aritmticas

En este mdulo se realiza lectura de dos nmeros y dispone de cuatro alternativas,
donde cada alternativa realiza una operacin aritmtica que puede ser de: suma
(+), resta (-), multiplicacin (*) y divisin ( / ) respectivamente.
En la siguiente figura (1), despus de
leer dos nmeros enteros (se valida b
para evitar divisin entre 0 ) y luego
se edita la operacin a realizar:
Procedimientos de ejecucin de cada
alternativa. Se ilustrar solo para
las operaciones de suma y divisin,
las dos restantes son similares a su
proceso.
[ + ] Suma. Despus de editar el operador +, se obtiene el mensaje conteniendo
la respuesta de +10.
[ / ] Divisin. Despus de editar el operador /, se obtiene el mensaje
conteniendo la respuesta, pero que cuando se realiza la lectura de b con valor
cero (0) , entonces el sistema debe enviar el mensaje de: Con dato <<0<< no existe
divisin, mensaje que permita salir al programa fuente.
PROGRAMA FUENTE//switch_menu_2006.cpp
#include <iostream.h> #include <stdlib.h> #include <dos.h>
#define linea ___________________________
void main()
{ char opcp,opera;
float a,b,resul;
struct date d; { getdate(&d); };
struct time t; {gettime(&t); };
gotoxy(10,2);cout<< ===> MEN PRINCIPAL <=== ;
gotoxy(5,3); cout<<linea; gotoxy(5,8); cout<<linea;
gotoxy(10,4);cout<< [O] Operaciones Aritmticas;
gotoxy(10,5);cout<< [F] Feha y Hora;
gotoxy(10,6);cout<< [C] Cuenta de ahorros ;
gotoxy(5,9);cout<< Elija opcin = ;cin>>opcp;
85
switch(opcp)
{ case o:case O:clrscr();
gotoxy(10,2);cout<< OPERACIONES ARITMTICAS;
gotoxy(10,5); cout<<Ingrese primer nmero = ;cin>>a;
gotoxy(10,6); cout<<ingrese segundo nmero= ;cin>>b;
gotoxy(5,7);cout<<linea;// primero dibujo el cuadro
gotoxy(5,8);cout<< Elija Operacin [+][-][*][/] = ;cin>>opera;
switch(opera)

{ case +:{resul=a+b;} break;
case -:{resul=a-b;}
break;
case *:{resul=a*b;}
break;

case /: { if(b!=0) resul=a/b;
else
{gotoxy(8,11);cout<< Con dato < <<b<< > no existe divisin ;
getche();
exit(0);
}
}
break;//fin fel if
default:
{ gotoxy(3,11);
cout<<Operador<<<opera <<>no
esta disponible, hasta luego..;
getche();exit(0);
}
}//fin del case opera
gotoxy(10,12); cout<< Resultado
de <<a<<opera<<b<< = <<resul;
gotoxy(8,14); system(pause);
case f: case F: clrscr();
gotoxy(10,2);cout<< Fecha Y Hora ;
gotoxy(10,5); cout<<Ao = <<d.da_year<<endl;
gotoxy(10,6);printf(dia = %d\n, d.da_day);
gotoxy(10,7);printf(mes = %d\n, d.da_mon);
gotoxy(10,9); printf(Hora= %2d:%02d:%02d.%02d\n,
t.ti_hour, t.ti_min, t.ti_sec, t.ti_hund);
getche(); break;
case c:case C:clrscr();

char usu[10],pasw[10];
int depos,saldoinic=0,opcion,tpcuenta,ret;
gotoxy(10,2); cout<< ==> MI CUENTA EN BCP <== ;
gotoxy(7,3);cout<<linea; //primero creo marco
86
gotoxy(10,4); cout<< Usuario = ;cin>>usu;

gotoxy(10,5); cout<< Clave = ; cin>>pasw;
if(strcmp(strupr(usu),TCN)==0 && strcmp(strupr(pasw),100)==0)
{ clrscr();
gotoxy(10,2);cout<< MENU PRINCIPAL ;
gotoxy(10,5);cout<< [1] Cuenta en Soles ;
gotoxy(10,6);cout<< [2] Cuenta en Dolares ;
gotoxy(10,7);cout<< [3] Salir ;
gotoxy(10,9);cout<< < Elija tipo de Cuenta > ; cin>>tpcuenta;
if((tpcuenta==1)||(tpcuenta==2))
{ clrscr();
gotoxy(15,1);
gotoxy(10,2);cout<< TIPO DE TRANSACCIONES ;
gotoxy(15,4);cout<< [1] Depositos;
gotoxy(15,5);cout<< [2] Retiros;
gotoxy(15,6);cout<< [3] Ver Saldo;
gotoxy(15,7);cout<< [4] Salir;
gotoxy(15,9);cout<< < Edite opcin > ; cin>>opcion;
if(saldoinic==0)// crago en mi cuenta una cantidad inicial
{ saldoinic=10*(1+random(10)); // random(100) genera cantid.de 2 dig. 46
}
switch(opcion)
{case 1:gotoxy(12,11);cout<<Ud. tiene un saldo de <<saldoinic;
gotoxy(12,13);out<<Cuanto desea depositar(10,100,200)..? :;cin>>depos;
if(depos==10 ||depos==100 ||depos==200)
{ saldoinic=saldoinic+depos;
gotoxy(12,15);cout<<Su saldo actual es <<saldoinic;
}
else
{ gotoxy(12,15); cout<< Monto no autorizado, hasta luego... ;getche();
exit(0);
}
getch(); break;
case 2: gotoxy(12,11);cout<<Ud. tiene un saldo de <<saldoinic;
gotoxy(12,13);cout<<Cuanto desea retirar..? : ;cin>>ret;
if((saldoinic-ret)>=20) //debo de tener un minimo de 20 soles en mi cuenta
{saldoinic=saldoinic-ret;
gotoxy(12,15);cout<<Su saldo actual es = <<saldoinic; getch();
}
else {gotoxy(8,16);cout<< Ud. no dispone de dinero, hasta luego... ; getch();
exit(0);
}
break;
case 3: gotoxy(6,11);
cout<< A la fecha Ud dispone en su cuenta de <<saldoinic; getch();break;
87
case 4: gotoxy(8,11);
Nmero de alumnos: 4
1
2
3
4
cout<<Gracias
por
cdigos
100
200
300
400
sus Transacciones... ;
Notas
16
10
16
16
getche();
break;
default : gotoxy(8,11);
cout<< Sr. el dato [<<opcion<<] No esta disponible, hasta luego.. ;
getche();exit(0);
} //fin del switch()
} // fin de if 1 o 2
else { gotoxy(20,20); cout<<Gracias por su visista...; getche();exit(0);
}
}// fin de validar datos del usuario else
{ gotoxy(6,8);cout<<Sr. hasta luego por error en datos !!! ; getche();exit(0); }
}//fin de switch O ,B F} //fine del main()
obs. Sr. usuario, validar opciones del men principal
Problema 15. Usando estructuras de control, disear un programa que permita
leer alumnos (n>0 y n<=100) por cdigo y nota respectivamente, los cdigo estn
formados solo por 3 dgitos y las notas solo son validas de 0..20 inclusive. Luego
genere reportes para conocer:
a. Mayor nota
b. Cdigo, posicin y nmero de
veces que se repite la mayor nota.
c. Secuencia de cdigos y secuencia
de notas respectivas (de la mayor).
Anlogamente
identificar
la
menor nota y realice los procesos
anteriormente solicitados para la
menor nota.
Ejemplo. Considere los datos de la siguiente tabla:
Solucin:
Interface de entrada de datos.- Se ilustra cmo se debe ingresar el cdigo y
la nota de cada alumno. El ingreso se realiza en forma interactiva al usar la
confirmacin de (S/N).
Resultados. En las siguientes interfaces, se ilustra los resultados respecto a mayor
nota, cdigo y posicin, anlogo a la menor nota y el consolidado de alumnos
aprobados y desaprobados.
Interface. Con datos respecto a la mayor nota, mostrando la secuencia de formacin
de esta, la secuencia de formacin de las notas, la secuencia de formacin de los
cdigos y la secuancia de formacin de las posiciones respectivas.
Observacin. Seor usuario describa el mdulo para la menor nota y hacer que
el programa tenga alcance general, (verificar con las notas 12, 16 12 y 16).
88
//while_prg_03.cpp
#define linea________________________________________
void main(){intcod,nota,codigos,aprob=0,desap=0,i,spos,pos,codi,mayor=-1;
int nrep=0,notas=0;
char resp=s;
gotoxy(12,1);cout<< Bienvenidos...; gotoxy(8,2);cout<<linea;
while(resp==s) { nrep++;
do{gotoxy(10,4);clreol();cout<< Ingrese cdigo <<nrep<< = ;cin>>cod;
}while(cod<1||cod>999);
do {gotoxy(10,5);clreol();cout<< Ingrese nota = ;cin>>nota;

}while (nota<0 || nota>20);
clrscr();
if (mayor<nota) {mayor=nota;
codi=cod; pos=nrep; codigos = codi; spos=pos; notas=notas*100+mayor;
}
else { if(mayor==nota)
{ notas=notas*100+mayor; codigos = codigos*1000 + cod;
spos=spos*10+nrep; }
}
if(nota>=10) {aprob++; }
else { desap++;
}
gotoxy(10,7);cout<<Desea ingresar nuevo dato..? (s/n);cin>>resp;
}
clrscr(); gotoxy(10,3);cout<< Mayor nota
= <<mayor;
gotoxy(10,4);cout<< Notas formadas
= <<notas;
gotoxy(10,5);cout<< Secuencia de Cdigos = <<codigos;
gotoxy(10,6);cout<< Secuencia de Posiciones = <<spos;
getch(); clrscr(); gotoxy(12,8);cout<<linea;
gotoxy(8,9);cout<<\t\t
mayor nota:<<mayor;
gotoxy(14,12);cout<<\tcodigo\t\tposicion;
gotoxy(12,13);cout<<linea; getche(),
i=0; int nt;
while(codigos>0)
{nt=notas%100; cod=codigos%1000;codigos=codigos/1000;
notas=notas/100;pos=spos%10;spos=spos/10;gotoxy(18,15+i);cout<<cod;
gotoxy(36,15+i);cout<<pos;
89
i++;
gotoxy(12,16+i);cout<<linea;
gotoxy(12,17+i);cout<<La
cantidad
desaprobados son :<<desap;
gotoxy(12,18+i);cout<<La cantidad de aprobados son :<<aprob;
gotoxy(12,19+i);cout<<linea; getche();}
de
Problema 16. Segn las siguientes interfaces, plantear el enunciado del problema
respectivo. Los datos correctos del usuario son:
Cdigo = tcn y clave = 123
1.
Validar datos del usuario.
Como observar la entrada de
datos son incorrectos y se repite
ms de tres veces, el sistema
envia mensaje de finalizacin.
2.
Si los datos de entrada son
correctos, entonces se dispone
las siguientes alterrnativas para
el usuario, usted puede usar
cualquiera de las alternativas,
considerando que cada alternativa se puede procesar en forma interactiva.
Vemos con alternativa P:
Primero ingresa cuatro prcticas y luego calcula el promedio eliminando la
menor nota. A contiuacin debe ingresar notas del examen parcial y final,
mostrando resultado final y se inicia la interactividad con el usuario.
3. Si el alumno tiene promedio de

prcticas menor a 6,5 no puede
rendir exmenes, con lo cual
queda desaprobado en el ciclo.
4. Si edita N, sale de opcin P y
regresa a men principal, tal
como se ilustra en paso 2.
90
5. Si edita opcin B Buscar Dgito,

primero solicita que ingrese un
nmero y un dgito a buscar.
Luego se obtiene los siguientes
resultados:
En esta interface puede usted
repetir los procesos de leer un
nmero y un dgito las veces que
sea necesario.
6. Si usa opcin N, obtiene el siguiente mensaje:

Programa Fuente // MENU.CPP
void main(){long int pd,fp,sd,sp,td,tp,nrove=0,p1,p2,p3,p4,nmin,nmin2;
int exp,tdd,exf,n,b,sr,snr,i,nrove2=0,d,di,na=0, dig_busc=0;
int no_vec_sec_rep=0,tol_sec_no_rep=0, no_vec_no_rep=0,dig,inv=0;
char cod[10],clave[10],opc,op; float pp,pf;clrscr();
gotoxy(5,2);cout<< Sr. usuario bienvenido a la validacin de sus datos... ;
do {gotoxy(3,4);cout<<Ingrese cdigo :;clreol();gets(cod);
if(strcmp(strupr(cod),TCN)!=0){nrove++;}
if(nrove>=3)
{clrscr(); gotoxy(12,5);
cout<< Sr. <<cod <<, debido que supero los 3 errores, no lo podemos atender,
gracias..; getche();exit(0);
}
}while(strcmp(strupr(cod),TCN)!=0);
do{gotoxy(3,5);cout<<Ingrese clave :;clreol();gets(clave);
if(strcmp(strupr(clave),123)!=0){nrove2++;}
if(nrove2>=3)
{clrscr();
gotoxy(2,10);cout<<Sr. << clave <<, debido que supero los 3 errores, no lo
podemos atender, gracias..;getche(); exit(0); }
}while(strcmp(strupr(clave),123)!=0);
do {clrscr();
gotoxy(12,2);cout<<------------- MENU PRINCIPAL ---------------;
91
for(i=6;i<=50;i++)
{gotoxy(5+i,4);cout<<=;gotoxy(5+i,15);cout<<=;}
for(i=1;i<=10;i++)
{gotoxy(10,4+i);cout<<||;gotoxy(55,4+i);cout<<||; }
gotoxy(15,6);cout<< Promedios del curso;
gotoxy(15,7);cout<< Buscar dgito;
gotoxy(15,8);cout<< Invertir nmero;
gotoxy(15,9);cout<< < S > Salir del sistema;
gotoxy(18,12);cout<<< Edite opcin >;cin>>opc;
switch(opc)
{case p:case P:
do {na++; clrscr();
gotoxy(5,2);cout<< Procesando promedios de Alumno #:< << na<< >
do{gotoxy(3,4);cout<<Ingrese p1 = ;clreol();cin>>p1;
}while((p1<0)||(p1>20));
}while((p2<0)||(p2>20));
}while((p3<0)||(p3>20));
}while((p4<0)||(p4>20));
nmin=p1;
if(nmin>p2){nmin=p2;}
pp=float(p1+p2+p3+p4-nmin)/3;
gotoxy(12,10);cout<< Sr. su prctica con menor nota = <<nmin;
gotoxy(12,12);cout<< Promedio eliminando la menor nota = <<pp;
getche();clrscr();
if(pp>7) {
do { gotoxy(3,4);cout<<Ingrese examen parcial:;clreol();cin>>exp;
}while((exp<0)||(exp>20));
do{gotoxy(3,5);cout<<Ingrese examen final :;clreol();cin>>exf;
}while((exf<0)||(exf>20));
pf=(pp+exp+exf)/3;
gotoxy(12,8);cout<< Promedio Final del alumno # <<na<< es =<<pf;
if(pf>10){gotoxy(12,10);cout<< Estado del # <<na << ==> Aprobado;
gotoxy(12,12);cout<< Desea Ud. continuar...?(S/N)==> ;cin>>op; }
else {gotoxy(12,10);cout<< Estado del # <<na << ==> Desaprobado ;
gotoxy(12,12);cout<< Desea Ud. continuar...?(S/N)==>;cin>>op;}
}
else {gotoxy(12,10);cout<< Desaprobado,no puede rendir examenes;
gotoxy(12,12);cout<< Desea Ud. continuar...?(S/N)==>;cin>>op;
}
}while((op==s)||(op==S));
92
break;
caseb:caseB:do{clrscr();
gotoxy(5,2);cout<< Formando secuencia de dgitos;
gotoxy(3,4);cout<< Ingrese nmero
:;cin>>n;
gotoxy(5,7);cout<<Ingrese dgito a buscar : ;cin>>dig_busc;
while(n>0) {dig=n%10;
if(dig==dig_busc)
{tol_sec_dig_rep=tol_sec_dig_rep+dig_busc*pow(10,no_vec_sec_rep);
no_vec_sec_rep++;
}
else
{tol_sec_no_rep=tol_sec_no_rep+dig*pow(10,no_vec_no_rep);
no_vec_no_rep++;
} n=n/10;}
gotoxy(5,9);cout<< TOTAL DE DGITOS REPETIDOS = <<no_vec_sec_rep;
gotoxy(5,10);cout<< SECUENCIA DE DGITOS
= <<tol_sec_dig_rep;
gotoxy(5,11);cout<< SECUENCIA NO REPETITIVA
= <<tol_sec_no_rep;
gotoxy(5,12);
cout<< TOTAL DE DGITOS NO REPETIDOS = <<no_vec_no_rep;
no_vec_sec_rep=0;
tol_sec_no_rep=0;no_vec_no_rep=0;
no_vec_no_rep=0;
tol_sec_dig_rep=0;
gotoxy(8,14);cout<< Desea ud. continuar...?(S/N)==>;cin>>op;
}while((op==s)||(op==S)); break;
casei:caseI:do{clrscr();gotoxy(5,2);cout<<Invertir nmero;
gotoxy(3,4);cout<<Ingrese nmero:;cin>>n;
if((n>999)&&(n<9999))
{while(n>0) {d=n%10;
inv=inv*10+d;
n=n/10;
}
gotoxy(12,10);cout<< Nmero invertido = <<inv;
gotoxy(12,12);cout<< Desea ud. continuar...?(S/N)==>;cin>>op;
}
else {clrscr(); gotoxy(12,10);cout<< Nmero fuera de rango... ;
gotoxy(12,12);cout<< Desea ingresar otro nmero..?(S/N)==>;cin>>op;
}}while((op==s)||(op==S));
break;
cases:caseS: clrscr();
gotoxy(12,10);cout<< Gracias por sus consultas ; getche(); exit(0); break;
default: clrscr(); gotoxy(12,10);cout<< Opcin incorrecta;
gotoxy(20,12);system(pause);op=n;break;
} //FIN DEL SWITCH
}while((op==n)||(op==N));
}//FIN DEL VOID MAIN
Problema 17. En el centro metereolgico de Argentina, se llevan los promedios
mensuales de lluvias caidas en las principales regiones productoras del pas.
93
Existen tres regiones importantes denominadas: norte, centro y sur. Disear un

programa que permita calcular:
a. Promedio anual de cada regin.
b. El mes y registro con mayor lluvia en la region sur.
c. La regin con mayor lluvia anual (los registros anuales de cada regin son
diferentes).
VARIABLES
- RNOi: variable de tipo real que inidica la lluvia caida en la regin norte en el
mes i: 1..12
- RCEi: variable de tipo real que inidica la lluvia caida en la regin centro en el
mes i: 1..12
- RNSi: variable de tipo real que inidica la lluvia caida en la regin sur en el
mes i: 1..12
- ARNO,ARCE,ARSU: Variables
que acumulan lluvias caidas en
cada regin
- MERSU: Almacena el menor
registro mensual de la regin
sur. Como trato de localizar el
mnimo, al principio lo inicializo con un valor grande
5000000
- MES: Almacena el mes con
menores con menores lluvias
en el sur
- RNO,RSU,RCE: Regiones
- PRORCE: Almacena el promedio anual de de las lluvias
caidas en la regin centro.
// For_if_Lluvias_NCS.cpp
void main(){int mes,l=1;
float arno=0,arce=0,arsu=0,mersu=
500000,rno,rce,rsu,prorce;
//for(l=1;l<=12;l++)
while(l<=12)
{gotoxy(10,l+1);cout<< Estadistica # <<l;
gotoxy(10,6);cout<< Regin Norte=;cin>>rno;
gotoxy(10,7);cout<< Regin centro=;cin>>rce;
gotoxy(10,8);cout<< Regin Sur=;cin>>rsu;
arno=arno+rno; arce=arce+rce;arsu=arsu+rsu;
if (rsu<mersu )
{mersu=rsu; mes=l;
}
94
l++; //si uso for no iria l++

}clrscr();
prorce=float(arce)/12; gotoxy(10,6);cout<<promedio de region centro = <<prorce;
gotoxy(10,7);cout<< mes con
menor lluvia regin sur <<mes;
gotoxy(10,8);cout<< registro del
mes <<mersu;getche();
clrscr(); //buscando regiones con
mayor lluvia
if (arno>arce)
{if(arno>arsu)
{gotoxy(10,8);cout<< Regin con mayo lluvia es = el Norte;
}
else {gotoxy(10,8);cout<< Regin con mayorlluvia es = el Sur ;
}
}
else
{ if(arce>arsu)
{
gotoxy(10,10);cout<< Regin con mayor lluvia es = Centro;
}
else{ gotoxy(10,10);cout<< Regin con menor lluvia es = Sur;
}
}
getche();
}
Problema 18. Disear un programa que permita a un usuario leer un nmero
entero positivo compuesto como mnimo de 6 y mximo 8 dgitos, asimismo, el
usuario ingresa un dgito a buscar en nmero. Por lo tanto, el programa debe
brindar al usuario los siguientes reportes; nmero invertido, total de dgitos
repetidos, la secuencia que forma y la suma de este cuando el usuario ingresa un
dgito a buscar, total de dgitos no repetidos, su secuencia y su suma respectiva.
Asimismo, de la secuencia no repetida, mostrar la secuencia formada por solo
nmeros pares, as como de los impares, (Ver figura, parte de resultados).
Solucin // while_busc_digi_Uni.cpp
# include<iostream.h >
# define linea --------------------------------------------------;
void main()
{long int dig,no_vec_sec_rep=0,n, sumanorep=0,sec_pares=0, cons=0;
int sec_impar=0, suma=0, npar=0, nimp=0,;
long int dig_busc=0,tol_sec_dig_rep=0,tol_sec_no_rep=0, no_vec_no_rep=0;
char opc, resp=s;
do {cons++; //para contra nmero de consultas
95
clrscr(); gotoxy(30,23);cout<< Ud. realizar la consulta # <<cons;

gotoxy(10,1);cout<< Formando secuencia de dgitos ;
gotoxy(3,2);cout<< linea;
gotoxy(5,3);cout<< Ingrese nmero
==> ;cin>>n;
gotoxy(5,4);cout<< Ingrese dgito a buscar
==> ;cin>>dig_busc;
gotoxy(10,5);cout<< RESULTADOS ;
gotoxy(3,6);cout<< linea;
while(n>0) {dig=n%10;
if(dig==dig_busc)
{tol_sec_dig_rep=tol_sec_dig_rep+dig_busc*pow(10,no_vec_sec_rep);
suma=suma+dig_busc;//suma de dgitos Repetidos
no_vec_sec_rep++;
}

else
{tol_sec_no_rep=tol_sec_no_rep+dig*pow(10,no_vec_no_rep);
sumanorep+=dig; //suma de dgitos no repetidos
no_vec_no_rep++;
if(dig%2==0)
{ sec_pares=sec_pares+dig*pow(10,npar);
npar++;
}
else {sec_impar=sec_impar+dig*pow(10,nimp);
nimp++;
}
} //fin del else
n=n/10;
} //fin del while
gotoxy(5,7);cout<< Total de Dgitos Repetidos = <<no_vec_sec_rep;
96
gotoxy(5,8);cout<< Secuencia de Dgitos

= <<tol_sec_dig_rep;
gotoxy(5,9);cout<< Suma de dgitos Repetidos = <<suma;
gotoxy(5,11);cout<<Total de Dgitos NO Repetidos= <<no_vec_no_rep;
gotoxy(5,12);cout<< Secuencia No Repetida = <<tol_sec_no_rep;
gotoxy(5,13);cout<< Suma de dgitos NO Repetidos = <<sumanorep;
gotoxy(5,16);cout<< Secuencia NO Repetida a Procesar= <<tol_sec_no_rep;;
gotoxy(5,17);cout<< Secuencia no repetida solo Pares = <<sec_pares;
gotoxy(5,18);cout<< Secuencia no repetida solo impares= <<sec_impar;
no_vec_sec_rep=0; tol_sec_no_rep=0;
suma=0;
sumanorep=0;
no_vec_no_rep=0;
no_vec_no_rep=0;
tol_sec_dig_rep=0; sec_pares=0; npar=0; sec_impar=0; nimp=0;
gotoxy(20,20);cout<< Desea Ud. continuar...?(S/N)==> ;cin>>opc;
}while((opc==s)||(opc==S));
if((opc==n)||(opc==N))
{clrscr(); gotoxy(20,12);
cout<< Ud.realizo <<cons<< consultas, hasta Luego....;
getche(); exit(1); }
}
Problema 19. Disear un programa que permita a un usuario validar sus datos de
entrada por cdigo=tcn, si los datos de entrada son correctos el sistema enva
el mensaje Bienvenidos as como el nmero de consulta y la fecha respectiva ,
luego solicita que ingrese un nmero entero comprendido en el rango del1 al 99,
este nmero permite calcular el factorial y con su resultado se debe mostrar el
nmero total de dgitos, el nmero de dgitos nulos y dgitos no nulos, asimismo,
el menor y mayor dgito.
Adicionalmente, el programa debe ser interactivo, es decir; cada vez que se
repite un nuevo proceso, el sistema solicita que ingrese el cdigo de validacin,
mostrando el nmero de consultas a la fecha (este nmero es diferente al total de
errores que cometa el usuario en su validacin de cdigo).
Asimismo, si el usuario no desea continuar, el sistema enva el mensaje de
agradecimientos, mostrando el nmero total de consultas.
Si el dato de validacin es incorrecto (recuerde que solo se dispone de tres
alternativas), superado este nmero el sistema enva el mensaje FIN DE
SESIN, PUES SUPERO MS DE INTENTOS
PROCEDIMIENTOS
1. Primera ejecucin del programa: en esta interfase, el sistema le advierte al
usuario que SLO dispone de tres alternativas para ingresar al sistema a
calcular el factorial de un nmero, para lo cual debe validar su cdigo TCN
(observe que el valor est en letras maysculas). Asimismo le indica el nmero
de consulta y la fecha correspondiente.
97
En esta interfase, el usuario ingresa su cdigo = tc, cdigo que es incorrecto.

Ante este error el sistema enva el mensaje de error y el nmero de oportunidades
que quedan, tal como se ilustra en la figura.
2. La siguiente interfase ilustra el error nmero 2, cometido por el usuario al

ingresar un cdigo = 3tcn, cdigo que no est registrado en el sistema. Se
deja constancia que el nmero de consultas no cambia, pero s el contador de
errores, como mximo tres.
3. En la siguiente interfase, el usuario ingresa correctamente su cdigo tcn

(observe que est en letras minsculas).
4. A consecuencia del paso 3, el sistema enva el mensaje de bienvenida y el

nmero de errores (2) en este caso.
98
5. Ahora el sistema solicita que ingrese un nmero SOLO en el rango del 1 al 99

(se debe validar descartando los negativos y los nmeros mayores a 99). En
esta interfase se calcula el factorial del nmero ingresado y otros resultados
(total de dgitos, total de dgitos nulos, total de dgitos diferentes de 0, dgito
menor y dgito mayor), tal como se ilustra en la figura.
Si el usuario contesta la pregunta con s, entonces se debe reiniciar el sistema

mostrando el nmero de consultas actuales (4) y la fecha, tal como se ilustra
en la siguiente interfase.
6. El usuario despus en su consulta nmero 4, ingresa el nmero 14 y los

resultados se ilustran en la siguiente intrefase.
99
7. Si el usuario responde con n, el sistema enva la siguiente interfase, indicando

los agradecimientos por las diferentes consultas, as como el total de consultas
realizadas.
Solucin / / do_valida_cod_Fact.cpp
// defina otras libreras
# define linea ------------------------------------------
# define lineam =======================================
void main()
{long int si,dp,re,opc,dt,nrovec=0,sa=0,nc=0;
char cod[10],resp=s;
while (resp==s)
{clrscr(); time_t t; time(&t);
nc++;
gotoxy(3,1);cout<< Sr. Ud dispone de 3 oportunidades ;
gotoxy(15,3);cout<< Realiza la consulta # <<nc;
gotoxy(39,3);printf( en fecha %s, ctime(&t)); ;
do //bucle infinito mientras no edite tcn
{ nrovec++; gotoxy(1,3); cout<<VALIDACIN :;
gotoxy(1,4); cout<<lineam;
if (nrovec<=3) //para salir del del bucle cuando sea mayor a 3
{ gotoxy(6,5);cout<<Ingrese codigo : ;clreol(); gets(cod);
100
if (strcmp(strupr(cod),TCN)!=0)
{gotoxy(6,7);
cout<<Sr. el cdigo ==> <<cod<< <== no esta registrado ;
gotoxy(6,9);cout<< Le quedan <<(3-nrovec)<< oportunidades :;
gotoxy(3,10); cout<<linea; getche();
clrscr();
}
else {gotoxy(6,10);
cout<<Cdigo ==> <<cod << <== registrado en el sistema, bienvenido ;
}
}
else {gotoxy(10,12);
cout<< FIN DE SESIN, PUES SUPERO MS DE<<(nrovec-1)<< INTENTOS
;
getche(); exit (0);
}
} while(strcmp(strupr(cod),TCN)!=0); //while(!(cod==100));
gotoxy(10,12);cout<<Total de errores cometidos <<(nrovec-1);
getche(); clrscr();gotoxy(10,3);cout<< BIENVENIDOS ;gotoxy(5,4);cout<<linea;
int n;long int fact=1;
do {gotoxy(10,6);cout<<Ingrese nmero : ;clreol();cin>>n;
} while((n<0)||(n>99));
gotoxy(10,8);cout<< Nmero correcto en el rango 1..99 ;
for(int i=1;i<=n;i++) {fact=fact*i; }
gotoxy(10,10);cout<<El factorial de <<n<< es = <<fact;
long int m,d,nd=0,ndnocero=0,ndnulos=0,menor=999,mayor=-1;
m= fact; while(m !=0)
{ d=m%10; nd++;
if(d==0) {ndnulos++; }
else { ndnocero++;
if(menor>d) {menor=d; }
if (mayor<d) {mayor=d; } }
m=m/10;
}//fin del while
gotoxy(10,15);cout<< OTROS RESULTADOS ;
gotoxy(10,17);cout<<El
factorial <<fact<< tiene <<nd<<
digito(s);
gotoxy(10,19);cout<< * Dgito(s)
nulo(s) = <<ndnulos ;
gotoxy(10,20);cout<< * Dgito(s) no nulo(s) = <<ndnocero;
gotoxy(10,21);cout<< * El dgito menor es = <<menor; gotoxy(10,22);cout<<
* El dgito mayor es = <<mayor;
gotoxy(10,24);cout<< Sr. desea continuar...? (S/N) ==> ;cin>>resp;
101
nrovec=0;//actualizar
}
if(resp==n) { clrscr(); time_t t; time(&t);
gotoxy(4,10);cout<< Sr. Ud. realiz <<nc << consultas ;
gotoxy(35,10);printf( en fecha %s, ctime(&t));
gotoxy(10,12);cout<<Gracias por todo, hasta luego;
gotoxy(10,16); system(pause);
}}
Problema 20. En el siguiente problema, se ha diseado un programa con ciertos
atributos, tales como: generacin de un marco, mensajes con diferentes colores,
dentro del marco se presenta los mensajes para validar dato de un usuario por
Nombre = LUIS, quien solo dispone de tres opciones, cuando comete errores
el sistema le envia el mensaje de advertencia que no est registrado, asimismo, el
nmero de oportunidades que le quedan, vea la figura adjunta.
Si el usuario ingresa correctamente su nombre, el sistema envia el mensaje de
bienvenida, as como el acumulado de los errores:
A continuacion solicita que ingrese cuatro prcticas para buscar la prctica con
menor nota.
Como se conoce la menor nota, se puede continuar con la siguiente consulta y
as puede hacer las consultas que crea conveniente, el contador de consultas nos
indica la cantidad respectiva.
Solucin //if_valida_color_utp_2007.cpp
// defina otras librerias
# define linea -------------------------------------------
void marco(int x,int y,int ancho, int alto,int color)
{int i,j;
textcolor(color);
for(i=0;i<=ancho;i++)
{gotoxy(x+i,y);cprintf(); gotoxy(x+i,y+alto);cprintf();
}
for(j=0;j<=alto;j++)
{gotoxy(x,y+j);cprintf(); gotoxy(x+ancho,y+j);cprintf(); }
textcolor(color);
}
void main()
{ int nproces=0,nrovec=0,pc1,pc2,pc3,pc4,min;
// char nombre[10],clave[10],
char nombre[10],resp; marco(6,2,60,20,10);
gotoxy(14,4);cout<< Sr. Ud solo dispone de 3 oportunidades ;
do //bucle infinito mientras no edite tcn
{clrscr(); nrovec++; marco(6,2,60,20,10);
102
if (nrovec<=3) //para salir del del bucle cuando sea mayor a 3

{textcolor(12);gotoxy(10,6); cprintf( MODULO DE VALIDACIN);
textcolor(15);gotoxy(8,7); cprintf(%s,linea);
gotoxy(10,9);cout<<Ingrese nombre = ;clreol(); gets(nombre);
if (strcmp(strupr(nombre),LUIS)!=0)
{ textcolor(12);gotoxy(10,12); cprintf(Sr. ==> );
textcolor(14);gotoxy(25,12); cprintf(%4s,nombre );
textcolor(14);gotoxy(35,12);
cprintf(<== no esta registrado );
textcolor(14);gotoxy(20,16);
cout<< Le quedan <<(3-nrovec)<< oportunidades :;
getche();
clrscr();
}
else {textcolor(14);
gotoxy(10,15);cprintf( Sr. ==>);
gotoxy(18,15);
cprintf(%4s,nombre);
gotoxy(25,15);
cprintf( <== registrado en el
sistema,Bienvenido );

}
}
else {gotoxy(10,12);
cout<<FIN DE SESION, PUES SUPERO MAS DE <<(nrovec-1)<< INTENTENTOS ; getche(); exit (0);
}
} while(strcmp(strupr(nombre),LUIS)!=0); //while(!(cod==100));
textcolor(11);gotoxy(20,19);cprintf(Total de errores cometidos = );
textcolor(11);gotoxy(50,19);cprintf( %i,nrovec-1); getche(); clrscr();
do {nproces++;
marco(6,2,60,20,10);
textcolor(22);gotoxy( 15,10);
cprintf( BIENVENIDOS AL SISTEMA DE PRCTICAS );
textcolor(122);gotoxy( 10,11);cprintf(linea); getche(); clrscr();
marco(6,2,60,20,10);
textcolor(122);gotoxy( 10,6);cprintf( BUSCANDO LA MENOR NOTA );
textcolor(122);gotoxy( 10,7);cprintf(linea);
textcolor(122);gotoxy( 10,8);cprintf( Ingrese 4 prcticas );
do{//validando la practica1, analogo hacer para p2,p3,p4
textcolor(22);gotoxy( 10,10);clreol();cprintf( PC1 = );cin>>pc1;
if(pc1<0 || pc1>20 )
{gotoxy(30,10); cout<< Error, ingrese nueva prctica ;getche(); }
else {gotoxy(30,10);cout<< Ingrese siguiente prctica ; }
}while(pc1<0 || pc1>20);
103
textcolor(22);gotoxy( 10,11);cprintf( PC2 = );cin>>pc2;

min=pc1 ;
if(min>pc2) {min=pc2;}
if(min>pc3){min=pc3;}
if(min>pc4){min=pc4;}
textcolor(13+0); gotoxy( 10,14);cprintf( Menor Nota : %i ,min);
getche(); clrscr(); marco(6,2,60,20,135);
marco(4,2,60,20,120);//marco(int x,int y,int ancho, int alto,int color)
marco(6,3,60,20,116);
textcolor(11+0);gotoxy( 20,10);cprintf( Consulta # %i,nproces);
textcolor(11+0);gotoxy( 20,18);cprintf( Desea continuar..?(S/N) ==> ),
cin>>resp; clrscr();
}while (resp==s||resp==S);
if ((resp==n)||(resp=N));
{ marco(6,3,60,20,116);
textcolor(14);gotoxy( 20,18);cprintf( Gracias por su consulta
) ;
textcolor(18);gotoxy( 20,20);system(pause);
}
}
Problema 21. Escribir un programa que lea cinco nmeros enteros, dos de ellos
por lo menos negativos. Luego, el programa deber ordenar en forma ascendente
los nmeros positivos, siempre y cuando existan por lo menos dos.
Solucin. En la siguiente grfica, se ilustra:
a. El programa no acepta nmeros negativos.
b. Tiene que editar por lo menos dos nmeros negativos.
104
En la siguiente grfica, se obtiene resultados solicitados por el usuario.
// Solucion while_if_do_pos_nega.cpp
void main() { int num,pos,neg,max,min,med,n;
clrscr();
do { pos=0, neg=0;
gotoxy(9,1); cout<<Ingrese 5 nmeros enteros no nulos ;

for (int i=1;i<=5;i++)
{ do { cout<< \n\tnumero <<i<<= ; cin>>num;

if (!num) cout<<\t\t\tError, debe ser diferente de 0\n ;

} while (!num);

if (num>0)
{pos++;

if (pos==1) max=min=med=num;
else
if (num>max)
max=num;

else
if (num<min)
min=num;
else med=num;
}
else neg++;
} //for i=1
if (neg<2)
{ cout<<\nError, debe haber por lo menos 2 nmeros Negativos<<endl;
clrscr();}
}while (neg<2);
if (pos>1) {cout<<\n\t Los nmeros positivos ordenados son: <<endl<<endl;
cout<<setw(7)<<min;

if (pos==3) cout<<setw(8)<<med; cout<<setw(8)<<max;
}
getche();
}
105
Estructuras de control: compendio de problemas

1. Secuenciales
2. Condicionales
3. Repetitivas
1. Disear un programa que permita a un usuario leer un Nmero entero positivo

compuesto como mnimo 6 y mximo 8 dgitos, asimismo el usuario ingresa
un DGITO a buscar en Nmero. Por lo tanto, el programa debe brindar al
usuario los siguientes reportes; nmero invertido, total de dgitos repetidos,
la secuencia que forma y la suma de este cuando el usuario ingresa un dgito
a buscar, Total de dgitos no repetidos, su secuencia y su suma respectiva.
Asimismo de la secuencia no repetida mostrar la secuencia formada por solo
nmeros pares as como de los impares, (Ver Figura, parte de RESULTADOS)
106
2. Disee un programa que permita calcular la suma acumulada de la siguiente

serie:
12 + 23 + 34 + 45 + ... + NN+1
para lo cual se debe leer el elemento
desde donde desea iniciar la suma
y luego el elemento hasta donde se
debe sumar. Se debe validar que el
primer elemento sea estrictamente
menor o igual al segundo elemento.
Luego realicen
los siguientes
reportes:
2.1. La suma acumulada de la serie
2.2. El resultado de 1), mostrarlo en
forma Invertida
2.3. El total de cifras que tiene resultado 1).
2.4. Total de cifras Pares segn resultado 1)
2.5. Secuencia de cifras Pares segn 1)
2.6. Suma de cifras Pares segn 5)
2.7. Total de cifras ImPares segn resultado 2.1)
2.8. Secuencia de cifras ImPares segn 1)
2.9. Suma de cifras ImPares segn 2.8)
En la siguiente interface se ilustra como debe presentar sus respuestas.

El programa debe ser Interactivo con el usuario, es decir, ejecutar el
mensaje:
Desea continuar..? (S/N)..
3. Disear un programa que permita a un usuario validar sus datos de entrada
por Clave=peru y codigo=100P, si los datos de entrada son correctos el
sistema enva el mensaje Procesando Edades de Poblacin en el Peru ,
solicitando inmediatamente que ingrese Nmero de Departamentos(Solo
107
en el rango 1..30 ), por cada Departamento debe ingresar Nmero de

Distritos(Solo en el rango 1..50 ) y por cada Distrito debe ingresar cantidad
de Pobladores,(solo en el rango 1..10000) donde por cada Poblador ingrese su
Edad(Solo en el rango 1..100), luego genere reportes para conocer( ver figura):
a) Promedio de Edades de pobladores en cada Distrito

b) Promedio de edades de Pobladores en cada Departamento
El programa debe se Interactivo, es decir despus de cada consulta debe preguntar
Sr. Desea hacer una siguiente consulta..? (S/N)==> .
Si el usuario ingrese datos incorrectos, entonces el programa indica el nmero
de error as como el nmero de intentos que le queda . Si el nmero de errores es
mayor que 3, el programa finaliza enviando el mensaje Debido a errores, Hasta
luego
4. Disear un programa que permita a un usuario validar sus datos de entrada
por cdigo=tcn, si los datos de entrada son correctos el sistema enva el
mensaje Bienvenidos as como el nmero de consulta y la fecha respectiva
, luego solicita que ingrese un nmero entero comprendido en el rango 1..99,
este nmero permite calcular el factorial y con su resultado se debe mostrar
el nmero total de dgitos, el nmero de dgitos nulos y dgitos no nulos,
asimismo el menor y mayor dgito.
Adicionalmente, el programa debe ser interactivo, es decir; cada vez que se
repite un nuevo proceso, el sistema solicita que ingrese el cdigo de validacin
mostrando el nmero de Consultas a la fecha (Este nmero es diferente al
total de errores que cometa el usuario en su validacin de cdigo).
Asimismo, si el usuario no desea continuar, el sistema enva el mensaje de
agradecimientos mostrando el nmero total de consultas.
Ahora si el dato de validacin es incorrecto (recuerde que solo se dispone de
3 alternativas), superado este nmero el sistema enva el mensaje FIN DE
SESION, PUES SUPERO MAS DE INTENTOS
108
PROCEDIMIENTOS
4.1. Primera ejecucin del programa: en esta interfase, el Sistema le advierte al
usuario que SOLO dispone de 3 Alternativas para ingresar al sistema a
calcular el factorial de un nmero, para lo cual debe validando su cdigo
TCN (observe que el valor esta en letras maysculas) Asimismo le indica
el Nmero de consulta y la fecha correspondiente.
En esta interface, el usuario ingresa su cdigo=tc, cdigo que es
incorrecto. Ante este error el sistema enva el mensaje de error y el nmero
de oportunidades que quedan, tal como se ilustra en la figura.
4.2. La siguiente interface ilustra el error nmero 2 cometido por el usuario al

ingresar un cdigo=3tcn, cdigo que no esta registrado en el sistema. Se
deja constancia que el nmero de consultas no cambia, pero si el contador
de errores, como mximo 3.
4.3. En la siguiente interface, el usuario ingresa correctamente su cdigo tcn

(observe que esta en letras minsculas)
4.4. A consecuencia del paso 3, el sistema enva el mensaje de Bienvenida y el
nmero de errores( 2) en este caso.
109
4.5. A continuacin, el sistema solicita que ingrese un nmero SOLO en el rango

1..99 (se debe validar descartando los negativos y los nmeros mayores a
99). En esta interface se calcula el factorial del nmero ingresado y otros
resultados (total de dgitos, total de dgitos nulos, total de dgitos diferentes
de 0, dgito menor y dgito mayor ), tal como se ilustra en la figura.
Si el usuario contesta la pregunta con s , entonces se debe reiniciar el

sistema mostrando el nmero de Consultas actuales(4) y la fecha , tal
como se ilustra en la siguiente interface .
4.6. El usuario despus en su consulta nmero 4, ingresa el nmero 14 y los

resultados se ilustran en la siguiente interface
4.7. Si el usuario responde con n, el sistema envi la siguiente interface,

indicando los agradecimientos por las diferentes consultas as como el total
de consultas realizadas.
110
5. Disear un programa que permite

leer 2 nmeros enteros y luego
genere un reporte que permita
visualizar tales nmeros en forma
intercambiada, tal como se ilustra
en la siguiente interface.
6. La siguiente figura, representa una
Interface para calcular el Promedio
Final de n alumnos(n>1), donde
por cada alumno, se lee 4 prcticas
calificadas con notas solo en el rango de 0..20 y luego se calcula su promedio
de prcticas (pp) eliminando la prctica con menor nota.
Para que el alumno tenga derecho a rendir Exmenes Parcial(exp.) y Final(exf.),

el promedio de practicas debe se mayor que 6,6. En otro caso El alumno esta
desaprobado en el ciclo
El promedio final (pf.) se calcula mediante: pf= (pp+exp+exf). Si pf >10 entonces
Alumno Aprobado. En otro caso alumno puede rendir examen sustitutorio (exs).
Para calcular el nuevo promedio final(pf), se considera el examen sustitutorio el
cual reemplaza al examen parcial o final dependiendo cual tiene menor nota. Si
111
pf>10 entonces Alumno

Aprobado, en otro caso
Alumno Desaprobado.
7. Disear un Programa
que permita al usuario
ingresar n empleados
(n<=100), a continuacin
por cada empleado
ingresar su sueldo respectivo. El programa
debe generar reportes
para conocer:
a). Suma acumulada de sueldo de empleados en el rango 100..1000
b). Suma acumulada de sueldo de empleados en el rango 1000..1999
c). Suma acumulada de sueldo de empleados en el rango 2000..3000.
Observacin. Se deja al lector que muestre la cantidad de Empleados por cada
rango de sueldo.
8. Una empresa, premia a sus Empleados de un cierto producto por las ventas
del da bajo las siguientes condiciones:
a) Si ventas < S/. 80, entonces no hay comisin
b) Si ventas esta en el rango de: 80..600 entonces la comisin es igual al 12%
c) Si ventas esta en el rango de: 601..1000 entonces la comisin es igual al 15%
Disear un programa que permita leer nombre de empleado, nombre de producto
y el total respectivo, luego hacer un reporte de la comisin. Tambin si las ventas
no satisfacen la
Condicin a), enviar el mensaje
Sr. ..Sus ventas No ameritan comisin. Si las ventas exceden la condicin c),
envar el mensaje Felicitaciones, ser ascendido..
9. Disee un programa que permita validar datos de usuario para ingresar

al sistema de consultas, donde el usuario se identifica por cdigo=100 y
clave=tlcn.
112
a. La validacion se debe realizar

primero el codigo y luego la
clave. La clave debe visualizarse
con el * . El usuario ingresa
su codigo, si este es correcto,
el sistema solicita que ingrese
clave, si esta contiene error, el
sistema envia el mensaje Es
Incorrecto, hasta luego . con
lo cual finaliza el programa.
Analogo para el cdigo.
b. Si los datos son correctamente
ingresados, el sistema envia
las siguientes alternativas, tal
como se ilustra en el siguiente
formulario, donde cada opcion
realiza las siguientes tareas:
<F> Formar intervalo: se trata de
formar un intervalo I:[a,b], donde
a<b. para lo cual el usuario ingresa
los nmeros enteros a,b.
Ejemplo.
*.- Si a=2 y b= 8 el sistema envia el
mensaje intervalo es correcto
* .- pero si a=8 y b=2, el sistemema
envia el mensaje de observacion,
mostrado en el formulario adjunto,
pero el mismo debe intercabiar los
valores y mostrar que el intervalo
es correcto I:2<8 o [2..8]. Luego
calcula el resto de 8 entre 2.
<M> Mayor de 3 Nmeros : El
usuario ingresa 3 nmeros enteros
positivos y luego el sistema muestra
el mayor respectivamente, ademas
indicando si es nmero Par o Impar
<N> Nmero de Cifras: El usuario
ingresa un nmero entero positivo
como minimo de 1 cifra y maximo
de k>1 cifras, luego el sistema debe
identificar y mostrar el total de
cifras del nmero ingresado.
113
 Nmero de Capicua (Palindrmico): La palabra capica (en

matemticas, nmero palndromo)
se refiere a cualquier nmero
que se lee igual de izquierda a
derecha y de derecha a izquierda
(Ejemplos: 121). El trmino se
origina en la expresin catalana
capicua (cabeza y cola).
Definicin. Un nmero palindrmico es un nmero simtrico
escrito en cualquier base a tal que
a1a2a3| a3a2a1.
Todos los nmeros de base 10 con
un dgito {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
son palindrmicos.
Existen
nueve
nmeros
palindrmicos de dos dgitos:
{11, 22, 33, 44, 55, 66, 77, 88, 99}.
Noventa de tres dgitos: {101,
111, 121,, 181, 191, 202, 212,, 292, 303, 313,, 898, 909, 919, 929,, 979, 989,
999}
Noventa con cuatro dgitos: {1001, 1111, 1221, 1331, 1441, 1551, 1661, 1771,
1881, 1991,, 9009, 9119, 9229, 9339, 9449, 9559, 9669, 9779, 9889, 9999},
Novecientos de cinco dgitos: {10001, 11011, 11111, 11211, 11311, 11411,
11511,,}
Un pequeo truco para hallarlos sera sumar un nmero con otro en el que
le damos la vuelta a sus cifras. Por ejemplo a mi me encanta el nmero 17,
y para buscar un nmero capica a partir del 17 lo que tengo que hacer es:
17+71=88 (capica).
Ejemplo: partimos del nmero 96:
96 + 69 = 165; 165 + 561 = 726; 726 + 627 = 1353; 1353 + 3531 = 4884
<S> Salir: Permite finalizar con el sistema
Si el usuario ingresa una letra que no corresponde a las opciones, el sistema
enva el mensaje Opcin no disponible y finaliza.
9. Disear un programa que permita Leer o ingresar Edades de n alumnos(n es
definido por usuario) y luego mostrar la Menor edad y la posicin Actual del
dato ingresado.
En la siguiente grafica se ilustra la lectura y los reportes, as como las edades
cuando se tiene que actualizar
114
Verificar: n=3, con las siguientes datos:

Nombres
Ana
Lus
Pedro
Edades
30
15
28
Posicin
El programa debe ser Interactivo,

es decir; despus de finalizar con el
ingreso de los datos, el sistema enva
el mensaje de Desea continuar
(S/N). Debe validar la edicin solo de
S o N. por cada error debe mostrar el mensaje Ingrese nueva letra, error # .
Cuando edita S, contina con la lectura de nuevos datos y si edita N, el programa
finaliza indicando el nmero de consultas realizadas.
10. Disear un programa interactivo que permita a un usuario Validar sus datos
de ingreso al sistema. Los datos pueden ser: una letra o un dgito. Si el usuario
ingresa un dgito, el sistema confirma que dato es un dgito y luego solicita
que ingrese un nmero entero mayor o igual a 10 y menor que 10000. Luego
puede ocurrir que:
I. Si el nmero es par, entonces
el programa debe realizar las
siguientes tareas:
a) Mostrar el nmero en forma invertida
b) Conocer el nmero total de dgitos.
c) Conocer el nmero total de dgitos pares.(ver figura.)
d) Conocer el nmero total de dgitos impares(ver figura.)
II. Si el nmero es impar, entonces el
sistema confirma que el dato es un
115
DGITO y luego el programa debe

calcular y mostrar el factorial del
ultimo dgito.
Ahora, si el usuario ingresa una
letra, el sistema confirma mediante
el mensaje, que el dato es una
LETRA, luego solicita que ingrese
una cadena, de la cual mostrar
su longitud y por cada posicin
del carcter, formar la secuencia
respectiva. Ver figura
11. Disear un Programa que permita
leer un nmero entero n, en Base
Decimal y devuelve su equivalente
en el Sistema Binario. En la siguiente interface se ilustra el ejemplo:
12.Disear un Programa que permita leer un nmero entero n(n>1) en Base

Binaria y devuelve el nmero expresado en en base Decimal. En la siguiente
interface se ilustra el ejemplo
Definicin. Un nmero perfecto es
un nmero que es igual a la suma
de sus divisores sin incluirse l
mismo.
As, 6 es un nmero perfecto,
porque sus divisores propios son
1, 2 y 3; y 6 = 1 + 2 +3. Los siguientes
nmeros perfectos son 28, 496 y
8128.
Se deja al usuario, disear el
programa que ingrese un nmero
116
hasta donde se desea procesar y el programa en forma aleatoria debe mostrar

los nmeros perfectos encontrados
12.Algunos nmeros enteros se pueden representar como suma de dos enteros al
cuadrado, por ejemplo 50 = 12 + 72 = 52 + 52. Escribe un programa que determine
la cantidad de formas distintas t en las que se puede escribir un nmero entero
n como suma de dos cuadrados a2 + b2 donde 0 a b n. Por ejemplo, si n =
50 entonces hay dos formas, por lo que t = 2.
Entrada: Un nmero entero n tal que 1 n 2,000,000,000.
Salida: Un nmero entero t.
13. Escribe un programa que determine el valor mximo p y el valor mnimo q

que toma la funcin f(x) = (ax + b)/(cx + d) en los enteros que se encuentran
en el intervalo dado por m y n (incluyndolos). Observa que es posible que la
funcin no este definida en todos los puntos de ese intervalo. Adems, deber
determinar los enteros r y s en los cuales se alcanzan estos valores (es decir,
tales que f(r) = p y f(s) = q). En caso de que haya varios enteros r y s con esa
propiedad, se deben dar aquellos cuyos valores sean los menores posibles.
Por ejemplo, si f(x) = (x + 2)/(x - 2) y el intervalo esta dado por m = -2 y n = 3
entonces vemos que f(-2) = 0, f(-1) = -1/3, f(0) = -1, f(1) = -3, f(2) no esta definida
y f(3) = 5, por lo que r = 3 y s = 1.
Entrada: Seis nmeros enteros a, b, c, d, m, n (con m n) separados por
espacios y todos ellos en el intervalo de -1000 a 1000 (incluyndolos). Puedes
suponer que el intervalo m x n contiene al menos un entero x en el cual la
funcin f(x) esta definida (y por lo tanto el mximo y el mnimo existen).
Salida: Dos nmeros enteros r, s, separados por espacios.
14. Euclides y Euler: Dados dos enteros positivos p y q, su mximo comn

divisor es el entero positivo mas grande que los divide a ambos exactamente
y se puede calcular con el algoritmo de Euclides (el cual puedes investigar
como funciona casi en cualquier lugar). Si el mximo comn divisor de p y q
es igual a 1, entonces se dice que p y q son primos relativos. La funcin j(n) de
Euler es igual a la cantidad de enteros en el intervalo del 1 al n que son primos
117
relativos con n. Por ejemplo,

j(9) = 6 debido a que 9 es primo
relativo con los seis enteros 1, 2,
4, 5, 7 y 8. Escribe un programa
que, dados dos enteros p y q,
encuentre el mximo valor m
que toma la funcin j(n) de
entre todos los enteros n en el
intervalo de p a q, adems del
menor valor de n en ese intervalo tal que j(n) = m.
ejemplo, si p = 4 y q = 10 entonces j(4) = 2, j(5) = 4, j(6) = 2, j(7) = 6, j(8) = 4, j(9) =
6 y j(10) = 4 por lo que m = 6 y n = 7.
Entrada: Dos nmeros enteros p y q tales que 1 p q 1,000,000.
Salida: Un nmero entero m y un nmero entero n.
15.Nmeros menores que dos
mil: Imagine que tiene una
lista de nmeros enteros (todos
ellos menores que dos mil) a
la cual se le han suprimido las
separaciones. Por ejemplo, si
comenz con la lista 31, 415, 9,
265 entonces obtuvo la cadena s
= 314159265. Ahora usted quiere recuperar una lista de nmeros enteros (todos
ellos menores que dos mil) agrupando los dgitos tanto como sea posible desde
el principio de la cadena. En nuestro caso, obtendr la lista 314, 1592, 65 con
p = 3 elementos. Despus usted realiza la misma operacin pero comenzando
desde el final de la lista. En nuestro caso, obtendr la lista 314, 159, 265 con f
= 3 elementos. Escriba un programa que dada la cadena de dgitos encuentre
cuantos elementos p y f contienen cada una de las listas.
Entrada: Una cadena s que contiene entre 1 y 1000 dgitos.
Salida: Dos nmeros enteros p y f separados por un espacio.
16.Diferencias de cuadrados:
Algunos enteros se pueden
representar como diferencia
de dos enteros al cuadrado,
por ejemplo 15 = 42 - 12 = 82 72. Escribe un programa que
determine la cantidad de formas
distintas t en las que se puede
escribir un nmero entero n como diferencia de dos cuadrados a2 - b2 donde
a b 0.
Entrada: Un nmero entero n tal que 0 n 1,000,000.
Salida: Un nmero entero t.
118
16. Sumas de nmeros consecutivos

Escribe un programa que determine la cantidad f de formas en las que se
puede escribir un nmero entero positivo n como suma de uno o ms nmeros
enteros positivos consecutivos. Tu programa tambin debe determinar el
nmero ms pequeo p que forma parte de alguna de estas sumas.
Por ejemplo: Si n = 33 entonces
f = 4 y p = 3 ya que 3 + 4 + 5 + 6 + 7 + 8 = 10 + 11 + 12 = 16 + 17 = 33.
Entrada: Un nmero entero n en el intervalo de 1 a 1,000,000 (incluyndolos).
Salida: Dos nmero enteros f y p.
17. Puntos dentro de un tringulo: Considera un tringulo T dado por sus tres
vrtices (a, b), (c, d) y (e, f) con coordenadas enteras. Algunos puntos de
coordenadas enteras estn sobre los lados de T y otros puntos de coordenadas
enteras estn dentro de T. Escribe un programa que encuentre las cantidades s
y t de puntos sobre los lados y dentro de T, respectivamente.
Por ejemplo, si los vrtices de T tienen las coordenadas (0, 1), (4, 3) y (2, 5)
entonces s = 6 y t = 4 ya que los 6 puntos (0, 1), (2, 2), (4, 3), (3, 4), (2, 5) y (1, 3)
estn sobre los lados de T mientras que los 4 puntos (1, 2), (2, 3), (2, 4) y (3, 3)
estn dentro de T.
Entrada: Seis nmeros enteros a, b, c, d, e, f separados por espacios y todos
ellos en el intervalo de -1000 a 1000 (incluyndolos). Puedes suponer que los
tres vrtices de T no estn alineados y por lo tanto forman un tringulo.
Salida: Dos nmeros enteros s y t separados por un espacio.
18. Boletos por besos: Para ir hacia su escuela, Juan aborda un camin. Cuando
Juan sube al camin y deposita las monedas en la alcanca, el conductor le da
un boleto con un nmero de serie consecutivo, el cual generalmente llega a
la basura. Sin embargo, un da el se entera de algo interesante. Si la suma de
los dgitos de dicho boleto es 21, el lo puede cambiar con quien quiera por un
119
beso. Juan quiere conseguir muchos besos de la persona que esta enamorado
y ella ha aceptado drselos a cambio de dichos boletos, pero no es tan fcil
conseguirlos. Juan ha decidido que si el boleto que le da el conductor no suma
21 esperara hasta que el de una persona que suba despus de el sume 21, y
le pedir a esta su boleto, para lo cual debe ir realizando las cuentas a mano,
cosa que es muy tediosa. Ayuda a Juan escribiendo un programa que dado
un nmero n de 7 dgitos, le proporcione el nmero p de personas que deben
abordar despus de el para que obtenga el boleto deseado y m, donde m
representa los 7 dgitos de dicho boleto. Cuando un tiraje de boletos termina,
es decir llega a 9999999, el conductor toma otro tiraje comenzando nuevamente
en el nmero 0000000.
Entrada: Un nmero entero n de 7 dgitos (que posiblemente comienza con
ceros).
Salida: Un nmero entero p y un nmero m de 7 dgitos.
19. No te salgas: Una pulga muy especial se encuentra en la esquina de una mesa
y quieres que brinque hasta la esquina contraria de la misma mesa. Lo especial
de la pulga es que se ha aprendido una sucesin numrica y la usara para
determinar como brinca. Cada vez que aplaudas, la pulga decidir si se queda
donde esta o si da un brinco cuya longitud esta determinada por el termino
correspondiente de la sucesin. Los brincos siempre sern paralelos a los lados
de la mesa y siempre debern alejar a la pulga de su posicin inicial. Lo ideal
es que la pulga logre llegar a la esquina contraria de la mesa. Sin embargo,
basta con que llegue a una posicin tan cercana como sea posible. Lo que no
esta permitido es que la pulga salte hacia afuera de la mesa (le ha costado
mucho subir a la mesa como para que ahora la dejes caer).
Ejemplo, si la sucesin de n = 7 saltos de la pulga fuera s = (3, 1, 4, 1, 5, 9, 2) y
la mesa midiera a = 5 por b = 6 entonces la pulga podra lograr su objetivo si su
sucesin de brincos fuera arriba, arriba, derecha, arriba, nada, nada y derecha.
Por otro lado, si su sucesin fuera arriba, arriba, derecha, nada, nada, nada,
nada entonces no llegara a la esquina contraria pero tampoco se saldra de la
mesa.
Entrada: El archivo de texto nts.ent contendr un rengln con tres enteros n,
a y b separados por espacios seguido de un rengln con n enteros positivos
s1, s2, ..., sn y separados por espacios. Puedes suponer que todos estos enteros
estn en el rango de 1 a 1000, incluyndolos.
120
Salida: El archivo de texto nts.sal deber contener un rengln con tres enteros
n, c y d separados por espacios seguido de un rengln con n enteros positivos
t1, t2, ..., tn y separados por espacios. Los valores de c y d representan la
coordenada a la que llega la pulga y para 1 i n, el valor de ti es 0 si la
pulga no dio el salto de longitud si, 1 si lo dio hacia arriba y 2 si lo dio hacia la
derecha.
Evaluacin: 1 punto si los n saltos indicados dejan a la pulga en la coordenada
( c, d) de la mesa. En ese caso, 9(c2 + d2)/(a2 + b2) puntos adicionales. El primer
ejemplo de salida mostrado abajo obtendra 1 + 9(52+62)/(52+62) = 10 puntos,
el segundo ejemplo 1 + 9(42+42)/(52+62) = 4 puntos y el tercer ejemplo 0 puntos
porque la pulga se sali de la mesa.
20. Disear un programa que permita jugar al Master Mind. Para ello se escribir
el Programa de la siguiente forma:
Generar cuatro valores enteros aleatorios entre 0 y 9 distintos entre si.
Preguntar al usuario por cuatro valores enteros.
Considerando ambas combinaciones, indicar cuntos nmeros comunes
estn en la misma posicin y cuntos valores comunes estn en distinta
posicin.
Ejemplo: 3786 y 8760 uno colocado (el 7) y dos descolocados (8 y 6)
Se terminar el programa cuando el jugador acierte la combinacin o haya
agotado sus intentos (constante MAXINTENTOS con valor 10)
121
122
CAPTULO III
Estructura de datos Arrays

Objetivos
* Definir estructuras de datos.
* Definir estructuras de datos tipo listas. Sus aplicaciones.
* Aplicar operaciones con vectores: mtodos de ordenacin, insercin,
eliminacin, bsquedas, crear sublistas, etc. Aplicaciones.
* Definir arrays bidimensionales.
* Definir arrays multidimensionales.
* Cmo se almacena arrays en memoria.
123
3.1 Introduccin
Los tipos de datos escalar (enteros, reales, booleanos, carcter, subrango y
definidos por el usuario) se denominan tipos simples, su justificacin se debe
a que las variables son limitadas a un solo valor cada vez que se procesan y no
existe alternativa de relaciones de alto nivel con otras variables del mismo tipo.
Esta tcnica permite clasificar y almacenar los datos del mundo real en grupos
o conjuntos de datos, pero todos del mismo tipo, es decir; puede almacenar y
procesar solo datos enteros, tales como: notas, pesos, cadenas, etc.
Se confirma que si maneja grandes volmenes de datos con arreglos y despus
de sus procesos (consultas, bsquedas, ordenamientos, etc.) estos se perdern. La
justificacin radica que los arreglos solo se realizan en memoria RAM (memoria
de acceso aleatorio).
La declaracin siguiente:
int a,b;
Se est estableciendo simplemente que a,b son dos variables no relacionadas que
tomarn valores de tipo enteros.
En segundo lugar, los tipos de datos estructurados, son tipos de datos de alto nivel
que se construyen a partir de conjuntos o colecciones de datos de tipo escalar simples
y que contienen algunas relaciones adicionales entre sus diversos elementos.
3.2 Arrays Unidimensionales (vectores)

Un arreglo (array) es un conjunto de datos del mismo tipo, los cuales ocupan
direcciones adyacentes en la memoria cuando el programa se ejecuta, permitiendo
acceder a ellos en forma aleatoria. Es decir; que a cada elemento se puede acceder
mediante un subndice entero nico que lo identifica.
Declaracin de un arreglo de una dimensin

Un array de una dimensin (vector o lista) en C++ se declara de la siguiente
manera:
tipo nombre[tamaol], en donde:
tipo: es el tipo de datos que conforman el array
nombre: es el identificador de todo el array
tamao: indica el mximo nmero de elementos (entero), menos 1, que pueden
almacenarse en el array. La justificacin radica que en todo arreglo en C++ el
primer elemento es cero (0), pero usted puede definir dnde iniciarlo.
Ejemplo: Int notas[20]
declara un array notas con 20 elementos enteros, cada uno de los cuales de
referencia por su subndice (notas[0], notas[1], notas[2]...notas[19])

notas[ 20]
124
[0] [1]
12
11
[2] [3]
09
15
[ 18 ] [ 19 ] ndice
........
11
08
02
12
Elementos individuales del vector y todos del mismo tipo

Para recorrer sus elementos para lectura y/o escritura, se debe usar estructuras
de control, tales como:
for(i=0;i<20;i++), while(i<20), etc.
Inicializacin de un arreglo
1. Se puede inicializar un array con la declaracin:

int a[3] = {2,1,7}

int b[5] = {1,3,6} /*inicializa los tres primeros elementos a 1, 2 y 3, y
los restantes a cero*/
2. Se puede omitir el tamao del array:
float lista[ ] = { 1.0,5.1.10.4} //Declara un array de tres elementos
Funcin de acceso
Permite acceder a un elemento especfico (ndice)
Ejemplo: Notas[2]: indica que estamos apuntando al elemento en el ndice 2.
As, notas[2] = 09
El array nos permite manipular sus elementos individuales como si fueran
cualquier tipo de variable, veamos. Se puede tratar como operandos, asignarles
valores, compararlas con otro valor, etc:
Notas_p[ I ] + notas_e[ j ];
Notas [3] = 15compara[5]<=6.Resto_d[3]%2==0Dato[i]!=.
125
Restriccin:
1. No se puede operar con todo el array directamente. La sentencias:
int valor[200] = { 0 }, int datos[200]; valor = datos;
Esto nos generan un error de sintaxis.
2. En C++ no realiza verificacin de lmites de un array,es decir; no se genera un
error de compilacin cuando se referencia aun elemento inexistente en ste.
3.3 OPERACIONES CON VECTORES

La aplicacin principal de un vector, se basa en las listas.
Lista.- Una lista es una estructura lineal (secuencial) de datos, en la cual sus
elementos se encuentran indexados (referenciados por un ndice), pudiendo
variar en nmero.
Las tareas sobresalientes son:
1. Reporte de elementos de la lista
2. Insertar elementos en alguna posicin de la lista
3. Eliminar elementos
4. Ordenar elementos en forma ascendente o descendente
5. Bsqueda de un elemento
6. Fusin o intercalacin de dos listas
7. Formar sublistas a partir de una lista
APLICACIONES
Problema 1. Disear un programa que permita leer nota y sexo de n alumnos
(n definido por el usuario) y luego generar un reporte que permita conocer la
cantidad de alumnos aprobados de sexo masculino.
Solucin // vector_sexo.cpp
#define max_el 100
# define linea -----------------------------------------------
void main(){ int nota[max_el],n,i;
char sexo[max_el], nap=0;
char op=s;clrscr();
gotoxy(10,2);cout<<Sistema de notas vs Sexo ;gotoxy(2,3);cout<<linea;
while (op==s)
{ gotoxy(2,5);cout<<Ingrese numero de alumnos: ;cin>>n;
for(i=0;i<n;i++)
{gotoxy(2,7+i*2);cout<<Alumno[<<(i+1)<<];
gotoxy(2,8+i*2); cout<<Ingrese nota [<<(i+1)<< ]= ; cin>>nota[i];
gotoxy(30,8+i*2);cout<<Ingrese sexo (M/F) = ; cin>>sexo[i];
}
for(i=0;i<n;i++)
126
if((sexo[i]==M)||(sexo[i]==m))
{ if(nota[i]>10) { gotoxy(2,15+i);
cout<<N[<<(i+1)<<]= <<nota[i]<< sexo[<<(i+1)<< ]= <<sexo[i];
}
Nap++ ;
}
gotoxy(2,19); cout<<Total alumnos aprobados de sexo Masculino :<<nap;
gotoxy(14,21); cout<<Desea continuar..(S/N);cin>>op;
getche();
}
}
Problema 2. Disear un programa que permita leer notas de n alumnos (n definido

por el usuario) y luego generar un reporte que permita concer el promedio de
prcticas.
Solucin //vector_prom.cpp
#define max_n 10
#define linea --------------
void main()
{int notas[max_n], i, n, suma=0;
flota
promedio;
clrscr();
gotoxy(10,2);cout<<Sistema
de
Promedio de practicas ;
do { gotoxy(2,5); cout<< Ingrese
cantidad de alumnos :; cin>>n;
} while (!((n>=1) && (n<=max_n)));
for (i=0; i<n; i++){ gotoxy(2,7+i*2);cout<<Alumno[<<(i+1)<<];
gotoxy(2,8+i*2); cout<<Ingrese nota [<<(i+1)<< ]= ; cin>>notas[i]; }
127
for (i=0; i<n; i++){suma=suma+notas[i]; }

promedio=(float)suma/n;
gotoxy(2,15);cout<< El promedio de practicas es = <<promedio; getch(); }
que permita leer nmeros enteros
y almacenarlo en un vector de
longitud n, luego generar un
reporte de los elementos ordenados
en forma ascendente.
Solucin. // vect_orden.cpp- Se
usar el mtodo de la burbuja, el
cual permite realizar comparaciones sucesivas de sus elementos.
# define max 10
void main(){ int i,j,n,aux,a[max];
clrscr();gotoxy(2,2);
cout<<Ingrese la longitud del vector : ; cin>>n;
gotoxy(2,4);cout<<Ingrese elmentos : <<endl;
for (i=1;i<=n;i++)
{ gotoxy(2,5+i);cout<<A[<<i<<]=;cin>>a[i];}
for (i=1;i<=n-1;i++)
for (j=i+1;j<=n;j++)
if(a[i]>a[j])
{ aux=a[i]; a[i]=a[j]; a[j]=aux;
} // Reporte ordenado de los elementos del vector //
gotoxy(15,9);cout<< Elementos ordenados en forma Ascendente;
for (i=1;i<=n;i++)
{ gotoxy(30,9+i);
cout<<A[<<i<<]=<<a[i]<<endl;
} system(pause);
}
Problema 4. Disear un programa que permita leer nmeros enteros y almacenarlo
en un vector A de longitud n, luego:
a. Generar un reporte de los elementos ordenados en forma ascendente.
b. Almacenar en un vector B los elementos pares del vector A y en un vector C
los elementos impares del vector A. Asimismo, mostrar el mayor elemento del
vector B y el menor elemento del vector C.
c. En un vector M, almacenar el mximo y el mnimo, segn parte b) y luego
solicitar al usuario que ingrese el nmero de elementos a insertar en este
vector. Generar un reporte para conocer los elementos respectivos.
128
Solucin //vectores_max_min.cpp
#include<iostream.h> //defina otras loibrerias
#define max_elem 100
void main()
{ int A[max_elem],k,i,n,j,aux,maxb,minc,B[max_elem],C[max_elem],d=0;
clrscr();
gotoxy(3,3);cout<<Ingrese numero de elementos del vector A: ;cin>>n;
gotoxy(4,5);cout<<Ingrese elementos;
for(i=1;i<=n;i++)
{ gotoxy(5,6+i);cout<<A[<<i<<]= ; cin>>A[i];}
for (i=1;i<=(n-1);i++)
for(j=i+1;j<=n;j++) if(A[i]>A[j]) { aux=A[i]; A[i]=A[j]; A[j]=aux;}
gotoxy(30,7);cout<<El vector ordenado es ;
for (i=1;i<=n;i++)
{gotoxy(35,8+i);cout<<A[<<i<<]=;gotoxy(40,8+i);cout<<A[i]<<endl;}
gotoxy(20,25);cout<<Presione cualquier tecla para continuar...;
getche();clrscr();
for(i=1;i<=n;i++) {if((A[i]%2)==0) {d=d+1; B[d]=A[i]; }
k=d;}
gotoxy(5,4);cout<< Vector B con elementos pares y su maximo :;
for(d=1;d<=k;d++)
{gotoxy(5,5+d);cout<<B[<<d<<]= ,cout<<B[d]<<endl;maxb=B[d];}
for(i=1;i<=n;i++)
{if(((A[i]%2)<0)||((A[i]%2)>0)) /* puede usar !=0*/
{d=d+1; C[d]=A[i];} k=d; }
for(d=1;d<2;d++){minc=C[d];}
gotoxy(40,4);cout<<Vector C con elementos impares:;
for(d=1;d<=k;d++)
{gotoxy(40,5+d);cout<<C[<<d<<]= ,cout<<C[d]<<endl;}
gotoxy(20,25);cout<<Presione cualquier tecla para continuar...;
gotoxy(5,15);cout<<Max de B= <<maxb;
gotoxy(5,16);cout<<Min de C= <<minc;getche();clrscr();
int q,r,r2,q2,M[max_elem],l,x,N[max_elem];gotoxy(3,3);
cout<<Ingrese cantidad de elementos para el vector MaxMin: ;cin>>q;
gotoxy(4,5);cout<<Ingrese elementos:;
for(r=1;r<=q;r++)
{gotoxy(5,6+r);cout<<M[<<r<<]= ;cin>>M[r];}
r=q;M[r+1]=maxb;M[r+2]=minc;q2=r+2;
for(r=1;r<=q2;r++)
for(r2=r+1;r2<=q2;r2++) if(M[r]>M[r2]) {l=M[r];
M[r]=M[r2];
M[r2]=l;}
for(r=1;r<=q2;r++){gotoxy(40,6+r);cout<<M[<<r<<]=;cout<<M[r]<<endl;}
getche();clrscr();x=0;
for(r=1;r<=q2;r++)
if( ((M[r]%2)>0)||((M[r]%2)<0) ){x=x+1; N[x]=M[r];}
for(r=1;r<=q2;r++) if((M[r]%2)==0){x=x+1; N[x]=M[r];}
129
gotoxy(4,2);cout<<El Nuevo vector incluyendo el maximo valor de B y minimo

valor de C es:;
for(x=1;x<=q2;x++)
{gotoxy(5,3+x);cout<<MaxMin[<<x<<]= ;cout<<N[x]<<endl;}getche();}
En las siguientes figuras se ilustra ordenado los nuevos elementos:
Vector M que contiene elementos segn b) y dos elementos nuevos insertados.

Finalmente se obtiene el vector MaxMin
Problema 5. Disear un programa que permita leer nmeros enteros y

almacenarlo en un vector A de longitud n, luego:
a. Generar un reporte del total de elementos eliminados
b. Generara un reporte de los elementos del vector sin repetirse
Solucin // vector_Repetido.cpp
#include<conio.h> // defina otras librerias
# define max 100
void main(){int a[max],n,i,d,j,aux,vser[max],p;clrscr();
gotoxy(2,2);cout<<Ingrese # de elementos del vector A: ;cin>>n;
for (i=1;i<=n;i++) { gotoxy(2,3+i);cout<<a[<<i<<]= ; cin>>a[i];
} //ORDENAMIENTO EN FORMA ASCENDENTE
for (i=1;i<=n-1;i++)
for(j=(i+1);j<=n;j++) if(a[i]>a[j]) { aux=a[i]; a[i]=a[j]; a[j]=aux; } /*inicializando*/
d=1;vser[1]=a[1];
130
for(i=2;i<=n;i++) if(a[i]!= a[i-1])

{ d++; vser[d]=a[i];
}
p=n-d;
gotoxy(2,10);cout<<El # de
elementos eliminados es : <<p;
gotoxy(2,11);
cout<<Elementos que quedan:
<<d;
gotoxy(2,13);
cout<<Vector repeticiones ;
for(i=1;i<=d;i++)
{g otoxy(6,14+i);
cout<<vser[<<i<<]=<<vser[i];
} getche();
}
Problema 6. Disear un programa que permita mostrar el total de caracteres que
se repiten en el vector inicializado:
b[20]={a,b,a,a,b,a,c,d,d,d,c}
Solucin / vect_char1.cpp
void main()
{char
b[10]={a,b,a,a,b,a,c,d,d,d,c};
int n=10, i,j=0,nrep;
char fin=\0,c;
cout<< \nReporte de elementos del vector :<<endl;
for(i=0;i<10;i++)
{ cout<<letra[<<i<<]= <<b[i]<<endl;
}
cout<<\nLos caracteres que se repiten son:;
while (j<n) { i=j+1; c=b[j]; nrep=1;
while (i<n)
{ if ((c==b[i])&&(b[i]!=fin))
{ nrep++; b[i]=fin;
}
i++;
}
if (nrep>1)
{ cout<<\n <<c<< = <<nrep<<
veces,;
}
j++;} getche();
}
131
Problema 7. Disear un programa que permita ingresar caracteres (letras) desde

el teclado. Luego mostrar:
a. El nmero de veces que se repite la letra a.
b. El nmero de veces que se repite la palabra uni
c. Elementos vector sin repetirse.
Solucin // vector_uni_veces.cpp
#define max 200
void main()
{char let[max],vlsrep[max],letra,aux;
intcontA,k,contU,contN,contI,menor,cantL,p,i=0,j;
k=0; contA=0; contU=0; contN=0; contI=0;
gotoxy(3,2); cout<<Finaliza la edicion de caracters al editar . ;
gotoxy(3,3); cout<< Ingreso de letras ;
do { i++ ;
gotoxy(3,3+i);cout << letra << (k+1) << = ; cin >>letra;
let[k]=letra;
if ((let[k]==a)||(let[k]==A))
contA+=1;
switch (letra)
{ case u: case U: contU+=1; break;
case n: case N: contN+=1; break;
case i: case I:
contI+=1; break;
}
k++;
} while (letra!=.) ;
cantL=k-1;
// buscando cuantas veces se repite la palabra UNI
if (contU<contN)
if (contU<contI) menor=contU;
else
menor=contI;
else
if (contN<contI)
menor=contN;
else menor=contI
for (i=0;i<cantL-1;i++)
for (j=i+1;j<cantL;j++)
{ if (let[i]>let[j])
{ aux=let[i];
let[i]=let[j];
let[j]=aux;
}
}
132
p=0;
for (i=0;i<cantL;i++)
{ if (let[i]!=let[i+1])
{ vlsrep[p]=let[i];
p++;
} }
gotoxy(2,12); cout << La letra < a > se repite = << contA << veces << endl;
gotoxy(2,13);cout << La palabra uni se repite = << menor << veces << endl;
gotoxy(2,14);cout << El vector sin letras repetidas es = << endl;
for (i=0;i<p;i++)
{ gotoxy(2,15+i);cout << vlsrep[<<i<< ]= <<vlsrep[i];
}
getche();
}
Problema 8. Disear un programa que permita ingresar nmeros enteros y
almacenarlo en un vector de longitud n (n definido por el usuario), luego mostrar:
Reporte de elementos ingresados.
Opciones en un men para :
a. Insertar elementos al inicio del vector
b. Insertar segn posicin espefificada por usuario
c. Insertar al final, cuando los datos estn ordenados
Solucin //vect_inse.cpp
#define linea -------------------------------
#define max_el 50
void main()
{ int a[max_el], n, i, dato; char opc,resp=S;
while(resp==S || resp==s)
{clrscr();
133
gotoxy(8,2);cout<<Ingrese numero de elementos: ; cin>>n;

for( i=1;i<=n;i++)
{cout<<\tA[<<i<<] = ; cin>>a[i];
}
clrscr();
gotoxy(8,2);cout<< Reporte de datos \n;
for (i=1; i<=n; i++)
{cout<<\tA[<<setw(2)<<i<<]=<<setw(4)<<a[i]<<endl;
} //Comprobamos si queda espacio disponible.
cout<<\nOpciones para Insertar un elemento en vector A <<endl;
if (n==max_el) cout<<\nLista llena, imposible insertar<<endl;
else
{cout<<\n; cout<<\t En una posicion
<<endl;
cout<<\t<f> Al final de la lista <<endl;
cout<<\t<o> Si A esta ordenada <<endl;
cout<<\n\t< Edite Opcion> ==> ;cin>>opc;
cout<<\nIngrese elemento a insertar = ; cin>>dato;
switch (opc) {
case p:case P: int pos; //leer una posicin vlida
do { cout<<\nIngrese posicion = ; cin>>pos;
} while ((pos<0)||(pos>n+1));
//Empujar los elementos desde a[pos] hasta el final
for (i=n;i>=pos;i--)
{ a[i+1]=a[i]; a[pos]=dato; //Copia elemento
n++;
}
cout<<\nReporte del vector con elemento = <<dato<< insertado en posicion
<<pos<<endl;
for (i=1;i<=n;i++)
cout<<\t A[<<i<<]=<<a[i]<<endl; break;
case f:case F:
a[n+1]=dato; n++;
cout<<\nReporte del vector con elementos insertados al final<<endl;
for (i=1;i<=n;i++)
cout<< A[<<i<<]=<<a[i]<<endl;
break;
case o:case O: i =1; //Verificando si dato ingresado es mayor que todos
while((i<=n)&&(a[i]<dato))
{i++; }
//empujar
for (int j=i;j<=n;j++)
{a[j+1]=a[j]; }
a[i] = dato; n++;
cout<<\n\tReporte del vector con elemento insertado<<endl;
for (i=1;i<=n;i++)
cout<< \tA[<<i<<]=<<a[i]<<endl; break;
134
} //Fin de switch
} //Fin de else
gotoxy(25,21);cout<<Desea continuar..? ==>(S/N);cin>>resp;clrscr();
}
if((resp==n) || (resp==N))
{clrscr();gotoxy(30,12); cout<<Gracias por sus consultas ;getche(); exit(0);
}
}
Problema 9. Disear un programa que permita leer n alumnos (n ingresado por
usuario ) y por cada alumno ingrese su prctica, luego generar un reporte que
permita mostrar el promedio de prcticas de los n alumnos.
Solucin //vector_prom.cpp
#include <iostream.h> //defina otras librerias
#define max_n 10
#define linea ----------------------------------------------
void main()
{ int notas[max_n], i, n, suma=0;
float promedio;
gotoxy(10,2);
cout<<Sistema de Promedio de
practicas ;
do { gotoxy(2,5);
cout<< Ingrese cantidad de
alumnos :; cin>>n;
} while (!((n>=1) && (n<=max_n)));
fo r (i=0; i<n; i++)
{ gotoxy(2,7+i*2);cout<<Alumno[
<<(i+1)<<];
gotoxy(2,8+i*2); cout<<Ingrese nota [<<(i+1)<< ]= ; cin>>notas[i];
}
for(i=0; i<n; i++)
{suma=suma+notas[i];
}
promedio=(float)suma/n;
gotoxy(2,15);
cout<< El promedio de practicas es = <<promedio; getch();
}
Problema 10. Disear un programa que permita leer datos de tipo entero y
almacenarlo en un vector, luego generar un reporte sin elementos repetidos.
Solucin //vect_sin_el_rep.cpp
void main ( )
135
{ int a[200], v[200], na, nv, i, j, total;

nv = 1;
cout<<\nEliminando elementos repetidos en un vector : ;
cout<<\nIngrese la longitud de A: ; cin>>na ; cout<<\n;
cout<<\nIngrese elementos <<endl;
for (i=1; i<=na; i++) {
cout<<v[<<i<<]=; cin>>a[i];
total = 0;
for (j=1; j<=nv; j++)
{ if (v[j] != a[i])
{ total++;
}
}
if (total == nv)
{
v[nv] = a[i];
nv++;
} }
cout<<\nEl vector sin elementos repetidos es: \n\n;
for (j=1; j<=(nv-1); j++) {
cout<< v[<<j<<]=<<v[j]<<endl;
}
system(pause);
}
almacenarlo en un vector, luego generar un reporte que permita conocer:
a. Nmero de elementos eliminados (cuando se repiten)
b. Total de elementos que quedan en el vector, despus de a)
c. Reporte ordenado de los elementos del vector despus de ejecutar a)
Solucin // vector_Repetido.cpp
# define max 100
void main(){ int a[max],n,i,d,j,aux,vser[max],p;
clrscr(); gotoxy(2,2);cout<<Ingrese # de elementos del vector A: ; cin>>n;
for (i=1;i<=n;i++){ gotoxy(2,3+i);cout<<a[<<i<<]= ; cin>>a[i];
} //ORDENAMIENTO EN FORMA ASCENDENTE
for (i=1;i<=n-1;i++)
for(j=(i+1);j<=n;j++) if(a[i]>a[j]) {aux=a[i];a[i]=a[j];a[j]=aux;}
d=1;vser[1]=a[1];
for(i=2;i<=n;i++) if(a[i]!= a[i-1]) { d++; vser[d]=a[i]; }
p=n-d;
gotoxy(2,10);
136
cout<<El # de elementos eliminados

es : <<p;
gotoxy(2,11);
cout<<Elementos que quedan:
<<d;
gotoxy(2,13); cout<< Vector sin
elementos repetidos;
for(i=1;i<=d;i++)
{ gotoxy(6,14+i);cout<<vser[<<i<
<]=<<vser[i];
}
getche();
}
almacenarlo en un vector a[ ], luego generar un reporte que permita conocer:
a. Elementos del vector
b. Elementos de un vector b[ ], que contiene nmeros pares e impares positivos
c. Elementos de un vector b[ ], que contiene nmeros pares e impares negativos
d. El nmero positivo mayor
e. El nmero menor negativo
Solucin //vect_copiar.cpp
# define linea -----------------------------------------------------
# define max_el 60
void main(){ int a[max_el],b[max_el],n,x,i,p,c[max_el],max,min;clrscr();
do{ gotoxy(2,2);clreol(); cout<<Ingrese #de elementos (<=100): ; cin>>n;
}while(n<0 || n>50);
for(i=1; i<=n; i++)
{ cout<<A[<<i<<]=;cin>>a[i];} clrscr();
gotoxy(2,2);cout<< Elementos del vector A:;
for(i=1; i<=n; i++)
{ gotoxy(9*i,4);cout<<A[<<i<<]=<<a[i]<<,;}
gotoxy(2,5); cout<<linea<<endl;
p=0;
for(i=1;i<=n; i++)
//(almacenando numeros positivos en B)/
{ if(a[i]>0)
{ p=p+1;
b[p]=a[i];
}
}
gotoxy(2,7);cout<<Vector que contiene numeros positivos pares e impares;
for(i=1; i<=p;i++)
137
{gotoxy(9*i,9); cout<<B[<<i<<]=<<b[i]<<,;
}
x=0;
gotoxy(2,12);
cout<<Vector que contine numeros negativos pares e impares <<endl;
gotoxy(2,13);cout<<linea<<endl;
for(i=1; i<=n; i++)
//(almacenando numeros negativos)/
{ if(a[i]<0)
{ x=x+1;
c[x]=a[i];
} }
for(i=1; i<=x; i++)
{ gotoxy(9*i,14);cout<<C[<<i<<]=<<c[i]<<, ; }
for(i=1; i<=p; i++)
//numero maximo positivo max)
{ max=b[1];
for(i=2; i<=p; i++)

{
if(b[i] > max ) max=b[i];
}
gotoxy(2,17);cout<<El maximo positivo es : <<max<<endl;
}
for(i=1; i<=x; i++)
// numero minimo min
{ min=c[1];
for(i=2; i<=x; i++) { if(c[i] < min )min=c[i]; }
gotoxy(2,19); cout<<El minimo negativo es : <<min<<endl;}getche();
}
En la siguiente figura, se ilustra el reporte de los elementos ingresados en el
vactor A, de longitud 6 y luego los reportes solicitados.
Problema 13. Disear un programa que permita leer datos de tipo entero positivos
y almacenarlo en un vector a[100 ], luego generar un reporte que permita conocer
el factorial de cada elemento del vector a[100].
138
Solucin //vector_fact_el. cpp

#include<iostream.h>//defina otras librerias
void main()
{int a[50],i,n,y,j; long int fact; clrscr();
do
{gotoxy(10,1);cout<< Factorial de Arreglo Unidimensional <<endl;
gotoxy(24,3);clreol();
gotoxy(1,3);cout<<Ingrese # de Elementos:;
cin>>n;
}while(n>100 ||n<=0);
gotoxy(1,5);cout<<Ingrese <<n<< Numeros Enteros:<<endl;
for(i=1;i<=n;i++) { gotoxy(27,6+i);cout<<a[<<i<<]=;cin>>a[i];
}
gotoxy(1,8+n);cout<<Factorial de cada elemento ===> ;
for(i=1;i<=n;i++)
{ fact=1; y=a[i];
for(j=1;j<=y;j++)
{fact=fact*j;
}
gotoxy(30,9+n+i);
cout<<a[<<i<<]= <<fact;
}
getche();
}
Problema 14. Disear un programa que permita leer datos de tipo entero
positivos y almacenarlo en un vector a[ ], luego buscar los elementos mltiplo de
5 y no de 2 y almacenarlo en un vector m[ ], mostrar sus elementos, la suma de
stos, as como su promedio.
Solucin //vect_multiplo.cpp
void main()
{int a[20],i,n,cont,r=0,m[20];
float suma,prom;
clrscr();
do
{gotoxy(10,2);
cout<<Arreglos Unidimensionales
;gotoxy(24,3);clreol();
gotoxy(1,3);
cout<<Ingrese # de
Elementos:;cin>>n;
}while(n>50 ||n<=0); / /lectura
for(i=1;i<=n;i++)
{gotoxy(27,3+i);cout<<a[<<i<<]=;
cin>>a[i];
}
139
suma=0;prom=0;cont=0;
for(i=1;i<=n;i++){ if (a[i]%5==0)
if(a[i]%2!=0)
{ r++;
m[r]=a[i];
suma=suma+a[i];cont=cont+1;
}
}
if(cont<=0)
{gotoxy(2,6);cout<<NO existe elemento que cumpla la condicion;
}
else
{prom=suma/cont; gotoxy(3,9);
cout<< Los elementos Multiplo de 5 y no de 2 son:;
for(i=1;i<=r;i++)
{ gotoxy(10*i,11);cout<<m[<<i<<]=<<m[i]<<,;
}
gotoxy(3,13);cout<<Suma = <<suma;
gotoxy(3,14);cout<<Promedio = <<prom;
}
getche();
}
Problema 15. Disear un programa que permita leer n alumnos, definido por
usuario, luego genere reportes para conocer:
a. Promedio general
b. Promedio de desaprobados
c. Promedio de aprobados
d. Total alumnos con nota 20
Solucin //vect_not_20.cpp
#include<iostream.h> //defina otras librerias
#define max 16
void main(){int i,j=0,k=0,v=0,n;
float nota[max],suma,promg,sumaa,sumad,promd,proma;
gotoxy(2,2);
cout<<Ingrese numero de alumnos; cin>>n;
for(i=1;i<=n;i++)
{cout<<\tNota [<<i<<]=;cin>>nota[i];
}
suma=0;
for(i=1;i<=4;i++){suma=nota[i]+suma;
}
sumad=0; sumaa=0;
for(i=1;i<=4;i++)
140
{if((nota[i]>=0)&&(nota[i]<=10))
{sumad=nota[i]+sumad;
j++;
}
if ((nota[i]>=11)&&(nota[i]<=20))
{sumaa=nota[i]+sumaa;
k++;
}
if(nota[i]==20)
{v++;
}
}
promg=suma/n; promd=sumad/j;
proma=sumaa/k;
gotoxy(4,n*2+2) ; cout<<REPORTES: ;
gotoxy(4,n*2+4); cout<<Promedio general
= <<promg;
gotoxy(4,n*2+5); cout<<Promedio de Desaprobados = <<promd;
gotoxy(4,n*2+6); cout<<Promedio de Aprobados = <<proma;
gotoxy(4,n*2+7); cout<<Total alumnos con nota 20 = <<v;
getche();
}
Problema 16. Disear un programa que permita leer el grado de un polinomio
Pn(x) y luego calcular para un valor x0 en x, el valor de P(x0), en la primera derivada: P(x0) y en la segunda derivada: P(x0).
El polinomio es de la forma : Pn (x) = P0 + P1x + P2x2 + P2x3 +....+ Pnxn
Solucin //vect_Polinomio.cpp
#include<conio.h>
# define max_coef 50
void main( )
{int i,n;float poli[max_coef]={0},x,px=0,dx=0,d2x=0;;
clrscr();
gotoxy(2,2);cout<<Ingrese el grado n del polinomio
gotoxy(2,3);cout<<Ingrese el Valor de la
variable x0 : ; cin>>x;
gotoxy(2,4);cout<<Ingrese el valor de
los coeficientes :<<endl<<endl;;
for(i=0; i<=n; i++)
{cout<<\tP[<<i<<]=;cin>>poli[i];
}
if (x==0) px=poli[0];
else {for(i=0; i<=n; i++)
{px += poli[i]*pow(x,i);
if (n>0) dx += poli[i]*i*pow(x,i-1);
if (n>1) d2x += poli[i]*i*(i-1)*pow(x,i-2);
: ; cin>>n;
141
}
}
cout<<\nRESULTADOS <<endl;
cout<<\n\tEl Valor de P(x<<=<<x<<)= <<px;
cout<<\tEl Valor de P(x<<=<<x<<)= <<dx;
cout<<\tEl Valorde P(x<<=<<x<<)= <<d2x;
getch();
}
Problema 17. Disear un programa que permita leer un nmero entero positivo
y luego retornar su equivalente en letras.
Solucin //vect_palab.cpp
char *Unidad[10]={ cero, uno, dos,tres,cuatro,cinco, seis,
siete, ocho, nueve};
char *Diez[10]={ diez, once, doce, trece, catorce, quince,
dieciseis, diecisiete, dieciocho, diecinueve};
char *Decena[10]={cero,diez,veinte,treinta,cuarenta, cincuenta,
sesenta,setenta,ochenta,noventa};
char *Centena[10]={ cien, ciento, doscientos, trescientos,
cuatrocientos,quinientos, seiscientos, setecientos,
ochocientos, novecientos };
char Millar[] = mil;
void main() { long Num,Aux;
char resp=s;
while (resp==s)
{ clrscr();gotoxy(4,2);cout<<CONVERTIR NUMEROS A PALABRAS;
gotoxy(4,4);cout<<Ingrese un nmero menor que 100000: ;cin>>Num;
if (Num<100000){
cout<<El nmero en letras es: ;
if (Num==0) cout<<Unidad[0];
while (Num>0){
Aux=Num;
if (Num>=1000) Num/=1000;
if (Num>0) {
int a,b,c;
c=Num%10;b=(Num%100c)/10;a=(Num-10*b-c)/100;
if (a>0) if (b==0 && c==0)
cout<<Centena[0]<< ;
else cout<<Centena[a]<< ; //si
100<Num<200
if (b>0)
if (b==1) cout<<Diez[c]<< ; //si 10<Num<20
else cout<<Decena[b]<< ; //si 1<b<10
142
if (c>0) { //imprime las unidades

if (b>1) cout<<y ;
if (b!=1) cout<<Unidad[c]<< ;
}
}
if (Aux>=1000) cout<<Millar<< ;
else break;
Num=Aux%1000;} }
elsecout<<Lo siento, nmero fuera de rango;
getche();
cout<<Deea continuar..?(S/N) >";cin>>resp;
clrscr();
}
}
Problema 18. Usando estructuras de control, disear un programa que permita
leer n alumnos (n>0 y n<=100) por cdigo y nota, respectivamente, los cdigos
estn formados slo por tres dgitos y las notas slo son vlidas de 0...20, inclusive.
Luego genere los siguientes reportes para conocer:
a. Mayor nota
b. Cdigo, posicin y nmero de veces que se repite la mayor nota
c. Secuencia de cdigos y secuencia de notas respectivas (de la mayor)
Anlogamente identificar la menor nota y realice los procesos anteriormente
solicitados para la menor nota.
Ejemplo. Considere los datos de la siguiente tabla:
143
Resultados
Solucin. En la siguiente figura se ilustra la entrada de datos de cuatro alumnos
por cdigo y nota respectivamente. Se valida para que los cdigos deben ser slo
de tres dgitos y las notas comprendidas en el rango 0 al 20
REPORTES DE LA MAYOR y MENOR NOTA. Se observa que la nota mayor
es 16 y esta se repite DOS veces, asignado a los alumnos de cdigos 400 y 200,
ocupando las posiciones 4 y 2, respectivamente; asimismo, se forma la secuencia
de cdigos: 400200 y la secuencia de repeticin de la nota mayor: 1616. Adems,
para la nota menor, tal como se observa en la grfica de identificacin de menor
nota.
//vectorNOtasCod_parc_01.cpp
# include <iostream.h >
#define linea _____________________
void main()
144
{ int cod[10],nota[10],n,i,max,ubica=0,cont=0,j,codi,pos;
int conts=0,ubicas=0,codis,poss,min;
long int codigos=0,codigosm=0;
gotoxy(4,2);
cout<<SISTEMA DE IDENTIFICACION DE MAYOR Y MENOR NOTA ;
for (i=1;i<=60;i++)
{gotoxy(2+i,4);cout<<;gotoxy(2+i,16);cout<<;
}
do
{gotoxy(5,6);clreol();cout<< Ingrese numero de alumnos = ;cin>>n;
}while(n<=0||n>100);
for(i=1;i<=n;i++)
{gotoxy(6,8);cout<<Ingrese Codigo de :;gotoxy(4,9);cout<<linea;
do
{gotoxy(5,10+i);clreol();cout<< Alumno <<i<< .- ;cin>>cod[i];
}while(cod[i]<100||cod[i]>999); }
for(i=1;i<=n;i++)
{gotoxy(34,8);cout<<Ingrese notas de : ;
do
{gotoxy(36,10+i);clreol();
cout<< Alumno <<i<< .- ;cin>>nota[i];
}while(nota[i]<0||nota[i]>20);
}
max=0;
for(i=1;i<=n;i++)
{if(nota[i]>=max)
max=nota[i];
}
for(i=1;i<=n;i++)
{if(nota[i]==max)
{codigos=codigos*1000+cod[i];
ubica=ubica*10+i;
cont++;
} }
clrscr();
gotoxy(3,1);cout<<Listado de Codigos y Posicion de la Nota Mayor ;
for (i=1;i<=43;i++)
{gotoxy(2+i,3);cout<<; gotoxy(2+i,7);cout<<;
gotoxy(2+i,9+cont);cout<<;
}
for (i=1;i<=9;i++)
{gotoxy(3,2+i);cout<<; gotoxy(45,2+i);cout<<; }
gotoxy(7,4);cout<< Nota Mayor = <<max;
gotoxy(25,4);cout<< Total = <<cont;
gotoxy(5,6);cout<< Codigo; gotoxy(25,6);cout<< Posicion;
145
for(j=1;j<=cont;j++)
{codi=codigos%1000;
codigos=codigos/1000;
pos=ubica%10;
ubica=ubica/10;
gotoxy(9,7+j);cout<<codi; gotoxy(29,7+j);cout<<pos;
gotoxy(23,7+j);cout<<;
gotoxy(5,20);cout<< Secuencia de Codigos = ;
gotoxy(5,21);cout<< Secuencia de Notas = ;
gotoxy(25+(4*j),20);cout<<codi; gotoxy(25+(4*j),21);cout<<max; }
getche(); clrscr();
min=999;
for(i=1;i<=n;i++) {if(min>=nota[i]) min=nota[i];}
for(i=1;i<=n;i++) {if(min==nota[i])
{codigosm=codigosm*1000+cod[i]; ubicas=ubicas*10+i; conts++;
}
}
gotoxy(3,1);cout<<Listado de Codigos y Posicion de la Nota Menor;
for (i=1;i<=43;i++)
gotoxy(2+i,9+cont);cout<<;
}
for (i=1;i<=9;i++)
{gotoxy(3,2+i);cout<<; gotoxy(45,2+i);cout<<;
}
gotoxy(7,4);cout<< Menor nota = <<min;
gotoxy(25,4);cout<< Total = <<conts;
gotoxy(5,6);cout<< Codigo; gotoxy(25,6);cout<< Posicion;
gotoxy(25,6);cout<< Posicion;
for(j=1;j<=conts;j++)
{codis=codigosm%1000;
codigosm=codigosm/1000;
poss=ubicas%10;ubicas=ubicas/10;
gotoxy(9,7+j);cout<<codis; gotoxy(29,7+j);cout<<poss;
gotoxy(23,7+j);cout<<;
gotoxy(5,20);cout<< Secuencia de Codigos = ;
gotoxy(5,21);cout<< Secuencia de notas = ;
gotoxy(25+(4*j),20);cout<<codis; gotoxy(25+(4*j),21);
cout<<min;
}
getche();
}
Problema 19. Disear un programa que permita leer, para un grupo de productos,
la siguiente informacin: cdigo, tipo de producto (una letra) y el nmero de
146
unidades. Sabiendo que algunos productos se pueden repetir (el mismo cdigo y
tipo de producto) se pide:
a. Mostrar un listado de los productos (sin repeticin) donde figure cdigo, tipo
de producto y el total de unidades (considere la suma de todas las unidades
del producto que se repite).
b. Indicar qu tipo(s) de producto(s) tiene(n) el mayor nmero de unidades.
Solucin
Diseo del mdulo de ingreso de productos por cdigo, tipo (letra) y cantidad de
productos. Debe validar que el cdigo solo acepte tres dgitos, la letra corresponde
a la abreviatura de un producto (A: arroz, F: fideos, etc.) y la cantidad es ilimitada,
solo depende de la longitud del tipo de dato especificado por el usuario.
Como se observa, durante el ingreso se repite el producto de cdigo 100 y tipo
A (arroz), entonces en el reporte final NO debe mostrarse repetido este cdigo,
pero si debe mostrar la suma acumulada (1200+800) del producto de tipo A, tal
como se ilustra en la siguiente figura:
Solucin//vector_prod_may_parcial_03
# include<iostrema.h>
#define linea _____________________________________________
int n, i, j, k, aux, temporal, mayor; codigo[100], unidades[100];
char tipo[100], codigoProd[1], aux2[1], maximo[1], resp=s;
void main (){gotoxy(6,2);
cout<< SISTEMA LOGISTICO PARA REGISTRAR PRODUCTOS ;
147
for (i=1;i<=60;i++)
}
while(resp==s) { do
{ gotoxy(5,4);cout<< Ingrese numero de productos [1..10]= ;cin >> n;
}while (n<1 || n>100);

// Ingreso de productos por cdigos, tipo y cantidad
for (i=1; i<=n; i++)
{ cout<<endl<<endl;
cout<<\tIngrese codigo del producto
<<i<<= ;cin>>codigo[i];
//gotoxy(6,7 Valido que el tipo sea de una sola letra
do
{ cout<<\tIngrese tipo de producto (Letra)
<<i<<= ;gets(codigoProd);
} while (strlen(codigoProd)>1);
// Se Agrego el caracter del Tipo de Producto a la variable Tipo
strcat(tipo,codigoProd);
cout <<\tIngrese total de unidades de producto <<i<<= ;cin>>unidades[i];
}
cout << endl;
// Ordenamos de mayor a menor segn Cdigo
for (i=1; i<=n-1; i++)
{for (j=i+1; j<=n; j++)
{if (codigo[i]<codigo[j])
{ aux=codigo[i];
codigo[i]=codigo[j];
codigo[j]=aux;
aux2[1]=tipo[i-1]; tipo[i-1]=tipo[j-1];tipo[j-1]=aux2[1];
aux=unidades[i]; unidades[i]=unidades[j]; unidades[j]=aux;
}
} }
cout << endl; cout << endl;
gotoxy(2+t,22);cout<<; // fin de marco que se genera bajo el for (*)
}
// ver tipo de producto que tiene mayor cantidad y ordenar primero por tipo
for (i=1; i<=n-1; i++)
{for (j=i+1; j<=n; j++)
{if (tipo[i-1]<tipo[j-1])
{ aux=codigo[i];
codigo[i]=codigo[j];
codigo[j]=aux;
aux2[1]=tipo[i-1];
tipo[i-1]=tipo[j-1];
tipo[j-1]=aux2[1];
aux=unidades[i];
unidades[i]=unidades[j]; unidades[j]=aux;
}
} }
// se suma por tipos, seleccionar cual es el mayor y hacer un reporte
i=1; j=1;
mayor=0;
148
do
{ if (tipo[i-1]==tipo[i+j-1])
{temporal=unidades[i];
do
{temporal=temporal+unidades[i+j];
j++;
}
while (tipo[i-1]==tipo[i+j-1]) ;
if (temporal>mayor)
{ mayor=temporal;
maximo[1]=tipo[i-1];
}

i=i+j;
j=1;
}
else
{ if (unidades[i]>mayor)
{ mayor=unidades[i];
maximo[1]=tipo[i-1];
}
i++;
}
} while (i<=n);
cout << endl;
gotoxy(10,16);cout << Tipo de Producto con MAYORES unidades ;
cout << endl; cout << endl; cout << Producto de tipo << maximo[1];
cout << tiene mayores cantidad y suma = << mayor;
cout << endl; cout << endl;
gotoxy(30, 23);cout<<Sr. desea continuar...? (S/N)==>; cin>>resp;
}
}
3.4 Arrays Bidimensionales

Definicin. Un array bidimensional
es una estructura denominada matriz
de orden mn, considerado como
conjunto rectangular de elementos aij
dispuestos en m lneas horizontales
(filas) y n verticales (columnas) de la
forma:
En la prctica, se expresa en la forma
A =(aij), donde i =1, 2, ..., n, =1, 2, ..., m.
149
Los subndices indican la posicin del elemento dentro de la matriz, el primero

denota la fila (i) y el segundo la columna (j). Esta figura representa una matriz o
arreglo bidimensional de orden n*m, donde en cada celda se asigna un dato, el
cual puede ser entero, real, carcter, etc.
Sintaxis
Constantes: max_f 100, max_c 100
Tipo nombre_mat [ max_f ] [ max_c ]
Donde:
1. Tipo es el tipo de datos que guarda la matriz.
2. nombre_mat es el identificador de la matriz.
3. max_f : cantidad mxima de elementos en las filas
max_c : cantidad mxima de elementos en las columnas.
Observaciones
1. Como todo ndice de arreglos en C++ inicia en 0, entonces el nmero de elementos de arreglo bidimensional (puede generalizar para multidimensionales) queda denotado por (max_f +1) (max_c+1).
2. En general, se pude declarar arreglos multidimensionales, dependiendo del
tipo de aplicacin que usted desea resolver. Si fuera de orden 3, tendramos un
arreglo de la siguiente forma:
Tipo Nombre [max_x][max_y][max_z]

Ejemplo 1. En C++, declare una matriz de nombre lista de 50 filas y 40 columnas
que almacene datos de tipo entero.
# define max_f 50
# define max_c 40
150
void main()
{ int lista[ max_f ] [ max_c ]
<instrs>;
}
Ejemplo 2. Inicializar los valores de una matriz para declarar una matriz lista de
5 x 3 elementos enteros.

int Lista [ 4 ] [ 2 ] = { { 4, 3, 3 },

{ 5, 4, 7 },

{ 7, 7, 7 },

{ 8, 4, 9 },

{ 9, 2, 5 }
}
Esta inicializacion, es equivalente a mostrarlo en la siguiente tabla.
Acceso a los elementos. Cada elemento de la matriz debe referenciarse
mediante sus ndices (subndices)
As,
Lista[ 3 ] [ 2 ] = 9
Lista[ 1 ] [ 1 ] = 4
Lista[ 4 ] [ 4 ] = 5
Aplicaciones
Los arreglos bidimensionales son utilizados ampliamente para problemas del
mundo real, tales como: control de productos en almacenes, distribuciones,
evaluciones, etc.
Problema 1. Una empresa importadora de vehculos tiene distribuido tres tipos de vehculos
en tres almacenes diferentes, tal
como se ilustra en la siguiente
figura:
Disear un programa que permita leer el nmero de tipos
de vehculos y el nmero de
almacenes (puede usted generalizar para n filas y m columnas), luego generar
reportes para conocer:
151
a. Total de vehculos por tipo

b. Total de vehculos en cada almacn
c. Total de vehculos de la empresa
Solucin //almacen.cpp
# define max_vehic 100// 100 vehiculos como maximo
# define max_almac 200 // 200 almacenes como maximo
void main()
{int almacen[max_vehic][max_almac],i,j,x=5,y=10,m,n;
float suma=0,tv=0; clrscr(); //leer datos
gotoxy(15,1);cout<<Compania Importadora de Autos ;
gotoxy(15,2);cout<<------------------------;
do{ gotoxy(1,3);cout<< Ingese total de Vehiculos: ; cin>>m;
gotoxy(1,4);cout<< Ingrese total de Almacen: ; cin>>n;
}while(m<=0 || m>=10 && n<=0 || n>=10);
gotoxy(1,5);cout<<Ingrese vehiculos :;
for(i=1;i<=m;i++)
for(j=1;j<=n;j++)
{ gotoxy(19+y*j,x+i*2);cout<<al[<<i<<,<<j<<]=;
gotoxy(27+y*j,x+i*2);cin>>almacen[i][j];
}//Suma tipos de vehiculos ( filas)
cout<<\nTotal de Vehiculos por tipo<<endl;
for(i=1;i<=m;i++)
for(j=1;j<=n;j++) { suma=suma+almacen[i][j];
if(j==n)
{ cout<<Tipo <<i<<.-<<suma<< vehiculos<<endl; suma=0;
}
tv=tv+almacen[i][j];
}//Sumando vehiculos por almacen (Columnas)
suma=0;
152
cout<<\nTotal por Almacen:<<endl;

for(j=1;j<=n;j++)
for(i=1;i<=m;i++) { suma=suma+almacen[i][j];
if(i==n) { cout<<almacen <<j<< = <<suma<< vehiculos<<endl;
}
} //total
cout<<\nTotal de Vehiculos de la empresa :<<tv<<endl; getch();}
suma=0;
Problema 2. (Anlogo al problema 1), con la diferencia que presenta la fecha del
sistema en pantalla y se pide, adems, los siguientes reportes para:
a. Total de vehculos, por tipo, distribuidos en los almacenes
b. Total de vehculos por cada almacn
c. Cantidad mayor de vehculos, por tipo, en uno de los almacenes
d. Crear un vector cant_por_al[ ], que permita copiar los resultados segn b)
e. Crear un vector cant_tip[ ] que permita copiar los resultados segn a)
f. Usando los vectores segn d) y e), copiar en un vector sump[ ] la suma de sus
elementos
g. Crear vectores: par[] e impar[ ], donde vector par[ ] almacena los elementos
pares y vector impar[], almacenar los elementos impares segn vector sump[]
de parte f)
Solucin //matriz_alm_2004.cpp
# define maxf 10
# define maxc 10
void main(){ time_t tiemp;time(&tiemp);int t,n,m,i,j,mayor,k,p, sump[maxf];
float a[maxf][maxc],cant_por_al[maxf],cant_tip[maxc],par[maxf],imp[maxf];
float totaltipos,totalalmac; int q=1, s=1,, x=5, y=10;
gotoxy(6,2);cout<<EMPRESA VENDEX S.A.:;
gotoxy(30,2);printf( Fecha de Consultas: %s\n,ctime(&tiemp));
for(i=1;i<=77;i++)
{ gotoxy(i+1,3);cout<<_; //ASCII :alt +95}
gotoxy(3,4);cout<<ingrese total de tipos :;cin>>n;
gotoxy(3,5);cout<<ingrese total de almacenes :;cin>>m;
for(i=1;i<=m;i++)
for(j=1;j<=n;j++)
{ gotoxy(19+y*j,x+i*2);cout<<al[<<i<<,<<j<<]=;
gotoxy(27+y*j,x+i*2);cin>>a[i][j];
} /*calculando por tipos */
cout<<Total por tipo de vehiculos :<<endl;;
for (i=1; i<=n;i++){ totaltipos=0;
for (j=1; j<=m;j++)
{totaltipos=totaltipos+a[i][j];
}
153
cout<<Total de tipo [<<i<<]= <<totaltipos<<endl;

} /*Total por almacenes */
cout<<Total por almacenes : <<endl;
for (j=1; j<=m;j++) { totalalmac=0;
for (i=1; i<=n;i++)
{totalalmac+=a[i][j];
}
cout<<Total en almacen: [<<j<< ]=<<totalalmac<<endl;
} /* Buscando el mayor elemento en el almacen */
mayor=a[1][1];
for(i=1;i<=n;i++)
{ for(j=1;j<=m;j++)
{ if(a[i][j]>mayor)
mayor=a[i][j];
} }
cout<< La mayor cantidad de vehiculos es: <<mayor<<endl; cout<<;
cout<<\nCreando el vector cant_por_al[max] y mostrando sus elementos:
<<endl;
k=1;
for(j=1;j<=m;j++)
{ totalalmac=0;
for(i=1;i<=n;i++)
{ totalalmac+=a[i][j];
}
cant_por_al[k]=totalalmac; k=k+1;
}
for(i=1;i<=k-1;i++) cout<<cant_por_al[<<i<<] = <<cant_por_al[i]<<endl;
cout<<; getche(); clrscr();
t=1;
for(i=1;i<=n;i++)
{ totaltipos=0;

for(j=1;j<=m;j++)
{ totaltipos+=a[i][j];
}
cant_tip[t]=totaltipos;
t=t+1;
}
cout<<\n Creando el vector cant_tip[max] y mostrando sus elementos: <<endl;
for(i=1;i<=t-1;i++)
cout<<cant_tip[<<(i+1)<<]= <<cant_tip[i]<<endl;
cout<<\nSumando vectores cant_por_al[]+cant_tip[] y el resultado copiar en
sump[]<<endl;
p=1;
for(i=1;i<=n;i++)
{sump[p]=cant_por_al[i]+cant_tip[i];
p++;
}
154
cout<<\n Elementos del vector sump[]<<endl;

for(i=1;i<=p-1;i++) { cout<<sump[<<(i)<<]= <<sump[i]<<endl;
}
cout<<\nCopiando elementos pares de sump[] en un vector par[] e impares en
imp[]: <<endl;
for (p=1;p<=n;p++)
{ if(sump[p]%2==0)
{par[q]=sump[p];
q=q+1;
}
else
{ imp[s]=sump[p]; s++;
}
}
cout<<\nElementos del vector Par[] :<<endl ;
for(i=1; i<=q-1;i++)
cout<<par[<<i<<]= <<par[i]<<endl;
cout<<\nElementos del vector impar :<<endl;
for(j=1; j<=s-1;j++) cout<<impar[<<j<<]= <<imp[j]<<endl;system(pause);
}
Problema 3. Disear un programa que permita leer n alumnos por apellidos
ytres notas por cada uno, luego genere reportes para conocer apellidos, promedio
y estado (aprobado, desaprobado). El promedio se calcula eliminando la menor
nota por alumno; asimismo, muestre el alumno que pertenece al tercio superior.
Solucin //matriz_notas.cpp
#define maxf 50#define maxc 50
void main() { char nom[maxf][maxc],temp[maxf];
float temp1, notas[maxf][3], prom[maxf], min[maxf];
int i,j,n;clrscr();
gotoxy(8,2);cout<<RELACION DE ALUMNOS Y RESPECTIVAS NOTAS;
gotoxy(6,3); cout<<___________________________________<<endl;
gotoxy(2,5);cout<<Ingrese Nro de alumnos: ; cin>>n;
for(i=1;i<=n;i++) {
gotoxy(2,6+i);cout<<endl<<Alumno
<<[<<i<<=]<<endl;
gotoxy(2,8+i);cout<<Apellidos :;cin>>nom[i];
cout<< Ingrese sus 3 notas: <<endl;
for(j=1;j<=3;j++)
{gotoxy(8,10+j);clreol(); cout<<nota[<<j<<]=;cin>>notas[i][j];
}
clrscr();
}
//Calculo de promedios
for(i=1;i<=n;i++)
155
{ prom[i]=0; min[i]=20;
}
for(i=1;i<=n;i++)
for(j=1;j<=3;j++)
{if (notas[i][j]<min[i])
min[i]=notas[i][j]; prom[i]+=notas[i][j];
}
for(i=1;i<=n;i++) {prom[i]-=min[i]; prom[i]/=2;
} //Ordenar la tabla descendentemente con respecto al promedio
for(i=1;i<=n-1;i++)
for(j=1;j<=n-i;j++)if (prom[j]<prom[j+1])
{
temp1=prom[j]; strcpy(temp,nom[j]);

prom[j]=prom[j+1]; strcpy(nom[j],nom[j+1]);

prom[j+1]=temp1; strcpy(nom[j+1],temp);
}
cout<<\n;
cout<<\t\tREPORTE DE ALUMNOS <<endl; cout<<\n;
cout<< Apellidos
Promedios
Estado<<endl;
for (i=1;i<=79;i++) cout<<;
for (i=1;i<=80;i++) cout<<_;
for (i=1;i<=n;i++) {cout<<i<<.-<<setw(10)<<nom[i]; //Nombres
cout<<setiosflags(ios::showpoint+ios::right);
cout<<setw(22)<<setprecision(2)<<prom[i]<<\t; //Promedios
if (prom[i]>=10) cout<< Aprobado;
else cout<< Desaprobado;cout<<endl;
}
for (i=1;i<=75;i++) cout<<_;cout<<\nPertenecen al Tercio Superior: <<endl;
if (n<3) cout<<alumno <<nom[1]<<endl;
else {for(i=1;i<=n/3;i++) cout<<alumno <<nom[i]<<endl; }
system(pause);}
1. Interface para ingreso de alumnos y sus tres notas
156
2. Reportes
Problema 4. Disear un programa que permita leer informacin de una empresa

por d departamentos s secciones y o obreros, por cada obrero debe
leer sueldo, luego generar un reporte para conocer el sueldo promedio de los
trabajadores de un departamento d y seccin s, ingresado por el usuario.
Solucin //matriz_obreros
#include<iostream,h>
#define max 10
void main(){int empresa[max][max][max],d,s,o,dep,sec,i,j,k;
char aux; float ac,prom;
do{
cout<<Ingrese numero de departamentos (menor que 10): ;cin>>d;
}while(d>10);
do{ cout<<Ingrese numero de secciones por departamento ;cin>>s;
}while(s>10);
do{ cout<<Ingrese numero de obreros por seccion (menor que 10): ;cin>>o;
}while(s>10);
for(i=0;i<d;i++)
for(j=0;j<s;j++)
{cout<<Para el departamento <<(i+1)<< seccion <<(j+1)<< : <<endl;
for(k=0;k<o;k++)
{cout<<Ingrese el sueldo del <<(k+1)<< obrero: ;cin>>empresa[i][j][k];
}
}
clrscr();
cout<<Ingrese departamento que desea conocer el promedio: ;cin>>dep;
do{cout<<Desea conocer el promedio de todo el departamento o de alguna
seccion en especial [Todo] [Especial]? ;cin>>aux;
}while(aux!=t && aux!=e && aux!=E && aux!=T);
ac=0;
if(aux==e || aux==E)
{cout<<\nIngrese la seccion de la cual desea conocer el promedio: ;cin>>sec;
157
for(i=0;i<o;i++)
{ac+=empresa[(dep-1)][(sec-1)][i];
}
cout<<ac;
prom=ac/o; clrscr();
cout<<El promedio del departamento y seccion es: <<prom;
}
else
{for(i=0;i<s;i++)
{for(j=0;j<o;j++)
ac+=empresa[(dep-1)][i][j];
}
prom=ac/(o*s);
clrscr();
cout<<El promedio del departamento es: <<prom;
}
getche();
}
Problema 5. Disear un programa que permita ingresar nmeros enteros en una

matriz cuadrada de orden n*m (n y m son ingresados por el usuario), luego se
pide mostrar:
a. La suma diagonal principal
b. La suma de la fila ingresada por el usuario
c. La suma de la columna ingresada por el usuario
d. La matriz ordenada por columnas
Solucin /* matrices_ord.cpp */
void main()
158
{ long a[10][10],n,m,i,j,k,aux; int suma=0, suma1=0,suma2=0; long s[10];

clrscr(); cout<<\ningrese el numero de filas: ;cin>>n;
cout<<\ningrese el numero de columnas: ;cin>>m;
int x=5,y=10;
for(i=1; i<=n;i++)
{ for(j=1;j<=m;j++) {gotoxy(19+y*j,x+i*2);cout<<al[<<i<<,<<j<<]=;
gotoxy(27+y*j,x+i*2);cin>>a[i][j];
}
}
for(i=1; i<=n;i++)
{ for(j=1;j<=m;j++)
{ if(i==j)
suma=suma+a[i][j];
} }
cout<<\nLa suma diagonals: ; cout<<suma;s[1]=0; getche();
for(i=1;i<=n;i++){
for(j=1;j<=m;j++)
{ s[i]=s[i]+a[i][j];
}
}
cout<<\nIngrese el numero de fila: ; cin>>i;
for(j=1; j<=n;j++)
{ suma1=suma1+a[i][j];
}
cout<<\nLa suma de la fila es: <<suma1<<endl;
cout<<\nIngrese el numero de columna: ; cin>>j;
for(i=1; i<=m;i++)
{ suma2=suma2+a[i][j];
}
cout<<\nLa suma de la columna es: <<suma2<<endl; getche(); clrscr();
gotoxy(8,4);cout<<\nMatriz ordenada pero mostrado por columnas <<endl;
for(i=1;i<=n;i++)
for(j=1;j<=m-1;j++) //ordenado filas en forma descendente
{for(k=j+1;k<=m;k++)
if (a[i][j]<i][k]) {aux=a[i][j]; a[i][j]=a[i][k]; a[i][k]=aux;
}
}
for (i=1;i<=n;i++)
for (j=1;j<=m;j++) { gotoxy(19+y*j,x+i*2); gotoxy(12+y*j,x+i*2);cout<<a[i][j];
}
getche();
}
Ingreso de datos y reporte de la matriz, ordenada por filas y en forma
descendente:
159
Problema 6. Disear un programa para que una matriz, primero, permita ingresar
el nmero de tipo de productos (en este caso arroz y fideos), luego ingresar
el nmero de distritos (en nuestro caso 2: Lima y Lince). A continuacin debe
ingresar las cantidades de productos por tipos en los distritos. Luego se pide:
a. Calcular en forma automtica el total de productos por tipos, distritos y total
de productos ingresados a la matriz.
b. Mostrar en la matriz ordenada en forma ascendente los productos por tipos de
productos.
c. Mostrar en la matriz ordenada en forma ascendente los productos por distritos.
Solucin //mat_EXAMEN2.cpp
#include<conio.h>
#define maxf 50 #define maxcol 50
int a[maxf][maxcol],ordt[maxf][maxcol],ordd[maxf][maxcol];
char nomt[10][10];char nomd[10][10];
int n,i,m,j,tpf[maxcol],tpd[maxf],tot, temp, x,v,k,d,o;
void main(){clrscr(); cout<< ingrese # numero de tipos ;cin>>n;
cout<< ingrese nombre de tipo <<endl;
for(i=0;i<n;i++)
{cout<<t[<<(i+1)<<]=
;cin>>nomt[i];
}
cout<<\nIngrese #numero de distritos ;cin>>m;
cout<< ingrese nombre de distrito <<endl;
for(i=0;i<m;i++)
{cout<<d[<<(i+1)<<]=;cin>>nomd[i];
}
clrscr();
gotoxy(30,2);cout<< ingrese datos de la matriz<<endl;
for(i=0;i<n;i++)
{gotoxy(15+10*i,4);cout<<nomt[i];
160
}
for(i=0;i<m;i++) {gotoxy(3,5+i);cout<<nomd[i]; } //lectura de datos en la matriz
for(i=0;i<n;i++)
for(j=0; j<m;j++)
{ gotoxy(15+10*i,5+j);cin>>a[i][j];
} //calculando por tipos
for(i = 0;i<n;i++)
for(j=0;j<m;j++)
{ tpf[i]=tpf[i]+a[i][j];
}
for(i=0;i<n;i++)
{ gotoxy(15+10*i,6+m);cout<<tpf[i];
}
getche();
for(j=0;j<m;j++)

for(i=0;i<n;i++)
{ tpd[j]=tpd[j]+a[i][j];
}
for(i=0;i<n;i++)
{ gotoxy(15+10*n,5+i);cout<<tpd[i];
}
for(j=0;j<m;j++)
{tot = tot + tpd[j];
}
gotoxy(15+10*n,6+m);cout<<tot; getch();
//proceso de ordenacion;
for(i = 0;i<n;i++)
{ for(j=0;j<m;j++){ ordt[i][j]=ordd[i][j]=a[i][j];
}
}
temp=0;
//ordenando
for(k=0;k<n;k++)
{for(i=0;i<m;i++)
{ for(j=i;j<m;j++)
if( ordt[k][i]>=ordt[k][j] )

{ temp=ordt[k][j]; ordt[k][j]=ordt[k][i];
ordt[k][i]=temp;
}
}
}
//ord vertical
for(k=0;k<m;k++)
{for(j=0;j<n;j++)
{ for(i=j;i<n;i++)
if (ordd[j][k] >= ordd[i][k])
{temp=ordd[j][k];
ordd[j][k]=ordd[i][k];
ordd[i][k]=temp;
161
}
}
}
clrscr();gotoxy(20,2);cout<<proceso de ordenacion por tipos de la matriz;
for(i=0;i<n;i++) {gotoxy(15+10*i,4);cout<<nomt[i]; }
for(i=0;i<n;i++)
{ for(j=0; j<m;j++) {gotoxy(15+10*i,5+j);cout<<ordt[i][j];
}
}getch();
clrscr();
gotoxy(20,2);cout<<proceso de ordenacion por distritos de la matriz;
for(i=0;i<m;i++)
{gotoxy(3,5+i);
cout<<nomd[i];
}
for(i=0;i<n;i++)
for(j=0; j<m;j++)
{ gotoxy(15+10*i,5+j);
cout<<ordd[i][j];
}
getch();
int
x=a[0][0];
for(i=0;i<n;i++)
for(j=0;j<m;j++)
if (a[i][j]>x) { x=a[i][j];
}
cout<<\nLa mayor cantidad ingresada es = <<x;getche(); }
Despus de ingresar datos, debe presionar ENTER para mostrar en forma
automtica los clculos del total por tipos y por distritos.
Luego presione ENTER, para mostrar las cantidades de matriz, ordenados en
forma ascendente por tipos de productos.
Luego presione ENTER para mostrar las cantidades de matriz, ordenados en

forma ascendente por distritos, as como la mayor cantidad dentro de la matriz.
162
Problema 7. Disear un programa que permita leer el nmero de filas y el nmero

de columnas de longitud mximo 10 y luego almacenar en una matriz datos de
tipo entero tales que permitan:
a. Mostrar la suma total de los datos de la matriz.
b. Calcular el promedio de los datos de la matriz.
c. Mostrar los datos de las filas pares y columnas impares.
Solucin // matriz_bid.cpp
void main(){ int z[10][10],i,j,m,n, x=6; y=11; suma=0;float suma,prom;
clrscr(); gotoxy(15,1);cout<<Arreglo Bidimensional ;
gotoxy(15,2);cout<<--------------------------;
do{
gotoxy(1,3);cout<<Ingrese numero de Filas : ; cin>>m;
gotoxy(1,4);cout<<Ingrese numero de Colunnas : ; cin>>n;
}while(m<=0 || m>=10 && n<=0 || n>=10);
gotoxy(1,5);cout<<Ingrese datos a la matriz:;
for(i=1;i<=m;i++)
for(j=1;j<=n;j++)
{ gotoxy(18+y*j,x+i*2);cout<<A[<<i<<,<<j<<]=;
gotoxy(26+y*j,x+i*2);cin>>z[i][j];suma=suma+z[i][j];
}
prom=suma/(m*n);
gotoxy(1,9+n+i);cout<< La Suma de los elementos es ==> <<suma;
gotoxy(1,7+n+i);cout<< El Promedio de los elementos es ==><<prom;
gotoxy(1,12+n+i);
cout<<Valores de fila(s) PAR(s), columna(s) IMPAR(s) :<<endl;
for(i=1;i<=m;i++)
for(j=1;j<=n;j++){ if (i%2==0)
if (j%2==1) cout<<z[i][j]<<endl;}getch(); }
163
Salida
Problema 8. Disear un programa que permita leer el nmero de filas y el nmero

de columnas de longitud mximo 10 y luego almacenar en una matriz cuadrada
datos de tipo entero, tales que permitan: mostrar la suma total de la diagonal
principal y de la diagonal secundaria.
Solucin //mat_diag.cpp
void main(){int z[10][10],i,x=6,y=11,j,m,n;float suma,suma1;
clrscr();gotoxy(15,1);cout<<Arreglo Bidimensional ;
gotoxy(15,2);cout<<-----------------------;
do{ gotoxy(3,3);cout<<Ingrese numero de filas :; cin>>m;
gotoxy(3,4);cout<<Ingrese numero de columnas :; cin>>n;
} while(m<=0 || m>=10 && n<=0 || n>=10);
if
(m==n)
{gotoxy(4,5);cout<<Ingrese
valores:;
for(i=1;i<=m;i++)
for(j=1;j<=n;j++)
{ gotoxy(18+y*j,x+i*2);
cout<<A[<<i<<,<<j<<]=;
gotoxy(26+y*j,x+i*2);cin>>z[i]
[j];
} //diagonal principal
suma=0;
for(i=1;i<=m;i++)
for(j=1;j<=n;j++)
{if(i==j)
{ suma=suma+z[i][j];
}
}
cout<<\nla suma de la diagonal principal es: <<suma<<endl;
164
suma1=0;
for(i=1;i<=m;i++)
for(j=1;j<=n;j++)
{ if(i+j==n+1)
{ suma1=suma1+z[i][j];
}
}
cout<<\nla suma de la diagonal secundaria es: <<suma1<<endl;
}
else cout<<la matriz no es cuadrada;getch();}
Problema 9. Disear un programa que permita ingresar nmeros enteros en una
matriz de orden 3*3, luego mostrarlo en forma ordenada por filas (las filas debe
ir ordenndose en forma secuencial y ascendente).
Solucin //mat_ord_fil.cpp
void main()
{ int A[3][3], min,j,i; clrscr();
cout<<Ingrese elementos de una matriz 3x3: <<endl;
for(i=0;i<3;i++)
for(j=0;j<3;j++)
{cout<<A[<<(i+1)<<,<<(j+1)<<]=;cin>>A[i][j];
}
clrscr();
cout<< Los datos de la La matriz original son:;
for(i=0;i<3;i++)
{cout<<endl;
for(j=0;j<3;j++) cout<<\t<<A[i][j];
}
for(i=0;i<8;i++)
{min=A[i/3][i%3];
for(j=i+1;j<9;j++)
if(A[j/3][j%3]<min)
{min=A[j/3][j%3];
A[j/3][j%3]=A[i/3][i%3];
A[i/3][i%3]=min;
}
}
cout<<endl<<endl<<La matriz ordenada es la siguiente :;
for(i=0;i<3;i++) {cout<<endl;
for(j=0;j<3;j++)
cout<<\t<<A[i][j];
}
getch();
}
165
Problema 10. Disear un programa que permita ingresar el nmero de filas y

columnas, luego ingresar datos de tipo entero y mostrar:
a. La matriz ordenada por filas
b. La matriz ordenada por columnas
c. La suma acumulada por filas y por columnas
d. Mostrar el valor mnimo y mximo de cada fila
const int max=100;
void main()
{ int A[max][max], n,m,min,i,j;clrscr();
cout<<Ingrese la dimension de la matriz (mxn): <<endl;
cout<< Ingrese numero de filas : ; cin>>m;
cout<< Ingrese numero de columnas : ; cin>>n;
cout<<endl<<Ingrese los elementos de la matriz <<endl;
for(int i=0;i<m;i++)
for(int j=0;j<n;j++)
{ cout<<A[<<(i+1)<<,<<(j+1)<<]=; cin>>A[i][j];clrscr();
cout<<Los datos de la matriz son:<<endl;
for(t i=0;i<m;i++)
{ cout<<endl;
for( j=0;j<n;j++)
cout<<\t<<A[i][j];
}
cout<<endl<<endl<<Pulse una tecla para continuar...<<endl<<endl; getch();
for(i=0;i<m;i++)
//ordenando por filas
for( j=0;j<n-1;j++) {min=A[i][j];
for(int k=j+1;k<n;k++)
if(A[i][k] < min)
{ min=A[i][k]; A[i][k]=A[i][j]; A[i][j]=min;
}
}
cout<<La matriz ordenada por filas:<<endl;
for(i=0;i<m;i++)
{ cout<<endl;
cout<<\t<<A[i][j];
}
cout<<endl<<endl<<Pulse una tecla para continuar ...<<endl<<endl;getch();
for( j=0;j<n;j++)
//ordenando por columnas
for( i=0;i<m-1;i++)
min=A[i][j];
for(int k=i+1;k<m;k++)
if(A[k][j] < min)
{min=A[k][j]; A[k][j]=A[i][j]; A[i][j]=min;
166
}
cout<<La matriz ordenada por columnas:<<endl;
for(i=0;i<m;i++)
{cout<<endl;
cout<<\t<<A[i][j];
}
cout<<endl<<endl<<Pulse una tecla para continuar ...<<endl<<endl;
getch(); clrscr();
for(i=0;i<m;i++)
//suma por filas, suma se acumula en
{ A[i][n]=0;
A[i][n]=A[i][n]+A[i][j];
}
cout<<La suma acumulada por filas:<<endl;
for(i=0;i<m;i++)
cout<<La suma de los elementos de la fila <<(i+1)<< es: <<A[i][n]<<endl;
cout<<endl<<Pulse una tecla para continuar ...<<endl<<endl; getch();
for(j=0;j<n;j++)
//suma por columnas, suma se acumula en
{ A[m][j]=0;
A[m][j]=A[m][j]+A[i][j];
}
cout<<La suma acumulada por columnas:<<endl;
for(j=0;j<n;j++)
cout<<La suma de los elementos de la columna <<(j+1)<< es: <<A[m][j]<<endl;
cout<<endl<<Pulse una tecla para continuar ...<<endl<<endl; getch();
cout<<Los valores mximo y mnimo de cada fila son:<<endl;
for(i=0;i<m;i++)
cout<<Enfila<<(i+1)<<, el mnimo es: <<A[i][0]<<y el mximo es: <<A[i][n-1];
cout<<endl<<Pulse una tecla para continuar ...<<endl;
getch();}
167

columnas de una matriz, tal que permita ingresar nmeros enteros positivos.
Luego calcular el factorial de cada elemento de la matriz, este resultado se debe
ir almacenando en un vector, finalmente mostrar los resultados.
void main()
{ int z[10][10],k,u,i,j,x,y,m,n; long int v[100]; double fact;clrscr();
gotoxy(15,2);cout<<FACTORIAL DE CADA ELEMENTOS DE LA MATRIZ;
gotoxy(13,3);cout<<---------------------------------------------;
do{ gotoxy(1,4);cout<<Ingrese cantidad de filas :; cin>>m;
gotoxy(1,5);cout<<Ingrese cantidad de columnas :; cin>>n;
}while(m<=0 || m>=10 && n<=0 || n>=10);
gotoxy(1,5);cout<<Ingrese valores :;
x=7; y=10;
for(i=1;i<=m;i++)
for(j=1;j<=n;j++)
{gotoxy(16+y*j,x+i*2);cout<<v[<<i<<,<<j<<]=;
gotoxy(23+y*j,x+i*2);cin>>z[i][j];
}
u=0; fact=1;
for(i=1;i<=m;i++)
{ for(j=1;j<=n;j++)
{for(k=1;k<=z[i][j];k++) { fact=fact*k; }
u=u+1;v[u]=fact;fact=1; }
}
gotoxy(4,14);cout<<Reporte de factoriales copiados en un vector :<<endl;
for(k=1;k<=(m*n);k++)
{ gotoxy(4,16+k);
168

cout<<v[<<k<<]=<<v[k]<<endl;
}
getch();
}
Problema 12. Disear un algoritmo y el programa correspondiente que al leer un
nmero entero n en base 10, determine si existe otra base de numeracin b, en la
cual el nmero es escrito con sus cifras al revs. En caso afirmativo, mostrar la
base b y el nmero en dicha base (b 10). n debe tener por lo menos dos cifras y
la ltima de ellas ser siempre significativa.
Solucin //matriz_base_x.cpp
void main(){
char c[100],b[100];
int r,m,p=-1,n,i,k,j,s[100],d[100],x,w,h=0;
gotoxy(10,2);cout<< ************* NUEVA BASE *************** ;
gotoxy(2,4);cout<<endl<<Ingrese el numero: ;cin>>c;
n=atoi(c);
while((n<11)||((n%10)==0))
{cout<<Error al ingresar los datos vuelva a intentarlo: ;
cout<<Ingrese el numero: ;cin>>c;
n=atoi(c);
}
for(i=strlen(c)-1;i>=0;i--)
{p++; b[p]=c[i];
}
m=atoi(b);
r=n;
{j=-1;
k=m;
do { j++;
d[j]=(k%10);
k=k/10;
} while(k>=10);
d[j+1]=k; }
for(i=2;i<=10000;i++)
{j=-1; k=n;
for(x=0;x<=strlen(c)-1;x++)
{s[x]=0; }
do{ j++;
s[j]=(k%i);
k=k/i;
}while(k>=i);
s[j+1]=k;
if(((j+2)==strlen(c))&&(i!=10))
{ w=0;
169
for(x=0;x<=strlen(c)-1;x++)
{if(d[x]!=s[x])
w++;
}
if(w==0) {h++;
gotoxy(3,6);cout<<La base es : <<i<< y el numero es <<m;
}}}
if(h==0)
cout<<No se encontro ningun valor para b; getch();
}
Problema 13. Un aeropuerto cuenta con los datos de los pasajeros, por vuelos,
de los doce meses del ao pasado. Se tiene nueve destinos desde donde pueden
venir o llegar dichos vuelos y cinco aerolneas a los cuales pueden pertenecer
los vuelos (llammosla A, B, C, D, E). Se desea saber el mes en el cual llegaron o
partieron ms vuelos al aeropuerto, la aerolnea que realiz el mayor transporte
de pasajeros entre enero, febrero, marzo y los dos destinos ms concurridos por
las aerolneas C, D, E.
Solucin //mat_vuelos_avion.cpp
void main()
{ int vuelos[2][12][5][9], pasajeros[2][12][5][9][5], cont[12];
int i, j, k, l, m, max, maxi, max_pas, aero, cont_pas[5];
system(cls); cout<<\nRegistro de Salidas : ;
for(i=0;i<12;i++)
{ cout<<\nMes <<i+1<< :;
for(j=0;j<5;j++)
{ cout<<\nAerolinea <<i+65<< :;
for(k=0;k<9;k++)
{cout<<Ingrese numero de vuelos para el destino <<k+1;
cin>>vuelos[0][i][j][k];
for(l=0;l<vuelos[0][i][j][k];l++)
{cout<<Nmero de pasajeros del vuelo <<l+1<< :;
cin>>pasajeros[0][i][j][k][l];
}
}
}
}
system(cls);
cout<<\nRegistro de Llegadas : ;
for(i=0;i<12;i++)
{ cout<<\nMes <<i+1<< :;
for(j=0;j<5;j++)

{ cout<<\nAerolinea <<i+65<< :;
170
for(k=0;k<9;k++)

{
cout<<Ingrese el nmero de vuelos desde <<k+1<< :;

cin>>vuelos[1][i][j][k];

for(l=0;l<vuelos[1][i][j][k];l++)

{
cout<<Nmero de pasajeros del vuelo <<l+1<< :;

cin>>pasajeros[1][i][j][k][l];

}
}
}
}
for(i=0;i<12;i++)
{ cont[i]=0; max = cont[i];
for(m=0;m<2;m++)
for(j=0;j<5;j++)
for(k=0;k<9;k++)

cont[i]=cont[i]+vuelos[m][i][j][k];

if (cont[i] > max)

{ max=cont[i];
maxi=i;
}
}
cout<<\nEl mes de de mayor numeros de vuelos es <<maxi+1<< :;
for(j=0;j<5;j++)
{ cont_pas[j]=0;
max_pas = cont_pas[j];
for(i=0;i<3;i++)
for(m=0;m<2;m++)
for(k=0;k<9;k++)
for(l=0;l<vuelos[m][i][j][k];l++)
cont_pas[j]=cont_pas[j]+pasajeros[1][i][j][k][l];
if (cont_pas[j] > max_pas)
{ max_pas=cont_pas[j];
aero=j;

}

}
cout<<\nLa aerolinea con transporte de pasajeros es <<aero + 65<< :;
}

171
Parte I. Lectura de datos
Parte II. Registro de llegadas de pasajeros
Problema 14. Disear un programa que permita leer n alumnos (n 200) y por
cada alumno, leer cdigo y ocho notas de prcticas calificadas, luego se pide:
a. Calcular el promedio de prcticas (PP) eliminando las dos notas ms bajas
b. Mostrar el cuadro de mritos con los siguientes datos: cdigo, las ocho notas
de prcticas y el promedio de prcticas (PP)
Solucin
Diseo del mdulo de ingreso de alumnos por cdigo y ocho notas. Se debe
validar los cdigos que estn compuestos por tres dgitos y las notas sean vlidas
slo en el rango del 0 al 20.
172
Solucin //matriz_notas_prac_02.cpp
# include <iostream .h>
#define linea1 ____________________
#define linea-------------------------------------------------------
#define maxal 100
void main() {int codigo,j,cod[maxal],menorpc1,menorpc2;
int not[maxal][8],nota,i,sum,n,aux1,pos[maxal]; float prom[maxal];
char resp=s; // para la parte interactiva
while(resp==s) {clrscr();
gotoxy(6,2);cout<<SISTEMA DE CONSULTAS DE NOTAS ;
for (i=1;i<=60;i++)
}
do {gotoxy(12,6);clreol();cout<<Ingrese cantidad de alumnos: ;cin>>n;
}while(n<1 ||n>maxal);
clrscr();
gotoxy(6,1);cout<< Total de alumnos <<n;
gotoxy(6,2);cout<< INGRESO DE CODIGO Y NOTAS POR ALUMNO ;
for(i=1;i<=n;i++)
{for (int t=1;t<=50;t++)
{gotoxy(2+t,4);cout<<; gotoxy(2+t,22);cout<<;
}
do
{gotoxy(8,5+i);clreol();cout<<Ingrese codigo de alumno <<i<<=;cin>>codigo;
}while(codigo<100 ||codigo>900);
cod[i]=codigo;
gotoxy(12,6+i); cout<<Ingreso de notas ;
gotoxy(10,8);
cout<<linea1;
gotoxy(10,17); cout<<linea1;
for(j=1;j<=8;j++)
{ do {gotoxy(12,8+j);clreol();
cout<< nota <<j<< = ;cin>>nota;
}while(nota<0 ||nota>20);
not[i][j]=nota;
}
clrscr();
}
for (int t=1;t<=60;t++)
{ gotoxy(2+t,4);cout<<;gotoxy(2+t,22);cout<<;
}
// buscando las dos notas mas bajas, creando el vector posicion y el vector promedio
for(i=1;i<=n;i++)
173
{ pos[i]=i;sum=0;menorpc1=21;menorpc2=21;
for(j=1;j<=8;j++)
{ sum=sum+not[i][j];
if(not[i][j]<menorpc1)
{ menorpc2=menorpc1; menorpc1=not[i][j];
}
else if(menorpc2>not[i][j])
menorpc2=not[i][j];
}
prom[i]=(sum-menorpc1-menorpc2)/6.0;
}
//ordenando en vector posicion
for(i=1;i<=n-1;i++)
(j=i+1;j<=n;j++)
if(prom[i]<prom[j])
{ aux1=pos[i];
pos[i]=pos[j];
pos[j]=aux1;
}
gotoxy(6,11);cout<<\t\t\tCuadro de Meritos;
gotoxy(6,13);cout<< #<< Codigo\t\t Notas\t\t Promedio;
gotoxy(20,15);cout<<1 2 3 4 5 6 7 8 ;
for(i=1;i<=n;i++)
{ gotoxy(6,16+i);cout<<i<<.-;
gotoxy(12,16+i);cout<<cod[pos[i]];
for(int j=1;j<=8;j++)
{ gotoxy(16+4*j,16+i);cout<<not[pos[i]][j];
}
gotoxy(54,16+i);cout<<prom[pos[i]];
174
}
gotoxy(6,16+i);cout<<linea;
gotoxy(30,23); cout<<Sr. desea continuar ?...(S/N); cin>>resp;
}// Debe actualizar las variables
}
Problema 15. Disear un programa que permita ingresar nmeros enteros a una
matriz de orden n*m (n:filas y m:columnas) n,m definidos por usuario y luego
mostrar sus elementos ordenados en forma ascendente y en espiral.
Los datos ingresados y resultados esperados, se ilustran en la siguiente figura:
Solucin //matriz_espiral.cpp
#include <stdio.h>
# define linea ___________________________
#define taman 20
void main()
{ int matriz[taman][taman], espiral[taman][taman], temp[100],i,j,k,n;
int farribaizq,farribader,cderechaarr,cderechaaba,fabajoder,fabajoizq, cizqaba;
int cizqarr,contador, aux;;
gotoxy(15,2);cout<< MATRIZ ESPIRAL ;gotoxy(6,3);cout<<linea ;
gotoxy(8,4);cout<< Ingrese dimension de la matriz = ;cin>>n;
gotoxy(8,6);cout<< Ingrese elementos de la matriz ;
int x,y; x = 10; y = 8; //para gotoxy(x,y)
for (i=0;i<n;i++){
for (j=0;j<n;j++)
{gotoxy(x,y);cout<<M[<<(i+1)<<,<<(j+1)<<]=;
cin>>matriz[i][j];
x +=12;
}
y +=1;
x = 10;
}
k = 0;
for (i=0;i<n;i++)
for(j=0;j<n;j++)
{temp[k] = matriz[i][j];
k ++;
}
for (j=0;j<n*n-1;j++)
{ for (i=0;i<n*n-1;i++)
{if (temp[i] > temp[i+1])
{ aux=temp[i];
temp[i]=temp[i+1];
temp[i+1]=aux;
}
175
}
}
k = 0;
for (i=0;i<n;i++)
for(j=0;j<n;j++)
{
matriz[i][j] = temp[k];
k ++;
}
//inicializacin de variables
farribaizq =0;farribader = n - 1;cderechaarr = 1;cderechaaba = n - 1;fabajoder = n 2;fabajoizq = 0;cizqaba = n - 2; cizqarr = 1;contador = 0;
while(contador < (n*n))
{for (i = farribaizq; i <= farribader; i++)
{espiral[farribaizq][i] = temp[contador];
contador++;
}
farribaizq++;
farribader--;
for( i = cderechaarr; i <= cderechaaba; i++ )
{espiral[i][cderechaaba] = temp[contador];
contador++;
}
cderechaarr++; cderechaaba--;
for( i = fabajoder; i >= fabajoizq; i-- )
{espiral[fabajoder + 1][i] = temp[contador];
contador++;
}
fabajoder--; fabajoizq++;
for( i = cizqaba; i >= cizqarr; i-- )
{espiral[i][cizqarr - 1] = temp[contador];
contador++;
}
cizqaba--;
cizqarr++;
}
cout<<\n\t Matriz de Forma de ESPIRAL ; cout<<\n\tlinea;
y += 3;
for( i = 0; i < n; i++ )
{for( j = 0; j < n; j++ )
{
gotoxy(x,y);

if( espiral[i][j] < 10 )
{cout<<espiral[i][j];

}
else{cout<<espiral[i][j];

}
176
x +=6;
}
y += 1;
x = 10;
cout<<\n;
}
cout<< \n\n\t ;system(pause);
}
Problema 16. Disear un programa que te permita ingresar los precios (en
formato real y hasta tres cifras decimales) de distintos productos pertenecientes
a distintos almacenes en una matriz de n filas (tipos de productos) y m columnas
(nmero de almacenes), donde n, m es definido por el usuario. Los datos
ingresados deben procesarse y ser presentados solo en formato entero, para lo
cual debe aplicar
Reglas de Redondeo. El programa debe realizar y presentar lo siguiente, tal
1. Almacenar en un vector Total en Almacn[ ] los totales en almacn
2. Almacenar en un vector Total para Producto Tipo[] los totales por producto
3. Mostrar en un vector los elementos todos tipos enteros tanto para Total en
Almacn[ ] como para Total para ProductoTipo[ ]
4. Segn la parte 3, mostrar los elementos repetidos, los elementos que quedan y
la secuencia
Solucin. En la siguiente figura se ilustra el proceso de datos.
177
a. En la parte 1 y 2 simplemente vamos almacenando los subtotales, conforme

vamos almacenando los precios hasta completar los vectores totales tanto de
almacn como de producto tipo.
b. Para mostrar los elementos enteros en los vectores correspondientes, lo que
hacemos es multiplicar por 1000 cada elemento de los vectores totales, luego
tomamos el residuo de dividir cada elemento entre 1000 (tomando as la parte
decimal de cada uno) y evaluamos si ese residuo es mayor que 500. Si lo es,
aadimos una unidad a la parte de las unidades, sino, no efectuamos nada y en
ambos casos copiamos a los vectores tipo entero correspondientes a almacn
como a tipo producto.
c. Para la parte 4, quiz la parte ms compleja, en una sola operacin evaluamos
el i-simo elemento de los vectores enteros tanto como para almacn y tipo
producto y luego si el i-simo elemento es igual al j-simo elemento que las
repeticiones se copien en otro vector (tanto para almacn como para producto
tipo) y que se eliminen del vector de enteros correspondientes quedando as
solamente los elementos que no se repiten.
d. Usaremos pues los datos del cuadro de arriba para simular el comportamiento
de nuestra empresa y para verificar si nuestro programa se comporta como es
debido.
//MATRIZ_DECIMAL.CPP
int main(){
int i, j, cant_al, cant_tipo, k=0, l=0, cant_al_Ent[8], cant_tipo_Ent[8], entero=0,
eliminados_al[8], eliminados_tipo[8], z, zz, auxiliar=0, p=0, eliminadoi, elementoi;
float precios[8][8], total_almacen[8], total_tipo[8], suma_almacen, suma_tipo;
clrscr();
cout<<INGRESE LA CANTIDAD DE ALMECENES : ;cin>>cant_al;
cout<<INGRESE LA CANTIDAD DE TIPO DE PRODUCTOS :;cin>>cant_tipo;
//Pidiendo los valores y almacenando en el vector total_almacen
for(j=1;j<=cant_al;j++){
cout<<\n\nEN EL ALMACEN <<j<< :<<endl;
suma_almacen=0;
for(i=1;i<=cant_tipo;i++)
{cout<<INGRESE EL PRECIO PARA EL PRODUCTO<<i<< = ;cin>>precios[i]
[j];
suma_almacen += precios[i][j];
}
total_almacen[j]=suma_almacen;
}
//Llenando los valores para el vector total_tipo
{suma_tipo=0;
for(j=1;j<=cant_al;j++)
suma_tipo += precios[i][j];total_tipo[i]=suma_tipo;
}
//Mostrando totales por almacen
178
cout<<\n\nMostrando los totales por almacen..<<endl;

for(j=1;j<=cant_al;j++)
cout<<Total para Almacen <<j<< es: <<total_almacen[j]<<endl;
cout<<Presione una tecla para continuar......;getche();
//Mostrando totales por tipo
cout<<\n\nMostrando los totales por tipo..<<endl;
cout<<Total para el producto Tipo <<i<< es: <<total_tipo[i]<<endl;
cout<<Presione una tecla para continuar......;getche();
//Mostrando en el vector cant_al_Ent los valores enteros de usando reglas de
recondeo
cout<<\n\nMostrando los elementos enteros para el vector Total en
Almacen...<<endl;
for(j=1;j<=cant_al;j++){

int multiplicado=1000*total_almacen[j];

int residuo=multiplicado%1000;
if(residuo>=500)
entero=multiplicado/1000+1;
else
entero=multiplicado/1000;
//k++;
cant_al_Ent[j]=entero;
cout<<El elemento entero <<j<< del vector Total en Almacen es <<cant_al_
Ent[j]<<endl;
}
cout<<Presione una tecla para continuar......; getche();
//Mostrando en el vector cant_tipo_Ent los valores enteros de usando reglas de
recondeo
cout<<\n\nMostrando los elementos para el vector Total para Producto
Tipo...<<endl;
for(i=1;i<=cant_tipo;i++){
int multiplicado=1000*total_tipo[i];
int residuo=multiplicado%1000;
if(residuo>=500)
entero=multiplicado/1000+1;
else
entero=multiplicado/1000;
//l++;
cant_tipo_Ent[i]=entero;
cout<<El elemento entero <<i<< del vector Total para Producto Tipo es:
<<cant_tipo_Ent[i];
}
cout<<Presione una tecla para continuar......; getche();
//Eliminando elementos repetidos en cant_al_Ent y colocando las secuencias de
179
los elementos //repetidos en el vector eliminados_al

z=0; eliminadoi=0; elementoi=1;
for(i=1;i<=cant_al-1;i++){
for(k=i+1;k<=cant_al;k++){
if (cant_al_Ent[k]==cant_al_Ent[i])
{p=k;
if(elementoi)
{
eliminados_al[++z]=cant_al_Ent[i];
eliminados_al[++z]=cant_al_
Ent[k];
elementoi=0;
}
Else
eliminados_al[++z]=cant_al_Ent[k];
while (p<=cant_al)
{cant_al_Ent[p]=cant_al_Ent[p+1];
p++;
}
cant_al--;k--;eliminadoi=1;
}
}
if(eliminadoi)
{l=i;
while(l<=cant_al)
{cant_al_Ent[l]=cant_al_Ent[l+1];
l++;
}
cant_al--;i--;eliminadoi=0;
elementoi=1;
}
}
//Eliminando elementos repetidos en cant_tipo_Ent y colocando las secuencias
de //los elementos repetidos en el vector eliminados_tipo
zz=0; eliminadoi=0; elementoi=1;
for(i=1;i<=cant_tipo-1;i++){
for(k=i+1;k<=cant_tipo;k++){
if (cant_tipo_Ent[k]==cant_tipo_Ent[i])
{p=k;
if(elementoi)
{
eliminados_tipo[++zz]=cant_tipo_Ent[i]; eliminados_tipo[++zz]=cant_
tipo_Ent[k];
elementoi=0;
}
else
eliminados_tipo[++zz]=cant_tipo_Ent[k];
while (p<=cant_tipo)
{cant_tipo_Ent[p]=cant_tipo_Ent[p+1];
180
p++;
}
cant_tipo--; k--; eliminadoi=1;
}
}
if(eliminadoi)
{l=i;
while(l<=cant_tipo)
{cant_tipo_Ent[l]=cant_tipo_Ent[l+1];
l++;
}
cant_tipo--;i--;eliminadoi=0;elementoi=1;
}
}
//Mostrando los elementos del vector entero cant_al_Ent sin repetidos
cout<<\n\nMostrando los elementos enteros sin repetir para el vector Total en
Almancen.;
for(i=1;i<=cant_al;i++)
cout<<El elemento sin repetir <<i<< del vector entero Total en Almacen es:
<<cant_al_Ent[i];
cout<<Presione una tecla para continuar......;
getche();//Mostrando los elementos del vector entero cant_tipo_Ent sin repetidos
cout<<\n\nMostrando los elementos enteros sin repetir para el vector Total
para Producto Tipo...;
cout<<El elemento sin repetir <<i<< del vector entero Total para Producto Tipo
es: <<cant_tipo_Ent[i]<<endl; cout<<Presione una tecla para continuar......;
getche();
//Mostrando los elementos del vector eliminado para cant_al_Ent
cout<<\n\n\nMostrando la secuencia de valores repetidos en el vector Total en
Almacen es: ;
for(i=1;i<=z;i++)
cout<<eliminados_al[i]<<endl;
cout<<Presione una tecla para continuar......;
getche();
//Mostrando los elementos del vector eliminado para cant_tipo_Ent
cout<<\nMostrando la secuencia de valores repetidos en el vector Total para
Producto Tipo es: ;for(i=1;i<=zz;i++)
cout<<eliminados_tipo[i]<<endl;
cout<<Fin del Programa;
getche();
return 0;
}
181
Problema 17. El cartero de una zona campestre debe de entregar cartas en n casas
de una regin. Para ello, desea armarse un recorrido que le permita entregar
todas las cartas y regresar a su oficina queriendo que el trayecto entre dos casas
consecutivas sea siempre recto.
Como le gusta pasear pretende, adems, que el recorrido no se corte a s mismo,
entonces el problema consiste en escribir un programa que le permita el ingreso
de las coordenadas (x,y)de cada una de las n casas y de la oficina de correos y que
si existe una lista de las casas en elorden en que deben ser visitadas.
Solucin // matriz_cartero.cpp
void main()
{int x,y,n,i,j,m,q,opc;double casa[100],y1,x1,aux;
cout<<\t\n ===> CARTERO <=== ;
cout<< \t\n Ingrese coordenadas de la Oficina;
do{gotoxy(10,4);cout<<x = ; cin>>x;
}while(x<1 || x>100);
do{ gotoxy(18,4);cout<<y = ; cin>>y;
}while(y<1 || y>100);
cout<< \t\n Sr. ingrese numero de Casas a visitar =;cin>>n;
for(i=1;i<=n;i++){cout<<\nIngrese Coordenadas de la Casa # <<i<< =<<endl;
do
{cout<< x = ; cin>>x1;
}while(x1<1 || x1>100);
do{cout<< y = ; cin>>y1;
}while(y1<1 || y1>100);
casa[i]=sqrt(pow(x1,2)+pow(y1,2));
// verificar mediante dx=pow((xx-x),2); dy=pow((yy-y),2);dxy=dx+dy;
//
dd=sqrt(dxy);
182
cout<< \t\n La Distancia de la Casa [<<i<< ] = <<casa[i]<<endl;}

for(i=1;i<=n-1;i++)
for(int j=(i+1);j<=n;j++)
if(casa[i]>casa[j]){aux=casa[i]; casa[i]=casa[j]; casa[j]=aux;}
cout<< \t\n La Primera casa a visitar es la que tiene la distancia=;
for(i=1;i<=n;i++){ cout<<\t\n casa[ <<i<< ]= <<casa[i]<<metos <<endl;}
getche(); }
[0] [1]
12
11
[2] [3]
09
15
[ 18 ] [ 19 ] ndice
........
11
08
02
12
Bidimensionales
Multidimensionales
Para caso: secciones, alumnos y notas
183
Problema 1. El problema consiste en identificar y registrar datos repetidos

durante lecturas, es decir, cuando elusuario ingresa n datos, n>1(ejemplo: sistema
de matrcula de alumnos), se debe identificar el dato y su ndice lgico (dato que
se genera en una tabla dentro de una base de datos que nunca se repite).
Se inicia el ingreso con el dato 12, mediante el cual se enva los mensajes indicando
el nmero de repeticiones, as como ubicacin del ndice en la posicin
i,asimismo, se va registrando el dato repetido y el total, se encarga de llevar el
registro de intentos (error) repetidos para el valor en la posicin i-k.(k>1).
En la siguiente interface se ilustra los procesos de la secuencia de datos repetidos,
nmero de intentos (errores) y la posicin donde se localiza el dato repetido.
Finalmente, en este formulario se

genera el proceso de identificacin
y registro de datos no repetido;
su total y datos repetidos, estos
deben estar ordenados en forma
ascendente y totalizados.
Problema 2. El problema se basa
en generar el cdigo de usuario
(alumno, empleado, ciudadano, vehculo, etc.) durante el proceso de registro
de datos en el sistema informtico. Este proceso se conoce con el nombre de
Algoritmo del Mdulo 11 , el cual consiste en que el usuario ingresa un nmero
entero (defina el tamao) y luego se descompone en la suma de factores de
184
multiplicacin usando los dgitos desde 2 hasta 9, y al resultado se extrae el resto,

a este se le asigna una letra ABCDEFGHIJK (vector cadena), segn resultado
del resto.
Ejemplo: Generar cdigo de dos empleados, cdigo registrado en la base de
datos del sistema de planilla de la universidad.
I. Empleado 1: Monzn
Ingrese cdigo: 838509
Suma de factores = 8*2 +3*3+ 8*4 +5*5+0*6+9*7 = 145
Mdulo 11
= 145%11 = 2 Asignacin de letra = C
Cdigo generado: 838509C
II. Empleado 2: Crdova
Ingrese cdigo: 848139
Suma de factores = 8*2 +4*3+ 8*4 +1*5+3*6+9*7 =146
Mdulo 11
= 164%11 = 3 Asignacin de letra = D
Cdigo generado: 848139D
Mdulos:
1. Longitud (): para registrar el nmero de empleados.
2. Lectura (): permite leer cdigos de
empleados sin repetirse.
3. Mdulo 11 (): funcin que devuelve letra.
Procedimientos:
1. Lectura de total de empleados.
2. Registrar a empleados por cdigo y apellidos. En este mdulo se valida el
cdigo y luego se busca el resto del mdulo 11 y, usando la funcin mdulo 11
(), se asigna la letra correspondiente. En las siguientes interfaces se ilustra los
resultados.
185
Sistema acadmico de evaluaciones y consultas

Problema 3. El director de la Escuela de Sistemas debe procesar datos de alumnos
(sexo: M: masculino y F: femenino) por asignaturas, donde cada asignatura tiene:
secciones (5), alumnos (1000) y notas (total ocho: cinco prcticas, tres exmenes:
parcial, final y sustitutorio) de la siguiente manera:
Registro de datos: se debe registrar mximo 1000 alumnos, y por cada alumno
leer su cdigo (nico: se debe generar usando el algoritmo del mdulo 11, el
cual se usa en la UNI), apellidos paterno y materno (cadenas de 20 caracteres).
Por alumno debe registrar: nmero de asignaturas identificadas por cdigo (4
cdigos distintos y que identifican cuatro reas diferentes en la FIIS ): Sistemas
(ST<3 dig>). Gestin (GP< 3_digs>), Tecnologa (TP<3 dig>), Ciencias bsicas (
CB<3 dig>) y nombre (cadena: 40 caracteres) y para cada asignatura leer el nmero
de secciones (mximo 5, que son caracteres: A,B,C,D,E) y por cada seccin leer
el nmero de prcticas (mximo 5) y exmenes (Exp: parcial, Exf: final y Exs:
sustitutorio). Debe validar datos, as, al registrar un alumno NO puede repetirse
en una asignatura, otros casos que usted contemple el sistema.
Consultas: El sistema debe proveer las siguientes informaciones:
1. Listado de apellidos del alumnos, nombre de asignatura y cdigo, secciones y
sus notas respectivas.
2. Listado por nombre de asignatura, secciones, apellidos de alumnos y su sus
notas (solo prcticas), su promedio de prcticas, eliminando la menor nota.
3. Listado por nombre de asignatura, secciones, apellidos de alumnos y sus notas (8), su promedio (eliminando la menor nota) de prcticas, promedio final
(considere prcticas, parcial y final) y el estado A: aprobado, D: desaprobado.
Adicionalmente enviar el mensaje sin sustitutorio.
4. Listado por nombre de asignatura, secciones, apellidos de alumnos y sus notas (8), su promedio (eliminando la menor nota) de prcticas, promedio final
(considere prcticas, parcial, final y examen sustitutorio, el cual reemplaza a la
menor nota de los exmenes respectivos) y el estado A: aprobado, D: desaprobado. Adicionalmente enviar el mensaje con sustitutorio.
5. Listado por nombre de asignatura, secciones y su promedio por seccin.
6. Listado de alumnos del tercio superior en cada seccin y apellidos.
7. Listado de alumnos por apellidos, ordenados en forma ascendente por seccin.
8. Promedio general institucional (use promedios de secciones).
9. Seccin con mayor promedio y seccin con menor promedio de la asignatura
correspondiente.
10.Total de alumnos desaprobados (promedio final >10) y aprobados (promedio
final<11) por asignatura y seccin (mostrar cantidad, nombre de asignatura y
seccin correspondiente).
Problema 4. Disear un programa que permita leer n y m elementos para vectores
A y B de tamao 100, respectivamente, luego genera el reporte que permita
mostrar los elementos interceptados y su posicin que ocupa el elemento en cada
vector.
186
Solucin
En la siguiente interface se ilustra
la lectura de datos a vectores A y B,
asimismo, en la figura siguiente, se
ilustra lo solicitado.

que permita calcular el valor de un
polinomio Pn(x), su primera y
segunda derivada, evaluado en
x0. Primero debe leer el grado
del polinomio, el valor donde se
evaluar y luego los coeficientes
respectivos. Para calcular la
primera derivada se debe validar
que el grado del polinomio debe
ser por lo menos de grado 1 y para
la segunda derivada, el polinomio
debe ser cuadrtico o ms.
que permita almacenar n tipos de productos en m almacenes (n, m<=100) en
una matriz de dimensin n y m, respectivamente. Los datos se deben generar en
forma aleatoria con la condicin que estn solo entre el 0 al 99. Luego mostrar lo
siguiente:
a. Datos de la matriz generada en forma aleatoria.
b. Datos almacenados en un vector de longitud m*n y ordenados en forma ascendente.
c. Total de productos por tipo y
por almacn, respectivamente.
d. Elementos de la matriz ordenados por filas en forma ascendente.
e. Producto con menor y mayor
cantidad de unidades y la ubicacin respectiva.
El programa debe ser interactivo
con el usuario.
187
Problema 7. Disear un programa que permita realizar las operaciones combinadas de vectores y matriz.
Leer la dimensin de la matriz y luego ingresar datos tipo enteros y almacenarlo
en una matriz, luego realice los procesos mostrados en las siguientes figuras:
a. Lectura del total de elementos de la matriz, almacenamiento de datos, copia de
datos de la matriz a un vector, ordenamiento de elementos de la matriz.
Problema 8. Disear un programa que permita leer la

dimensin de una matriz de
orden n*m y luego ingresar
datos solo de dos dgitos,
finalmente mostrar en forma
invertida sus elementos.
188
Problema 9. SISTEMA DE GESTION DE ALUMNOS: Disear un programa que

permita leer n alumnos(n>0, n<1000) por datos: cdigo (entero solo tres dgitos),
apellidos (cadenas[20]) y edad(edad>14, Edad<=70). Se debe validar el cdigo de
alumno en el contexo que NO EXISTE CDIGOS REPETIDOS , pues, en la
prctica, un cdigo SOLO pertenece a un alumno o un alumno posee un NICO
cdigo. El proceso consiste en leer el cdigo del primer alumno y su apellido y, a
continuacin, leer el cdigo del segundo alumno. A partir del segundo cdigo se
inicia la validacin respectiva. En las siguientes interfaces, se ilustra los procesos
de validacin:
Cuando edita el cdigo del segundo alumno y es igual al cdigo del primer
alumno, el sistema enva mensaje:
Cdigo existe en posicin 1 intento # 1
En el segundo intento, cuando edita cdigo de segundo alumno y es igual al

cdigo del primer alumno, el sistema enva mensaje:
Cdigo existe en posicin 1 Intento # 2
Si este proceso se repite con igual cdigo, el sistema enviar el mismo mensaje
pero en k veces (k=3,4)
Ahora, si el cdigo del segundo alumno es diferente del primero, se puede editar
cdigo del tercer alumno, pero para este tercer alumno si se repite el cdigo,
entonces el sistema enva el mensaje:
Codigo Existe en posicion 2 Intento # 1
189
As continuar ingresando y validando cdigo y sus apellidos respectivos, tal

A continuacin, genere listado de alumnos ordenados por apellidos en forma

ascendente, mostrando su cdigo y la posicin inicial de cada alumno, este
proceso como resultado se ilustra en la siguiente figura:

positivo y luego mostrar:
a. Todos los divisores de una cifra, de dos cifras y tres cifras, respectivamente.
b. Total de divisores de una cifra, dos cifras y tres cifras.
c. El mayor grupo de divisores (en este caso mayor de 2 cifras = 7 divisores).
190
Arreglos unidimensionales
Problema 11. Solo se deben usar para que el usuario ingrese sus datos por cdigo
(solo de tres dgitos), nombre (cadena de longitud de 10 caracteres) y edad
(15..70) de n empleados( n<=100 ). Los datos deben almacenarse en vectores que
usted defina, luego genere los siguientes reportes:
1. Empleados por cdigo, nombre y edad, respectivamente.
2.
Empleados por nombre y
edad, ordenados en forma ascendente por edad.
Asimismo, mostrar la posicin actual y original de cada
empleado.
3. Buscar empleados por edad, si
existen; mostrar el total.
4. Insertar nuevo(s) empleado(s).
Mostrar los nuevos resultados.
5. Retirar empleados que tiene edad mayor a 60 aos.
Arreglos bidimensionales
Problema 12. Disear un programa que permita almacenar cantidad de vehculos
por marca (Toyota, Datsun, Honda, etc.) en almacenes ubicados en distritos
(Lima, Lince, Rmac, etc.) y luego genere los siguientes reportes:
a. Total de vehculos por tipo y ordenados en forma ascendente. Tambin se debe
mostrar el tipo (nombre) correspondiente.
b. Total de vehculos en cada almacn y ordenados en forma ascendente.Tambin
se debe mostrar el almacn (distrito) correspondiente.
c. Vehculos ordenados en forma ascendente en la matriz.
d. Nombre del almacn con mayor cantidad de vehculos, segn tipo y posicin
respectiva.
e. Nombre del tipo de vehculo con menor cantidad y nombre del almacn correspondiente y su posicin respectiva.
191
Problema 13. Programa que permita realizar las operaciones combinadas de

vectores y matriz. Leer datos tipo enteros y almacenarlos en una matriz, luego
realice los procesos mostrados en las siguientes figuras:
1. Lectura del total de elementos de la matriz, almacenamiento de datos, copia de
datos de la matriz a un vector, ordenamiento de elementos de la matriz.
Problema 14. Disear un programa que permita inicializar en estructuras la

siguiente informacin: 5 secciones (A,B,C,D,E), 5 asignaturas (Basicas, Fisica I,
Ingles I, Ecologia, Analisis) y 20 alumnos Marcos, Jose, Ana, Abel,
Pedro, Betty, Estela, Luz, Arturo, Robert, Manuel, Bryan, Kike,
Daniel, Leonel, Alfredo, Anais, Julio, Pepe, Margot y 3 prcticas
(5..15). Luego en forma aleatoria debe asignarse la correspondencia de los datos
respectivos para generar los siguientes:
a. Reporte de datos de alumnos.
b. Reporte de nombres de alumnos, su promedio en su asignatura y seccin respectiva, as como promedio por seccin.
c. Reporte de seccin con mayor promedio.
d. Reporte de datos de alumnos, pero ordenados segn seccin.
192
Reporte de alumnos ordenados por seccin

Seccin con mayor promedio
Problema 15. Dada una matriz bidimensional n x n, crear otra de las mismas
dimensiones, donde el valor de cada elemento, sea el promedio del elemento en
la misma posicin de la primera matriz y de los vecinos que lo rodean (nueve o
menos).
Ejemplo:
El elemento 2a fila y 2a columna es el promedio de todos
sus vecinos (marcados con doble lnea)
Problema 16. Matriz con entradas en diagonal
Dados dos enteros m y n, disear un programa que construya una matriz con
m filas y n columnas cuyas entradas sean los nmeros 1, 2, ..., m*n acomodados
en diagonal, comenzando con el 1 en la entrada que esta en la esquina superior
izquierda, siguiendo con el 2 a la derecha del 1 y el 3 abajo del 1, y as
sucesivamente.
193
Entrada: Dos nmeros enteros 2 m, n 100, separados por un espacio.

Salida: La matriz requerida
Problema 17. Matrices binarias giradas

Una matriz binaria tiene todas sus entradas iguales a 0 o a 1. Dos matrices A y B
tienen una entrada comn si Aij = Bij. Si adems permitimos que esas matrices
se giren o reflejen de todas las formas posibles, entonces la cantidad de entradas
comunes puede cambiar. Escribe un programa que lea dos matrices binarias
cuadradas y que encuentre la cantidad mxima p y mnima q de entradas
comunes cuando se permite girar o reflejar cualquiera de las dos matrices de
cualquiera de las formas posibles.
Entrada: Un nmero entero n seguido de dos matrices A y B de n n.
Puedes suponer que 1 n 100
Salida: Un nmero entero p y un nmero entero q.
Problema 18. Uno, dos, tres

Imagina que estas parado en el punto (0, 0) de un plano cartesiano. A partir de all,
puedes dar un paso de tamao 1 en alguna direccin, luego un paso de tamao
2 en alguna direccin, despus un paso de tamao 3 en alguna direccin, etc. Las
cuatro direcciones posibles son arriba, abajo, izquierdas y derechas. El objetivo es
que llegues al punto de coordenadas (a, b) en la menor cantidad n de pasos que
te sea posible. Disee un programa que te ayude a encontrar un posible camino
de (0, 0) a (a, b) que cumpla esas condiciones.
194
Entrada: Dos nmeros enteros a y b tales que -1,000 a, b 1,000.

Salida: Un nmero entero n seguido de n parejas de enteros xi, yi separados por
espacios, las cuales corresponden con los n puntos a los que llegas despus de
cada paso.
Evaluacin: 1 punto si la n pasa indicada cumplen las condiciones pedidas. En
ese caso, 5m/n puntos adicionales, donde m es la cantidad mnima de pasos
necesaria para llegar de (0, 0) a (a, b). El primer ejemplo recibira 1+5*3/3 = 6
puntos mientras que el segundo recibira 1+5*3/7 = 3 puntos.
Problema 19. Matriz con entradas en espiral

Dados dos enteros m y n, disee un programa que construya una matriz con m
filas y n columnas cuyas entradas sean los nmeros 1, 2, ..., m*n acomodados
en espiral, comenzando con el nmero 1 en la entrada que esta en la esquina
superior izquierda, siguiendo hacia la derecha, luego hacia abajo, luego hacia la
izquierda, luego hacia arriba, y asi sucesivamente.
Entrada: Dos nmeros enteros m, n, separados por un espacio, cuyos valores
estn entre 1 y 100 (incluyndolos).
Salida: La matriz requerida (para mayor detalle, ver el ejemplo de salida, aunque
no se requiere exactamente el mismo espaciado, solo el orden.
Problema 20. Cuadrados de colores

Una cuadrcula de m por n tiene pintado cada uno de sus cuadritos de alguno
de k colores. Estos cuadritos a veces forman cuadrados ms grandes donde
todos los cuadritos son del mismo color. Escribe un programa que determine
195
la longitud g del lado ms grande de cualquiera de estos cuadrados. Adems,

tu programa deber determinar la cantidad c de cuadrados de ese tamao y el
nmero d de colores distintos en los que existan cuadrados de ese tamao. El
ejemplo mostrado abajo tiene g = 2. Los cuadrados correspondientes son uno de
color 1 y tres de color 3 (por lo que c = 4 y d = 2).
Entrada: Tres nmeros enteros m, n y k en el intervalo 1 a 100 (incluyndolos)

seguidos de m renglones con n enteros cada uno en el intervalo 1 a k
(incluyndolos).
Salida: Tres nmeros enteros g, c y d.
Problema 21. Se trata de VALIDAR dato de
n alumnos, dato que es su CODIGO. Pues,
en la practica un cdigo SOLO pertenece a
un Alumno. El programa consiste en leer
el Cdigo de primer alumno y luego leer
cdigo de segundo alumno. Luego compare
si estos cdigos son iguales entonces enviar
el mensaje Cdigo ya Existe . Ante este
mensaje el sistema le solicita que ingrese
nuevo cdigo, nuevamente se coinciden vuelve a emitir el mensaje hasta que Ud.
Ingrese cdigo diferente al primero. As continua la validacin. Ver la siguiente
grafica:
Problema 22. Disear un programa que permita ingresar datos de n alumnos
(n<=1000) por cdigo, apellidos, nombres y edad, respectivamente, luego genere
los siguientes reportes que permita conocer datos procesados tal como se ilustra
en la figura adjunta.
196
1. Ingreso de Registros
2. Reporte Ordenado de Registros
por Apellidos
Permite ordenar los registros por
apellidos en forma ascendente
3. Insertando Registros. El usuario
ingresa el nmero de registros
que desea insertar, para lo cual el
sistema totaliza la cantidad total n) de registros que existen y enva el mensaje
que ingrese el (n+1) registro(s). Al final genere un reporte indicando el total de
registros.
4. Listado de los Registros. En este listado se verifica el total de registros que

dispone en el sistema (memoria RAM).
5. Eliminacin de Registros. El usuario ingresa el nmero del Registro que desea
eliminar, luego del proceso de eliminacin el sistema enva el mensaje de
confirmacin, asimismo indicando
la cantidad actual de registros.
6.
Reporte de registros despus
de eliminar. Permite mostrar la
cantidad actual de registros en el
sistema
7. Reporte de registros ordenados
por Cdigo. Como observa en
197
opcin 6 y despus del proceso

de insercin, los registros no
estn ordenados por cdigo. En
el siguiente proceso se ilustra la
ordenacin por el campo cdigo y
8. Reporte de registros ordenados
por Apellidos despus de ordenar
por Cdigo. Permite ordenar
nuevamente por apellidos en
forma ascendente.
9. Buscando edades. Este mdulo
permite al usuario realizar el
proceso de bsqueda de registros
segn el dato edad, si existe totaliza
y enva el mensaje respectivo. En
otro caso indicar que no existen
registros con la edad buscada.
198
Captulo 4
Las cadenas de caracteres
Objetivos
- Comprender cmo funciona el
procesamiento de cadenas.
- Definir la longitud fsica de una
cadena.
- Establecer el dato de usuario con
nombre de la cadena.
- Definir vector cadena.
- Definir vector de cadenas.
- Usar funciones de comparacin
(strcmp), convertir caracteres a
maysculas (strupper), etc.
- Funciones para el tratamiento de
cadenas: strlen(), strcat().
- Copia de cadenas: stpcpy(), strcpy(), strncpy().
4.1 Introduccin
Una cadena de caractereses una secuencia de cero o ms smbolos que incluyen
letras, dgitos y caracteres especiales o es un arreglo de caracteres que, en el caso
de C++, debe terminar en el carcter nulo (\0). Una cadena puede representarse,
o bien como un array comn (encerrado entre llaves), o bien como una serie de
caracteres encerrado entre comillas.
Existen diferentes juegos de caracteres, dentro de los que se destacan el cdigo
ASCII y el EBCDIC.
Ejemplo:
1. {A, l, a, n, d, , C, +, \0} //es una cadena en C++
2. Borland C++ 5 //Es una cadena C++
3. {s,u,n,a,l, ,C,+} //No es una cadena C++
199
Sintaxis
char cadena[30]; //Cadena de 30 caracteres + \0;
Se puede omitir la longitud de la cadena en la declaracin si es que tambin se
la inicializa:
char salida[ ]= Lenguajues de Programacion Estructurado;
4.2 Punteros a cadenas de caracteres

Una cadena puede declararse como un arreglo de caracteres en el cual el nombre
de la cadena se refiere en realidad a la posicin en memoria de su primer carcter.
Sintaxis:
char *cad1; en donde cad1 es el nombre de la cadena
- cad1 o cad1[1]: es el primer carcter de cad1
- (cad+1) o cad1[2]: es el segundo carcter de cad1
- (cad + -1) o cad1[i]: es el isimo carcter de cad1
Problema 1. Disear un programa que permita leer una cadena y luego imprimir
el primer carcter.
Solucin //vect_ca_l.cpp
voidmain() { charcad;
clrscr();gotoxy(2,2);cout<<Ingrese una
cadena :;cin>>cad;
gotoxy(2,4);cout<<Salida de la cadena:
<<cad;getche();
}
Problema 2. Programa que usa tres cadenas para repetir la segunda.
Solucin //vect_cal.cpp
voidmain() {char *cad1=Curso, Algoritmos, Estudien, *cad2, *cad3;
cad2=cad1; //Asigna cad1 a cad2
cad3=cad1+17; //Asigna a cad3 la cadena cad1 desde su 18 carcter
cout<<cad2<< <<cad3; //imprime Curso Algoritmos, Estudien, Estudien
getche() ;
}
200
Observacin:
1. Si declara cad[ ]: Solicita un valor
2. Si declara cad [4]: Imprime la cadena hasta encontrar un espacio en blanco
3. cout<<(cad1+1): imprime cad1 a partir de su segundo carcter
Notas:
1. Slo con punteros a cadenas (char*) se puede hacer la asignacin de cadenas
con el smbolo =, pues en este caso, nos referimos nicamente al primer carcter
de la cadena.
2. El flujo cincuenta con un mtodo getline, que es ms eficiente para leer una
cadena incluyendolos espacios en blanco que pueda contener.
Su sintaxis es:
cin.getline(char *cadena, int longitud, char escape=\n)
Cadena: es una variable de tipo cadena.
Longitud: es el nmero mximo de caracteres a considerar en la entrada.
Generalmente se usa el formato sizeof(cadena) para leer una cadena cuyo
tamao mximo es desconocido.
Escape: es el carcter con el cual terminar la lectura de la cadena. Es opcional.
3. Se puede acceder individualmente a cada carcter de la cadena, como en un
arreglo, llamndolo por su ndice, el cual representa su posicin en la cadena.
Problema 3. Disear un programa que permita convertir una cadena escrita en
letras minsculas a letras maysculas.
Solucin //vect_cad1.pp
void main() { char cad[40]; char copia_l[40];int i;
gotoxy(2,2); cout<< Ingrese cadena :;gets(cad);
for (i=0;i<=sizeof(cad);i++){copia_l[i]=toupper(cad[i]);}
gotoxy(2,4);
cout<<Cadena convertida a mayusculas =<<copia_l;
getche(); }
201
4.3 Funciones para el tratamiento de cadenas strlen() y

strcat()
Strleng(). Devuelve el nmero de caracteres de una cadena.
Sintaxis: size_tstrlen (constchar*s)
Problema 1. Disear un programa para conocer la longitud de la cadena
inicializada.
Solucin //vect_cad_lon.cpp
void main(){char *cad1 = Programacion estructurada;

int lon;
lon=strlen(cad1);

gotoxy(2,2);cout<<longitud cadena=<<lon; //Visualiza 25 getche();}
Concatenacin de cadenas
Funcin strcat()
Permite concatenar (unir) dos cadenas ledos e inicializadas por usuario.
Sintaxis:
char*strcat (char*cad1, constchar*cad2)
Problema 1. Disear un programa que permita leer dos cadenas: cad1[50] y
cad2[20], luego imprimir la cadena concatenada.
202
Solucin
//cadena5.cpp
void main()
{ char cad1[40];
char cad2[20];
cout<<\n Ingrese cadena 1: ;
gets(cad1);
cout<<\n Ingrese cadena 2: ;gets(cad2);
strcat(cad1,cad2);
cout<<\nCadena concatenada : <<cad1;getche() ;
}
Problema 2. Disear un programa que permita leer dos cadenas de longitud n
y m, respectivamente; luego las dos cadenas mostrarlas en forma concatenada,
convertirla a maysculas, mostrar en forma invertida y finalmente, la cadena
invertida mostrarla en su estado de origen (al estado en que se realiz la
conversin a maysculas).
Solucin //cadena_invertida.cpp
#define max 80
voidmain()
{ char cad1[max], *inv,original[max],x1[max], cad2[max],*p1,r*p2;inti,lon;
p1=&cad1[0]; p2=&cad2[0];
cout<<Ingresecadena 1 :; gets(p1);
cout<<Ingresecadena 2 :; gets(p2);
lon=strlen(strcat(p1,p2));
cout<<\n Cadena concatenada original: <<p1<<endl;
cout<<\n La longitud de la cadena es: <<lon<<endl;
for(i=0;i<lon;i++)
{
x1[i]=toupper(p1[i]); // copia en vector letras maysculas

x1[lon]=\0; //para fin de cadena
}
cout<<\n La concatenacin en Maysculas es : <<x1<<endl;
inv=strrev(x1); //para invertir cadena
cout<<\n La cadena invertida en maysculas es: <<inv<<endl;
cout<< \n Uso de for para mostrar invertida (a su original) la cadena. ;
for(i=0;i<lon;i++) {original[lon-i-1]=x1[i];
original[lon]=\0; //para fin de cadena
}
cout<<\n la cadena invertida: <<original;
getch();
}
203
Problema 3. Disear un programa que permita leer una cadena de longitud 30

caracteres (puede incluir espacio en blanco) y luego generar un reporte que a
partir del tercer carcter sean todos expresados en maysculas.
Solucin //cadena1.cpp
voidmain() { char cad1[30] ;int i; clrscr();
cout<<\nIngrese un una cadena:; gets(cad1);
for(i=2;i<=sizeof(cad1);i++)
cad1[i]=toupper(cad1[i]);
cout<<\n Reporte de cadena en minsculas y maysculas:<<cad1;
getche();}
Ejemplo:
Ingrese una cadena:
Lenguaje de programacin
Salida de la cadena en maysculas y minsculas:
leNGUAJES DE PROGRAMACION
4.4 Copia de cadenas: funciones stpcpy(), strcpy(), strncpy()

Para el funcionamiento de estas funciones, se usa la librera: <string.h> las
funciones strcpy() como stpcpy() copian el contenido de una cadena cad2 en una
cadena cad1, de acuerdo a la sintaxis:
char *strcpy(char *cad1, constchar *cad2)
char *stpcpy(char *cad1, constchar *cad2)
La diferencia est en el valor que devuelven como resultado. strcpy() devuelve
un puntero al primer carcter de cad1 y stpcpy() devuelve un puntero al ltimo
carcter de cad1.
La funcin strncpy() funciona igual que strcpy(), con la diferencia de que copia
solo un nmero mximo n de caracteres definidos por el usuario; strncpy no
204
aade al final de cad1 el carcter nulo, por lo que se debe definir para el correcto
funcionamiento del programa.
char *strncpy(char *cad1, constchar *cad2, size_t n)
Problema 1. Disear un programa que permita leer una cadena cad2, de longitud
mxima 50 y luego:
a. Copiar informacin de cad2 en un vector cad1
b. Imprimir a partir del tercer carcter y hasta el final
c. Imprimir solo los tres primeros caracteres
Solucin // cadena3.cpp
void main() {char cad1[40];
char cad2[100];
gotoxy(2,2);cout<<Ingrese una cadena : ;gets(cad2);
strcpy(cad1,cad2); //copia cad2 en cad1
gotoxy(2,4);cout<<Cadena completa :<<cad1;
strncpy(cad1,cad2,12); // solo imprime los primeros 3 caracteres
cad1[3]=\0;
// selecciona los 3 primeros caracteres, el resto es =0
gotoxy(2,6);cout<<Primeros 3 caracteres de cad2 : <<cad1<<endl;
stpcpy(cad1,cad2+3); //impresin a partir del cuarto carcter
gotoxy(2,8);cout<<Impresin a partir del 4 carcter y hasta el final:<<cad1;
getche() ;}
Problema 2. Disear un programa que permita leer una cadena cad1 de longitud
mxima 50 y luego imprimir a partir del octavo carcter. (Use asignacin de
variables tipo cadena).
voidmain()
{ char cad1[10], *cad2, *cad3;
gotoxy(2,2); cout<<ingrese cadena1 :; gets(cad1);
205
cad2=cad1; //Asigna cad1 a cad2

gotoxy(2,4); cout<<valor de cad2, copiado de cad1 :<<cad2<<endl;
cad3=cad1+7; //Asigna a cad3 la cadena cad1 desde su 8 carctergotoxy(2,6);
cout<<\nReporte a partir del 8 carcter: <<cad3<<endl
getche();}
4.5 Funciones para buscar un carcter en una cadena

1. Funcin strchr()
Devuelve un puntero a la cadena que comienza a partir de la primera aparicin
de un carcter especificado en una cadena cad. Devuelve 0 si no se encuentra el
carcter.
2. Funcin strrchr()
Hace lo mismo que strchr, pero busca la ltima aparicin de un carcter c en
lugar de la primera.
Sintaxis:char *strchr(const char *s, int c),
char *strrchr(const char *s, int c);
Problema 1. Disear un programa que permita leer dos cadenas: cad1[50] y
cad2[20] y copiar en cad1 la informacin de cad2. Luego ingresar un carcter
de bsqueda, si el carcter se encuentra en la cadena, este enva el mensaje el
carcter est en la posicin. En otro caso el carcter no se encuentra.
Intmain()
{ char cadena1[20],cadena2[20], *ptr, busca;
cout<<\nIngrese cadena :;gets(cadena2);strcpy(cadena1, cadena2);
cout<<\nIngresecaracter a buscar :;cin>>busca;
ptr = strchr(cadena1, busca); //en ptr almacena toda la cadena a partir de busca
cout<<\ncadena resultante al especificar el carcter de bsqueda :<<ptr<<endl;
cout<<\ntoda la cadena :<<cadena1<<endl;
206
if (ptr)
cout<<\nElcaracter <<busca<< esta en la posicin: <<(ptr-cadena1);
else
cout<<\n El caracter <<busca<< no se encuentra: ;return 0;getche();
}
Problema 2. Disear un programa que permita inicializar una cadena cad[]=

universidad, luego genere reportes para conocer la posicin del primer
carcter i e imprima el resto de la cadena. Asimismo, del segundo carcter i
la posicin y el resto de cadena.
voidmain()
{ charcad[ ]=universidad ;
char *resp;
gotoxy(2,2);cout<<Cadena original: <<cad;
resp=strchr(cad,i);//identifica primer caracter i
gotoxy(2,4);cout<<El 1er i se encuentra en la posicin: <<(resp-cad) ;
gotoxy(2,6);cout<<Cadena resultante = <<resp;
resp=strrchr(cad,i); //identifica segundo caracter i
gotoxy(2,8);cout<<El ultimo i se encuentra en la posicin: <<(resp-cad);
gotoxy(2,10);cout<<Cadena resultante = <<resp;
getche() ;}
207
4.6 Funcin para reconocimiento de una porcin de cadena

1. Funcin strspn()
Localiza la posicin del primer carcter de una cadena cad1, en donde sta difiere
de otra cadena cad2. Devuelve 0 si las cadenas son diferentes desde el principio.
Sintaxis: size_tstrspn(constchar *s1, constchar *s2);
Problema 1. Disear un programa que permita inicializar dos cadenas:
Cad1 = La universidad.Cad2= La un.
Luego genere un reporte de cad1 sin considerar los caracteres que posee cad2.
Solucin//cadena7.cpp
voidmain()
{ char * cad1=La universidad;
char * cad2=La un ;
int p;
p=strspn(cad1,cad2); //p == 5
gotoxy(2,3);
cout<<la segunda cadena
coincide hasta el valor de
:<<p<<endl;
cout<<cad1+p; //Visualiza cadena iversidad
getche() ;
}
2. Funcin strcspn()
Localiza la posicin de la primera aparicin de cualquier carcter de una cadena
cad2 dentro de una cadena cad1.
Sintaxis: size_tstrcspn (const char *s1, const char *s2);
Problema 2. Disear un programa que permita inicializar dos cadenas:
cad1=Los alumnos,estudian c, c++;cad2=,;
Luego genere un reporte de cad1 a partir del carcter idntico de cad2.
voidmain()
{ char *cad1=Los alumnos,estudian c, c++;

char *cad2= , ; // character a identificar en cad1

int p;

p=strcspn(cad1,cad2); //p == 11
cout<<\nLa posicin del carcter idntico esta en=<<p<<endl;

cout<<\nResto de la cadena : <<(cad1+p); getche() ;}
208
3. Funcin strtok()
Permite dividir una cadena cad1en palabras, consideradas unidades sintcticas,
las cuales se encontrarn separadas por caracteres especiales contenidos en otra
cadena cad2.
Sintaxis: char*strtok(char*cad1, constchar*cad2);
Strtok. Coloca un carcter nulo inmediatamente despus del primer token
encontrado en cad1. Por ello, la primera llamada a strtok() deber hacerse con
cad1 como primer argumento y las siguientes con NULL como primer argumento
(esta ltima es una constante definida en stdio.h y su valor es 0).
Strtok(). Devuelve un puntero a la cadena encontrado. Devuelve NULL cuando
ya no encuentran ms caracteres.
Ejemplo 1. Disear un programa para leer cadena1, compuesta por un conjunto
de caracteres y cada palabra(s) separado por comillas, luego leer cadena 2 basado
en el carcter que separa cada palabra (cadena1) mediante el cual, y despus de
este carcter, se insertaren la cadena 3, y finalmente, leer cadena 3 compuesta
por una palabra que ser la que se inserta en la cadena 1 y donde corresponda.
Solucin ///vect_inse.cpp
void main(){ char *p; char cad1[60]; char cad2[60]; char cad3[60];
gotoxy(2,2);cout<<Ingrese cadena 1:;gets(cad1);
gotoxy(2,4);cout<<Ingrese caracter :;gets(cad2); gotoxy(2,6);cout<<Ingrese
cadena 3 :;gets(cad3); gotoxy(2,8); cout<<\n;
p=strtok(cad1,cad2);
while (p)
{ cout<<p<<cad3;
p=strtok(NULL,cad2);
}
getche() ;
}
209
4. Funcin strpbrk()
Devuelve un puntero a una subcadena de cad1, en donde se encuentra la primera
aparicin de un carcter cualquiera, contenido en cad2. Devuelve NULL si no
encuentra ningn carcter.
Sintaxis:
char *strpbrk(constchar *s1, constchar *s2)
Ejemplo 1. Disear un programa que permita buscar, a partir de una cadena 2,

el primer carcter que se inicia con la cadena 1 y luego imprime la subcadena
restante.
Solucin //vect_blanco1.cpp
Voidmain()
{char *cadena1= curso de BorlandC++5.0.2 ;
char *cadena2=s;
char *ptr;
ptr = strpbrk(cadena1, cadena2);
if (ptr)
{ cout<<ptr;
}
getche() ;
}
4.7 Funciones para la comparacin de cadenas

Los operadores <, > o ==, no permiten comparar cadenas, en su lugar hay que
emplear las siguientes funciones:
1. Strcmp()
Compara dos cadenas, su sintaxis es: Intstrcmp(constchar *s1, constchar*s2)
Ejemplo 1. Disear un programa para validad datos de usuario por cdigo y
clave, si el cdigo=8712D y clave=tcn.
Solucin.-//vect_strcmp.cpp
voidmain(){ char
codigo[10],pasw[5];
gotoxy(2,2);cout<<Ingresecodig
o :;
gets(codigo);
gotoxy(2,3);
cout<<Ingresepasword :
;gets(pasw);
if(strcmp(codigo,8712D)==0&&strcmp(pasw,tcn)==0)
210
{ gotoxy(2,5);cout<<Bienvenidos al sistema de Consultas;

}
else
{ gotoxy(2,5);cout<<Error en su entrada a de datos;
} getche();
}
2. Stricmp() y strcmpi()
Comparan dos cadenas, pero sin tomar en cuenta si se comparan letras maysculas
o minsculas.
Sintaxis
int strcmpi(const char *cade1, const char *cad2);
int stricmp(const char *cad1, const char * cad2);
3. Strncmp()
Compara los n primeros caracteres de dos cadenas: intstrncmp(constchar *cad1,
constchar*cad2, size_t n);
4. Strnicmp() y strncmpi()
Hacen lo mismo que strncmp(), pero no toman en cuenta el tamao de las letras.
5. Strcoll()
Hace lo mismo que strcmp(), pero toma en cuenta el juego de caracteres internacionales seleccionado en el sistema operativo.
Estas funciones devuelven un valor entero i tal que:
i>0
i<0
i==0
si cad1>cad22
si cad1<cad2
si cad1i==cad2
Notas
1. El criterio para la desigualdad es comparar las cadenas carcter a carcter, de
acuerdo a su cdigo ASCII.
2. Si el primer carcter de cad1 es mayor que cad2, cad1 es mayor que cad2.
3. Si el primer carcter de cad1 es menor que cad2, cad1 es menor que cad2.
4. Si el primer carcter de cad1 es igual que cad2, se comparan los segundos
caracteres y as sucesivamente hasta encontrar caracteres desiguales o llegar al
final de las cadenas.
5. Las funciones stricmp() y strcmpi() son las mismas; strcmpi se implementa
mediante una macro en el archivo string.h que traduce la llamada desde
strcmpi() a stricmp(). Lo mismo sucede con strncmpi() y strncmpi().
211
Aplicaciones
int c;
c=strcmp(uni,UNI); //devuelve un c>0
c=stricmp(uni,UNI); //devuelve un c==0
c=strcmpi(fiis,uni); //devuelve un c<0;
c=strncmp(uni,uni fiis,3); //devuelve un c==0
Problema 1. Disear un programa que permita leer dos cadenas y luego hacer
una comparacin entre cadenas para obtener una de las siguientes respuestas:
a. Cadena 2 es ms grande que cadena 1
b. Cadena 2 es menor que cadena 1
c. Cadena 2 es igual a cadena 1
Solucin //vect_cad_com.cpp
int main(void)
{// char *cad1 =cordova, *cad2=CORD; puede inicializar para comparar
char cadena1[20],cadena2[20];intptr;
gotoxy(2,2);cout<<Ingrese cadena 1: ; gets(cadena1);
gotoxy(2,3);cout<<Ingrese cadena 2 : ; gets(cadena2);
ptr = strcmpi(cadena2, cadena1);
if (ptr> 0)
{ gotoxy(2,5);
cout<<cadena2 <<cadena2<<es ms grande que cadena1:<<cadena1;
}
else
if (ptr< 0) {gotoxy(2,5);
cout<<cadena2 <<cadena2<< es menor que cadena1 :<<cadena1;
}
elseif (ptr == 0)
{ gotoxy(2,5);
cout<<cadena2 <<cadena2<< es igual a cadena1 <<cadena1;
} getche();}
212
4.8 Transformacin de cadenas

1. Funcin strset()
Convierte todos los caracteres de una cadena s en un carcter especificado.
2. Funcin strnset()
Convierte los n primeros caracteres de una cadena s en un carcter c.
Sintaxis: char *strset(char *s, char c); char *strnset(char *s, char c, int n);
Problema 1. Disear un programa que permita inicializar la cadena:
cad = 848139d es mi Password
Luego genere un reporte :
a. Los primeros seis caracteres de cad reemplazados *.
b. Todos los caracteres de cad reemplazados *
voidmain(){char *cad = 848139d es mi Password ;
strnset(cad,*,6); //convierte a partir de la posicin 6 en *
cout<<\n Solo nmeros en * <<cad<<endl<<endl; //Visualiza ******* es mi
Password
strset(cad,*); // convierte todo en *
cout<<\nToda la cadena en * <<cad;
getch(); }
213
4.9 Funciones para invertir cadenas

1. Funcin strrev()
Invierte los caracteres de una cadena.

char *strrev(char *s)
Problema 1. Disear un programa que permita ingresar una cadena y luego:
a. Convertirlo a maysculas.
b. Mostrarlo en forma invertida segn resultado de a.
Solucin //vect_in_cad1.pp
void main() {char cad[40]; char copia_l[40];
int i;
gotoxy(2,2); cout<< Ingrese cadena :;gets(cad);
for (i=0;i<=sizeof(cad);i++
{copia_l[i]=toupper(cad[i]);
}
gotoxy(2,4);
cout<<Cadena convertida a mayusculas =<<copia_l;
gotoxy(2,6); cout<<La cadena invertida es :<<strrev(copia_l);getche(); }
2. Funcin strxfrm()
3. Funcin strrev()
Invierte los caracteres de una cadena.

char*strrev(char*s)
Convierte una cadena s1 en una cadena igual a la secuencia de primeros n-1
caracteres de s2
Sintaxis: size_tstrxfrm(char*s1, char*s2, size_t n);
Problema 1. Disear un programa que permita inicializar una cadena y luego
mostrar su longitud
214
Solucin //vect_strx_cad.cpp
intmain(void)
{ char *destino;
char *origen = Borlandc++
5.0.2;
intlong;
destino = (char *) calloc(80,
sizeof(char));
longit= strxfrm(destino, origen,
80);gotoxy(2,2);
cout<< La cadena :<<destino<< tiene una longitud :<<longit<<endl <<endl;
system(pause); }
4.10 Conversin a maysculas y minsculas

1. Funcin strupr()
Convierte todos los caracteres de una cadena cad1 a maysculas.
2. Funcin strlwr()
Convierte todos los caracteres de una cadena cad1 a minsculas.
Sintaxis: char *strupr(char *cad1)
char *strlwr(char *cad1)
Problema1. Disear un programa que permita leer una cadena y convertir la

cadena todo a maysculas y todo a minsculas.
Solucin //vect_cad_may_min.cpp
void main() { char cadena[20]; char *mayusc,*minusc; clrscr();
gotoxy(2,2);cout<<Ingrese una cadena :;gets(cadena);
mayusc=strupr(cadena);
gotoxy(2,4);cout<<Cadena en mayusculas :<<mayusc;
minusc=strlwr(cadena); gotoxy(2,6); cout<<Cadena en minuscula: << minusc;
getche() ; }
4.11 Inclusin de una cadena en otra cadena (funcin

strstr())
Devuelve la subcadena contenida en cad1 a partir de la primera aparicin de
cad2 en s1. En caso contrario, devuelve NULL.
Sintaxis: char *strstr(constchar *s1, constchar *s1);
Problema 1. Disear un programa que imprima el resto de la cadena a partir de
una subcadena dada.
215
Solucin //vect_str_str_cad.cpp
void main() { char *cadena = lenguajes Algoritmicos, con diagrama de flujo de
datos ;
char *subcad = con; char *ptr;
ptr=strstr(cadena, subcad);cout<<ptr; getche();}
Aplicaciones
Problema 1. Escribir un programa que permita ordenar una cadena de texto en
base a sus palabras, bajo los siguientes criterios:
1. En orden alfabtico, ascendente y descendente.
2. En orden de tamao, ascendente y descendente.
Adems, que muestre el texto con sus palabras invertidas y el texto con las
palabras en orden invertido del nmero total de palabras.
Solucin//vect_dic_forma
void main() { char frase[80]; int k;
char espacio[]= ;

cout<<Ingrese una cadena: ;cin.getline(frase,sizeof(frase));

//Obtenemos el nmero n de palabras de la frase

char *ptr, aux[80];
strcpy(aux,frase);

int n=0;
ptr=strtok(aux,espacio);

while (ptr) {n++;
ptr=strtok(NULL,espacio);

}
//Ordenar las palabras de la frase

enumTorden {ascendente=1, descendente, longitudasc, longituddes};

//Tipos de ordenacin

char ordenada[80]; //Frase ordenada

int SW; //Bandera para el mtodo de seleccin

for (int o=ascendente; o<=longituddes; o++) {
strcpy(ordenada,frase);
216

for (int i=1; i<=n-1; i++) {

for (int j=i+1; j<=n; j++) {

char *t, *ti, *tj;
strcpy(aux,ordenada);
t=strtok(aux,espacio);

for (int k=1; (k<=i)||(k<=j)&&(t); k++) {

if (i==k) ti=t;
if (j==k) tj=t;
t=strtok(NULL,espacio);
}

switch (o) {

caseascendente:
SW=(strcmp(ti,tj)>0); break;

casedescendente:
SW=(strcmp(ti,tj)<0); break;

caselongitudasc:
SW=(strlen(ti)>strlen(tj)); break;

caselongitudes: SW=(strlen(ti)<strlen(tj)); break;
}

char aux2[80]=;

t = strtok(ordenada, espacio);

for (k=1; t; k++) {
if ((i==k)&&(SW))
strncat(aux2,tj,strlen(tj));

else if ((i==k)&&(!SW))
strncat(aux2,ti,strlen(ti));
if ((j==k)&&(SW))
strncat(aux2,ti,strlen(ti));

else if ((j==k)&&(!SW))
strncat(aux2,tj,strlen(tj));

if ((i!=k)&&(j!=k))strncat(aux2,t,strlen(t)); strcat(aux2, );
t=strtok(NULL,espacio);}
stpcpy(ordenada,aux2);
}
}

switch(o) {
case ascendente:
cout<<endl<<Palabras ordenadas en forma ascendentemente: ;
break;

case descendente:

cout<<endl<<Palabras ordenadas en forma descendentemente: ; break;

caselongitudasc:

cout<<endl<<Palabras ordenadas por tamano ascendente: ; break;
caselongituddes:

cout<<endl<<Palabras ordenadas por tamano descendente: ; break;
}
217
cout<<endl<<ordenada<<endl;
}

cout<<endl<<Palabras escritas al reves<<endl;
strcpy(aux,frase);

while (ptr)
{
cout<<strrev(ptr)<< ;
}
cout<<endl;

cout<<endl<<Palabras de atras hacia delante<<endl;
strcpy(aux,strrev(frase));

while (ptr)
{
cout<<strrev(ptr)<< ;
}
cout<<endl;

cout<<endl<<Total de palabras de la frase: <<n<<endl;
system(pause);
} Salida:
Problema 2. Escribir un programa que elimine los comentarios de una
frase. Llmense comentarios a todo aquello que se encuentre encerrado por
parntesis, por ejemplo la frase:

No me interrumpan (por favor) cuando estoy interrumpiendo
Debe ser convertida en No me interrumpan cuando estoy interrumpiendo

Nota: Considerar que los comentarios se pueden anidar. Por ejemplo: Esta es una
frase (con comentarios (intiles) anidados) completa
Solucin //vect_eli_com.cpp
voidmain() {char frase[80];
char *ptr;

int abrir=0,cerrar=0;
gotoxy(2,2);cout<<Ingrese una frase :;cin.getline(frase,sizeof(frase));

ptr = strchr(frase,();

while (ptr!=NULL) {abrir++;ptr = strchr(ptr+1,();}

ptr = strchr(frase,));

while (ptr!=NULL)
{cerrar++;ptr = strchr(ptr+1,));
}

if (abrir!=cerrar)
{cout<<Error en la frase<<endl;exit(1);
}

int SW, c=1;
218

char res[80];
strcpy(res,frase);

ptr = strchr(res,();

while (ptr) {SW = 0;
c = (ptr-res);

do {
if (res[c]==)) SW--;

else if (res[c]==() SW++;

for(int i=c; i<=strlen(res)-1; i++)

res[i]=res[i+1]; res[strlen(res)]=\0;

} while (SW);

ptr = strchr(res,();
}
gotoxy(2,5);cout<<Frase sin comentarios: <<res;gotoxy(7,8);system(pause);}
COMPENDIO DE PROBLEMAS
Problema 1. Una palabra es anagrama de otra cuando se obtiene una de la otra
por permutacin de sus letras. Por ejemplo:
- pote es anagrama de tope; saco es anagrama de cosa y de ocas.
- porta es anagrama de topar, de tropa y de parto.
Problema 2. Disear un programa que permita leer un texto formado por mas de
tres lneas y luego mostrar el nmero de palabaras que tiene el texto.
Problema 3. Disear un programa que permita leer un texto, luego mostrar la
letra o letras que ms se repiten.
Problema 4. Disear un programa que permita leer un texto y una letra, si la letra
est en el texto eliminarlo, formado por ms de tres lneas y luego mostrar el
nmero de palabaras que tiene el texto.
Escribir un programa que dado un grupo de palabras pueda determinar los
conjuntos de anagramas que existen en ste.
219
220
Captulo 5
Programacin modular
Objetivos
-
-
-
-
-
-
-
Establecer prototipos de funciones.

Definir subprogramas.
Como diferenciar proceso de funcin definida por usuario.
Diferenciar funciones no recursivas de funciones recursivas.
Como crear archivos de cabecera.
Como crear lista de parmetros.
Cuando usar variables globales, locales.
5.1 Introduccin
En el presente captulo, para la solucin de problemas, nos basaremos en las
tcnicas de diseo top-down (de arriba - abajo), tcnicas que permiten organizar
nuestra aplicacin en pequeos mdulos denominados funciones.
El funcionamiento del programa modular se basa en que el programa principal
Llamador, por el nombre de la funcin que realiza una llamada(call), usando
221
el nombre de la funcin, esta procesa sus instrucciones y luego devuelve al

programa principal la tarea realizada por la funcin. En la siguiente figura se
trata de visualizar el funcionamiento respectivo.
Asimismo, existe el concepto de procedimientos (proceso), en el cual no se
especifica el tipo de dato a devolver.
5.2 Funciones definidas por el usuario

En C++, las funciones pueden establecer el concepto de programacin modular,
para lo cual cada programa debe tener una sola funcin externa denominada
main().
El formato general de una funcin en C es:
Tipo_dato_devuelto Nombre_funcion(lista_de_parmetros){variables locales
<cuerpo de la funcin>
}
ElTipo_dato_devuelto. Indica el tipo del valor que la funcin devolver mediante
el uso de return. El valor puede ser de cualquier tipo vlido. Si no se especifica un
valor, entonces la computadora asume por defecto que la funcin devolver un
resultado entero. No se tienen siempre que incluir parmetros en una funcin. La
lista de parmetros puede estar vaca. Se ilustra a continuacin un ejemplo que
encuentra el promedio de dos enteros:
float prom(int num1, int num2)
{ float promed;
promed = (num1 + num2) / 2.0; return(promed);
}
void main(){ int a=10, b=13; float respuesta;
respuesta=prom(a, b);
gotoxy(4,10);cout<<Promedio=<<respuesta; getche();}
222
Las funciones terminan y regresan automticamente al procedimiento que las

llam cuando se encuentra la ltima llave }, o bien, se puede forzar el regreso
antes, usando la sentencia return. Adems del uso sealado, la funcin return se
usa para devolver un valor.
Las funciones se declaran en cabeceras (estndar o especficas de usuario) o
dentro de los ficheros fuente.Estos tipos de declaraciones se les denomina:
Prototipos de funciones.Con frecuencia la declaracin y definicin se realiza
en el mismo punto, pero es estratgico usar al principio del programa los
prototipos de las funciones que sern utilizadas en su interior, y las definiciones
o implementaciones en cualquier otro sitio. Veremos primero la sintaxis y luego
la teora y finalmente sus diversas aplicaciones.
// 1. Declaracin de libreras
................................
// 2. Declaracin de prototipo de funciones
Tipo_dato_devuelto Nombre_funcion (lista de argumentos) ;
.
// 3. Declaracin de variables globales
// 4. Declaracin de constantes globales
// 5. Definicin o implementacin de las funciones prototipos
Tipo_dato_devuelto Nombre_funcion(lista de argumentos)

{ <declaracin de variables totales>;

< Cuerpo de la funcin >;
}
// 6. Programa (funcin) principal
Tipo_dato_devuelto main() l
{ // llamadas a las funciones por su nombre
}
Observacin. El programa principal puede definirlo a continuacin de los
prototipos de funciones.
Partes de la definicin:
1. Una funcin tiene un nico nombre, al utilizar este nombre en otras partes del
programa se pueden ejecutar los enunciados contenidos en la funcin. A esto
se le conoce como llamara la funcin. Una funcin puede ser llamada desde
otra funcin, esta tcnica define el anidamiento de funciones.
floatdatos( )
nico nombre de la funcin
223
2. Una funcin es independiente. Una funcin puede ejecutar sus tareas sin
interferencia en o de otras partes del programa.
float cuadrado (float x)
{ int x;
float resp;
if (x!=0) resp=1/x; return resp;
}
3. Una funcin ejecuta una tarea especfica. Esta es la parte fcil de la definicin.
Una tarea es un conjunto de instrucciones definido por el programador.
4. Una funcin opcionalmente devuelve un solo valor o ninguno al programa que
la llam. Cuando un programa llama a una funcin se ejecutan los enunciados
contenidos en sta, si elprograma lo requiere, stos enunciados pueden
devolver un valor al programa que llam a la funcin. Debe usar la instruccin
return (cuando no devuelve ningn valor) return (valor_a_devolver) cuando
la funcin devuelve un valor especificado por el programador.
Tipos devueltos:
1. Pueden ser: float, int, etc.
Floatcalcular( ): la funcin calcular(), devuelve un tipo de dato real.
Intfactorial(int n): la funcin factorial(int n), devuelve un tipo de dato entero.
2. Puede devolver:void es una funcin que no devuelve ningn valor.
5.3 Declaracin y definicin de funciones

Para utilizar una funcin en un programa se requiere en primer lugar declararla
y despus definirla. La declaracin de la funcin le indica al compilador el
nombre, el tipo de dato devuelto por la funcin y los parmetros pasados a la
funcin. A la declaracin de una funcin se le llama tambin el prototipo de la
funcin.
El prototipo de una funcin provee al compilador con informacin de una funcin
que ser definida posteriormente en el programa. El prototipo incluye, en este
orden, el tipo de valor que la funcin devolver, el nombre de la funcin, el cual
debe ser significativo del trabajo realizado por la funcin y el tipo de variables
utilizadas como argumentos que sern pasados a la funcin, siempre termina en
punto y coma ;.
La definicin de una funcin es en s la funcin misma, est compuesta en su
primera lnea de cdigo por el encabezado, que debe ser idntico al prototipo de la
funcin, pero en ste caso no se utiliza el punto y coma, adems, al contrario del
prototipo, donde es opcional incluir el nombre de las variables utilizadas como
argumentos, en el encabezado de la funcin se debe incluir el nombre de las
variables, despus del nombre no asignar punto y coma ; .
224
5.4 Lista de parmetros y sus tipos de datos

Las palabras parmetro y argumento, aunque de significado similar, tiene distintas
interpretaciones semnticas, veamos: se denominan parmetros a los objetos
declarados en el prototipo (que deben corresponder con la definicin). Cuando se
realiza una llamada a la funcin, los valores pasados se denominan argumentos.
Con frecuencia se utilizan tambin las expresiones argumentos formales, para los
parmetros y argumentos actuales o ficticios para los valores pasados.
Parmetros (establecidos en prototipo o definicin) argumentos formales
Valores pasados (en tiempo de ejecucin) argumentos actuales
Tipo 1. Funciones sin lista de parmetros y su valor devuelto

Como prototipo:
Tipo_dato_devuelto Nombre_funcin ( ); //sin lista de argumentos
Como definicin:
Tipo_dato_devuelto Nombre_funcin ( )
{ <instr>; return;}
Tipo 2. Funciones con lista de argumentos y su valor devuelto

Sintaxis.
Como prototipo:
Tipo_dato_devuelto Nombre_funcin (lista_de_argumentos);
Como definicin:
Tipo_dato_devuelto Nombre_funcin (lista_de_argumentos)
{ <instr> ;
return;
}
donde la lista_de_argumentos, puede ser: un dato simple, un vector o matriz, un
puntero, cadenas, etc. En los dos ejemplos siguientes, se ilustra la aplicacin de la
teora y su explicacin respectiva.
que contenga dos funciones:
resta(arg1,arg2): permite calcular la
resta de dos nmeros enteros.
multiplica(arg1,arg2): permite calcular
el producto de dos nmeros enteros.
Luego, desde el programa principal
leer los dos nmeros y estos pasarlos
como parmetros de las funciones
invocadas para que realicen sus tareas.
Solucin // func_arit.cpp
225
void resta(int , int ); // Prototipo de funciones
int multiplica(int, int);
int num1, num2, resultado;
void resta(int a, int b)
{ int restan;
// variable local
restan=a-b;
gotoxy(3,7);
cout<<La resta de <<a<< - <<b<< es = <<restan<< endl;
}
int multiplica(int a, int b)
{ int producto; // variable local
producto = a *b; return producto;}
int main() // Funcin principal
{ gotoxy(3,2); cout << Ingrese 2 numeros : << endl;
gotoxy(3,4); cout<<Ingrese numero 1 = ; cin >> num1;
gotoxy(3,5); cout<<Ingrese numero 2 = ; cin >> num2;
resta(num1, num2); // llama a la funcin resta
resultado = multiplica(num1, num2); gotoxy(3,9);
cout<<El producto de <<num1<< * <<num2<< es = <<resultado<<endl;
getche();}
5.5 Variables locales y globales: mbito de un identificador

C++ permite declarar variables en cualquier parte del cdigo fuente. Ademsde
pasar variables como parte del argumento de una funcin.
Un identificador es local. Cuando est definido dentro del cuerpo de una
funcin, a este tipo de variables se les denomina locales, ya que slo son tiles
dentro del cuerpo de la funcin.
Un identificador es global. Cuando estn definidas fuera del bloque ofuera del
cuerpo de cualquier funcin.
Estas variables estn disponibles para cualquier funcin del programa,
incluyendo a main( ). Las variables locales que tienen el mismo nombre que las
variables globales no cambian el valor de las globales, sin embargo una variable
local con el mismo nombre que una variable global oculta a la variable global.
Observacin. Las variables globales, se inicializan automticamente en cero (0),
las locales no.
Nota. Evitaremos el uso de variables globales y de nombres de variable duplicados
(efectos colaterales).
226
Ejemplo
int multiplica(int valor1, int valor2)
{int productol; // variable local
producto = valor1 * valor2; return producto;}
Los parmetros de la funcin, son de tipo int, llamados valor1 y valor2, son en
efecto variables de alcance local,al igual que la variable declarada como de tipo
int, llamada producto dentro del cuerpo de la funcin multiplica( ). El alcance
de una variable es simplemente el espacio dentro del cdigo fuente donde la
variable puede ser utilizada, generalmente ste espacio est limitado por el par
de llaves que sirven para encerrar las instrucciones queconforman una funcin.
5.6 Parmetros por defecto

Un valor por defecto es el valor a utilizar en caso de que ninguno sea especificado,
as, una declaracin de una funcin podra ser esta:
float facto(int dato_defecto=43);
En ste ejemplo se declara una funcin llamada facto() que toma un parmetro
de tipo int, pero en caso de que no se incluya el parmetro necesario, entonces se
utilizar el valor de 43 para ser utilizado por la funcin.
Tambin, como no es absolutamente necesario utilizar nombres para los
parmetros en el prototipo de una funcin, tambin podemos escribir la
declaracin de una funcin de la siguiente manera:
float facto (int = 43);
Paso de parmetros valor y por referencia:

Paso de parmetros por referencia
Procedimiento para que la funcin pueda modificar el valor de las variables. Una
variable consta, adems de su nombre, tipo y valor, de una direccin de memoria
en la que se ubica (valor numrico).
Para extraer la direccin de memoria asociada a una variable utilizaremos el
operador & antepuesto a su nombre.
Para extraer el contenido de una direccin de memoria, se usa el operador *
antepuesto a su nombre.
Un puntero es una variable que almacena una direccin de memoria
independientemente de lo que sta contenga.
Para realizar el paso de parmetros por referencia utilizaremos punteros.
En la cabecera se especifica cada parmetro por referencia con el operador *
Dentro de la funcin, cambiaremos el contenido de cada variable con *.
227
En la llamada a la funcin use el operador & para extraer la direccin de las

variables.
Problema 1. Disear un programa que permita leer un nmero entero y luego
ste debe pasar como parmetro en una funcin sumando() y transformarlo
aumentando la unidad al valor ingresado.
Solucin //func_pasa_para.cpp
void sumando(int *dato)
{ *dato= *dato+ 1; return ;
}
void main(void)
{int valor_inicial;
gotoxy(3,3); cout<<Favor ingrese un
numero : ;;cin>>valor_inicial;
sumando(&valor_inicial );
gotoxy(4,5);cout<<Nuevo valor <<valor_inicial;getche();}
Respecto al tratamiento de cadenas de caracteres son de por s punteros. Siempre
se pasan por referencia sin necesidad del operador & ni del puntero *.
Problema 2. Disear un programa que permita leer una cadena y pasarlo como
parmetro de una funcin Palabra_Mayusculas( ) y luego devuelve la cadena
expresada en letras maysculas.
Solucin //func_mayusc.cpp
void Palabra_Mayusculas(char cadena[])
{ for(i=0;i<strlen(cadena);i++)
{ if(cadena[i]>=a && cadena[i]<=z)
{cadena[i]=cadena[i]-a+A;
}
}
return;}
void main(void)
{char cad[255];gotoxy(3,3);cout<<Introduzca cadena: ; scanf(%s,cad);
Palabra_Mayusculas(cad);
gotoxy(3,5);cout<<La cadena en mayusculas es = <<cad; return;getche();
}
228
Problema 3. Disear un programa, usando funciones, que permita calcular la

suma acumulada de la serie: =1/2 + 2/3 + 3/4+..........+n/(n+1). El usuario ingresa el
nmero de trminos de la serie a sumar.
Solucin //func_do_while.cpp
void leer();float sumatoria(); void imprimir(); int n;
void leer(){gotoxy(2,3);cout<<Ingrese numero de terminos de la serie:;cin>>n;
}
float sumatoria()
{ int i=1; float s=0;
do {s=s+float(i)/(i+1);
i++;
} while(i<=n);
return (s); }
void imprimir()
{gotoxy(2,5);
cout<< La suma es = <<sumatoria();}
void main()
{ leer();sumatoria();imprimir();getche();
}
Problema 4. Disear un programa, usando funciones, que permita ingresar la
hora y los minutos, luego mostrarlo en los siguientes formatos:
Formato 1: 14:45
Formato 2: 2:45 PM
Solucin // func_hora.cpp
# include <iostrea.h>
void lectura(int h,int m);
void transformacion(char cad[1],int
h);
void Salida(int h,int m);
void main(){ char cad[1];
int
m,h;clrscr();
gotoxy(2,2);cout<<Bienvenidos
a
conocer los formatos del Tiempo ;
gotoxy(2,4);cout <<Ingrese la hora :
;cin >>h;
gotoxy(2,5);cout <<Ingrese minutos
: ;cin>>m;
lectura(h,m);
transformacion(cad,h);
Salida(h,m);getch();
}
229
void lectura(int h,int m)

{gotoxy(2,7);cout << La Entrada es:
<< << h << :<<m;
}
void transformacion(char cad[1],int
h)
{ if(h>12) {h=h-12;strcpy(cad,PM);
}
else strcpy(cad,AM);
}
void Salida(int h,int m)
{char cad[1];
if (h > 12)
{h=h-12;strcpy(cad,PM);
}
else
strcpy(cad,AM);
gotoxy(2,8); cout<< Otro formato : <<h<<:<< m << <<cad ;}
Problema 5. Disear un programa que permita ingresar la cantida de nmeros
enteros y luego para cada nmero ingresado, mostrar su cantidad de dgitos.
Solucin //func_for_digitos1.cpp
void leerd();
void procesar(int );
int m, b,nd=0,d,r,n,a;
void leerd() {cout<< Ingrese cantidad de numeros :; cin>>n;}
void procesar(int n)
{ for(int i=1;i<=n;i++)
{ cout<<\nIngrese numero <<i<< : ; cin>>r;

m=r; // en m cargo el nmero de entrada
nd=0;// inicializo contador de dgitos
while(m>0) // descompongo el nmero m ingresado
{d=m%10;
nd=nd+1;
m=m/10
}
cout<< El numero de
entrada <<r<< tiene:
<<nd<< digitos<<endl; }
}
void main( )
{ leerd(); procesar(n);
getche();
}
230
Problema 6. Disear un programa que permita mostrar la suma acumulada de la

serie 1: 1+1/2*2+1/3*3+...+1/n*n o la suma acumulada del cudradado de la serie
2: 1 + 2 + 3 +..........+n.
Para cada caso, el usuario ingresar el nmero de trminos de la serie a sumar.
Solucin. // funcio_inv1.cpp
double suma_inversa(int valor);
double serie_cuadrado(int valor);
int numterm,opcion,i;double suma=0,
suma_temp;
double suma_inversa(int valor)
{ return pow(valor,-1);
}
double serie_cuadrado(int valor)
{return pow(valor,2);
}
void main ()
{ gotoxy(2,3);cout<<Ingrese el numero de terminos a sumar: ;cin>>numterm;

gotoxy(2,5);cout<< < 1 > : Suma de inversas ;

gotoxy(2,6);cout<< < 2 > : Suma de cuadrados;

gotoxy(2,8);cout<<Ingrese opcion :;cin>>opcion;
switch (opcion)
{case 1:
for (i=1;i<=numterm;i++)

{ suma_temp=suma_inversa(i*i);

suma=suma+suma_temp;
}
break;
case 2: for (i=1;i<=numterm;i++)

{ suma_temp=serie_cuadrado(i);

suma+=suma_temp;
}
break;}
gotoxy(2,10); cout<<La suma de la serie es: << suma; getche();}
que permita elevar a la potencia un
nmero ingresado como base. Mostrar
el reporte respectivo.
Solucin // funcio_inv1.cpp
void leerd(); int proceso();
void reporte();
int pot,base,poten;
231
void leerd()
{gotoxy(2,3);
cout<<Ingrese la base : ; cin>>base;
gotoxy(2,4);cout<<Ingrese la Potencia : ; cin>>pot; }
int proceso()
{poten=pow(base,pot); return poten;
}
void reporte()
{ gotoxy(3,6);cout<<El numero <<base<< elevado al <<pot<< es =
<<proceso();}
void main()
{leerd(); proceso();
reporte(); getche();}
Problema 8. Disear un programa que permita leer un nmero entero positivo y
luego calcular su factorial.
Solucin // func_fact.cpp
void leernum ();
void imprimir();
int n,facto=1; float fact ();
void leernum ()
{ do
{ gotoxy(2,5);clreol(); cout<< Ingrese un numero=;cin>>n ;
}while (n<0);}
float fact()
{ int i;
for(i=1;i<=n;i++)
{ facto=facto*i;
}
return (facto);
}
void imprimir ()
{gotoxy(2,7);
cout << El factorial de <<n<< es = <<facto;
}
void main()
{ gotoxy(4,2);cout<<FACTORIAL DE UN NUMERO ;
leernum (); fact(); imprimir(); getche();
}
Problema 9. Disear un programa que permita leer el rango de una matriz A y
luego:
232
a. Leer y mostrar los elementos de la matriz A

b. Mostrar la suma acumulada de los elementos diagonales
c. El resultado de parte b) sirve como parmetro de la funcin totald( ), que calcula el total de dgitos que tiene el resultado de la suma diagonal
d. Leer los elementos de la matriz B y mostrar la suma de las dos matrices
Solucin // func_matriz.cpp
# define max_el 50
int a[max_el][max_el], b[max_el][max_el], c[max_el][max_el] ,n,suma=0,d;
void LeeMatriz ( int [max_el][max_el], int );
void imprimirm( int m[max_el][max_el], int r);
int sumadiag( int m[max_el][max_el], int r);
int totald(int );
int sumamatriz(int a[max_el][max_el],int b[max_el][max_el],int c[max_el][max_
el], int n);
void LeeMatriz(int m[max_el][max_el], int r)
{ int i, j;
for( i= 1 ;i<=r;i++)
for (j= 1 ;j<=r;j++ )
{ cout<<m[<<i<<,<<j<<]=; cin>>m[i][j]; }clrscr();
}
void imprimirm(int m[max_el][max_el], int r)
{ int i, j;
for( i= 1 ;i<=r;i++)
for (j= 1 ;j<=r;j++ )
{ gotoxy(10+i-1,3*i+j);
cout<<m[<<i<<,<<j<<]=<<m[i][j];
} }
int sumadiag(int m[max_el][max_el], int r)
{ int i, j;
for( i=1;i<=r;i++)
for (j=1;j<=r;j++ )
if(i==j) {suma=suma+ m[i][j];
}
cout<<\nLa suma diagonal es= <<suma<<endl;
return 0;
}
int totald(int suma)
{ int td=0;

int dato=suma;
while(dato>0)
{d=dato%10;
td++;
dato=dato/10;
}
233
cout<<\nEl numero <<suma<< tiene << td << digitos <<endl;

return 0;
}
int sumamatriz(int a[max_el][max_el], int b[max_el][max_el], int c[max_el]
[max_el], int r )
{ int i, j;
cout<<\nSumando dos matrices A+B se obtiene <<endl;
for( i= 1 ;i<=r;i++)

for (j= 1 ;j<=r;j++ )
{
c[i][j]=a[i][j]+b[i][j];
}
return 0;
}
void main()
{ gotoxy(2,1);cout<<\nIngrese orden de la matriz :; cin>>n;
LeeMatriz(a,n);
cout<<\nElementos de la matriz A: <<endl;
imprimirm(a, n); cout<<\n;
sumadiag(a,n);totald(suma);
cout<<\nElementos de la matriz B: <<endl;
LeeMatriz(b,n); sumamatriz(a,b,c,n);imprimirm(c,n);getche();}
Problema 10. Disear un programa que permita almacenar en una matriz de

orden n*m caracteres de a. .z y luego mostrar el nmero de veces que se forma
la palabra peru (slo en letras minsculas). Considere que la palabra(s) se
forma:
-
-
-
-
En los elementos diagonales

Se pueden leer en columnas de arriba hacia abajo y viceversa
Se pueden leer en filas de izquierda a derecha y viceversa
Una letra puede servir para formar varias palabras
Solucin //func_matriz_peru.cpp
234
# define max_l 50
void case1(); void case2(); void case3();
void case4(); void case5(); void case6();
void case7(); void case8();
int peru=0, m,n,i,j,t;char A[max_l][max_l][1];
void main()
{clrscr();
/* Se usa la variable de estado t para que informe lo siguiente:
Si t=0 no esta tratando de formar una palabra y
Si t=1 se esta tratando de formar la palabra PERU*/
cout<<\n\tIngrese la cantidad de filas : ; cin>>n;
cout<<\n\tIngrese la cantidad de columnas : ; cin>>m;
cout<<\n\tIngrese los datos de la matriz ;
for(i=1;i<=n;i++){
for(j=1;j<=m;j++){

gotoxy(10+2*j,7+i); cin>>A[i][j];
} }
/*Comparo con las letra p y dependiendeo del caso llamo a una funcion
que cumple con los requerimientos*/
for(i=1;i<=n;i++){
for(j=1;j<=m;j++){

if((A[i][j-1][1]==p)||(A[i+3][j-1][1]==P)){

if(((i+3)<=n)&&((j-3)>0))
case1();
if(((i+3)<=n)&&((j+3)<=m)) case2();
if(((i-3)> 0)&&((j-3)> 0))
case3();
if((j+3)<=m)

case4();
if((j-3)>0)
case5();
if(((i-3)>0)&&((j+3)<=m)) case6();
if((i+3)<=n)

case7();
if((i-3)>0)
case8();
}
}
}
gotoxy(4,13);cout<<La palabra PERU, se repite <<peru<< veces ;
getch();}
void case1(
){

if((A[i+1][j-1-1][1]==e)||(A[i+1][j-1-1][1]==E)){

if((A[i+2][j-2-1][1]==r)||(A[i+2][j-2-1][1]==R)){

if((A[i+3][j-3-1][1]==u)||(A[i+3][j-3-1][1]==U)){
peru=peru+1;
}
} }}
void case2(){

if((A[i+1][j+1-1][1]==e)||(A[i+1][j+1-1][1]==E)){

if((A[i+2][j+2-1][1]==r)||(A[i+2][j+2-1][1]==R)){
235

i f ( ( A [ i + 3 ] [ j + 3 - 1 ]
[1]==u)||(A[i+3][j+3-1][1]==U)){
peru=peru+1;
} } }}
void case3(){

i f ( ( A [ i - 1 ] [ j - 1 - 1 ]
[1]==e)||(A[i-1][j-1-1][1]==E)){

i f ( ( A [ i - 2 ] [ j - 2 - 1 ]
[1]==r)||(A[i-2][j-2-1][1]==R)){

i f ( ( A [ i - 3 ] [ j - 3 - 1 ]
[1]==u)||(A[i-3][j-3-1][1]==U)){
peru=peru+1;
}
} } }
void case4(){

if((A[i][j+1-1][1]==e)||(A[i]
[j+1-1][1]==E)){

if((A[i][j+2-1][1]==r)||(A[i][j+2-1][1]==R)){

if((A[i][j+3-1][1]==u)||(A[i][j+3-1][1]==U)){
peru=peru+1;
} } } }
void case5(){

if((A[i][j-1-1][1]==e)||(A[i][j-1-1][1]==E)){

if((A[i][j-2-1][1]==r)||(A[i][j-2-1][1]==R)){

if((A[i][j-3-1][1]==u)||(A[i][j-3-1][1]==U)){
peru=peru+1;
}
} }
}
void case6(){

if((A[i-1][j+1-1][1]==e)||(A[i-1][j+1-1][1]==E)){

if((A[i-2][j+2-1][1]==r)||(A[i-2][j+2-1][1]==R)){

if((A[i-3][j+3-1][1]==u)||(A[i-3][j+3-1][1]==U)){
peru=peru+1;
}
} }
}
void case7(){

if((A[i+1][j-1][1]==e)||(A[i+1][j-1][1]==E)){

if((A[i+2][j-1][1]==r)||(A[i+2][j-1][1]==R)){

if((A[i+3][j-1][1]==u)||(A[i+3][j-1][1]==U)){
peru=peru+1;
}
} }}
void case8(){
if((A[i-1][j-1][1]==e)||(A[i-1][j-1][1]==E))
{ if((A[i-2][j-1][1]==r)||(A[i-2][j-1][1]==R))
{ if((A[i-3][j-1][1]==u)||(A[i-3][j-1][1]==U))
236
{ peru=peru+1;
}
}
}
}
Problema 11. Disear un programa que permita mostrar la suma acumulada de
la serie 1+2+3+4+....+n. El usuario edita el primer trmino de la serie (ldi) y luego
edita el lado derecho (ldd: hasta donde desea sumar).
Solucin // func_suma_ser.cpp
void leerd(); void suma_r(); void imprimir();
int ldi,ldd,suma=0,rldi;
void leerd()

{ gotoxy(2,4);cout<<Ingrese lado izquierdo :;cin>>ldi;
gotoxy(2,5);cout<<Ingrese lado derecho :;cin>>ldd;
}
void suma_r()

{ rldi=ldi; while(ldi<=ldd)
{ suma=suma+ldi; ldi=ldi+1;}
}
void imprimir()
{gotoxy(2,7);cout<<La suma desde <<rldi<< hasta <<ldd << es = <<suma;
}
void main() {gotoxy(2,2);cout<< Suma de Serie: 1 + 2 + 3 + 4 +...+ n :;
leerd(); suma_r(); imprimir(); getche();}
Problema 12. Disear un programa que permita ingresar un nmero entero como
cadena (ejemplo num=432), luego convertir esta cadena numrica a nmero
entero y elevar al cubo el segundo dgito.
Solucin ///func_dig_cub.cpp
void leerd (); int procesar(); void reporte();
int n,n1,n2,p;char num[3];
void leerd()
237
{gotoxy(2,2);cout<<ingrese un nmero de tres dgitos en cadena

numerica:;gets(num);}
int procesar ()
{ n=atoi(num); //convertir una cadena entera a numero
n1=n/10; n2=n1%10;p=pow(n2,3); return p; }
void reporte()
{ gotoxy(2,4);cout<<El dgito <<n2<< elevado al cubo es =<<procesar();
}
void main()
{leerd(); procesar(); reporte();
getche();
}
Problema 13. Disear un programa que permita ingresar elementos de tipo

enteros a un vector de longitud n (n definido por el usuario) y luego mostrar el
total de:
a. Elementos postivos
c. Elementos negativo
b. Elementos nulos
d. Total de elementos del vector
Solucin //func_pos_neg.cpp
void marco(); //genera un Marco(ventana)
void leer(int n,int Vec[10]);
int contador(int n,int Vec[]);
int posit=0,nulos=0,negat=0,n,Vec[10],totalel=0;
void marco()
{ int i;
for(i=1;i<=60;i++) //diseo de las filas
{gotoxy(8+i,2);cout<<_;
gotoxy(8+i,18);cout<<_; }
for(i=1;i<=16;i++) //diseo de las columnas
{gotoxy(8,2+i);cout<<|;
gotoxy(68,2+i);cout<<|; }
}
void leer(int n,int Vec [10])
{int i;
for(i=1;i<=n;i++) { gotoxy(13,5+i);cout<<v[<<i<<]=; cin>>Vec[i];
}
238
}
int contador (int n, int Vec[10])
{ int i;
for(i=1; i<=n; i++)
{ if (Vec[i]>0) { posit++;
}
else { if(Vec[i]==0)
{ nulos++; }
else

{negat++; }
}
}
totalel=totalel+posit+nulos+negat;re
turn 0;
}
void main()
{ marco(); gotoxy(12,5); cout<<Ingrese el tamao del vector:; cin>>n;
leer(n,Vec); contador(n,Vec);
gotoxy(12,12);cout<<Total positivos = <<posit;
gotoxy(12,13);cout<<Total nulos = <<nulos;
gotoxy(12,14);cout<<Total negativos = <<negat;
gotoxy(12,16);cout<<Total elementos = <<totalel;getche();}
columnas de dos matriz A y B, luego almacenar datos de tipo entero y con estos
datos mostrar:
a. Elementos de las matrices A y B
b. Almacenar en una matriz C, la suma de las dos matrices: A+B
c. Mostrar en forma invertida cada elemento de la matriz C
Solucin // func_mat_inv.cpp
#define max_f 30
#define max_c 30
#define linea -----------------------------------------------------------------
void leerd ();int procesar();void reporte();
int a[max_f][max_c],b[max_f][max_c],d[max_f][max_c],t[max_f][max_c],
di[max_f][max_c],inv[max_f][max_c],f,c,i,j;
void leerd()
{cout<<Ingrese total de filas : ;cin>>f;
cout<<Ingrese total de columnas : ;cin>>c;
cout<<linea;
for(i=1;i<=f;i++)
for(j=1;j<=c;j++)
{gotoxy(18,4);cout<<Matriz A;
gotoxy(10*j,5+2*i);cout<<a[<<i<<,<<j<<]=;
cin>>a[i][j];cout<<endl;
239
}
gotoxy(35,4);cout<<+;
for(i=1;i<=f;i++)
for(j=1;j<=c;j++)
{ gotoxy(48,4);cout<< Matriz B;
gotoxy(30+10*j,5+2*i);cout<<b[<<i<<,<<j<<]=;
cin>>b[i][j];cout<<endl;
}
}
int procesar ()
{ for(i=1;i<=f;i++)
for(j=1;j<=c;j++)
{ d[i][j]=a[i][j]+b[i][j]; t[i][j]=d[i][j];
while(d[i][j]>0)

{ di[i][j]=d[i][j]%10; inv[i][j]=inv[i][j]*10+di[i][j]; d[i][j]=d[i][j]/10; } }
return 0;
}
void reporte()
{ gotoxy(8,16);cout<< Suma de Matriz C ;
for(i=1;i<=f;i++)
for(j=1;j<=c;j++)
{gotoxy(10*j,16+2*i);cout<<d[<<i<<,<<j<<]=<<t[i][j];cout<<endl;
}
gotoxy(40,16);cout<<Elementos invertidos de matriz c:;
for(i=1;i<=f;i++)
for(j=1;j<=c;j++)
{gotoxy(35+10*j,16+2*i);cout<<d[<<i<<,<<j<<]=<<inv[i][j];cout<<endl;}
getche();
}
void main()
{leerd();
procesar();
reporte(); getche();}
}
240
Problema 15. Disear un programa que permita leer cantidad de nmeros

enteros y luego estos nmeros encryptar (reemplzar cada nmero por*) y
mostrar en una primera lnea los nmeros impares encryptados y en una segunda
lnea mostrar los nmeros pares encryptados. Asimismo, mostar los nmeros
ordenados, primero los impares en forma ascendente y, a continuacin, los pares
en forma descendente.
Observacin. Primero ingresar nmeros impares y luego los pares.
Solucin //func_encrypta1.cpp
#include <fstream.h>
void Burbuja(int mat[30],int m)
{
int i,j,temp;
for(i=0;i<m-1;i++)
for(j=i+1;j<m;j++)
if(mat[i]>mat[j])
{temp=mat[i];mat[i]=mat[j]; mat[j]=temp;
}
}
void main() { int i,n,A[30],m_orden[30],resp[30];
bool
clrscr();
cout<<\n\tIngrese cantidad de numeros a Encryptar ;cin>>n;
//en un arreglo se indican las posiciones: si es impar sera false
//si es par sera true
for(i=0;i<n;i++)
{gotoxy(14+4*i,6);cin>>A[i];
if(A[i]%2!=0) //si es impar
Orden[i]=false;
else
//si es impar
Orden[i]=true;m_orden[i]=A[i];//
}//hacemos marcar ubicacin de nmeros pares e impares
gotoxy(2,8);cout<<Impares : ;
gotoxy(2,9);cout<<Pares : ;
for(i=0;i<n;i++){if(Orden[i]==false)
{gotoxy(14+4*i,8);
cout<<*;
}
else
{ gotoxy(14+4*i,9);
cout<<*;
}
}
//se ordenan los elementos del arreglo AEspejo
Burbuja(m_orden,n);
int a=0; //sera el indice de los impares
int b=n-1;
//sera el indice de los pares
for(i=0;i<n;i++)
{ if(m_orden[i]%2!=0)//si es impar

{ while(Orden[a]==true)
Orden[30];
241

{
a++;
}
resp[a]=m_orden[i];
a++;
}
else {while(Orden[b]==false)
{b--;
}
resp[b]=m_orden[i];
b--;
}
}
gotoxy(2,11);cout<<\n\n\nResultado : ;
for(i=0;i<n;i++){gotoxy(14+4*i,14);cout<<resp[i];}getch();}
Problema 16. Disear un programa que permita encontrar todas las soluciones
para la relacin: SEND + MORE = MONEY.
Solucin //func_send_more.cpp
int buscando(int t);
void main(){ int o,f,i,c,e,m,n,d,s,w,r,a,b;
for(o=1;o<=9;o++)
{ for(f=0;f<=9;f++)
{ for(i=0;i<=9;i++)
{ for(c=0;c<=9;c++)
{ for(e=0;e<=9;e++)
{ for(m=1;m<=9;m++)
{ for(n=0;n<=9;n++)
{ for(d=0;d<=9;d++)
{ for(s=0;s<=9;s++)
{ for(w=1;w<=9;w++)
{ for(r=0;r<=9;r++)
{ a= o*10*10*10*10*10 + f*10*10*10*10 + f*10*10*10 + i*10*10 + c*10 + e ;
b=m*10*10*10*10*10 + s*10*10*10*10 + w*10*10*10 + o*10*10 + r*10 + d ;
242
if(a+b== w*10*10*10*10*10*10 + i*10*10*10*10*10 + n*10*10*10*10 + d*10*10*10

+ o*10*10 + w*10 + s )
{ if(buscando(c)==1)
{ cout<<o:<<o<<endl; cout<<f:<<f<<endl;
cout<<i:<<i<<endl; cout<<c:<<c<<endl;
cout<<e:<<e<<endl; cout<<m:<<m<<endl;
cout<<n:<<n<<endl; cout<<d:<<d<<endl;
cout<<w:<<w<<endl; cout<<r:<<r<<endl<<endl<<endl;
printf(\n%i+\n%i\n----------\n
%i\n,a,b,w*10*10*10*10*10*10+ i*10*10*10*10*10 + n*10*10*10*10 + d*10*10*10 +
o*10*10 + w*10 + s );
}
} } } } } } } } } } } }getch();}
int buscando(int t)
{ int i,u=1;
for(i=2;i<t;i++) { if(t%i==0)
{ u=0; break;
} }
return (u);
}
Problema 17. Cierto cajero automtico realiza transacciones sobre una determinada
cuenta corriente. Para acceder a dicha cuenta se debe introducir un cdigo y una
contrasea. Asumamos que el cdigo de un usuario es TLCN y su contrasea
es 1234. El cajero permitir el ingreso slo si se ingresan correctamente estos
datos, caso contrario, puede dar hasta tres intentos en total, para acceder al
sistema. Una vez dentro del mismo, se podrn realizar transacciones con un
saldo inicial (un nmero aleatorio entre 100 y 1000), seleccionando las opciones
de un men, como el siguiente:

Opcin 1) Depsitos
Opcin 2) Retiros
Opcin 3) Ver saldo
Opcin 4) Salir
Cada opcin es accedida mediante su nmero de acceso. Los depsitos pueden

ser en cantidades fijas de 10,100 y 200 soles. Los retiros pueden ser de cualquier
cantidad, pero manteniendo un saldo mnimo de 5 soles.
Si el usuario cometi ms de tres errores, el sistema le enva el mensaje Ud. no
puede ingresar al sistema, hasta luego.
Disear el programa correspondiente que simule a este cajero.
Solucin //func_banco_s.cpp
# define linea -----------------------------
time_t tiemp;int monto,saldo,n;
243
void Retiro(){
gotoxy(2,10);cout<<Cuanto dinero desea retirar...?: ;cin>>monto;
if (( saldo - monto )< 5 )
{gotoxy(2,12);cout<< Su saldo es menor al monto del retiro;
}
else { saldo -= monto;
gotoxy(2,12); cout<< Presione ENTER : ;
}
getch();
}
void Deposito( ){
gotoxy(4,10);cout<<Elegir cantidad a Depositar[10,100,200]; cin>>monto;
if ( monto == 100 || monto == 200 || monto == 10 )
{saldo += monto;
gotoxy(4,12);cout<<Dinero depositado, presione ENTER ;
getche();
}
else
{ gotoxy(4,12);cout<<El monto no es correcto;

gotoxy(4,13);cout<<Presione ENTER : ;
getch();
}}
void MostrarSaldo(){
gotoxy(4,11);cout<<Su Saldo Actual es : <<saldo;
gotoxy(2,12);cout<<Presione ENTER : ;
getch();
}
void Menu(){
char iTecla; randomize(); saldo = random(1000);
do{ do{clrscr();
gotoxy(10,2); cout<< Menu Principal ;
gotoxy(8,4);cout<< [1] DEPOSITOS ;
gotoxy(8,5);cout<< [2] RETIROS ;
gotoxy(8,6);cout<< [3] SALDOS ;
gotoxy(8,7);cout<< [4] SALIR ;
gotoxy(4,8);cout<<linea; gotoxy(8,10);cout<<Seleccione Opcion :;

iTecla = getche();

} while( iTecla != 1 && iTecla != 2 && iTecla != 3 && iTecla != 4);

switch( iTecla ){ case 1 : Deposito(); break;

case 2 : Retiro(); break;

case 3 : MostrarSaldo(); break;
}
} while( iTecla != 4 );
}
void Usuario()
{char Uid[12]; char Pwd[12]; int Intentos=0;
do{ time(&tiemp);

gotoxy(34,2);printf( Fecha de Consultas: %s,ctime(&tiemp));
244
gotoxy(35,3);cout<<linea;gotoxy(50,3);cout<<linea;

gotoxy(8,2);cout<< CUENTA BANCARIA ;

gotoxy(4,4);cout<<Sr. Ud. solo tiene 3 Intentos ;
gotoxy(4,6);cout<<Ingrese Usuario : ;cin>>Uid;

gotoxy(4,7);cout<<Ingrese Clave : ;cin>>Pwd;

if (strcmp(Uid,tcn)==0 && strcmp(Pwd,1234)==0){

gotoxy(6,9);cout<<Sr.<<Uid<< Bienvenidos al sistema ..... ;/
Intentos=0;

}
else { Intentos++;
gotoxy(6,11);cout<<Sr.le quedan <<(3-Intentos)<< intentos ; getche();
}
} while(Intentos!=0 && Intentos!=3 );
if ( Intentos == 3 ){ clrscr();
gotoxy(4,3);cout<<Ud. no puede
ingresar al sistema, hasta Luego;
getche();
}
else
Menu();
}
void main()
{ Usuario();
}
Primero validar datos de usuario. En
la primera corrida, observe que se
comete un error, con lo cual le genera
el mensaje Sr. le quedan 2 intentos.
Suponga que en la seguna corrida
Los datos son correctos, entonces
se presentan las opciones para el
mantenimiento. Si selecciona la
opcion [ 1 ], le solicita que ingrese la
cantidad a depositar (en mi caso 200).
As puede continuar procesando las
opciones [2],[3] y [4].
Problema 18. Disear un programa que permita leer las coordenadasde dospuntos
A(x1,y1), B(x2,y2) y calcular la distancia entre los dos puntos descritos.
Solucin //func_dist.cpp
float distanciaxy(float x1, float y1,float x2, float y2);
float x1,y1,x2,y2;
245
float salida;
float distanciaxy(float x1, float
y1,float x2, float y2)
{ float resultado,intermedio;
intermedio=pow(x1x2,2)+pow(y1-y2,2);
resultado =sqrt(intermedio);
return (resultado); }
voidmain(){clrscr();
gotoxy(2,2);cout<<DISTANCIA
ENTRE DOS PUNTOS;
gotoxy(2,3);cout<<PUNTO A(x1,y1);
gotoxy(2,4);cout<<Ingrese el valor de x1 :;cin >>x1;
gotoxy(2,5);cout<<ingrese el valor de y1 :;cin >>y1;
gotoxy(2,7);
cout<<PUNTO B(x2,y2);
gotoxy(2,9);
cout<<Ingrese el valor de x2 :;
cin >>x2;
gotoxy(2,10);cout<<Ingrese el valor de y2:;cin >>y2;
salida=distanciaxy(x1,y1,x2,y2);
gotoxy(2,12); cout<<La distancia es= <<salida; getch();}
5.7 Funciones que llaman a funciones

El cuerpo de una funcin, puede contener llamada a otra funcin. La condicin
es que deben estar definidas en el protipode funciones.
Problema 1. Disear un programa que permita leer dos nmeros y luego
mostrarlos ordenados en forma ascendente. Debe definir las siguientes funciones:
-
-
-
-
Entradas(): lee dos nmeros enteros desde teclado.

Intercambia(): intercambia valores de dos variables.
Ordena(): ordena los nmeros que estn almacenados en variables.
Imprimir(): imprime resultados de las dos variables.
Solucin //func_func_ord.cpp
void entradas(int& a , int& b);
void intercambia(int& var1 ,int& var2);
void Ordena(int& n ,int& m);
void imprimir(int res1,int res2 );
void main(){int a, b;
gotoxy(5,2);cout<<FUNCIONES
QUE
LLAMAN
ABSTRACCION;
entradas(a, b); Ordena(a, b); imprimir(a, b); getche();
246
FUNCIONES:
}
void entradas(int& aa , int& bb)
{gotoxy(2,4);cout<<Ingrese primer numero :;cin>>aa;
gotoxy(2,5);cout<<Ingrese segundo numero :;cin>>bb; }
void intercambia(int& var1 ,int& var2)
{int aux;aux=var1;var1=var2;var2=aux;}
void Ordena(int& n ,int& m)
{ if(n>m) intercambia(n,m);}
void imprimir(int res1,int res2 )
{ gotoxy(2,7);cout<<los numeros ordenados son :<<res1<< <<res2<<endl;}
Problema 2. Disear un programa que permita ingresar una cadena de caracteres

y luego mostrarlo en forma invertida.
Solucin //func_letra_car.cpp
void leercaracter();
void leercaracter()
{char tecla;
tecla=getch();
if(tecla!=13&&tecla!=27)
{cout<<tecla;leercaracter();
}
else
if(tecla==13) cout<<\n\n;
cout<<tecla;
}
void main()
{ gotoxy(2,3);
cout<<Ingrese una cadena :;
leercaracter();
getch();}
positivo en forma hexadecimal y luego mediante una funcin, convertir este
nmero en su equivalente expresado en sistema binario.
247
Anlisis. Los nmeros decimales son dgitos (0 al 9) y los nmerosbinarios son

dgitos (0,1). As, la representacin binaria de un nmero decimal se puede hallar
mediante el siguiente algoritmo: sea n un nmero positivo decimal. Hallar n % 2
y n / 2, y almacenamos el primero. Reemplazamos n por n/2. Se repite el proceso
hasta que n sea igual a cero. Por ejemplo: supongamos que n es 23.
N
N%2
N/2
23
1
11
11
1
5
5
1
2
2
0
1
1
1
0
0
La representacin binaria de 23 es 10111
Solucin //func_rec_binar.cpp
const int base = 2;
void sist_binario(int n);
void sist_binario(int n)
{ if (n > 0) {sist_binario(n/base);
cout<<n%base;
//mostrando
elementos binarios }
}
int main()
{ int n;
gotoxy(2,2); cout<<Introduzca un entero positivo: ;cin >>n ;
gotoxy(2,4); cout<<El Numero << n << es igual a ;
sist_binario(n); cout << en el sistema binario ;
//return 0;getche();
}
Problema 4. Disear un programa que permita ingresar dos puntos A(x1,y1 ) y
B(x2,y2) y verifica si un punto P(x,y) pertenece a L.
Solucin //func_recta.cpp
float pendiente(float p,float q,float r,float s);
float recta(float a, float b,float c,float d,float e);
float pendiente(float p, float q, float r,float s)
{ return((s-q)/(r-p));
// 1/3=0.33333 : 1,4=0.25
}
float recta(float a, float b,float c,float d,float e)
{ if((a-b-c*(d-e))==0)
// y-y1 = m(x-x1)
{ // a-b = c*(d-e) --> a-b-c*(d-e)=0
return(1);
}
248
else return(0);
}
void main()
{ float x1,y1,x2,y2,m,x,y,r;
gotoxy(2,2); cout<<Ingrese las coordenadas del punta A(x1,y1):;
gotoxy(2,4); cout<<x1=; cin>>x1;
gotoxy(2,5); cout<<y1=; cin>>y1;
gotoxy(14,5);cout<<Punto: A(<<x1<<,<<y1<<);
gotoxy(2,7); cout<<Ingrese las coordenadas del punta B(x2,y2):;
gotoxy(2,9); cout<<x2=; cin>>x2;
gotoxy(2,10);cout<<y2=; cin>>y2;
gotoxy(14,10);cout<< Punto: B(<<x2<<,<<y2<<);
m = pendiente(x1,y1,x2,y2);
gotoxy(2,12);cout<<Calculando pendiente m =(y2-y1/x2-x1). de donde: m=
<<m;
gotoxy(2,13);cout<<Reemplazando en ecuacion de la recta L : y-y1=m(x-x1);
gotoxy(2,14);cout<< Obtenemos : y <<-<<y1<<=<<m<<(x<<-<<x1<<);
gotoxy(2,15);cout<<************************************************************;
gotoxy(2,17);cout<<Verificando si un punto pertenece a la recta L ;
gotoxy(2,18);cout<<Ingrese las coordenadas de un punto P(x,y):;
gotoxy(2,19);cout<<x=; cin>>x;
gotoxy(2,20);cout<<y=; cin>>y;
r = recta(y,y1,m,x,x1);
if(r==1)
{gotoxy(2,22);cout<<El punto P(<<x<<,<<y<<) Si pertenece a la recta L;
} else
{ gotoxy(2,22);cout<<El punto P(<<x<<,<<y<<), No pertenece a la recta L ;
} getche();
}
249
Problema 5. Una utilidad comn para un programador, en lenguaje ensamblador,

es poder convertir los resultados entre las bases hexadecimal, octal y binario
alternativamente. Escribir un algoritmo para realizar esta tarea, el cual deber
pedir primero el nmero y luego solicitar la base mediante una tecla H, B,
O, para luego intercambiar el nmero entre las bases pulsando entre estas
teclas.
Solucin ////func_case_binar_hex.cpp
void f_base(unsigned int,int);
char letra(int,int);
void f_base(unsigned int n, int b)
{ unsigned int c, r;
int i, j; char num[16];

for(i=0;i<16;i++) num[i]= 9;

i = 0; c = n/b; r = n%b;

if (c > b){ num[i] = letra(b,r);
i++;

while (c > b)

{n = c;c = n/b; r = n%b;
num[i] = letra(b,r);

I ++;}

num[i] = letra(b,c);
}

else{ num[i] = letra(b,r);

i++;
num[i] = letra(b,c);}

for(j=i;j>=0;j--)putch(num[j]);
}
char letra(int base,int numero)
{ char resp;

switch (base)

{ case 2 : switch (numero) {

case 0 : resp = 0; break; case 1 : resp = 1; break;

}
break;

case 8 : switch (numero) {





}
break;

case 16 :switch (numero) {


case 2 : resp = 2; break;


250


case 10 : resp = A; break;
case 11 : resp = B; break;

case 12 : resp = C; break; case 13 : resp = D; break;

case 14 : resp = E; break;
case 15 : resp = F; break;

}
break; }
return (resp);}
void main(){ unsigned int numero;
char opc;
gotoxy(2,2);cout<<CAMBIANDO BASE DE UN NUMERO ;
gotoxy(4,4);cout<<Ingrese un numero : ; cin>>numero;
gotoxy(4,6);cout<< [H] Hexadecimal ;
gotoxy(4,7);cout<< [O] Octal
;
gotoxy(4,8);cout<< [B] Binario <<endl;
gotoxy(4,9); cout<< [Esc] Salir <<endl;
gotoxy(4,11); cout<< Elija una opcion:; cin>>opc;
switch (opc)
{case b: case B : gotoxy(4,13);cout<< En Sistema Binario ;f_base(numero,2);
break;
case o: case O : gotoxy(4,13);cout<< En Sistema Octal ;f_base(numero,8);
break;
case h: case H : gotoxy(4,13);cout<< En Sistema Hexadecimal
;f_
base(numero,16); break;
case s: case S : break;default: cout<<opcin invalida;}
getche();
}
Problema 6. Las facultades de una universidad estn preocupadas por el

rendimiento acadmico de sus estudiantes, especialmente los del rea de
sistemas. Para tomar una estadstica se ha decidido realizar los compendios de
notas de ocho ciclos anteriores de cada curso de stos. De cada compendio se
toma la nota final de cada alumno y se promedia la nota de stos. Se considera
que en un curso hay problemas de rendimiento cuando el promedio general de
los alumnos no ha superado la nota aprobatoria por lo menos cinco veces de estos
ocho ciclos. Escribir un algoritmo interactivo que permita ingresar, curso por
curso, la cantidad de alumnos y sus notas durante estos ocho ciclos y determine
cules cursos tienen problemas.
251
Solucin //func_Facultad_cursos.cpp
#include <iostream.h> #include <stdlib.h>
#include <string.h>
void calculo_promed();
int n,ca,i,j,prom,s,nota,cdesap;
char rpta,curso[20];
void calculo_promed()
{ do {cout<<Ingrese el nombre del curso:;
cin>>curso;
cdesap=0;
ca=0;
for(i=1;i<=8;i++)
{ cout<<\nCiclo : <<i<<endl;
cout<<Ingrese la cantidad de alumnos:; cin>>n;
s=0;
cout<<Ingrese las notas de los alumnos:\n;
for(j=1;j<=n;j++)
{cout<<Alumno <<j<<:;
cin>>nota;
s=s+nota;}
prom=s/n;
cout<<\nEl promedio de este ciclo es:<<prom<<endl;
if(prom<=10) { cdesap=cdesap+1;
}
}
cout<<\nNumero ciclos aprobados:<<8-cdesap<<endl;
cout<<\nNumero ciclos desaprobados:<<cdesap<<endl;
if(cdesap>=5)
{ puts(curso);
cout<<\nEl curso tiene problemas<<endl;
}
else { puts(curso);
cout<<\nEl curso no tiene
problemas<<endl;
}
cout<<\n\ Desea ingresar
otro curso [s/n]:; cin>>rpta;
if ((rpta==s)||(rpta==S))
{getchar();
}
}
while((rpta==s)||(rpta==
S));
}
void main()
{calculo_promed();
}
252
Problema 7. Disear un programa usando funciones que permita ingresar

clave =1234 de usuario y si este es verdadero, el programa solicita nmero de
vendedores. Por cada vendedor existe cuatro tipos de servicios y su precio
respectivo por pasaje:
Al norte : S/.40
Al centro : S/. 25
Al sur
: S/.30
Al oriente: S/.22
El programa debe generar los siguientes reportes:

a. Nmero total de pasajeros por servicio y monto total por cada servicio
b. Nmero total de pasajeros y monto total
c. Vendedor con mayor venta de pasajes
d. Vendedor con mayor venta de pasajes por servicio
e. Servicio que recaud mayor cantidad de dinero y el vendedor respectivo
Solucin //func_Ventas_pasaj.cpp
#define max 10
typedef char cadena[20];
int costo[4]={40,30,25,22};
cadena oficina[4]={Norte,Sur,Centro,Oriente};
int ganancia[4]={2,3,4,5};
void Leer_datos(int&,cadena[],int[max][4]);
bool Ingreso_usuar_sistema();
int Sumar(int,int,int[max][4],bool);
int Mayor(int,int,int[max][4],bool);
void Comparar(int,int,int,cadena[],int[max][4],bool);
void main()
{cadena vendedor[max];
int numero_vendedor,ventas[max][4];
bool flag; int i,j,suma=0,suma_venta=0; clrscr();
flag=Ingreso_usuar_sistema();
Leer_datos(numero_vendedor,vendedor,ventas);
if (flag) {clrscr();
cout<<\n\t Numero de Pasajeros y monto total de cada servicio: \n;
for(i=0;i<4;i++)
{cout<<\n\t Pasajeros al <<oficina[i]<< = ;
cout<<Sumar(numero_vendedor,i,ventas,false)<<endl;
cout<<\t\ Monto total al <<oficina[i]<< = ;
cout<<Sumar(numero_vendedor,i,ventas,false)*costo[i]<<endl;
}
cout<<\n\tPresione Tecla para continuar....<<endl;getch();
cout<<\n\t - Numero de Pasajeros y monto total de cada servicio: \n\n;
for(i=0;i<numero_vendedor;i++)
for(j=0;j<4;j++)
253
{suma=suma+ventas[i][j];
suma_venta=suma_venta+ventas[i][j]*costo[j];
}
cout<<\t\ Pasajeros totales = <<suma<<endl;
cout<<\t\ Monto total = <<suma_venta<<endl;
cout<<\n\Presione Tecla para continuar....<<endl;getch();
cout<<\n\ Mayor ventas de boletos es de ;
suma=Mayor(numero_vendedor,4,ventas,false);
cout<<suma<< del:\n\n;
Comparar(suma,numero_vendedor,4,vendedor,ventas,false);
cout<<\n\t Presione una Tecla para continuar....<<endl;getch();
cout<<\n\t Servicio que vendio mas boletos y el vendedor : \n\n;
suma=Mayor(numero_vendedor,4,ventas,true);
cout<<\tLa mayor venta de un servicio es <<suma<< del :<<endl;cout<<\n;
Comparar(suma,numero_vendedor,4,vendedor,ventas,true);
cout<<\n\tPresione Tecla para continuar....<<endl;getch();
cout<<\n\t Servicio que recaudo mas dinero y el vendedor : \n\n;
suma=0;
for(j=0;j<4;j++)
if (suma<ventas[i][j]*costo[j])
suma=ventas[i][j]*costo[j];
cout<<\t El dinero que mas se recaudo es de <<suma<< del : <<endl;
cout<<\n;
for(j=0;j<4;j++)
if (suma==ventas[i][j]*costo[j])
cout<<\tServicio <<oficina[j]<< del vendedor <<vendedor[i]<<endl;
cout<<\n\t\Presione una Tecla para salir :<<endl;getch();
} }
void Leer_datos(int &n, cadena v[],int ve[max][4])
{int i,j;
cout<<\n\t Ingrese Numero de Vendedores : ; cin>>n;
for (i=0;i<n;i++)
{cout<<\n\t Nombre del vendedor <<(i+1)<< : ; gets(v[i]);
cout<<\n\t Ventas de boletos del vendedor <<v[i]<< : <<endl;
for (j=0;j<4;j++)
{cout<<\n\tBoletos vendidos hacia el <<oficina[j]<<=; cin>>ve[i][j];
}
} }
bool Ingreso_usuar_sistema()
{int clave,intentos=3;
bool flag=false;
do {clrscr();gotoxy(2,2);cout<< MODULODE VALIDACION DE DATOS ;
gotoxy(2,4);cout<<Ingrese Clave : ;cin>>clave;
if (clave==1234)
flag=true;
254
else
{gotoxy(4,6);intentos--;
cout<<Clave incorrecta, le quedan <<intentos << intentos;
gotoxy(4,8);cout<< Presione cualquier tecla.......; getch();
} if (flag) intentos=0;
//exit(0);
}while(intentos!=0); return flag;
}
int Sumar(int fila,int columna,int v[max][4],bool flag)
{int i,suma=0;
if (flag)
for(i=0;i<columna;i++)
suma=suma+v[fila][i];
else
for(i=0;i<fila;i++)
suma=suma+v[i][columna];
return suma;
}
int Mayor(int fila,int columna,int v[max][4],bool flag)
{int i,j,numero,aux;
if (flag)
{numero=v[0][0];
for(i=0;i<fila;i++)
for(j=0;j<columna;j++)
{aux=v[i][j];
if (numero<aux) numero=aux;
}
}
else
{numero=Sumar(0,columna,v,true);
for(i=1;i<fila;i++)
{aux=Sumar(i,columna,v,true);
if (numero<aux) numero=aux;
}
}
return numero;
}
void Comparar(int numero,int fila,int columna,cadena v[],int ve[max][4],bool
flag)
{int i,j,aux; if (flag)
{for(i=0;i<fila;i++)
for(j=0;j<columna;j++)
{aux=ve[i][j]; if(numero==aux)
cout<<\t\ Vendedor <<v[i]<< con servicio al <<oficina[j]<<endl;
}
}
else
{for(i=0;i<fila;i++){aux=Sumar(i,columna,ve,true); if(numero==aux) cout<<\t
255
Vendedor <<v[i]<<endl;
}
}
Problema 8. Disear un programa,usando funciones, que permita ingresar

n caracteres en un vector de longitud definida por el usuario y luego generar
reportes para conocer:
Nmero de veces que se repite cada letra correpondiente a las vocales, asimismo,
el total acumulado de otras letras (que no forman parte de las vocales pero que
el usuario las ingres)
Solucin //func_vector_let.cpp
#include <iostream.h> #include <stdio.h> #include <conio.h>
void leerletras(int, char l[]);
int contadorletras(int n,int l[]); char l[20];int aa=0,ee=0,ii=0,oo=0,uu=0,n,otrasl=0;
void leerletras(int, char l[20])
{ for (int i=1;i<=n;i++)
{gotoxy(2,2+i);cout<<l[<<i<<]=;
cin>>l[i];}}
int contadorletras(int n,char l[20])
{ for (int i=1;i<=n;i++)
switch(l[i])
{case a:case A:aa++;break; case
e:case E:ee++;break;
case i:case I:ii++;break; case
o:case O:oo++;break;
case
u:case
U:uu++;break;
default: otrasl++; } return 0; }
void main()
{ gotoxy(2,1); cout<<ingrese longitud del vector:;cin>>n;
leerletras(n,l); contadorletras(n,l);
gotoxy(5,15); cout<<endl<<RESULTADOS<<endl;
gotoxy(5,16); cout<< a se ingreso <<aa<< veces<<endl;
gotoxy(5,17); cout<< e se ingreso <<ee<< veces<<endl;
gotoxy(5,18); cout<< i se ingreso <<ii<< veces<<endl;
gotoxy(5,19); cout<< o se ingreso <<oo<< veces<<endl;
gotoxy(5,20); cout<< u se ingreso <<uu<< veces<<endl;
gotoxy(5,23); cout<< Otras letras ingresadas: <<otrasl;getch();}
Problema 9. Disear un programa que gener nmeros en forma aleatoria y
almacenarlo en una matriz de n filas y m columnas, luego mostrar la matriz,
compuesta con elementos constituidos slo por dgitos y ordenados en forma
ascendente.
Solucin //func_mat_rand.cpp
256
# define max_el 100
void LeerMatriz (int matriz[10][10], int f, int c);
void ReporteMatriz(int matriz[10][10], int f, int c);
void OrdenarMatriz(int matriz[10][10], int f, int c);
void MostarDatosMatriz(int matriz[10][10], int f, int c);
void OrdenarVector (int vector[10], int n);
int genera[30][30], n, m;
void LeerMatriz(int matriz[10][10], int f, int c)
{ int i, j;
srand(10);//reinicializa el numero aleatorio
for(i=1; i<= f; i++)
{ for(j=1; j<=c; j++)
{ matriz[i][j]=rand()%10; }
cout<<\n;
} getche();
}
void OrdenarMatriz(int matriz[][10], int f, int c)
{ int vector[max_el ], i, j, k=1; // copiando elementos de la matriz en un vector
for(i=1; i<= f; i++)
for(j=1; j<= c; j++)
{ vector[k]=matriz[i][j]; k++; }
//Ordenar el Vector
OrdenarVector(vector, k); //Pasar los datos ordenados del vector a la Matriz
k=1;
for(i=1; i<= f; i++)
for(j=1; j<= c; j++)
matriz[i][j]=vector[k];
k++;}
}
void MostarDatosMatriz(int matriz[10][10], int f, int c)
{ int i, j;srand(10);//reinicializa el numero aleatorio
for(i=1; i<= f; i++)
{ for(j=1; j<=c; j++)
cout<<matriz[i][j]<<\t; cout<<\n;
}
}
void OrdenarVector(int vector[], int
n)
{ int i, j, aux;
for(i=1; i<n-2; i++)
{ for(j=1; j<n-1-i; j++)
{ if(vector[j] > vector[j+1])
{ aux=vector[j]; vector[j]=vector[j+1];
vector[j+1]=aux; } }}}
void main()
257
{ cout<<Ingresa el numero de filas ; cin>>n;

cout<<Ingresa el numero de columnas ; cin>>m;
cout<<Generando datos matriz...\n;
LeerMatriz(genera, n, m);
cout<< Valores de la matriz \n\n;
MostarDatosMatriz(genera, n, m);
OrdenarMatriz(genera, n, m);
cout<<\nDatos de la matriz Ordenada\n\n;
MostarDatosMatriz(genera, n, m); system(pause);
}
Problema 10. Disear un programa que, mediante una funcin cantidad_num(),
permita leer la cantidad de nmeros para buscar sus divisores, el nmero debe estar
comprendido en el rango 1..100, inclusive. Luego disee otra funcin divisores()
que permita ingresar el nmero del que desea buscar sus divisores (usted ingrese
nmeros hasta la cantidad definida con la funcin cantidad_num()). Finalmente
desde el programa principal llamar a las funciones implementadas.
Solucin //func_vect_factores.cpp
# define linea -----------------------------------------
# define max_el 100
void cantidad_num();
int divisores();int datos[max_el], n ,i,j;
void cantidad_num ()
{gotoxy(2,4);cout<<Ingrese n:;
do { cin>>n;gotoxy(2,4);cout<<Numero fuera de rango, vuelva a Ingresar:
;clreol();
}while(n<0||n>100);
gotoxy(2,6);cout<<Ud.ha ingresado correctamente, gracias;
}
int divisores(){gotoxy(2,9);cout<<Ingrese <<n<< numero(s) para descomponer
en divisores<<endl;
258
for(i=1;i<=n;i++){cout<<\nNumero[<<i<<]=; cin>>datos[i];
for(j=1;j<=datos[i];j++)

{if (datos[i]%j==0)

{cout<<El numero << datos[i]<< tiene como divisores a <<j<<endl;
}}
}
return 0; }
void main(){ gotoxy(6,2);cout<< DIVISORES UN NUMEROS ;
gotoxy(2,3);cout<<linea; cantidad_num (); divisores(); getch(); }
Salida inicialmente, le solicita que ingrese n, si usted ingresa un nmero menor
que 0 o mayor que 100, entonces el sistema enva el mensaje Nmero fuera de
rango, vuelva a Ingresar . Vea como ejemplo para n=3.
5.8 Funciones recursivas

Puede definirse un programa en trminos recursivos, como una serie de pasos
bsicos, o paso base (tambin conocido como condicin de parada), y un paso
recursivo, donde vuelve a llamarse a la funcin. En un ordenador, esta serie de
pasos recursivos debe ser finita, terminando con un paso base. Es decir, a cada paso
recursivo se reduce el nmero de pasos que hay que dar para terminar, llegando
un momento en el que no se verifica la condicin de paso a la recursividad. Ni el
paso base ni el paso recursivo son necesariamente nicos.
Cuando una funcin se puede llamar a s misma (por su nombre), se le denomina
recursividad y puede ser directa e indirecta.
Recursividad directa. Cuando una funcin se llama a s misma.
Recursividad indirecta. Cuando tenemos un procedimiento P que llama a otro
Q y ste, a su vez, llama a P. Tambin en estos casos debe haber una condicin
de parada.Los dos tipos de recursividad se dan en dos formas, aquellas que
eventualmente terminan de ejecutar los procesos y generan un resultado y el
caso en que la recursividad nunca termina produciendo un bucle infinito y de
aqu una falla en tiempo de ejecucin por falta de memoria.
Durante el proceso de compilacin, es importante resaltar en la recursividad que
cuando una funcin se llama a s misma, una nueva copia de esta funcin es la
que se ejecuta.
En la siguiente figura se ilustra el proceso de definir casos base y caso recursivo
para calcular el factorial de un nmero, veamos:
n!=
1
si n = 0
n(n-1) si n 0
Caso base
Caso recursivo
259
Que permite ejecutarse de la siguiente manera:

Ilustracion analtica de la descomposicin de n=5
factorial(5) =
5 * (factorial(4)) =
5 * ( 4 * (factorial(3))) =
5 * ( 4 * ( 3 * (factorial(2)))) =
5 * ( 4 * ( 3 * ( 2 * (factorial(1))))) =
5 * ( 4 * ( 3 * ( 2 * ( 1 * (factorial(0)))))) =
5 * ( 4 * ( 3 * ( 2 * ( 1 * 1)))) =
5 * ( 4 * ( 3 * ( 2 * 1))) =
5 * ( 4 * ( 3 * 2)) =
5 * ( 4 * 6) =
5 * 24 =120
Diseando la funcin recursiva:
int factorial(int n);
{ if (n == 0)| return 1;
else return n * factorial(n-1);
}
Considere el caso cuando n=3
return 3*factoria(2)

return 2*factorial(1)

return 1*factorial(0) //como n es cero , no vuelve a llamar
En general para n se tiene la siguiente expresin: n! = n (n - 1) (n - 2) ... 1 lo
cual significa que n! es igual al producto de todos los enteros no negativos entre
n y 1.
Aplicaciones
positivo y luego, en forma recursiva, generar un reporte de los elementos a partir
del nmero ingresado hasta terminar en cero (0).
Solucin //func_rec_serie.cpp
# define linea ------------------
int resp;int n,i=0;
void recursiva(int i);
void recursiva(int i)
{ if(i<=n)
{ recursiva(i+1);
cout<<i<< ;
}}
void main()
260
{gotoxy(4,2);cout<<RECURSIVIDAD DESCENDENTE;
gotoxy(4,5);cout<<Ingrese el numero:;cin>>n;
gotoxy(4,7);cout<<Serie Descendente: ;recursiva(0);getche();}
Problema 2. Disear un programa que permita leer un nmero entero positivo y
luego, en forma recursiva, calcular su factorial e indicar el nmero de veces que
se llama a la funcin recursiva por su nombre.
Solucin //func_rec_fact.cpp
void leer(int ); float factorial(int ); void imprimir();
int n,i,resp,j=1;
void leer(int )
{ gotoxy(2,4);cout<<Ingrese numero
:;cin>>n;return ;
}
float factorial(int n)
{ if ((n==0)||(n==1))
resp=1;
else { resp=(n*factorial(n-1));
j++;
}
return(resp);}
void imprimir()
{gotoxy(2,8);cout<<El factorial de
<< n<< es = <<factorial(n); }
void main()
{gotoxy(2,2);cout<<FACTORIAL EN FORMA RECURSIVA;
leer(n); factorial(n); gotoxy(2,6);
cout <<Usando el numero <<n<< se llamara a la funcion factorial <<j<<
veces << endl; imprimir(); getche();
}
Problema 3. Disear un programa que permita ingresar una cadena de n
caracteres, luego el programa debe solicitar al usuario que ingrese un carcter,
mediante l se debe generar un
reporte del nmero de veces que se
repite el carcter ingresado.
Solucin // func_rec_letras.cpp
int contador(char letra,char[]);
int contador(char letra, char cad[])
{if (cad[0]==\0) return 0;
else if(letra==cad[0])
return 1 + contador(letra,&cad[1]) ;
261
n!=
1
si n = 0
n(n-1) si n 0
Caso base
Caso recursivo
else
return contador(letra,&cad[1]);
}
void main()
{ char letra,cade[80];
gotoxy(3,3);cout<<Ingrese cadena : ; gets(cade);
gotoxy(3,4); cout<<Ingrese caracter a contar : ;
letra=getchar(); gotoxy(2,6);
cout<<El caracter <<letra<< se repite <<contador(letra,cade)<< veces en la
cadena :<<cade; getche();
}
Problema 4. Disear un programa que permita ingresar un nmero entero (base)
y un nmero entero m (para mostrar el nmero base su potencia desde cero hasta
el valor de m). Mostrar la potencia de un nmero en forma recursiva.
Solucin //func_rec_pote1.cpp
int potencia(int x , int n);
int potencia(int x , int n)
{ if (n<0) { cout<<Base de la potencia
no es valida:; exit(1); }
if(n>0)
return (x*potencia(x,n-1)); return(1);}
int main(){ int x,m;gotoxy(5,2);
cout<<FUNCION RECURSIVA ;
base
:;cin>>x;
gotoxy(5,5);
cout<<Ingresepotencia :;cin>>m;
{cout<<Numero <<x << a la
potencia <<i<< es <<potencia(x,i)<<endl;
} // return 0; getche(); }
Clculo de la potencia ab:

ab =
1
si b = 0
a(ab-1) si b > 0
Problema 5. Disear un programa que permita ingresar un nmero entero (base)

y un segundo nmero entero (expon) y luego calcule el resultado en forma
recursiva.
Solucin //func_rec_po.cpp
float potencia( float base, int expon );
float potencia( float base, int expon )
{ if(exp == 0 ) return(1); return( base*potencia(base,expon-1)); }
void main(){ int base, exp;
gotoxy(2,2);cout<<FUNCION RECURSIVA POTENCIA;
gotoxy(2,4);cout<<Ingrese base
:;cin>>base;
262
gotoxy(2,5);cout<<Ingrese exponente : ;cin>>expon;

gotoxy(2,7); cout<<El numero <<base<< elevado
<<potencia(base,expon); getche();}
<<exp<<es=
Problema 6. Disear un programa que permita ingresar un nmero entero a

(multiplicando) y un nmero entero b (multiplicador) y luego calcule en forma
recursiva el producto de los dos nmeros.
Solucin func_rec_multi.cpp
int multiplicacion( int a, int b );
int multiplicacion( int a, int b )
{ if(b == 0 ) return(0);
return( a + multiplicacion(a, b-1));
}
void main()
{int a,b;gotoxy(2,2);cout<<FUNCION
RECURSIVA MULTIPLICACION;
gotoxy(2,4);cout<<Ingrese valor del multiplicando :;cin>>a;
gotoxy(2,5);cout<<Ingrese valor del multiplicador : ;cin>>b;
gotoxy(2,7);cout<<El numero <<a<< multiplicado por <<b<< es =
<<multiplicacion(a,b); getche(); }
Problema 7. Disear un programa que permita leer la longitud de un vector para
ingresar los elementos de tipo enteros y en formada ordenada, luego ingrese el
elemento a buscar en forma recursiva. El programa debe informar si se encuentra
o no tal elemento.
Solucin func_rec_busc_bin.cpp
const int longi =50; // Tamao del vector
typedef int lista[longi];
void buscar(lista Ordenado, int Primero, int Ultimo, int Item, int &Dato);
void buscar(lista Ordenado, int Primero, int Ultimo, int Item, int &Dato)
{int Mitad;
if (Primero > Ultimo) {
Dato = 0; }
263
else{Mitad = (Ultimo + Primero) / 2;

if (Ordenado[Mitad] == Item) { Dato
= Mitad; }
else { if (Ordenado[Mitad] < Item)
{ buscar(Ordenado, Mitad+1, Ultimo,
Item, Dato);
}
else
{ buscar(Ordenado, Primero,
Mitad-1, Item, Dato);
} } }}
int main(){ lista Ordenado;
int n, i, Dato,Item;
gotoxy(2,3);cout<<Ingrese numero de elementos Ordenados: ;cin >>n;
if (n>longi){ n = longi; // No se pueden leer ms de longi elementos
}
for ( i = 0; i<=(n-1);i++)
{cout<< L[<<(i+1)<<]=;cin >>Ordenado[i] ; }
cout<<\nIngrese elemento a buscar: ;cin>>Item ;
buscar(Ordenado, 0, n-1, Item, Dato);
if (Dato == 0){cout<< Elemento no esta en la lista.;}
else{cout<<\n El elemento <<Item<< esta en la posicion <<(Dato+1)<< del
vector;}getche();}
Problema 8. Disear un programa que permita buscar,en forma recursiva, el
mximo elemento del vector inicializado: vector[ ]={2,8,7,3};
Solucin //func_recursiv.cpp
int max(int n , int x[]);
int max(int n, int x[])
{ if (n==1) return x[0];
if (x[n-1]>max(n-1,x))
return x[n-1];
else return max(n-1,x);
}
void main()
{ clrscr();
gotoxy(2,2);
cout<<FUNCION RECURSIVA MAXIMO ;
int x[]={2,8,7,3}; int n=3;
gotoxy(2,4);cout<<el maximo es <<max(n,x);
getche();}
Problema 9. Disear un programa que permita mostrar todas las posibles
permutaciones de la palabra inicializada NUI.
264
Solucin //func_rec_c++.cpp
void rotaciones(char s[],int n);void permutaciones(char s[],int n);
void main()
{ cout<<\n Permutaciones de la palabra NUI<<endl<<endl;
char s[]=NUI; int n=strlen(s);per
mutaciones(s,n);getche();}
void rotaciones(char s[], int n)
{ char c; int i; c=s[0];
for (i=0;i<n-1;i++)
s[i]=s[i+1]; s[n-1]=c;}
void permutaciones(char s[], int n)
{ int i; for(i=0;i<n;i++)
if(n==2)
{ cout<<s<< ;rotaciones(s,n);
}
else{permutaciones(s,n-1); rotaciones(s,n);
}}
Problema 1. Disear un programa que permita ingresar datos de n alumnos
(n<=1000) por apellidos, nombres, cdigo, edad y sus evaluaciones respectivas:
tres prcticas calificadas y dos exmenes. En la figura adjunta se ilustra el ingreso
de datos por alumno.
Genere los siguientes reportes que permita conocer datos procesados usando los
siguientes subprogramas:
longitud_Vector(b, m): subprograma para lectura del tamao del vector o de la
matriz.
lectura_Edades(b,m): subprograma para lectura de edades en el rango 10..99. En
forma anloga, crear nuevas estructuras para almacenar los datos mostrados en
la figura adjunta.
265
Ordena(b[, n): subprograma que ordena las edades en forma ascendente (si
cambia la edad, tambin debe cambiar el resto de datos, inclusive la posicin
original como la actual de cada registro).
pares_impares(b,n): subprograma (funcin) que devuelve informacin de
vectores con edades pares e impares, asimismo, la secuencia de edades que
forman en cada vector.
reportes(): subprograma (procedimiento) que realiza un reporte de edades
ordenadas en forma ascendente.
usando la tcnica de subprogramas,
que permita leer datos de alumnos por
nombres y edad de n alumnos (n<=1000),
luego genere los siguientes reportes
mostrados segn las grficas:
1. Subprograma para hacer lectura del
total de alumnos y subprograma para
hacer lectura de sus datos respectivos.
2. Subprograma que permita hacer reporte de datos de alumnos incluyendo la
ubicacin inicial.
3. Subprograma que permita hacer reporte de alumnos ordenados por

nombre en forma ascendente.
4. Subprograma que permita buscar
alumno(s) segn nombre. Si repiten,
debe mostrarse el total. Asimismo, el
mdulo debe ser interactivo con el
usuario.
5. Subprograma que permita hacer insercin. Solicita datos de alumnos y tambin es interactivo.
6. Subprograma que permita hacer reporte despus de la insercin de datos.
7. Subprograma para reporte ordenado despus de la insercin.
8. Subprograma para mostrar reporte de alumnos que sus edades no se repitan.
266

usando los siguientes mdulos:
Grado(int p): Proceso que permite
definir el grado > 2 del polinomio.
Coeficientes(int n, int poli[100]):
Proceso que permite leer los coeficientes
del polinomio enteros o reales.
mayorcoef(int n,int poli[100]):
Funcin que devuelve el mayor
coeficiente y su posicin respectiva.
Manorcoef(int n,int poli[100]):
Funcin que devuelve el manor
coeficiente y su posicin respectiva.
Derivadas(int n, int poli[100]):
Proceso que permite transformar
los datos, es decir; encontrar su
primera y segunda derivada y
evaluar en un valor ingresado por
el usuario.
reportes(): Genera listado de las consultas solicitadas.
Problema 4. La validacin y generacin de cdigo para la asignacin empleados,
se suele realizar por medio del
Algoritmo del Mdulo 11, el cual
consiste en sumar los productos de
los dgitos de tal nmero por 2, 3,4.
de izquierda a derecha, y luego el
resultado de esa sumatoria extraerle
el mdulo de dividirlo entre 11. Si
el resto es 0, se asigna la letra A, si
resulta 1, se asigna B, para el 2 se
asigna C y as sucesivamente.
Por ejemplo, si edito el cdigo 990006,
267
entonces genero la multiplicacin: (9*2+9+3+..+6*7) mod 11 lo cual resulta

10, es decir le corresponde la letra K, siendo entonces el cdigo generado:
990006K.
Usando subprogramas, disear el algoritmo el cual lea apellidos y dado su cdigo
entero formado slo por 6 dgitos, genere el cdigo de empleado respectivo, en
particular para 848139 se genera en la figura el cdigo.
Problema 5. Disear un programa usando las tcnicas de diseo modular, usando
los siguientes subprogramas:
Total(): mdulo que permite leer total de alumnos.
Lectura(): proceso que permite leer datos de alumnos por cdigo (no debe repetirse)
y nombres, cinco asignaturas (Bsicas,Fsica,Ingles I,Ecologa,Anlisis);
y cinco secciones (A,B,C,D,E), respectivamente. Donde cada alumno puede estar
matriculado en uno o mximo cinco cursos y en una o mximo cinco secciones,
por cada asignatura-seccin, cada alumno solo rinde tres prcticas calificadas, las
cuales son tomadas en forma aleatoria y slo en el rango de 2..18.
Observacin. la correspondencia de alumno-asignaturas-seccin-prcticaspuede
hacerlo aleatoriamente o mediante lectura desde teclado.
ReportesDat(): proceso que permite mostrar datos ingresados/capturados
aleatoriamente, usando el siguiente formulario:
Cdigo
Apellidos
Asignatura
Seccin
Prctica 1
Prctica 2
Prctica 3
ReportesProm(): Proceso que permite procesar evaluaciones de alumnos; es decir,

calcular el promedio de prcticas, eliminando la menor nota y luego mostrar un
reporte tal como se ilustra en el siguiente formulario:
Cdigo
Apellidos
Asignatura
Seccin
Prctica 1
Prctica 2
Prctica 3
Menor
Promedio
SeccAgrupa(): Proceso que genera un reporta donde se ilustra: la informacin

mostrada en el siguiente formulario, es decir: seccin, asignatura, promedio
de prcticas, nombre de alumno, promedio de seccin y seccin con mayor
promedio.
268
InsertaAlm(): Proceso que en forma interactiva permita insertar uno o ms

alumnos con todos sus datos respectivos.
Observacin. El cdigo un alumno
no debe repetirse
OrdenaSeccion():
Proceso
que permite ordenar en forma
ascendente por seccin. Los datos a
mostrarse se ilustran en el siguiente
formulario:
Cdigo
Apellidos
Asignatura
Seccin
Prctica 1
Prctica 2
Prctica 3
Menor
Promedio
EliminarAlumn(): Proceso que permite eliminar registros segn dato especificado.

Problema 6. La siguiente aplicacin, permita procesar informacin de un
conjunto de n (n<=1000), usando los siguientes atributos: nombre, cdigo (slo
de tres dgitos). En esta aplicacin se ilustra la tcnica de diseo tipos top-down:
DISEO MODULAR DEPENDIENTE, basado en el concepto de procedimientos
y funciones. Tambin se resalta las tcnicas de listas y tablas (matriz) para
procesar cadenas. A continuacin se describe cada mdulo y la tarea especfica
que stos realizan:
Longitud(). Es un procedimiento para
definir la cantidad de alumnos. En la
siguiente figura se ilustra la ejecucin
de este mdulo, donde para iniciar
se ingrese dos alumnos, pues ms
adelante existe mdulo de insercin.
Lectura(). Es un procedimiento en
el que el usuario ingresa los datos de
alumnos por nombres (cadenas) y se
almacena en una matriz y el cdigo
se almacena en un vector segn el
tamao de alumnos. En la siguiente
figura se ilustra el proceso de entrada
de deatos al sistema.
Reportes(). Es un procedimiento
que permite generar un listado de
los alumnos y sus datos ingresados.
Asimismo, indica la posicin de cada
registro, este dato es importante
cuando se realiza el ordenamiento
y permite conocer el lugar inicial de
269
ingreso del registro. En la siguiente figura se ilustra el proceso de entrada de

datos al sistema.
OrdenarNombresAsc(). Es un procedimiento que permite ordenar datos
de alumnos por nombre y en forma
ascendente. Usando el Procedimiento
Reportes(), se genera el reporte respectivo.
BuscarNombre(). Es un procedimiento que permite al usuario realizar
bsquedas de alumnos por nombre. En las figuras adjuntas se ilustra y verifica
que los compiladores hacen una diferencia entre letras maysculas de minsculas.
Asimismo, este procedmiento permite al usuario, en forma interactiva, informar
la existencia del alumno y el reporte acumulado si hubiera varios alumnos con el
mismo nombre.
OrdenarcodigoAsc(). Es un procedimiento que permite generar un reporte de alumnos ordenados en forma

ascendente, tal como se ilustra en la
siguiente figura.
InsertarDatos(). Es un procedimiento
que permite insertar nuevo registro (lo
importante es mostrar cmo insertar una cadena en una matriz). Observe que el
cdigo 100 se repite, pues se hace con la finalidad de eliminar cdigos repetidos.
Despus de insertar, se genera un reporte donde se observa los registros
ordenados en forma ascendente. Ver figura adjunta.
270
Eliminacin(). Es un procedimiento que permite eliminar registros que tienen

igual cdigo. Ver figuras adjuntas.
271
272
Captulo 6
Registros (struct)
OBJETIVOS
-
-
-
-
-
-
Definicin de registros (struct)

Definir campos de una tabla, asignando sus claves respectivas
Disear modelo relacional de base de datos
Cmo definir registro lgico y fsico
Cmo acceder a los elementos de un registro
Establecer anidamientode registros
6 .1 Introduccin
Un campo de la informtica es el procesamiento de datos reales, tales como
empleados, alumnos, vehculo, etc. Este tipo de informacin ser procesada con
mucha facilidad usando la tcnica de registro (struct), pero el procesamiento
solo se hace a nivel de memoria RAM.
273
Manejo de base de datos: El almacenamiento y gestin de datos en una empresa

da lugar al uso de los denominados archivos informticos; para lo cual se debe
iniciar con los trminos semnticos de: entidad, modelos relacionales, claves
primarias, forneas, etc. En la siguiente figura se ilustra un modelo relacional de
base de datos:
Entidad y atributos
Entidad: Objeto del mundo real, con existencia independiente y distinguible de
otros, del que queremos almacenar informacin en la base de datos.
Atributo o campo: propiedades especficas de cada entidad para describirla.
Registro: Est compuesto por un conjunto de estructuras denominadas campos.

Se procesa datos en trminos de: registro lgico, registro fsico, campo, claves
primarias, forneas. En el presente modelo ilustra el uso de las claves respectivas.
El modelo relacional es el modelo lgico en el que se basan la mayora de los
sistemas de gestin de bases de datos.
Cuando se disea una struct, tambin se le conoce como diseo del modelo.
Clave primaria. Es un campo que identifica al registro y cuida por la unicidad
de sus datos. Es un tipo de dato (int, char). En la siguiente figura, se ilustra un
registro denominado empleado y sus diferentes tipos de datos (campos), donde
el campo cdigo representa la clave primaria.
Clave fornea. Es un campo que identifica al registro y sirve para relacionar las
tablas, asimismo, permite mezclar la informacin respectiva.
274
Empleado
Cdigo
nombre
89760K
Ana
Tipos de datos: cadena(har)
apellidos
Salas
Entero(int)
edad
30
sueldo
1209,4
sexo
F
Real (float)
Del grfico, se puede obtener el modelo:

struct Empleado
{
char codigo[10] ,nombre[20], apellidos[20], sexo;
int edad;
float sueldo;
};// En esta rea se puede declarar la variable tipo registro simple o vector
6.2 Definicin y declaracin de una estructura

La declaracin de una estructura(modelo), significa definir un tipo de datos
identificndolo con un nombre, seguido de sus elementos (miembros).
Sintaxis:

Structnombre_tipo
{ tipo_dato_1 campo_nombre1;
tipo_dato_2 campo_nombre2;
....................................................

tipo_dato_n campo_nombre_n;

};
donde:
1. nombre_tipo: nombre de la estructura o modelo creado, bajo el cual servir
para crear las diversas instancias de la estructura.
2. tipo_dato_1, tipo_dato_2,..., tipo_dato_n: son los tipos de datos respectivos de
cada dato miembro.
3. campo_nombre_1,campo_nombre_2,...,campo_nombre_n son los nombres
respectivos.
6.3 Variables (instancias)

Para utilizar una estructura as definida se debe declarar tambin instancias de
ella:

nombre_tipo instancia_1, instancia_2,.....,instancia_n;
275
As, las variables reales con las que se proces los datos son: instancia_1,
instancia_2,...,instancia_n y no nombre_tipo, el cual slo define la estructura de
cada una de aqullas.
Tambin es posible declarar las instancias del tipo al final de la declaracin de la
estructura:
struct nombre_tipo
{ <miembros>
} instancia_1,instancia_2,...,instancia_n;
Usando la estructura Empleado, se tiene la siguiente sintaxis:

struct Empleado
{ char codigo[10];
char apellidos[20], sexo;
int edad;
float sueldo;

} empl_1 empl_2, empl_3;
donde: empl_1 empl_2, empl_3, son las variables respectivas.
Pero puede mejorarse el almacenenamiento de los datos de la estructura
empleada, es decir, se debe almacenar en un vector de longitiud definida por el
usuario, de tal manera que cada registro sea un elemento del vector, para esto,
definir la instancia tipo registo: Lista_empleados[3]
6.4 Anidamiento de registros

Las estructuras pueden anidarse (tambin se les denomina estructuras jerrquicas),
es decir, pueden ser datos miembro de otra estructura.
6.5 Acceso a los elementos de una estructura

Para acceder a los miembros de la estructura, se usa el operador ..
Sintaxis
Operador punto
nomb_var_de_estructura.nombre_var_miembro
Como se mencion, para trabajar con estructuras anidadas, se utilizar el punto
. varias veces para acceder a los miembros de la estructura ms interna.

struct Empleado
{char codigo[10];char apellidos[20], sexo;
int edad; float sueldo;
} Lista_empleado[4] // el vector cuyos elementos seran registros
276
6.6 Aplicaciones
Problema 1. Disear un programa que permita almacenar, en un vector de tamao
mximo 100, datos de n alumnos (n definido por usuario), donde la informacin
del alumno consta de: cdigo, nombres y edad. Genere reportes para conocer:
a. Total de alumnos con edades pares.
b. Total de alumnos con edades impares.
c. Listado de alumnos ordenados en forma ascendente por edad.
Solucin //struct_alumnos.cpp
# define maxal 100
# define linea ----------------------------------------------------------
struct alumnos
{ char codigo[10]; char nombre[20]; int edad;
};
void main()
{ struct alumnos aux,datos[maxal];
int i,j,n,par=0,impar=0;
gotoxy(2,2);cout<<Ingrese nmero de alumnos: ;cin>>n;
for(i=1;i<=n;i++)
{ cout<<\n\tAlumno[<<i<<]<<endl;
cout<<\tCodigo = ;gets(datos[i].codigo);

cout<<\tNombre = ;gets(datos[i].nombre);
cout<<\tedad = ;cin>>datos[i].edad; cout<<\n;
}
for(i=1;i<=n-1;i++)
{ for(j=i+1;j<=n;j++)
{ if (datos[i].edad>datos[j].edad)
{ aux=datos[i];datos[i]=datos[j];
datos[j]=aux;
} } }
for(i=1;i<=n;i++)
{ if (datos[i].edad % 2==0)

{ par++;
}

else{ impar++;
}
}
clrscr();
gotoxy(2,1);cout<<REPORTE DE ALUMNOS ; gotoxy(1,2);cout<<linea ;
gotoxy(2,4);cout<<Total del alumnos con edad par : <<par;
gotoxy(2,5);cout<<Total del alumnos con edad impar : <<impar;
gotoxy(2,7); cout<<REPORTE DE ALUMNOS ORDENADOS POR EDAD
EN FORMA ASCENDENTE;
277
gotoxy(2,8); cout<< Codigo
Nombre
Edad<<endl;
gotoxy(2,9); cout<<linea ;
for(i=1;i<=n;i++) { gotoxy(4,10+i);
cout<<datos[i].codigo<< <<datos[i].nombre<< <<datos[i].edad;
getche();}
Problema 2. Disear un programa que permita almacenar en un vector de tamao

mximo 100, datos de n alumnos (n definido por usuario), donde la informacin
del alumno consta de: apellidos, nombres, cdigo, edad, tres prcticas calificadas
y dois exmenes (parcial y final). Genere reportes para conocer:
a. Promedio de prcticas
b. Promedio final
c. Condicin de alumno: aprobado o desaprobado. Si promedio final es mayor a
10.5 alumno APROBADO, sino DESAPROBADO
d. Cantidad de alumnos aprobados y alumnos desaprobados
Solucin //struct_alum_prom.cpp
# define linea ------------------------------------------------------------------------
struct alumno
{ char apellido[50], nombre[40, codigo[10];
int edad; float ex1,ex2,ex3,pf,p1,p2,p3,pp;
} datos[max],aux;
void main()
{ int n,i,aprob=0,desap=0; clrscr();
do {gotoxy(3,1);cout<< Ingrese Nmero de Alumnos: ;cin>>n;

} while(n<=0);

for(i=1; i<=n; i++)

gotoxy(4,2);cout<<ALUMNO [<<i<<]<<endl;

gotoxy(5,3);cout<< Apellido : ;gets(datos[i].apellido);

gotoxy(5,4);cout<< Nombre : ;gets(datos[i].nombre);

gotoxy(5,5);cout<< Cdigo : ;cin>>datos[i].codigo;

gotoxy(5,6);cout<< Edad : ;cin>>datos[i].edad;
278

do{gotoxy(5,7);clreol();cout<< Examen Parcial: ;cin>>datos[i].ex1;

}while(datos[i].ex1<0 || datos[i].ex1>20);
do{ gotoxy(5,8);clreol();cout<< Examen Final: ;cin>>datos[i].ex2;

}while(datos[i].ex2<0 || datos[i].ex2>20);
do{ gotoxy(5,9);clreol();cout<< Practica 1 : ;cin>>dates[i].p1;

}while(dates[i].p1<0 || dates[i].p1>20);
do{ gotoxy(5,10);clreol();cout<< Practica 2 : ;cin>>dates[i].p2;

do{gotoxy(5,11);clreol(); cout<< Practica 3 : ;cin>>dates[i].p3;
clrscr();
dates[i].pp=(dates[i].p1+datos[i].p2+datos[i].p3)/3;
datos[i].pf=(datos[i].ex1 + datos[i].ex2 + datos[i].pp)/3;
} // buscando alumnos aprobados y desaprobados
clrscr();
for(i=1; i<=n; i++)
{if(dates[i].pf>10.5)
{ aprob++;
}
else{ desap++;
}
}
gotoxy(2,13); cout<<=> Total de Alumnos Aprobados: <<aprob<<endl;
gotoxy(2,14); cout<<=> Total de Alumnos Desaprobados: <<desap<<endl;
for(i=1; i<=n; i++)
{gotoxy(2,2);
cout<<Apellido;gotoxy(12,2); cout<<Nombre ;
gotoxy(20,2); cout<<Cdigo ;gotoxy(29,2); cout<<Edad ;
gotoxy(35,2); cout<<Ex_P; gotoxy(41,2); cout<<Ex_F;
gotoxy(47,2); cout<<Prom_p ;gotoxy(56,2); cout<<Promedio_f;
gotoxy(68,2); cout<<Condicin;gotoxy(1,3); cout<<linea;
gotoxy(2,3+i); cout<<dates[i].apellido;gotoxy(12,3+i); cout<<dates[i].nombre;
gotoxy(21,3+i); cout<<dates[i].codigo;gotoxy(30,3+i); cout<<dates[i].edad;
gotoxy(36,3+i); cout<<dates[i].ex1;gotoxy(42,3+i); cout<<dates[i].ex2;
gotoxy(48,3+i); cout<<dates[i].pp;gotoxy(58,3+i); cout<<dates[i].pf;
if(dates[i].pf>10.5)
{ gotoxy(68,3+i); cout<<\APROBO\<<endl;
}
else
{ gotoxy(68,3+i); cout<<\DESAPROBO\<<endl;
}
}
getch();
}
279
Salidas. Despus de ingresar los registros, se obtiene:
Problema 3. Disear un programa que permita crear tres funciones y que realicen
los siguientes procesos:
leer_reg(): permite almacenar en un vector de tamao mximo tres personas, con
los siguientes datos: nombre, edad, sexo, estatura, color de piel, color de ojos y
nacionalidad.
ordenar(): permite ordenar los registros por nombre.
listar(): permite generar reportes.
Solucin //struct_persona.cpp
# define linea ---------------------------------------------------------------
struct persona
{char nombre[30], sexo, piel[10], ojos[10], nacionalidad[15];
int edad, altura;
}inf[70];
//Prototipos de funciones
void leer_reg();void ordenar();void listar();
voidmain(){ char opcion;
do{clrscr();gotoxy(21,9);cout<<ELIJA UNA OPCIN ;gotoxy(10,10);cout<< linea;
gotoxy(27,12);cout<<[A] Ingresar Datos;gotoxy(27,13);cout<<[B] Ordenar;
gotoxy(27,14);cout<<[C] Listar;gotoxy(27,15);cout<<[T] Terminar\n\n\n\n\
n\n;
opcion=tolower(getche());
switch(opcion)
{ case t:return 0;case a:leer_reg();
break;case b:ordenar();break;
case c:listar();break;}
}while(opcion!=t);return 0;
}
void leer_reg()
{ int i;
for(i=0;i<cantidad_p;i++){clrscr();flushall();
280
gotoxy(20,10);cout<<Introduzca un nombre: ;gets(inf[i].nombre);

gotoxy(20,11);cout<<edad: ;
scanf(%i,&inf[i].edad);
gotoxy(20,12);cout<<sexo: ;
scanf(%c,&inf[i].sexo);
gotoxy(20,13);cout<<estatura (cm.): ; scanf(%i,&inf[i].altura);
gotoxy(20,14);cout<<color de piel: ;
scanf(%s,&inf[i].piel);
gotoxy(20,15);cout<<color de ojos: ; scanf(%s,&inf[i].ojos);
gotoxy(20,16);cout<<nacionalidad: ;
scanf(%s,&inf[i].nacionalidad);}}
void ordenar()
{clrscr();int i,j;persona aux;
for(i=0;i<cantidad_p-1;i++)
for(j=0;j<cantidad_p-1-i;j++)
{ if(strcmp(inf[j].nombre,inf[j+1].nombre)>0)
{ aux=inf[j]; Inf[j]=inf[j+1]; inf[j+1]=aux;
} };
gotoxy(30,3);cout<<LISTA ORDENADA; gotoxy(5,5);cout<<NOMBRE;
gotoxy(20,5);cout<<EDAD;
gotoxy(28,5);cout<<SEXO;
gotoxy(35,5);cout<<ESTATURA;
gotoxy(48,5);cout<<PIEL;
gotoxy(55,5);cout<<OJOS;
gotoxy(65,5);cout<<NACIONALIDAD;
for(i=0;i<cantidad_p;i++)
{gotoxy(5,i+10);cout<<inf[i].nombre;
gotoxy(21,i+10);cout<<inf[i].edad;
gotoxy(25,i+10);cout<<inf[i].sexo; gotoxy(37,i+10);cout<<inf[i].altura;
gotoxy(45,i+10);cout<<inf[i].piel;
gotoxy(55,i+10);cout<<inf[i].ojos;
gotoxy(65,i+10);cout<<inf[i].nacionalidad;} getch();}
void listar(){clrscr(); int i;
gotoxy(5,5);cout<<NOMBRE;
gotoxy(20,5);cout<<EDAD;
gotoxy(28,5);cout<<SEXO;
gotoxy(35,5);cout<<ESTATURA;
gotoxy(48,5);cout<<PIEL;
gotoxy(55,5);cout<<OJOS;
gotoxy(65,5);cout<<NACIONALIDAD; gotoxy(4,6);cout<<linea;
for(i=0;i<cantidad_p;i++)
{gotoxy(5,i+10);cout<<inf[i].nombre;
gotoxy(21,i+10);cout<<inf[i].edad;
gotoxy(25,i+10);cout<<inf[i].sexo;
gotoxy(37,i+10);cout<<inf[i].altura;
gotoxy(45,i+10);cout<<inf[i].piel;
gotoxy(55,i+10);cout<<inf[i].ojos;
gotoxy(65,i+10);cout<<inf[i].nacionalidad;}getch();}
Parte I. Men de opciones
281
Parte II. (opcin B) reporte ordenado por nombre
Parte III. (opcin C) listado de todos los registros

Problema 4. Disear un programa que permita leer n alumnos, por cada alumno
m cursos y por cada curso p prcticas (n, m y p son definidos por el usuario) los
alumnos, cursos y notas deben almacenarse en vectores de tamao definido por
usuario. Los datos a procesar son:
1. Para alumnos: leer su cdigo, apellidos y nombres
2. Para cursos: leer nombre de cursos
3. Para notas, leer prcticas, exmenes parcial y final. Asimismo, si el promedio
final por curso es menor a 6.1, debe leer examen sustitutorio y reemplazar al
examen parcial o final segn donde corresponda.
Los reportes por alumno consisten en: apellidos y nmero de cursos, nombre del
curso, condicin del curso (aprobado o desaprobado) y su nota final.
Solucin //alumn_curs_prom.cpp
struct cursos {char nombre_curso[30]; int numero_practica;
float practica[max_al],pp,ep,ef,es,pf;
};
struct alumnos
{char codigo[8],apellido[30],nombre[30]; int numero_curso;
cursos curso[max_al];
//anida la estructura: curso
}alumno[max_al];
void main()
{int cantidad,i,j,k,l,m,aux; char *op; clrscr();
282
cout<<\n\n\tIngrese numero de Alumnos :; cin>>cantidad;

cout<<\n\t Ingreso de datos de los alumnos : \n;
for(i=0;i<cantidad;i++)
{cout<<\t\tAlumno [<<i+1<< ]= <<endl;
cout<<\n\t\tcodigo=;gets(alumno[i].codigo);
cout<<\t\tApellido=;gets(alumno[i].apellido);
cout<<\t\tnombre = ; gets(alumno[i].nombre);
cout<<\n\t\tIngrese numero de Cursos :;cin>>alumno[i].numero_curso;
for(j=0;j<alumno[i].numero_curso;j++)
{cout<<\t\t\tNombre del curso [<<(j+1)<<]=;
gets(alumno[i].curso[j].nombre_curso);
cout<<\n\t\t\tIngrese nmero de prcticas: ;
cin>>alumno[i].curso[j].numero_practica;
for(k=0;k<alumno[i].curso[j].numero_practica;k++)
{cout<<\t\t\t\tPrctica[<<(k+1)<<]=; cin>>alumno[i].curso[j].practica[k];}
cout<<\n\t\t\t\tIngrese Examen parcial : ; cin>>alumno[i].curso[j].ep;
cout<<\n\t\t\t\tIngrese Examen final : ; cin>>alumno[i].curso[j].ef;
if (alumno[i].curso[j].numero_practica>4)
{for(l=0;l<alumno[i].curso[j].numero_practica-1;l++)
for(m=l+1;m<alumno[i].curso[j].numero_practica;m++)
if (alumno[i].curso[j].practica[l]<alumno[i].curso[j].practica[m])
{aux=alumno[i].curso[j].practica[l];
alumno[i].curso[j].practica[l]=alumno[i].curso[j].practica[m];
alumno[i].curso[j].practica[m]=aux;
}
alumno[i].curso[j].numero_practica--;
}
alumno[i].curso[j].pp=0;
for(l=0;l<alumno[i].curso[j].numero_practica;l++)
alumno[i].curso[j].pp=alumno[i].curso[j].pp+alumno[i].curso[j].practica[l];
alumno[i].curso[j].pp=alumno[i].curso[j].pp/alumno[i].curso[j].numero_practica;
alumno[i].curso[j].pf=(alumno[i].curso[j].ep+alumno[i].curso[j].ef+alumno[i].
curso[j].pp)/3;
if (alumno[i].curso[j].pf>=6.1)
{op=N;cout<<\n\t\t\t\tDesea dar Sustitutorio(S/N) :; cin>>op;
}
if ((op[0]==s)||(op[0]==S))
{cout<<\n\t\t\t\tIngresar nota sustitutoria :;cin>>alumno[i].curso[j].es;
if (alumno[i].curso[j].ep>alumno[i].curso[j].ef)
alumno[i].curso[j].ef=alumno[i].curso[j].es;
else
alumno[i].curso[j].ep=alumno[i].curso[j].es;
alumno[i].curso[j].pf=(alumno[i].curso[j].ep+alumno[i].curso[j].ef+alumno[i].
curso[j].pp)/3;
}
283
}
}
clrscr();
cout<<REPORTES DE ALUMNOS POR APELLIDOS, NUMERO DE CURSOS,
ESTADO Y NOTA FINAL<<endl;
for(i=0;i<cantidad;i++)
{ cout<<\n\n\t\t El alumno <<alumno[i].apellido;
cout<< llevo <<alumno[i].numero_curso<< cursos : \n;

for(j=0;j<alumno[i].numero_curso;j++)

{cout<<\t\t\t Su curso <<alumno[i].curso[j].nombre_curso;

if (alumno[i].curso[j].pf>=10.0)

cout<< Aprobo con <<alumno[i].curso[j].pf;

else
cout<< Desaprob con <<alumno[i].curso[j].pf;

}
getch();
}
}
Entrada de datos y salida de datos
Problema 5. Disear un programa que permita crear tres funciones para procesar
registros de n alumnos (n definido por usuario), donde cada funcin realiza los
siguientes procesos:
Ingresa(): permite ingresar registros de alumnos por nombre y edad en un vector
de tamao 100. El usuario define la cantidad real de registros a procesar.
imprime(): genera un reporte de todos los registros ingresados.
Mayoredad(): busca el alumno con mayor edad.
Solucin//STRUCT_Al_mayor.cpp
#include<conio.h>
284
# define linea ----------------------------------------------------------

void ingresa();
void imprime();
int mayoredad(); // functions prototipos
int i, mayor,cmy=0,n;
struct alumno {char nombre[20]; int edad;} lista[100];
void main(){ clrscr();cout<<\n\tINGRESO DE ALUMNOS :;
cout<<\n\t<<linea; cout<<\n\tIngrese cantidad de registros :;cin>>n;
ingresa();imprime(); mayoredad();
cout<<\n\tAlumno de mayor edad es :<<mayor;getche(); }
void ingresa()
{ for(i=1;i<=n;i++)

{cout<<\n\tAlumno[<<i<<];

cout<<\n\tNombre = ; gets(lista[i].nombre);

cout<<\tEdad =; cin>>lista[i].edad;
cout<<\t;
} }
int mayoredad() {mayor=lista[1].edad;
for (int i=2;i<=n;i++)if (lista[i].edad>mayor)
{mayor=lista[i].edad; }return (mayor);
}
void imprime()
{ clrscr(); cout<< \n\tReporte de todos los Registros <<endl;
cout<<linea; cout<<\n\tNombre Edad <<endl; cout<<linea<<endl;
for(i=1;i<=n;i++)
{cout<<\t<<i<<.-<<lista[i].nombre<< <<lista[i].edad<<endl;
}
}
Ingreso de registros
Reporte de registros
Problema 6. Disear un programa que permita procesar registros de alumnos

por cdigo, apellidos y edad. Los mdulos a implementar son:
Primero, debe disear una funcin marco (), que genere una ventana (marco)
para que en su interior contenga las siguientes opciones:
285
< 1 > Crear ARCHIVO;

< 2 > Ingreso de registros;
< 3 > Ingresar nuevos registros;
< 4 > Eliminar registros;
< 5 > Registros ordenados por edad ;
< 6 > Registros ordenados por cdigo ;
< 7 > Registros ordenados por apellidos;
<8>Consultas por eleccin de un dato;
< 9 > Salir;
Donde cada opcin realiza las siguientes tareas:
< 1 > Crear ARCHIVO:permite crear un archivo.
< 2 > Ingreso de Registros: permite ingresar el nmero de registros.
< 3 > Ingresar nuevos registros: solicita el nmero de registros a insertar.
< 4 > Eliminar Registros:solicita el nmero de registro a eliminar.
Opciones < 5 >,< 6 > y< 7 > Ordena en forma ascendente por el campo que usted
seleccione.
< 8 > Consultas por eleccin de un dato: slo genera reporte del registro por el
dato personal que usted edite (ejemplo: por cdigo, debe ingresar cdigo ledo).
< 9 > Salir: enva el mensaje: Esta seguro que quiere salir del sistema (s/n):. Si
edita S, usted sale del modo compilacin al programa fuente, en otro caso regresa
al men principal.
Finalmente, despus de compilar el programa lo primero que se debe generar es
un informe de la fecha y la hora.
Solucin //struct_menu_ins.cpp
struct Alumnos
{char cod[10], apell[20], nomb[20]; int edad;
}lista[cant_alumnos],aux,aux1,aux2;
void marco()
{ int i;
time_t t;
t = time(&t);
gotoxy(20,3);cout<<La fecha y hora actual es :<<ctime(&t);
//esquinas
for (i=11 ;i <=69 ; i++) {gotoxy(i,4) ;cout<<; gotoxy(i,5) ;cout<<;
gotoxy(i,20) ;cout<<;
}
gotoxy(70,4) ;cout<<; gotoxy(70,20) ;cout<<;
//esquinas
for(i=5;i<=19;i++)
{gotoxy(10,i) ;cout<<; gotoxy(70,i );cout<<;
} }
void main()
{ char rpta,rpta1, arch[25];char apelli[10];
int n=0,i,j,k,l,opc,a,e,u,o,opc1,edadal,codi,m,aum,eli;
do {
do {marco();
286
gotoxy(23,5);cout<< BIENVENIDOS AL SISTEMA DE CONSULTAS ;

gotoxy(16,7);cout<<< 1 > Crear Registro;
gotoxy(16,8);cout<<< 2 > Ingreso de Registros;
gotoxy(16,9);cout<<< 3 > Ingresar nuevos registros;
gotoxy(16,10);cout<<< 4 > Eliminar Registros;
gotoxy(16,11);cout<<< 5 > Registros ordenados por Edad ;
gotoxy(16,12);cout<<< 6 > Registros ordenados por Codigo ;
gotoxy(16,13);cout<<< 7 > Registros ordenados por Apellidos;
gotoxy(16,14);cout<<< 8 > Consultas por eleccin de un dato;
gotoxy(16,15);cout<<< 9 > Salir ;
gotoxy(14,18);cout<< <Elija opcin> ;cin>>opc;clrscr();
}while((opc!=1)&&(opc!=2)&&(opc!=3)&&(opc!=4)&&(opc!=5)&&(opc!=6)&&(op
c!=7)&&(opc!=8)&&(opc!=9));
switch(opc)
{ clrscr();case 1:{marco();
gotoxy(25,5);cout<< CREANDO EL ARCHIVO...... ;
gotoxy(16,7);cout<<Ingrese nombre de Achivo : ;gets(arch);
gotoxy(16,8);cout<<Ingrese nmero de Alumnos: ; cin>>n; clrscr();
}
break;
case 2:{marco();
gotoxy(22,5);cout<< INGRESAR DATOS..... ;
gotoxy(15,9);cout<< Ingrese Datos del alumno ==> 1;
for(i=1;i<=n;i++)
{gotoxy(14,10+i);cout<<Cdigo : ;gets(lista[i].cod);
gotoxy(14,12+i);cout<<Apellidos : ;gets(lista[i].apell);
gotoxy(14,14+i);cout<<Nombre : ;gets(lista[i].nomb);
gotoxy(14,16+i);cout<<Edad
: ;cin>>lista[i].edad; clrscr(); marco();
gotoxy(22,5);cout<<INGRESAR DATOS.... ;
gotoxy(15,9); cout<<Ingrese datos del alumno ==> <<(i+1);
} clrscr();break;
case 3:{ marco();
gotoxy(22,5);cout<< INSERTANDO NUEVOS REGISTROS.... ;
gotoxy(14,9);cout<<Ingrese nmero de Alumnos :;cin>>aum;
gotoxy(14,11);cout<<Ingrese Datos del alumno ==> <<(n+1);
for(i=(n+1);i<=(n+aum);i++)
{gotoxy(14,11+i);cout<<Cdigo : ;gets(lista[i].cod);

gotoxy(14,12+i);cout<<Apellidos : ;gets(lista[i].apell);

gotoxy(14,13+i);cout<<Nombre : ;gets(lista[i].nomb);

gotoxy(14,14+i);cout<<Edad
: ;cin>>lista[i].edad; clrscr(); marco();

gotoxy(22,5);cout<<INGRESAR DATOS ....;
gotoxy(15,9);cout<<Ingrese datos del alumno ==> <<(i+1);
}
n=n+aum;system(cls); marco();

gotoxy(15,9);cout<< Actualmente, Ud. tiene <<n<< Registros ;
287
gotoxy(20,16);system(pause); system(cls); } break;

case 4:{ marco();
gotoxy(22,5);cout<< ELIMINACIN DE REGISTROS.... ;

gotoxy(14,9);cout<<Ingrese nmero de Registro a Eliminar:;cin>>eli;

for(i=1;i<=n;i++){ if(i==eli)
{lista[i]=lista[i-1]; n=n-1; }
gotoxy(14,12);cout<<Se ha eliminado el Registro #: <<i;
} system(cls);
marco();

gotoxy(15,9);cout<< Actualmente, Ud. tiene <<n<< Registros ;
gotoxy(20,16);system(pause);
system(cls); } clrscr(); break;
case 5:{ system(cls); marco();
for(i=1;i<=(n-1);i++)
for(j=(i+1);j<=n;j++)
{ if(lista[i].edad>lista[j].edad)

{aux=lista[i]; lista[i]=lista[j]; lista[j]=aux; }
}
}

gotoxy(12,17);cout<< REPORTE POR EDAD ;

gotoxy(34,17);cout<< Esta usando el ARCHIVO :<<arch;

gotoxy(14,19);cout<<Cdigo; gotoxy(28,19);cout<<Apellidos;

gotoxy(50,19);cout<<Nombres; gotoxy(65,19);cout<<Edad;
for(i=1;i<=n;i++)

{ gotoxy(14,20+i);cout<<lista[i].cod;
gotoxy(28,20+i);cout<<lista[i].apell; gotoxy(50,20+i);cout<<lista[i].nomb;
gotoxy(65,20+i);cout<<lista[i].edad;}
for(k=1;k<=59;k++)

{ gotoxy(k+10,18);cout<<_;
gotoxy(k+10,16);cout<<_;

gotoxy(k+10,20+i);cout<<_;

} //Verticales.
for(l=1;l<=(i+5);l++)

{ gotoxy(10,15+l);cout<<|;

if(l<=(i+3)) { gotoxy(25,17+l);cout<<|; gotoxy(47,17+l);cout<<|;
gotoxy(62,17+l);cout<<|;
}

gotoxy(70,13+l);cout<<|; }break;
case 6:{ system(cls);
marco();
for(i=1;i<=(n-1);i++)
for(o=(i+1);o<=n;o++)

{if(atoi(lista[i].cod)>atoi(lista[o].cod)) { aux1=lista[i];

lista[i]=lista[o]; lista[o]=aux1; }
}

gotoxy(12,17);cout<< REPORTE POR CODIGO;

gotoxy(14,19);cout<<Cdigo;
gotoxy(28,19);cout<<Apelli
dos;
gotoxy(50,19);cout<<Nombres;
gotoxy(65,19);cout<<Edad;
for(i=1;i<=n;i++)
288
{gotoxy(14,20+i);cout<<lista[i].cod;
gotoxy(28,20+i);cout<<lista[i].
apell;
gotoxy(50,20+i);cout<<lista[i].nomb; gotoxy(65,20+i);cout<<lista[i].edad;
}
for(k=1;k<=59;k++)
gotoxy(k+10,20+i);cout<<_;}
for(l=1;l<=(i+5);l++)


if(l<=(i+3))
{
}
gotoxy(70,15+l);cout<<|; }
} break;
case 7:{ system(cls);
marco();
for(i=1;i<=(n-1);i++)
for(m=(i+1);m<=n;m++){ if(strcmp(lista[i].apell,lista[m].apell)>0)
{aux2=lista[i];
lista[i]=lista[m];
lista[m]=aux2; }
}

gotoxy(12,17);cout<< REPORTE POR APELLIDO;

gotoxy(14,19);cout<<Codigo;
gotoxy(28,19);cout<<Apellidos;
for(i=1;i<=n;i++)

{
gotoxy(14,20+i);cout<<lista[i].cod;
gotoxy(28,20+i);cout<<lista[i].apell;

gotoxy(50,20+i);cout<<lista[i].nomb;
gotoxy(65,20+i);cout<<lista[i].edad;

}// marcos Horizontales.
for(k=1;k<=59;k++)
{gotoxy(k+10,18);cout<<_;

gotoxy(k+10,20+i);cout<<_;
}
for(l=1;l<=(i+5);l++)
{gotoxy(10,13+l);cout<<|;
if(l<=(i+3)) {gotoxy(25,17+l);cout<<|; gotoxy(47,17+l);cout<<|;
gotoxy(70,15+l);cout<<|;} } break;
case 8:{marco();
gotoxy(22,5);cout<< REPORTE SEGUN ELECCIN DE DATOS ;
gotoxy(26,7);cout<< MEN DE OPCIONES ;
do {gotoxy(14,9);cout<<< 1 > Por Edad;

gotoxy(14,10);cout<<< 2 > Por Cdigo;
289

gotoxy(14,11);cout<<< 3 > por Apellidos;

gotoxy(14,12);cout<<Ingrese Opcin ;cin>>opc1;
switch(opc1)
{ case 1:
{clrscr(); marco();
gotoxy(28,5);cout<< REPORTE SEGN EDAD ;
gotoxy(35,6);cout<< Esta usando el ARCHIVO: <<arch;
gotoxy(28,8);cout<<Ingrese su edad ;cin>>edadal;clrscr();
for(i=1;i<=n;i++)

{ if(lista[i].edad==edadal)

{ gotoxy(25,17);cout<<SISTEMA DE CONSULTAS POR EDAD;

gotoxy(14,19);cout<<Codigo;
gotoxy(28,19);cout<<Apellid
os;
gotoxy(65,19);cout<<Edadgotoxy(14,20+i);cout<<lista[i].cod;
gotoxy(50,20+i);cout<<lista[i].nomb; otoxy(65,20+i);cout<<lista[i].edad;

}
}
for(k=1;k<=59;k++)


gotoxy(k+10,20+i);cout<<_; }
for(l=1;l<=(i+5);l++)

if(l<=(i+3))


gotoxy(70,15+l);cout<<|;}
gotoxy(50,16+l);cout<<Desea Salir (s/n):;cin>>rpta1;clrscr(); marco();
} break;
case 2:
{clrscr(); marco();
gotoxy(28,5);cout<< REPORTE SEGN CDIGO ;
gotoxy(30,14);cout<<Ingrese su Cdigo ;cin>>codi;clrscr();
for(i=1;i<=n;i++)
{if(atoi(lista[i].cod)==codi)

{ gotoxy(11,15);cout<< ARCHIVO : <<arch;

gotoxy(25,17);cout<<SISTEMA DE CONSULTAS POR CDIGO;


gotoxy(50,19);cout<<Nombres; gotoxy(65,19);cout<<Edad;

gotoxy(14,20+i);cout<<lista[i].cod; gotoxy(28,20+i);cout<<lista[i].apell;

gotoxy(50,20+i);cout<<lista[i].nomb; gotoxy(65,20+i);cout<<lista[i].edad;

} }
for(k=1;k<=59;k++)


gotoxy(k+10,20+i);cout<<_;}
for(l=1;l<=(i+5);l++)
290
{gotoxy(11,15+l);cout<<|;
if(l<=(i+3))
{ gotoxy(25,17+l);cout<<|; gotoxy(47,17+l);cout<<|;
gotoxy(50,16+l);cout<<Desea Salir (s/n): ;cin>>rpta1;clrscr(); marco(); }
break;
case 3: { clrscr();marco();
gotoxy(28,5);cout<< REPORTE SEGN APELLIDOS ;
gotoxy(30,18);cout<<Ingrese su Apellido ;gets(apelli);clrscr();
for(i=1;i<=n;i++)
{ if(strcmp(lista[i].apell,apelli)==0)
{ gotoxy(11,15);cout<<Registro <<arch;
gotoxy(25,17);cout<<SISTEMA DE CONSULTAS POR APELLIDOS;
gotoxy(14,20+i);cout<<lista[i].cod;
gotoxy(50,20+i);cout<<lista[i].
nomb;
gotoxy(65,20+i);cout<<lista[i].edad;
}
}
for(k=1;k<=59;k++)
{gotoxy(k+10,18);cout<<_;
gotoxy(k+10,20+i);cout<<_;} //Verticales.
for(l=1;l<=(i+5);l++)
if(l<=(i+3))
}
gotoxy(70,15+l);cout<<
}
gotoxy(50,16+l);cout<<Desea Salir
(s/n):;cin>>rpta1;
} break;
} while(rpta1==n);clrscr(); } break;
case 9:{marco();
for(e=1;e<=50;e++)

{ gotoxy(12+e,8);cout<<_;
gotoxy(12+e,10);cout<<_;}
291
for(u=1;u<=2;u++)
{gotoxy(12,8+u);cout<<|;
gotoxy(63,8+u);cout<<|;
}
gotoxy(14,9); cout<<Continuar.. s/n):; cin>>rpta;clrscr();
a=6;
}
break; }
}while((rpta==n)||(a<=5));}
Ingresando registros, despus de asignar el nombre al archivo, el nmero de
registros, usted usa la opcin 2, la cual permite ingresar datos de los alumnos.
Problema 7. Disear un programa que permita leer n alumnos (n ingresado por
el usuario) por cdigo, nombre, edad y facultad (existen tres facultades: sistemas,
industriales y mecnica). El programa debe permitir los siguientes:
a. Lectura de n de empleados dentro de un marco (ventana), fecha y hora de
implementacin del programa. El programa indica el nmero de registro a
editar cada vez que contesta S de la siguiente pregunta DESEA SEGUIR
INGRESANDO DATOS? (S/N).
b. Reporte de todos los registros ingresados.
c. Reporte del promedio de edades de alumnos por facultad.
d. Reporte de la edad mayor y posicin donde se localiza el registro.
Solucin //struct_alum_fac.cpp
#include<iostream.h>;
#define linea __________________________________________;
struct alum_universidad
{int codigo, edad;
char nomb[20], facu[20];
}alumno[20];
void marco(); void ingreso(); void imprimir(); void promedio(); void mayor();
int i=1, j; //implementacin de las funciones prototipo
void marco() {int i;
time_t t;
t = time(&t);
gotoxy(20,3);cout<<La fecha y hora actual es :<<ctime(&t);
textcolor(11) ;
//esquinas
//esquinas
for (i=11 ;i <=69 ; i++)
{ gotoxy(i,4) ;cout<<; gotoxy(i,5) ;cout<<;
// lineas horizontales
gotoxy(i,20) ;cout<<; }
gotoxy(70,4) ;cout<<; gotoxy(70,20) ;cout<<;
//esquinas
for(i=5;i<=19;i++) {gotoxy(10,i) ;cout<<;
//lineas verticales
gotoxy(70,i );cout<<;
} }
void ingreso() { char opc; i=1;
marco(); gotoxy(20,5); cout<<Datos de Alumno ==> 1;
do { gotoxy(12,8); cout<<Ingrese Codigo
: ; cin>>alumno[i].codigo;
292
gotoxy(12,9); cout<<Ingrese Nombre ; gets(alumno[i].nomb);

gotoxy(12,10); cout<<Ingrese Edad
: ; cin>>alumno[i].edad;
gotoxy(12,11); cout<<Ingrese Facultad : ; gets(alumno[i].facu);
i++;
gotoxy(12,14); cout<<DESEA SEGUIR INGRESANDO DATOS
(S/N):;cin>>opc;
if(opc==n || opc==N)
{gotoxy(12,18); cout<<Total de alumnos ingresados : <<(i-1)<<endl<<endl;

getch(); } clrscr(); marco();
gotoxy(20,5); cout<<Alumno ==> <<i;
}while(opc==S||opc==s);
}
void reportes() {clrscr(); marco();
gotoxy(20,5); cout<<...MODULO DE REPORTES...;
gotoxy(12,8); cout<<N. Cdigo Nombre Edad Facultad;
for(j=1; j<i; j++)
{gotoxy(13,10+j); cout<<(j)<<.-;
gotoxy(18,10+j); cout<<alumno[j].codigo;
gotoxy(27,10+j); cout<<alumno[j].nomb; gotoxy(38,10+j); cout<<alumno[j].edad;
gotoxy(45,10+j); cout<<alumno[j].facu; }
gotoxy(20,22);system(pause); }
void promedio()
{ double suma1=0, suma2=0, suma3=0, prom1, prom2, prom3;
int cont1=0, cont2=0, cont3=0;
clrscr();
marco();
gotoxy(20,5); cout<<...MODULO DE REPORTES...;
for(j=1; j<i; j++) if(strcmp(alumno[j].facu, sistemas )==0||strcmp(alumno[j].
facu, Sistemas )==0||strcmp(alumno[j].facu, SISTEMAS )==0)
{ cont1++; suma1=suma1+alumno[j].edad;
}
if(strcmp(alumno[j].facu, INDUSTRIAL)==0) { cont1++;
suma2=suma2+alumno[j].edad;
}
if(strcmp(alumno[j].facu, mecanica)==0)
{ cont3++;
suma3=suma3+alumno[j].edad; } }
if(cont1!=0) { prom1=suma1/cont1; }
else { prom1=0; }
else { prom2=0; }
else { prom3=0; }
gotoxy(16,7); cout<< PROMEDIO DE EDADES POR FACULTADES ;
gotoxy(18,10); cout<< SISTEMAS
INDUSTRIALES
MECANICA ;
gotoxy(23,12); cout<<prom1;
gotoxy(35,12); cout<<prom2;
gotoxy(50,12); cout<<prom3; gotoxy(20,22);system(pause); }
void mayor() { int pos, mayor=0;
clrscr();
marco();
gotoxy(20,5); cout<< .... ALUMNOS Y MAYOR EDAD .... ;
293
for(j=0;j<i;j++)

{if(strcmp(alumno[j].facu,sistemas)==0)

{if(alumno[j].edad>mayor)
{mayor=alumno[j].edad; pos=j;
}
gotoxy(14,10); cout<<El alumno de Sistemas con Edad Mayor es :
<<alumno[pos].nomb;
gotoxy(14,11);cout<<alumno[pos].nomb<< esta en la posicin <<(j+1);
}
if(strcmp(alumno[j].facu,industriales)==0)
{ mayor=alumno[j].edad; pos=j; }
gotoxy(14,13);cout<<El alumno de Industriales con Edad Mayor es :
<<alumno[pos].nomb;
gotoxy(14,14);cout<<alumno[pos].nomb<< esta en la posicin <<(j+1);}
if(strcmp(alumno[j].facu,mecanica)==0)

{ mayor=alumno[j].edad;
pos=j;
}
gotoxy(14,16); cout<<El alumno de Mecnica con Edad Mayor es :
<<alumno[pos].nomb;
gotoxy(14,17);cout<<alumno[pos].nomb<< esta en la posicin<<(j+1);
} } gotoxy(20,22);system(pause); }
void main()
{ marco(); ingreso(); reportes(); promedio(); mayor(); getch();
}
Procedimientos de salida
Parte I. Entrada de datos: adems de lectura de datos por cada alumno, puede
visualizar un marco, fecha y hora del sistema. Para ingresar ms registros
presione S.
Parte II. Reporte: despus de presionar N, usted obtiene un listado de registros
y el total respectivo.
Parte III. Reporte del promedio de edades de alumnos por facultad. A
continuacin se ilustra la entrada y salida.
294
Problema 8. La empresa BETA, dedicada al negocio de transporte de pasajeros,

tiene cuatro tipos de pasajes: A, B, C y B, respectivamente. Asimismo, puede
haber n (definido por usuario) vendedores quienes pueden vender los cuatro
tipos de pasajes. Las reglas del negocio para las ventas son:
El pasaje de tipo A, tiene un costo de S/. 40.00 y por su venta se asigna el 2%.
El pasaje de tipo B, tiene un costo de S/. 30.00 y por su venta se asigna el 3%.
El pasaje de tipo C, tiene un costo de S/. 25.00 y por su venta se asigna el 4%.
El pasaje de tipo D, tiene un costo de S/. 22.00 y por su venta se asigna el 5%.
El programa debe permitir conocer:
1. El total de boletos vendidos por cada tipo y monto respectivo.
2. El total de boletos vendidos de los diferentes tipos por cada vendedor.
3. Recaudacin por cada vendedor y recaudacin total de sus ventas.
4. Porcentaje de ganancia para cada vendedor.
5. El vendedor con mayor cantidad de ventas de boletos por tipo y la cantidad
respectiva.
6. El vendedor con menor cantidad de ventas de boletos por tipo y la cantidad
respectiva.
7. La cantidad mxima y mnima de venta recaudada.
8. Reporte ordenado en forma ascendente por cantidad de ventas y el nombre del
vendedor, respectivamente.
El programa debe ser interactivo, es decir, despus de cada ejecucin debe preguntar al usuario Desea continuar?.....(S/N)>.
Solucin //struct_vendedor_mat.cpp
# define linea ----------------------------------------------------------------------
voidBurbuja (int a[50],int m);void color(char fondo,char texto);
void Burbuja(int a[50],int m) { int i,j,aux;
for(i=0;i<m-1;i++)
for(j=i+1;j<m;j++)
if(a[i]>a[j]) {aux=a[i]; a[i]=a[j]; a[j]=aux;
295
}}
void color(char fondo,char texto)
{ textcolor(texto);
textbackground(fondo);}
struct transporte { char vendedor[30]; int tipo,cant; };
void main (){int r,n=4,i,j,k=0;int x[10][10],ta[50],tb[50],tt;int orden[50];
int
recau[50]; int precio[50]; float comision[50],porce[50],trec;int monto[50];
transporte data[50];
int maxtipo,maxvend,mintipo,minvend;
int maxmontotipo,maxmontovend,minmontotipo,minmontovend;
char menu;color(1,14);
precio[0]=40; precio[1]=30; precio[2]=25; precio[3]=22;
porce[0]=0.02; porce[1]=0.03; porce[2]=0.04; porce[3]=0.05;
do{clrscr();
gotoxy(16,2);cout<<EMPRESA DE TRANSPORTES BETA:;
gotoxy(4,5);cout<<Disponibilidad de Oficinas, Precio y Porcentajes por ventas ;
gotoxy(4,7);cout<< Tipo A : S/.40.00 2% para cada vendedor;
gotoxy(4,8);cout<< Tipo B : S/.30.00 3% para cada vendedor;
gotoxy(4,9);cout<< Tipo C : S/.25.00 4% para cada vendedor;
gotoxy(4,10);cout<< Tipo D : S/.22.00 5% para cada vendedor;
gotoxy(8,12);cout<< Ingrese Cantidad de Vendedores : ;cin>>r;
for(i=0;i<r;i++){
cout<<\t\t\tVendedor [<<(i+1)<<] = ; cin>>data[i].vendedor; data[i].cant=0;
}
for(i=0;i<n;i++){data[i].tipo=i; }tt=0; trec=0;clrscr();
gotoxy((11+r*7 /2),1);cout<<Vendedores;gotoxy(5,2);cout<<linea;
for(i=0;i<r;i++){
gotoxy((5+7*(i+1)),3); cout<<data[i].vendedor;
ta[i]=0; recau[i]=0; comision[i]=0; }
for(j=0;j<n;j++){ gotoxy(1,(j+5));
switch (data[j].tipo) {case 0 : cout<< <<TIPO A ;break;
case 1 :cout<< <<TIPO B ;break;
case 2 :cout<< <<TIPO C ;break;
case 3 :cout<< <<TIPO D ;break; }
gotoxy(5,n);cout<<linea; tb[j]=0;}
gotoxy(3,j+n+1);cout<<linea; // Ingreso de Datos
for(i=0;i<r;i++){
for(j=0;j<n;j++){
gotoxy((6+7*(i+1)),(j+5));
cin>>x[i][j];
orden[k]=x[i][j]; monto[k]=x[i][j]*precio[j]; k++;
ta[i]+=x[i][j];
// Calculo de los Totales en los Distritos
recau[i]+=x[i][j]*precio[j];
comision[i]+=x[i][j]*precio[j]*porce[j];
data[i].cant+=x[i][j];
tb[j]+=x[i][j];
// Clculo de los Totales de las Marcas de tipos
296
tt+=x[i][j];
// Clculo de la Suma de todos los elementos
} }
Burbuja(orden,k); Burbuja(monto,k);gotoxy(1,6+n);cout<<BoletoxVend;
gotoxy(1,7+n);cout<<RecaudxVend;gotoxy(1,8+n);cout<< % x Vend;
for(i=0;i<r;i++){ gotoxy((6+7*(i+1)),6+n);cout<<ta[i];
gotoxy((6+7*(i+1)),7+n);cout<<recau[i];
trec+=recau[i]; gotoxy((6+7*(i+1)),8+n);cout<<comision[i]; }
Burbuja(ta,i); gotoxy(12+(r*7),3);cout<<TotalxOfic.;
gotoxy(24+(r*7),3);cout<<MontoxOficina;
for(i=0;i<n;i++){ gotoxy(15+(r*7),(i+5));cout<<tb[i];
gotoxy(25+(r*7),(i+5));cout<<tb[i]*precio[i];}
gotoxy(15+(r*7),6+n);cout<<Total = <<tt<< Pasajeros;
gotoxy(15+(r*7),7+n);cout<<Rec. Total S/.<<trec;
for(i=0;i<r;i++){
for(j=0;j<n;j++){if (orden[k-1]==x[i][j]){maxtipo=j; // Posicin con Max # en Oficina
maxvend=i;
// Posicin con Max # por Vendedor
}
if (orden[0]==x[i][j])
{mintipo=j;
// Posicin con Min # en Oficina
minvend=i;
// Posicin con Min # por Vendedor
}
if (monto[k-1]==x[i][j]*precio[j])
maxmontotipo=j; // Posicin con Max Monto en Oficina
maxmontovend=i;
// Posicin con Max Monto por Vendedor
}
if (monto[0]==x[i][j]*precio[j]){
minmontotipo=j;
// Posicin con Min Monto en Oficina
minmontovend=i;
// Posicin con Min Monto por Vendedor
} }}
cout<<\n\n\n\tPasajeros Registrados\t\tVendedor\tOficina;
cout<<\n =====================================================;
cout<<\n\tMax # de Pasaj : <<orden[k-1];
switch (data[maxtipo].tipo)
{
case 0 : cout<<\t\t<<data[maxvend].vendedor<<\t\tTIPO A;break;

case 1 : cout<<\t\t<<data[maxvend].vendedor<<\t\tTIPO B;break;

case 2 : cout<<\t\t<<data[maxvend].vendedor<<\t\tTIPO C;break;
case 3 : cout<<\t\t<<data[maxvend].vendedor<<\t\tTIPO D;break; }
cout<<\n\tMin # de Pasaj : <<orden[0];
switch (data[mintipo].tipo)
{
case 0 :
cout<<\t\t<<data[minvend].vendedor<<\t\tTIPO
A;break;

case 1 :
B;break;

case 2 :
297
C;break;

case 3 :
D;break;
}cout<<\n\tMax Recaud S/. : <<monto[k-1];
switch (data[maxmontotipo].tipo)
{case 0 : cout<<\t\t<<data[maxmontovend].vendedor<<\t\tTIPO A;break;
case 1 : cout<<\t\t<<data[maxmontovend].vendedor<<\t\tTIPO B;break;
case 2 : cout<<\t\t<<data[maxmontovend].vendedor<<\t\tTIPO C;break;
case 3:cout<<\t\t<<data[maxmontovend].vendedor<<\t\tTIPO D;break; }
cout<<\n\tMin Recaud S/. : <<monto[0];
switch (data[minmontotipo].tipo)
{case 0 : cout<<\t\t<<data[minmontovend].vendedor<<\t\tTIPO A;break;
case 1 : cout<<\t\t<<data[minmontovend].vendedor<<\t\tTIPO B;break;
case 2 : cout<<\t\t<<data[minmontovend].vendedor<<\t\tTIPO C;break;
case 3 : cout<<\t\t<<data[minmontovend].vendedor<<\t\tTIPO D;break;
}
cout<<\n\nOrdenado por Vendedores :\n\t\t;int temp[50];
for(k=0;k<r;k++){ gotoxy((6+7*(k+1)),n+19);cout<<ta[k];
for(i=0;i<r;i++){ if (ta[k]==data[i].cant){temp[k]=i;
} }
gotoxy((6+7*(k+1)),n+18);cout<<data[temp[k]].vendedor;
}
gotoxy(50,24);
cout<<Desea continuar ...(S/N)==>;cin>>menu;
}
while ((menu==S)||(menu==s));}
Parte I. Ingreso del nmero de
vendedores.
Parte II. Lectura de cantidad de boletos
expedidos por cada vendedor.
298
Parte III. Resultados solicitados por el programador, despus de la lectura del

nmero de pasajes por tipo y por vendedor, se ilustra los datos procesados.
Problema 1. Disear un programa que permita ingresar n alumnos (n definido
por el usuario), identificados por: apellidos y nombre (cadenas de 20), fecha
de nacimiento (da/mes/ao) y su edad respectiva. Luego realice las siguientes
consultas:
a. Alumnos por apellidos, fecha de nacimiento y edad
b. Alumnos ordenados por apellidos en forma ascendente
c. El alumno(s) de mayor edad, alumno(s) de menor edad
d. Total de alumnos y el promedio de edades
Problema 2. Disear un programa que permita ingresar n artculos (n definido
por usuario), donde cada artculo provee los siguientes campos: cdigo (cadena
de 4), nombre (cadena de 20), fecha de fabricacin (d/m/a), cantidad (entero) y
precio (real). Realice las siguientes consultas:
a. Listado de productos por cdigo, nombre, fecha de fabricacin y precio
b. Listado de productos ordenados en forma ascendente por precio
c. Listado de artculo(s) con mayor precio y la cantidad
por usuario), los registros alumnos corresponden a un colegio, identificados por:
cdigo (cadena de 8), el apellidos (cadena de 20), puntaje (entero:0 al 100) y sexo
(carcter). Realice las siguientes consultas:
a. Listado de alumnos por: cdigo, apellidos y puntaje
b. Listado de alumnos por apellidos y ordenados por sexo en forma ascendente
c. Total de alumnos indicando promovidos cuando su puntaje es mayor que
20 y la cantidad de repitentes, cuando su puntaje es menor que 20
299
Problema 4. Disear un programa que permita ingresar n registros (n definido

por usuario), registros que corresponden a datos de las ventas que maneja una
inmobiliaria por da, tales como la direccin del inmueble (cadena de 20), el
nombre del propietario (cadena de 20), tipo de inmueble (carcter) y precio base
(real). Realice las siguientes consultas:
a. La cantidad de departamentos vendidos.
b. La cantidad de casas vendidas.
c. El total de las ventas.
Tenga en cuenta que los descuentos
son respecto al precio base.
Tipo de inmueble
Descuento
C (casa)
18%
D (departamento)
12%
Problema 5. La siguiente aplicacin,

permite procesar informacin de un
conjunto de n (n<=1000), usando los
siguientes atributos: cdigo (solo de 3
dgitos); apellidos[20], nombres[20] y
edad, respectivamente. Los registros se
guardan en la estructura lista o vector.
Asimismo, los datos se mantienen
temporalmente en memoria RAM. A
continuacin se describe cada mdulo
y la tarea especfica que stos realizan:
marcos(). Es un procedimiento con la
siguiente sintaxis:
Marco(int x,int y,int ancho,int alto,int
color)
Fechas(). Es un procedimiento que
muestra datos de fecha, hora, estacin.
Ver figura.
Valida(). Es un procedimiento para
validar dato de usuario, solo dispone
de tres opciones.
Longitud(). Procedimiento para definir la cantidad de registros. En la
siguiente figura se ilustra la ejecucin
de este mdulo, donde para iniciar se
300
ingrese el registro de alumnos, pues

ms adelante existe el mdulo de
insercin.
Lectura(). Procedimiento en el que
el usuario ingresa los datos de los
registros por: nombres, apellidos y
cdigo y edad. Se almacenan en un
vector segn el tamao de alumnos.
En la siguiente figura se ilustra el
proceso de entrada de datos al sistema.
Reportes(). Es un procedimiento que permite generar un listado de los registros
y sus datos ingresados. En la siguiente figura se ilustra el proceso de entrada de
datos al sistema.
OrdenApelliods(). Es un procedimiento que permita ordenar datos de registros
por apellidos en forma ascendente. Usando el procedimiento Reportes(), se
genera el reporte respectivo.
Insertar(). Procedimiento que permite al usuario insertar uno o ms registros. En
nuestro caso el sistema solicita que ingrese el nmero de registros y luego solicita
susdatos. En nuestro caso son dos registros. Al finalizar la insercion, se genera un
reporte respectivo.
EliminarReg(). Es un procedimiento que permite eliminar registro, para lo cual el
sistema solicita el nmero de registro a eliminar, despus de procesar, el sistema
envia la confirmacin respectiva. En la ltima figura se lista registros actuales.
En la siguiente figura se ilustra los registros restantes despus de la eliminacin.
BuscaEdad(). Procedimiento que permite al usuario buscar una edad respectiva.
301
Problema 6. Disear un programa que permita generar el siguiente modelo

relacional de base de datos, donde la entidad o tabla alumnos debe aceptar
datos de n alumnos(n<=1000) por apellidos, nombres, cdigo, edad. La entidad
o tabla cursos debe aceptar m cursos (m<=10) por cdigo, descripcin y crditos,
finalmente crear la entidad Alumnos_Notas, entidad que depende de los cdigos
de las dos tablas anteriores y sus datos son tres prcticas calificadas y dos
exmenes (parcial y final).
Realice las siguientes consultas:
a. Listado de alumnos por cdigo, apellido, sus cursos por cdigo, nombre
(descripcin) y crdito, respectivamente.
b. Listado de alumnos por apellido, nombre, sus cursos por nombre (descripcin)
y sus notas (pc1, pc2, pc3, exp, exf).
c.
Listado de alumnos por
nombre, sus cursos por nombre
(descripcin) y sus notas (pc1,
pc2, pc3) y su promedio de
prctica, eliminando la menor
nota.
d. Listado de alumnos por apellidos y nombres, sus cursos
por nombre (descripcin) y
sus notas (pc1, pc2, pc3, exp,
exf), su promedio de prctica,
eliminando la menor nota y
su promedio final, mostrando
el estado final (aprobado: si
promedio final es mayor que 10, en otro caso desaprobado).
e. Listado de alumnos por apellidos, sus cursos por nombre (descripcin) y sus
notas (pc1, pc2, pc3, exp, exf), su promedio de prctica, eliminando la menor
nota y su promedio final, mostrando el estado final (aprobado: si promedio
final es mayor que 10, en otro caso desaprobado).
f. Listado de alumnos por apellidos y nombre, sus cursos por nombre
(descripcin) y su promedio final ordenado en forma ascendente por apellidos
(debe mostrar tambin la posicin original y actual de cada registro, pues
debido al ordenamiento los registros se intercambian).
Problema 7. Para implementar los mdulos mostrados en la figura que contiene
las siguientes opciones, donde cada opcin se ejecuta usando los siguientes
procedimientos:
crea_alumnos(): Procedimiento para registrar n alumnos (n<=1000). Debe validar
que el cdigo NO se repita. Si lee un cdigo que ya existe, debe enviar el mensaje
Cdigo Existe, vuelva a leer.
302
crea_cursos():
Procedimiento
para registrar m cursos (m<=10)
por alumno, tambin debe validar
que el cdigo del curso que NO
se repita. Si lee un cdigo que ya
existe, debe enviar el mensaje
Cdigo Existe, vuelva a leer.
En la siguiente figura se ilustra
procedimiento de lectura.
Editar_Notas(): Procedimiento
para registrar mximo tres
prcticas calificadas por cada
alumno y su curso respectivo.
Primero se lee el nmero de
alumnos y luego cdigo de
alumno y cdigo de curso, luego se registra las notas. Para el llenado de notas
se debe procesar tal como se ilustra en la siguiente figura, considerando que el
cdigo actual del alumno sea igual al cdigo registrado en la tabla alumnos.
Lista 1(): Procedimiento (opcin

A) lista los alumnos y sus cursos
matriculados por cdigo.
B) lista los alumnos por Cdigo,
303
Apellidos y luego su(s) curso(s) por

cdigo y sus notas respectivas. Ver
figura adjunta.
Si alumno no se matricul, enviar el
mensaje alumno falta matricularse
en sus cursos.
C) lista los alumnos por Cdigo,
Apellidos y luego su(s) curso(s)
por cdigo y sus notas respectivas,
mostrando tambin la Menor notar.
Ver figura adjunta.
Lista 4(): Procedimiento (opcin D) lista cdigo de alumnos, de cursos y su
promedio de practica eliminado la menor nota. Ver figura adjunta.
Lista 5 (): Procedimiento (opcin E)
lista cdigo de alumnos, de cursos,
su promedio de prctica eliminado
la menor nota el estado Aprobado
/ Desaprobado. Asimismo, totaliza
Aprobados y Desaprobados. Ver
figura adjunta.
Lista 6(): Procedimiento (opcin F) lista cdigo de alumnos su promedio
ponderado y la posicin inicial de entrada.
Lista 7(): Procedimiento (opcin G) lista cdigo, apellidos, nombres de alumnos
y su promedio ponderado.
Para la opcin T, es un submen/opciones que realiza operaciones de Insercin,
eliminacin, actualizacin, ordenamiento, bsquedas. Se debe hacer para cada
tabla.
Problema 8. Disear un programa que permita leer datos de n empleados

(n<100), datos correspondientes a: cdigo (entero de 7 dgitos), apellidos y
nombres (cadenas de longitud 30 caracteres), sueldo (real con dos decimales) y
sexo (carcter: M / F). Hacer los siguientes reportes:
a. Listado de empleados por cdigo, apellidos y sueldo
b. Listado de empleados por cdigo, apellidos, sueldo ordenados en forma ascendente por apellidos
c. Total de empleados y el Promedio de sueldo respectivo
304
Problema 9. Disee un programa que permita leer datos de n alumnos (n<100),

datos correspondientes a: Cdigo (siete dgitos, cdigo no se debe repetir),
apellidos y nombres (cadenas de 20 caracteres), para cada alumno se debe leer
como mnimo dos y mximo cinco prcticas calificadas (entero). Luego calcule
el promedio de prcticas eliminando la menor nota. Luego leer examen parcial
y examen final, con estos datos y el promedio de prcticas, calcule el promedio
final. Luego realice los siguientes reportes:
a. Cdigo, apellidos, promedio de prcticas
b. Apellidos, nombres, promedio de prcticas y promedio final. Si el promedio
final es Mayor a 10, enviar el estado de alumno Aprobado, en otro caso
Desaprobado. Si este resultado ocurre leer examen sustitutorio y realice
el nuevo clculo del promedio considerando que el examen sustitutorio
reemplaza al examen de menor calificativo (parcial o final). Mostrar el resultado
final enviando el estado (Aprobado con examen sustitutorio/ Desaprobado
con examen sustitutorio)
c. Total de alumnos aprobados y desaprobados
d. Alumnos por apellido y su menor promedio, tambin alumnos con mayor
promedio
Problema 10. Disee un programa que registre datos de las n (n<200), ventas
de boletos de varias empresas, datos correspondientes a: cdigo de la empresa
(cadena de 4), la numeracin del primer boleto vendido (entero), la numeracin
del ltimo boleto vendido (entero), el precio del boleto (real), luego realice las
siguientes consultas:
a. Listado de las n empresas por cdigo, numeracin del boleto y precio respectivo
b. Listado de las n empresas por cdigo, cantidad de boletos vendidos y el importe
de esta venta La empresa con ms boletos vendidos, as como la empresa con
menor cantidad de boletos vendidos
Problema 11. Disear un programa que permita ingresar n alumnos ( n definido
por el usuario), alumnos identificados por: Apellidos y nombre (cadenas de
20), fecha de nacimiento (da/mes/ ao) y su edad respectiva. Luego realice las
siguientes consultas:
a. Alumnos por apellidos, fecha de nacimiento y edad
b. Alumnos ordenados por apellidos en forma ascendente
c. El alumno(s) de mayor edad, alumno(s) de menor edad
d. Total de alumnos y el promedio de edades
Problema 12. Disear un programa que permita ingresar n artculos ( n definido
por usuario), donde cada artculo provee los siguientes campos: cdigo (cadena
de 4), nombre (cadena de 20), fecha de fabricacin (dd/mm/aa), cantidad (entero)
y precio (real). Realice las siguientes consultas:
305
a. Listado de productos por cdigo, nombre, fecha de fabricacin y precio

b. Listado de productos ordenados en forma ascendente por precio
c. Listado de artculo(s) con mayor precio y la cantidad
por usuario), los registros alumnos corresponden a un colegio, identificados por:
cdigo (cadena de 8), el apellidos (cadena de 20), puntaje (entero: 0...100) y sexo
(carcter). Realice las siguientes consultas:
a. Listado de alumnos por: cdigo, apellidos y puntaje
b. Listado de alumnos por apellidos y ordenados por sexo en forma ascendente
c. Total de alumnos indicando Promovidos cuando su puntaje es mayor que
20 y la cantidad de Repitentes, cuando su puntaje es menor que 20.
306
Captulo 7
Archivos (file)
Objetivos
-
-
-
-
-
-
Cmo definir un archivo

Aplicar tcnicas de archivos secuenciales y de acceso aleatorio
Cmo reconocer la direccin lgica y fsica de registros
Cundo usar funciones de fin de lnea y funciones de fin de archivo
Aplicar tcnica de moldeamiento de datos
Aplicar tcnica de programacin independiente para crear mdulos que sean
invocados como cabeceras del programa
307
7.1 INTRODUCCIN
Los archivos constan de una coleccin de registros y sirven para la entrada y
salida de datos en computadora y son procesados con programas o lenguajes de
programacin de bajo nivel y alto nivel ( c++, netbeans, etc).
Para mejorar el procesamiento de archivos se puede usar vectores (arrays) como
variables tipo registros, lo cual resulta ms eficiente para las operaciones de
mantenimiento de Datos(insercin, eliminacin, modificacin, actualizacin).
7.2 CARACTERSTICAS DE LOS ARCHIVOS

Las principales caractersticas de esta estructura son:
a. Independencia de los datos respecto de los programas
b. Los datos son almacenados en forma permanente
c. Los archivos pueden ser accedidos por distintos programas en distintos momentos
7.3 Archivos (FILE)

Es una estructura de datos para el procesamiento de registros, es decir, est
compuesto por un conjunto de registros con igual cantidad de campos (ver
figura). Recuerde que los registros se inician con el ndice lgico cero (0).
7.4 Apertura de archivos

Para procesar datos de archivos, primeros e debe abrir y luego escribir o leer
datos, respectivamente. Al abrir el archivo se establece comunicacin entre el
programa y el sistema operativo acerca de cmo accederlo. Se requiere que el
programa le proporcione al sistema operativo el nombre del archivo y el modo de
uso (leer o escribir datos), entonces se definen reas de comunicacin entre ellos.
308
7.5 Clasificacin de archivos por tipo de contenido: texto,

binarios
7.5.1. Archivos de texto

Son archivos que pueden contener cualquier clase de datos,
detal manera que son entendibles por la sociedad. Los
datos de los registros, en un archivo de texto, se almacenan
usando el cdigo ASCII. Este tipo de archivos solo tiene
marcas lgicas de fin de lnea (eol y eof), asimismo,no tiene
CAMPOS, ndices lgicosde registros para identificar los
registros fsicos.
7.5.2. Archivos binarios

Este tipo de archivos procesan y almacenan los datos numricos basados en su
representacin binaria. Cuando utiliza un lenguaje de programacin, se usa
instrucciones, a esto se le denomina programa fuente y cuando ejecuta este
programa genera un archivo binario. Archivo que se puede ejecutar sin disponer
del lenguaje de programacin.
309
7.6 Clasificacin de archivos por tipo de acceso

Los archivos, de acuerdo a la tcnica de acceso de datos, se clasifican en
secuenciales o directos (acceso directo, aleatorios). En esta seccin se ilustra el
marco conceptual, las aplicaciones sern en los siguientes ndices.
7.6.1. Archivos secuenciales

La tcnica consiste en grabar
los registros en secuencia o
consecutivamente y su acceso es
del mismo modo. Conforme se van
insertando nuevos registros, stos se
almacenan despus del ltimo registro;
as, para consultar por un registro,
es necesario recorrer todo el archivo,
leyendo cada registro y comparndolo
con el que se busca. En este tipo de
archivo se utiliza una marca invisible
que el sistema operativo coloca al final
de los archivos: eof (end of file), la cual
sirve para identificar dnde termina el
archivo.
7.6.2 Archivos directos: acceso

aleatorio
Son aquellos que estn formados
por un conjunto de registros, todos de un mismo tamao y se puede acceder
directamente a un registro ubicando el puntero o apuntador en el ndice y la
funcin de acceso aleatorio seek(). En los siguientes tpicos se mostrar la sintaxis
de la funcin respectiva y sus variaciones, respecto a que el puntero puede estar
al inicio, al final o posicin especificada por el programador.
7.7 Direcciones Lgicas y Direcciones Fsicas

El lenguaje de programacin C++
usa
direcciones fsicas y no
lgicas(pascal), es decir; que el
direccionamiento consiste en el
espacio ocupado por los datos en
el archivo (calculado en bytes),no
en el rengln al que se asign dicho
registro.
310
Ejemplo, suponga que tiene un archivo llamado Empleados.txt que almacena

registros con diseo lgico mostrado en la figura. Dicho registro tiene 4 campos,
cada uno con un tipo de dato definido, un tamao y que al sumarlos se obtiene el
espacio (57) ocupado para cada registro.
Observacin. calcular direccin fsica antes de reposicionar el apuntador de
archivo.
7.8 Clculo de direcciones fsicas

Para poder reposicionar el apuntador de un archivo en un registro especfico
es necesario calcular su direccin fsica correspondiente de acuerdo al espacio
ocupado por sus registros predecesores.
7.9 Funciones para el manejo de archivos

En esta seccin se presenta los procedimientos generales para disear aplicaciones
con archivos en lenguaje de programacin C++ 5.02. Las aplicaciones se basanen el
uso de registros (struct) en archivos, para lo cual se presentan los procedimientos
y las funciones bsica para este tipo de aplicaciones.
7.10 Declaracin de la variable lgica (alias) del archivo

Se debe iniciar con la siguiente librera estndar de entrada / salida:
#include <stdio.h>
Asimismo, se debe declarar una variable dinmica de tipo archivo (FILE) que
enlace el apuntador desde memoria RAM con el nombre del archivo (alias).
FILE *alias;
7.11 Funcin para procesar archivos

Para la apertura de archivos se debe usar la funcin fopen() con los siguientes
atributos:
311
fopen(nomb_archivo,modo):
Donde: nomb_archivo: es una cadena que indica ruta y nombre de archivo
modo : modo de acceso al archivo que se abrir o se crear
Modo de
apertura
(archivos de
texto)
texto)
Modo de
apertura
(archivos
binarios)
rb
wb
ab
r+
rb+
w+
wb+
a+
ab+
Descripcin
Apertura en modo de slo lectura. El archivo debe existir.
Apertura en modo de slo escritura. Si el archivo existe,
se reescribir (pierde el contenido anterior).Si archivo no
existe, lo crea
Apertura en modo de agregar. Si el archivo existe, los
datos se agregan al final del archivo en caso contrario el
archivo se crea.
Apertura en modo de lectura/escritura. El archivo debe
existir.
Apertura en modo de lectura/escritura. Si el archivo existe,
se reescribir.
Apertura en modo de lectura/agregar. Si el archivo no
existe lo crea.
7.12 Validar la apertura

de un archivo
Se debe crear el mdulo para validar
la existencia del archivo. Si no existe,
la respuesta ser (F) o marcador
lgico 0.
En la siguiente figura se ilustra la
validacin respectiva.
7.13Cierre
de
archivos
usando fclose() y fcloseall()
Despus de procesar datos del archivo se debe cerrar. Esto se logra mediante las
funciones fclose() o fcloseall(), donde:
Funcin fclose (): cierra un archivo abierto
Funcin floreal (): cierra todos los archivos abiertos
312
7.14 Escritura de registros usando fwrite()

Esta funcin trabaja con registros de longitud constante y forma pareja con
fread(). Es capaz de escribir hacia un archivo uno o varios registros de la misma
longitud, almacenados a partir de una direccin de memoria.
Esta funcin tiene cuatro argumentos: la variable que se desea grabar, su tamao
en bytes, la cantidad de variables y el alias del archivo donde se desea almacenar.
Sintaxis
Donde:
fwrite(&var_reg, sizeof(var_reg), 1, alias1);
&
: direccin de memoria
var_reg : es una variable registro
1
: se procesar en cada operacin 1 registro
alias1 : es una variable lgica para relacionar con archivo fsico
La funcin fwrite() graba el registro en la direccin fsica
Tambin puede usar fprintf ().
7.15 Vaciando los buffers usando fflush()

Un buffer es un rea de almacenamiento temporal en memoria de todos los datos
ledos o escritos en el archivo. Estos buffers retienen datos en trnsito desde
y hacia el archivo y tienen la finalidad de hacer ms eficiente la ejecucin del
programa.
Los buffers tambin se vacan cuando se cierra el archivo.
7.16 Lectura de registros usando fread()

La funcin fread permite abrir o cargar todos los campos de un registro, es decir;
lee un registro y lo copia en la memoria RAM para luego realizar operaciones.
Esta funcin tiene los mismos argumentos que la funcin fwrite ().
fread(&var_reg, sizeof(var_reg), 1, alias1);
Tambin puede usar la funcin fscanf(), funciona igual que scanf en cuanto a
parmetros, pero la entrada se toma de un archivo en lugar del teclado.
7.17 Funcin para acceso de archivos

Funcin fseekf(): Esta funcin sirve para situar el cursor del archivo para leer o
escribir en el lugar deseado. El valor de retorno es cero si la funcin tuvo xito, y
un valor distinto de cero si hubo algn error. Tambin es importante mencionar
que cada vez que se realiza una operacin de lectura o de escritura, el apuntador
se mueve al final de dicho dato, de tal forma que est posicionado en el siguiente,
313
por lo se debe asegurar que se encuentre en la posicin deseada antes de realizar

cualquier operacin.
Sintaxis
fseek(alias, direcc_fisica, Punto_de_referencia);
Donde:
Alias: variable lgica
direcc_fisica: Se debe calcular la direccin fsica antes de reposicionar el
puntador del archivo.
Punto_de_referencia: se refiere desde dnde se iniciar el conteo de bytes
determinado por la direccin fsica. Vara segn:
1. SEEK_SET : el desplazamiento se cuenta desde el inicio del archivo.
2. SEEK_CUR: el desplazamiento se cuenta desde la posicin actual del cursor.
3. SEEK_END : el desplazamiento se cuenta desde el final del archivo.
7.18 Conocer posicin del apuntador del archivo

Funcin ftell(): Se usa para conocer la posicin actual del apuntador de un
archivo abierto. La posicin se expresa en bytes (direccin fsica), contados desde
el principio del archivo.
Sintaxis
long int direcc_fisica;
direcc_fisica = ftell(alias)
7.19 Posicionando apuntador al inicio del archivo: rewind()

Se usa para colocar el apuntador del archivo al inicio del archivo abierto, sin
necesidad de usar la funcin fseek.
Sintaxis
rewind(alias)
7.20 Detectando el final del archivo con feof()

Esta funcin sirve para comprobar si se ha alcanzado el final del archivo.
Sintaxis
while (|feof(alias)) {<instrucciones>;
7.21 Cambio de nombre de archivo rename()

Cambia nombre cuando un archivo esta cerrado.
Sintaxis
314
rename(c:\\datost\\empleados.txt, c:\\datos\\trabajadores.txt)
Donde:
empleados.txt : debe existir
trabajadores.txt : nuevo archivo
7.22 Eliminando archivos con la funcin remove()

Esta funcin elimina definitivamente un archivo especificando su nombre.
Sintaxis:remove(c:\\tarea\\
empleados.txt);
Aplicaciones
Basado en los problemas de
registros (struct) debe aplicarse los
conceptos de archivo y uso de sus
funciones respectivas.
Aplicacin 1
SISTEMA DE MANTENIMIENTO
DE TRES TABLAS
Consiste en disponer de un
modelo relacional de base de datos
usando tres entidades (tablas),
relacionadas mediante la clave
fornea respectiva. En la siguiente
figura, se ilustra una carpeta con
el programa fuente implementado en Borland C++ 5.02, como ver no existe
archivos.
Interface principal del sistema
Se dispone al usuario de un conjunto de alternativas que puede realizar con
el sistema de mantenimiento: alternativas que se implementan mediante el
siguiente mdulo:
int Menu() { int i;
do { system (cls); textcolor(15);
cout <<\n\n\ SISTEMA DE MANTENIMIENTO ;
cout<<1.- INGRESAR ALUMNOS \n;
cout<<2.- INGRESAR CURSOS \n;
cout<<3.- INGRESAR NOTAS DEL ALUMNO \n;
cout << 4.- ACTUALIZACIN \n;
cout << 5.- ELIMINACIN \n;
315
cout << 6.- MOSTRAR REGISTRO DE

ALUMNOS \n;
gotoxy(6,13); cout << 7.- REPORTE
DE ALUMNO \n;
cout <<
0.- SALIR\n;
cout << \n\n\nSeleccione su opcin :
; cin >>i;
cout <<endl; } while(i<0
|| i>7); return(i); }
Alternativa 1. Mdulo para ingresar datos de alumnos. Registra la data de
alumnos usando la tabla (struct) ALUMNO, que permite crear el archivo
ALUMNO.DAT. Los datos son: cdigo, nombre y apellidos. Esta informacin
se implementa mediante el siguiente mdulo:
void IngresarAlumno () { int cod_al; system(cls);
cout << \n\r INGRESAR REGISTROS DEL ALUMNO;
falumno=fopen(ALUMNO.DAT,rb+);
if(falumno == NULL) {
// Crea el archivo en caso de no existir
falumno = fopen(ALUMNO.DAT,wb); }
cout << \n\n\n\r Codigo del Alumno : ; cin >>cod_al;
fread(&f1,sizeof(f1),1,falumno);
while(!feof(falumno))
{if(f1.cod_al == cod_al)
{ cout << \n\n\n\r Registro ALUMNO YA EXISTE ...!!!;
fclose(falumno); getch(); return;
}
fread(&f1,sizeof(f1),1,falumno); } f1.cod_al = cod_al;
cout<< \n\rNombre : ; gets(f1.apell_al);
cout<< \n\rApellido : ; gets(f1.nomb_al); // Grabar el Registro completo
fwrite(&f1, sizeof(f1), 1, falumno); fclose(falumno); // Cierra el archivo
cout << \n\n\n\r ALUMNO REGISTRADO !!!\n; getch(); return;
}
Al ejecutar el archivo se ha creado con el nombre de Alumno.dat y su contenido
se puede mostrar acontinuacin.
Alternativa 2. Mdulo para ingresar datos de cursos. Registra la data de notas

usando la tabla (struct) CURSO, que permite crear el archivo CURSO.DAT
por cdigo, descripcin y crditos. Esta informacin se implementa mediante el
siguiente mdulo:
316
void IngresarCurso()
{ int cod_cur; system(cls);
cout<<\n\rINGRESAR
REGISTROS DEL CURSO;
fcurso=fopen(CURSO.
DAT,rb+);
if(fcurso == NULL)
{
fcurso = fopen(CURSO.
DAT,wb); }
cout << \n\n\n\r Codigo del
Curso : ;
cin
>>cod_cur;
fread(&f2,sizeof(f2),1,fcurso);
while(!feof(fcurso))
{ if(f2.cod_cur == cod_cur)
{cout << \n\n\n\r Registro DE CURSO YA EXISTE ...!!!;
fclose(fcurso); getch(); return;
}
fread(&f2,sizeof(f2),1,fcurso);
}
f2.cod_cur = cod_cur;
cout<< \n\rNombre del Curso : ; gets(f2.nomb_cur);
cout<< \n\rCreditos:;cin>>f2.cred;
fwrite(&f2,sizeof(f2),1, fcurso); fclose(fcurso); // Cierra el archivo
cout << \n\n\n\r CURSO REGISTRADO !!!\n; getch(); return;
}
Alternativa 3. Mdulo para ingresar notas.- Se registra la data de notas usando la
tabla (struct) NOTA_ALUMNO, que permite crear el archivo NOTAALUMNO.
DAT,usando los campos para claves forneas y los campos p1,p2,p3, ep, ef. Esta
informacin se implementa mediante el siguiente mdulo:
void Crea_archivo_NotasAlumnos()
{ clrscr(); NOTA_ALUMNO f3; int n,i;
fnota_alumno=fopen(NOTAALUMNO.DAT,a+);
if (fnota_alumno==NULL)
{ cout<<Creare el archivo;
cout<<Ingrese nmero de alumnos cuyas notas quiere ingresar: ;cin>>n;
for(i=1;i<=n;i++)
{cout<<Codigo Alumno :<<\n;
cin>>f3.cod_al;
cout<<Codigo del curso:; cin>>f3.cod_cur;
cout<<Nota de la practica 1: ;cin>>f3.p1;
cout<<Nota de la practica 2: ;cin>>f3.p2;
cout<<Nota de la practica 3: ; cin>>f3.p3; cout<<Nota del examen parcial: ;
317
cin>>f3.ep; //scanf(%d,&reg.ep);
cout<<Nota del examen final: ;
cin>>f3.ef;
fwrite(&f3,sizeof(f3),1,fnota_
alumno); }fclose(fcurso);
}
Con estos tres mdulos, se ha creado
los tres archivos fsicos, tal como se
ilustra en la siguiente grfica:
Mantenimiento. A partir de la alternativa 4, se considera mantenimiento de la
data, es decir se puede modificar contenido de las archivos fsicos (eliminar,
insertar, etc.), as como modificar datos de algn registro que el usuario crea
conveniente. A continuacin, se procesan las alternativas, es decir, se puede usar
indistintamente las alternativas, veamos:
Alternativa 6. Mostrar registro de alumnos.- En la siguiente grfica, se ilustra el
reporte de los registros de alumnos.
Esta interfase se logra al implementar el siguiente mdulo.
void Mostrar()
{ system(cls);
cout
<<
\n\rLISTADO
DE
REGISTROS
DE
ALUMNOS<<endl<<endl;
falumno = fopen(ALUMNO.
dat,rb);
if(falumno == NULL)
{ cout << \n\n\n\rNo existe el
archivo !!!\n;
cout << \n\r<<< ... PRESIONE ENTER para continuar >>>; getch(); return;
}
cout <<\n\r _________________________________________________;
cout << \n\r
CODIGO
NOMBRE
APELLIDO;
cout <<\n\r ___________________________________________________;
fread(&f1, sizeof(f1), 1, falumno);
{ printf(\n\r %12d
\t%15s %-5s,f1.cod_al, f1.apell_al,
f1.nomb_al);
}
fclose(falumno); // Cierra el
archivo
cout<<\
318
n\r__________________________;
cout << endl<<\n\n;
cout << \n\r<<< ... PRESIONE ENTER para continuar >>>; getch(); return;}
Alternativa 4. Actualizacin.- Suponga que el error est en al apellido de Ana,
es decir el apellido correcto es SIFUENTES, entonces se debe llamar el registro
por cdigo 100 (es la clave pimaria) y luego edite los nuevos datos. Este proceso
se ilustra en la siguiente grfica:
Verificacin. Use alternativa 6 y
por el cdigo verificar el cambio,
veamos:
Como se observa en la siguiente
grafica, el registro nmero 1 ha
sido actualizado.
Alternativa 5
Eliminacin. Se
elimina registros mediante la
edicin del cdigo, tal como se
ilustra a continuacin:
Para la verificacin, use la
alternativa 6, tal como se ilustra a
continuacin, que solo queda en
el archivo alumnos.dat, el registro
correspondiente a Carlos.
Este proceso se logra al implementar el siguiente mdulo:
void Eliminacin()
{ int cod_al; char op; system(cls);Eliminar(); cout << \n\rELIMINACION
DE REGISTROS DE ALUMNO;
falumno = fopen(ALUMNO.DAT,rb+);
if(falumno == NULL) // Checa la existencia del archivo
{ cout < \n\n\n\rNo existe el archivo !!!\n;
getch(); return;
}
cout << \n\n\n\r CODIGO DE ALUMNO A ELIMINAR : ; cin >>cod_al;
{ if(f1.cod_al == cod_al) { f1.cod_al = 0;
do { cout << \n\n\r... SEGURO que desea BORRARLO ...? [S/N] : ;
op = toupper(getche());
}while(op!=S && op!=N);
if(op == S)
{ fseek(falumno, ftell(falumno)-sizeof(f1), SEEK_SET);
fwrite(&f1, sizeof(f1), 1, falumno); cout << \n\n\n\rRegistro eliminado !!!\n;
}
319
fclose(falumno); Eliminar();
getch();
return;
}
fread(&f1, sizeof(f1), 1, falumno); }
cout << \n\rNo se encuentra ese registro !!!\n; fclose(falumno); // Cierra el
archivo
Eliminar(); getch(); return; }
void Eliminar()
{ //Variable para controlar el archivo temporal
FILE *Temporal;
falumno = fopen(ALUMNO.DAT,rb); // Valida la
existencia del archivo
if(falumno == NULL)
{ cout << \n\n\n\rNo existe el archivo !!!\n; getch(); return;
}
// Crea el archivo Temporal.DAT Temporal = fopen(TEMPORAL.DAT,wb);
{ if(f1.cod_al != 0) fwrite(&f1,sizeof(f1),1,Temporal); fread(&f1, sizeof(f1), 1,
falumno); //Lee el siguiente elemento del archivo }
fclose(falumno); fclose(Temporal); remove(ALUMNO.DAT);
rename(TEMPORAL.DAT, ALUMNO.DAT); getch(); return; }
Problema 1. Disear programas que permitan crear los archivos mostrados en
las siguientes figuras usando las tcnicas de: Programa 1.- Solo usa tcnica de
archivos.
Se entiende que los campos claves no deben repetirse en las tablas, luego realice
las siguientes consultas usando las tcnicas de:
320
I. Tcnica de archivos:
Consulta 1. Listado de alumnos por cdigo y edad, pero ordenados en forma
ascendente por edad
Consulta 2. Listado de alumnos por cdigo, apellidos, nombre de cursos, notas y
su promedio respectivo, indicando el estado aprobado / desaprobado.
Problema 2. Disear programas que permita consultar data histrica (avance
curricular) de n alumnos. Para lo cual considere las siguientes restricciones:
- Considere solo 10 ciclos acadmicos.
- El Archivo ALUMNOS.TXT, puede ser el NICO y contiene datos de alumnos.
- El Archivo NOTAS.TXT contiene notas y datos de alumnos.
- Considere que se implementaron 3 ciclos por ao.
- Las notas por cada ciclo varan.
- Cuando ingresa a consultar las notas de un alumno, se elije el primer ao
acadmico, en este ao el programa permite al usuario consultar ciclo por
ciclo (hasta 3), luego puede pasar al segundo ao y repite lo mismo del
primer ciclo- 1.
Ejemplo:
Cdigos
100
200
Ciclos
Promedio
2005-1
12.3
2006-1
5.5
2005-2
11.4
2006-2
2005-3
15.8
2006-3
Ciclos
Promedio
Ciclos
Ciclos
Promedio
Ciclos
Promedio
2007-1
10.2
12.5
2007-2
3.4
6.7
2007-3
11.2
Ciclos
Promedio
2005-1
11
2006-1
Promedio
4.4
2007-1
12.4
2005-2
11.4
2006-2
12.2
2007-2
17.5
2005-3
12
2006-3
11.3
2007-3
11.5
Problema 2. Usando archivos con disear un programa que permita disponer

de un sistema acadmico de matrcula, para lo cual se considera el siguiente
modelo relacional de base de datos:
Usando el modelo relacional, se inicia la programacin considerando interfaces
amigables y didcticas para los usuarios.
321
En las siguientes interfaces se ilustra los procesos a disear:
Interface de validacin: En la presente interface solo el administrador tiene todos

los derechos en el sistema tales como: insertar, eliminar, modificar, etc.
322
Interface de validacin de usuario:
Interface de advertencia: cuando sus datos son ingresados incorrectamente.
Interface del administrador: cuando ingresa sus datos correctamente dispone de

opciones para mantenimiento del sistema.
323
Interface para registrar datos de las entidades:

Si seleccionamos opcin alumnos, en la siguienmte interface se realiza el ingreso:
Si selecciona sistema de evaluacion, se ingresa los datos solicitados

Ahora cuando ingresa como alumno, usted ver la siguiente interface:
Creando usuario es ALUMNO, el sistema solicita le da derechos de solo lectura,

pues el alumno no puede insertar notas, no puede modificar sus notas, es decir,
324
solo puede visualizar sus datos. Tambin si el alumno no est registrado, se

puede crear sus datos como usuario.
El usuario administrador, puede usar la siguiente interface
325
326
Captulo 8
Programacin dinmica (punteros)
OBJETIVOS
- Definicin de punteros.
- Cmo identificar una direccin de memoria y cmo asignar espacios de
memoria.
- Usar estructuras de pilas para procesar archivos.
8.1 PROGRAMACIN DINMICA (PUNTEROS)

Un puntero es un tipo especial de variable que almacena el valor de una direccin
de memoria, donde direccin puede ser la de una variable simple, pero ms
frecuentemente ser la de un elemento de un array, una estructura u objeto de
327
una clase. Los punteros pertenecen a un

tipo (type), en la prctica se afirma que un
puntero apunta hacia un tipo al que
pertenece.
8.2 CREACIN DE UN PUNTERO
variable
puntero
valor
guarda
direccin
*P
Un puntero se declara de la siguiente

manera:
Donde:
Tipo_dato: tipo estndar de dato
*: apunta a
Variable: identificador vlido
Ejemplo:
void main()
{ int * x ;
// x es un puntero a entero
char *nombre ; // nombre es un puntero a carcter
float *a,*b ;
//a y b son punteros a reales
}
Notaciones: Las siguientes sintaxis
void main(){ int *a;int* a;
}
Las dos notaciones son vlidas, la nica diferencia es que para caso 1) se sugiere
que * forma parte de b, y para el caso 2), * forma parte del tipo de dato.
Es recomendable adoptar la segunda forma, la primera se presta a confundir el
operador * con el operador de indirection; para que el programa compile sin
problemas es necesario utilizar el operador & antes del nombre de la variable, el
efecto del operador es devolver la direccin en memoria de la variable, la cual se
asigna naturalmente a un puntero.
8.3 OPERADORES
Este operador proporciona el contenido de una variable
apuntada.
Este operador devuelve la direccin de memoria de una
variable.
328
*P
&Q
8.4 INICIALIZACIN DE UN PUNTERO

int x =20 ;int
p= & x ;
* p;
Declaracin e inicializacin. Un puntero, despus de ser declarado (para

comenzar a existir), requiere ser inicializado, lo cual se realiza mediante el
operador de asignacin (=).
void main() {int a; int * b;b = &a;//El puntero b apunta a a.}
Opciones de inicializacin
Puntero inicializado a
partir de:
Un objeto individual
T x;
Valor 0 = puntero nulo
Null=0
Declaracin e inicializacin Declaracin e inicializacin

en una misma lnea
desdobladas
T* ptr;
T* ptr = &x;
ptr = &x;
T* ptr;
T* ptr = 0;
ptr = 0;
T* ptr;
T* ptr = NULL;
ptr = NULL;
Memoria dinmica. Tambin llamada almacenamiento libre (free store). En

estos casos el programador solicita memoria para almacenar un objeto y es
responsable de liberar tal memoria para que pueda ser reutilizada por otros
objetos. El papel de los punteros, en relacin a la memoria dinmica, es muy
importante, por la razn de que al pedir, al sistema operativo, una cantidad
determinada de memoria dinmica para un objeto, el sistema nos retorna un
puntero que apunta a esa zona de memoria libre, la respuesta depender de si
hay o no tanto espacio como el solicitado.
a. Si hay suficiente memoria se retorna un puntero que apunta al comienzo de
esa zona de memoria.
b. Si no hay suficiente, retorna un puntero nulo.
En C++ los operadores usados para requerir y liberar memoria dinmica son new
y delete. La sintaxis es la siguiente:
Variable individual
Array de elementos individuales
Reserva de memoria
dinmica
int* a = new int
int* a = new int [n];
Liberacin de memoria
reservada
delete a;
delete [] a;
329
APLICACIONES
Problema 1. Disee un programa que permita declarar dos punteros y que
apunten a su variable dinmica para almacenar nmeros ingresados por el
usuario, luego genere reportes para conocer: suma de las variables dinmicas,
contenido de cada variable, direccin de cada puntero y finalmente, liberar
espacio de memoria ocupada por los dos punteros.
Solucin:*/ punt_0011_2008.cpp
void main()
{ int suma;
int *a;
int *b ;
a = new int;
b = new int;
gotoxy(10,2);
cout<< Ingrese valor de *a = ;cin>>*a;
gotoxy(10,3);
cout<< Ingrese valor de *b =
;cin>>*b;
suma=*a+*b;
gotoxy(10,5);cout<< La suma de *a+*b es = <<suma;
gotoxy(10,7);cout<< El contenido de la variable puntero *p es = <<*a;
gotoxy(10,9);cout<< El contenido de la variable puntero *p es = <<*a;
gotoxy(10,12);cout<< La direccin de puntero *a es = <<a;
gotoxy(10,14);cout<< El La direccin de puntero *b es = <<b;
delete a;
delete b;
gotoxy(10,16);
cout<< Eliminacin de espacio de
memoria: delete a ;
gotoxy(10,17);
cout<< Eliminacin de espacio de
memoria: delete b ;
getche();
}
Problema 2. Realizar un programa que me permita declarar un puntero y que
apunte a una variable, la misma que almacena un nmero entero quees igual a
16. Generar un reporte para conocer contenido y la direccin de memoria donde
se encuentra dicha variable.
Solucin:*/ Punt001_2008.cpp
void main()
{
int x=16;
int *p;
330
p=&x;
gotoxy(10,4);cout<< El contenido es de la variable puntero es = <<*p;
gotoxy(10,5);cout<< El valor de la direccin del puntero es = <<p;
getche();
}
Problema 3. Disee un programa que permita ingresar por teclado dos nmeros
enteros y que estos permitan apuntar a su puntero respectivo, luego generar
un reporte que permita la suma acumulada de las dos variables dinmicas y su
direccin de la suma de dichos punteros.
Solucin / puntero_P002_suma_2008.cpp
void main(){

int x,y,*p,*q,suma;

gotoxy(10,4);cout<<Ingrese primer nmero = ;cin>>x;

gotoxy(10,5);cout<< Ingrese segundo nmero = ;cin>>y;

p=&x; q=&y; suma=*q+*p;

gotoxy(10,7);cout<< La suma de *p + *p es = <<suma;

gotoxy(10,9); cout<< El contenido de &suma es = <<&suma; getche();
}
Problema 4. Disee un programa, usando variables dinmicas, que permite
validar datos de usuario por cdigo =tcn y clave =123. Si los datos son
correctamente ingresados, el sistema solicita que ingrese dos nmeros enteros
para calcular la suma respectiva. A este resultado y usando una funcin que
reciba como parmetros la suma acumulada de los dos variables dinmicas,
mostrarlo en forma invertida. El programa debe ser interactivo con el usuario. Si
los datos son ingresados incorrectamente, el sistema finaliza.
Solucin //punt_valida_usuarios.cpp
int numero(int num);
int q;
int numero (int num)
{ int inv=0,n;n=num;
while(n>0)
{ inv=10*inv+n%10; n=n/10;
}
return inv;
}
void main()
{ clrscr(); int *a,*b; int q;char *cod, *clave; char resp=s;
do
{ gotoxy(10,2);cout<<VALIDANDO DATOS DE USUARIO ;clrscr();
cod=new char[5];
clave=new char[5];
a=new int;
b=new int;
gotoxy(10,4);cout<<Ingrese codigo = ; cin>>cod;
331
gotoxy(10,5);cout<<Ingrese clave = ; cin>>clave;

if (strcmp (cod,tcn)==0 && (strcmp(clave,123)==0))
{ gotoxy(10,7);cout<<Ingrese nmero a = ;cin>>*a;
gotoxy(10,8);cout<<Ingrese nmero b = ;cin>>*b;
q=*a+*b;
gotoxy(10,10); cout<<Suma = <<q;
gotoxy(10,12);cout<<Numero invertido =<<numero(q);getche();
do
{ gotoxy(10,14);cout<<Desea Ingresar nuevos datos..? ==>; cin>>resp;
}while(resp!=s && resp!=n);
if (resp==n)
{clrscr(); gotoxy(10,6); cout<< Hasta luego ; getche();exit(0);
}
}
else
{gotoxy(10,3);cout<<error en datos de usuario;
}
delete a;
delete b;
delete[]cod;
delete[]clave;
clrscr();
}while(resp==s);
}
8.5 Lista
Una lista lineal es un conjunto de elementos definidos que pueden variar en
nmero y donde cada elemento tiene un nico predecesor y un nico sucesor o
siguiente, excepto el primero y el ltimo de la lista.
Lista
20
12
11
8.6 PILA
Ultimo en Ingresar, Primero en Salir(LIFO), quiere decir, que el elemento
que se ingres al final ser el primer elemento que se muestra y tambin ser el
primero en salir.
-> UltmoIngresar -> UltmoIngresar-1 -> UltmoIngresar-2 -> ...-> 2do -> 1ro -> NULL
Una pila (stack) es un tipo especial de lista lineal en la que la insercin y borrado
de nuevos elementos se realiza solo por un extremo que se denomina cima o
tope (top).
332
Dado que las operaciones de insercin y eliminacin se realizan por un solo

extremo (el superior), los elementos solo pueden eliminarse en orden inverso al
que se insertan en la pila. El ltimo elemento que se pone en la pila es el primero
que se puede sacar, razn por la cual a estas estructuras se les denomina LIFO
(Last input , first output)
En las operaciones se presenta:
Push(): meter, poner (insercin de elementos)
Pop(): sacar, quitar (eliminacin de elementos)
Problema 1.- Disee un programa mediante una funcin prom_sumas( ) que
reciba como argumentos tres prcticas como variables punteros y luego devuelva
el promedio con cifras decimales y el promedio tipo entero.
El promedio tipo entero sirve como argumento de la funcin invertir(), la cual
devuelve en forma invertida. Asimismo, en una funcin guarda(), recibe tambin
el promedio entero y devuelve procesado en dgitos.
Solucin (vea figura adjunta)
//punt_func_sin_lista_prom .cpp
#include <iostream.h> #include <conio.h> #include <stdlib.h> #include <iomanip.
h> #include <math.h>
# define linea -----------------------------------------
int n,m,z,a[10],entero;
float prom_sumar(int *p, int *q, int *r);
int invertido(int );
void guarda(int, int a[10]);
float prom_sumar(int *p, int *q, int *r)
{float prom;
p=new int;
q=new int;
r=new int;

gotoxy(10,4);cout<<Ingrese p=; cin>>*p;

gotoxy(10,5);cout<<Ingrese b=; cin>>*q;

gotoxy(10,6);cout<<Ingrese b=; cin>>*r;

prom=float(*p+*q+*r)/3;
gotoxy(10,8); cout<< El promedio es = <<prom;

delete p;
delete q;
delete r;
entero=ceil(prom);//incrementa 1
gotoxy(10,10); cout<< Promedio entero =<<entero;
return 0;
}
int invertido(int entero)
{ int datos,d,inv=0;
333

datos=entero;

while(datos!=0)

{d=datos%10;

inv=inv*10+d;
datos=datos/10;

}
return (inv);
}
void guarda(int entero, int a[10])
{ int d,k=1,i;
while(entero!=0)
{d=entero%10;
a[k]=d;
k++;
entero=entero/10;
}
gotoxy(10,12);cout<<Promedio almacenado en un vector ;
for(i=1;i<k;i++)
{
gotoxy(10,12+i); cout<< A[<<i<<]=<<a[i]<<endl;
}
return ;
}
void main()
{gotoxy(10,2);cout<< ESTRUCTURA PUNTEROS ;
prom_sumar(&n,&m,&z);
gotoxy(10,17); cout<< Promedio <<entero<< invertido es = <<invertido(entero);
guarda(entero,a);getche();}
334
Problema 2. Disee un programa mediante una funcin prome( ),

permitaalmacenar en cada nodo notas de alumnos, luego devolver el promedio
con cifras decimales y el promedio tipo entero.
El promedio tipo entero sirve como argumento de la funcin invertir(), la cual
devuelve en forma invertida.
Solucin (ver figura adjunta)
//punt_prom_notas.cpp
//programa que trabaja con punteros p,q,r y que no forman una lista
#include <iostream.h> #include <conio.h> #include <stdlib.h>
#include <iomanip.h> #include <math.h>
int invertirn();
float prome();
typedef struct notas
{int nota;

struct noas *sigte;
}nodo;
float prom_pract;
int prom_entero, prom_mas,a,b,c,inv=0;
float prome( )
{ nodo *p,*q,*r;

p=new nodo ; q=new nodo; r=new nodo;
gotoxy(10,4);cout<< ESTRUCTURA PUNTEROS Con NODOS( sin formar
lista);
do{gotoxy(10,6);clreol();cout<< p1=;cin>>p->nota;

}while(p->nota<0||p->nota>20) ;
do{
gotoxy(10,7);clreol();cout<< p2=;cin>>q->nota;
}while(q->nota<0||q->nota>20) ;
do{gotoxy(10,8);clreol();cout<< p3=;cin>>r->nota;
}while(r->nota<0||r->nota>20) ;
prom_pract= float(p->nota+q->nota+r->nota)/3;
gotoxy(10,10);cout<<Promedio = <<prom_pract;
prom_entero=floor(prom_pract); //floor captura solo parte entera
gotoxy(10,12);cout<<Promedio sin Decimales = <<prom_entero;
prom_mas=ceil(prom_pract); //ceil aumenta mas 1
gotoxy(10,14);cout<<Promedio Redondeado = <<prom_mas;
return 0;
getche();
}
int invertirn(int prom_mas)
{ int d,invertir;
invertir=prom_mas;
while(invertir!=0)

335
{d = invertir%10;
inv =inv*10+d;
invertir=invertir/10;}
return (inv);
}
void main(){invertirn(prom_mas);prome();
gotoxy(10,16);cout<<Numero invertido es = <<invertirn(prom_mas); getche();
}
8.7. Punteros Nivel RAM

Permite procesar los datos de la pila en la semntica El ltimo elemento en
entrar, ser el Primero en Salir: (LIFO), pero al finalizar la tarea se debe liberar
espacio de memoria utilizada.
Problema 1.-Disear un programa
que permitaalmacenar las notas
de tres alumnos en una estructura
dinmica pila, luego genere un
reporte de los elementos de lapila,
liberar (eliminar) espacio de memoria
utilizada por cada nodo.
Solucin
//pila_2010_3_Nodos.cpp
typedefstruct alum // defino estructura de la pila
{int nota;
struct alum *sigte;
}nodo;
voidmain()
{nodo *p; nodo *q; nodo *r; //declaro
3 punteros
p=new nodo;
// asigno
memoria para cada puntero
q=new nodo; r=new nodo;
system(title Cordova Neri T.
:
pila_2010_3_Nodos.cpp);
gotoxy(12,2); cout<< ==> CREANDO
PILA <== ;
gotoxy(10,4); cout<<Ingrese Nota de Primer Nodo : ;cin>> p->nota;
p->sigte=q;
gotoxy(10,5); cout<<Ingrese Nota de Segundo Nodo : ;cin>>q->nota;
q->sigte=r;
gotoxy(10,6); cout<<Ingrese Nota de Tercer Nodo : ;cin>>r->nota;
r->sigte=NULL;
//reporte
336
gotoxy(10,11); cout<< Pila:;

gotoxy (18,11);
cout<<r->nota<< => <<q->nota<< =>
<<p->nota;
// eliminando nodos
delete [] p;delete [] q ;delete [] r; o
free(p);
getche();
}
Problema 2. Disear un programa que permita almacenar notas de alumnos en
una pila de tamao n (n definido por usuario), luego clasificar notas aprobadas
y guardar en el vector Aprob[ ], as como notas desaprobadas y guardar en
el vector desp[ ]. Luego genere un reporte de los elementos de la pila. Use los
siguientes subprogramas:
- crear_nodo(int valor): funcin para inicializar e ir creando nodos.
- marco(): procedimiento para crear marco.
- crear_lista(nodo*&p): procedimiento para crear la pila.
- aprob_desap(nodo*&p): procedimiento para recorrer la pila en busca de notas
aprobadas y desaprobadas.
- Listar datos(nodo *&p): procedimiento para recorrer la pila y mostrar la
estructura formada por todos los elementos de cada nodo, tal como se ilustra
en la figura adjunta.
Solucin
//pila_nodo_notas_func_reportes_
ok.cpp
# include<time.h>
intn,j,
i,
aprob=0,
desap=0,de=0,ap=0,notas[100],
notasde[100],aux;
int datos[100];
typedefstructnotaslaumnos//
MODELO
{ int nota; // DATO DE USUARIO
structnotaslaumnos *sgte;//ENLACE DE SIGUIENTE NODO
}nodo; //VAR REGISTRO
nodo *crear_nodo(int valor) //creo nodo y le asigno datos
{ nodo *r; // r toma direccin de memoria
r = new nodo; // r recibe espacio de memoria
r->nota=valor;//llenar campo del nodo
r->sgte=NULL;//termina de definir el nodo
return(r);//returne la direccin de r
337
}
voidmarco()
{ int i;
time_t t;
t = time(&t);
gotoxy(12,3);cout<<Fecha y hora actual : <<ctime(&t);
gotoxy(10,20) ;cout<<; gotoxy(10,4) ;cout<<; //esquinas
for (i=11 ;i <=59 ; i++)
{gotoxy(i,4) ;cout<<; gotoxy(i,5) ;cout<<;
// lineashorizontales
gotoxy(i,20) ;cout<<;
}
gotoxy(60,4) ;cout<<; gotoxy(60,20) ;cout<< ; //esquinas
for(i=5;i<=19;i++)
{gotoxy(10,i) ;cout<<; gotoxy(60,i );cout<<; //lineasverticales
}
gotoxy(17,5);cout<< ---> Creando Lista (*PILA) <--- ;
}
voidcrear_lista(nodo *&p)// creo procedimiento para ir llamando a nodo
{ marco(); intnota,i;
nodo *r;
p=NULL;//inicializo
do{ gotoxy(16,7);cout<<Ingrese numero de nodos: ;cin>>n;
}while (n<0 ||n>100);
for(i=1;i<=n;i++)
{ do {gotoxy(18,i+8);cout<<Nota <<i<< : ;cin>>nota;
}while(nota<0||nota>20);
r=crear_nodo(nota);//llamar a funcin y asigno nota

// preguntamos: existe pila o no
if (p==NULL) //1.- Pila p NO existe

{p=r; //tomo direccin de nodo r

}
else
// 2.- pila existe
{ r->sgte=p;//inserto nodo delante de p
p=r;//p recibe direccin de r
}
}//fin de for
}// fin procedimiento
voidaprob_desap(nodo *&p)// recorrer la pila
{ marco();
nodo *aux;// crear var puntero para obtener copia
aux=new nodo;// su espacio de memoria
aux=p; //hacer copia de p en aux
while(aux!=NULL)//recorre la lista mientras no este al final de ultimo nodo
{ if(aux->nota >10)// ingrese a dato de cada nodo

{ap++;//aprob++;

notas[ap]=aux->nota;//copia nota en vector

}
338
else
{de++;//desap++;

notasde[de]=aux->nota;

}

aux=aux->sgte;// pasar al nuevo nodo
} //fin del while
gotoxy(13,n+10);cout<<Total Aprobados: <<ap;//aprob;
gotoxy(18,n+11);cout<<Notas ;
for(i=1;i<=ap;i++) // vector notasaprob

{ gotoxy(15,n+12);cout<<----------------;

gotoxy(18,i+16);cout<<i<<.- <<notas[i]<<endl;
}
gotoxy(36,n+10);cout<<Total Desaprobados: <<de;//desap;
gotoxy(42,n+11);cout<<Notas <<endl;
for(i=1;i<=de;i++)// noasdesaprob
{ gotoxy(39,n+12);cout<<----------------;
gotoxy(40,i+16);cout<<\t<<i<<.-<< <<notasde[i]<<endl;
}
}//fin de procedimiento desap()
voidListarDatos(nodo *&p)// procedimiento p mostrar pila
{ nodo *aux;// para obtener copia
if(aux==NULL)
cout<<\n\nLA LISTA ESTA VACIA<<endl;
int k=0;
while(aux!=NULL)
{ k++;
gotoxy(14,10); cout<<PILA: ;
gotoxy(12+7*k,11);cout<< -> <<aux->nota;
aux=aux->sgte; //paso a siguiente nodo
}
getch();
}
voidbuscar_nota(nodo *&p)// procedimiento para buscar
{ intnotas,nn=0;
marco();
nodo *aux;// para obtener copia
gotoxy(13,15);cout<<Ingrese Nota a Buscar = ;cin>>notas;
while(aux!=NULL)//recorre la lista
{if(aux->nota==notas)

{ nn++;

}
339

} //fin del while
gotoxy(13,16);cout<<Total de Notas
Encontradas = <<nn;
}
voidmain()
{nodo *lista;crear_lista(lista);aprob_
desap(lista); getch(); clrscr();
marco(); ListarDatos(lista); // clrscr();
marco(); buscar_nota(lista);getche();
}
Problema 3. Disear un programa que este compuesto por los siguientes
subprogramas:
- Menup(): genera las siguientes alternativas/opciones tal como se ilustra en la
siguiente figura: donde cadaopcin se ejecuta con los siguientes subprogramas:
- crear_nodo(valor): funcin que devuelve un nodo con dato de usuario:nota.
- crea_lista(lista):
procedimiento
que crea la pila con n nodos.
- aprob_desap(lista): procedimiento
que recorre la pila y muestra notas
aprobadas, desaprobadas. En la
siguiente figura se ilustra la lectura
de notas con el procedimiento:
- aprob_desap(nodo *&p): listado
de notas aprobadas y el total,
asimismo, las notas desaprobadas
y su total.
- Ordenar ascend(lista): procedi-miento que recorre la pila y ordena las notas
- Ordenar descend(lista): procedimiento que recorre la pila y ordena
las notas en forma descendente.
- Eliminar(lista):
procedimiento
que solicita al usuario el ingreso de
una nota para ser eliminada.
-
Buscar
por
pos(lista):
procedimiento que busca una nota
segn posicin ingresada por usuario.
- Buscar por val (lista): procedimiento que busca una nota ingresada por
usuario.
Mostrar lista(lista): procedimiento que recorre la pila y genera un reporte de
340
todos sus elementos.

Solucin
//pilas_orden_elim_crea_2009.cpp
#include marcos.h
# include carat_principal.h
# define linea ---------------------------------
int n;
typedefstructnota_alumno
{ int nota;
structnota_alumno *sgte;
}nodo;
nodo *crear_nodo(int valor) {
caratulmarco();;
nodo *r; // r temporal
r=new nodo;
r->nota=valor;
r->sgte=NULL; return (r);
}
int Menu(nodo *p)
{ caratulmarco();int i;
//
system(cls);//system(color 4e);
caratulmarco();//system(color 4e);
gotoxy(15,5); cout<< ==> PILAS ( L.I.F.O. ) <==;
gotoxy(8,6); cout<<_________________________________________;
gotoxy(13,7);cout<< <1> Crear Pila;
gotoxy(13,8);cout<< <2> Aprobados y Desprobados;
gotoxy(13,9);cout<< <3> Ordenar forma Ascendente;
gotoxy(13,10);cout<< <4> Ordenar forma Descendente ;
gotoxy(13,11);cout<< <5> Eliminar Nota;
gotoxy(13,12);cout<< <6> Buscar Nota segunPosicion;
gotoxy(13,13);cout<< <7> Buscar Nota segun Valor;
gotoxy(13,14);cout<< <8>MostrarPila ;
gotoxy(13,15);cout<< <0>Finalizar ;
do{
gotoxy(15,17);cout<< < Elija su opcin>==> ;

clreol();//system(color 4e);
cin>>i;
}while(i<0 || i>9);
return(i);
}
voidcrea_lista (nodo *&p) // dinmico y direccin
{clrscr();caratulmarco();
nodo *r;int nota, i ; p=NULL;
gotoxy(10,4);cout<< Cuantos nodos desea crear: ; cin>>n;
for (i = 1; i<=n; i++)
{ caratulmarco(); gotoxy(10,4+i); cout<<nota[<<i<<]=; cin>>nota;
341
r = crear_nodo(nota); // r recibe la direccin de la funcin

if (p==NULL) // si pila no est creada entonces reciba la direccin del nodo
// temporal de r

{ p=r;
}
else // si pila esta creada tiene 1 o + nodos entonces
{ r ->sgte=p; //el campo siguiente apunta hacia el inicio de la pila
p=r; // p toma la direccin de r (copio nodo r delante del valor de la pila p)
}
}
return;
}
voidaprob_desap(nodo *&p)// recorrer la pila
{
nodo *aux;// crear var puntero para obtener copia


intap=0,de=0,notas[100],notasde[100],i;
while(aux!=NULL)//recorre la lista mientras no est al final de ultimo nodo

{ if(aux->nota >10)// ingrese a dato de cada nodo

{ ap++;

notas[ap]=aux->nota;//copia nota en vector

}
else
{ de++;

notasde[de]=aux->nota;
}
} //fin del while
gotoxy(13,6);cout<<Total Aprobados: <<ap;//aprob;
gotoxy(18,8);cout<<Notas ; gotoxy(15,9);cout<<----------------;
for(i=1;i<=ap;i++) // vector notasaprob
{ gotoxy(18,i+9);cout<<i<<.- <<notas[i];
}
gotoxy(36,6);cout<<Total Desaprobados: <<de;//desap;
gotoxy(42,8);cout<<Notas <<endl; gotoxy(39,9);cout<<----------------;
for(i=1;i<=de;i++)// noasdesaprob
{ gotoxy(40,i+9);cout<<i<<.-<< <<notasde[i];
}
}
voidOrdenarAscend(nodo *p)
{ caratulmarco();int i=0; nodo *q; int aux;
q = new nodo; q=p;
gotoxy(20,5);cout<< Reporte de Notas;
gotoxy(4,6);
cout<<__________________________________________________ ;
gotoxy(10,9);cout<< Notas ordenadas de forma Ascendente ;
342
while(p!=NULL)
{ q=p->sgte;
while(q!=NULL)
{ if(q->nota < p->nota)

{ aux=q->nota; q->nota=p->nota;
p->nota=aux;
}
q=q->sgte;
}
gotoxy(10,11); cout<< Notas : ;
gotoxy (20+8*i,11); cout<< => << p->nota;
p=p->sgte; i++;
}
free(q); free(p);
return;
}
voidOrdenarDescend(nodo *p)
{ caratulmarco();
nodo *q;intaux,i=0;
q = new nodo;
q=p;
gotoxy(20,5);cout<< Reporte de Notas;
gotoxy(4,6);
cout<<__________________________________________________ ;
gotoxy(10,9);cout<< Notas ordenadas de forma Descendente ;
while(p!=NULL)
{
q=p->sgte;
while(q!=NULL)
{ if(q->nota > p->nota)

{aux=q->nota;q->nota=p->nota; p->nota=aux;
}
q=q->sgte;
}
gotoxy(10,11); cout<< Notas : ;
p=p->sgte; i++;
}
free(q); free(p); return;
}
void Eliminar(nodo *p)
{ caratulmarco();int dato; nodo *q;
gotoxy(20,5);cout<< Modulo de Eliminacion ;
gotoxy(15,6);
cout<<__________________________________________________ ;
gotoxy(10,11);cout<< Ingrese Nota a eliminar = ;cin>>dato;
q = new nodo; q=p;
343
if(p->nota==dato)
{q=q->sgte;
free(p);
return;
}
while(p!=NULL)
{ if(p->nota==dato)
{ q->sgte=p->sgte;
free(p);
gotoxy(10,13);cout<< Nota Eliminada.... ;
getche();
return;
}
q=p;
p=p->sgte;
}
gotoxy(10,12);cout<< existe ese dato...\n\n;
system(pause);
return;
}
voidBuscarXPos(nodo *p)
{ caratulmarco();
intpos,cont=0;
gotoxy(20,5);cout<< Modulo de Bsqueda ;
gotoxy(15,6);cout<<________________________________ ;
gotoxy(10,8);cout<< Ingrese posicin: ;cin>>pos;
while(p!=NULL)
{ cont++;
if(cont==pos)
{
gotoxy(10,12);
cout<<La posicin <<pos<< contiene la nota : <<p->nota;
getche();
return;
}
p=p->sgte;
}
gotoxy(10,12);cout<< La posicin no existe;
getche();
return;
}
voidBuscarXVal(nodo *p)
{caratulmarco();
intdato,cont=0;
gotoxy(20,5);cout<< Mdulo de Bsqueda ;
gotoxy(4,6);cout<<________________________________ ;
gotoxy(10,8);cout<< Ingrese Nota = ;cin>>dato;;
while(p!=NULL)
{ cont++;
344
if(p->nota==dato)
{gotoxy(10,12);cout<< La Nota se encuentra en la posicin : <<cont;;
getche();
return;
}
p=p->sgte;
}
gotoxy(10,12);cout<< La Nota no existe;
getche();
return;
}
voidMostrarLista(nodo *p)
{ caratulmarco();
int i;
gotoxy(20,5);cout<< PILA(LIFO) FORMADA ;
gotoxy(10,6);cout<<________________________________________ ;
while(p!=NULL)
{ gotoxy(12,11); cout<< Pila : ;
p=p->sgte;
i++;
}
return;
}
void main()
{ nodo *lista;
bool log=true;
caratula();
caratulmarco();
do{caratulmarco();
switch(Menu(lista))
{ case 1: clrscr();//caratula();
crea_lista(lista); getche();clrscr(); break;
case 2: clrscr();caratulmarco();aprob_desap(lista);getche();clrscr();
break;
case 3:clrscr();caratulmarco();OrdenarAscend(lista);getche();clrscr();
break;
case 4: clrscr();caratulmarco();;OrdenarDescend(lista); getche();clrscr();
break;
case 5: clrscr();caratulmarco();Eliminar(lista);
getche();clrscr();
break;
case 6: clrscr();caratulmarco();BuscarXPos(lista); getche();clrscr();
break;
case 7: clrscr();caratulmarco();BuscarXVal(lista); getche();clrscr();
break;
case 8: clrscr();caratulmarco();MostrarLista(lista);getche();clrscr();
345
break;
case 0: clrscr();log=false;
}
}while(log);
}
8.8 Nivel archivos

Tambin permite procesar los datos de la pila, pero al finalizar la tarea, los
datos pueden almacenar en memorias externas (USB, Hard Disk, etc.) para
posteriormente realizar mantenimientode los datos.
Aplicacin
Disear un programa que permita crear el archivo ALUMNOS.TXT y luego
almacenar datos de nalumnos (n definido por usuario), datos por: nombre(se
puede considerar como clave con fines de usar funciones de cadenas), promedio
y crditos respectivamente. Luego de usando el archivo de datos, mediante una
pila hacer un reporte de alumnos10. Seguir los siguientes procedimientos:
1. Crear archivo ALUMNOS.TXT. En la siguiente interface se ilustra la lectura de
datos de alumnos, observe que existen dos alumnos con promedio menor a 10.
2. Procesando PILA. Permite jalar, cargar los registros de los n alumnos
creados, segn paso 1. Los resultados se ilustran en la siguiente interface.
Observe que en el reporte se
visualiza los elementos de
la estructura dinmica PILA
(LIFO), asimismo, no existen
alumnos con promedio menor a
10.
Implementacin
I. CREA ARCHIVO//Arc_crea_
Pilas_Alumn.cpp
struct ALUM
{ char alum_pri_nomb[12]; float prom;int cred;
} alumnos;
FILE *falumnos;
void crea_alumnos()
{int l,i=0,j;
char resp=S,cod[12];clrscr();
gotoxy(10,2);
cout<<....CreandoArchivo ALUMNOS.txt.;
gotoxy(10,4);
346
cout<< Nombre
Promedio
Creditos ;
gotoxy(5,5); cout<<_______________
____________;
while(resp==S||resp==s)
{i++; falumnos=fopen(ALUMNOS.
txt,a+);
if(falumnos == NULL)
{ f a l u m n o s = f o p e n ( A L U M N O S .
txt,a+);}
gotoxy(12,5+i);gets(cod) ;fread(&al
umnos,sizeof(alumnos),1,falumnos);
while(!feof(falumnos))
{if(strcmpi(alumnos.alum_pri_
nomb,cod)==0)
{ gotoxy(26,16); fclose(falumnos);
cout<< Nombre ya existe..!!! ; getche();return;
}
fread(&alumnos,sizeof(alumnos),1,falumnos);
}
strcpy(alumnos.alum_pri_nomb,cod);
do{ gotoxy(26,5+i);clreol();cin>>alumnos.prom;
}while(alumnos.prom<0 || alumnos.prom>20);
gotoxy(45,5+i);cin>>alumnos.cred;
gotoxy(4,16);cprintf(Desea ingresar nuevo alumnos..?<S/N>==> );cin>>resp;
for(l=1;l<=50;l++)
{gotoxy(3+l,16);cprintf(); }
fwrite(&alumnos,sizeof(alumnos),1,falumnos);fclose(falumnos);
}
gotoxy(10,21);cout<<adios; getche(); return;
}
void main(){crea_alumnos();getche();}
II. Mediante la estructura PILA. Programa que permite, mediante una PILA,
hacer un reporte de alumnos almacenados en un archivoALUMNOS.TXT,
creado con el programa fuente del paso I)
Solucin //pila_jala_arch_Alumn.cpp
struct ALUM
{char nomb[12];
float prom;
int cred;
}f1;
typedef struct pila_trabajadores
{ float prom; char nombres[20]; int cred;
347
struct pila_trabajadores *sigte;

}nodo;
//crear una funcion que jale registros del Archivo externo
nodo *cargar_Al(char nombres[20],float prom,int creditos)
{ nodo *aux;aux=new nodo;
strcpy(aux->nombres,nombres); aux->prom=prom;
aux->cred=creditos;
aux->sigte=NULL; return(aux);
}
void main()
{ FILE *ftrabajador; char resp;
Do
{clrscr();
system(title programa--- pila_jala_arch_Alumn.cpp );
struct ALUM f1;
int tot_reg,i=0; nodo *aux;
ftrabajador=fopen(ALUMNOS.txt,r+);
fread(&f1,sizeof(f1),1,ftrabajador);
while(!feof(ftrabajador))
{ i++;
}
fclose(ftrabajador);
i= i-1;
tot_reg=i;
i=0;
ftrabajador=fopen(ALUMNOS.txt,r+);
gotoxy(7,2);cout<<Cargando data del Archivo ALUMNOS.TXT Espere.......;
gotoxy(9,4);
cout<<
#
<<setw(13)<<Nombres
<<setw(13)<<Promedio
<<setw(13)<<Creditos ;
gotoxy(5,5);
cout<< _____________________________________________________________;
while(!feof(ftrabajador)&&i<tot_reg)
{ i++;
aux=cargar_Al(f1.nomb,f1.prom,f1.cred); gotoxy(10,5+i);
cout<<i<<.-<<setw(8)<<aux->nombres<<setw(12)<<aux>prom<<setw(14)<<aux->cred;
aux=aux->sigte;
}
gotoxy(10,15); cout<<Total de registros = <<tot_reg;
gotoxy(10,18); cout<<Desea hacer nueva consulta...? (S/N)==> ;cin>>resp;
} while(resp==S ||resp==s);
}
348
8.9 Compendio de problemas

Problema 1. Disear programas que permitan crear los archivos mostrados en las
siguientes figuras usando las tcnicas de:
1. Programa 1. Solo usa tcnica de archivos
2. Programa 2. Usa archivos + pilas (LIFO)
Se entiende que los campos claves no deben repetirse en las tablas, luego realice
las siguientes consultas usando las tcnicas de:
I.- Tcnica de archivos
Consulta 1. Listado de alumnos por cdigo y edad, pero ordenados en forma
ascendente por edad.
Consulta 2. Listado de alumnos por cdigo, apellidos, nombre de cursos, sus
notas y su promedio respectivo indicando el estado aprobado / desaprobado.
II. Tcnica de pilas

Consulta 1. Listado de alumnos por cdigo, apellidos, cdigo de cursos y sus
notas.
Consulta 2. Listado de alumnos por cdigo, cdigo de cursos, sus notas y su
promedio respectivo.
Problema 2. Disear programas que permitanconsultardata histrica (avance
curricular)de n alumnos. Para lo cual considere las siguientes restricciones:
1. Considere solo 10 ciclos acadmicos.
2. El archivo ALUMNOS.TXT, puede ser el nico.
3. El archivo NOTAS.TXT solo vara los siguientes datos:
- Considere que se implementaron tres ciclos por ao.
- Las notas por cada ciclo varan
- Cuando ingresa a consultar las notas de un alumno, se elije el primer ao
acadmico, en este ao el programa permite al usuario consultar ciclo por
349
clico (hasta 3), luego puedepasar al segundo ao y repite lo mismo del

primer ciclo.
Ejemplo:
Cdigos
100
200
Ciclos
Promedio
2005-1
12.3
2005-2
11.4
2005-3
15.8
Ciclos
Promedio
2005-1
11
2005-2
11.4
2005-3
12
Ciclos
Promedio
2006-1
5.5
2006-2
12.5
2006-3
6.7
Ciclos
Promedio
2006-1
4.4
2006-2
12.2
2006-3
11.3
Ciclos
Promedio
2007-1
10.2
2007-2
3.4
2007-3
11.2
Ciclos
Promedio
2007-1
12.4
2007-2
17.5
2007-3
11.5

que permita leer n (n>10) alumnos
por cdigo(int) y apellidos(char(20))
y almacenarlo en un archivo Lista.
dat, usando la tcnica de colas, luego
debe realizar los procesos mostrados
en la siguiente pantalla.
El programa debe ser interactivo
con el usuario, es decir; despus de
mostrar el resultado se debe mostrar
la siguiente pregunta: Sr. desea
hacer nueva consulta? (S/N).
Problema 4. Una seccin cuenta con 40 alumnos codificados correlativamente
como cod01, cod02, cod10, etc., (son nicos, no se repiten). Diseen un programa
que genere aleatoriamente (o puede leer) las notas de los 40 alumnos (colocar en
un vector) de la seccin e imprima a continuacin un listado como el siguiente:

350
LISTADO GENERAL DE NOTAS

-----------------------------------------------------------------Cdigo
Notas
Condicin
------------------------------------------------------------------cod01
17
Aprobado
cod02
08
Desaprobado
cod03
14
Aprobado
.
.

.
cod45
cod15
.
06
06
Desaprobado
Desaprobado
-------------------------------------------------------------------
Adems, en ese mismo instante, mostrar por pantalla un reporte estadstico.

REPORTE ESTADSTICO
---------------------------------------------------------------------------------Nmero de aprobados: 33 (73.33 %) (calculado con todas las notas)
Nmero de desaprobados:
12 (26.67 %) (calculado con todas las notas)
Nota promedio:
14.50

Mayor nota:
17 (total =1)

Menor a:
06 (total =2)
Problema 5.- Se tienen las siguientes tablas donde se almacena los datos de cada
docente y los das que dicta cada curso, el pago por hora es de acuerdo a la
categora segn:
Categora 1: 20 soles
Usando tcnica de archivos con pilas/colas disear el programa que permita
leer los datos solicitados, segn campos mostrados, en cada entidad el siguiente
modelo relacional de base de datos:
Aqu, se ilustra tablas con datos de algunos registros.
DOCENTE
DIARIO
CODDOC
5C
NOMDOC
30C
CATEGORIA int.
D001
D002
D003
Luis Vera
Ana Garca
Juan Lopez
CURSO
CODDOC
CODCUR
HORAS
FECHA
1
3
2
D001
D001
D002
D002
D003
D003
C001
C004
C003
C001
C005
C003
5C
5C
DOUBLE
10C
4
5
3
4
3
2
11/10/10
15/10/10
17/11/10
21/11/10
23/11/10
25/11/10
CODCUR5C
NOMCUR
15C
C001
C002
C003
C004
Matemtica I
Anlisis II
Fisca I
Qumica
Luego mostrar resultados de acuerdo al siguiente formulario:
351

RECORD DE HORAS DICTADAS
Cdigo del docente: XXXXXXXX
(se ingresa)
Nombre del docente: xxxxxxxxxxxxxxxxxxxxxxxxxxxxx (se obtiene del sistema)
Categora => 99
Pago hora=>
Fecha
Horas
Nombre del curso
XXXXX
999
Total horas
Total pago
xxxxxxxxxxx
=> 999,999.
=> 999.999.99
Problema 6. Disear un programa que ingrese a una estructura de datos PILA,

datos de n socios de un club (N<=1000) por: cdigo, apellidos, edad, cuota y
mora. Se pide calcular e imprimir por medio de un subprograma:
a. Un reporte de los socios que incluya el importe a pagar por socio.
b. Socio con edad ms alta.
c. Los dos socios de menos edad.
Los datos correspondientes a estudiantes de una institucin educativa se ilustran
en los siguientes archivos:
ALUMNOS.DAT
Cd_al
Apellidos
CURSOS.DAT
Nombres
Cod._cur.
Descripcin
rea acad.
100
Salas
Juan
124
Matemticas
Bsicas
200
Sols
Pedro
760
Compiladores
Sistemas
300
Cspedes
Mara
195
Numricos
Bsicas
400
Carrasco
Noem
511
Costos
Gestin
Cdigo
100
200
300
400
100
Cod._cur.
124
760
124
124
760
N1
14
13
11
10
08
N2
11
14
11
10
10
N3
10
05
14
13
14
pp
?
NOTAS_ALUMNOS.DAT
Se pide:
a. Disear un programa que permita: crear los archivos fsicos:
ALUMNOS.DAT, CURSOS.DAT y NOTAS_ALUMNOS.DAT
b. Disear un programa: Reportes.CPP, programa que permita mostrar un
reporte de los archivos alumnos o cursos o notas_alumnos.
c. Disear un programa: Insertar.CPP, programa que permita insertar registros
correspondientes a alumnos o cursos o notas_alumnos.
d. Disear un programa: Eliminar.CPP, programa que permita eliminar registros
alumnos o cursos o notas_alumnos.
352
e. Disear
un
programa:
Modificar.CPP, programa que
permita modificar
re-gistros
correspondientes a alumnos o
cursos o notas_alumnos.
f. Disear un programa: Estado_
Alum.CPP,
programa
que
permita hacer un reporte
de alumnos por: cdigo,
apellidos y nombre, cond_cur, descripcin y sus promedios, mostrando el
estado:aprobado o desaprobado.
g. Cuando realiza el proceso de eliminacin, guardar como histrico todos los
registros eliminados en un archivo registros_baja.txt.
Problema 7.- Usando pilas, disear un programa que permita ingresar datos de
n alumnos (n<=1000) por apellidos, nombres, cdigo, edad y sus evaluaciones
respectivas: tres prcticas calificadas y dos exmenes.
En la figura adjunta se ilustra el ingreso de datos por alumno. Realice los
siguientes procesos:
Reporte # 1: Listado de los registros, mostrando sus datos de entrada, promedio

de prcticas, promedio final y el estado de alumno APROBADO, si el
promedio final es mayor a 10,5, en otro caso DESAPROBADO. Asimismo,
total de aprobados y desaprobados.
353
Reporte # 2: Listado de los alumnos ordenados por edad y en forma ascendente.

Asimismo, el usuario debe buscar edad especfica.
Reporte # 3: Usuario ingresa edad y

el sistema genera el reporte mostrado
en la figura.
Reporte # 4: Listado de los alumnos
ordenados por apellido y en forma
ascendente (puede haber variado
datos debido a segunda ejecucin).
Reporte # 5: Mdulo para insertar registros.
354
Reporte # 6: Mdulo que permite eliminar registros, solicita el nmero de

registros a eliminar e informa el total disponible. Listado despus de eliminar.
Problema 8. Usando archivos con pilas/ colas, disear un programa que permita
disponer de un sistema acadmico de matrcula, para lo cual se considera el
siguiente modelo relacional de base de datos:
Usando el modelo relacional, se inicia la programacin considerando interfaces

amigables y didcticas para los usuarios.
En las siguientes interfaces se ilustra los procesos a disear:
Interface de validacin: En la presente interface solo el administrador tiene todos
los derechos en el sistema tales como: insertar, eliminar, modificar, etc.
355
Interface de validacin de usuario:
Usar las interfaces del problema 2 del captulo VII de Archivo
356
Bibliografa
Deitel & Associates Inc. C/C++ Como programar. 4a ed. Mxico: Prentice Hall, 2004.
Joyanes, Luis. Fundamentos de programacin. Madrid: Mc. Graw Hill, 2004
------------------. Programacin en Turbo Pascal. 3a Madrid...
357
358
ndice temtico
Anidamiento de registros..............................................................276
ANSI C.............................................................................................. XV
Argumento.......................................................................................225
Arrays bidimensionales.................................................................149
Arreglos unidimensionales............................................................191
Cadenas de caracteres....................................................................199
Cin.getline........................................................................201, 216, 218
Conversin a mayscula y minscula.........................................215
Colas (FIFO).....................................................................................351
Estructura repetitiva.............................................................29, 37, 44
Estructura selectivas condicionales................................................16
Estructura selectiva compuesta.......................................................18
Funciones.........................................................................................221
Funciones para invertir cadenas...................................................214
Funciones para la comparacin de cadenas................................210
Identificadores.....................................................................................4
Inclusin de una cadena en otra...................................................215
Lenguaje de programacin procedural...............................................XV
Lenguaje orientado a objetos.......................................................... XV
Lenguajes de mquina.........................................................................3
Operaciones con vectores...............................................................126
Parmetro.................................................................................225, 227
Programacin dinmica (punteros)..............................................327
Recursividad directa e indirecta...................................................259
Registros...........................................................................................273
Rewind..............................................................................................314
Tipos de datos......................................................................................5
Transformacin de cadenas...........................................................213
Variables locales y globales............................................................226
359
360
Este libro se termin de imprimir en el mes

de mayo de 2012 en los talleres grficos de la
imprenta de la Editorial Universitaria de la
361
362

Lenguaje de Programacion Borland

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Lenguaje de Programacion Borland

Uploaded by

Copyright:

Available Formats

Lenguaje de programacin estructurada y sus aplicaciones en Borland C++ 5.0.

Teodoro Luciano Crdova Neri

Universidad Nacional de Ingeniera

Teodoro Luciano Crdova Neri

Rector Dr. Ing. Aurelio Padilla Ros

Av. Tpac Amaru 210, Rmac Lima

Lenguaje de programacin estructurada y sus aplicaciones en Borland C++ 5.0.2

Dr. Ing. Aurelio Padilla Ros

Teodoro Luciano Crdova Neri

Lenguaje de programacin estructurada y sus aplicaciones en Borland C++ 5.0.2

A mis padres Luis y Gliceria, gracias

Teodoro Luciano Crdova Neri

Lenguaje de programacin estructurada y sus aplicaciones en Borland C++ 5.0.2

Reconocimiento y gratitud a todos mis maestros

Teodoro Luciano Crdova Neri

Lenguaje de programacin estructurada y sus aplicaciones en Borland C++ 5.0.2

Teodoro Luciano Crdova Neri

2.4 Estructuras repetitivas....................................................................................... 29

Introduccin a las estructuras de datos......................................................... 124

Lenguaje de programacin estructurada y sus aplicaciones en Borland C++ 5.0.2

Introduccin. Definiciones.............................................................................. 273

Teodoro Luciano Crdova Neri

Lenguaje de programacin estructurada y sus aplicaciones en Borland C++ 5.0.2

Teodoro Luciano Crdova Neri

Lenguaje de programacin estructurada y sus aplicaciones en Borland C++ 5.0.2

Teodoro Luciano Crdova Neri

Lenguaje de programacin estructurada y sus aplicaciones en Borland C++ 5.0.2

1.2 Introduccin a la programacin

Teodoro Luciano Crdova Neri

Dato. Es la representacin de algn hecho, concepto o entidad real.

1.3 Caractersticas de un algoritmo de computador

1.4 Lenguajes de programacin

Lenguaje de programacin estructurada y sus aplicaciones en Borland C++ 5.0.2

por el procesador, sino que requieren de pasos intermedios de traduccin e

1.5 Lenguajes de mquina

1.6 Lenguajes de bajo nivel

1.7 Lenguajes de alto nivel

1.8 Programa ejecutable

1.10 Palabras reservadas

Teodoro Luciano Crdova Neri

Lenguaje de programacin estructurada y sus aplicaciones en Borland C++ 5.0.2

14.2 Por los delimitadores (/*..*/) para comentarios de una o ms lneas.

1.13 Tipos de datos

0 .. 4 294 967 295

2 147 483 648 .. 2 147 483 647

1.14 Carcter (char)

alerta (bip sonoro)

salto de pgina en la impresora (formfeed)

nueva lnea (newline)

retorno de carro (carriagereturn)

barra invertida (backslash)

Teodoro Luciano Crdova Neri

Constantes cadena (char * o char[])

Lenguajes de Programacion, Borland C++ 5.0.2

Tambin se pueden incluir secuencias de escape:

1.15 Declaracin de constantes simblicas

en donde tipo_de_dato es cualquier tipo vlido en C++.

// prom es un datos de tipo real.

Operadores.- Tienen una gran utilidad durante la programacin, considerando

Lenguaje de programacin estructurada y sus aplicaciones en Borland C++ 5.0.2

n++ usa n y luego incrementa en 1

a/b // divide a entre b

a%b // devuelve el mdulo de la divisin

14.2 Por los delimitadores (/../) para comentarios de una o ms lneas.