3cera Edi 3 Lenguaje de Programacion Borland

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

I

Universidad Nacional de IngenieríaEditorial Universitaria

Teodoro Luciano Córdova Neri

Lenguaje de programación estructuraday sus aplicaciones en Borland C++ 5.02


II

Rector Dr. Ing. Aurelio Padilla RíosPrimer Vicerrector Geol. José S. Martínez TalledoSegundo Vicerrector Msc. Ing. Walter Zaldívar Álvarez

Primera edición, mayo de 2012

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2Impreso en el Perú / Printed in Peru

© Teodoro Luciano Córdova Neri Derechos reservados

© Derechos de edición

Universidad Nacional de IngenieríaEditorial Universitaria

Av. Túpac Amaru 210, Rímac – LimaPabellón Central / SótanoTelfs. 4814196 / 4811070 anexo 215Correo-e: [email protected] EDUNI: Prof. Álvaro Montaño FreireCoordinador Editorial: Nilton Zelada Minaya

Impreso en la Imprenta de la Editorial Universitaria de la Universidad Nacional de Ingeniería

ISBN 978-612-4072-23-9

Hecho el Depósito Legal en la Biblioteca Nacional del Perú Nº 2011-13203

Prohibida la reproducción de este libro por cualquier medio, total o parcialmente, sin permiso expreso del autor.


III

Palabras liminares

Me complace felicitar a los docentes de nuestra Universidad ganadores del II Concurso para la Publicación de Libros de Texto convocado por el Rectorado y realizado en cada una de las Facultades. Una de las políticas medulares del Rectorado es la permanente mejora en la calidad académica, y en ese sentido nos interesa que cada docente tenga la oportunidad de convertir su labor cotidiana de enseñanza en textos para uso de los estudiantes universitarios de todo el país.

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 diálogo 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 publicación de textos académicos es una de las obligaciones de toda universidad y uno de los índices que se toma en cuenta para la evaluación de la calidad académica. Por ende, seguiremos apoyando la publicación de libros y revistas a través de nuestra Editorial Universitaria, cuya meta es formar parte del liderazgo peruano en la industria editorial dedicada a ingeniería, ciencia y arquitectura.

Es responsabilidad de la Universidad Nacional de Ingeniería aportar al Perú un liderazgo de base tecnológica que trabaje en estrecha asociación con las autoridades gubernamentales, los dirigentes empresariales y la sociedad civil en su conjunto, lo cual requiere de una política editorial y de publicaciones que estamos impulsando.

Dr. Ing. Aurelio Padilla RíosRector


IV


V

A mis padres Luis y Gliceria, gracias por todo.

A María, mi compañera de siempre.

A mis tres hijos, frutos del amor y compromiso con la vida...


VI


VII

Reconocimiento y gratitud a todos mis maestros por su importante apoyo Profesional.Y en especial al Decano FIIS Mg. Luis Acuña P. y al Ing. Carlos Chafloque E. por su apoyo


VIII


IX

Presentación ...............................................................................................................XIII

Introducción ................................................................................................................XV

Capítulo IGeneralidades ............................................................................................................... 1

1.1 Introducción......................................................................................................... .11.2 Introducción a la programación ........................................................................ 11.3 Características de un algoritmo de computador ............................................. 21.4 Lenguajes de programación ............................................................................... 21.5 Lenguajes de máquina ........................................................................................ 31.6 Lenguaje de bajo nivel ......................................................................................... 31.7 Lenguaje de alto nivel ......................................................................................... 31.8 Programa ejecutable ............................................................................................ 31.9 Compilador ........................................................................................................... 31.10 Palabras reservadas ............................................................................................. 31.11 Identificadores ...................................................................................................... 41.12 Comentarios .......................................................................................................... 41.13 Tipos de datos ...................................................................................................... 51.14 Carácter (char) ...................................................................................................... 51.15 Declaración de constantes simbólicas ............................................................... 6

Capítulo IIEstructuras de control ................................................................................................ 11

2.1 Estructuras secuenciales .................................................................................. 112.2 Estructuras selectivas condicionales ............................................................... 162.2.1 Estructura selectiva simple .............................................................................. .162.2.2 Estructura selectiva compuesta........................................................................ 182.2.3 Estructura condicional con anidamiento ........................................................ 19 2.3 Estructuras múltiples ........................................................................................ 21

Índice


X

2.4 Estructuras repetitivas....................................................................................... 292.4.1 Estructura repetitiva con pretest de prueba .................................................. 292.4.2 Estructura repetitiva con postest de prueba ................................................. 372.4.3 Estructura repetitiva cuando se conoce el número de iteraciones ............ 442.4.4 Estructuras múltiples – módulo de operaciones aritméticas....................... 85

Capítulo IIIEstructuras de datos arrays ..................................................................................... 123

3.1 Introducción a las estructuras de datos ........................................................ 1243.2 Arraysunidimensionales: los vectores .......................................................... 1243.3 Operaciones con vectores: métodos de ordenación, inserción, eliminación, búsquedas, crear sublistas, etc. Aplicaciones ........................ 1263.4 Arrays bidimensionales .................................................................................. 149

Capítulo IVLas cadenas de caracteres ........................................................................................ 199

4.1 Introducción...................................................................................................... 1994.2 Punteros a cadenas .......................................................................................... 2004.3 Funciones para el tratamiento de cadenas:strlen(), strcat() ....................... 2024.4 Copia de cadenas:stpcpy(), strcpy(), strncpy() ............................................ 2044.5 Funciones para buscar un carácter en una cadena:strchr(), strrchr() ....... 2064.6 Función para reconocimiento de una porción de cadena: strspn(), strcspn(), strpbrk() y strtok() ......................................................................... 2084.7 Funciones para la comparación de cadenas: strcmp(), strnicmp(), stricmp() ............................................................................................................ 2104.8 Transformación de cadenas: strset(), strnset() ............................................. 2134.9 Funciones para invertir cadenas:strxfrm(), strrev() .................................... 2144.10 Conversión a mayúsculas y minúsculas: strupr(),strlwr() ......................... 2154.11 Inclusión de una cadena en otra cadena ....................................................... 215

Capítulo VProgramación modular ............................................................................................ 221

5.1 Introducción...................................................................................................... 2215.2 Funciones definidas por el usuario ............................................................... 2225.3 Declaración y definición de funciones .......................................................... 2245.4 Lista de parámetros y sus tipos de datos ..................................................... 2255.5 Variables locales y globales ............................................................................ 2265.6 Parámetros por defecto, valor ........................................................................ 2275.7 Funciones que llaman a funciones ................................................................ 2465.8 Funciones recursivas ....................................................................................... 259


XI

Capítulo VIRegistros .................................................................................................................... 273

6.1 Introducción. Definiciones ............................................................................. 2736.2 Definición y declaración de una estructura ................................................. 2756.3 Variables registro (instancias) ........................................................................ 2756.4 Anidamiento de registros ............................................................................... 2766.5 Acceso a los elementos de una estructura .................................................... 2766.6 Aplicaciones ...................................................................................................... 277

Capítulo VIIArchivos (File)…….………………….……………..............……........................... 307

7.1 Introducción...................................................................................................... 3087.2 Características de los archivos ....................................................................... 3087.3 Archivos (file) ................................................................................................... 3087.4 Apertura de archivos ....................................................................................... 3087.5 Clasificación de archivos por tipo de contenido: texto, binarios .............. 3097.5.1 Archivos de texto ............................................................................................. 3097.5.2 Archivos binarios ............................................................................................. 3097.6 Clasificación de archivos por tipo de acceso ................................................ 3107.6.1 Archivos secuenciales ...................................................................................... 3107.6.2 Archivos directos: acceso aleatorio .............................................................. 3107.7 Direcciones lógicas y direcciones físicas ....................................................... 3107.8 Cálculo de direcciones físicas ......................................................................... 3117.9 Funciones para el manejo de archivos .......................................................... 3117.10 Declaración de la variable lógica (“alias”) del archivo ............................... 3117.11 Función para procesar archivos ..................................................................... 3117.12 Validar la apertura de un archivo .................................................................. 3127.13 Cierre de archivos usando fclose() y fcloseall() ........................................... 3127.14 Escritura de registros usando fwrite() .......................................................... 3137.15 Vaciando los buffers usando fflush () .......................................................... 3137.16 Lectura de registros usando fread () ............................................................. 3137.17 Función para acceso de archivo ..................................................................... 3137.18 Conocer posición del apuntador del archivo:función ftell() ..................... 3147.19 Posicionando apuntador al inicio del archivo: rewind() ............................ 3147.20 Detectando el final del archivo con feof() ..................................................... 3147.21 Cambio de nombre de archivo rename() ...................................................... 3147.22 Eliminando archivos con la función remove() ............................................. 315


XII

Capítulo VIIIProgramación dinámica .......................................................................................... 327

8.1 Programación dinámica:punteros ................................................................. 3278.2 Creación de un puntero .................................................................................. 3288.3 Operadores ....................................................................................................... 3288.4 Inicialización de un puntero ........................................................................... 3298.5 Lista .................................................................................................................... 3328.6 Pila ...................................................................................................................... 3328.7 Punteros nivel RAM ........................................................................................ 3368.8 Punteros y archivos ........................................................................................ 3468.9 Compendio de problemas .............................................................................. 349

Bibliografía ................................................................................................................. 357

Índice temático ……………………………………………………...........…..…… 359


XIII

En el milenio pasado, como en el actual, se exige constantemente a la universidad elevar su calidad académica, especialmente la formación profesional que está relacionada directamente con la formación 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 enseñanza - aprendizaje en sus asignaturas correspondientes. Dentro de este contexto, felicito a las autoridades de la Universidad y al ente normativo de promocionar actividades estratégicas en el sector académico, tales como la publicación de textos universitarios, actividad estratégica que beneficia a la universidad como al docente, debido que en conjunto se está cumpliendo con el perfil de la universidad: Ciencia Tecnología y Sociedad (CTS).

Respecto al docente, estamos en la responsabilidad de proporcionar un conjunto de enfoques didácticos relacionados con nuestro rol universitario, donde el proceso de enseñanza - aprendizaje, métodos, técnicas y evaluación, engloben las TICS buscando mejoras continuas. En este sentido, como docente de la asignatura “Lenguaje de Programación 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 diseñado con base en la experiencia de más de 20 años comprometido con el concepto de programación en lenguajes estructurados.

Esperando que la lectura, análisis y reflexión de la antología que presento sirva para acrecentar el espíritu de renovación institucional, de innovación profesional continua y que obviamente trascenderá al mejor aprendizaje y alta calidad académica de nuestros alumnos, cuando además de la enseñanza presencial, también se dispongan de herramientas didácticas: libros, clases on line, etc.

El autor

Presentación


XIV


XV

El comité para el estándar ANSI C se formó en el año 1983 con el objetivo de crear un lenguaje uniforme a partir del Lenguaje de Programación 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 extensión 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 difusión 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 versátil, 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. Además, ha eliminado muchas de las dificultades y limitaciones que tiene C original. La evolución de C++ ha continuado con la aparición de Java, un lenguaje creado simplificando algunas partes de C++ y añadiendo otras, que se utiliza en la presente década para realizar aplicaciones en internet.

El C++ se presenta como:

