3cera Edi 3 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 Teodoro Luciano Crdova Neri Derechos reservados Derechos de edicin Universidad Nacional de Ingeniera 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 Universidad Nacional de Ingeniera 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
Lenguaje de programacin estructurada y sus aplicaciones en Borland C++ 5.0.2
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 Lgico Enteros bool unsigned char char enum unsigned int short int int unsigned long long Reales float double long double Tamao 1 bit 8 bits 8 bits 16 bits 16 bits 16 bits 16 bits 32 bits 32 bits 32 bits 64 bits 80 bits true o false 0 .. 255 128 .. 127 32 768 .. 32 767 0 .. 65 535 32 768 .. 32 767 32 768 .. 32 767 0 .. 4 294 967 295 2 147 483 648 .. 2 147 483 647 3.4E38 .. 3.4E+38 1.7E308 .. 1.7E+308 3.4E4932 .. 1.1E+4932 Rango
1.14 Carcter (char)

Las constantes que representan a caracteres o acciones especiales. Ejemplos: s, A, -,|
\a \b \f \n \r \t \v \\ alerta (bip sonoro) retroceso (backspace) salto de pgina en la impresora (formfeed) nueva lnea (newline) retorno de carro (carriagereturn) tabulacin horizontal 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 Ejemplos float prom; nombre_de_variable; 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 su prioridad de evaluacin de operadores y su significado. En la siguiente grfica, se ilustra la sintaxis y el uso respectivo.
Lenguaje de programacin estructurada y sus aplicaciones en Borland C++ 5.0.2 Categora Negacin Contador Incremento Contador Disminuir Multiplicar Dividir Resto Operadores relacionales Operador ! ++ -* / % < <= > >= Igualdad y O Condicional Asignacin == != && || ?: = Significado Negacin lgica (NOT) Preincremento o posincremento Predecremento o posdecremento Multiplicacin Divisin Mdulo (resto) Menor que Ejemplo !(n<11) //si n es menor que 11,devuelve falso (0) n++ usa n y luego incrementa en 1 ++n // incrementa n en 1 y luego lo usa n --n// n disminuye en 1
a * b //Multiplica a por b. a/b // divide a entre b a%b // devuelve el mdulo de la divisin entera de a y b (que deben ser enteros) a < b // devuelve verdadero si a es menor que b. los otros son similares
Menor o igual que a <= b Mayor que Igualdad Desigualdad y Lgico (AND) oLgico (OR) Condicional abreviado Asignacin Asignar producto Asignar divisin Asignar mdulo Asignar suma c>d 5 == 3 // devuelve falso a!=13 ((5<13)&&(5>=4)) //Devuelve verdadero (mivar==hola) || (3<5) //Devuelve verdadero (a<b) ? a++:a-- //Si a<b, a se aumenta en 1 Sino se disminuye en 1 x = 5 //A x se le asigna el valor entero 5 (x5) m*=3 //Equivale a m = m * 3 e/=d //Equivale a e = e / d t%=2//Equivale a t = t % 2 g+=7 //Equivale a g = g + 7 Mayor o igual que d >= e
Expresiones: *= /= %= +=
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: # include<iostream.h> 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 #include<iostream.h> 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 #include<iostream.h> #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(8,5);cout<<linea; 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(8,8);cout<<linea; 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 <iostream.h> #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 #include <iostream.h> 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 #include<iostream.h> 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 //: #include <iostream.h> 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 #include<iostream.h> # 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(8,4);cout<<linea; 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(8,10);cout<<linea; gotoxy(15,11);cout<< Ingrese opcin: ;cin>>opc; switch(opc) { case P:case p: clrscr(); gotoxy(4,2);cout<<linea; 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; gotoxy(4,10);cout<<linea; break; caseR:case r: clrscr(); gotoxy(4,2);cout<<linea; gotoxy(15,4);cout<< Ingrese un nmero :; cin>>n; raiz=sqrt(n); gotoxy(15,5);cout<< La raz cuadrada de << n<< es =<<raiz; gotoxy(4,10);cout<<linea; getche(); break; caseI:case i: clrscr(); gotoxy(10,2);cout<<NMERO INVERTIDO ; gotoxy(4,3);cout<<linea; 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
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(); }
cout<<linea;
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(14,9);cout<<linea; 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(4,2);cout<<linea; gotoxy(15,5);cout<< [O] Ordenadores; gotoxy(15,6);cout<< [I] Impresoras; gotoxy(15,7);cout<< [L] Lectoras; gotoxy(15,8);cout<< [S] Salir; gotoxy(4,10);cout<<linea; 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(4,10);cout<<linea; 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; gotoxy(15,6);cout<< Edite opcin;cin>>imp; 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; gotoxy(15,6);cout<< Edite opcin;cin>>imp; 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<iostream.h> #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 #include <iostream.h> #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(5,8);cout<<linea; 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; gotoxy(5,14);cout<<linea; 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 #include <iostream.h> 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 #include <iostream.h> 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 #include<iostream.h> 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<iostream.h> #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(); } Problema 6. Disear un programa 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 #include <iostream.h> 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 #include<iostream.h> 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 #include <iostream.h> 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)
} 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(); }
if (num>>min) } i++; } gotoxy(10,4+i+1); cout<<ingrese nmero:;cin>>num;
{in++; sin+=num; } { min=num; }
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 ; gotoxy(6,3); cout<<linea;
Obs. La condicin de prueba puede ser tambin do { }while(!(cont>n));
37
gotoxy(10,4); cout<< 1 + 2 + 3 + .....+ n; gotoxy(6,5); cout<<linea; 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 #include<iostream.h> # 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(6,3); cout<<linea; gotoxy(12,4); cout<<1 2 3..........n; gotoxy(10,5); cout<< 1 + 2 + 3 + .....+ n; gotoxy(6,6); cout<<linea; 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(); } Problema 3. Disear un programa que permita calcular la suma acumulada de 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 #include <iostream.h> # 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 #include<iostream.h> 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 #include<iostream.h> 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 #include<iostream.h> 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<<\nHay <<b20<< billetes de 20; cout<<\nHay <<b10<< billetes de 10; cout<<\nHay <<b5<< billetes de 5; cout<<\nHay <<b1<< billetes de 1; 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 #include<iostream.h> 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
} 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);
if (n>0) { gotoxy(42,i);cout<<nmero par positivo; sumanpp+=n; npp++; } else { gotoxy(42,i);cout<<nmero par negativo; sumanpn+=n; npn++; }
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:
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
for(inicializar;<condicin>; contador) { <instrucciones>; }
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 #include<iostream.h> # 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; gotoxy(5,11);cout<<linea; 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 #include<iostream.h> 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 #include<iostream.h> # 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(7,5); cout<<linea; 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<iostream.h> #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<< ; cout<<MORE = <<1<<o<<r<<e<<\n; 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<< ; cout<<MORE = <<1<<o<<r<<e<<\n; a=a+1; }break; } else{ if(e+o+1==10+n){ if(s+1+1==10+o){ cout<<SEND = <<9<<e<<n<<d<< ; cout<<MORE = <<1<<o<<r<<e<<\n; 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
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<< ; cout<<MORE = <<1<<o<<r<<e<<\n; 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<< ; cout<<MORE = <<1<<o<<r<<e<<\n; a=a+1; }break; } else{ if(e+o+1==10+n){ if(s+1+1==10+o){ cout<<SEND = <<9<<e<<n<<d<< ; cout<<MORE = <<1<<o<<r<<e<<\n; 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 #include<iostream.h> 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(); } Problema 7. Disear un programa 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 #include <iostream.h> 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 #include<iostream.h> # define linea ------------------------------------------- main() {float principal=1000.0,interes =0.1,cantdep; gotoxy(20,3);cout<< CUENTA BANCARIA; gotoxy(15,5);cout<< ANNOS CANTIDAD; gotoxy(10,6);cout<<linea; 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 #include <iostream.h> 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 #include <iostream.h> 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 #include <iostream.h> 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; } } while (!correcto); 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; } } while (!correcto);
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. #include<iostream.h> 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; case 1:num1=num1%100; 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; case 5:num9=num9%10000; if(num9==0) cout<<Ochenta ; else cout<<Ochentay ; break; case 4: num5=num5/10000; num5=num5%10; num6=num6/10000; if (num5==0 || num5!=1||num6==0){ cout<<Ocho Mil ; } break; case 3: cout<<Ochocientos ;break; case 2: num8=num8%10; if(num8==0) cout<<Ochenta ; else cout<<Ochentay ; break; case 1: num1=num1%100; 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; case 5:num9=num9%10000; if(num9==0) cout<<Setenta ; else cout<<Setentay ; break; case 4: num5=num5/10000; num5=num5%10; num6=num6/10000; if (num5==0 || num5!=1||num6==0){ cout<<Siete Mil ;}break; case 3: cout<<Setecientos ;break; case 2: num8=num8%10; if(num8==0) cout<<Setenta ; else cout<<Setentay ; break; case 1: num1=num1%100; 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; case 5:num9=num9%10000; if(num9==0) cout<<Sesenta ; else cout<<Sesentay ; break; case 4: num5=num5/10000; num5=num5%10; num6=num6/10000; if (num5==0 || num5!=1||num6==0){ cout<<Seis Mil ;}break; case 3: cout<<Seiscientos ;break; case 2: num8=num8%10; if(num8==0) cout<<Sesenta ; else cout<<Sesentay ; break; case 1:num1=num1%100; 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; case 5:num9=num9%10000; if(num9==0) cout<<Cincuenta ; else cout<<Cincuentay ; break; case 4: num5=num5/10000; num5=num5%10; num6=num6/10000; if (num5==0 || num5!=1||num6==0){ cout<<Cinco Mil ;}break; case 3: cout<<Quinientos ;break; case 2: num8=num8%10; if (num8==0) cout<<Cincuenta ; else cout<<Cincuentay ; break; case 1: num1=num1%100;
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; case 5:num9=num9%10000; if(num9==0) cout<<Cuarenta ; else cout<<cuarentay ; break; case 4: num5=num5/10000; num5=num5%10; num6=num6/10000; if (num5==0 || num5!=1||num6==0){ cout<<Cuatro Mil ;}break; case 3: cout<<Cuatrocientos ;break; case 2: num8=num8%10; if(num8==0) cout<<Cuarenta ; else cout<<cuarentay ; break; case 1:num1=num1%100; 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; case 5:num9=num9%10000; if(num9==0)cout<<Treinta ; else cout<<Treintay ; break; case 4: num5=num5/10000; num5=num5%10; num6=num6/10000; if (num5==0 || num5!=1||num6==0){ cout<<Tres Mil ;}break; case 3: cout<<Trecientos ;break; case 2: num8=num8%10; if(num8==0)cout<<Treinta ; else cout<<Treintay ; break; case 1:num1=num1%100; 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; case 5:num9=num9%10000; if (num9==0) cout<<Veinte ; else cout<<Veinty ; break; case 4: num5=num5/10000; num5=num5%10; num6=num6/10000; if (num5==0 || num5!=1||num6==0){ cout<<Dos Mil ;}break; case 3: cout<<Doscientos ;break; case 2: num8=num8%10; if(num8==0) cout<<Veinte ; else cout<<Veinty ; break; case 1: num1=num1%100; 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; case 5: num4=num4/1000; 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; case 4: num5=num5/10000; num5=num5%10; num6=num6/10000; if (num5==0 || num5!=1||num6==0){ cout<<Un Mil ;}break; case 3: num7=num7%100;
65
if(num7==0)cout<<Cien ; else cout<<Ciento ; break; case 2: num2=num1%10; 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; case 1:num1=num1%100; 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; case 2: num2=num1%10; 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 #include<iostream.h> 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 #include<iostream.h> 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
Problema 7. Disear un programa que permita calcular la suma acumulada de 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 #include <iostream.h> # 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 #include<iostream.h> 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 #include<iostream.h> void main(){ int t,tt,ni,i; float n,max; char h[100]; textcolor(11) ; gotoxy(10,20) ;cout<<; gotoxy(10,4) ;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
Pc1 12 10 05 Pc2 10 8 18 Pc3 14 12 12 Pc4 14 12 18 Pc5 08 05 13
U V W
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 #include <iostream.h> 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; gotoxy(7,8);cout<<linea; getche(); } else { clrscr(); gotoxy(7,1);cout<<linea; 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(7,4);cout<<linea; 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(7,13);cout<<linea; 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; gotoxy(10,3);cout<<Ingrese 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; gotoxy(7,8);cout<<linea; getche(); } else { clrscr(); gotoxy(7,1);cout<<linea; 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(5,2); cout<<linea; gotoxy(10,3);cout<< pc1=;cin>>p1; gotoxy(10,4);cout<< pc2=;cin>>p2; gotoxy(10,5);cout<< pc3=;cin>>p3; gotoxy(10,6);cout<< pc4=;cin>>p4; 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(5,3);cout<<linea; gotoxy(5,6);cout<<linea; 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...; gotoxy(5,9); cout<<linea; }
84
} else { clrscr(); gotoxy(20,12); cout<<Sr. sus datos tienen error !!! ; gotoxy(12,13); cout<<linea; } 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(10,7);cout<< [S] Salir; gotoxy(5,9);cout<< Elija opcin = ;cin>>opcp;
85
switch(opcp) { case o:case O:clrscr(); gotoxy(10,2);cout<< OPERACIONES ARITMTICAS; gotoxy(5,3);cout<<linea; 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,9);cout<<linea; 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(7,3);cout<<linea; 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 gotoxy(7,6);cout<<linea;
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(7,3);cout<<linea; 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(6,3);cout<<linea; gotoxy(6,8);cout<<linea; 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 #include<iostream.h> #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(12,10);cout<<linea; 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++; de
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();}
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 #include<iostream.h> 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)); do{gotoxy(3,5);cout<<Ingrese p2 = ;clreol();cin>>p2; }while((p2<0)||(p2>20)); do{gotoxy(3,6);cout<<Ingrese p3 = ;clreol();cin>>p3; }while((p3<0)||(p3>20)); do{gotoxy(3,7);cout<<Ingrese p4 = ;clreol();cin>>p4; }while((p4<0)||(p4>20)); nmin=p1; if(nmin>p2){nmin=p2;} if(nmin>p3){nmin=p3;} if(nmin>p4){nmin=p4;} 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 # include<iostream.h> 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(3,14);cout<<linea; 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 # include<iostream.h> // 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(5,12);cout<<linea; 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 #include <iostream.h> // 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; textcolor(22);gotoxy( 20,10);cprintf( PC3 = );cin>>pc3; textcolor(22);gotoxy( 20,11);cprintf( PC4 = );cin>>pc4; 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 #include <iostream.h> 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 Edades Posicin Ana 30 1 Lus 15 2 Pedro 28 3
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 ........ 11
[ 18 ] [ 19 ] ndice 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 #include <iostream.h> #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 ; gotoxy(2,3);cout<<linea; 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(); } Problema 3. Disear un programa 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. #include<iostream.h> # 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 #include <iostream.h> 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 #include <iostream.h> #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 ; gotoxy(2,3);cout<<linea; 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); } Problema 11. Disear un programa que permita leer datos de tipo entero y 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 #include<iostream.h> # 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(); } Problema 12. Disear un programa que permita leer datos de tipo entero y 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 #include<iostream.h> # 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:; gotoxy(2,3); cout<<linea; 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; gotoxy(2,8); cout<<linea<<endl; for(i=1; i<=p;i++)
137
{gotoxy(9*i,9); cout<<B[<<i<<]=<<b[i]<<,; } gotoxy(2,10); cout<<linea<<endl; 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]<<, ; } gotoxy(2,15); cout<<linea<<endl; 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 #include<iostream.h> 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 #include <iostream.h> 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 : ; gotoxy(32,9);cout<<linea; 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,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<< 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++) {gotoxy(2+i,5);cout<<; gotoxy(2+i,23);cout<<; } 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(3,12);cout<<linea; 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 #include<iostream.h> # 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 #include <iostream.h> #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 */ #include<iostream.h> 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<iostream.h> #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 #include<iostream.h> 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 Solucin //mat_ord_fil.cpp #include <iostream.h> 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; for(int j=0;j<n;j++) 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; for(int j=0;j<n;j++) 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; for(int j=0;j<n;j++) 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; for(int i=0;i<m;i++) 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
Problema 11. Disear un programa que permita ingresar el nmero de filas y 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. Solucin //mat_ord_fil.cpp #include<iostream.h> 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 #include<iostream.h> 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 #include <iostream.h> 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++) {gotoxy(2+i,4);cout<<; gotoxy(2+i,20);cout<<; } 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,10);cout<<linea; gotoxy(6,11);cout<<\t\t\tCuadro de Meritos; gotoxy(6,12);cout<<linea; gotoxy(6,13);cout<< #<< Codigo\t\t Notas\t\t Promedio; gotoxy(6,14);cout<<linea; gotoxy(20,15);cout<<1 2 3 4 5 6 7 8 ; gotoxy(6,16);cout<<linea; 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
} 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 como se ilustra en la siguiente figura: 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.
x +=6; } y += 1; x = 10; cout<<\n;
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 for(i=1;i<=cant_tipo;i++) {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; for(i=1;i<=cant_tipo;i++) 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...; for(i=1;i<=cant_tipo;i++) 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 #include<iostream.h> 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 ........ 11
[ 18 ] [ 19 ] ndice 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.
Problema 5. Disear un programa 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. Problema 6. Disear un programa 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 como se ilustra en la siguiente figura:
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:
Problema 10. Disear un programa que permita ingresar un nmero entero 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 en forma ascendente. 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 #include<iostream.h> 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 #include<iostream.h> 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 #include <iostream.h> 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 #include <iostream.h> 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 #include<iostream.h> 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 #include<iostream.h> 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 #include<iostream.h> 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). Solucin //cadena4.cpp #include<iostream.h> 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. Solucin //cadena50.cpp 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. Solucin //cadena6.cpp #include<iostream.h> 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. Solucin //cadena8.cpp 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 #include <iostream.h> 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 #include<iostream.h> 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 # include<iostream.h> 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 #include <iostream.h> 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 * Solucin //cadena9.cpp #include<iostream.h> 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 #include <iostream.h> 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 #include <iostream.h> 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 #include <iostream.h> 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 #include <iostream.h> 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 #include<iostream.h> 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); ptr=strtok(aux,espacio); while (ptr) { cout<<strrev(ptr)<< ; ptr=strtok(NULL,espacio); } cout<<endl; cout<<endl<<Palabras de atras hacia delante<<endl; strcpy(aux,strrev(frase)); ptr=strtok(aux,espacio); while (ptr) { cout<<strrev(ptr)<< ; ptr=strtok(NULL,espacio); } 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 # include<iostream.h> ................................ // 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. Problema 1. Disear un programa 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
#include <iostream.h> 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 #include <iostream.h> 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 #include<iostream.h> 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 #include <iostream.h> 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 #include <iostream.h> 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();} Problema 7. Disear un programa que permita elevar a la potencia un nmero ingresado como base. Mostrar el reporte respectivo. Solucin // funcio_inv1.cpp #include<iostream.h> 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 #include<iostream.h> # 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 #include <iostream.h>
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 #include<iostream.h> 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 #include <iostream.h> 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();} Problema 14. Disear un programa que permita ingresar el nmero de filas y 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 #include<iostream.h> #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 #include <iostream.h> 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 #include<iostream.h> # 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(4,3);cout<<linea; 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,3);cout<<linea; 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 #include <iostream.h> 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 # include<iostream.h> 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 #include <iostream.h> 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();} Problema 3. Disear un programa que permita ingresar un nmero entero 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 #include <iostream.h> 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 #include <iostream.h> 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 #include <iostream.h> 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) { case 0 : resp = 0; break; case 1 : resp = 1; break; case 2 : resp = 2; break; case 3 : resp = 3; break; case 4 : resp = 4; break; case 5 : resp = 5; break; case 6 : resp = 6; break; case 7 : resp = 7; break; } break; case 16 :switch (numero) { case 0 : resp = 0; break; case 1 : resp = 1; break; case 2 : resp = 2; break; case 3 : resp = 3; break; case 4 : resp = 4; break; case 5 : resp = 5; break; case 6 : resp = 6; break; case 7 : resp = 7; break;
250
case 8 : resp = 8; break; case 9 : resp = 9; break; 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 #include<iostream.h> #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(i=0;i<numero_vendedor;i++) 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(i=0;i<numero_vendedor;i++) 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
#include<iostream.h> # 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 #include<iostream.h> # 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
Problema 1. Disear un programa que permita ingresar un nmero entero 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 #include <iostream.h> # 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(2,3);cout<<linea; 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 #include <iostream.h> 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 # include<iostream.h> 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 # include<iostream.h> 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 ; gotoxy(5,4);cout<<Ingrese base :;cin>>x; gotoxy(5,5); cout<<Ingresepotencia :;cin>>m; for(int i=0;i<m;i++) {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 #include <fstream.h> 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 #include <fstream.h> 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 #include<iostream.h> 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 #include<iostream.h> 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 #include<iostream.h> 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. Problema 2. Disear un programa 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
Problema 3. Disear un programa 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
89760K
nombre
Ana
apellidos
Salas
edad
30
sueldo
1209,4
sexo
F
Tipos de datos: cadena(har)
Entero(int)
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 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 Operador punto
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 # include<iostream.h> # 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; }while(dates[i].p2<0 || dates[i].p2>20); do{gotoxy(5,11);clreol(); cout<< Practica 3 : ;cin>>dates[i].p3; }while(dates[i].p3<0 || dates[i].p3>20); 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; gotoxy(4,10);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();} 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 #include <iostream.h> 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 #include<iostream.h> 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); gotoxy(10,20) ;cout<<; gotoxy(10,4) ;cout<<; //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);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(34,17);cout<< Esta usando el ARCHIVO :<<arch; 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,18);cout<<_; gotoxy(k+10,16);cout<<_; gotoxy(k+10,20);cout<<_; gotoxy(k+10,20+i);cout<<_;} 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,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(34,17);cout<< Esta usando el ARCHIVO :<<arch; gotoxy(14,19);cout<<Codigo; 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; }// marcos Horizontales. for(k=1;k<=59;k++) {gotoxy(k+10,18);cout<<_; gotoxy(k+10,16);cout<<_; gotoxy(k+10,20);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(62,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(50,19);cout<<Nombres; gotoxy(65,19);cout<<Edadgotoxy(14,20+i);cout<<lista[i].cod; gotoxy(28,20+i);cout<<lista[i].apell; 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,18);cout<<_; gotoxy(k+10,16);cout<<_; gotoxy(k+10,20);cout<<_; gotoxy(k+10,20+i);cout<<_; } for(l=1;l<=(i+5);l++) { gotoxy(11,15+l);cout<<|; if(l<=(i+3)) { gotoxy(25,17+l);cout<<|; gotoxy(47,17+l);cout<<|; gotoxy(62,17+l);cout<<|; } 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(14,19);cout<<Cdigo; gotoxy(28,19);cout<<Apellidos; 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,18);cout<<_; gotoxy(k+10,16);cout<<_; gotoxy(k+10,20);cout<<_; 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(62,17+l);cout<<|; } gotoxy(70,15+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,19);cout<<Cdigo; gotoxy(28,19);cout<<Apellidos; 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,18);cout<<_; gotoxy(k+10,16);cout<<_; gotoxy(k+10,20);cout<<_; gotoxy(k+10,20+i);cout<<_;} //Verticales. for(l=1;l<=(i+5);l++) { gotoxy(11,15+l);cout<<|; if(l<=(i+3)) { gotoxy(25,17+l);cout<<|; gotoxy(47,17+l);cout<<|; gotoxy(62,17+l);cout<<|; } 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) ; gotoxy(10,20) ;cout<<; //esquinas gotoxy(10,4) ;cout<<; //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; gotoxy(11,9); cout<<linea; 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; } if(cont2!=0) { prom2=suma2/cont2; } else { prom2=0; } if(cont3!=0) { prom3=suma3/cont3; } else { prom3=0; } gotoxy(16,7); cout<< PROMEDIO DE EDADES POR FACULTADES ; gotoxy(14,8); cout<<linea; 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) {if(alumno[j].edad>mayor) { 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) {if(alumno[j].edad>mayor) { 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 #include <fstream.h> # 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(6,3);cout<<linea; 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 : cout<<\t\t<<data[minvend].vendedor<<\t\tTIPO B;break; case 2 : cout<<\t\t<<data[minvend].vendedor<<\t\tTIPO
297
C;break; case 3 : cout<<\t\t<<data[minvend].vendedor<<\t\tTIPO 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 Problema 3. Disear un programa que permita ingresar n alumnos (n definido 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 C (casa) D (departamento) Descuento 18% 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. Lista 2(): Procedimiento (opcin 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. Lista 3(): Procedimiento (opcin 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 Problema 13. Disear un programa que permita ingresar n alumnos (n definido 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) r w Modo de apertura (archivos binarios) rb wb
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.
a r+ w+ a+
ab rb+ wb+ ab+
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); while(!feof(falumno)) { printf(\n\r %12d \t%15s %-5s,f1.cod_al, f1.apell_al, f1.nomb_al); fread(&f1, sizeof(f1), 1, falumno); } 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; fread(&f1, sizeof(f1), 1, falumno); while(!feof(falumno)) { 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); fread(&f1, sizeof(f1), 1, falumno); while(!feof(falumno)) { 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 Ciclos 2005-1 2005-2 2005-3 200 Ciclos 2005-1 2005-2 2005-3 Promedio 12.3 11.4 15.8 Promedio 11 11.4 12 Ciclos 2006-1 2006-2 2006-3 Ciclos 2006-1 2006-2 2006-3 Promedio 5.5 12.5 6.7 Promedio 4.4 12.2 11.3 Ciclos 2007-1 2007-2 2007-3 Ciclos 2007-1 2007-2 2007-3 Promedio 10.2 3.4 11.2 Promedio 12.4 17.5 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.
variable valor X
puntero
guarda direccin
8.2 CREACIN DE UN PUNTERO

Un puntero se declara de la siguiente manera:
*P
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.
*P
&Q
328
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 Reserva de memoria dinmica Liberacin de memoria reservada int* a = new int delete a; Array de elementos individuales int* a = new int [n]; 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; gotoxy(5,7);cout<<linea; 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; gotoxy(5,11);cout<<linea; 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; } gotoxy(5,15);cout<<linea; 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 aux=new nodo;// su espacio de memoria aux=p; //hacer copia de p en aux 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 aux=new nodo;// su espacio de memoria aux=p; //hacer copia de p en aux gotoxy(13,15);cout<<Ingrese Nota a Buscar = ;cin>>notas; while(aux!=NULL)//recorre la lista {if(aux->nota==notas) { nn++; }
339
aux=aux->sgte;// pasar al nuevo nodo } //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 en forma ascendente. - 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 aux=new nodo;// su espacio de memoria aux=p; //hacer copia de p en aux 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; } aux=aux->sgte;// pasar al nuevo nodo } //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 : ; gotoxy (20+8*i,11); cout<< => << p->nota; 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 : ; gotoxy (20+8*i,11); cout<< => << p->nota; 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++; fread(&f1,sizeof(f1),1,ftrabajador); } 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<< _____________________________________________________________; fread(&f1,sizeof(f1),1,ftrabajador); while(!feof(ftrabajador)&&i<tot_reg) { i++; fread(&f1,sizeof(f1),1,ftrabajador); 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 Ciclos 2005-1 2005-2 2005-3 200 Ciclos 2005-1 2005-2 2005-3 Promedio 12.3 11.4 15.8 Promedio 11 11.4 12 Ciclos 2006-1 2006-2 2006-3 Ciclos 2006-1 2006-2 2006-3 Promedio 5.5 12.5 6.7 Promedio 4.4 12.2 11.3 Ciclos 2007-1 2007-2 2007-3 Ciclos 2007-1 2007-2 2007-3 Promedio 10.2 3.4 11.2 Promedio 12.4 17.5 11.5
Problema 3. Disear un programa 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:
LISTADO GENERAL DE NOTAS -----------------------------------------------------------------Cdigo Notas Condicin ------------------------------------------------------------------cod01 17 Aprobado cod02 08 Desaprobado cod03 14 Aprobado . .
350
Lenguaje de programacin estructurada y sus aplicaciones en Borland C++ 5.0.2 . 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 Categora 2: 23 soles Categora 3: 27 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 CODDOC 5C NOMDOC 30C CATEGORIA int. DIARIO CODDOC CODCUR HORAS FECHA 5C 5C DOUBLE 10C CURSO CODCUR5C NOMCUR 15C
D001 D002 D003
Luis Vera Ana Garca Juan Lopez
1 3 2
Luego mostrar resultados de acuerdo al siguiente formulario:
D001 D001 D002 D002 D003 D003
C001 C004 C003 C001 C005 C003
4 5 3 4 3 2
11/10/10 15/10/10 17/11/10 21/11/10 23/11/10 25/11/10
C001 C002 C003 C004
Matemtica I Anlisis II Fisca I Qumica
351
Teodoro Luciano Crdova Neri 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 xxxxxxxxxxx => 999,999. => 999.999.99 Total horas Total pago
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 100 200 300 400 Apellidos Salas Sols Cspedes Carrasco Nombres Juan Pedro Mara Noem Cdigo 100 200 300 400 100 CURSOS.DAT Cod._cur. 124 760 195 511 Cod._cur. 124 760 124 124 760 N1 14 13 11 10 08 N2 11 14 11 10 10 Descripcin Matemticas Compiladores Numricos Costos N3 10 05 14 13 14 pp ? rea acad. Bsicas Sistemas Bsicas Gestin
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 Universidad Nacional de Ingeniera
361
362

3cera Edi 3 Lenguaje de Programacion Borland

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

3cera Edi 3 Lenguaje de Programacion Borland

Hochgeladen von

Copyright:

Verfügbare Formate

Lenguaje de programacin estructurada y sus aplicaciones en Borland C++ 5.0.

Teodoro Luciano Crdova Neri

Lenguaje de programacin estructurada

Universidad Nacional de Ingeniera

Teodoro Luciano Crdova Neri

Lenguaje de programacin estructurada y sus aplicaciones en Borland C++ 5.0.2

Dr. Ing. Aurelio Padilla Ros Rector

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

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

Teodoro Luciano Crdova Neri

Lenguaje de programacin estructurada y sus aplicaciones en Borland C++ 5.0.2

1.2 Introduccin a la programacin 1.2.1 Definiciones

Teodoro Luciano Crdova Neri

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

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

1.13 Tipos de datos

1.14 Carcter (char)

Teodoro Luciano Crdova Neri

1.15 Declaracin de constantes simblicas

Estructura bsica de un programa // directivas o libreras # include<iostream.h>

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

2.1 Estructuras secuenciales

Sintaxis <instruccin_1>; < instruccin _2>; ........................... < instruccin _ n>;

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

2.2 Estructuras selectivas condicionales

2.2.1 Estructura selectiva simple

Lenguaje de programacin estructurada y sus aplicaciones en Borland C++ 5.0.2

Teodoro Luciano Crdova Neri

2.2.2 Estructura selectiva compuesta: sentencia if - else

Lenguaje de programacin estructurada y sus aplicaciones en Borland C++ 5.0.2

2.2.3. Estructura condicional con anidamiento

Teodoro Luciano Crdova Neri

Lenguaje de programacin estructurada y sus aplicaciones en Borland C++ 5.0.2

2.3 Estructuras mltiples

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