1. Lenguaje de programación procedural (orientado a algoritmos) y por cumplir con las normas de poseer las tres estructuras de control (secuenciales, condicionales/múltiples 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 programación admite una filosofía completamente diferente, que exige del programador un completo cambio de mentalidad. Las características propias de la programación orientada a objetos, este tema es el más fascinante, pues C++ cambia radicalmente su pensamiento de programación.

Cabe notar que un programa fuente diseñado a nivel C++, no compila en C, pero lo contrario sí se cumple. Además de las estructuras del control, también disponen de estructuras de datos en forma legible al usuario, tales como: listas o

Introducción


XVI

vectores, tablas o matrices, etc. Asimismo, los registros (struct), uniones, archivos (FILE), programación dinámica (punteros), procesamiento de cadenas basadas fuertemente en funciones (strcmp, struppr, etc.).

El presente texto está basado en experiencias obtenidas por más de década y media, dictando asignaturas en las escuelas de Ingeniería de Sistemas, Computación e Informática de las diferentes universidad del Perú (Universidad Nacional de Ingeniería - Facultad de Ingeniería Industrial y de Sistemas), Universidad de San Martín, Universidad Antúnez de Mayolo, Universidad Tecnológica del Perú, Universidad San Martín 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


1

ObjetIvOs

- Conocer la biblioteca standard de Borland C++ 5.02.

- Dar fundamentos para el estudio de otros lenguajes de programación en general y aplicarlos para java, etc.

- Comprender la programación de ni-vel estructurada.

- Comprender las técnicas básicas para resolver problemas.

- Desarrollar programas usando las técnicas de tipo top-down (de arriba abajo)

- Usar los operadores lógicos, relacio-nales, funciones resto y parte entera.

- Usar los tipos de datos enteros, rea-les, cadenas, booleanos.

1.2 IntrOduccIón a la PrOgramacIón

1.2.1 definiciones

Computadora. Una computadora (PC) se puede definir como una máquina electrónica digital capaz de procesar información y producir datos de salida, para lo cual requiere de datos de entrada. El término digital se debe al hecho de que la información almacenada y procesada por la computadora está representada mediante códigos numéricos 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 informáticos hay una diferencia entre datos e información.

generalidades

Capítulo 1


2

Dato. Es la representación de algún hecho, concepto o entidad real.

Información. Es el resultado del procesamiento de los datos.

Observación. Para este curso no haremos distinción entre dato e información sino que hablaremos de datos de entrada y datos de salida.

Proceso de información en una computadora

Una computadora está compuesta por dos elementos fundamentales: hardware y software.

Hardware. Está constituido por la parte física 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 lógica de la computadora y está formado por el conjunto de programas que controlan el funcionamiento de la computadora.

Organización física de una computadora

El software es el conjunto de datos y programas que usa la computadora y se guardan en algún 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 información que necesite el programa: caracteres, números, imágenes, 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 características 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 máquinas 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 programación

Sirven para editar programas (instrucciones). Las instrucciones escritas en la mayoría de los lenguajes de programación no son entendibles directamente


3

por el procesador, sino que requieren de pasos intermedios de traducción e interpretación para convertir.

Estas instrucciones al lenguaje del procesador, conocido como lenguaje máquina. Podemos citar como lenguajes de programación a Pascal, borlandc++ 5.02, etc.

1.5 lenguajes de máquina

Permiten escribir instrucciones directamente entendibles por el procesador. Una instrucción máquina consiste en una secuencia de dígitos binarios (0 y 1) en la memoria principal, que le indica al procesador qué operación máquina debe realizar. Una colección de instrucciones máquina en la memoria principal se denomina programa en lenguaje máquina.

1.6 lenguajes de bajo nivel

Los lenguajes de bajo nivel representan un paso hacia la humanización de los lenguajes de programación, son más fáciles que los lenguajes máquina pero, al igual que ellos, son dependientes de la máquina. Los lenguajes de bajo nivel son lenguajes simbólicos, siendo el más 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 inglés cotidiano (o una mezcla de inglés y otro idioma) y contienen notaciones matemáticas de uso común, 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 programación para ejecutarse, pues solo basta ejecutar desde el sistema operativo (DOS).

1.9 compilador

Es una herramienta básica en el mantenimiento y mejora del sistema operativo. Por ello este producto está en constante evolución, ya que de su buen rendimiento depende en parte el del sistema.

1.10 Palabras reservadas

Llamadas también 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.


4

Ejemplos:

break do enum int typedefbool double for private whilecase 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 válido debe cumplir con lo siguiente:

Reglas

13.1. Debe estar formado solamente por letras mayúsculas (de la “A” a la “Z”), o letras minúsculas (de la “a” a la “z”) Adicionalmente puede combinarse con el carácter subrayado ( _ ).

Ejemplo : pc, prom_pc, cont, _nombre.

13.2. Usar dígitos del 0 al 9. Debe comenzar con una letra o letras (nunca con números).

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 válidos:

3pc: comienza con un númeronombre apellidos: contiene un espacio en blanco_i_y: comienza con dos subrayadosx*y: contiene un carácter no válido (*)do: es una palabra reservada

Nota: C++ es sensible al uso de las mayúsculas y minúsculas. 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 línea.


5

14.2 Por los delimitadores (/*..*/) para comentarios de una o más líneas.

Ejemplo:// comenta respecto a una linea:

/* Comenta respecto a una línea o varias líneas:

1.13 tipos de datos

En la siguiente tabla se ilustra los diferentes tipos de datos:

Tipo Tamaño Rango

Lógico bool 1 bit true o false

Enteros unsigned char 8 bits 0 .. 255

char 8 bits –128 .. 127

enum 16 bits –32 768 .. 32 767

unsigned int 16 bits 0 .. 65 535

short int 16 bits –32 768 .. 32 767

int 16 bits –32 768 .. 32 767

unsigned long 32 bits 0 .. 4 294 967 295

long 32 bits –2 147 483 648 .. 2 147 483 647

Reales float 32 bits ±3.4E–38 .. ±3.4E+38

double 64 bits ±1.7E–308 .. ±1.7E+308

long double 80 bits ±3.4E–4932 .. ±1.1E+4932

1.14 carácter (char)

Las constantes que representan a caracteres o acciones especiales. Ejemplos: ‘s’, ‘A’, ‘-’,‘|’

‘\a’ alerta (bip sonoro)‘\b’ retroceso (backspace)‘\f’ salto de página en la impresora (formfeed)‘\n’ nueva línea (newline)‘\r’ retorno de carro (carriagereturn)‘\t’ tabulación horizontal‘\v’ tabulación vertical‘\\’ barra invertida (backslash)


6

Constantes cadena (char * o char[])

Son secuencias de caracteres encerrados entre comillas:

“Lenguajes de Programacion”, “Borland C++ 5.0.2”

También se pueden incluir secuencias de escape:

“\tEstudiar, es una etapa de sabidurias \n”

1.15 declaración de constantes simbólicas

Mediante una directiva #define:

Sintaxis:

#define nombre valor

Ejemplos:# define pi 3.141# define linea “---------------------------------------------------------------“

Puede hacer que una constante tome un valor en función de otras: # define pi 3.141, # define doble_pi 2*pi

Mediante tipos enumerados:

El tipo enum es útil cuando se crean constantes simbólicas con valores enteros.

Ejemplo:enumdias = {lunes=1,martes,miercoles,jueves,viernes,sabado,domingo}

Además, se puede alterar el orden consecutivo, por ejemplo:

enum colores = {blanco,amarillo,rojo,azul,anterior=64 }

Variables.- Una variable es un identificador válido cuyo valor puede cambiar temporalmente durante la ejecución de un programa. Las variables deben ser declaradas antes de ser utilizadas.

Sintaxis:

Tipo_de_dato nombre_de_variable;

en donde tipo_de_dato es cualquier tipo válido en C++.

Ejemplosfloat prom; // prom es un datos de tipo real.

Operadores.- Tienen una gran utilidad durante la programación, considerando su prioridad de evaluación de operadores y su significado. En la siguiente gráfica, se ilustra la sintaxis y el uso respectivo.

7

Categoría Operador Significado Ejemplo

Negación ! Negación lógica (NOT)

!(n<11) //si n es menorque 11,devuelve falso (0)

ContadorIncremento ++ Preincremento o

posincrementon++ usa n y luego incrementa en 1++n // incrementa n en 1 y luego lo usa n

ContadorDisminuir -- Predecremento o

posdecremento --n// n disminuye en 1

Multiplicar * Multiplicación a * b //Multiplica a por b.

Dividir / División a/b // divide a entre b

Resto % Módulo (resto) a%b // devuelve el módulo de la división entera de a y b (que deben ser enteros)

Operadores relacionales < Menor que a Mayor que c > d

>= Mayor o igual que d >= e

Igualdad == Igualdad 5 == 3 // devuelve falso

!= Desigualdad a!=13

y && y Lógico (AND) ((5<13)&&(5>=4)) //Devuelve verdadero

O || oLógico (OR) (mivar==”hola”) || (3<5)//Devuelve verdadero

Condicional ?: Condicional abreviado

(a<b) ? a++:a-- //Si a<b, a se aumenta en 1 Sino se disminuye en 1

Asignación = Asignación x = 5 //A x se le asigna el valor entero 5 (x←5)

Expresiones: *= Asignar producto m*=3 //Equivale a m = m * 3

/= Asignar división e/=d //Equivale a e = e / d

%= Asignar módulo t%=2//Equivale a t = t % 2

+= Asignar suma g+=7 //Equivale a g = g + 7

Estructura básica de un programa

// directivas o librerías# include<iostream.h>

8

# define pi 3.14// Prototipo de funciones tipo_datonomb_ funcion (lista_argumentos); .................................................// Declaracion de variables globales inta,b,c;// Declaración y definición de funciones: Implementación

tipo_datonomb_funcion(lista__de_argumentos)

{ Declaraciones locales <Instrucciones >;return(expresión_de_tipo_dato); }

tipo_nfuncion_n(lista_de_argumentos) { <ídem caso de la funcion1>; }/

/Programa principalvoidmain() { 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 más empleado para un programa en C++ se compone básicamente por:

1. Directivas2. Declaración y definición de funciones secundarias definidas por el usuario3. Una función principal main()

Notas:

1. La función principal o main() regresa un valor 0 al sistema operativo para in-dicar que el proceso terminó exitosamente, cuando ocurre algún tipo de error regresará algún otro valor entero. Si no se requiere que main devuelva algún valor, se escribe voidmain() y se omite return0;

2. Si desea retornar un valor entero, entonces defina el tipo de dato delante de la función respectiva.

intmain() { return 0; }

9

Las demás funciones, por lo general son llamadas a ejecución dentro del ámbito de nuestra función principal y por consiguiente, ahí pueden regresar valores.

Observación:Durante el diseño de los programas solo especificaré una librería de entrada y de salida:

# include<iostream.h>

Las demás librerías el usuario definirá según su requerimiento.


10

11

estructuras de control

Capítulo II

ObjetIvOs

- Comprender la selección a través de la instrucción de condicional if (simple, compuesta y con anidamiento).

- Como definir estructuras múltiples o de selección 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, múltiples y repetitivas.

- Hacer aplicaciones que representen problemas reales, tales como validación de códigos de alumnos, empleados, DNI, código de productos, etc.

2.1 estructuras secuencIales

Son aquellas que se escriben línea a línea 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<instrucción_1>;< instrucción _2>;...........................< instrucción _ n>;

Sentencia nula: En C++ existe, además, la sentencia nula (una instrucción que no hace nada), está representada por un punto y coma (“;”).

12

Su aplicación se da a las estructuras repetitivas, cuando se quieren ignorar ciertos valores y procesar otros en función de una condición lógica.

Problema 1. Escribir un programa que calcule el perímetro y el área de un triángulo, dados como datos las longitudes de sus tres lados (suponer que siempre se cumple la desigualdad triangular).

Solución // area.cpp#include<iostream.h>#include<iomanip.h> //para setiosflagsvoid 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 = “; cin>>b; gotoxy(10,6);cout<<”c = “; cin>>c; p=(a+b+c)/2; gotoxy(10,8);cout<<”El perímetro es “<<setw(10)<<setprecision(2)<<2*p;a r e a = f l o a t ( s q r t ( p * ( p - a ) * ( p -b)*(p-c)));//moldeo de datosgotoxy(10,10);cout<<”El área es “<<setw(15)<<setprecision(4)<<area<<” metros “;gotoxy(10,14);system(“pause”);

}

Problema 2. Diseñar un programa que permita leer datos de un trabajador consistentes en: nombre, código, sueldo básico y bonificación. Considere también 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

Solución: //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();

13

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<<”Código :”;cin>>cod; gotoxy(5,7),cout<<”Sueldo Básico :”;cin>>s_basico; gotoxy(5,8),cout<<”Bonificación :”;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); //Cálculos 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<<»BÁSICO»; 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(); }

14

Problema 3. Diseñar un programa que permita leer tres números enteros y luego usando operadores relaciones con operadores lógicos, 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;

//Solución: 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 Lógicos(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=1gotoxy(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= 1gotoxy(10,8);cout<<a<<”<”<<b<<”y not “<<b<< “> “<< c <<” ==> res = “<<resp; getche();

15

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 = 0gotoxy(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. Diseñar un programa que permita ingresar un número entero positivo y compuesto por tres dígitos, luego mostrarlo en forma invertida.

Solución //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 NÚMERO <===”; gotoxy(8,5);cout<<linea; gotoxy(12,6);cout<<” Ingrese número = “;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();}

16

2.2 estructuras selectIvas cOndIcIOnales

Permiten evaluar condiciones de proposiciones, comparaciones de tipos de datos que pueden ser números, 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 condición lógica. Si esta es verdadera, la secuencia se ejecuta, si no lo es, continúa el programa con la instrucción siguiente.

Sintaxis:Cuando se ejecuta una sola sentencia dentro de la estructura if (<condición>)

{ intrucciones; }

Cuando se ejecutan varias sentencias dentro de la estructura If (<condición>) { instrucción_1; instrucción_2; ………………... Instrucción_n; }

Observaciones:a. <condicion> es la condición valor numérico o función que será evaluada como

verdadera (distinta de cero) o falsa (cero). Esta puede ser simple (un solo valor o condición) o compuesta, la cual está formada por varias condiciones simples conectadas por los operadores lógicos vistos anteriormente: && (y), || (o) y ! (negación).

b. Siempre se usa paréntesis encerrando a la expresión a evaluarse.

Problema 1. Diseñar un programa que permita leer un número n entero positivo y mayor que 9. Si la lectura es correcta entonces se debe obtener el último dígito. Si la lectura es incorrecta el programa no realiza ninguna tarea.

17

Solución // 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 número :”;cin>>n;dato=n;if(n>9) { ult_dig=dato%10;gotoxy(10,5);cout<<”Último dígito de “<< n<<” es = “<<ult_dig; }getche();}

Problema 2. Diseñar un programa que permita leer un número n entero positivo y mayor que 99. Si le lectura es correcta, entonces obtener sus dos últimos dígitos. Si la lectura es incorrecta el programa no realiza ninguna tarea.

Solución void main(){int n, dos_dig,dato; clrscr();gotoxy(10,2);cout<<”Sr. ingrese número :”;cin>>n;dato=n; if(n>99) {dos_dig=dato%100;gotoxy(10,5);cout<<” Dos Últimos dígitos de “<< n<<” es = “<<dos_dig; if(dos_dig%2==0) { gotoxy(10,7);cout<<” Y además, “<< dos_dig<<” es un número PAR “; }}getche();}

Comentario. Los resultados de los problemas 1, 2 y 3 se obtiene toda vez que la condición lógica es verdadera. Si usted ingresa números que no satisfacen la condición, el programa no envía ningún resultado.

18

2.2.2 estructura selectiva compuesta: sentencia if - else

Es aquella que realiza dos acciones distintas, ambas mutuamente excluyentes, de acuerdo al valor lógico de una expresión, es decir, se ejecuta solo una instrucción.

SintaxisCuando las instrucciones a ejecutarse son simples if (<Condición>) instrucción_1; else instrucción_2;

Si en cada instrucción existe solo una, no se usa { .. }, en otro casi si.

Problema 1. Diseñar un programa que permita leer datos de usuario por: código = 10 y clave = 12, luego, si los datos son correctos, el programa solicita que ingrese un número entero positivo, inmediatamente el programa debe enviar un reporte si el número ingresado es par, en otro caso es impar. Si los datos del usuario son incorrectos, el programa envia el mensaje “Datos incorrectos ” y finaliza.

Solución: // Sielse.cpp#include <iostream.h> void main() {int cod, clave,p; clrscr();cout<<”ingrese código :”; cin>>cod; cout<<”ingrese clave :”; cin>>clave;if((cod==10) && (clave==12)) { cout<<”Ingrese práctica:”; cin>>p; if(p%2==0); cout<<p<<”es número Par”; else cout<<p<<” es número impar”; } else cout<<” Datos incorrectos “;getche(); }

También se puede usar la expresión condicional abreviada equivalente:(expresión) instrucción1: instrucción2;

Cuando las instrucciones a ejecutarse son compuestas if (expresión) {instruccion_1; instruccion_2; .......……………………… instruccion_n; } else {instruccion_1; instruccion_2; .......………………………….. instruccion_n; } }

19

Si < expresión > es verdadera, se ejecuta el bloque <instrucciones >, en otro caso se ejecuta las <instrucciones> del bloque else.

Problema 1. Diseñar un programa que permita leer un número y luego averiguar si es capicúa.

Solución // if_capicua.cpp #include<iostream.h> void main(){int num,c,r1,d,u,inv;clrscr();gotoxy(10,4);cout<<” Ingrese Número: “;cin>>num;c=num/100; // obtiene primer dígitor1=num%100; //obtiene dos últimos dígitosd=r1/10; u=r1%10; inv=u*100+d*10+u; if (num==inv) { clrscr(); gotoxy(10,4);cout<<” El número”<<num << “ Es capicúa”; gotoxy(10,5);cout<<” su primer dígito es=”<<c; }else { clrscr(); gotoxy(10,4);cout<<”El número”<<num <<” No capicúa”; gotoxy(10,5);cout<<”Sus últimos dos dígitos 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 expresión (numérica o lógica). Si el valor que toma la expresión no figura entre los especificados, se ejecutará el bloque de instrucciones_else.(sino...).

20

Observación. Si el bloque de <instrucciones_x> está formado por varias instrucciones estas deberán agruparse con llaves { }.

Problema 1. Diseñar un programa que permita leer tres números 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

Solución //: #include <iostream.h>void main(){ int a,b,c; clrscr();gotoxy(10,1);cout<<” VERIFICANDO SUMA DE NÚMEROS”;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;}elseif (b==a+c) { gotoxy(10,6);cout<<” Se cumple que “<<b<<” = “<< a<<” + “<< c;} elseif (c==a+b) {gotoxy(10,6); cout<<” Se cumple que “<<c<<” = “<< a<<” + “<< b} elseif((a==b)&&(b==c)){ gotoxy(10,6); cout<<” Se cumple que “<<a<<”=”<<b<<”=”<< c } else { gotoxy(10,7);cout<<” No se cumple ninguna relación “; } getche(); }

Problema 2. Diseñar un programa que permita ingresar datos de un usuario por apellidos = “CORDOVA” y clave = “TCN ”, si los datos son correctos el sistema envía un mensaje de saludos y solicita que ingrese tres números enteros y luego devuelve el mayor de ellos. Si el usuario ingreso sus datos con error, el sistema envía el mensaje indicando el error respectivo.

Solución//if_mayor_tres_num.cpp# define linea “----------------------------------------”;void main()

21

{ 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),”TCN”)==0)){ gotoxy(10,6);cout<<” Saludos, Sr..”<< apell<< “ y Bienvenido “;gotoxy(10,7);cout<<” Ingrese 3 números “; 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 número es = «<<mayor; } else if((b>a)&&(b>c)) {mayor=b; gotoxy(10,13);cout<<”El mayor número es = “<<mayor; } else if((c>a)&&(c>b)) {mayor=c; gotoxy(10,13);cout<<”El mayor número es = “<<mayor; } else { gotoxy(10,13);cout<<” Los números son iguales...”; } }

else { gotoxy(10,5); cout<<” Sr. sus datos son incorrectos “;

}getche(); }

2.3 estructuras múltIPles

Es aquella en la cual el usuario puede realizar una determinada acción para cada tipo de valor que pueda tomar una expresión. Cada acción a realizarse excluye a las demás, de modo que solamente una de ellas es ejecutada.switch (expresión) { case valor1:<instrucciones_1>;

break;

22

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 demás casos.

3. La variable “selector ” no puede ser tipo: real, cadena de dígitos, cadenas.

4. Cuando se quiere realizar una misma acción para distintos valores de la expresión evaluada, se coloca una sentencia case por cada valor, sin ninguna acción y la acción común se pone al final del último valor. Por ejemplo, el segmento de código:

switch (a) { case 1:case 2:case 3: cout<<”Acción para 1, 2 y 3”; break; case 4: cout<<”Acción para 4”; break; default: cout<<”Acción para cualquier otro valor”; break; }

Problema 1. Diseñar un programa que permita disponer de tres alternativas:

- Alternativa 1: permite leer la base y el exponente para calcular la potencia de un número.

- Alternativa 2: permite leer un número n positivo y luego calcula la raíz cuadrada.

- Alternativa 3: permite ingresar un número de tres dígitos y luego este número mostrarlo en forma invertida sin usar estructuras de control repetitivas.

- Alternativa 4: permite salir del modo compilación al programa fuente.

23

Asimismo, el programa debe enviar el mensaje “Fuera de rango”, cuando el usuario digita un número que no está dentro de la lista disponible.

Solución // 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 Número”;gotoxy(15,8);cout<<” [S] Salir”;gotoxy(8,10);cout<<linea;gotoxy(15,11);cout<<” Ingrese opción: “;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 número “<< base<<” elevado a “ <<pot <<” es =”<<poten;gotoxy(4,10);cout<<linea; break;

case’R’:case ‘r’: clrscr(); gotoxy(4,2);cout<<linea; gotoxy(15,4);cout<<” Ingrese un número :”; cin>>n;

raiz=sqrt(n);gotoxy(15,5);cout<<” La raíz cuadrada de “<< n<<” es =”<<raiz;gotoxy(4,10);cout<<linea; getche();

break; case’I’:case ‘i’: clrscr(); gotoxy(10,2);cout<<”NÚMERO INVERTIDO “;

gotoxy(4,3);cout<<linea;gotoxy(15,4);cout<<” Ingrese un número = “; 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<<” Número Invertido = “<<ult_dig<<pult_dig<<parte_

entera2;gotoxy(4,8);

24

cout<<linea; getche(); }else { gotoxy(15,6); cout<<” El número no satisface condición “; } break; case’S’: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 opción correcta.. “; } getche(); }

Problema 2. Diseñar 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 opción que usted ingrese, el número de ordenadores a comprar y luego el precio por unidad y calcula el monto a pagar.Análogamente sucede para las demás opciones: para impresoras y lectoras.Si usted ingreso sus datos de validación incorrectos, el sistema envía el mensaje:“Sr. usuario, sus Datos son incorrectos, hasta pronto”;

Solución // 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;

25

char apell[10],clave[10], char opc,imp; clrscr();gotoxy(25,8);cout<<”MÓDULO DE VALIDACIÓN”;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 opción :”; 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 opción”;cin>>imp;switch(imp) { case ‘i’:case ‘I’: { clrscr();cout<<”\nOrdenadores marca IBM”; cout<<”\ningrese número 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 número 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 número de ordenadores a comprar:”;cin>>noliv; cout<<”\ningrese precio por unidad:”; cin>>poliv; montooliv=noliv*poliv; cout<<” \nUd. debe pagar :”<<montooliv; getche(); }

26

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’:// Opción de case principal :I : Impresorasclrscr(); gotoxy(15,2); cout<<”Impresoras”; gotoxy(15,4);cout<<”<L> Lasse :”; gotoxy(15,5);cout<<”<M> Matricial”; gotoxy(15,6);cout<<” Edite opción”;cin>>imp;switch(imp) { case ‘l’:case ‘L’: clrscr(); cout<<”\ningrese número 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 número 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: Impresorasbreak; case ‘l’:case ‘L’:// Opción 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 opción”;cin>>imp;switch(imp) { case ‘c’:case ‘C’: clrscr();cout<<”\ningrese número 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 número de Lectoras HP: “;cin>>nlhp; cout<<” \ningrese precio por unidad:”; cin>>plhp; montolhp=nlhp*plhp;

27

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 ifelse 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 (submenús), por ejemplo si edita “O”, entonces se obtiene el submenú correspondiente a los tipos de ordenadores:

Ahora, si usted edita la opción C, de Compac, el programa le solicita que ingrese número de ordenadores y precio por unidad, luego calcula el monto a pagar. Así puede continuar con las demás opciones correspondientes a impresoras y lectoras.

Problema 4. Diseñar 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 ......................”

Observación

28

En el siguiente programa se ilustra que usando la estructura múltiple o la estructura if con anidamiento se puede obtener el mismo resultado

Solución a) Mediante Case (..)//case_if_anidados.cppvoid main() { char mes; clrscr();gotoxy(24,1),cout<<»Meses del Año»; 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 Año»;g o t o x y ( 2 1 , 2 ) , c out<<”================”;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”; } elseif(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);

29

cout<<” El valor ingresado esta disponible......!”; }getche() }

2.4 estructuras rePetItIvas

Permiten realizar instrucciones más de una vez, formando bucles. A cada repetición se le llama también iteración, por lo cual las estructuras repetitivas se denominan también 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. También 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 también bucle con entrada controlada, es aquel que repite un grupo de acciones mientras que el resultado de la condición lógica sea verdadera (o distinta de cero). En otros términos, si el resultado de evaluar la condición es verdadera se ejecuta por lo menos UNA instrucción o más. En otro caso NO se ejecuta ninguna instrucción.

Sintaxis: while (< condición >)

{ <instrucciones>; }Hay que tener especial cuidado para conseguir, en algún momento, una forma de que la <condición> a evaluar sea falsa. Es muy fácil escribir bucles que se repiten indefinidamente hasta agotar la memoria y hacer colapsar al sistema.

Problema 1. Escribir un programa

30

que lea una cadena y determine en ella la frecuencia de aparición de cada vocal.

Solución // 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<<”Cáracter # 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 número compuesto por más de un dígito y luego mostrar:

Total de dígitos, total de dígitos pares e impares, número invertido, total de suma de dígitos pares e impares respectivamente. El programa debe ser interactivo, es decir; después de cada ejecución, el sistema envía el mensaje “Desea continuar..? (S / N)”. Si edita S continúa ejecutando el programa, en otro caso finaliza.

Solución // 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’)

31

{ gotoxy(8,3);cout<<”Ingrese un número con mas de 1 dígito : “; cin>>n; r = n; nd=0;// inicializó contador de dígitos while(n>0) // descompongo el número 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 número “<<r<<” tiene :”; gotoxy(12,7); cout<<” “<< nd<< “ dígitos “; gotoxy(12,8); cout<<” Invertido es = “<<inv; gotoxy(12,9); cout<<” Tiene “<<par<<” dígitos pares”; gotoxy(12,10); cout<<” La suma de los números pares es = “<<sump; gotoxy(12,11); cout<<” Tiene “<<impar<<” dígitos impares”;gotoxy(12,12); cout<<” La suma de los números impares es = “<<sumimpar;gotoxy(20,16); cout<<”Desea continuar..(s/n)”;cin>>resp; } getche(); }

Problema 3. Diseñar un programa que permita leer dos números comprendidos entre 10 y 99. Luego mostrar el producto respectivo. Si el usuario edita números que no están en el rango especificado, el sistema envía el mensaje: “Sr. sus números deben estar en el rango <10..99>”. Asimismo, el programa debe ser interactivo, es decir; después del error, el sistema envía el mensaje “Desea continuar……..? (s / n)”.

Solución // while_producto.cpp#include <iostream.h>void main() { int n,d,p,i=0,a,b; char resp; resp=’s’; clrscr();

32

while(resp==’s’){ gotoxy(10,3);cout<<” MULTIPLICACIÓN DE NÚMEROS “; 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 números 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 dígitos en el rango solicitado, el sistema calcula el producto, tal como se mustra en la siguiente gráfica:

Problema 4. Diseñar un programa que permita validar datos del usuario usando solo un carácter para código 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

33

suma acumulada y el total de dígitos que tiene este resultado. Si los datos son incorrectos, el sistema envía el mensaje de error.

Solución //while_if.cpp#include<iostream.h>void main() {int acum=0,ladi,ladd,li; char codigo, clave; gotoxy(12,6);cout<<” Ingrese código : “;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 dígito “; } else { if ((acum>9)&&(acum< 100)){ gotoxy(6,8);cout<<” La suma tiene 2 dígitos”; } else { if ((acum>99)&&(acum< 999)){ gotoxy(6,9);cout<<” La suma tiene 3 dígitos”; } } } } // fin del if else {clrscr(); gotoxy(12,12); cout<<” Sus datos no se registraron, hasta luego :”; } getche();}

Problema 5. Diseñar un programa que permita leer un número n entero positivo, luego calcular su factorial e imprir su resultado.

Solución // while_fact.cpp#include<iostream.h>#include<conio.h> void main()

34

{ double fact=1.0,n,minumero;gotoxy(8,4); cout<<”Ingrese un número : “; cin>>n; minumero=n; while (minumero >0) { fact=fact* minumero;

minumero--; } gotoxy(15,6);cout<<”El factorial de “<<n <<” es =”<<fact; getche(); }

Problema 6. Diseñar un programa que permita mostrar la tabla de multiplicar de n filas y m columnas, donde el usuario ingresar número de filas y columnas.

Solución //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 número de fila :”;cin>>n; gotoxy(4,6); cout<<”ingrese número 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. Diseñar 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 número de términos a sumar.

Solución //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;

35

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. Diseñar un programa que permita leer n números enteros y para finalizar la lectura, edite 0 (cero). Asimismo, el programa debe permitir :

a. La suma de números pares positivos.b. La suma de números 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 dígito es par y la

posición que ocupa y si es impar y la posición que ocupa, respectivamente.e. Según los datos ingresados, genere reportes del: total de dígitos pares e

impares positivos, dígitos negativos pares e impares, al mayor dígito par y el mayor dígito impar negativo.

Solución //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 número : “;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;

36

} } else if (num %2!=0) {in++; sin+=num; } if (num>>min) { min=num; } } i++; } gotoxy(10,4+i+1); cout<<”ingrese número:”;cin>>num;} cout<<” \nSuma de pares positivos :”<<spp<<endl;cout<<” \nSuma de impares positivos:”<<sip<<endl;getche();

y=sip; while(y>0) {y=y/10;p1++; }x=(spp*pow(10,p1))+ sip; o= x; while (o>0) { o=o/10; s++; } o=x; cout<<”\n el resultado concatenado es “<<o<<endl;getche(); while (o>0) { ud= o%10;if (ud%2==0) {cout<<”\n “<<ud<<” es par, su posición es “<<s<<endl; s--; } else { cout<<”\n “<<ud<<” es impar,su posición 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(); }

37

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 <instrucción> y luego verifica la <condición>, a partir de esta ejecución, se comporta como la estructura while. Por este motivo la estructura se ejecuta por lo menos una vez.

Sintaxis do {<instrucciones> } while (expresión) ;Este tipo de secuencias es muy utili-zada en procesos de validación de datos (cuando se quiere que el usua-rio del programa introduzca siempre datos correctos). Es decir, se repite un proceso de lectura hasta que la ex-presión (que indica su invalidez) sea falsa.

Problema 1. Diseñar un programa que permita calcular la suma acumulada de la serie: 1+2+3+4+….+n. El usuario ingresa el número de términos a sumar, validando que el número de términos no sea negativo.

Solución //do_sum.cpp# include <iostream.h># define linea “---------------------------------------”void main(){ int cont=1,suma=0,n,dato;gotoxy(8,2); cout<<” SUMANDO TÉRMINOS DE SERIE “;gotoxy(6,3); cout<<linea;

Obs. La condición de prueba puede ser también

do {

}while(!(cont>n));

38

gotoxy(10,4); cout<<” 1 + 2 + 3 + .....+ n”;gotoxy(6,5); cout<<linea;do{gotoxy(10,6); clreol();cout<<”Ingrese número de términos = “; 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. Diseñar un programa que permita calcular la suma acumulada de la serie:

11+22+33+44+….+nn

El usuario ingresa el número de términos a sumar. Después del resultado el sistema envía el mensaje “Desea continuar..? (s/n) ”.

Solución// do_suma_rep.cpp #include<iostream.h># define linea “---------------------------------------”void main(){ int cont=1,suma=0,n,dato; char resp; clrscr();do //módulo para repetir el programa {clrscr();gotoxy(8,2); cout<<” SUMANDO TÉRMINOS 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 número de términos = “; cin>>n;}while(n<1); gotoxy(10,10); cout<<” Ud. sumará “<< n <<” términos de la serie”;dato=cont;

39

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. Diseñar 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.

Solución //do_whi_serie.cpp#include <iostream.h># define linea “----------------------------------------------------”void main () { int n=1; float s=0.0,e; gotoxy(10,2);cout<<”Ingrese precisión(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 iteración “<<n; n++;}while(!(1.0/(n*n)<e));gotoxy(10,n+7);cout<<”Valor aproximado final: “;cout<<setw(6)<<setprecision(3)<<s<<” en iteración “<<n<<endl;gotoxy(10,n+9);cout<<”Sesatisface que:”;cout<<setw(6)<<setprecision(3)<<p<<”<”<<e<<” en iteración <<n<<endl;getche(); }

Problema 4. Diseñar un programa que permita validar prácticas 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.

Solución // validar.cpp#include<iostream.h>void main() { int i=0,pc1;clrscr(); gotoxy(10,4); cout<<” Sr. usuario, tiene Ud. solo 3 opciones”;

40

do { i++; gotoxy(10,8); cout<<” Le quedan “<<(4-i)<<” intentos:”;clreol();cin>>pc1;gotoxy(10,12);cout<<” La práctica 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. Diseñar un programa que valida, si desea o no, finalizar con la ejecución del programa después de mostrar los resultados de calcular el resto de dos números, donde los números son ingresados por el usuario.

Solución //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();}

41

Problema 6. Diseñar 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

Solución // 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. Diseñar un programa que permita leer n números enteros y luego generar reportes para conocer:

Total de números PARES POSITIVOS, suma de números PARES POSITIVOS, total de números PARES NEGATIVOS, suma de números PARES NEGATIVOS, total de números IMPARES POSITIVOS, suma de números IMPARES POSITIVOS, total de números IMPARES NEGATIVOS, suma de números IMPARES NEGATIVOS.

El programa permite leer números hasta que usted presiona 0 (cero).

Solución //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 número: “;cin>>n; if(n%2==0) { gotoxy(42,i);cout<<”número par”;

42

if (n>0) { gotoxy(42,i);cout<<”número par positivo”;

sumanpp+=n; npp++; } else { gotoxy(42,i);cout<<”número par negativo”; sumanpn+=n; npn++; } } else { gotoxy(42,i);cout<<”número impar”; if (n>0) { gotoxy(42,i);cout<<”número impar positivo”;

sumanip+=n; nip++; }

else {gotoxy(42,i);cout<<”número impar negativo”;

sumanin+=n; nin++;} }

} while(n!=0);

clrscr();gotoxy(20,4);cout<<” ............... RESULTADOS................. “; gotoxy(10,9);cout<<” Total de Números PARES POSITIVOS =”<<npp; gotoxy(10,13);cout<<”Suma de Números PARES POSITIVOS =”<<sumanpp; gotoxy(10,10);cout<<”Total de Números PARES NEGATIVOS =”<<npn-1; gotoxy(10,14);cout<<”Suma de Números PARES NEGATIVOS =”<<sumanpn; gotoxy(10,11);cout<<”Total de Números IMPARES POSITIVOS =”<<nip; gotoxy(10,15);cout<<”Suma de Números IMPARES POSITIVOS =”<<sumanip; gotoxy(10,12);cout<<”Total de Números IMPARES NEGATIVOS =”<<nin;gotoxy(10,16);cout<<”Suma de Números IMPARES NEGATIVOS =”<<sumanin; getche(); } Problema 8. En la siguiente figura, se ilustra la funcionalidad del módulo de validación y número de intentos por parte del usuario, es decir, debe ingresar la cantidad de dígitos que se desea procesar, que para nuestro caso el rango es como mínimo cinco dígitos (puede ser: 6, 7 ,8, etc.). Por cada error, el sistema envía el mensaje de error (ver figura) y, asimismo, el número de intentos que le quedan. Si el número de intentos supera los tres, entonces el sistema finaliza.

Cuando se ingresó correctamente la cantidad de dígitos en el rango establecido, (en nuestro caso cinco) entra a funcionar el Módulo de Validación de Dígitos definidos como cadenas, el cual solicita que usted ingrese dígito por dígito y si ingresa una letra en forma automática, elimina la letra y presenta los dígitos anteriores para que continúe ingresando más datos hasta cumplir con la condición inicial (cinco dígitos). Ejemplo: edito 43 U, entonces el sistema elimina la letra (carácter U y devuelve solo el número 43, donde usted continúa ingresando nuevos datos (ver figura).

43

Es un clásico problema en la cual se usa estructuras de control repetitivas, donde la condición de prueba está basada en letras o caracteres y especialmente en caracteres que son los dígitos de 0 a 9, motivo por la cual se debe declarar, en la sesión de variables, el tipo de dato char como un vector de caracteres.

Después de completar de editar los cinco dígitos entra a funcionar el módulo de reportes, para lo cual adicionalmente usted debe contestar lo siguiente:

a. Reporte para conocer la cadena expresada en números enteros. (Usted ingresó la cadena: “43256” entonces cadena en enteros: 43256)b. Reporte de la cadena numérica en forma invertida: 65234c. Reporte de los últimos 2 dígitos: 34.d. Reporte del factorial del último dígito, según c) 4! = 24.e. Reporte del total de dígitos pares, según c).f. Reporte del total de dígitos impares, según c).

Solución // for_cadena_digitos1.cpp #define max 100void main(){ char cad[max]; int i,j,x,nrovec=0,dosd,fact=1,ndp=0,ndi=0;do {nrovec++; gotoxy(20,2);cout<<”MÓDULO DE VALIDACIÓN: “; gotoxy(10,4);cout<<”Ingrese total de dígitos(x>4): “;clreol(); cin>>x; cout<<”\nSr. el número:”<<x<<” no esta en el rango solicitado, ingrese nuevo número :”<<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 módulo de Validación,ahora validar SÓLO DÍGITOS «<<endl;cout<<»\nIngrese cadena de sólo números, 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 sólo dígitos :”<<endl;

44

cout<<”\nHe eliminado el carácter:”<<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 blancoint p=atoi(cad);cout<<”\n La cadena convertida en número es :”<<p<<endl;int inv=0,d,tt=p; while(p>0) {d=p%10; inv=inv*10+d; p=p/10; } cout<<”\nEl número “ <<tt << “ invertido es : “<<inv<<endl; dosd=inv%100; cout<<”Los dos últimos dígitos del número invertido “<<inv<<” es “<<dosd<<endl;int uld=dosd%10; cout<<”\nEl último dígito de :”<<dosd<<” es “<<uld<<endl;for(i=1;i<=uld; i++) fact=fact*i; cout<<”\nEl factorial del último dígito 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 dígitos pares de “<<vi<<” es = “<<ndp;cout<<”\nEl total de dígitos impares de “<<vi<<” es =”<<ndi; getche(); }

2.4.3 estructura repetitiva cuando se conoce el número de iteraciones: for ( <instrs >)

Permite realizar instrucciones conociendo el número de iteraciones.

Sintaxis: for(inicializar;<condición>; contador) { <instrucciones>; }donde:1. inicializar: indica valor donde inicia el bucle.2. <condición>: se evalúa antes de cada iteración. Si es verdadera, se ejecuta el

bloque de <instrs>, en caso contrario se termina la estructura y se salta a la instrucción siguiente.

45

3. Contador: es la instrucción a ejecutarse cuando se termina cada iteración

Tradicionalmente esta sentencia es utilizada para hacer que un grupo de instrucciones se repita un número de veces conocido, utilizando un contador:

for (i=valor_inicial; i<=valorfinal; i++) <intrucciones>;

Observación. Se puede declarar una variable dentro de la inicialización:for (int i=valor_inicial; i<=valorfinal; i++)

<instrucciones>;

Pero la potencia del bucle for radica en que pueden omitirse tanto la inicialización como la expresión a evaluarse y/o el proceso de actualización, de tal manera que se pueden generar los for “infinitos” o los for solamente condicionados (no actualizados automáticamente), de tal manera que pueden reemplazar a una secuencia while<cond> { } o do {...} while<cond>;

//for solamente condicionadofor (;expresión;) {<instrucciones>; }

//for infinitofor (;;) { instrucciones>; }

Para salir de esta última estructura, en algún lugar dentro de ella debe figurar la instrucción break, vista anteriormente, sometida al valor de una determinada expresión.

Si en un bucle for solamente condicionado, la instrucción break se ejecuta de todas maneras al final (no está sometida a ninguna condición), entonces el for puede actuar como si fuera un if: for (;expresión;) {

<instrucciones>;break;

}Sin embargo, este uso reduce la legibilidad del código y por lo tanto, no es recomendable.Problema 1. Diseñar un programa que permita leer el número de términos de la serie:

1/1 ^2 +1/2 ^2 +1/3 ^2 +1/4 ^2 +............................+1/n ^2

46

y luego mostrar la suma acumulada.

Solución //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 términos:”;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. Diseñar un programa que permita generar una tabla de multiplicar de orden 12 *12 y luego:

a. Dar un reporte del total de números dentro de la tabla con un dígito.b. Dar un reporte del total de números dentro de la tabla con dos dígitos.c. Dar un reporte del total de números dentro de la tabla con tres dígitos.d. Calcular el número mayor y mostrarlo en forma invertida (144 ←441).e. Usando respuesta en d), calcular el total de dígitos pares y mostrar su suma

acumulada.f. Usando respuesta en d), calcular el total de dígitos impares y mostrar su suma

acumulada.

Solución: 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<<” números de 1 dígito. “;gotoxy(19,17);cout<<”En la tabla hay: “<<dosd<<” números de 2 dígitos.”;gotoxy(19,18);cout<<”En la tabla hay: “<<tres<<” números de 3 dígitos.”;gotoxy(19,19);cout<<”El mayor número de 3 dígitos es: “<<may;

47

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 número de tres cifras es = “<<inv; gotoxy(19,22);cout<<”El número de dígitos pares es =”<<dp; gotoxy(19,23);cout<<”El número de dígitos impares es =: “<<di; gotoxy(19,24);cout<<”La suma de los dígitos pares es = “<<sdp; gotoxy(19,25);cout<<”La suma de los dígitos impares es= “<<sdi; getch();}Problema 3. Diseñar 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 número de trabajadores por: nombre, código, sueldo básico, bonificación, descuento, categoría y estado civil. Para categoría

48

existen tres: profesional, técnico 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 categorías: profesional, técnico y auxiliar.c. Promedio por estado civil.d. Reporte por nombre y sueldo de cada trabajador.

Si sus datos de validación son incorrectos, el sistema envía el mensaje:

“ Sr. usuario, sus Datos son incorrectos, hasta pronto”;

Solución // sue_gen.cpp#include<iostream.h># define linea “-----------------------------------------------------------”void main() { floatpp,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 VALIDACIÓN 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 Básico :”;cin>>s_basico; gotoxy(23,7);clreol();gotoxy(5,7),cout<<”Bonificación :”;cin>>bonif; gotoxy(23,8);clreol();gotoxy(5,8),cout<<”Descuento :”;cin>>dscto;gotoxy(30,9), cout<<”[P] Profesional”;gotoxy(30,10),cout<<”[T] Técnico”; 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;

49

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;

50

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 Técnico :”<<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 número de trabajadores luego sus datos solicitados por cada trabajador.Segundo: Ingreso de datos por cada trabajador y luego genera los reportes solicitados:Problema 4. Diseñar un programa que permita leer un número n de alumnos por código, 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.

51

Solución //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<<”Cálculo de Promedios”;gotoxy(23,2),cout<<”=====================”; gotoxy(23,3);clreol();cout<<” Ingrese número de Alumnos : “; cin>>n;for (i=1;i<=n;i++) { gotoxy(23,4);cout<<”Alumno #:”<<i; gotoxy(5,5),cout<<”Código 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(); }

52

//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 ESTADÍSTICOS”;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. Diseñar un programa que permita encontrar todas las soluciones de la siguiente expresión, donde cada carácter represente dígito (s)

SEND + MORE = MONEY

Solución //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++){

53

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<<” “;

54

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. Diseñar un programa que permita leer un número n positivo comprendido dentro del intervalo del 10 al 999 y luego mostrar su factorial.

Solución // 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 número :” ;cin>>n;

55

} 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. Diseñar un programa que permita leer un número entero (número de filas) comprendido en el rango:1al 9 y luego mostrar la formación de una pirámide tal como se ilustra en la figura adjunta. El programa debe solictar confirmación si desea continuar imprimiendo nuevas pirámides y dependiendo del número de filas.

Solución //for_piramide.cpp #include <iostream.h>void main() {int i,j,k; char opción; do {int n=2; do {if (n!=2) {cout<<”Error”;getch(); }; clrscr(); cout<<”CONSTRUCCIÓN DE UNA PIRAMIDE\n\nIngrese el número 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 año y durante 10 años.

56

Usar a = p*( 1 + r ) ^ n

Donde p: cantidad invertida inicialmente r : tasa de interésn: cantidad de años a: cantidad en depósito al final de cada

año

Solución // 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. Diseñar un programa que permita leer un número entero (número de filas) y luego mostrar la formación de una pirámide tal como se ilustra en la figura adjunta.

Solución //for_piramide.cpp#include <iostream.h>void main() { int nl,lt,i; clrscr();gotoxy(3,2);cout<<”Ingrese número 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 continueSe utiliza con las instrucciones for, while y do–while para avanzar a la siguiente iteración del bucle, abandonando la actual.

57

Por ejemplo, el segmento de código siguiente imprimirá solo los valores enteros múltiplos de 5 en el intervalo 1–100:

For (int i=1;i<=100;i++) { if (i%5) continue; cout<<i<<” es múltiplo de 5”<<endl; }

NOTA: Existe otro tipo de sentencia de control llamada incondicional, la cual, como dice su nombre, bifurca a un lugar específico 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 línea que contiene la instrucción goto, el flujo del programa se bifurca a la línea marcada por etiqueta, sin condición alguna. La instrucción goto, para evitar bucles infinitos, deberá estar colocada dentro de una estructura condicional, o en todo caso debe haber una instrucción de salida exit o return entre la etiqueta y goto.

Problema 10. Diseñar un programa que permita leer un número entero positivo comprendido entre 99 y 999999. Si el ingreso es correcto el programa solicita que ingrese un dígito a buscar dentro del número ingresado, si existe genera el reporte del número de veces que se repite.

Si el número ingresado no está en el rango, el sistema envía el mensaje:”Número no esta en rango”

Solución //do_if_uni.cppvoid main(){int cont=0, digito,num,busca_dig;cout<<”\n Ingrese un número :”;cin>>num; if ((num>99) && (num<999999)){ cout<<”ingrese el dígito a buscar:”;cin>>busca_dig; do { digito=num%10; num=num/10; if (digito==busca_dig) {cont++; } }while(num>0); cout<<” El número de veces es: “<<cont; } //fin del ifelse cout<<”número fuera de rango”<<endl; getche();}

58

cOmPendIO de PrOblemas

Problema 1. Escribir un programa que lea cinco números enteros, dos de ellos por lo menos negativos. Luego, el programa deberá ordenar en forma ascendente los números positivos, siempre y cuando existan por lo menos dos.

Solución: posneg.cpp#include <iostream.h>void main() { int num,pos,neg,max,min,med; clrscr(); do {pos=0, neg=0; cout<<”Ingrese 5 números enteros no nulos”<<endl; for (int i=1;i<=5;i++) { do {cout<<i<<” número: “; 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 números negativos”<<endl; } while (neg<2); if (pos>1) {cout<<”Los números positivos ordenados son: “<<endl; cout<<setw(8)<<min; if (pos==3) cout<<setw(8)<<med; cout<<setw(8)<<max; }getch(); }

59

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 día y la hora correctos en que los dos relojes volverán 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 están sincronizados.

Solución: relojes.cpp#include <iostream.h>main() {int aa,mm,dd, h,m, a1,a2, correcto; clrscr(); cout<<”Hora y Fecha de sincronización”; 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);

60

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 volverán a sincronizarse el “;cout<<dd<<”/”<<mm<<”/”<<aa<<endl; cout<<”A la hora exacta: “<<h<<”:”<<m;getch(); }

Problema 3. Diseñar un programa que solicita el ingreso de un número entre -999,999 y 999,999 a continuación imprima el nombre en letras de dicho número.

61

Solución //Prg_1.cpp.#include<iostream.h>void main() {int num,k,num1,r,valor,num2,num3,num4,num5,num6,num7,num8,num9,num10; char op; gotoxy(12,2),cout<<” CONVERSIÓN DE NÚMEROS A LETRAS”<<endl;do{ do{ cout<<” \nIngrese un número 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;

62

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){

63

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 “; elsecout<<”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 “;elsecout<<”Cincuentay “; break; case 1: num1=num1%100;

64

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;

65

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;

66

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();}

67

Problema 4. Negociar un préstamo de consumidor no siempre es sencillo. Una forma de préstamo es el préstamo a plazos con documento, que funciona de la siguiente manera:

Supongamos que un préstamo tiene un valor nominal de S/. 1000, que la tasa de interés es de 15% anual y que la duración 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 préstamo de 1.5 años para dar un interés 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 restitución del préstamo se efectúa con pagos mensuales iguales basados en el valor nominal.

Así pues, el pago mensual del préstamo será de S/. 1000 dividido, entre 18 lo que queda S/. 55.56. En este método de cálculo, podría no ser tan malo, si el consumidor necesita S/. 775, pero el cálculo es más complicado si el consumidor necesita S/.1000.

Escribir el programa que lea la cantidad que el consumidor necesita recibir, la tasa de interés y la duración del préstamo en meses. El programa deberá calcular entonces el valor nominal requerido para que el consumidor reciba la cantidad que necesita. También se deberá calcular el pago mensual.

El programa debe permitir que el usuario repita este cálculo cuantas veces crea necesario.

Solución //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 interés :” ; cin>>ti; gotoxy(10,6); cout<<”Ingrese el tiempo en meses de duración del préstamo :”;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 crías cada mes y

68

cada nueva pareja se hace fértil a la edad de un mes. Si se dispone de una pareja fértil y ninguno de los conejos muertos. ¿Cuántas parejas habrá después de un año?

Mejorar el problema calculando el número de meses necesarios para producir un número dado de parejas de conejos.

Solución // while_conejos.cppVoid 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 año :»<<mes_tot; gotoxy(5,4);cout<<»ingrese número 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 número de meses necesarios es=»<<meses; getche();}

Problema 6. Diseñar un programa que permita calcular e imprimir la suma de los siete primeros términos de la serie de fibonaci: 1,1,2,3,5,8,13. Asimismo, el programa debe ir mostrando las sumas parciales.

Solución. //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(); }

69

Problema 7. Diseñar un programa que permita calcular la suma acumulada de la serie:

para un error (precisión) de 10-2. (señor lector, puede generalizar para lectura de cualquier grado de error).

Solución //do_whi_serie.cpp#include <iostream.h># define linea “----------------------------------------------------”void main () { int n=1; float s=0.0,e;gotoxy(10,2);cout<<”Ingrese precisión(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 iteración “<<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 iteración “<<n<<endl;gotoxy(10,n+9);cout<<”Se satisface que:”;cout<<setw(6)<<setprecision(3)<<p<<»<»<<e<<» en iteración «<<n<<endl; getche(); }

24222

1........41

31

21

11

n+++++

70

Problema 8. El calendario gregoriano, el cual utilizamos actualmente, fue una corrección hecha al calendario romano (de 365 días y 6 horas) por el Papa Gregorio XIII, debido a que un año astronómico realmente se componía de 365 días, 5 horas, 49 minutos y 12 segundos.

Dicha corrección consistió en adelantar la fecha del 05/10/1582 al 14/10/1582 y establecer que los años bisiestos sean aquellos que son múltiplos de 4, pero no de 100, a menos que lo sean también de 400 (1900 no fue bisiesto, 1800 sí lo fue). Más tarde, un monje estableció que el primer día 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 día correspondiente (lunes, martes, ...) según el calendario gregoriano.

Solución //do_while_gregoriano.cpp#include<iostream.h>void main(){int a,m,d,p,r,b=0,xxx,g;int i,j; cout<<” Día segun calendario Gregoriano:”<<endl;cout<<”Ingrese ano(D.C): “;cin>>a;cout<<”Ingrese mes : “;cin>>m;cout<<”Ingrese día : “;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) )

71

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 día: “; 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<<”Sábado”;break;} case 6:{cout<<”Domingo”;break;} case 7:{cout<<”Lunes”;break;}case 0:{cout<<”Lunes”;break;} } getch();}

Problema 9.- Un virus desconocido aumenta su población de acuerdo a la siguiente ley:

n = ni*t/(ni+t*exp(t))

en donde ni es el número inicial de unidades virales, t es el tiempo en minutos.

Escribir un programa que lea la cantidad inicial del virus y determine cuántos minutos serán necesarios para que éste alcance su población máxima. Indicar dicha cantidad.

Solución //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<<”º”; }

72

gotoxy(18,2);cout<<”************* VIRUS INFORMÁTICO ************ “;time_t tiemp; time(&tiemp);gotoxy(30,22);cout<<”Fecha de Consultas: “<<ctime(&tiemp);gotoxy(12,6);cout<<”Ingrese ni(número 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 población máxima 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). Diseñar un algoritmo para ingresar la nota y sección de dichos alumnos (el ingreso de datos termina cuando se ingresa como nota el número - 10) y luego determine:

- El porcentaje de aprobados por sección (si existen alumnos en dicha sección).- La nota promedio general (de todas las secciones).- La mayor nota y el número de alumnos que la poseen (de todas las secciones).

Solución. Usando las siguientes evaluaciones, se mostrara el diseño del programa

Pc1 Pc2 Pc3 Pc4 Pc5U 12 10 14 14 08V 10 8 12 12 05W 05 18 12 18 13

1.- Diseño del bucle repetitivo para ingreso de nota y sección.- Usted ingresa notas hasta que edite -10 mientras, tal como se ilustra en la siguiente gráfica. 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;

73

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<<” sección= “;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=sumaw+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//cálculo de porcentaje por sección if(nu==0) { g o t o x y ( 5 , 5 ) ; cout<<”Sección U no tiene alumnos”; } else { pu=float(nau*100)/nu; } gotoxy(5,6);cout<<” Promedio de la sección U = “<<promu; gotoxy(5,7);cout<<” Porcentaje de Aprobados = “<<pu<<” % “; //cálculo de porcentaje por sección V if(nv==0) {gotoxy(5,9);cout<<”Sección v no tiene alumnos”;} else { pv=float(nav*100)/nv;} gotoxy(5,10);cout<<” Promedio de la sección V = “<<promv; gotoxy(5,11);cout<<” Porcentaje de Aprobados = “<<pv<<” % “; //cálculo de porcentaje por sección w if(nw==0) {gotoxy(5,13);cout<<”Sección w no tiene alumnos”; }else

74

{ pw=float(naw*100)/nw; } gotoxy(5,14);cout<<” Promedio de la sección W = “<<promw; gotoxy(5,15);cout<<” Porcentaje de aprobados = “<<pw<<” % “; //cálculo delpromedio general pg=float(promu+promv+promw)/3;gotoxy(5,17); cout<<” Promedio de las 3 Secciones = “<<pg; //mostrar la nota máxima y cuantos la poseen gotoxy(5,19);cout<<”la nota máxima es=”<<notamax<<” y la poseen “<<nmax<<”Alumnos”; getche(); }

Problema 11. Diseñar un algoritmo que realice las siguientes tareas: remita al usuario validar sus datos de ingreso (código y clave). Si el código es 221 y la clave es 999, el usuario puede ingresar al sistema, caso contrario se vuelve a pedir los datos hasta un máximo de 3 intentos (si supera los 3 intentos el sistema envía el mensaje “No puede usar el sistema” y termina el proceso). Si el usuario ingresa al sistema, le debe solicitar un número entero positivo n para luego calcular la siguiente suma de n términos:

S = 15 + 35 + 55 + 75 + 115+ ….Luego debe mostrar el dígito mayor del número S y el número SI (SI es el número invertido de S).

Ejemplo: Para n = 2 S = 244 y SI = 442

Solución

Módulo I. Verificación de usuario autorizado a ingresar al sistema a realizar operaciones. Aquí se aplica la estructura de control Repetir (do..), validando el Código = 221 de usuario (CLAVE = 999, ES ANÁLOGO) 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.Módulo II. Verificación del nú-mero de consultas (interactivo), el usuario puede continuar realizando consultas (este es el


75

modo interactivo de usuario con el sistema) cuando se aplica la estructura de control mientras (while..). Para lo cual, se ha diseñado la pregunta “Sr. desea continuar..? (S/N)” y por cada respuesta de S, el sistema usa un contador (n_cons) denominado número de consultas. Si supera tres consultas el sistema finaliza.

Procedimientos 1. Verificar que el usuario (Código = 221) solo tiene tres alternativas para realizar

sus consultas. Por cada error que comete, el sistema le envía mensajes de usuario no registrado en el sistema, así como el número 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 número de errores es igual a 4, entonces el sistema envía el siguiente mensaje, indicando que el usuario no tiene más oportunidades (ver figura 2) o “fin de sesión”.

Se deja constancia que el número de consultas no cambia, pero sí el contador de errores, el cual aceptará como máximo tres.

3. En la siguiente interfase, el usuario ingresa correctamente su código “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. Después 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

número de términos y luego se obtiene las respuestas mostradas en las siguientes interfaces.

//Preg_02_algo_SOLUCION.cpp#define linea “____________________________”void main()

76

{ 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 máximo 3 errores, no dependen de consultas { ner++; clrscr() ; if(ner<=3) { clrscr(); gotoxy(10,1);cout<<” Validación de Datos de Usuario”; gotoxy(10,3);cout<<”Ingrese Código = “;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 sesión, 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 número de términos 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 término “<<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();

77

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 término “<<n<< “ es = “<<sum; gotoxy(10,10);cout<<” * El dígito menor es = “ <<menor; gotoxy(10,11);cout<<” * El dígito mayor es = “ <<mayor; gotoxy(10,12);cout<<” * El Número Invertido es = “ <<inv; gotoxy(7,13);cout<<linea; gotoxy(10,15); cout<<” Gracias por su consulta Número : “<<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 número de consultas... máximo ncons <= 3 else { gotoxy(10,2); cout<<”No esta autorizado para hacer más 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 número y calcule el factorial respectivo.

Análisis- Se diseñará los siguientes dos módulos principales:

Módulo I. Verificación 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.

Módulo II. Verificación del número 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 diseñado la pregunta “Sr. desea continuar..? (S/N)” y por cada respuesta de si (S),el sistema usa un contador (n_cons) denominado número de consultas. Si supera tres consultas el sistema finaliza.

Procedimientos 1. Verificar que el usuario (Nombre = LUIS) solo tiene tres alternativas para


78

realizar sus consultas. Por cada error que comete, el sistema le envía mensajes de usuario no registrado en el sistema, así como el número 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 número de errores es igual a 4, entonces el sistema envía el siguiente mensaje,

indicando que el usuario no tiene más oportunidades (ver figura 2)

Se deja constancia que el número de consultas NO cambia, pero sí el contador de errores, el cual solo aceptará como máximo tres oportunidades.

3. En la siguiente interfase, el usuario ingresa correctamente su nombre “luis” (observe que está en letras minúsculas), entonces el sistema le da la bienvenida, así como le muestra el total (2) de errores cometidos y solicita que ingrese un número.

4. Después de ingresar el número (en nuestro caso 7), el sistema debe validar descartando los negativos y los números mayores a 50. Luego debe calcular el factorial del número ingresado y mostrar los siguientes resultados: el factorial y, a este resultado, tambien identificar: el total de dígitos, total de dígitos nulos, total de dígitos diferentes de cero, dígito menor y dígito mayor), tal como se ilustra en la figura. Asimismo, envía el número 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 número 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 saldría registrando solo una consulta).

5. En la siguiente figura, se ilustra cuándo el usuario realizó tres consultas (modo interactivo) y cuando se desea hacer la consulta número 4, entonces se finalizará, tal como se ilustra en la figura con el mensaje indicando que no se puede realizar más de tres consultas.

79

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.

Solución //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++; //máximo 3 if(ncons<=3){// do para validar

máximo 3 errores, no dependen de consultas

do { ner++; clrscr() ; if(ner<=3){ clrscr(); gotoxy(10,1);cout<<” Vali-

dación 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 sesión, 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 consultado { gotoxy(10,6); clreol();cout<<”Ingrese número = “;cin>>n; }while(n<0 || n>50 );

80

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<<” dígito(s)”;gotoxy(10,8);cout<<” * Dígito(s) nulo(s) = “<<ndnulos ; gotoxy(10,9);cout<<” * Dígito(s) no nulo(s) = “<<ndnocero;gotoxy(10,10);cout<<” * El dígito menor es = “ <<menor; gotoxy(10,11);cout<<” * El dígito mayor es = “ <<mayor; gotoxy(7,12);cout<<linea; gotoxy(10,14); cout<<” Gracias por su consulta Número : “<<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 más de “ <<(ncons-1)<<” consultas, adi-

os...”; getche();exit(0); } clrscr(); } }//fin principal

Problema 13. Las siguientes gráficas (interfaces) permiten ilustrar una aplicación 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. Módulo de validación para ingresar al sistema: para este módulo se debe diseñar la instrucción que permita comparar dos cadenas, la cadena 1 o dato ingresado por usuario = “CÓRDOVA” y cadena 2 el passWord = “***”. Los valores iniciales de la cadena están registradas en el programa fuente en letras


81

mayúsculas, razón por la cual la instrucción debe ser capaz de convertir letras minúsculas a mayúsculas (ver figura 1). Para la comparación y conversión use las funciones: strcmp() y strupr(). Para simular este proceso, ver figura 1).

2. Cuando el usuario ingresó en forma incorrecta sus datos, el sistema envía el mensaje mostrado en la figura2), indicando la salida del modo compilación al programa fuente.

3. Cuando el usuario ingresó en forma correcta sus datos, el sistema solicita que ingrese prácticas, las cuales deben estar en el rango 0..20. Si una o más notas no cumple con esta condición, ver figura 3 (notas que no corresponden a la realidad).

Error que permite salir del modo compilación al programa fuente. Entonces debe reiniciar la compilación del programa y después de usar paso 1), se ingresa las notas y se calcula el promedio de prácticas eliminando la menor nota (ver figura 5).

4. Si el promedio de prácticas 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, más el promedio de prácticas, 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

Interface de validación(Fig. 1)

Interface cuando existe error de datos(Fig. 2)

82

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 prácticas 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)

Solución // 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);

83

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 condición de prácticas “;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 práctica es = “<<min<<” y se eliminó”;gotoxy(10,12);cout<<” ===> Promedios de Prácticas <=== “<<pp; getche(); if(pp>6.5) {clrscr(); int exp,exf; float pf;gotoxy(10,2);cout<<” Alumno puede rendir Exámenes “;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);

84

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 exámeneselse{clrscr(); gotoxy(15,12);cout<<” Ingreso de Exámenes fuera de rango... “; }}//fin exp>0 else {clrscr(); gotoxy(3,11);cout<<”Sr.su Promedio de prácticas es menor a 6.5, no puede rendir exámenes”;gotoxy(5,12); cout<<” Hasta el proximo ciclo!!!!!!”;} } //fin 6.5else{ clrscr(); gotoxy(10,8);cout<<” Error en el ingreso de prácticas...”; gotoxy(5,9); cout<<linea; }

85

} else { clrscr(); gotoxy(20,12); cout<<”Sr. sus datos tienen error !!! “; gotoxy(12,13); cout<<linea; } getche(); }

2.4.4 estructuras múltiple - módulo de operaciones aritméticas

En este módulo se realiza lectura de dos números y dispone de cuatro alternativas, donde cada alternativa realiza una operación aritmética que puede ser de: suma (+), resta (-), multiplicación (*) y división ( / ) respectivamente.

En la siguiente figura (1), después de leer dos números enteros (se valida b para evitar división entre 0 ) y luego se edita la operación a realizar:

Procedimientos de ejecución de cada alternativa. Se ilustrará solo para las operaciones de suma y división, las dos restantes son similares a su proceso.

[ + ] Suma. Después de editar el operador “+”, se obtiene el mensaje conteniendo la respuesta de +10.

[ / ] División. Después 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 división”, 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 Aritméticas”; 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 opción = “;cin>>opcp;

86

switch(opcp) { case ‘o’:case ‘O’:clrscr(); gotoxy(10,2);cout<<” OPERACIONES ARITMÉTICAS”; gotoxy(5,3);cout<<linea; gotoxy(10,5); cout<<”Ingrese primer número = “;cin>>a; gotoxy(10,6); cout<<”ingrese segundo número= “;cin>>b; gotoxy(5,7);cout<<linea;// primero dibujo el cuadro gotoxy(5,9);cout<<linea; gotoxy(5,8);cout<<” Elija Operación [+][-][*][/] = “;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 división “;

getche(); exit(0); } } break;//fin fel ifdefault:{ gotoxy(3,11);cout<<”Operador<”<<opera <<”>no esta disponible, hasta luego..”;getche();exit(0);} }//fin del case operagotoxy(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<<”Año = “<<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 marcogotoxy(7,6);cout<<linea;

87

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 opción > “; 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;

88

case 4: gotoxy(8,11); cout<<”Gracias por sus Transacciones... “; 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, diseñar un programa que permita leer alumnos (n>0 y n<=100) por código y nota respectivamente, los código están formados solo por 3 dígitos y las notas solo son validas de 0..20 inclusive. Luego genere reportes para conocer:

a. Mayor notab. Código, posición y número de

veces que se repite la mayor nota. c. Secuencia de códigos y secuencia

de notas respectivas (de la mayor).

Análogamente identificar la menor nota y realice los procesos anteriormente solicitados para la menor nota.

Ejemplo. Considere los datos de la siguiente tabla:

Solución:

Interface de entrada de datos.- Se ilustra cómo se debe ingresar el código y la nota de cada alumno. El ingreso se realiza en forma interactiva al usar la confirmación de (S/N).

Resultados. En las siguientes interfaces, se ilustra los resultados respecto a mayor nota, código y posición, análogo a la menor nota y el consolidado de alumnos aprobados y desaprobados.

Interface. Con datos respecto a la mayor nota, mostrando la secuencia de formación de esta, la secuencia de formación de las notas, la secuencia de formación de los códigos y la secuancia de formación de las posiciones respectivas.

Observación. Señor usuario describa el módulo para la menor nota y hacer que el programa tenga alcance general, (verificar con las notas 12, 16 12 y 16).

Número de alumnos: 4 1 2 3 4

códigos 100 200 300 400

Notas 16 10 16 16

89

//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 código «<<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 Códigos = “<<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;

90

i++;} gotoxy(12,16+i);cout<<linea; gotoxy(12,17+i);cout<<”La cantidad de desaprobados son :”<<desap; gotoxy(12,18+i);cout<<”La cantidad de aprobados son :”<<aprob;gotoxy(12,19+i);cout<<linea; getche();}

Problema 16. Según las siguientes interfaces, plantear el enunciado del problema respectivo. Los datos correctos del usuario son:

Código = “tcn” y clave = “123”

1. Validar datos del usuario. Como observará la entrada de datos son incorrectos y se repite más de tres veces, el sistema envia mensaje de finalización.

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 prácticas y luego calcula el promedio eliminando la menor nota. A contiuación 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 prácticas menor a 6,5 no puede rendir exámenes, con lo cual queda desaprobado en el ciclo.

4. Si edita N, sale de opción P y regresa a menú principal, tal como se ilustra en paso 2.

91

5. Si edita opción B Buscar Dígito, primero solicita que ingrese un número y un dígito a buscar. Luego se obtiene los siguientes resultados:

En esta interface puede usted repetir los procesos de leer un número y un dígito las veces que sea necesario.

6. Si usa opción 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 validaci¢n de sus datos... “; do {gotoxy(3,4);cout<<”Ingrese código :”;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 ---------------”;

92

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 dígito”;gotoxy(15,8);cout<<” Invertir número”;gotoxy(15,9);cout<<” < S > Salir del sistema”;gotoxy(18,12);cout<<”< Edite opción >”;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 práctica 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’));

93

break; case’b’:case’B’:do{clrscr();gotoxy(5,2);cout<<” Formando secuencia de dígitos”; gotoxy(3,4);cout<<” Ingrese número :”;cin>>n; gotoxy(5,7);cout<<”Ingrese dígito 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 DÍGITOS REPETIDOS = “<<no_vec_sec_rep;gotoxy(5,10);cout<<” SECUENCIA DE DÍGITOS = “<<tol_sec_dig_rep;gotoxy(5,11);cout<<” SECUENCIA NO REPETITIVA = “<<tol_sec_no_rep;gotoxy(5,12);cout<<” TOTAL DE DÍGITOS 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;case’i’:case’I’:do{clrscr();gotoxy(5,2);cout<<”Invertir número”;gotoxy(3,4);cout<<”Ingrese número:”;cin>>n;if((n>999)&&(n<9999)) {while(n>0) {d=n%10;inv=inv*10+d; n=n/10; } gotoxy(12,10);cout<<” Número invertido = “<<inv;gotoxy(12,12);cout<<” Desea ud. continuar...?(S/N)==>”;cin>>op; } else {clrscr(); gotoxy(12,10);cout<<” Número fuera de rango... “;gotoxy(12,12);cout<<” Desea ingresar otro número..?(S/N)==>”;cin>>op;}}while((op==’s’)||(op==’S’));break; case’s’:case’S’: clrscr(); gotoxy(12,10);cout<<” Gracias por sus consultas “; getche(); exit(0); break; default: clrscr(); gotoxy(12,10);cout<<” Opción 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 metereológico de Argentina, se llevan los promedios mensuales de lluvias caidas en las principales regiones productoras del país.

94

Existen tres regiones importantes denominadas: norte, centro y sur. Diseñar un programa que permita calcular:

a. Promedio anual de cada región.b. El mes y registro con mayor lluvia en la region sur.c. La región con mayor lluvia anual (los registros anuales de cada región son

diferentes).

VARIABLES- RNOi: variable de tipo real que inidica la lluvia caida en la región norte en el

mes i: 1..12- RCEi: variable de tipo real que inidica la lluvia caida en la región centro en el

mes i: 1..12- RNSi: variable de tipo real que inidica la lluvia caida en la región sur en el

mes i: 1..12- ARNO,ARCE,ARSU: Variables

que acumulan lluvias caidas en cada región

- MERSU: Almacena el menor registro mensual de la región sur. Como trato de localizar el mínimo, al principio lo ini-cializo con un valor grande 5000000

- MES: Almacena el mes con menores con menores lluvias en el sur

- RNO,RSU,RCE: Regiones- PRORCE: Almacena el pro-

medio anual de de las lluvias caidas en la región 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<<” Región Norte=”;cin>>rno; gotoxy(10,7);cout<<” Región centro=”;cin>>rce; gotoxy(10,8);cout<<” Región Sur=”;cin>>rsu;arno=arno+rno; arce=arce+rce;arsu=arsu+rsu; if (rsu<mersu ) {mersu=rsu; mes=l; }

95

l++; //si uso for no iria l++ }clrscr(); prorce=float(arce)/12; gotoxy(10,6);cout<<”promedio de region centro = “<<pro-

rce;gotoxy(10,7);cout<<” mes con

menor lluvia región 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<<” Región con mayo lluvia es = el Norte”; } else {gotoxy(10,8);cout<<” Región con mayorlluvia es = el Sur “; } } else { if(arce>arsu) { gotoxy(10,10);cout<<” Región con mayor lluvia es = Centro”; } else{ gotoxy(10,10);cout<<” Región con menor lluvia es = Sur”; } }getche(); }

Problema 18. Diseñar un programa que permita a un usuario leer un número entero positivo compuesto como mínimo de 6 y máximo 8 dígitos, asimismo, el usuario ingresa un dígito a buscar en número. Por lo tanto, el programa debe brindar al usuario los siguientes reportes; número invertido, total de dígitos repetidos, la secuencia que forma y la suma de este cuando el usuario ingresa un dígito a buscar, total de dígitos no repetidos, su secuencia y su suma respectiva. Asimismo, de la secuencia no repetida, mostrar la secuencia formada por solo números pares, así como de los impares, (Ver figura, parte de resultados).

Solución // 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 número de consultas

96

clrscr(); gotoxy(30,23);cout<<” Ud. realizará la consulta # “<<cons;gotoxy(10,1);cout<<” Formando secuencia de dígitos “;gotoxy(3,2);cout<< linea;gotoxy(5,3);cout<<” Ingrese número ==> “;cin>>n;gotoxy(5,4);cout<<” Ingrese dígito 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 dígitos Repetidosno_vec_sec_rep++; } else {tol_sec_no_rep=tol_sec_no_rep+dig*pow(10,no_vec_no_rep); sumanorep+=dig; //suma de dígitos 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 Dígitos Repetidos = «<<no_vec_sec_rep;

97

gotoxy(5,8);cout<<» Secuencia de Dígitos = «<<tol_sec_dig_rep; gotoxy(5,9);cout<<» Suma de dígitos Repetidos = «<<suma; gotoxy(5,11);cout<<»Total de Dígitos NO Repetidos= «<<no_vec_no_rep; gotoxy(5,12);cout<<» Secuencia No Repetida = «<<tol_sec_no_rep; gotoxy(5,13);cout<<» Suma de dìgitos 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. Diseñar un programa que permita a un usuario validar sus datos de entrada por código=”tcn”, si los datos de entrada son correctos el sistema envía el mensaje “ Bienvenidos así como el número de consulta y la fecha respectiva ”, luego solicita que ingrese un número entero comprendido en el rango del1 al 99, este número permite calcular el factorial y con su resultado se debe mostrar el número total de dígitos, el número de dígitos nulos y dígitos no nulos, asimismo, el menor y mayor dígito.

Adicionalmente, el programa debe ser interactivo, es decir; cada vez que se repite un nuevo proceso, el sistema solicita que ingrese el código de validación, mostrando el número de consultas a la fecha (este número es diferente al total de errores que cometa el usuario en su validación de código).

Asimismo, si el usuario no desea continuar, el sistema envía el mensaje de agradecimientos, mostrando el número total de consultas.

Si el dato de validación es incorrecto (recuerde que solo se dispone de tres alternativas), superado este número el sistema envía el mensaje “FIN DE SESIÓN, PUES SUPERO MÁS DE INTENTOS”

PROCEDIMIENTOS1. Primera ejecución del programa: en esta interfase, el sistema le advierte al

usuario que SÓLO dispone de tres alternativas para ingresar al sistema a calcular el factorial de un número, para lo cual debe validar su código “TCN” (observe que el valor está en letras mayúsculas). Asimismo le indica el número de consulta y la fecha correspondiente.


98

En esta interfase, el usuario ingresa su código = “tc”, código que es incorrecto. Ante este error el sistema envía el mensaje de error y el número de oportunidades que quedan, tal como se ilustra en la figura.

2. La siguiente interfase ilustra el error número 2, cometido por el usuario al ingresar un código = “3tcn”, código que no está registrado en el sistema. Se deja constancia que el número de consultas no cambia, pero sí el contador de errores, como máximo tres.

3. En la siguiente interfase, el usuario ingresa correctamente su código “tcn” (observe que está en letras minúsculas).

4. A consecuencia del paso 3, el sistema envía el mensaje de bienvenida y el número de errores (2) en este caso.


99

5. Ahora el sistema solicita que ingrese un número SOLO en el rango del 1 al 99 (se debe validar descartando los negativos y los números mayores a 99). En esta interfase se calcula el factorial del número ingresado y otros resultados (total de dígitos, total de dígitos nulos, total de dígitos diferentes de 0, dígito menor y dígito mayor), tal como se ilustra en la figura.

Si el usuario contesta la pregunta con “s”, entonces se debe reiniciar el sistema mostrando el número de consultas actuales (4) y la fecha, tal como se ilustra en la siguiente interfase.

6. El usuario después en su consulta número 4, ingresa el número 14 y los resultados se ilustran en la siguiente intrefase.

100

7. Si el usuario responde con “n”, el sistema envía la siguiente interfase, indicando los agradecimientos por las diferentes consultas, así como el total de consultas realizadas.

Solución / / do_valida_cod_Fact.cpp# include<iostream.h>// defina otras librerías # 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<<»VALIDACIÓN :»; 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);

101

if (strcmp(strupr(cod),”TCN”)!=0){gotoxy(6,7); cout<<”Sr. el código ==> “<<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<<”Código ==> “<<cod <<” <== registrado en el sistema, bienvenido “;

}}else {gotoxy(10,12);cout<<” FIN DE SESIÓN, PUES SUPERO MÁS 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 número : “;clreol();cin>>n;} while((n<0)||(n>99));gotoxy(10,8);cout<<” Número 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 RE-

SULTADOS “;gotoxy(10,17);cout<<”El facto-

rial “<<fact<<” tiene “<<nd<<” digito(s)”;

gotoxy(10,19);cout<<” * Dígito(s) nulo(s) = “<<ndnulos ;

gotoxy(10,20);cout<<” * Dígito(s) no nulo(s) = “<<ndnocero; gotoxy(10,21);cout<<” * El dígito menor es = “ <<menor; gotoxy(10,22);cout<<”

* El dígito mayor es = “ <<mayor;gotoxy(10,24);cout<<” Sr. desea continuar...? (S/N) ==> “;cin>>resp;

102

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 diseñado un programa con ciertos atributos, tales como: generación 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 número 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 prácticas para buscar la práctica 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.

Solución //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);

103

if (nrovec<=3) //para salir del del bucle cuando sea mayor a 3 {textcolor(12);gotoxy(10,6); cprintf(“ MODULO DE VALIDACIÓN”); 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-nro-

vec)<<» 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)<<” IN-

TENTENTOS “; 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 PRÁCTICAS “);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 prácticas “);do{//validando la practica1, analogo hacer para p2,p3,p4textcolor(22);gotoxy( 10,10);clreol();cprintf(“ PC1 = “);cin>>pc1; if(pc1<0 || pc1>20 ){gotoxy(30,10); cout<<” Error, ingrese nueva práctica “;getche(); } else {gotoxy(30,10);cout<<” Ingrese siguiente práctica “; }}while(pc1<0 || pc1>20);


104

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 números enteros, dos de ellos por lo menos negativos. Luego, el programa deberá ordenar en forma ascendente los números positivos, siempre y cuando existan por lo menos dos.

Solución. En la siguiente gráfica, se ilustra:

a. El programa no acepta números negativos.b. Tiene que editar por lo menos dos números negativos.

105

En la siguiente gráfica, 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 números 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 números Negativos”<<endl;clrscr();} }while (neg<2); if (pos>1) {cout<<”\n\t Los números positivos ordenados son: “<<endl<<endl;cout<<setw(7)<<min; if (pos==3) cout<<setw(8)<<med; cout<<setw(8)<<max; } getche();}


106

1. Diseñar un programa que permita a un usuario leer un Número entero positivo compuesto como mínimo 6 y máximo 8 dígitos, asimismo el usuario ingresa un DÍGITO a buscar en Número. Por lo tanto, el programa debe brindar al usuario los siguientes reportes; número invertido, total de dígitos repetidos, la secuencia que forma y la suma de este cuando el usuario ingresa un dígito a buscar, Total de dígitos no repetidos, su secuencia y su suma respectiva. Asimismo de la secuencia no repetida mostrar la secuencia formada por solo números pares así como de los impares, (Ver Figura, parte de RESULTADOS)

estructuras de control: compendio de problemas

1. Secuenciales2. Condicionales3. Repetitivas


107

2. Diseñe 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 serie2.2. El resultado de 1), mostrarlo en

forma Invertida2.3. El total de cifras que tiene resul-

tado 1).2.4. Total de cifras Pares según resul-

tado 1)2.5. Secuencia de cifras Pares según 1)2.6. Suma de cifras Pares según 5)2.7. Total de cifras ImPares según resultado 2.1)2.8. Secuencia de cifras ImPares según 1)2.9. Suma de cifras ImPares según 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. Diseñar 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 envía el mensaje “ Procesando Edades de Población en el Peru ”, solicitando inmediatamente que ingrese Número de Departamentos(Solo


108

en el rango 1..30 ), por cada Departamento debe ingresar Número 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 Distritob) Promedio de edades de Pobladores en cada DepartamentoEl programa debe se Interactivo, es decir después de cada consulta debe preguntar “Sr. Desea hacer una siguiente consulta..? (S/N)==> ”.

Si el usuario ingrese datos incorrectos, entonces el programa indica el número de error así como el número de intentos que le queda . Si el número de errores es mayor que 3, el programa finaliza enviando el mensaje “Debido a errores, Hasta luego…”

4. Diseñar un programa que permita a un usuario validar sus datos de entrada por código=”tcn”, si los datos de entrada son correctos el sistema envía el mensaje “ Bienvenidos así como el número de consulta y la fecha respectiva ”, luego solicita que ingrese un número entero comprendido en el rango 1..99, este número permite calcular el factorial y con su resultado se debe mostrar el número total de dígitos, el número de dígitos nulos y dígitos no nulos, asimismo el menor y mayor dígito.

Adicionalmente, el programa debe ser interactivo, es decir; cada vez que se repite un nuevo proceso, el sistema solicita que ingrese el código de validación mostrando el número de Consultas a la fecha (Este número es diferente al total de errores que cometa el usuario en su validación de código).

Asimismo, si el usuario no desea continuar, el sistema envía el mensaje de agradecimientos mostrando el número total de consultas.

Ahora si el dato de validación es incorrecto (recuerde que solo se dispone de 3 alternativas), superado este número el sistema envía el mensaje “ FIN DE SESION, PUES SUPERO MAS DE INTENTOS “


109

PrOcedImIentOs

4.1. Primera ejecución 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 número, para lo cual debe validando su código ”TCN” (observe que el valor esta en letras mayúsculas) Asimismo le indica el Número de consulta y la fecha correspondiente.

En esta interface, el usuario ingresa su código=”tc”, código que es incorrecto. Ante este error el sistema envía el mensaje de error y el número de oportunidades que quedan, tal como se ilustra en la figura.

4.2. La siguiente interface ilustra el error número 2 cometido por el usuario al ingresar un código=”3tcn”, código que no esta registrado en el sistema. Se deja constancia que el número de consultas no cambia, pero si el contador de errores, como máximo 3.

4.3. En la siguiente interface, el usuario ingresa correctamente su código ”tcn” (observe que esta en letras minúsculas)

4.4. A consecuencia del paso 3, el sistema envía el mensaje de Bienvenida y el número de errores( 2) en este caso.


110

4.5. A continuación, el sistema solicita que ingrese un número SOLO en el rango 1..99 (se debe validar descartando los negativos y los números mayores a 99). En esta interface se calcula el factorial del número ingresado y otros resultados (total de dígitos, total de dígitos nulos, total de dígitos diferentes de 0, dígito menor y dígito mayor ), tal como se ilustra en la figura.

Si el usuario contesta la pregunta con “ s ”, entonces se debe reiniciar el sistema mostrando el número de Consultas actuales(4) y la fecha , tal como se ilustra en la siguiente interface .

4.6. El usuario después en su consulta número 4, ingresa el número 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.


111

5. Diseñar un programa que permite leer 2 números enteros y luego genere un reporte que permita visualizar tales números 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 prácticas calificadas con notas solo en el rango de 0..20 y luego se calcula su promedio de prácticas (pp) eliminando la práctica con menor nota.

Para que el alumno tenga derecho a rendir Exámenes 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

112

pf>10 entonces ‘Alumno Aprobado’, en otro caso ‘Alumno Desaprobado’.

7. Diseñar un Programa que permita al usuario ingresar n empleados (n<=100), a continuación por cada empleado ingresar su sueldo res-pectivo. 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.

Observación. 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 día bajo las siguientes condiciones:

a) Si ventas < S/. 80, entonces no hay comisión b) Si ventas esta en el rango de: 80..600 entonces la comisión es igual al 12% c) Si ventas esta en el rango de: 601..1000 entonces la comisión es igual al 15%

Diseñar un programa que permita leer nombre de empleado, nombre de producto y el total respectivo, luego hacer un reporte de la comisión. También si las ventas no satisfacen laCondición a), enviar el mensaje “ Sr. ..Sus ventas No ameritan comisión”. Si las ventas exceden la condición c), envíar el mensaje “ Felicitaciones, será ascendido.. ”

9. Diseñe un programa que permita validar datos de usuario para ingresar al sistema de consultas, donde el usuario se identifica por código=100 y clave=”tlcn”.

113

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 código.

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 números 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 Números : El usuario ingresa 3 números enteros positivos y luego el sistema muestra el mayor respectivamente, ademas indicando si es número Par o Impar

<N> Número de Cifras: El usuario ingresa un número 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 número ingresado.

114

 Número de Capicua (Palin-drómico): La palabra capicúa (en matemáticas, número palíndromo) se refiere a cualquier número que se lee igual de izquierda a derecha y de derecha a izquierda (Ejemplos: 121). El término se origina en la expresión catalana capicua (cabeza y cola).

Definición. Un número palin-drómico es un número simétrico escrito en cualquier base a tal que a1a2a3…|… a3a2a1.

Todos los números de base 10 con un dígito {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} son palindrómicos.

• Existen nueve números palindrómicos de dos dígitos: {11, 22, 33, 44, 55, 66, 77, 88, 99}.

• Noventa de tres dígitos: {101, 111, 121,…, 181, 191, 202, 212,…, 292, 303, 313,…, 898, 909, 919, 929,…, 979, 989, 999}

• Noventa con cuatro dígitos: {1001, 1111, 1221, 1331, 1441, 1551, 1661, 1771, 1881, 1991,…, 9009, 9119, 9229, 9339, 9449, 9559, 9669, 9779, 9889, 9999},

• Novecientos de cinco dígitos: {10001, 11011, 11111, 11211, 11311, 11411, 11511,…,}

• Un pequeño truco para hallarlos sería sumar un número con otro en el que “le damos la vuelta” a sus cifras. Por ejemplo a mi me encanta el número 17, y para buscar un número capicúa a partir del 17 lo que tengo que hacer es: 17+71=88 (capicúa).

• Ejemplo: partimos del número 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 envía el mensaje “Opción no disponible” y finaliza.

9. Diseñar un programa que permita Leer o ingresar Edades de n alumnos(n es definido por usuario) y luego mostrar la Menor edad y la posición Actual del dato ingresado.

En la siguiente grafica se ilustra la lectura y los reportes, así como las edades cuando se tiene que actualizar


115

Verificar: n=3, con las siguientes datos:Nombres Ana Luís Pedro

Edades 30 15 28

Posición 1 2 3

El programa debe ser Interactivo, es decir; después de finalizar con el ingreso de los datos, el sistema envía el mensaje de “Desea continuar… (S/N)”. Debe validar la edición solo de S o N. por cada error debe mostrar el mensaje Ingrese “ nueva letra, error # “. Cuando edita S, continúa con la lectura de nuevos datos y si edita N, el programa finaliza indicando el número de consultas realizadas.

10. Diseñar un programa interactivo que permita a un usuario Validar sus datos de ingreso al sistema. Los datos pueden ser: una letra o un dígito. Si el usuario ingresa un dígito, el sistema confirma que dato es un dígito y luego solicita que ingrese un número entero mayor o igual a 10 y menor que 10000. Luego puede ocurrir que:

I. Si el número es par, entonces el programa debe realizar las siguientes tareas:

a) Mostrar el número en forma in-vertida

b) Conocer el número total de dígi-tos.

c) Conocer el número total de dígi-tos pares.(ver figura.)

d) Conocer el número total de dígi-tos impares(ver figura.)

II. Si el número es impar, entonces el sistema confirma que el dato es un


116

DÍGITO y luego el programa debe calcular y mostrar el factorial del ultimo dígito.

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 posición del carácter, formar la secuencia respectiva. Ver figura

11. Diseñar un Programa que permita leer un número entero n, en Base Decimal y devuelve su equivalente en el Sistema Binario. En la siguiente interface se ilustra el ejemplo:

12.Diseñar un Programa que permita leer un número entero n(n>1) en Base Binaria y devuelve el número expresado en en base Decimal. En la siguiente interface se ilustra el ejemplo

Definición. Un número perfecto es un número que es igual a la suma de sus divisores sin incluirse él mismo.

Así, 6 es un número perfecto, porque sus divisores propios son 1, 2 y 3; y 6 = 1 + 2 +3. Los siguientes números perfectos son 28, 496 y 8128.

Se deja al usuario, diseñar el programa que ingrese un número


117

hasta donde se desea procesar y el programa en forma aleatoria debe mostrar los números perfectos encontrados

12.Algunos números 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 número 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 número entero n tal que 1 ≤ n ≤ 2,000,000,000. Salida: Un número entero t.

13. Escribe un programa que determine el valor máximo p y el valor mínimo q que toma la función f(x) = (ax + b)/(cx + d) en los enteros que se encuentran en el intervalo dado por m y n (incluyéndolos). Observa que es posible que la función no este definida en todos los puntos de ese intervalo. Además, 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 números enteros a, b, c, d, m, n (con m ≤ n) separados por espacios y todos ellos en el intervalo de -1000 a 1000 (incluyéndolos). Puedes suponer que el intervalo m ≤ x ≤ n contiene al menos un entero x en el cual la función f(x) esta definida (y por lo tanto el máximo y el mínimo existen).

Salida: Dos números enteros r, s, separados por espacios.

14. Euclides y Euler: Dados dos enteros positivos p y q, su máximo común 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 máximo común divisor de p y q es igual a 1, entonces se dice que p y q son primos relativos. La función j(n) de Euler es igual a la cantidad de enteros en el intervalo del 1 al n que son primos


118

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 máximo valor m que toma la función j(n) de entre todos los enteros n en el intervalo de p a q, además 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 números enteros p y q tales que 1 ≤ p ≤ q ≤ 1,000,000. Salida: Un número entero m y un número entero n.15.Números menores que dos

mil: Imagine que tiene una lista de números 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 números enteros (todos ellos menores que dos mil) agrupando los dígitos tanto como sea posible desde el principio de la cadena. En nuestro caso, obtendrá la lista 314, 1592, 65 con p = 3 elementos. Después usted realiza la misma operación 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 dígitos encuentre cuantos elementos p y f contienen cada una de las listas.

Entrada: Una cadena s que contiene entre 1 y 1000 dígitos. Salida: Dos números 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 número entero n como diferencia de dos cuadrados a2 - b2 donde a ≥ b ≥ 0.

Entrada: Un número entero n tal que 0 ≤ n ≤ 1,000,000. Salida: Un número entero t.


119

16. Sumas de números consecutivos Escribe un programa que determine la cantidad f de formas en las que se

puede escribir un número entero positivo n como suma de uno o más números enteros positivos consecutivos. Tu programa también debe determinar el número más pequeño 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 número entero n en el intervalo de 1 a 1,000,000 (incluyéndolos). Salida: Dos número enteros f y p.

17. Puntos dentro de un triángulo: Considera un triángulo T dado por sus tres vértices (a, b), (c, d) y (e, f) con coordenadas enteras. Algunos puntos de coordenadas enteras están sobre los lados de T y otros puntos de coordenadas enteras están 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 vértices 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) están sobre los lados de T mientras que los 4 puntos (1, 2), (2, 3), (2, 4) y (3, 3) están dentro de T.

Entrada: Seis números enteros a, b, c, d, e, f separados por espacios y todos ellos en el intervalo de -1000 a 1000 (incluyéndolos). Puedes suponer que los tres vértices de T no están alineados y por lo tanto forman un triángulo.

Salida: Dos números enteros s y t separados por un espacio.

18. Boletos por besos: Para ir hacia su escuela, Juan aborda un camión. Cuando Juan sube al camión y deposita las monedas en la alcancía, el conductor le da un boleto con un número de serie consecutivo, el cual generalmente llega a la basura. Sin embargo, un día el se entera de algo interesante. Si la suma de los dígitos de dicho boleto es 21, el lo puede cambiar con quien quiera por un


120

beso. Juan quiere conseguir muchos besos de la persona que esta enamorado y ella ha aceptado dárselos a cambio de dichos boletos, pero no es tan fácil 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 después 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 número n de 7 dígitos, le proporcione el número p de personas que deben abordar después de el para que obtenga el boleto deseado y m, donde m representa los 7 dígitos de dicho boleto. Cuando un tiraje de boletos termina, es decir llega a 9999999, el conductor toma otro tiraje comenzando nuevamente en el número 0000000.

Entrada: Un número entero n de 7 dígitos (que posiblemente comienza con ceros).

Salida: Un número entero p y un número m de 7 dígitos.

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 sucesión numérica 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 sucesión. Los brincos siempre serán paralelos a los lados de la mesa y siempre deberán alejar a la pulga de su posición inicial. Lo ideal es que la pulga logre llegar a la esquina contraria de la mesa. Sin embargo, basta con que llegue a una posición 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 sucesión 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 podría lograr su objetivo si su sucesión de brincos fuera arriba, arriba, derecha, arriba, nada, nada y derecha. Por otro lado, si su sucesión fuera arriba, arriba, derecha, nada, nada, nada, nada entonces no llegaría a la esquina contraria pero tampoco se saldría de la mesa.

Entrada: El archivo de texto nts.ent contendrá un renglón con tres enteros n, a y b separados por espacios seguido de un renglón con n enteros positivos s1, s2, ..., sn y separados por espacios. Puedes suponer que todos estos enteros están en el rango de 1 a 1000, incluyéndolos.


121

Salida: El archivo de texto nts.sal deberá contener un renglón con tres enteros n, c y d separados por espacios seguido de un renglón 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.

Evaluación: 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 obtendría 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. Diseñar 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 cuántos números comunes

están en la misma posición y cuántos valores comunes están en distinta posición.

Ejemplo: 3786 y 8760 → uno colocado (el 7) y dos descolocados (8 y 6) • Se terminará el programa cuando el jugador acierte la combinación o haya

agotado sus intentos (constante MAXINTENTOS con valor 10)


122


123

ObjetIvOs

* Definir estructuras de datos.* Definir estructuras de datos tipo listas. Sus aplicaciones.* Aplicar operaciones con vectores: métodos de ordenación, inserción,

eliminación, búsquedas, crear sublistas, etc. Aplicaciones.* Definir arrays bidimensionales.* Definir arrays multidimensionales.* Cómo se almacena arrays en memoria.

Capítulo III

estructura de datos arrays


124

3.1 IntrOduccIón

Los tipos de datos escalar (enteros, reales, booleanos, carácter, subrango y definidos por el usuario) se denominan tipos simples, su justificación 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 técnica 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 volúmenes de datos con arreglos y después de sus procesos (consultas, búsquedas, ordenamientos, etc.) estos se perderán. La justificación radica que los arreglos solo se realizan en memoria RAM (memoria de acceso aleatorio).

La declaración siguiente: int a,b;

Se está estableciendo simplemente que a,b son dos variables no relacionadas que tomarán 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 subíndice entero único que lo identifica.

declaración de un arreglo de una dimensión

Un array de una dimensión (vector o lista) en C++ se declara de la siguiente manera:

tipo nombre[tamañol], en donde:

tipo: es el tipo de datos que conforman el array

nombre: es el identificador de todo el array

tamaño: indica el máximo número de elementos (entero), menos 1, que pueden almacenarse en el array. La justificación radica que en todo arreglo en C++ el primer elemento es cero (0), pero usted puede definir dónde iniciarlo.

Ejemplo: Int notas[20]declara un array notas con 20 elementos enteros, cada uno de los cuales de referencia por su subíndice (notas[0], notas[1], notas[2]...notas[19]) notas[ 20]

125

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.

Inicialización de un arreglo

1. Se puede inicializar un array con la declaración:

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 tamaño del array:

float lista[ ] = { 1.0,5.1.10.4} //Declara un array de tres elementos

Función de acceso

Permite acceder a un elemento específico (í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]!=’.’

[ 0 ] [ 1 ] [ 2 ] [ 3 ] [ 18 ] [ 19 ] índice

12 11 09 15 ........ 11 08 02 12

126

restricción:

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 verificación de límites de un array,es decir; no se genera un

error de compilación cuando se referencia aun elemento inexistente en éste.

3.3 OPeracIOnes cOn vectOres

La aplicación 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 número.

Las tareas sobresalientes son:

1. Reporte de elementos de la lista2. Insertar elementos en alguna posición de la lista3. Eliminar elementos4. Ordenar elementos en forma ascendente o descendente5. Búsqueda de un elemento6. Fusión o intercalación de dos listas7. Formar sublistas a partir de una lista

aPlIcacIOnes

Problema 1. Diseñar 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.

Solución // 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++)

127

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. Diseñar 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 prácticas.

Solución //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]; }

128

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. Diseñar un programa que permita leer números enteros y almacenarlo en un vector de longitud n, luego generar un reporte de los elementos ordenados en forma ascendente.

Solución. // vect_orden.cpp- Se usará el método de la burbuja, el cual permite realizar comparacio-nes sucesivas de sus elementos.#include<iostream.h># define max 10void 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. Diseñar un programa que permita leer números 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 máximo y el mínimo, según parte b) y luego solicitar al usuario que ingrese el número de elementos a insertar en este vector. Generar un reporte para conocer los elementos respectivos.

129

Solución //vectores_max_min.cpp#include<iostream.h> //defina otras loibrerias#define max_elem 100void 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];}

130

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 según b) y dos elementos nuevos insertados.Finalmente se obtiene el vector MaxMin

Problema 5. Diseñar un programa que permita leer números enteros y almacenarlo en un vector A de longitud n, luego:

a. Generar un reporte del total de elementos eliminadosb. Generara un reporte de los elementos del vector sin repetirse

Solución // vector_Repetido.cpp#include<conio.h> // defina otras librerias# define max 100void 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 ASCENDENTEfor (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];

131

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. Diseñar 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’}

Solución / 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();}

132

Problema 7. Diseñar un programa que permita ingresar caracteres (letras) desde el teclado. Luego mostrar:

a. El número de veces que se repite la letra “ a”.b. El número de veces que se repite la palabra “ uni”c. Elementos vector sin repetirse.

Solución // vector_uni_veces.cpp#include <iostream.h>#define max 200void 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 UNIif (contU<contN)if (contU<contI) menor=contU; elsemenor=contI;else if (contN<contI) menor=contN; else menor=contIfor (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; }}

133

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. Diseñar un programa que permita ingresar números 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 vectorb. Insertar según posición espefificada por usuarioc. Insertar al final, cuando los datos están ordenados

Solución //vect_inse.cpp#define linea “-------------------------------”#define max_el 50void main() { int a[max_el], n, i, dato; char opc,resp=’S’; while(resp==’S’ || resp==’s’) {clrscr();

134

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 posición válida

do { cout<<»\nIngrese posicion = «; cin>>pos; } while ((pos<0)||(pos>n+1));

//Empujar los elementos desde a[pos] hasta el finalfor (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;

135

} //Fin de switch } //Fin de elsegotoxy(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. Diseñar un programa que permita leer n alumnos (n ingresado por usuario ) y por cada alumno ingrese su práctica, luego generar un reporte que permita mostrar el promedio de prácticas de los n alumnos.

Solución //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. Diseñar un programa que permita leer datos de tipo entero y almacenarlo en un vector, luego generar un reporte sin elementos repetidos.

Solución //vect_sin_el_rep.cppvoid main ( )

136

{ 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. Diseñar un programa que permita leer datos de tipo entero y almacenarlo en un vector, luego generar un reporte que permita conocer:

a. Número de elementos eliminados (cuando se repiten)b. Total de elementos que quedan en el vector, después de a)c. Reporte ordenado de los elementos del vector después de ejecutar a)

Solución // vector_Repetido.cpp#include<iostream.h># define max 100void 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 ASCENDENTEfor (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);

137

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. Diseñar 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 vectorb. Elementos de un vector b[ ], que contiene números pares e impares positivosc. Elementos de un vector b[ ], que contiene números pares e impares negativos d. El número positivo mayore. El número menor negativo

Solución //vect_copiar.cpp#include<iostream.h># define linea “-----------------------------------------------------”# define max_el 60void 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++)

138

{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. Diseñar 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].

139

Solución //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. Diseñar un programa que permita leer datos de tipo entero positivos y almacenarlo en un vector a[ ], luego buscar los elementos múltiplo de 5 y no de 2 y almacenarlo en un vector m[ ], mostrar sus elementos, la suma de éstos, así como su promedio.

Solución //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]; }

140

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. Diseñar un programa que permita leer n alumnos, definido por usuario, luego genere reportes para conocer:

a. Promedio generalb. Promedio de desaprobadosc. Promedio de aprobadosd. Total alumnos con nota 20

Solución //vect_not_20.cpp#include<iostream.h> //defina otras librerias#define max 16void 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++)

141

{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. Diseñar 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 deri-vada: P’(x0) y en la segunda derivada: P’’(x0).El polinomio es de la forma : Pn (x) = P0 + P1x + P2x2 + P2x3 +....+ Pnxn

Solución //vect_Polinomio.cpp#include<conio.h># define max_coef 50void 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 : “; cin>>n;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);

142

}}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. Diseñar un programa que permita leer un número entero positivo y luego retornar su equivalente en letras.

Solución //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 número menor que 100000: “;cin>>Num;if (Num<100000){cout<<”El número 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%100-c)/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<200if (b>0) if (b==1) cout<<Diez[c]<<” “; //si 10<Num<20else cout<<Decena[b]<<» «; //si 1<b<10

143

if (c>0) { //imprime las unidadesif (b>1) cout<<»y «; if (b!=1) cout<<Unidad[c]<<» «; } } if (Aux>=1000) cout<<Millar<<» «; else break;Num=Aux%1000;} }elsecout<<”Lo siento, número fuera de rango”; getche();cout<<”Deea continuar..?(S/N) —>";cin>>resp; clrscr(); } }

Problema 18. Usando estructuras de control, diseñar un programa que permita leer n alumnos (n>0 y n<=100) por código y nota, respectivamente, los códigos están formados sólo por tres dígitos y las notas sólo son válidas de 0...20, inclusive. Luego genere los siguientes reportes para conocer:

a. Mayor notab. Código, posición y número de veces que se repite la mayor notac. Secuencia de códigos y secuencia de notas respectivas (de la mayor)

Análogamente identificar la menor nota y realice los procesos anteriormente solicitados para la menor nota.

Ejemplo. Considere los datos de la siguiente tabla:

144

Resultados

Solución. En la siguiente figura se ilustra la entrada de datos de cuatro alumnos por código y nota respectivamente. Se valida para que los códigos deben ser sólo de tres dígitos 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 códigos 400 y 200, ocupando las posiciones 4 y 2, respectivamente; asimismo, se forma la secuencia de códigos: 400200 y la secuencia de repetición de la nota mayor: 1616. Además, para la nota menor, tal como se observa en la gráfica de identificación de menor nota.

//vectorNOtasCod_parc_01.cpp# include <iostream.h >#define linea “_____________________”void main()

145

{ 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”;

146

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. Diseñar un programa que permita leer, para un grupo de productos, la siguiente información: código, tipo de producto (una letra) y el número de

147

unidades. Sabiendo que algunos productos se pueden repetir (el mismo código y tipo de producto) se pide:

a. Mostrar un listado de los productos (sin repetición) donde figure código, 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 número de unidades.

SoluciónDiseño del módulo de ingreso de productos por código, tipo (letra) y cantidad de productos. Debe validar que el código solo acepte tres dígitos, 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 código 100 y tipo A (arroz), entonces en el reporte final NO debe mostrarse repetido este código, pero si debe mostrar la suma acumulada (1200+800) del producto de tipo A, tal como se ilustra en la siguiente figura:

Solución//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 “;

148

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 códigos, tipo y cantidadfor (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 según Código 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 reportei=1; j=1; mayor=0;

149

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

Definición. Un array bidimensional es una estructura denominada matriz de orden m×n, considerado como conjunto rectangular de elementos aij dispuestos en m líneas horizontales (filas) y n verticales (columnas) de la forma:

En la práctica, se expresa en la forma A =(aij), donde i =1, 2, ..., n, =1, 2, ..., m.


150

Los subíndices indican la posición 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, carácter, etc.

SintaxisConstantes: max_f 100, max_c 100Tipo 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 máxima de elementos en las filas max_c : cantidad máxima de elementos en las columnas.

Observaciones1. Como todo índice de arreglos en C++ inicia en 0, entonces el número de ele-

mentos de arreglo bidimensional (puede generalizar para multidimensiona-les) queda denotado por (max_f +1) (max_c+1).

2. En general, se pude declarar arreglos multidimensionales, dependiendo del tipo de aplicación que usted desea resolver. Si fuera de orden 3, tendríamos 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

151

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 ele-mento de la matriz debe referenciarse mediante sus índices (subíndices) Así, Lista[ 3 ] [ 2 ] = 9 Lista[ 1 ] [ 1 ] = 4Lista[ 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 im-portadora de vehículos tiene dis-tribuido tres tipos de vehículos en tres almacenes diferentes, tal como se ilustra en la siguiente figura:

Diseñar un programa que per-mita leer el número de tipos de vehículos y el número de almacenes (puede usted generalizar para n filas y m columnas), luego generar reportes para conocer:

152

a. Total de vehículos por tipob. Total de vehículos en cada almacénc. Total de vehículos de la empresa

Solución //almacen.cpp# define max_vehic 100// 100 vehiculos como maximo# define max_almac 200 // 200 almacenes como maximovoid main() {int almacen[max_vehic][max_almac],i,j,x=5,y=10,m,n;float suma=0,tv=0; clrscr(); //leer datosgotoxy(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;

153

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; suma=0; } } //totalcout<<”\nTotal de Vehiculos de la empresa :”<<tv<<endl; getch();}

Problema 2. (Análogo al problema 1), con la diferencia que presenta la fecha del sistema en pantalla y se pide, además, los siguientes reportes para:

a. Total de vehículos, por tipo, distribuidos en los almacenesb. Total de vehículos por cada almacénc. Cantidad mayor de vehículos, por tipo, en uno de los almacenesd. Crear un vector cant_por_al[ ], que permita copiar los resultados según b)e. Crear un vector cant_tip[ ] que permita copiar los resultados según a)f. Usando los vectores según 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 según vector sump[] de parte f)

Solución //matriz_alm_2004.cpp#include<iostream.h> # define maxf 10 # define maxc 10void 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]; }

154

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++; }

155

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. Diseñar 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.

Solución //matriz_notas.cpp#include <iostream.h>#define maxf 50#define maxc 50void 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 promediosfor(i=1;i<=n;i++)

156

{ 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 promediofor(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]; //Nombrescout<<setiosflags(ios::showpoint+ios::right);cout<<setw(22)<<setprecision(2)<<prom[i]<<»\t»; //Promediosif (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

157

2. Reportes

Problema 4. Diseñar un programa que permita leer información 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 sección s, ingresado por el usuario.

Solución //matriz_obreros#include<iostream,h>#define max 10void 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;

158

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. Diseñar un programa que permita ingresar números 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 principalb. La suma de la fila ingresada por el usuarioc. La suma de la columna ingresada por el usuariod. La matriz ordenada por columnas

Solución /* matrices_ord.cpp */#include<iostream.h>void main()

159

{ 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:

160

Problema 6. Diseñar un programa para que una matriz, primero, permita ingresar el número de tipo de productos (en este caso arroz y fideos), luego ingresar el número de distritos (en nuestro caso 2: Lima y Lince). A continuación debe ingresar las cantidades de productos por tipos en los distritos. Luego se pide:

a. Calcular en forma automática 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 distri-tos.

Solución //mat_EXAMEN2.cpp#include<iostream.h>#include<conio.h>#define maxf 50 #define maxcol 50int 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]; ç

161

}for(i=0;i<m;i++) {gotoxy(3,5+i);cout<<nomd[i]; } //lectura de datos en la matrizfor(i=0;i<n;i++) for(j=0; j<m;j++) { gotoxy(15+10*i,5+j);cin>>a[i][j];} //calculando por tiposfor(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; //ordenandofor(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 verticalfor(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;

162

} } }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(); }

Después de ingresar datos, debe presionar ENTER para mostrar en forma automática los cálculos 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.

163

Problema 7. Diseñar un programa que permita leer el número de filas y el número de columnas de longitud máximo 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.

Solución // 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(); }

164

Salida

Problema 8. Diseñar un programa que permita leer el número de filas y el número de columnas de longitud máximo 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.

Solución //mat_diag.cppvoid 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 principalsuma=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;

165

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. Diseñar un programa que permita ingresar números enteros en una matriz de orden 3*3, luego mostrarlo en forma ordenada por filas (las filas debe ir ordenándose en forma secuencial y ascendente).

Solución //mat_ord_fil.cppvoid 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();}

166

Problema 10. Diseñar un programa que permita ingresar el número de filas y columnas, luego ingresar datos de tipo entero y mostrar:

a. La matriz ordenada por filasb. La matriz ordenada por columnasc. La suma acumulada por filas y por columnasd. Mostrar el valor mínimo y máximo de cada fila

Solución //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 columnasfor( 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;

167

} }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 m ximo y m¡nimo de cada fila son:”<<endl;for(i=0;i<m;i++)cout<<”Enfila”<<(i+1)<<”, el m¡nimo es: “<<A[i][0]<<”y el m ximo es: “<<A[i][n-1];cout<<endl<<”Pulse una tecla para continuar ...”<<endl; getch();}

168

Problema 11. Diseñar un programa que permita ingresar el número de filas y columnas de una matriz, tal que permita ingresar números 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.

Solución //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);

169

cout<<”v[“<<k<<”]=”<<v[k]<<endl; }getch();}

Problema 12. Diseñar un algoritmo y el programa correspondiente que al leer un número entero n en base 10, determine si existe otra base de numeración b, en la cual el número es escrito con sus cifras al revés. En caso afirmativo, mostrar la base b y el número en dicha base (b ≠10). n debe tener por lo menos dos cifras y la última de ellas será siempre significativa.

Solución //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;

170

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 año pasado. Se tiene nueve destinos desde donde pueden venir o llegar dichos vuelos y cinco aerolíneas a los cuales pueden pertenecer los vuelos (llamémosla A, B, C, D, E). Se desea saber el mes en el cual llegaron o partieron más vuelos al aeropuerto, la aerolínea que realizó el mayor transporte de pasajeros entre enero, febrero, marzo y los dos destinos más concurridos por las aerolíneas C, D, E.

Solución //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<<”N£mero 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<<” :”;

171

for(k=0;k<9;k++) { cout<<”Ingrese el n£mero de vuelos desde “<<k+1<<” :”; cin>>vuelos[1][i][j][k]; for(l=0;l<vuelos[1][i][j][k];l++) { cout<<”N£mero 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<<” :”;}


172

Parte I. Lectura de datos

Parte II. Registro de llegadas de pasajeros

Problema 14. Diseñar un programa que permita leer n alumnos (n ≤ 200) y por cada alumno, leer código y ocho notas de prácticas calificadas, luego se pide:

a. Calcular el promedio de prácticas (PP) eliminando las dos notas más bajasb. Mostrar el cuadro de méritos con los siguientes datos: código, las ocho notas

de prácticas y el promedio de prácticas (PP)

SoluciónDiseño del módulo de ingreso de alumnos por código y ocho notas. Se debe validar los códigos que estén compuestos por tres dígitos y las notas sean válidas sólo en el rango del 0 al 20.

173

Solución //matriz_notas_prac_02.cpp# include <iostream .h>#define linea1 “____________________”#define linea”-------------------------------------------------------”#define maxal 100void 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 interactivawhile(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 pro-mediofor(i=1;i<=n;i++)

174

{ 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]];

175

} gotoxy(6,16+i);cout<<linea; gotoxy(30,23); cout<<»Sr. desea continuar ?...(S/N)»; cin>>resp;}// Debe actualizar las variables }

Problema 15. Diseñar un programa que permita ingresar números 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:

Solución //matriz_espiral.cpp#include <stdio.h># define linea “___________________________”#define taman 20void 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; }

176

} } k = 0; for (i=0;i<n;i++)for(j=0;j<n;j++){ matriz[i][j] = temp[k];k ++;}//inicialización de variablesfarribaizq =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\t”linea;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]; }

177

x +=6; } y += 1; x = 10; cout<<”\n”; }cout<<” \n\n\t “;system(“pause”);}

Problema 16. Diseñar 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 (número 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 Almacén[ ] los totales en almacén2. Almacenar en un vector Total para Producto Tipo[] los totales por producto3. Mostrar en un vector los elementos todos tipos enteros tanto para Total en

Almacén[ ] como para Total para ProductoTipo[ ]4. Según la parte 3, mostrar los elementos repetidos, los elementos que quedan y

la secuencia

Solución. En la siguiente figura se ilustra el proceso de datos.

178

a. En la parte 1 y 2 simplemente vamos almacenando los subtotales, conforme vamos almacenando los precios hasta completar los vectores totales tanto de almacén 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, añadimos una unidad a la parte de las unidades, sino, no efectuamos nada y en ambos casos copiamos a los vectores tipo entero correspondientes a almacén como a tipo producto.

c. Para la parte 4, quizá la parte más compleja, en una sola operación evaluamos el i-ésimo elemento de los vectores enteros tanto como para almacén 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 almacén 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_almacenfor(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_tipofor(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

179

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 recondeocout<<”\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 recondeocout<<”\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

180

los elementos //repetidos en el vector eliminados_alz=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_tipozz=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];

181

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 repetidoscout<<”\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 repetidoscout<<”\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_Entcout<<”\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_Entcout<<”\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;}

182

Problema 17. El cartero de una zona campestre debe de entregar cartas en n casas de una región. 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, además, 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.

Solución // 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);

183

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 ] [ 2 ] [ 3 ] [ 18 ] [ 19 ] índice

12 11 09 15 ........ 11 08 02 12

Bidimensionales

Multidimensionales

Para caso: secciones, alumnos y notas


184

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 matrícula de alumnos), se debe identificar el dato y su índice lógico (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 envía los mensajes indicando el “número de repeticiones”, así como “ubicación del índice en la posición 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 posición i-k.(k>1).

En la siguiente interface se ilustra los procesos de la secuencia de datos repetidos, número de intentos (errores) y la posición donde se localiza el dato repetido.

Finalmente, en este formulario se genera el proceso de identificación 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 código de usuario (alumno, empleado, ciudadano, vehículo, etc.) durante el proceso de registro de datos en el sistema informático. Este proceso se conoce con el nombre de “ Algoritmo del Módulo 11” , el cual consiste en que el usuario ingresa un número entero (defina el tamaño) y luego se descompone en la suma de factores de


185

multiplicación usando los dígitos desde 2 hasta 9, y al resultado se extrae el resto, a este se le asigna una letra “ABCDEFGHIJK “(vector cadena), según resultado del resto.

Ejemplo: Generar código de dos empleados, código registrado en la base de datos del sistema de planilla de la universidad.

I. Empleado 1: Monzón Ingrese código: 838509 Suma de factores = 8*2 +3*3+ 8*4 +5*5+0*6+9*7 = 145 Módulo 11 = 145%11 = 2 Asignación de letra = ‘C’ Código generado: 838509C

II. Empleado 2: Córdova Ingrese código: 848139 Suma de factores = 8*2 +4*3+ 8*4 +1*5+3*6+9*7 =146 Módulo 11 = 164%11 = 3 Asignación de letra = ‘D’ Código generado: 848139D

Módulos:1. Longitud (): para registrar el nú-

mero de empleados.2. Lectura (): permite leer códigos de

empleados sin repetirse.3. Módulo 11 (): función que devuel-

ve letra.

Procedimientos:1. Lectura de total de empleados.2. Registrar a empleados por código y apellidos. En este módulo se valida el

código y luego se busca el resto del módulo 11 y, usando la función módulo 11 (), se asigna la letra correspondiente. En las siguientes interfaces se ilustra los resultados.

186

sistema académico 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 prácticas, tres exámenes: parcial, final y sustitutorio) de la siguiente manera:

Registro de datos: se debe registrar máximo 1000 alumnos, y por cada alumno leer su código (único: se debe generar usando el algoritmo del módulo 11, el cual se usa en la UNI), apellidos paterno y materno (cadenas de 20 caracteres). Por alumno debe registrar: número de asignaturas identificadas por código (4 códigos distintos y que identifican cuatro áreas diferentes en la FIIS ): Sistemas (ST<3 dig>). Gestión (GP< 3_digs>), Tecnología (TP<3 dig>), Ciencias básicas ( CB<3 dig>) y nombre (cadena: 40 caracteres) y para cada asignatura leer el número de secciones (máximo 5, que son caracteres: A,B,C,D,E) y por cada sección leer el número de prácticas (máximo 5) y exámenes (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 código, secciones y sus notas respectivas.

2. Listado por nombre de asignatura, secciones, apellidos de alumnos y su sus notas (solo prácticas), su promedio de prácticas, eliminando la menor nota.

3. Listado por nombre de asignatura, secciones, apellidos de alumnos y sus no-tas (8), su promedio (eliminando la menor nota) de prácticas, promedio final (considere prácticas, 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 no-tas (8), su promedio (eliminando la menor nota) de prácticas, promedio final (considere prácticas, parcial, final y examen sustitutorio, el cual reemplaza a la menor nota de los exámenes respectivos) y el estado A: aprobado, D: desapro-bado. Adicionalmente enviar el mensaje “con sustitutorio”.

5. Listado por nombre de asignatura, secciones y su promedio por sección.6. Listado de alumnos del tercio superior en cada sección y apellidos. 7. Listado de alumnos por apellidos, ordenados en forma ascendente por sección.8. Promedio general institucional (use promedios de secciones).9. Sección con mayor promedio y sección con menor promedio de la asignatura

correspondiente.10.Total de alumnos desaprobados (promedio final >10) y aprobados (promedio

final<11) por asignatura y sección (mostrar cantidad, nombre de asignatura y sección correspondiente).

Problema 4. Diseñar un programa que permita leer n y m elementos para vectores A y B de tamaño 100, respectivamente, luego genera el reporte que permita mostrar los elementos interceptados y su posición que ocupa el elemento en cada vector.

187

SoluciónEn 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. Diseñar 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 cuadrático o más.

Problema 6. Diseñar un programa que permita almacenar n tipos de productos en m almacenes (n, m<=100) en una matriz de dimensión n y m, respectivamente. Los datos se deben generar en forma aleatoria con la condición que estén 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 ascen-

dente.c. Total de productos por tipo y

por almacén, respectivamente.d. Elementos de la matriz orde-

nados por filas en forma ascen-dente.

e. Producto con menor y mayor cantidad de unidades y la ubi-cación respectiva.

El programa debe ser interactivo con el usuario.


188

Problema 7. Diseñar un programa que permita realizar las operaciones combina-das de vectores y matriz.Leer la dimensión 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. Diseñar un pro-grama que permita leer la dimensión de una matriz de orden n*m y luego ingresar datos solo de dos dígitos, finalmente mostrar en forma invertida sus elementos.

189

Problema 9. SISTEMA DE GESTION DE ALUMNOS: Diseñar un programa que permita leer n alumnos(n>0, n<1000) por datos: código (entero solo tres dígitos), apellidos (cadenas[20]) y edad(edad>14, Edad<=70). Se debe validar el código de alumno en el contexo que “NO EXISTE CÓDIGOS REPETIDOS ”, pues, en la práctica, un código SOLO pertenece a un alumno o un alumno posee un ÚNICO código. El proceso consiste en leer el código del primer alumno y su apellido y, a continuación, leer el código del segundo alumno. A partir del segundo código se inicia la validación respectiva. En las siguientes interfaces, se ilustra los procesos de validación:

Cuando edita el código del segundo alumno y es igual al código del primer alumno, el sistema envía mensaje:

Código existe en posición 1 intento # 1

En el segundo intento, cuando edita código de segundo alumno y es igual al código del primer alumno, el sistema envía mensaje:

Código existe en posición 1 Intento # 2

Si este proceso se repite con igual código, el sistema enviará el mismo mensaje pero en k veces (k=3,4…)

Ahora, si el código del segundo alumno es diferente del primero, se puede editar código del tercer alumno, pero para este tercer alumno si se repite el código, entonces el sistema envía el mensaje:

“Codigo Existe en posicion 2 Intento # 1


190

Así continuará ingresando y validando código y sus apellidos respectivos, tal como se ilustra en la siguiente figura:

A continuación, genere listado de alumnos ordenados por apellidos en forma ascendente, mostrando su código y la posición inicial de cada alumno, este proceso como resultado se ilustra en la siguiente figura:

Problema 10. Diseñar un programa que permita ingresar un número 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).

191

arreglos unidimensionales

Problema 11. Solo se deben usar para que el usuario ingrese sus datos por código (solo de tres dígitos), 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 código, nom-bre y edad, respectivamente.

2. Empleados por nombre y edad, ordenados en forma as-cendente por edad.

Asimismo, mostrar la posi-ción 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 resulta-dos.

5. Retirar empleados que tiene edad mayor a 60 años.

arreglos bidimensionales

Problema 12. Diseñar un programa que permita almacenar cantidad de vehículos por marca (Toyota, Datsun, Honda, etc.) en almacenes ubicados en distritos (Lima, Lince, Rímac, etc.) y luego genere los siguientes reportes:

a. Total de vehículos por tipo y ordenados en forma ascendente. También se debe mostrar el tipo (nombre) correspondiente.

b. Total de vehículos en cada almacén y ordenados en forma ascendente.También se debe mostrar el almacén (distrito) correspondiente.

c. Vehículos ordenados en forma ascendente en la matriz.d. Nombre del almacén con mayor cantidad de vehículos, según tipo y posición

respectiva.e. Nombre del tipo de vehículo con menor cantidad y nombre del almacén co-

rrespondiente y su posición respectiva.


192

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. Diseñar un programa que permita inicializar en estructuras la siguiente información: 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 prácticas (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 sección res-

pectiva, así como promedio por sección.c. Reporte de sección con mayor promedio.d. Reporte de datos de alumnos, pero ordenados según sección.


193

Reporte de alumnos ordenados por sección

Sección 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 posición 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 línea)

Problema 16. Matriz con entradas en diagonalDados dos enteros m y n, diseñar un programa que construya una matriz con m filas y n columnas cuyas entradas sean los números 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.


194

Entrada: Dos números 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 común si Aij = Bij. Si además 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 máxima p y mínima q de entradas comunes cuando se permite girar o reflejar cualquiera de las dos matrices de cualquiera de las formas posibles.

Entrada: Un número entero n seguido de dos matrices A y B de n ´ n.

Puedes suponer que 1 ≤ n ≤ 100

Salida: Un número entero p y un número 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 tamaño 1 en alguna dirección, luego un paso de tamaño 2 en alguna dirección, después un paso de tamaño 3 en alguna dirección, 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. Diseñe un programa que te ayude a encontrar un posible camino de (0, 0) a (a, b) que cumpla esas condiciones.


195

Entrada: Dos números enteros a y b tales que -1,000 ≤ a, b ≤ 1,000.

Salida: Un número entero n seguido de n parejas de enteros xi, yi separados por espacios, las cuales corresponden con los n puntos a los que llegas después de cada paso.

Evaluación: 1 punto si la n pasa indicada cumplen las condiciones pedidas. En ese caso, 5m/n puntos adicionales, donde m es la cantidad mínima de pasos necesaria para llegar de (0, 0) a (a, b). El primer ejemplo recibiría 1+5*3/3 = 6 puntos mientras que el segundo recibiría 1+5*3/7 = 3 puntos.

Problema 19. Matriz con entradas en espiralDados dos enteros m y n, diseñe un programa que construya una matriz con m filas y n columnas cuyas entradas sean los números 1, 2, ..., m*n acomodados en espiral, comenzando con el número 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 números enteros m, n, separados por un espacio, cuyos valores están entre 1 y 100 (incluyéndolos).

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 cuadrícula de m por n tiene pintado cada uno de sus cuadritos de alguno de k colores. Estos cuadritos a veces forman cuadrados más grandes donde todos los cuadritos son del mismo color. Escribe un programa que determine

196

la longitud g del lado más grande de cualquiera de estos cuadrados. Además, tu programa deberá determinar la cantidad c de cuadrados de ese tamaño y el número d de colores distintos en los que existan cuadrados de ese tamaño. 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 números enteros m, n y k en el intervalo 1 a 100 (incluyéndolos) seguidos de m renglones con n enteros cada uno en el intervalo 1 a k (incluyéndolos).

Salida: Tres números 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 código SOLO pertenece a un Alumno. El programa consiste en leer el Código de primer alumno y luego leer código de segundo alumno. Luego compare si estos códigos son iguales entonces enviar el mensaje ”Código ya Existe” . Ante este mensaje el sistema le solicita que ingrese nuevo código, nuevamente se coinciden vuelve a emitir el mensaje hasta que Ud. Ingrese código diferente al primero. Así continua la validación. Ver la siguiente grafica:

Problema 22. Diseñar un programa que permita ingresar datos de n alumnos (n<=1000) por código, apellidos, nombres y edad, respectivamente, luego genere los siguientes reportes que permita conocer datos procesados tal como se ilustra en la figura adjunta.


197

1. Ingreso de Registros2. Reporte Ordenado de Registros

por Apellidos Permite ordenar los registros por

apellidos en forma ascendente3. Insertando Registros. El usuario

ingresa el número de registros que desea insertar, para lo cual el sistema totaliza la cantidad total n) de registros que existen y envía 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. Eliminación de Registros. El usuario ingresa el número del Registro que desea eliminar, luego del proceso de eliminación el sistema envía el mensaje de confirmación, asimismo indicando la cantidad actual de registros.

6. Reporte de registros después de eliminar. Permite mostrar la cantidad actual de registros en el sistema

7. Reporte de registros ordenados por Código. Como observa en


198

opción 6 y después del proceso de inserción, los registros no están ordenados por código. En el siguiente proceso se ilustra la ordenación por el campo código y en forma ascendente.

8. Reporte de registros ordenados por Apellidos después de ordenar por Código. Permite ordenar nuevamente por apellidos en forma ascendente.

9. Buscando edades. Este módulo permite al usuario realizar el proceso de búsqueda de registros según el dato edad, si existe totaliza y envía el mensaje respectivo. En otro caso indicará que no existen registros con la edad buscada.


199

ObjetIvOs

- Comprender cómo funciona el procesamiento de cadenas.

- Definir la longitud física de una cadena.

- Establecer el dato de usuario con nombre de la cadena.

- Definir vector cadena.- Definir vector de cadenas.- Usar funciones de comparación

(strcmp), convertir caracteres a mayúsculas (strupper), etc.

- Funciones para el tratamiento de cadenas: strlen(), strcat().

- Copia de cadenas: stpcpy(), strcpy(), strncpy().

4.1 IntrOduccIón

Una cadena de caractereses una secuencia de cero o más símbolos que incluyen letras, dígitos y caracteres especiales o es un arreglo de caracteres que, en el caso de C++, debe terminar en el carácter nulo (‘\0’). Una cadena puede representarse, o bien como un array común (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 código 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++

las cadenas de caracteres

Capítulo 4

200

Sintaxis char cadena[30]; //Cadena de 30 caracteres + ‘\0’;Se puede omitir la longitud de la cadena en la declaración si es que también 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 posición en memoria de su primer carácter.

Sintaxis:char *cad1; en donde cad1 es el nombre de la cadena- cad1 o cad1[1]: es el primer carácter de cad1- (cad+1) o cad1[2]: es el segundo carácter de cad1- (cad + -1) o cad1[i]: es el i–ésimo carácter de cad1

Problema 1. Diseñar un programa que permita leer una cadena y luego imprimir el primer carácter.

Solución //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.

Solución //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º caráctercout<<cad2<<” “<<cad3; //imprime “Curso Algoritmos, Estudien, Estudiengetche() ;}

201

Observación:

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 carácter

Notas: 1. Sólo con punteros a cadenas (char*) se puede hacer la asignación de cadenas

con el símbolo =, pues en este caso, nos referimos únicamente al primer carácter de la cadena.

2. El flujo cincuenta con un método getline, que es más 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 número máximo de caracteres a considerar en la entrada.

Generalmente se usa el formato sizeof(cadena) para leer una cadena cuyo tamaño máximo es desconocido.

Escape: es el carácter con el cual terminará la lectura de la cadena. Es opcional.3. Se puede acceder individualmente a cada carácter de la cadena, como en un

arreglo, llamándolo por su índice, el cual representa su posición en la cadena.

Problema 3. Diseñar un programa que permita convertir una cadena escrita en letras minúsculas a letras mayúsculas.

Solución //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(); }

202

4.3 FuncIOnes Para el tratamIentO de cadenas strlen() y strcat()

Strleng(). Devuelve el número de caracteres de una cadena.

Sintaxis: size_tstrlen (constchar*s)

Problema 1. Diseñar un programa para conocer la longitud de la cadena inicializada.

Solución //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();}

concatenación de cadenas

Función strcat()

Permite concatenar (unir) dos cadenas leídos e inicializadas por usuario.

Sintaxis: char*strcat (char*cad1, constchar*cad2)

Problema 1. Diseñar un programa que permita leer dos cadenas: cad1[50] y cad2[20], luego imprimir la cadena concatenada.

203

Solución //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. Diseñar un programa que permita leer dos cadenas de longitud n y m, respectivamente; luego las dos cadenas mostrarlas en forma concatenada, convertirla a mayúsculas, mostrar en forma invertida y finalmente, la cadena invertida mostrarla en su estado de origen (al estado en que se realizó la conversión a mayúsculas).

Solución //cadena_invertida.cpp#define max 80voidmain(){ 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 mayúsculas x1[lon]=’\0’; //para fin de cadena }cout<<”\n La concatenación en Mayúsculas es : “<<x1<<endl;inv=strrev(x1); //para invertir cadenacout<<”\n La cadena invertida en mayúsculas 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();}

204

Problema 3. Diseñar 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 carácter sean todos expresados en mayúsculas.

Solución //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 minúsculas y mayúsculas:”<<cad1; getche();}

Ejemplo:Ingrese una cadena:Lenguaje de programaciónSalida de la cadena en mayúsculas y minúsculas:leNGUAJES DE PROGRAMACION

4.4 cOPIa de cadenas: FuncIOnes stPcPy(), strcPy(), strncPy()

Para el funcionamiento de estas funciones, se usa la librería: <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 carácter de cad1 y stpcpy() devuelve un puntero al último carácter de cad1.

La función strncpy() funciona igual que strcpy(), con la diferencia de que copia solo un número máximo n de caracteres definidos por el usuario; strncpy no

205

añade al final de cad1 el carácter nulo, por lo que se debe definir para el correcto funcionamiento del programa.

char *strncpy(char *cad1, constchar *cad2, size_t n)

Problema 1. Diseñar un programa que permita leer una cadena cad2, de longitud máxima 50 y luego:

a. Copiar información de cad2 en un vector cad1b. Imprimir a partir del tercer carácter y hasta el finalc. Imprimir solo los tres primeros caracteres

Solución // 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 cad1gotoxy(2,4);cout<<”Cadena completa :”<<cad1;strncpy(cad1,cad2,12); // solo imprime los primeros 3 caracterescad1[3]=’\0’; // selecciona los 3 primeros caracteres, el resto es =0gotoxy(2,6);cout<<”Primeros 3 caracteres de cad2 : “<<cad1<<endl;stpcpy(cad1,cad2+3); //impresión a partir del cuarto caráctergotoxy(2,8);cout<<”Impresión a partir del 4 carácter y hasta el final:”<<cad1;getche() ;}

Problema 2. Diseñar un programa que permita leer una cadena cad1 de longitud máxima 50 y luego imprimir a partir del octavo carácter. (Use asignación de variables tipo cadena).

Solución //cadena4.cpp#include<iostream.h>voidmain(){ char cad1[10], *cad2, *cad3;gotoxy(2,2); cout<<”ingrese cadena1 :”; gets(cad1);

206

cad2=cad1; //Asigna cad1 a cad2gotoxy(2,4); cout<<”valor de cad2, copiado de cad1 :”<<cad2<<endl; cad3=cad1+7; //Asigna a cad3 la cadena cad1 desde su 8º carácterºgotoxy(2,6);cout<<”\nReporte a partir del 8 carácter: “<<cad3<<endlgetche();}

4.5 FuncIOnes Para buscar un carácter en una cadena

1. Función strchr()

Devuelve un puntero a la cadena que comienza a partir de la primera aparición de un carácter especificado en una cadena cad. Devuelve 0 si no se encuentra el carácter.

2. Función strrchr()

Hace lo mismo que strchr, pero busca la última aparición de un carácter c en lugar de la primera.

Sintaxis:char *strchr(const char *s, int c),char *strrchr(const char *s, int c);

Problema 1. Diseñar un programa que permita leer dos cadenas: cad1[50] y cad2[20] y copiar en cad1 la información de cad2. Luego ingresar un carácter de búsqueda, si el carácter se encuentra en la cadena, este envía el mensaje “el carácter está en la posición”. En otro caso “el carácter no se encuentra”.

Solución //cadena50.cppIntmain(){ 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 buscacout<<”\ncadena resultante al especificar el carácter de búsqueda :”<<ptr<<endl;cout<<”\ntoda la cadena :”<<cadena1<<endl;

207

if (ptr)cout<<”\nElcaracter “<<busca<<” esta en la posición: “<<(ptr-cadena1);else cout<<”\n El caracter “<<busca<<” no se encuentra: “;return 0;getche();}

Problema 2. Diseñar un programa que permita inicializar una cadena cad[]= “universidad”, luego genere reportes para conocer la posición del primer carácter “i” e imprima el resto de la cadena. Asimismo, del segundo carácter “i” la posición y el resto de cadena.

Solución //cadena6.cpp#include<iostream.h>voidmain()

{ charcad[ ]=”universidad “;char *resp;gotoxy(2,2);cout<<”Cadena original: “<<cad;resp=strchr(cad,’i’);//identifica primer caracter igotoxy(2,4);cout<<”El 1er ‘i’ se encuentra en la posición: “<<(resp-cad) ;gotoxy(2,6);cout<<”Cadena resultante = “<<resp;resp=strrchr(cad,’i’); //identifica segundo caracter igotoxy(2,8);cout<<”El ultimo ‘i’ se encuentra en la posición: “<<(resp-cad);gotoxy(2,10);cout<<”Cadena resultante = “<<resp;getche() ;}

208

4.6 FuncIón Para recOnOcImIentO de una POrcIón de cadena

1. Función strspn()

Localiza la posición del primer carácter 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. Diseñar 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.

Solución//cadena7.cppvoidmain(){ char * cad1=”La universidad”; char * cad2=”La un “;int p;

p=strspn(cad1,cad2); //p == 5gotoxy(2,3);cout<<”la segunda cadena coincide hasta el valor de :”<<p<<endl;cout<<cad1+p; //Visualiza “ cadena iversidad” getche() ; }

2. Función strcspn()

Localiza la posición de la primera aparición de cualquier carácter de una cadena cad2 dentro de una cadena cad1.

Sintaxis: size_tstrcspn (const char *s1, const char *s2);

Problema 2. Diseñar un programa que permita inicializar dos cadenas:cad1=”Los alumnos,estudian c, c++”;cad2=”,”;

Luego genere un reporte de cad1 a partir del carácter idéntico de cad2.

Solución //cadena8.cppvoidmain()

{ char *cad1=”Los alumnos,estudian c, c++”; char *cad2=” , “ ; // character a identificar en cad1 int p; p=strcspn(cad1,cad2); //p == 11cout<<”\nLa posición del carácter idéntico esta en=”<<p<<endl; cout<<”\nResto de la cadena : “<<(cad1+p); getche() ;}

209

3. Función strtok()

Permite dividir una cadena cad1en palabras, consideradas unidades sintácticas, las cuales se encontrarán separadas por caracteres especiales contenidos en otra cadena cad2.

Sintaxis: char*strtok(char*cad1, constchar*cad2);

Strtok. Coloca un carácter nulo inmediatamente después 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 más caracteres.

Ejemplo 1. Diseñar 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 carácter que separa cada palabra (cadena1) mediante el cual, y después de este carácter, se insertaráen 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.

Solución ///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() ; }

210

4. Función strpbrk()

Devuelve un puntero a una subcadena de cad1, en donde se encuentra la primera aparición de un carácter cualquiera, contenido en cad2. Devuelve NULL si no encuentra ningún carácter.

Sintaxis: char *strpbrk(constchar *s1, constchar *s2)

Ejemplo 1. Diseñar un programa que permita buscar, a partir de una cadena 2, el primer carácter que se inicia con la cadena 1 y luego imprime la subcadena restante.

Solución //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 cOmParacIón 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. Diseñar un programa para validad datos de usuario por código y clave, si el código=8712D y clave=tcn.

Solución.-//vect_strcmp.cpp# include<iostream.h>voidmain(){ char codigo[10],pasw[5];gotoxy(2,2);cout<<”Ingresecodigo :”;gets(codigo);gotoxy(2,3); cout<<”Ingresepasword :”;gets(pasw);if(strcmp(codigo,”8712D”)==0&&strcmp(pasw,”tcn”)==0)

211

{ 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 mayúsculas o minúsculas.

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 tamaño de las letras.

5. strcoll()

Hace lo mismo que strcmp(), pero toma en cuenta el juego de caracteres interna-cionales seleccionado en el sistema operativo.Estas funciones devuelven un valor entero i tal que:

i>0 si cad1>cad22i<0 si cad1<cad2i==0 si cad1i==cad2

notas

1. El criterio para la desigualdad es comparar las cadenas carácter a carácter, de acuerdo a su código ASCII.

2. Si el primer carácter de cad1 es mayor que cad2, cad1 es mayor que cad2.3. Si el primer carácter de cad1 es menor que cad2, cad1 es menor que cad2.4. Si el primer carácter 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().

212

aplicaciones

int c;c=strcmp(“uni”,”UNI”); //devuelve un c>0c=stricmp(“uni”,”UNI”); //devuelve un c==0c=strcmpi(“fiis”,”uni”); //devuelve un c<0;c=strncmp(“uni”,”uni fiis”,3); //devuelve un c==0

Problema 1. Diseñar un programa que permita leer dos cadenas y luego hacer una comparación entre cadenas para obtener una de las siguientes respuestas:

a. Cadena 2 es más grande que cadena 1b. Cadena 2 es menor que cadena 1 c. Cadena 2 es igual a cadena 1

Solución //vect_cad_com.cpp#include <iostream.h>int main(void){// char *cad1 =”cordova”, *cad2=”CORD”; puede inicializar para compararchar 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 más grande que cadena1:”<<cadena1;}elseif (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();}

213

4.8 transFOrmacIón de cadenas

1. Función strset()

Convierte todos los caracteres de una cadena s en un carácter especificado.

2. Función strnset()

Convierte los n primeros caracteres de una cadena s en un carácter c.

Sintaxis: char *strset(char *s, char c); char *strnset(char *s, char c, int n);

Problema 1. Diseñar 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 “*”

Solución //cadena9.cpp#include<iostream.h>voidmain(){char *cad = “848139d es mi Password” ;strnset(cad,’*’,6); //convierte a partir de la posición 6 en *cout<<”\n Solo números en * “<<cad<<endl<<endl; //Visualiza ******* es mi Passwordstrset(cad,’*’); // convierte todo en *cout<<”\nToda la cadena en * “<<cad;getch(); }

214

4.9 FuncIOnes Para InvertIr cadenas

1. Función strrev()

Invierte los caracteres de una cadena. char *strrev(char *s)

Problema 1. Diseñar un programa que permita ingresar una cadena y luego:

a. Convertirlo a mayúsculas.b. Mostrarlo en forma invertida según resultado de a.

Solución //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. Función strxfrm()

3. Función 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. Diseñar un programa que permita inicializar una cadena y luego mostrar su longitud

215

Solución //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 cOnversIón a mayúsculas y mInúsculas

1. Función strupr()

Convierte todos los caracteres de una cadena cad1 a mayúsculas.

2. Función strlwr()

Convierte todos los caracteres de una cadena cad1 a minúsculas.

Sintaxis: char *strupr(char *cad1) char *strlwr(char *cad1)

Problema1. Diseñar un programa que permita leer una cadena y convertir la cadena todo a mayúsculas y todo a minúsculas.

Solución //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 InclusIón de una cadena en Otra cadena (FuncIón strstr())

Devuelve la subcadena contenida en cad1 a partir de la primera aparición de cad2 en s1. En caso contrario, devuelve NULL.

Sintaxis: char *strstr(constchar *s1, constchar *s1);

Problema 1. Diseñar un programa que imprima el resto de la cadena a partir de una subcadena dada.

216

Solución //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 alfabético, ascendente y descendente.2. En orden de tamaño, ascendente y descendente.

Además, que muestre el texto con sus palabras invertidas y el texto con las palabras en orden invertido del número total de palabras.

Solución//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 número 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 ordenación char ordenada[80]; //Frase ordenada int SW; //Bandera para el método de selección for (int o=ascendente; o<=longituddes; o++) { strcpy(ordenada,frase);

217

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; }

218

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. Llámense “comentarios” a todo aquello que se encuentre encerrado por paréntesis, 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 (inútiles) anidados) completa

Solución //vect_eli_com.cppvoidmain() {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;

219

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”);}


Problema 1. Una palabra es anagrama de otra cuando se obtiene una de la otra por permutación 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. Diseñar un programa que permita leer un texto formado por mas de tres líneas y luego mostrar el número de palabaras que tiene el texto.

Problema 3. Diseñar un programa que permita leer un texto, luego mostrar la letra o letras que más se repiten.

Problema 4. Diseñar un programa que permita leer un texto y una letra, si la letra está en el texto eliminarlo, formado por más de tres líneas y luego mostrar el número 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.


220


221

ObjetIvOs

- Establecer prototipos de funciones.- Definir subprogramas.- Como diferenciar proceso de función definida por usuario.- Diferenciar funciones no recursivas de funciones recursivas.- Como crear archivos de cabecera.- Como crear lista de parámetros.- Cuando usar variables globales, locales.

5.1 IntrOduccIón

En el presente capítulo, para la solución de problemas, nos basaremos en las técnicas de diseño top-down (de arriba - abajo), técnicas que permiten organizar nuestra aplicación en pequeños módulos denominados funciones.

El funcionamiento del programa modular se basa en que el programa principal “Llamador”, por el nombre de la función que realiza una “llamada”(call), usando

Programación modular

Capítulo 5

222

el nombre de la función, esta procesa sus instrucciones y luego devuelve al programa principal la tarea realizada por la función. 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 programación modular, para lo cual cada programa debe tener una sola función externa denominada main().

El formato general de una función en C es:

Tipo_dato_devuelto Nombre_funcion(lista_de_parámetros){variables locales <cuerpo de la función>}

ElTipo_dato_devuelto. Indica el tipo del valor que la función devolverá mediante el uso de return. El valor puede ser de cualquier tipo válido. Si no se especifica un valor, entonces la computadora asume por defecto que la función devolverá un resultado entero. No se tienen siempre que incluir parámetros en una función. La lista de parámetros puede estar vacía. Se ilustra a continuación 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();}

223

Las funciones terminan y regresan automáticamente al procedimiento que las llamó cuando se encuentra la última llave }, o bien, se puede forzar el regreso antes, usando la sentencia return. Además del uso señalado, la función return se usa para devolver un valor.

Las funciones se declaran en cabeceras (estándar o específicas de usuario) o dentro de los ficheros fuente. Estos tipos de declaraciones se les denomina:

Prototipos de funciones. Con frecuencia la declaración y definición se realiza en el mismo punto, pero es estratégico usar al principio del programa los “prototipos” de las funciones que serán utilizadas en su interior, y las definiciones o implementaciones en cualquier otro sitio. Veremos primero la sintaxis y luego la teoría y finalmente sus diversas aplicaciones.

// 1. Declaración de librerías # include<iostream.h> ................................// 2. Declaración de prototipo de funciones Tipo_dato_devuelto Nombre_funcion (lista de argumentos) ; ……………………………………………………….// 3. Declaración de variables globales// 4. Declaración de constantes globales// 5. Definición o implementación de las funciones prototipos Tipo_dato_devuelto Nombre_funcion(lista de argumentos) { <declaración de variables totales>; < Cuerpo de la función >; }// 6. Programa (función) principal Tipo_dato_devuelto main() l{ // “llamadas” a las funciones por su nombre }

Observación. El programa principal puede definirlo a continuación de los prototipos de funciones.

Partes de la definición:

1. Una función tiene un único nombre, al utilizar este nombre en otras partes del programa se pueden ejecutar los enunciados contenidos en la función. A esto se le conoce como llamara la función. Una función puede ser llamada desde otra función, esta técnica define el anidamiento de funciones.

floatdatos( ) Único nombre de la función


224

2. Una función es independiente. Una función 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 función ejecuta una tarea específica. Esta es la parte fácil de la definición. Una tarea es un conjunto de instrucciones definido por el programador.

4. Una función opcionalmente devuelve un solo valor o “ninguno” al programa que la llamó. Cuando un programa llama a una función se ejecutan los enunciados contenidos en ésta, si elprograma lo requiere, éstos enunciados pueden devolver un valor al programa que llamó a la función. Debe usar la instrucción return (cuando no devuelve ningún valor) return (valor_a_devolver) cuando la función devuelve un valor especificado por el programador.

tipos devueltos:

1. Pueden ser: float, int, etc. Floatcalcular( ): la función calcular(), devuelve un tipo de dato real. Intfactorial(int n): la función factorial(int n), devuelve un tipo de dato entero.2. Puede devolver:void es una función que no devuelve ningún valor.

5.3 declaracIón y deFInIcIón de FuncIOnes

Para utilizar una función en un programa se requiere en primer lugar declararla y después definirla. La declaración de la función le indica al compilador el nombre, el tipo de dato devuelto por la función y los parámetros pasados a la función. A la declaración de una función se le llama también el prototipo de la función.

El prototipo de una función provee al compilador con información de una función que será definida posteriormente en el programa. El prototipo incluye, en este orden, el tipo de valor que la función devolverá, el nombre de la función, el cual debe ser significativo del trabajo realizado por la función y el tipo de variables utilizadas como argumentos que serán pasados a la función, siempre termina en punto y coma “;”.

La definición de una función es en sí la función misma, está compuesta en su primera línea de código por el encabezado, que debe ser idéntico al prototipo de la función, pero en éste caso no se utiliza el punto y coma, además, al contrario del prototipo, donde es opcional incluir el nombre de las variables utilizadas como argumentos, en el encabezado de la función se debe incluir el nombre de las variables, después del nombre no asignar punto y coma ”; ”.

225

5.4 lIsta de ParámetrOs y sus tIPOs de datOs

Las palabras parámetro y argumento, aunque de significado similar, tiene distintas interpretaciones semánticas, veamos: se denominan parámetros a los objetos declarados en el prototipo (que deben corresponder con la definición). Cuando se realiza una llamada a la función, los “valores” pasados se denominan argumentos.Con frecuencia se utilizan también las expresiones argumentos formales, para los parámetros y argumentos actuales o ficticios para los valores pasados.

Parámetros (establecidos en prototipo o definición) argumentos formales

Valores pasados (en tiempo de ejecución) argumentos actuales

tipo 1. Funciones sin lista de parámetros y su valor devuelto

Como prototipo:Tipo_dato_devuelto Nombre_función ( ); //sin lista de argumentos

Como definición:Tipo_dato_devuelto Nombre_función ( ) { <instr>; return;}

tipo 2. Funciones con lista de argumentos y su valor devuelto

Sintaxis.Como prototipo:Tipo_dato_devuelto Nombre_función (lista_de_argumentos);Como definición:Tipo_dato_devuelto Nombre_función (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 aplicación de la teoría y su explicación respectiva.

Problema 1. Diseñar un programa que contenga dos funciones:resta(arg1,arg2): permite calcular la resta de dos números enteros.multiplica(arg1,arg2): permite calcular el producto de dos números enteros.Luego, desde el programa principal leer los dos números y estos pasarlos como parámetros de las funciones invocadas para que realicen sus tareas.Solución // func_arit.cpp

226

#include <iostream.h>void resta(int , int ); // Prototipo de funcionesint multiplica(int, int);int num1, num2, resultado;void resta(int a, int b){ int restan; // variable localrestan=a-b; gotoxy(3,7);cout<<”La resta de “<<a<<” - “<<b<<” es = “<<restan<< endl;}int multiplica(int a, int b){ int producto; // variable localproducto = a *b; return producto;}int main() // Función 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 función «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 código fuente. Ademásde pasar variables como parte del argumento de una función.

Un identificador es local. Cuando está definido dentro del cuerpo de una función, a este tipo de variables se les denomina locales, ya que sólo son útiles dentro del cuerpo de la función.

Un identificador es global. Cuando están definidas fuera del bloque ofuera del cuerpo de cualquier función.

Estas variables están disponibles para cualquier función 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.

Observación. Las variables globales, se inicializan automáticamente en cero (0), las locales no.

Nota. Evitaremos el uso de variables globales y de nombres de variable duplicados (efectos colaterales).


227

Ejemploint multiplica(int valor1, int valor2){int productol; // variable localproducto = valor1 * valor2; return producto;}

Los parámetros de la función, 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 función multiplica( ). El alcance de una variable es simplemente el espacio dentro del código 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 función.

5.6 ParámetrOs POr deFectO

Un valor por defecto es el valor a utilizar en caso de que ninguno sea especificado, así, una declaración de una función podría ser esta:

float facto(int dato_defecto=43);

En éste ejemplo se declara una función llamada facto() que toma un parámetro de tipo int, pero en caso de que no se incluya el parámetro necesario, entonces se utilizará el valor de 43 para ser utilizado por la función.

También, como no es absolutamente necesario utilizar nombres para los parámetros en el prototipo de una función, también podemos escribir la declaración de una función de la siguiente manera:

float facto (int = 43);

Paso de parámetros valor y por referencia:

Paso de parámetros por referencia

Procedimiento para que la función pueda modificar el valor de las variables. Una variable consta, además de su nombre, tipo y valor, de una dirección de memoria en la que se ubica (valor numérico).

Para extraer la dirección de memoria asociada a una variable utilizaremos el operador & antepuesto a su nombre.

Para extraer el contenido de una dirección de memoria, se usa el operador * antepuesto a su nombre.

Un puntero es una variable que almacena una dirección de memoria independientemente de lo que ésta contenga.

Para realizar el paso de parámetros por referencia utilizaremos punteros.

En la cabecera se especifica cada parámetro por referencia con el operador *

Dentro de la función, cambiaremos el contenido de cada variable con *.

228

En la llamada a la función use el operador & para extraer la dirección de las variables.

Problema 1. Diseñar un programa que permita leer un número entero y luego éste debe pasar como parámetro en una función sumando() y transformarlo aumentando la unidad al valor ingresado.

Solución //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. Diseñar un programa que permita leer una cadena y pasarlo como parámetro de una función Palabra_Mayusculas( ) y luego devuelve la cadena expresada en letras mayúsculas.

Solución //func_mayusc.cppvoid 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();}

229

Problema 3. Diseñar 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 número de términos de la serie a sumar.

Solución //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. Diseñar un programa, usando funciones, que permita ingresar la hora y los minutos, luego mostrarlo en los siguientes formatos:Formato 1: 14:45Formato 2: 2:45 PM

Solución // 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(); }

230

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. Diseñar un programa que permita ingresar la cantida de números enteros y luego para cada número ingresado, mostrar su cantidad de dígitos.

Solución //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 número de entrada nd=0;// inicializo contador de dígitoswhile(m>0) // descompongo el número 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(); }

231

Problema 6. Diseñar 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 número de términos de la serie a sumar.

Solución. // 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. Diseñar un programa que permita elevar a la potencia un número ingresado como base. Mostrar el reporte respectivo.

Solución // funcio_inv1.cpp#include<iostream.h>void leerd(); int proceso(); void reporte();int pot,base,poten;

232

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. Diseñar un programa que permita leer un número entero positivo y luego calcular su factorial.

Solución // func_fact.cppvoid 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. Diseñar un programa que permita leer el rango de una matriz A y luego:

233

a. Leer y mostrar los elementos de la matriz Ab. Mostrar la suma acumulada de los elementos diagonalesc. El resultado de parte b) sirve como parámetro de la función totald( ), que cal-

cula el total de dígitos que tiene el resultado de la suma diagonald. Leer los elementos de la matriz B y mostrar la suma de las dos matrices

Solución // func_matriz.cpp#include<iostream.h># define max_el 50int 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; }

234

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. Diseñar un programa que permita almacenar en una matriz de orden n*m caracteres de ‘a’. .’z’ y luego mostrar el número de veces que se forma la palabra “peru” (sólo en letras minúsculas). 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

Solución //func_matriz_peru.cpp#include <iostream.h>

235

# define max_l 50void 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’)){


236

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’))

237

{ peru=peru+1; } } }}

Problema 11. Diseñar un programa que permita mostrar la suma acumulada de la serie 1+2+3+4+....+n. El usuario edita el primer término de la serie (ldi) y luego edita el lado derecho (ldd: hasta donde desea sumar).

Solución // func_suma_ser.cppvoid 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. Diseñar un programa que permita ingresar un número entero como cadena (ejemplo num=”432”), luego convertir esta cadena numérica a número entero y elevar al cubo el segundo dígito.

Solución ///func_dig_cub.cpp#include<iostream.h>void leerd (); int procesar(); void reporte();int n,n1,n2,p;char num[3];void leerd()

238

{gotoxy(2,2);cout<<”ingrese un número de tres dígitos en cadena numerica:”;gets(num);} int procesar () { n=atoi(num); //convertir una cadena entera a numeron1=n/10; n2=n1%10;p=pow(n2,3); return p; }void reporte(){ gotoxy(2,4);cout<<”El dígito “<<n2<<” elevado al cubo es =”<<procesar();}void main(){leerd(); procesar(); reporte();getche();}

Problema 13. Diseñar 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 b. Elementos nulos c. Elementos negativo d. Total de elementos del vector

Solución //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++) //diseño de las filas{gotoxy(8+i,2);cout<<”_”; gotoxy(8+i,18);cout<<”_”; }for(i=1;i<=16;i++) //diseño 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]; }

239

}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;return 0;}void main(){ marco(); gotoxy(12,5); cout<<”Ingrese el tamaño 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. Diseñar un programa que permita ingresar el número 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 Bb. Almacenar en una matriz C, la suma de las dos matrices: A+Bc. Mostrar en forma invertida cada elemento de la matriz C

Solución // 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;

240

} 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();}

}

241

Problema 15. Diseñar un programa que permita leer cantidad de números enteros y luego estos números encryptar (reemplzar cada número por‘*’) y mostrar en una primera línea los números impares encryptados y en una segunda línea mostrar los números pares encryptados. Asimismo, mostar los números ordenados, primero los impares en forma ascendente y, a continuación, los pares en forma descendente.

Observación. Primero ingresar números impares y luego los pares.

Solución //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 Orden[30]; 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 truefor(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 imparOrden[i]=true;m_orden[i]=A[i];//}//hacemos marcar ubicación de números pares e imparesgotoxy(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 AEspejoBurbuja(m_orden,n);int a=0; //sera el indice de los imparesint b=n-1; //sera el indice de los paresfor(i=0;i<n;i++){ if(m_orden[i]%2!=0)//si es impar { while(Orden[a]==true)

242

{ 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. Diseñar un programa que permita encontrar todas las soluciones para la relación: SEND + MORE = MONEY.

Solución //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 ;

243

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 automático realiza transacciones sobre una determinada cuenta corriente. Para acceder a dicha cuenta se debe introducir un código y una contraseña. Asumamos que el código de un usuario es “TLCN” y su contraseña es “1234”. El cajero permitirá el ingreso sólo 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 podrán realizar transacciones con un saldo inicial (un número aleatorio entre 100 y 1000), seleccionando las opciones de un menú, como el siguiente:

Opción 1) Depósitos Opción 2) Retiros Opción 3) Ver saldo Opción 4) Salir

Cada opción es accedida mediante su número de acceso. Los depósitos pueden ser en cantidades fijas de 10,100 y 200 soles. Los retiros pueden ser de cualquier cantidad, pero manteniendo un saldo mínimo de 5 soles.

Si el usuario cometió más de tres errores, el sistema le envía el mensaje “Ud. no puede ingresar al sistema, hasta luego”.

Diseñar el programa correspondiente que simule a este cajero.

Solución //func_banco_s.cpp#include<iostream.h># define linea “-----------------------------” time_t tiemp;int monto,saldo,n;

244

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));

245

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. Diseñar un programa que permita leer las coordenadasde dospuntos A(x1,y1), B(x2,y2) y calcular la distancia entre los dos puntos descritos.

Solución //func_dist.cpp#include <iostream.h>float distanciaxy(float x1, float y1,float x2, float y2);float x1,y1,x2,y2;

246

float salida;float distanciaxy(float x1, float y1,float x2, float y2){ float resultado,intermedio; intermedio=pow(x1-x2,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 función, puede contener llamada a otra función. La condición es que deben estar definidas en el protipode funciones.

Problema 1. Diseñar un programa que permita leer dos números y luego mostrarlos ordenados en forma ascendente. Debe definir las siguientes funciones:

- Entradas(): lee dos números enteros desde teclado.- Intercambia(): intercambia valores de dos variables.- Ordena(): ordena los números que están almacenados en variables.- Imprimir(): imprime resultados de las dos variables.

Solución //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 A FUNCIONES: ABSTRACCION”; entradas(a, b); Ordena(a, b); imprimir(a, b); getche();

247

}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. Diseñar un programa que permita ingresar una cadena de caracteres y luego mostrarlo en forma invertida.

Solución //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. Diseñar un programa que permita ingresar un número entero positivo en forma hexadecimal y luego mediante una función, convertir este número en su equivalente expresado en sistema binario.

248

Análisis. Los números decimales son dígitos (0 al 9) y los númerosbinarios son dígitos (0,1). Así, la representación binaria de un número decimal se puede hallar mediante el siguiente algoritmo: sea n un número 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 / 223 1 1111 1 55 1 22 0 11 1 00

La representación binaria de 23 es 10111

Solución //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. Diseñar 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.

Solución //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)=0return(1); }

249

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(); }

250

Problema 5. Una utilidad común 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 número y luego solicitar la base mediante una tecla “H”, ”B”, ”O”, para luego intercambiar el número entre las bases pulsando entre estas teclas.

Solución ////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;

251

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<<”opción invalida”;}getche();

}

Problema 6. Las facultades de una universidad están preocupadas por el rendimiento académico de sus estudiantes, especialmente los del área de sistemas. Para tomar una estadística 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 cuáles cursos tienen problemas.

252

Solución //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();}

253

Problema 7. Diseñar un programa usando funciones que permita ingresar clave =1234 de usuario y si este es verdadero, el programa solicita número de vendedores. Por cada vendedor existe cuatro tipos de servicios y su precio respectivo por pasaje:

Al norte : S/.40 Al sur : S/.30Al centro : S/. 25 Al oriente: S/.22

El programa debe generar los siguientes reportes:

a. Número total de pasajeros por servicio y monto total por cada serviciob. Número total de pasajeros y monto totalc. Vendedor con mayor venta de pasajesd. Vendedor con mayor venta de pasajes por servicioe. Servicio que recaudó mayor cantidad de dinero y el vendedor respectivo

Solución //func_Ventas_pasaj.cpp #include<iostream.h>#define max 10typedef 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++)

254

{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;

255

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

256

Vendedor “<<v[i]<<endl; } } }

Problema 8. Diseñar un programa,usando funciones, que permita ingresar n caracteres en un vector de longitud definida por el usuario y luego generar reportes para conocer:

Número 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ó)

Solución //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. Diseñar un programa que gener números en forma aleatoria y almacenarlo en una matriz de n filas y m columnas, luego mostrar la matriz, compuesta con elementos constituidos sólo por dígitos y ordenados en forma ascendente.

Solución //func_mat_rand.cpp

257

#include<iostream.h># define max_el 100void 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 aleatoriofor(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 vectorfor(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 Matrizk=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 aleatoriofor(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()

258

{ 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. Diseñar un programa que, mediante una función cantidad_num(), permita leer la cantidad de números para buscar sus divisores, el número debe estar comprendido en el rango 1..100, inclusive. Luego diseñe otra función divisores() que permita ingresar el número del que desea buscar sus divisores (usted ingrese números hasta la cantidad definida con la función cantidad_num()). Finalmente desde el programa principal “llamar” a las funciones implementadas.

Solución //func_vect_factores.cpp#include<iostream.h># define linea “-----------------------------------------”# define max_el 100void 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;

259

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 número menor que 0 o mayor que 100, entonces el sistema envía el mensaje “Número fuera de rango, vuelva a Ingresar” . Vea como ejemplo para n=3.

5.8 FuncIOnes recursIvas

Puede definirse un programa en términos recursivos, como una serie de pasos básicos, o paso base (también conocido como condición de parada), y un paso recursivo, donde vuelve a llamarse a la función. 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 número de pasos que hay que dar para terminar, llegando un momento en el que no se verifica la condición de paso a la recursividad. Ni el paso base ni el paso recursivo son necesariamente únicos.

Cuando una función se puede llamar a sí misma (por su nombre), se le denomina recursividad y puede ser directa e indirecta.

Recursividad directa. Cuando una función 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. También en estos casos debe haber una condición 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 ejecución por falta de memoria.

Durante el proceso de compilación, es importante resaltar en la recursividad que cuando una función se llama a sí misma, una nueva copia de esta función 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 número, veamos:

n ! = 1

n(n-1)si n = 0si n ≠ 0

Caso base

Caso recursivo{

260

Que permite ejecutarse de la siguiente manera:

Ilustracion analítica de la descomposición de n=5factorial(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

Diseñando la función recursiva:int factorial(int n);{ if (n == 0)| return 1; else return n * factorial(n-1);}Considere el caso cuando n=3return 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 expresión: 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. Diseñar un programa que permita ingresar un número entero positivo y luego, en forma recursiva, generar un reporte de los elementos a partir del número ingresado hasta terminar en cero (0).

Solución //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()

261

{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. Diseñar un programa que permita leer un número entero positivo y luego, en forma recursiva, calcular su factorial e indicar el número de veces que se “llama” a la función recursiva por su nombre.

Solución //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. Diseñar un programa que permita ingresar una cadena de n caracteres, luego el programa debe solicitar al usuario que ingrese un carácter, mediante él se debe generar un reporte del número de veces que se repite el carácter ingresado.

Solución // 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]) ;

262

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. Diseñar un programa que permita ingresar un número entero (base) y un número entero m (para mostrar el número base su potencia desde cero hasta el valor de m). Mostrar la potencia de un número en forma recursiva.

Solución //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(); }

Problema 5. Diseñar un programa que permita ingresar un número entero (base) y un segundo número entero (expon) y luego calcule el resultado en forma recursiva.

Solución //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;

n ! = 1n(n-1)

si n = 0si n ≠ 0

Caso base

Caso recursivo{

Cálculo de la potencia ab:

ab = 1

a(ab-1)si b = 0si b > 0{

263

gotoxy(2,5);cout<<”Ingrese exponente :” ;cin>>expon;gotoxy(2,7); cout<<”El numero “<<base<<” elevado a “<<exp<<”es= “<<potencia(base,expon); getche();}

Problema 6. Diseñar un programa que permita ingresar un número entero a (multiplicando) y un número entero b (multiplicador) y luego calcule en forma recursiva el producto de los dos números.

Solución 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. Diseñar 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.

Solución func_rec_busc_bin.cpp#include<iostream.h>const int longi =50; // Tamaño del vectortypedef 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; }

264

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 más 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. Diseñar un programa que permita buscar,en forma recursiva, el máximo elemento del vector inicializado: vector[ ]={2,8,7,3};

Solución //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. Diseñar un programa que permita mostrar todas las posibles permutaciones de la palabra inicializada “NUI”.

265

Solución //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);permutaciones(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. Diseñar un programa que permita ingresar datos de n alumnos (n<=1000) por apellidos, nombres, código, edad y sus evaluaciones respectivas: tres prácticas calificadas y dos exámenes. 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 tamaño del vector o de la matriz.

lectura_Edades(b,m): subprograma para lectura de edades en el rango 10..99. En forma análoga, crear nuevas estructuras para almacenar los datos mostrados en la figura adjunta.

266

Ordena(b[, n): subprograma que ordena las edades en forma ascendente (si cambia la edad, también debe cambiar el resto de datos, inclusive la posición original como la actual de cada registro).

pares_impares(b,n): subprograma (función) que devuelve información 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. Diseñar un programa usando la técnica de subprogramas, que permita leer datos de alumnos por nombres y edad de n alumnos (n<=1000), luego genere los siguientes reportes mostrados según las gráficas:

1. Subprograma para hacer lectura del total de alumnos y subprograma para hacer lectura de sus datos respecti-vos.

2. Subprograma que permita hacer reporte de datos de alumnos incluyendo la ubicación inicial.

3. Subprograma que permita hacer re-porte de alumnos ordenados por nombre en forma ascendente.

4. Subprograma que permita buscar alumno(s) según nombre. Si repiten, debe mostrarse el total. Asimismo, el módulo debe ser interactivo con el usuario.

5. Subprograma que permita hacer inserción. Solicita datos de alumnos y tam-bién es interactivo.

6. Subprograma que permita hacer reporte después de la inserción de datos.7. Subprograma para reporte ordenado después de la inserción.8. Subprograma para mostrar reporte de alumnos que sus edades no se repitan.


267

Problema 3. Diseñar un programa usando los siguientes módulos:

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]): Función que devuelve el mayor coeficiente y su posición respectiva.

Manorcoef(int n,int poli[100]): Función que devuelve el manor coeficiente y su posición 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 validación y generación de código para la asignación empleados, se suele realizar por medio del “Algoritmo del Módulo 11”, el cual consiste en sumar los productos de los dígitos de tal número por 2, 3,4…. de izquierda a derecha, y luego el resultado de esa sumatoria extraerle el módulo 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 código 990006,


268

entonces genero la multiplicación: (9*2+9+3+…..+6*7) mod 11 lo cual resulta 10, es decir le corresponde la letra ‘K’, siendo entonces el código generado: 990006K.

Usando subprogramas, diseñar el algoritmo el cual lea apellidos y dado su código entero formado sólo por 6 dígitos, genere el código de empleado respectivo, en particular para 848139 se genera en la figura el código.

Problema 5. Diseñar un programa usando las técnicas de diseño modular, usando los siguientes subprogramas:

Total(): módulo que permite leer total de alumnos.

Lectura(): proceso que permite leer datos de alumnos por código (no debe repetirse) y nombres, cinco asignaturas (“Básicas”,”Física”,”Ingles I”,”Ecología”,”Análisis); y cinco secciones (A,B,C,D,E), respectivamente. Donde cada alumno puede estar matriculado en uno o máximo cinco cursos y en una o máximo cinco secciones, por cada asignatura-sección, cada alumno solo rinde tres prácticas calificadas, las cuales son tomadas en forma aleatoria y sólo en el rango de 2..18.

Observación. la correspondencia de alumno-asignaturas-sección-prácticaspuede hacerlo aleatoriamente o mediante lectura desde teclado.

ReportesDat(): proceso que permite mostrar datos ingresados/capturados aleatoriamente, usando el siguiente formulario:

ReportesProm(): Proceso que permite procesar evaluaciones de alumnos; es decir, calcular el promedio de prácticas, eliminando la menor nota y luego mostrar un reporte tal como se ilustra en el siguiente formulario:

SeccAgrupa(): Proceso que genera un reporta donde se ilustra: la información mostrada en el siguiente formulario, es decir: sección, asignatura, promedio de prácticas, nombre de alumno, promedio de sección y sección con mayor promedio.

Código Apellidos Asignatura Sección Práctica 1 Práctica 2 Práctica 3

Código Apellidos Asignatura Sección Práctica 1 Práctica 2 Práctica 3 Menor Promedio

269

InsertaAlm(): Proceso que en forma interactiva permita insertar uno o más alumnos con todos sus datos respectivos.

Observación. El código un alumno no debe repetirse

OrdenaSeccion(): Proceso que permite ordenar en forma ascendente por sección. Los datos a mostrarse se ilustran en el siguiente formulario:

EliminarAlumn(): Proceso que permite eliminar registros según dato especificado.

Problema 6. La siguiente aplicación, permita procesar información de un conjunto de n (n<=1000), usando los siguientes atributos: nombre, código (sólo de tres dígitos). En esta aplicación se ilustra la técnica de diseño tipos top-down: DISEÑO MODULAR DEPENDIENTE, basado en el concepto de procedimientos y funciones. También se resalta las técnicas de listas y tablas (matriz) para procesar cadenas. A continuación se describe cada módulo y la tarea específica que éstos realizan:

Longitud(). Es un procedimiento para definir la cantidad de alumnos. En la siguiente figura se ilustra la ejecución de este módulo, donde para iniciar se ingrese dos alumnos, pues más adelante existe módulo de inserción.

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 código se almacena en un vector según el tamaño 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 posición de cada registro, este dato es importante cuando se realiza el ordenamiento y permite conocer el lugar inicial de

Código Apellidos Asignatura Sección Práctica 1 Práctica 2 Práctica 3 Menor Promedio


270

ingreso del registro. En la siguiente figura se ilustra el proceso de entrada de datos al sistema.

OrdenarNombresAsc(). Es un proce-dimiento que permite ordenar datos de alumnos por nombre y en forma ascendente. Usando el Procedimiento Reportes(), se genera el reporte res-pectivo.

BuscarNombre(). Es un procedimien-to que permite al usuario realizar búsquedas de alumnos por nombre. En las figuras adjuntas se ilustra y verifica que los compiladores hacen una diferencia entre letras mayúsculas de minúsculas.

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 procedi-miento que permite generar un re-porte 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 cómo insertar una cadena en una matriz). Observe que el código 100 se repite, pues se hace con la finalidad de eliminar códigos repetidos.

Después de insertar, se genera un reporte donde se observa los registros ordenados en forma ascendente. Ver figura adjunta.


271

Eliminación(). Es un procedimiento que permite eliminar registros que tienen igual código. Ver figuras adjuntas.


272


273

ObjetIvOs

- Definición de registros (struct)- Definir campos de una tabla, asignando sus claves respectivas- Diseñar modelo relacional de base de datos- Cómo definir registro lógico y físico- Cómo acceder a los elementos de un registro- Establecer anidamientode registros

6 .1 IntrOduccIón

Un campo de la informática es el procesamiento de datos reales, tales como empleados, alumnos, vehículo, etc. Este tipo de información será procesada con mucha facilidad usando la técnica de registro (struct), pero el procesamiento solo se hace a nivel de memoria RAM.

registros (struct)

Capítulo 6


274

Manejo de base de datos: El almacenamiento y gestión de datos en una empresa da lugar al uso de los denominados archivos informáticos; para lo cual se debe iniciar con los términos semánticos de: entidad, modelos relacionales, claves primarias, foráneas, 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 información en la base de datos.

Atributo o campo: propiedades específicas de cada entidad para describirla.

Registro: Está compuesto por un conjunto de estructuras denominadas campos. Se procesa datos en términos de: registro lógico, registro físico, campo, claves primarias, foráneas. En el presente modelo ilustra el uso de las claves respectivas.El modelo relacional es el modelo lógico en el que se basan la mayoría de los sistemas de gestión de bases de datos.Cuando se diseña una struct, también se le conoce como diseño 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 código representa la clave primaria.Clave foránea. Es un campo que identifica al registro y sirve para relacionar las tablas, asimismo, permite mezclar la información respectiva.


275

Empleado

Código nombre apellidos edad sueldo sexo

Tipos de datos: cadena(har) Entero(int) Real (float)

Del gráfico, 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 deFInIcIón y declaracIón de una estructura

La declaración de una estructura(modelo), significa definir un tipo de datos identificándolo 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 también instancias de ella:

nombre_tipo instancia_1, instancia_2,.....,instancia_n;

‘89760K’ ‘Ana’ ‘Salas’ 30 1209,4 ‘F’

276

Así, las variables reales con las que se procesó los datos son: instancia_1, instancia_2,...,instancia_n y no nombre_tipo, el cual sólo define la estructura de cada una de aquéllas.

También es posible declarar las instancias del tipo al final de la declaración 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 (también se les denomina estructuras jerárquicas), es decir, pueden ser datos miembro de otra estructura.

6.5 accesO a lOs elementOs de una estructura

Para acceder a los miembros de la estructura, se usa el operador “.”.

Sintaxis Operador punto

nomb_var_de_estructura.nombre_var_miembro

Como se mencionó, para trabajar con estructuras anidadas, se utilizará el punto “.” varias veces para acceder a los miembros de la estructura más interna.

struct Empleado {char codigo[10];char apellidos[20], sexo;

int edad; float sueldo; } Lista_empleado[4] // el vector cuyos elementos seran registros

277

6.6 aPlIcacIOnes

Problema 1. Diseñar un programa que permita almacenar, en un vector de tamaño máximo 100, datos de n alumnos (n definido por usuario), donde la información del alumno consta de: código, 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.

Solución //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 número 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”;

278

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. Diseñar un programa que permita almacenar en un vector de tamaño máximo 100, datos de n alumnos (n definido por usuario), donde la información del alumno consta de: apellidos, nombres, código, edad, tres prácticas calificadas y dois exámenes (parcial y final). Genere reportes para conocer:

a. Promedio de prácticasb. Promedio finalc. Condición de alumno: aprobado o desaprobado. Si promedio final es mayor a

10.5 alumno APROBADO, sino DESAPROBADOd. Cantidad de alumnos aprobados y alumnos desaprobados

Solución //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 Número 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<<” Código : “ ;cin>>datos[i].codigo; gotoxy(5,6);cout<<” Edad : “ ;cin>>datos[i].edad;

279

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 desaprobadosclrscr();

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<<»Código «;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<<»Condición»;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(); }

280

Salidas. Después de ingresar los registros, se obtiene:

Problema 3. Diseñar un programa que permita crear tres funciones y que realicen los siguientes procesos:

leer_reg(): permite almacenar en un vector de tamaño máximo 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.

Solución //struct_persona.cpp# define linea “---------------------------------------------------------------”struct persona{char nombre[30], sexo, piel[10], ojos[10], nacionalidad[15];int edad, altura; }inf[70];//Prototipos de funcionesvoid leer_reg();void ordenar();void listar();voidmain(){ char opcion;do{clrscr();gotoxy(21,9);cout<<”ELIJA UNA OPCIÓN “;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();

281

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

282

Parte II. (opción B) reporte ordenado por nombre

Parte III. (opción C) listado de todos los registros

Problema 4. Diseñar un programa que permita leer n alumnos, por cada alumno m cursos y por cada curso p prácticas (n, m y p son definidos por el usuario) los alumnos, cursos y notas deben almacenarse en vectores de tamaño definido por usuario. Los datos a procesar son:

1. Para alumnos: leer su código, apellidos y nombres2. Para cursos: leer nombre de cursos3. Para notas, leer prácticas, exámenes 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 según donde corresponda.

Los reportes por alumno consisten en: apellidos y número de cursos, nombre del curso, condición del curso (aprobado o desaprobado) y su nota final.

Solución //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();

283

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 número de prácticas: “; cin>>alumno[i].curso[j].numero_practica;for(k=0;k<alumno[i].curso[j].numero_practica;k++){cout<<”\t\t\t\tPráctica[“<<(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;elsealumno[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; }

284

} } 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. Diseñar un programa que permita crear tres funciones para procesar registros de n alumnos (n definido por usuario), donde cada función realiza los siguientes procesos:

Ingresa(): permite ingresar registros de alumnos por nombre y edad en un vector de tamaño 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.

Solución//STRUCT_Al_mayor.cpp#include<conio.h>

285

# define linea “----------------------------------------------------------”void ingresa(); void imprime(); int mayoredad(); // functions prototiposint 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. Diseñar un programa que permita procesar registros de alumnos por código, apellidos y edad. Los módulos a implementar son:

Primero, debe diseñar una función marco (), que genere una ventana (marco) para que en su interior contenga las siguientes opciones:

286

< 1 > Crear ARCHIVO”;< 2 > Ingreso de registros”;< 3 > Ingresar nuevos registros”;< 4 > Eliminar registros”;< 5 > Registros ordenados por edad “;< 6 > Registros ordenados por código “;< 7 > Registros ordenados por apellidos”;<8>Consultas por elección de un dato”;< 9 > Salir”;

Donde cada opción realiza las siguientes tareas:< 1 > Crear ARCHIVO”:permite crear un archivo.< 2 > Ingreso de Registros”: permite ingresar el número de registros.< 3 > Ingresar nuevos registros”: solicita el número de registros a insertar.< 4 > Eliminar Registros”:solicita el número de registro a eliminar.Opciones < 5 >,< 6 > y< 7 > Ordena en forma ascendente por el campo que usted seleccione.< 8 > Consultas por elección de un dato”: sólo genera reporte del registro por el dato personal que usted edite (ejemplo: por código, debe ingresar código leído).< 9 > Salir”: envía el mensaje: “Esta seguro que quiere salir del sistema (s/n):”. Si edita S, usted sale del modo compilación al programa fuente, en otro caso regresa al menú principal.Finalmente, después de compilar el programa lo primero que se debe generar es un informe de la fecha y la hora.

Solución //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<<»É»; //esquinasfor (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<<”¼”; //esquinasfor(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();

287

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 elección de un dato”;gotoxy(16,15);cout<<”< 9 > Salir” ;gotoxy(14,18);cout<<” <Elija opción> “;cin>>opc;clrscr();}while((opc!=1)&&(opc!=2)&&(opc!=3)&&(opc!=4)&&(opc!=5)&&(opc!=6)&&(opc!=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 número 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<<”Código : “;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 número 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<<”Código : “;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 “;

288

gotoxy(20,16);system(“pause”); system(“cls”); } break;case 4:{ marco();

gotoxy(22,5);cout<<” ELIMINACIÓN DE REGISTROS.... “; gotoxy(14,9);cout<<”Ingrese número 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<<”Código”; 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<<”Código”; gotoxy(28,19);cout<<”Apellidos”;

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

289

{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; g o t o x y ( 5 0 , 2 0 + i ) ; c o u t < < l i s t a [ i ] . n o m b ; 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 ELECCIÓN DE DATOS “;gotoxy(26,7);cout<<” MENÚ DE OPCIONES “;do {gotoxy(14,9);cout<<»< 1 > Por Edad»; gotoxy(14,10);cout<<”< 2 > Por Código”;

290

gotoxy(14,11);cout<<”< 3 > por Apellidos”; gotoxy(14,12);cout<<”Ingrese Opción “;cin>>opc1;switch(opc1) { case 1: {clrscr(); marco();gotoxy(28,5);cout<<” REPORTE SEGÚN 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<<”Apellidos”;gotoxy(50,19);cout<<”Nombres”; g o t o x y ( 6 5 , 1 9 ) ; c o u t < < ” E d a d ” g o t o x y ( 1 4 , 2 0 + i ) ; c o u t < < l i s t a [ i ] . c o d ; 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 SEGÚN CÓDIGO “;gotoxy(30,14);cout<<”Ingrese su Código “;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 CÓDIGO”; gotoxy(14,19);cout<<”Código”; 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++)

291

{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 SEGÚN 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<<”Código”; 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<<”_”;}

292

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, después de asignar el nombre al archivo, el número de registros, usted usa la opción 2, la cual permite ingresar datos de los alumnos.

Problema 7. Diseñar un programa que permita leer n alumnos (n ingresado por el usuario) por código, nombre, edad y facultad (existen tres facultades: sistemas, industriales y mecánica). El programa debe permitir los siguientes:

a. Lectura de n de empleados dentro de un marco (ventana), fecha y hora de implementación del programa. El programa indica el número 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 posición donde se localiza el registro.

Solución //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; //implementación de las funciones prototipovoid 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<<»È»; //esquinasgotoxy(10,4) ;cout<<»É»; //esquinasfor (i=11 ;i <=69 ; i++) { gotoxy(i,4) ;cout<<»Í»; gotoxy(i,5) ;cout<<»Í»; // lineas horizontalesgotoxy(i,20) ;cout<<»Í»; }gotoxy(70,4) ;cout<<»»»; gotoxy(70,20) ;cout<<»¼»; //esquinasfor(i=5;i<=19;i++) {gotoxy(10,i) ;cout<<»º»; //lineas verticalesgotoxy(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;

293

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º. Código 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 ....” ;

294

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 posición “<<(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 posición “<<(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 Mecánica con Edad Mayor es : “<<alumno[pos].nomb;gotoxy(14,17);cout<<alumno[pos].nomb<<” esta en la posición”<<(j+1);} } gotoxy(20,22);system(“pause”); }void main(){ marco(); ingreso(); reportes(); promedio(); mayor(); getch(); }

Procedimientos de salida

Parte I. Entrada de datos: además de lectura de datos por cada alumno, puede visualizar un marco, fecha y hora del sistema. Para ingresar más registros presione S.

Parte II. Reporte: después 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 continuación se ilustra la entrada y salida.

295

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. Recaudación por cada vendedor y recaudación 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 máxima y mínima 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, después de cada ejecución debe pre-guntar al usuario “Desea continuar?.....(S/N)—>.

Solución //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;

296

}}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 Distritosrecau[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]; // Cálculo de los Totales de las Marcas de tipos

297

tt+=x[i][j]; // Cálculo 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; // Posición con Max # en Oficinamaxvend=i; // Posición con Max # por Vendedor}if (orden[0]==x[i][j]){mintipo=j; // Posición con Min # en Oficinaminvend=i; // Posición con Min # por Vendedor}if (monto[k-1]==x[i][j]*precio[j])maxmontotipo=j; // Posición con Max Monto en Oficinamaxmontovend=i; // Posición con Max Monto por Vendedor}if (monto[0]==x[i][j]*precio[j]){minmontotipo=j; // Posición con Min Monto en Oficinaminmontovend=i; // Posición 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

298

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 número de vendedores.

Parte II. Lectura de cantidad de boletos expedidos por cada vendedor.


299

Parte III. Resultados solicitados por el programador, después de la lectura del número de pasajes por tipo y por vendedor, se ilustra los datos procesados.


Problema 1. Diseñar un programa que permita ingresar n alumnos (n definido por el usuario), identificados por: apellidos y nombre (cadenas de 20), fecha de nacimiento (día/mes/año) y su edad respectiva. Luego realice las siguientes consultas:

a. Alumnos por apellidos, fecha de nacimiento y edadb. Alumnos ordenados por apellidos en forma ascendentec. El alumno(s) de mayor edad, alumno(s) de menor edadd. Total de alumnos y el promedio de edades

Problema 2. Diseñar un programa que permita ingresar n artículos (n definido por usuario), donde cada artículo provee los siguientes campos: código (cadena de 4), nombre (cadena de 20), fecha de fabricación (d/m/a), cantidad (entero) y precio (real). Realice las siguientes consultas:

a. Listado de productos por código, nombre, fecha de fabricación y preciob. Listado de productos ordenados en forma ascendente por precioc. Listado de artículo(s) con mayor precio y la cantidad

Problema 3. Diseñar un programa que permita ingresar n alumnos (n definido por usuario), los registros alumnos corresponden a un colegio, identificados por: código (cadena de 8), el apellidos (cadena de 20), puntaje (entero:0 al 100) y sexo (carácter). Realice las siguientes consultas:

a. Listado de alumnos por: código, apellidos y puntajeb. Listado de alumnos por apellidos y ordenados por sexo en forma ascendentec. Total de alumnos indicando “promovidos” cuando su puntaje es mayor que

20 y la cantidad de repitentes, cuando su puntaje es menor que 20

300

Problema 4. Diseñar un programa que permita ingresar n registros (n definido por usuario), registros que corresponden a datos de las ventas que maneja una inmobiliaria por día, tales como la dirección del inmueble (cadena de 20), el nombre del propietario (cadena de 20), tipo de inmueble (carácter) y precio base (real). Realice las siguientes consultas:

a. La cantidad de departamentos vendidos.b. La cantidad de casas vendidas.c. El total de las ventas.Tenga en cuenta que los descuentos son respecto al precio base.

Tipo de inmueble Descuento

C (casa) 18%

D (departamento) 12%

Problema 5. La siguiente aplicación, permite procesar información de un conjunto de n (n<=1000), usando los siguientes atributos: código (solo de 3 dígitos); 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 continuación se describe cada módulo y la tarea específica 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, estación. Ver figura.

Valida(). Es un procedimiento para validar dato de usuario, solo dispone de tres opciones.

Longitud(). Procedimiento para defi-nir la cantidad de registros. En la siguiente figura se ilustra la ejecución de este módulo, donde para iniciar se


301

ingrese el registro de alumnos, pues más adelante existe el módulo de inserción.

Lectura(). Procedimiento en el que el usuario ingresa los datos de los registros por: nombres, apellidos y código y edad. Se almacenan en un vector según el tamaño 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 más registros. En nuestro caso el sistema solicita que ingrese el número 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 número de registro a eliminar, después de procesar, el sistema envia la confirmación respectiva. En la última figura se lista registros actuales.

En la siguiente figura se ilustra los registros restantes después de la eliminación.

BuscaEdad(). Procedimiento que permite al usuario buscar una edad respectiva.

302

Problema 6. Diseñar 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, código, edad. La entidad o tabla cursos debe aceptar m cursos (m<=10) por código, descripción y créditos, finalmente crear la entidad Alumnos_Notas, entidad que depende de los códigos de las dos tablas anteriores y sus datos son tres prácticas calificadas y dos exámenes (parcial y final).

Realice las siguientes consultas:

a. Listado de alumnos por código, apellido, sus cursos por código, nombre (descripción) y crédito, respectivamente.

b. Listado de alumnos por apellido, nombre, sus cursos por nombre (descripción) y sus notas (pc1, pc2, pc3, exp, exf).

c. Listado de alumnos por nombre, sus cursos por nombre (descripción) y sus notas (pc1, pc2, pc3) y su promedio de práctica, eliminando la menor nota.

d. Listado de alumnos por ape-llidos y nombres, sus cursos por nombre (descripción) y sus notas (pc1, pc2, pc3, exp, exf), su promedio de práctica, 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 (descripción) y sus notas (pc1, pc2, pc3, exp, exf), su promedio de práctica, 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 (descripción) y su promedio final ordenado en forma ascendente por apellidos (debe mostrar también la posición original y actual de cada registro, pues debido al ordenamiento los registros se intercambian).

Problema 7. Para implementar los módulos mostrados en la figura que contiene las siguientes opciones, donde cada opción se ejecuta usando los siguientes procedimientos:

crea_alumnos(): Procedimiento para registrar n alumnos (n<=1000). Debe validar que el código NO se repita. Si lee un código que ya existe, debe enviar el mensaje” Código Existe, vuelva a leer”.

303

crea_cursos(): Procedimiento para registrar m cursos (m<=10) por alumno, también debe validar que el código del curso que NO se repita. Si lee un código que ya existe, debe enviar el mensaje” Código Existe, vuelva a leer”. En la siguiente figura se ilustra procedimiento de lectura.

Editar_Notas(): Procedimiento para registrar máximo tres prácticas calificadas por cada alumno y su curso respectivo. Primero se lee el número de alumnos y luego código de

alumno y código 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 código actual del alumno sea igual al código registrado en la tabla alumnos.

Lista 1(): Procedimiento (opción A) lista los alumnos y sus cursos matriculados por código.

Lista 2(): Procedimiento (opción B) lista los alumnos por Código,

304

Apellidos y luego su(s) curso(s) por código y sus notas respectivas. Ver figura adjunta.

Si alumno no se matriculó, enviar el mensaje “alumno falta matricularse en sus cursos”.

Lista 3(): Procedimiento (opción C) lista los alumnos por Código, Apellidos y luego su(s) curso(s) por código y sus notas respectivas, mostrando también la Menor notar. Ver figura adjunta.

Lista 4(): Procedimiento (opción D) lista código de alumnos, de cursos y su promedio de practica eliminado la menor nota. Ver figura adjunta.

Lista 5 (): Procedimiento (opción E) lista código de alumnos, de cursos, su promedio de práctica eliminado la menor nota el estado Aprobado / Desaprobado. Asimismo, totaliza Aprobados y Desaprobados. Ver figura adjunta.

Lista 6(): Procedimiento (opción F) lista código de alumnos su promedio ponderado y la posición inicial de entrada.

Lista 7(): Procedimiento (opción G) lista código, apellidos, nombres de alumnos y su promedio ponderado.

Para la opción T, es un submenú/opciones que realiza operaciones de Inserción, eliminación, actualización, ordenamiento, búsquedas. Se debe hacer para cada tabla.

Problema 8. Diseñar un programa que permita leer datos de n empleados (n<100), datos correspondientes a: código (entero de 7 dígitos), apellidos y nombres (cadenas de longitud 30 caracteres), sueldo (real con dos decimales) y sexo (carácter: M / F). Hacer los siguientes reportes:

a. Listado de empleados por código, apellidos y sueldob. Listado de empleados por código, apellidos, sueldo ordenados en forma as-

cendente por apellidosc. Total de empleados y el Promedio de sueldo respectivo

305

Problema 9. Diseñe un programa que permita leer datos de n alumnos (n<100), datos correspondientes a: Código (siete dígitos, código no se debe repetir), apellidos y nombres (cadenas de 20 caracteres), para cada alumno se debe leer como mínimo dos y máximo cinco prácticas calificadas (entero). Luego calcule el promedio de prácticas eliminando la menor nota. Luego leer examen parcial y examen final, con estos datos y el promedio de prácticas, calcule el promedio final. Luego realice los siguientes reportes:

a. Código, apellidos, promedio de prácticas b. Apellidos, nombres, promedio de prácticas 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 cálculo 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 desaprobadosd. Alumnos por apellido y su menor promedio, también alumnos con mayor

promedio

Problema 10. Diseñe un programa que registre datos de las n (n<200), ventas de boletos de varias empresas, datos correspondientes a: código de la empresa (cadena de 4), la numeración del primer boleto vendido (entero), la numeración del último boleto vendido (entero), el precio del boleto (real), luego realice las siguientes consultas:

a. Listado de las n empresas por código, numeración del boleto y precio respectivob. Listado de las n empresas por código, cantidad de boletos vendidos y el importe

de esta venta La empresa con más boletos vendidos, así como la empresa con menor cantidad de boletos vendidos

Problema 11. Diseñar un programa que permita ingresar n alumnos ( n definido por el usuario), alumnos identificados por: Apellidos y nombre (cadenas de 20), fecha de nacimiento (día/mes/ año) y su edad respectiva. Luego realice las siguientes consultas:

a. Alumnos por apellidos, fecha de nacimiento y edadb. Alumnos ordenados por apellidos en forma ascendentec. El alumno(s) de mayor edad, alumno(s) de menor edad d. Total de alumnos y el promedio de edades

Problema 12. Diseñar un programa que permita ingresar n artículos ( n definido por usuario), donde cada artículo provee los siguientes campos: código (cadena de 4), nombre (cadena de 20), fecha de fabricación (dd/mm/aa), cantidad (entero) y precio (real). Realice las siguientes consultas:


306

a. Listado de productos por código, nombre, fecha de fabricación y preciob. Listado de productos ordenados en forma ascendente por precioc. Listado de artículo(s) con mayor precio y la cantidad

Problema 13. Diseñar un programa que permita ingresar n alumnos (n definido por usuario), los registros alumnos corresponden a un colegio, identificados por: código (cadena de 8), el apellidos (cadena de 20), puntaje (entero: 0...100) y sexo (carácter). Realice las siguientes consultas:

a. Listado de alumnos por: código, apellidos y puntajeb. Listado de alumnos por apellidos y ordenados por sexo en forma ascendentec. Total de alumnos indicando “Promovidos” cuando su puntaje es mayor que

20 y la cantidad de Repitentes, cuando su puntaje es menor que 20.


307

ObjetIvOs

- Cómo definir un archivo - Aplicar técnicas de archivos secuenciales y de acceso aleatorio- Cómo reconocer la dirección lógica y física de registros- Cuándo usar funciones de fin de línea y funciones de fin de archivo- Aplicar técnica de moldeamiento de datos - Aplicar técnica de programación independiente para crear módulos que sean

invocados como cabeceras del programa

archivos (file)

Capítulo 7


308

7.1 IntrOduccIón

Los archivos constan de una colección de registros y sirven para la entrada y salida de datos en computadora y son procesados con programas o lenguajes de programación 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 más eficiente para las operaciones de mantenimiento de Datos(inserción, eliminación, modificación, actualización).

7.2 caracterÍstIcas de lOs arcHIvOs

Las principales características 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 mo-

mentos

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 lógico 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 comunicación entre el programa y el sistema operativo acerca de cómo 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 comunicación entre ellos.


309

7.5 clasIFIcacIón 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 código ASCII. Este tipo de archivos solo tiene marcas lógicas de fin de línea (eol y eof), asimismo,no tiene CAMPOS, índices lógicosde registros para identificar los registros físicos.

7.5.2. archivos binarios

Este tipo de archivos procesan y almacenan los datos numéricos basados en su representación binaria. Cuando utiliza un lenguaje de programación, 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 programación.


310

7.6 clasIFIcacIón de arcHIvOs POr tIPO de accesO

Los archivos, de acuerdo a la técnica de acceso de datos, se clasifican en secuenciales o directos (acceso directo, aleatorios). En esta sección se ilustra el marco conceptual, las aplicaciones serán en los siguientes índices.

7.6.1. archivos secuenciales

La técnica 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 después del último registro; así, para consultar por un registro, es necesario recorrer todo el archivo, leyendo cada registro y comparándolo 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 dónde termina el archivo.

7.6.2 archivos directos: acceso aleatorio

Son aquellos que están formados por un conjunto de registros, todos de un mismo tamaño y se puede acceder directamente a un registro ubicando el puntero o apuntador en el índice y la función de acceso aleatorio seek(). En los siguientes tópicos se mostrará la sintaxis de la función respectiva y sus variaciones, respecto a que el puntero puede estar al inicio, al final o posición especificada por el programador.

7.7 dIreccIOnes lógIcas y dIreccIOnes FÍsIcas

El lenguaje de programación C++ usa direcciones físicas y no lógicas(pascal), es decir; que el direccionamiento consiste en el espacio ocupado por los datos en el archivo (calculado en bytes),no en el renglón al que se asignó dicho registro.

311

Ejemplo, suponga que tiene un archivo llamado “Empleados.txt” que almacena registros con diseño lógico mostrado en la figura. Dicho registro tiene 4 campos, cada uno con un tipo de dato definido, un tamaño y que al sumarlos se obtiene el espacio (57) ocupado para cada registro.

Observación. calcular dirección física antes de reposicionar el apuntador de archivo.

7.8 cálculO de dIreccIOnes FÍsIcas

Para poder reposicionar el apuntador de un archivo en un registro específico es necesario calcular su dirección física correspondiente de acuerdo al espacio ocupado por sus registros predecesores.

7.9 FuncIOnes Para el manejO de arcHIvOs

En esta sección se presenta los procedimientos generales para diseñar aplicaciones con archivos en lenguaje de programación C++ 5.02. Las aplicaciones se basanen el uso de registros (struct) en archivos, para lo cual se presentan los procedimientos y las funciones básica para este tipo de aplicaciones.

7.10 declaracIón de la varIable lógIca (“alIas”) del arcHIvO

Se debe iniciar con la siguiente librería estándar de entrada / salida:#include <stdio.h>

Asimismo, se debe declarar una variable dinámica de tipo archivo (FILE) que enlace el apuntador desde memoria RAM con el nombre del archivo (alias).

FILE *alias;

7.11 FuncIón Para PrOcesar arcHIvOs

Para la apertura de archivos se debe usar la función fopen() con los siguientes atributos:


312

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 deapertura

(archivos detexto)texto)

Modo deapertura(archivosbinarios)

Descripción

“r” “rb” Apertura en modo de sólo lectura. El archivo debe existir.

“w” “wb”Apertura en modo de sólo escritura. Si el archivo existe, se reescribirá (pierde el contenido anterior).Si archivo no existe, lo crea

“a” “ab”Apertura en modo de agregar. Si el archivo existe, los datos se agregan al final del archivo en caso contrario el archivo se crea.

“r+” “rb+” Apertura en modo de lectura/escritura. El archivo debe existir.

“w+” “wb+” Apertura en modo de lectura/escritura. Si el archivo existe, se reescribirá.

“a+” “ab+” Apertura en modo de lectura/agregar. Si el archivo no existe lo crea.

7.12 valIdar la aPertura de un arcHIvO

Se debe crear el módulo para validar la existencia del archivo. Si no existe, la respuesta será (F) o marcador lógico 0.

En la siguiente figura se ilustra la validación respectiva.

7.13cIerre de arcHIvOs usandO FclOse() y FclOseall()

Después de procesar datos del archivo se debe cerrar. Esto se logra mediante las funciones fclose() o fcloseall(), donde:

Función fclose (): cierra un archivo abierto

Función floreal (): cierra todos los archivos abiertos


313

7.14 escrItura de regIstrOs usandO FwrIte()

Esta función 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 dirección de memoria.

Esta función tiene cuatro argumentos: la variable que se desea grabar, su tamaño en bytes, la cantidad de variables y el alias del archivo donde se desea almacenar.

Sintaxisfwrite(&var_reg, sizeof(var_reg), 1, alias1);

Donde:

& : dirección de memoriavar_reg : es una variable registro1 : se procesará en cada operación 1 registroalias1 : es una variable lógica para relacionar con archivo físicoLa función fwrite() graba el registro en la dirección física

También puede usar fprintf ().

7.15 vacIandO lOs buFFers usandO FFlusH()

Un buffer es un área de almacenamiento temporal en memoria de todos los datos leídos o escritos en el archivo. Estos buffers retienen datos en tránsito desde y hacia el archivo y tienen la finalidad de hacer más eficiente la ejecución del programa.

Los buffers también se vacían cuando se cierra el archivo.

7.16 lectura de regIstrOs usandO Fread()

La función 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 función tiene los mismos argumentos que la función fwrite ().

fread(&var_reg, sizeof(var_reg), 1, alias1);

También puede usar la función fscanf(), funciona igual que scanf en cuanto a parámetros, pero la entrada se toma de un archivo en lugar del teclado.

7.17 FuncIón Para accesO de arcHIvOs

Función fseekf(): Esta función sirve para situar el cursor del archivo para leer o escribir en el lugar deseado. El valor de retorno es cero si la función tuvo éxito, y un valor distinto de cero si hubo algún error. También es importante mencionar que cada vez que se realiza una operación de lectura o de escritura, el apuntador se mueve al final de dicho dato, de tal forma que está posicionado en el siguiente,

314

por lo se debe asegurar que se encuentre en la posición deseada antes de realizar cualquier operación.

Sintaxisfseek(alias, direcc_fisica, Punto_de_referencia);

Donde:Alias: variable lógicadirecc_fisica: Se debe calcular la dirección física antes de reposicionar el puntador del archivo.Punto_de_referencia: se refiere desde dónde se iniciará el conteo de bytes determinado por la dirección física. Varía según:

1. SEEK_SET : el desplazamiento se cuenta desde el inicio del archivo. 2. SEEK_CUR: el desplazamiento se cuenta desde la posición actual del cursor. 3. SEEK_END : el desplazamiento se cuenta desde el final del archivo.

7.18 cOnOcer POsIcIón del aPuntadOr del arcHIvO

Función ftell(): Se usa para conocer la posición actual del apuntador de un archivo abierto. La posición se expresa en bytes (dirección física), 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 función fseek.

Sintaxis

rewind(alias)

7.20 detectandO el FInal del arcHIvO cOn FeOF()

Esta función 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

315

rename(“c:\\datost\\empleados.txt”, “c:\\datos\\trabajadores.txt”)Donde: empleados.txt : debe existir trabajadores.txt : nuevo archivo

7.22 elImInandO arcHIvOs cOn la FuncIón remOve()

Esta función 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.

Aplicación 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 foránea 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 sistemaSe dispone al usuario de un conjunto de alternativas que puede realizar con el sistema de mantenimiento: alternativas que se implementan mediante el siguiente módulo: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.- ACTUALIZACIÓN \n”;cout << “5.- ELIMINACIÓN \n”;

316

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 opción : “; cin >>i; cout <<endl; } while(i<0 || i>7); return(i); }

Alternativa 1. Módulo 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: código, nombre y apellidos. Esta información se implementa mediante el siguiente módulo:

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 completofwrite(&f1, sizeof(f1), 1, falumno); fclose(falumno); // Cierra el archivocout << «\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 acontinuación.

Alternativa 2. Módulo para ingresar datos de cursos. Registra la data de notas usando la tabla (struct) CURSO, que permite crear el archivo “CURSO.DAT” por código, descripción y créditos. Esta información se implementa mediante el siguiente módulo:

317

void IngresarCurso() { int cod_cur; system(“cls”);c o u t < < ” \ n \ r I N G R E S A R 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 archivocout << “\n\n\n\r CURSO REGISTRADO !!!\n”; getch(); return;}

Alternativa 3. Módulo 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 foráneas y los campos p1,p2,p3, ep, ef. Esta información se implementa mediante el siguiente módulo:

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 número 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: “;

318

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 módulos, se ha creado los tres archivos físicos, tal como se ilustra en la siguiente gráfica:

Mantenimiento. A partir de la alternativa 4, se considera mantenimiento de la data, es decir se puede modificar contenido de las archivos físicos (eliminar, insertar, etc.), así como modificar datos de algún registro que el usuario crea conveniente. A continuación, se procesan las alternativas, es decir, se puede usar indistintamente las alternativas, veamos:

Alternativa 6. Mostrar registro de alumnos.- En la siguiente gráfica, se ilustra el reporte de los registros de alumnos.

Esta interfase se logra al implementar el siguiente módulo.

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 N O M B R E 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<<”\

319

n\r__________________________”;cout << endl<<”\n\n”; cout << “\n\r<<< ... PRESIONE ENTER para continuar >>>»; getch(); return;}

Alternativa 4. Actualización.- Suponga que el error está en al apellido de Ana, es decir el apellido correcto es SIFUENTES, entonces se debe llamar el registro por código 100 (es la clave pimaria) y luego edite los nuevos datos. Este proceso se ilustra en la siguiente gráfica:

Verificación. Use alternativa 6 y por el código verificar el cambio, veamos:

Como se observa en la siguiente grafica, el registro número 1 ha sido actualizado.

Alternativa 5 Eliminación. Se elimina registros mediante la edición del código, tal como se ilustra a continuación:

Para la verificación, use la alternativa 6, tal como se ilustra a continuación, que solo queda en el archivo alumnos.dat, el registro correspondiente a Carlos.

Este proceso se logra al implementar el siguiente módulo:

void Eliminación(){ 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”;}

320

fclose(falumno); Eliminar(); getch(); return; } fread(&f1, sizeof(f1), 1, falumno); }cout << “\n\rNo se encuentra ese registro !!!\n”; fclose(falumno); // Cierra el archivoEliminar(); 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. Diseñar programas que permitan crear los archivos mostrados en las siguientes figuras usando las técnicas de: Programa 1.- Solo usa técnica de archivos.

Se entiende que los campos claves no deben repetirse en las tablas, luego realice las siguientes consultas usando las técnicas de:


321

I. Técnica de archivos:

Consulta 1. Listado de alumnos por código y edad, pero ordenados en forma ascendente por edad

Consulta 2. Listado de alumnos por código, apellidos, nombre de cursos, notas y su promedio respectivo, indicando el estado aprobado / desaprobado.

Problema 2. Diseñar programas que permita consultar data histórica (avance curricular) de n alumnos. Para lo cual considere las siguientes restricciones:

- Considere solo 10 ciclos académicos.- 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 año. - Las notas por cada ciclo varían. - Cuando ingresa a consultar las notas de un alumno, se elije el primer año

académico, en este año el programa permite al usuario consultar ciclo por ciclo (hasta 3), luego puede pasar al segundo año y repite lo mismo del primer ciclo- 1.

Ejemplo:

Códigos

100 Ciclos Promedio Ciclos Promedio Ciclos Promedio

2005-1 12.3 2006-1 5.5 2007-1 10.2

2005-2 11.4 2006-2 12.5 2007-2 3.4

2005-3 15.8 2006-3 6.7 2007-3 11.2

200 Ciclos Promedio Ciclos Promedio Ciclos Promedio2005-1 11 2006-1 4.4 2007-1 12.4

2005-2 11.4 2006-2 12.2 2007-2 17.5

2005-3 12 2006-3 11.3 2007-3 11.5

Problema 2. Usando archivos con diseñar un programa que permita disponer de un sistema académico de matrícula, para lo cual se considera el siguiente modelo relacional de base de datos:

Usando el modelo relacional, se inicia la programación considerando interfaces amigables y didácticas para los usuarios.


322

En las siguientes interfaces se ilustra los procesos a diseñar:

Interface de validación: En la presente interface solo el administrador tiene todos los derechos en el sistema tales como: insertar, eliminar, modificar, etc.


323

Interface de validación 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.


324

Interface para registrar datos de las entidades:

Si seleccionamos opción 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,


325

solo puede visualizar sus datos. También si el alumno no está registrado, se puede crear sus datos como usuario.

El usuario administrador, puede usar la siguiente interface


326


327

ObjetIvOs

- Definición de punteros.- Cómo identificar una dirección de memoria y cómo asignar espacios de

memoria.- Usar estructuras de pilas para procesar archivos.

8.1 PrOgramacIón dInámIca (PunterOs)

Un puntero es un tipo especial de variable que almacena el valor de una dirección de memoria, donde dirección puede ser la de una variable simple, pero más frecuentemente será la de un elemento de un array, una estructura u objeto de

Programación dinámica (punteros)

Capítulo 8


328

una clase. Los punteros pertenecen a un tipo (type), en la práctica se afirma que un puntero “apunta hacia” un tipo al que pertenece.

8.2 creacIón de un PunterO

Un puntero se declara de la siguiente manera:

Donde:

Tipo_dato: tipo estándar de dato*: apunta a…Variable: identificador válido

Ejemplo:void main(){ int * x ; // x es un puntero a enterochar *nombre ; // nombre es un puntero a carácterfloat *a,*b ; //a y b son punteros a reales}

Notaciones: Las siguientes sintaxisvoid main(){ int *a;int* a; }

Las dos notaciones son válidas, 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 dirección 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 dirección de memoria de una variable.

variable puntero

valor guarda dirección

X *P

& Q

* P


329

8.4 InIcIalIZacIón de un PunterO

int x =20 ;int * p ; p= & x ;

Declaración e inicialización. Un puntero, después de ser declarado (para comenzar a existir), requiere ser inicializado, lo cual se realiza mediante el operador de asignación (‘=’).ç

void main() {int a; int * b;b = &a; //El puntero ‘b’ apunta a ‘a’.}

Opciones de inicialización

Puntero inicializado a partir de:

Declaración e inicialización en una misma línea

Declaración e inicialización desdobladas

Un objeto individual T x; T* ptr = &x; T* ptr;

ptr = &x;

Valor 0 = puntero nulo Null=0

T* ptr = 0; T* ptr; ptr = 0;

T* ptr = NULL; T* ptr; ptr = NULL;

Memoria dinámica. También 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 relación a la memoria dinámica, es muy importante, por la razón de que al pedir, al sistema operativo, una cantidad determinada de memoria dinámica 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 dinámica son new y delete. La sintaxis es la siguiente:

Variable individual Array de elementos individuales

Reserva de memoria dinámica int* a = new int int* a = new int [n];

Liberación de memoria reservada delete a; delete [] a;

330

aPlIcacIOnes

Problema 1. Diseñe un programa que permita declarar dos punteros y que apunten a su variable dinámica para almacenar números ingresados por el usuario, luego genere reportes para conocer: suma de las variables dinámicas, contenido de cada variable, dirección de cada puntero y finalmente, liberar espacio de memoria ocupada por los dos punteros.

Solución:*/ punt_0011_2008.cppvoid 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 dirección de puntero *a es = “<<a; gotoxy(10,14);cout<<” El La dirección de puntero *b es = “<<b; delete a; delete b; gotoxy(10,16);cout<<” Eliminación de espacio de memoria: delete a “; gotoxy(10,17);cout<<” Eliminación 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 número entero quees igual a 16. Generar un reporte para conocer contenido y la dirección de memoria donde se encuentra dicha variable.

Solución:*/ Punt001_2008.cppvoid main(){ int x=16; int *p;

331

p=&x;gotoxy(10,4);cout<<” El contenido es de la variable puntero es = “<<*p; gotoxy(10,5);cout<<” El valor de la dirección del puntero es = “<<p; getche();}

Problema 3. Diseñe un programa que permita ingresar por teclado dos números enteros y que estos permitan apuntar a su puntero respectivo, luego generar un reporte que permita la suma acumulada de las dos variables dinámicas y su dirección de la suma de dichos punteros.

Solución / puntero_P002_suma_2008.cppvoid main(){ int x,y,*p,*q,suma; gotoxy(10,4);cout<<”Ingrese primer número = “;cin>>x; gotoxy(10,5);cout<< “ Ingrese segundo número = “;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. Diseñe un programa, usando variables dinámicas, que permite validar datos de usuario por código =”tcn” y clave =”123”. Si los datos son correctamente ingresados, el sistema solicita que ingrese dos números enteros para calcular la suma respectiva. A este resultado y usando una función que reciba como parámetros la suma acumulada de los dos variables dinámicas, mostrarlo en forma invertida. El programa debe ser interactivo con el usuario. Si los datos son ingresados incorrectamente, el sistema finaliza.

Solución //punt_valida_usuarios.cppint 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;

332

gotoxy(10,5);cout<<”Ingrese clave = “; cin>>clave;if (strcmp (cod,”tcn”)==0 && (strcmp(clave,”123”)==0)){ gotoxy(10,7);cout<<”Ingrese número a = “;cin>>*a;gotoxy(10,8);cout<<”Ingrese número 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 número y donde cada elemento tiene un único predecesor y un único sucesor o siguiente, excepto el primero y el último de la lista.

Lista

5 4 1 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 también 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 inserción y borrado de nuevos elementos se realiza solo por un extremo que se denomina cima o tope (top).

333

Dado que las operaciones de inserción y eliminación 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, razón por la cual a estas estructuras se les denomina LIFO (Last –input , first output)

En las operaciones se presenta:

Push(): meter, poner (inserción de elementos)Pop(): sacar, quitar (eliminación de elementos)

Problema 1.- Diseñe un programa mediante una función prom_sumas( ) que reciba como argumentos tres prácticas 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 función invertir(), la cual devuelve en forma invertida. Asimismo, en una función guarda(), recibe también el promedio entero y devuelve procesado en dígitos.

Solución (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;

334

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();}

335

Problema 2. Diseñe un programa mediante una función 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 función invertir(), la cual devuelve en forma invertida.

Solución (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)

336

{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 semántica “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.-Diseñar un programa que permitaalmacenar las notas de tres alumnos en una estructura dinámica pila, luego genere un reporte de los elementos de lapila, liberar (eliminar) espacio de memoria utilizada por cada nodo.

Solución//pila_2010_3_Nodos.cpptypedefstruct 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

337

gotoxy(10,11); cout<< “Pila:”;gotoxy (18,11);cout<<r->nota<<” => “<<q->nota<<” => “<<p->nota;// eliminando nodosdelete [] p;delete [] q ;delete [] r; o free(p);getche();}

Problema 2. Diseñar un programa que permita almacenar notas de alumnos en una pila de tamaño 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): función 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.

Solución//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];t y p e d e f s t r u c t n o t a s l a u m n o s / /MODELO { int nota; // DATO DE USUARIOstructnotaslaumnos *sgte;//ENLACE DE SIGUIENTE NODO }nodo; //VAR REGISTROnodo *crear_nodo(int valor) //creo nodo y le asigno datos { nodo *r; // r toma dirección de memoria r = new nodo; // r recibe espacio de memoriar->nota=valor;//llenar campo del nodor->sgte=NULL;//termina de definir el nodoreturn(r);//returne la dirección de r

338

}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<<”É”; //esquinasfor (i=11 ;i <=59 ; i++) {gotoxy(i,4) ;cout<<”Í”; gotoxy(i,5) ;cout<<”Í”; // lineashorizontalesgotoxy(i,20) ;cout<<”Í”; }gotoxy(60,4) ;cout<<””; gotoxy(60,20) ;cout<<” “; //esquinasfor(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;//inicializodo{ 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 función y asigno nota // preguntamos: existe pila o noif (p==NULL) //1.- Pila p NO existe {p=r; //tomo dirección de nodo r }else // 2.- pila existe { r->sgte=p;//inserto nodo delante de p p=r;//p recibe dirección de r } }//fin de for }// fin procedimientovoidaprob_desap(nodo *&p)// recorrer la pila{ marco();nodo *aux;// crear var puntero para obtener copiaaux=new nodo;// su espacio de memoriaaux=p; //hacer copia de p en auxwhile(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 }

339

else {de++;//desap++;

notasde[de]=aux->nota; } aux=aux->sgte;// pasar al nuevo nodo } //fin del whilegotoxy(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 copiaaux=new nodo;// su espacio de memoriaaux=p; //hacer copia de p en auxif(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 copiaaux=new nodo;// su espacio de memoriaaux=p; //hacer copia de p en auxgotoxy(13,15);cout<<”Ingrese Nota a Buscar = “;cin>>notas;while(aux!=NULL)//recorre la lista{if(aux->nota==notas) { nn++; }

340

aux=aux->sgte;// pasar al nuevo nodo } //fin del whilegotoxy(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. Diseñar un programa que este compuesto por los siguientes subprogramas:

- Menup(): genera las siguientes alternativas/opciones tal como se ilustra en la siguiente figura: donde cadaopción se ejecuta con los siguientes subprogramas:

- crear_nodo(valor): función 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): procedi-miento 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 según posición 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

341

todos sus elementos.

Solución//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 opción>==> “; clreol();//system(“color 4e”); cin>>i;}while(i<0 || i>9);return(i);}voidcrea_lista (nodo *&p) // dinámico y dirección{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;

342

r = crear_nodo(nota); // r recibe la dirección de la funciónif (p==NULL) // si pila no está creada entonces reciba la dirección 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 dirección 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 auxintap=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 whilegotoxy(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 “;

343

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;

344

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 Búsqueda “;gotoxy(15,6);cout<<”________________________________” ;gotoxy(10,8);cout<<” Ingrese posición: “;cin>>pos;while(p!=NULL){ cont++;if(cont==pos){ gotoxy(10,12);cout<<”La posición “<<pos<<” contiene la nota : “<<p->nota;getche();return; } p=p->sgte;}gotoxy(10,12);cout<<” La posición no existe”;getche();return;}voidBuscarXVal(nodo *p){caratulmarco();intdato,cont=0;gotoxy(20,5);cout<<” Módulo de Búsqueda “;gotoxy(4,6);cout<<”________________________________” ;gotoxy(10,8);cout<<” Ingrese Nota = “;cin>>dato;;while(p!=NULL){ cont++;

345

if(p->nota==dato) {gotoxy(10,12);cout<<” La Nota se encuentra en la posición : “<<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();

346

break;case 0: clrscr();log=false; } }while(log);}

8.8 nIvel arcHIvOs

También 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.

aplicación

Diseñar 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 créditos 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, según paso 1. Los resultados se ilustran en la siguiente interface.

Observe que en el reporte se visualiza los elementos de la estructura dinámica PILA (LIFO), asimismo, no existen alumnos con promedio menor a 10.

Implementación

I. CREA ARCHIVO//Arc_crea_Pilas_Alumn.cppstruct 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);

347

cout<<” Nombre Promedio Creditos “;gotoxy(5,5); cout<<”___________________________”;while(resp==’S’||resp==’s’){i++; falumnos=fopen(“ALUMNOS.txt”,”a+”);if(falumnos == NULL){ fa lumnos=fopen(“ALUMNOS.txt”,”a+”);}gotoxy(12,5+i);gets(cod) ;fread(&alumnos,sizeof(alumnos),1,falumnos); while(!feof(falumnos)){ i f (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)

Solución //pila_jala_arch_Alumn.cppstruct ALUM{char nomb[12]; float prom;int cred;}f1;typedef struct pila_trabajadores{ float prom; char nombres[20]; int cred;

348

struct pila_trabajadores *sigte;}nodo;//crear una funcion que “jale” registros del Archivo externonodo *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’);}


349

8.9 cOmPendIO de PrOblemas

Problema 1. Diseñar programas que permitan crear los archivos mostrados en las siguientes figuras usando las técnicas de:

1. Programa 1. Solo usa técnica de archivos2. 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 técnicas de:

I.- Técnica de archivos

Consulta 1. Listado de alumnos por código y edad, pero ordenados en forma ascendente por edad.

Consulta 2. Listado de alumnos por código, apellidos, nombre de cursos, sus notas y su promedio respectivo indicando el estado aprobado / desaprobado.

II. Técnica de pilas

Consulta 1. Listado de alumnos por código, apellidos, código de cursos y sus notas.

Consulta 2. Listado de alumnos por código, código de cursos, sus notas y su promedio respectivo.

Problema 2. Diseñar programas que permitanconsultardata histórica (avance curricular)de n alumnos. Para lo cual considere las siguientes restricciones:

1. Considere solo 10 ciclos académicos.2. El archivo ALUMNOS.TXT, puede ser el único.3. El archivo NOTAS.TXT solo varía los siguientes datos: - Considere que se implementaron tres ciclos por año. - Las notas por cada ciclo varían - Cuando ingresa a consultar las notas de un alumno, se elije el primer año

académico, en este año el programa permite al usuario consultar ciclo por


350

clico (hasta 3), luego puedepasar al segundo año y repite lo mismo del primer ciclo.

Ejemplo:

Códigos

100 Ciclos Promedio

Ciclos Promedio

Ciclos Promedio2005-1 12.3 2006-1 5.5 2007-1 10.22005-2 11.4 2006-2 12.5 2007-2 3.42005-3 15.8 2006-3 6.7 2007-3 11.2

200 Ciclos Promedio

Ciclos Promedio

Ciclos Promedio2005-1 11 2006-1 4.4 2007-1 12.42005-2 11.4 2006-2 12.2 2007-2 17.52005-3 12 2006-3 11.3 2007-3 11.5

Problema 3. Diseñar un programa que permita leer n (n>10) alumnos por código(int) y apellidos(char(20)) y almacenarlo en un archivo “Lista.dat”, usando la técnica de colas, luego debe realizar los procesos mostrados en la siguiente pantalla.

El programa debe ser interactivo con el usuario, es decir; después de mostrar el resultado se debe mostrar la siguiente pregunta: “¿Sr. desea hacer nueva consulta? (S/N)”.

Problema 4. Una sección cuenta con 40 alumnos codificados correlativamente como cod01, cod02, cod10, etc., (son únicos, no se repiten). Diseñen un programa que genere aleatoriamente (o puede leer) las notas de los 40 alumnos (colocar en un vector) de la sección e imprima a continuación un listado como el siguiente:

LISTADO GENERAL DE NOTAS ------------------------------------------------------------------ Código Notas Condición ------------------------------------------------------------------- cod01 17 Aprobado cod02 08 Desaprobado cod03 14 Aprobado . .


351

. . cod45 06 Desaprobado cod15 06 Desaprobado

-------------------------------------------------------------------

Además, en ese mismo instante, mostrar por pantalla un reporte estadístico.

REPORTE ESTADÍSTICO----------------------------------------------------------------------------------Número de aprobados: 33 (73.33 %) (calculado con todas las notas) Número 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 días que dicta cada curso, el pago por hora es de acuerdo a la categoría según:

Categoría 1: 20 soles Categoría 2: 23 soles Categoría 3: 27 soles

Usando técnica de archivos con pilas/colas diseñar el programa que permita leer los datos solicitados, según campos mostrados, en cada entidad el siguiente modelo relacional de base de datos:

Aquí, se ilustra tablas con datos de algunos registros.

Luego mostrar resultados de acuerdo al siguiente formulario:

CURSO

CODCUR5C NOMCUR 15C

DIARIO

CODDOC 5C CODCUR 5C HORAS DOUBLE FECHA 10C

DOCENTE

CODDOC 5C NOMDOC 30C CATEGORIA int.

D001 C001 4 11/10/10D001 C004 5 15/10/10D002 C003 3 17/11/10D002 C001 4 21/11/10D003 C005 3 23/11/10D003 C003 2 25/11/10

C001 Matemática IC002 Análisis IIC003 Fisca IC004 Química

D001 Luis Vera 1D002 Ana García 3D003 Juan Lopez 2

352

RECORD DE HORAS DICTADASCódigo del docente: XXXXXXXX (se ingresa) Nombre del docente: xxxxxxxxxxxxxxxxxxxxxxxxxxxxx (se obtiene del sistema)Categoría => 99 Pago hora=> “Fecha Horas Nombre del curso XXXXX 999 xxxxxxxxxxx “Total horas => 999,999. Total pago => 999.999.99

Problema 6. Diseñar un programa que ingrese a una estructura de datos PILA, datos de n socios de un club (N<=1000) por: código, 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 más alta.c. Los dos socios de menos edad.

Los datos correspondientes a estudiantes de una institución educativa se ilustran en los siguientes archivos:

ALUMNOS.DAT CURSOS.DATCód_al Apellidos Nombres Cod._cur. Descripción Área acad.

100 Salas Juan 124 Matemáticas Básicas200 Solís Pedro 760 Compiladores Sistemas300 Céspedes María 195 Numéricos Básicas 400 Carrasco Noemí 511 Costos Gestión

Código Cod._cur. N1 N2 N3 pp100 124 14 11 10 ¿ ?200 760 13 14 05300 124 11 11 14400 124 10 10 13100 760 08 10 14

NOTAS_ALUMNOS.DAT

Se pide:

a. Diseñar un programa que permita: crear los archivos físicos: ALUMNOS.DAT, CURSOS.DAT y NOTAS_ALUMNOS.DAT b. Diseñar un programa: Reportes.CPP, programa que permita mostrar un

reporte de los archivos alumnos o cursos o notas_alumnos.c. Diseñar un programa: Insertar.CPP, programa que permita insertar registros

correspondientes a alumnos o cursos o notas_alumnos.d. Diseñar un programa: Eliminar.CPP, programa que permita eliminar registros

alumnos o cursos o notas_alumnos.

353

e. Diseñar un programa: Modificar.CPP, programa que permita modificar re-gistros correspondientes a alumnos o cursos o notas_alumnos.

f. Diseñar un programa: Estado_Alum.CPP, programa que permita hacer un reporte de alumnos por: código, apellidos y nombre, cond_cur, descripción y sus promedios, mostrando el estado:“aprobado ” o “desaprobado”.

g. Cuando realiza el proceso de eliminación, guardar como histórico todos los registros eliminados en un archivo “registros_baja.txt”.

Problema 7.- Usando pilas, diseñar un programa que permita ingresar datos de n alumnos (n<=1000) por apellidos, nombres, código, edad y sus evaluaciones respectivas: tres prácticas calificadas y dos exámenes.

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 prácticas, 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.


354

Reporte # 2: Listado de los alumnos ordenados por edad y en forma ascendente. Asimismo, el usuario debe buscar edad específica.

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 ejecución).

Reporte # 5: Módulo para insertar registros.


355

Reporte # 6: Módulo que permite eliminar registros, solicita el número de registros a eliminar e informa el total disponible. Listado después de eliminar.

Problema 8. Usando archivos con pilas/ colas, diseñar un programa que permita disponer de un sistema académico de matrícula, para lo cual se considera el siguiente modelo relacional de base de datos:

Usando el modelo relacional, se inicia la programación considerando interfaces amigables y didácticas para los usuarios.

En las siguientes interfaces se ilustra los procesos a diseñar:

Interface de validación: En la presente interface solo el administrador tiene todos los derechos en el sistema tales como: insertar, eliminar, modificar, etc.


356

Interface de validación de usuario:

Usar las interfaces del problema 2 del capítulo VII de Archivo


357

bibliografía

Deitel & Associates Inc. C/C++ Como programar. 4a ed. México: Prentice Hall, 2004.

Joyanes, Luis. Fundamentos de programación. Madrid: Mc. Graw Hill, 2004

------------------. Programación en Turbo Pascal. 3a Madrid...


358


359

Anidamiento de registros .............................................................276ANSI C ............................................................................................. XVArgumento ......................................................................................225Arrays bidimensionales ................................................................149Arreglos unidimensionales ...........................................................191Cadenas de caracteres ...................................................................199Cin.getline .......................................................................201, 216, 218Conversión a mayúscula y minúscula ........................................215Colas (FIFO) ....................................................................................351Estructura repetitiva ............................................................29, 37, 44Estructura selectivas condicionales ...............................................16Estructura selectiva compuesta ......................................................18Funciones.........................................................................................221Funciones para invertir cadenas ..................................................214Funciones para la comparación de cadenas ...............................210Identificadores ....................................................................................4Inclusión de una cadena en otra ..................................................215Lenguaje de programación procedural ..............................................XVLenguaje orientado a objetos ......................................................... XVLenguajes de máquina ........................................................................3Operaciones con vectores ..............................................................126Parámetro ................................................................................225, 227Programación dinámica (punteros) .............................................327Recursividad directa e indirecta ..................................................259Registros ..........................................................................................273Rewind .............................................................................................314Tipos de datos .....................................................................................5Transformación de cadenas ..........................................................213Variables locales y globales ...........................................................226

Índice temático


360


361

Este libro se terminó de imprimir en el mes de mayo de 2012 en los talleres gráficos de la imprenta de la Editorial Universitaria de la

Universidad Nacional de Ingeniería


362

3cera Edi 3 Lenguaje de Programacion Borland

Documents

Transcript of 3cera Edi 3 Lenguaje de Programacion Borland