Lenguaje_de_programacion_Borland

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

Teodoro Luciano Córdova Neri

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

Universidad Nacional de Ingeniería Editorial Universitaria

I


Rector Dr. Ing. Aurelio Padilla Ríos Primer Vicerrector Geol. José S. Martínez Talledo Segundo 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.2 Impreso en el Perú / Printed in Peru © Teodoro Luciano Córdova Neri Derechos reservados © Derechos de edición Universidad Nacional de Ingeniería Editorial Universitaria

Av. Túpac Amaru 210, Rímac – Lima Pabellón Central / Sótano Telfs. 4814196 / 4811070 anexo 215 Correo-e: [email protected] Jefe EDUNI: Prof. Álvaro Montaño Freire Coordinador 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.

II


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íos Rector

III


IV


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...

V


VI


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

VII


VIII


Índice

Presentación................................................................................................................XIII Introducción.................................................................................................................XV Capítulo I Generalidades................................................................................................................ 1 1.1 Introducción......................................................................................................... .1 1.2 Introducción a la programación......................................................................... 1 1.3 Características de un algoritmo de computador.............................................. 2 1.4 Lenguajes de programación................................................................................ 2 1.5 Lenguajes de máquina......................................................................................... 3 1.6 Lenguaje de bajo nivel.......................................................................................... 3 1.7 Lenguaje de alto nivel.......................................................................................... 3 1.8 Programa ejecutable............................................................................................. 3 1.9 Compilador............................................................................................................ 3 1.10 Palabras reservadas.............................................................................................. 3 1.11 Identificadores....................................................................................................... 4 1.12 Comentarios........................................................................................................... 4 1.13 Tipos de datos....................................................................................................... 5 1.14 Carácter (char)....................................................................................................... 5 1.15 Declaración de constantes simbólicas................................................................ 6 Capítulo II Estructuras de control................................................................................................. 11 2.1 Estructuras secuenciales ................................................................................... 11 2.2 Estructuras selectivas condicionales................................................................ 16 2.2.1 Estructura selectiva simple............................................................................... .16 2.2.2 Estructura selectiva compuesta........................................................................ 18 2.2.3 Estructura condicional con anidamiento......................................................... 19 2.3 Estructuras múltiples......................................................................................... 21 IX


2.4 Estructuras repetitivas....................................................................................... 29 2.4.1 Estructura repetitiva con pretest de prueba................................................... 29 2.4.2 Estructura repetitiva con postest de prueba.................................................. 37 2.4.3 Estructura repetitiva cuando se conoce el número de iteraciones ............. 44 2.4.4 Estructuras múltiples – módulo de operaciones aritméticas....................... 85 Capítulo III Estructuras de datos arrays...................................................................................... 123 3.1 3.2 3.3 3.4

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

Capítulo IV Las cadenas de caracteres......................................................................................... 199 4.1 Introducción...................................................................................................... 199 4.2 Punteros a cadenas........................................................................................... 200 4.3 Funciones para el tratamiento de cadenas:strlen(), strcat()........................ 202 4.4 Copia de cadenas:stpcpy(), strcpy(), strncpy()............................................. 204 4.5 Funciones para buscar un carácter en una cadena:strchr(), strrchr()........ 206 4.6 Función para reconocimiento de una porción de cadena: strspn(), strcspn(), strpbrk() y strtok().......................................................................... 208 4.7 Funciones para la comparación de cadenas: strcmp(), strnicmp(), stricmp()............................................................................................................. 210 4.8 Transformación de cadenas: strset(), strnset().............................................. 213 4.9 Funciones para invertir cadenas:strxfrm(), strrev()..................................... 214 4.10 Conversión a mayúsculas y minúsculas: strupr(),strlwr().......................... 215 4.11 Inclusión de una cadena en otra cadena........................................................ 215 Capítulo V Programación modular............................................................................................. 221 5.1 Introducción...................................................................................................... 221 5.2 Funciones definidas por el usuario................................................................ 222 5.3 Declaración y definición de funciones........................................................... 224 5.4 Lista de parámetros y sus tipos de datos...................................................... 225 5.5 Variables locales y globales............................................................................. 226 5.6 Parámetros por defecto, valor......................................................................... 227 5.7 Funciones que llaman a funciones................................................................. 246 5.8 Funciones recursivas........................................................................................ 259 X


Capítulo VI Registros..................................................................................................................... 273 6.1 6.2 6.3 6.4 6.5 6.6

Introducción. Definiciones.............................................................................. 273 Definición y declaración de una estructura.................................................. 275 Variables registro (instancias)......................................................................... 275 Anidamiento de registros................................................................................ 276 Acceso a los elementos de una estructura..................................................... 276 Aplicaciones....................................................................................................... 277

Capítulo VII Archivos (File)…….………………….……………..............……........................... 307 7.1 Introducción...................................................................................................... 308 7.2 Características de los archivos........................................................................ 308 7.3 Archivos (file).................................................................................................... 308 7.4 Apertura de archivos........................................................................................ 308 7.5 Clasificación de archivos por tipo de contenido: texto, binarios............... 309 7.5.1 Archivos de texto.............................................................................................. 309 7.5.2 Archivos binarios.............................................................................................. 309 7.6 Clasificación de archivos por tipo de acceso................................................. 310 7.6.1 Archivos secuenciales....................................................................................... 310 7.6.2 Archivos directos: acceso aleatorio ............................................................... 310 7.7 Direcciones lógicas y direcciones físicas........................................................ 310 7.8 Cálculo de direcciones físicas.......................................................................... 311 7.9 Funciones para el manejo de archivos........................................................... 311 7.10 Declaración de la variable lógica (“alias”) del archivo................................ 311 7.11 Función para procesar archivos...................................................................... 311 7.12 Validar la apertura de un archivo................................................................... 312 7.13 Cierre de archivos usando fclose() y fcloseall()............................................ 312 7.14 Escritura de registros usando fwrite()........................................................... 313 7.15 Vaciando los buffers usando fflush ()........................................................... 313 7.16 Lectura de registros usando fread ().............................................................. 313 7.17 Función para acceso de archivo...................................................................... 313 7.18 Conocer posición del apuntador del archivo:función ftell()...................... 314 7.19 Posicionando apuntador al inicio del archivo: rewind()............................. 314 7.20 Detectando el final del archivo con feof()...................................................... 314 7.21 Cambio de nombre de archivo rename()....................................................... 314 7.22 Eliminando archivos con la función remove().............................................. 315

XI


Capítulo VIII Programación dinámica........................................................................................... 327 8.1 Programación dinámica:punteros.................................................................. 327 8.2 Creación de un puntero................................................................................... 328 8.3 Operadores........................................................................................................ 328 8.4 Inicialización de un puntero............................................................................ 329 8.5 Lista..................................................................................................................... 332 8.6 Pila....................................................................................................................... 332 8.7 Punteros nivel RAM......................................................................................... 336 8.8 Punteros y archivos......................................................................................... 346 8.9 Compendio de problemas............................................................................... 349 Bibliografía.................................................................................................................. 357 Índice temático. ……………………………………………………...........…..…… 359

XII


Presentación 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

XIII


XIV


Introducción 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

XV


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

XVI


Capítulo 1

Generalidades

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 nivel 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, relacionales, funciones resto y parte entera. - Usar los tipos de datos enteros, reales, 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.

1


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 2


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.

3


Ejemplos: break do enum int typedef bool double for private while case else if sizeof

1.11 Identificadores Son secuencias de caracteres que representan a las variables, constantes, tipos, funciones, clases y etiquetas en un programa. En C++, un identificador 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úmero nombre apellidos: contiene un espacio en blanco _i_y: comienza con dos subrayados x*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. 4


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

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

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

Reales

Rango

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)

5


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++. Ejemplos float 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.

6

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

Operador

Significado

Ejemplo

Negación

!

Negación lógica (NOT)

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

Contador Incremento

++

Preincremento o posincremento

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

Contador Disminuir

--

Predecremento o posdecremento

--n//

Multiplicar

*

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

>=

Mayor o igual que d >= e

==

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
Asignación

=

Asignación

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

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

Igualdad

Expresiones: *=

n disminuye en 1

c>d

Estructura básica de un programa // directivas o librerías # include

7


# 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 ; return(expresión_de_tipo_dato); } tipo_nfuncion_n(lista_de_argumentos) { <ídem caso de la funcion1>; } / /Programa principal voidmain() { Declaraciones sobre variables locales al proceso principal ; 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. Directivas 2. Declaración y definición de funciones secundarias definidas por el usuario 3. Una función principal main() Notas: 1. La función principal o main() regresa un valor 0 al sistema operativo para indicar 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; }

8


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 Las demás librerías el usuario definirá según su requerimiento.

9


10


CAPÍTULO II

Estructuras de control 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 _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 (“;”). 11


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 #include //para setiosflags void main() { float a,b,c,p,area; clrscr(); gotoxy(8,2);cout<<”Ingrese los lados del triangulo”; gotoxy(10,4);cout<<”a = “; cin>>a; gotoxy(10,5);cout<<”b = “; cin>>b; gotoxy(10,6);cout<<”c = “; cin>>c; p=(a+b+c)/2; gotoxy(10,8);cout<<”El perímetro es “<
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 void main() { float s_basico,bonif,dscto,aumento,s_neto,s_real,fon,afp,snp, float inval,senati,aport; char nom[20],cod[5]; clrscr(); 12


gotoxy(24,1),cout<<” SISTEMA DE PLANILLAS “; gotoxy(24,3),cout<<” Ingrese datos del trabajador:”; gotoxy(5,5),cout<<”Nombre :”;cin>>nom; gotoxy(5,6),cout<<”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. “<
13


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 V y V==> resp=V=1 - resp=(ac));//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 #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<>a; gotoxy(10,4);cout<<” Ingrese b = “;cin>>b; gotoxy(10,5);cout<<” Ingrese c = “;cin>>c; resp=(a V y V==> resp=V=1 gotoxy(10,7);cout< resp = “<< resp; getche(); resp=(ac));//2<3 y not(3>4) ==>V y V ==>resp= V= 1 gotoxy(10,8);cout< “<< c <<” ==> res = “<

resp=(a==b)|| (!(b>c));//2=3 o not(3>4) ==> F o not(F)==> resp=V=1 gotoxy(10,9);cout< “<< c <<” ==> resp = “<c);//2=3 y(3>4) ==> F y F = 0; gotoxy(10,10); cout< “<< c <<” ==> resp = “<c);//2=3 o (3>4) F o F = 0 gotoxy(10,11); cout< “<< c <<” ==> resp = “< resp = “<resp= “<>letra1; gotoxy(10,16);cout<<”Ingrese Segunda letra = “; cin>>letra2; letra=letra1 #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<>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<
15


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

Cuando se ejecutan varias sentencias dentro de la estructura If () { instrucción_1; instrucción_2; ………………... Instrucción_n; } Observaciones: a. 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.

16


Solución // if_resto.cpp #include #include #include 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 = “<>n; dato=n; if(n>99) {dos_dig=dato%100; gotoxy(10,5);cout<<” Dos Últimos dígitos de “<< n<<” es = “<
17


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. Sintaxis Cuando las instrucciones a ejecutarse son simples if () 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 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<
18


Si < expresión > es verdadera, se ejecuta el bloque , en otro caso se ejecuta las 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 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ígito r1=num%100; //obtiene dos últimos dígitos d=r1/10; u=r1%10; inv=u*100+d*10+u; if (num==inv) { clrscr(); gotoxy(10,4);cout<<” El número”<
2.2.3. Estructura condicional con anidamiento ……………………………. if ( < condicion 1 >) else if (< condicion 2 >) < instruccion_1;> ……………... else if (< condicion n >) else Aquí el programa realiza una sola para un 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...).

19


Observación. Si el bloque de 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 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 “<
}

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

20


{ char apell[10],clave[10],e=0; int a,b,c,mayor, tresd; gotoxy(10,2); cout<<” Ingrese Apellido = “;gets(apell); gotoxy(10,3); cout<<” Ingrese Clave = “;gets(clave); gotoxy(10,4); cout<>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 = «<a)&&(b>c)) {mayor=b; gotoxy(10,13); cout<<”El mayor número es = “<a)&&(c>b)) {mayor=c; gotoxy(10,13);cout<<”El mayor número es = “<
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: ; break;

21


case valor2: ; break; …….……….………... case valor_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. 22


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 # 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<>opc; switch(opc) { case ‘P’:case ‘p’: clrscr(); gotoxy(4,2);cout<>base; gotoxy(15,5);cout<<” Ingrese la potencia:”; cin>>pot; poten=pow(base,pot); gotoxy(15,7); cout<<” El número “<< base<<” elevado a “ <>n; raiz=sqrt(n); gotoxy(15,5);cout<<” La raíz cuadrada de “<< n<<” es =”<>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 = “<

}

cout<
getche();

else { gotoxy(15,6); cout<<” El número no satisface condición “; } break; case’S’:case ‘s’: clrscr(); gotoxy(2,8);cout<
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, Compac y 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 # define linea “----------------------------------------------------” void main() { int nibm,pibm,monto,montoc,ncomp,pcomp,noliv,poliv,montooliv; int montolasser,nimpl,pimpl, int montomat,nimpm,pimpm; int montolcre,nlcre,plcre, int montolhp,nlhp,plhp; 24


char apell[10],clave[10], char opc,imp; clrscr(); gotoxy(25,8);cout<<”MÓDULO DE VALIDACIÓN”; gotoxy(14,9);cout<>opc; switch(opc) { case ‘o’:case ‘O’: clrscr();gotoxy(4,2);cout< IBM :”; gotoxy(15,5);cout<<” Compact”; gotoxy(15,6);cout<<” Olivetti”; gotoxy(4,10);cout<>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 :”<>ncomp; cout<<”\ningrese precio por unidad:”; cin>>pcomp; montoc=ncomp*pcomp; cout<<” \nUd. debe pagar :”<>noliv; cout<<”\ningrese precio por unidad:”; cin>>poliv; montooliv=noliv*poliv; cout<<” \nUd. debe pagar :”<

}

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 : Impresoras clrscr(); gotoxy(15,2); cout<<”Impresoras”; gotoxy(15,4);cout<<” Lasse :”; gotoxy(15,5);cout<<” 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 :”<>nimpm; cout<<”\ningrese precio por unidad:”; cin>>pimpm; montomat=nimpm*pimpm; cout<<” \nUd. debe pagar :”< Creative :”; gotoxy(15,5);cout<<” 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 :”<>nlhp; cout<<” \ningrese precio por unidad:”; cin>>plhp; montolhp=nlhp*plhp; 26


cout<<” \nUd. debe pagar :”<
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 27


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.cpp void 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 #include void main() {char mes[10]; clrscr(); gotoxy(20,1),cout<<» Meses del Año»; g o t o x y ( 2 1 , 2 ) , c o ut<<”================”; gotoxy(20,4),cout<<”Ingrese letra inical del mes:”;gets(mes); if(strcmp(mes,”E”)==0||strcmp(mes ,”e”)==0) { gotoxy(20,6);cout<<” Mes de Enero”; } else if(strcmp(mes,”F”)==0||strcmp(mes, ”f”)==0) {gotoxy(20,6);cout<<” Mes de Febrero”; } else if(strcmp(mes,”M”)==0||strcmp(mes,”m”)==0) { gotoxy(20,6);cout<<” Mes de Marzo” } else if(strcmp(mes,»A»)==0||strcmp(mes,»a»)==0) {gotoxy(20,6);cout<<” Mes de Abril”; } else {gotoxy(20,5); 28


} getche() }

cout<<” El valor ingresado esta disponible......!”;

2.4 Estructuras repetitivas Permiten realizar instrucciones 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 { } 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 >) { ; } Hay que tener especial cuidado para conseguir, en algún momento, una forma de que la 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 29


que lea una cadena y determine en ella la frecuencia de aparición de cada vocal. Solución // while_vocal.cpp #include #define linea “ ____________________________________” void main() { int na=0,ne=0,ni=0,no=0,nu=0; char c=’\0’; gotoxy(10,2);cout<<”Ingrese texto :”< RESULTADOS <=== “; gotoxy(8,7);cout<<”Cáracter # de repeticiones “; gotoxy(5,8);cout< void main() { int r,d,n,inv=0,par=0,impar=0, nd,sump=0,sumimpar=0; char resp=’s’; while(resp==’s’)

30


{ gotoxy(8,3);cout<<”Ingrese un 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 “<>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 void main() { int n,d,p,i=0,a,b; char resp; resp=’s’; clrscr();

31


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

32


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 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 “<=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 #include void main() 33


{ 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 “< 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 :”< void main() { int x,n,i=1; float r=0.0; clrscr(); gotoxy(8,2);cout<<”SUMA DE SERIE = 1+X+X*X/2!+...+X^n/n!” ; gotoxy(8,4);cout<<”Ingrese el valor de x : “;cin>>x; gotoxy(8,5);cout<<”Ingrese el valor de n : “;cin>>n; 34


while(i<=n) { float fact=1,g=1;int j=1; while(j<=i) { g=x*g; fact=fact*j; j++; } r=r+g/fact; i++; } gotoxy(8,7); cout<<”La suma Acumulada es = “;cout<<(r+1)< 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; 35


} } else if (num %2!=0)

{in++; sin+=num; } { min=num; }

if (num>>min) } i++; } gotoxy(10,4+i+1); cout<<”ingrese número:”;cin>>num;

} cout<<” \nSuma de pares positivos :”<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 “<0) { ud= o%10; if (ud%2==0) {cout<<”\n “<
36


2.4.2 Estructura repetitiva con postest de prueba: do { } while () Llamado bucle con salida controlada, ejecuta lo mismo que la estructura while, con la diferencia que primero ejecuta una y luego verifica la , 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 { } while (expresión) ; Este tipo de secuencias es muy utilizada en procesos de validación de datos (cuando se quiere que el usuario del programa introduzca siempre datos correctos). Es decir, se repite un proceso de lectura hasta que la expresió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 # define linea “---------------------------------------” void main() { int cont=1,suma=0,n,dato; gotoxy(8,2); cout<<” SUMANDO TÉRMINOS DE SERIE “; gotoxy(6,3); cout<
Obs. La condición de prueba puede ser también do { }while(!(cont>n));

37


gotoxy(10,4); cout<<” 1 + 2 + 3 + .....+ n”; gotoxy(6,5); cout<>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 = “< # 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<>n; }while(n<1); gotoxy(10,10); cout<<” Ud. sumará “<< n <<” términos de la serie”; dato=cont; 38


do { suma+=pow(cont,cont); cont++; } while (cont<=n); gotoxy(10,12); cout<<”La suma desde “<< dato <<” hasta “<< n<<” es = “<>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 # define linea “----------------------------------------------------” void main () { int n=1; float s=0.0,e; gotoxy(10,2);cout<<”Ingrese precisión(error) :”;cin>>e; cout< void main() { int i=0,pc1; clrscr(); gotoxy(10,4); cout<<” Sr. usuario, tiene Ud. solo 3 opciones”; 39


do { i++; gotoxy(10,8); cout<<” Le quedan “<<(4-i)<<” intentos:”;clreol();cin>>pc1; gotoxy(10,12);cout<<” La 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 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 ”<>resp; clrscr(); } while((resp==’s’) && (resp==’n’)); } while ( resp ==’n’); getch(); }

40


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


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 =”<

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: 65234 c. 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 100 void main() { char cad[max]; int i,j,x,nrovec=0,dosd,fact=1,ndp=0,ndi=0; do {nrovec++; gotoxy(20,2);cout<<”MÓDULO DE VALIDACIÓN: “; gotoxy(10,4);cout<<”Ingrese total de dígitos(x>4): “;clreol(); cin>>x; cout<<”\nSr. el número:”<3) exit(1); else cout<<”Le quedan “<<(3-nrovec)<<” oportunidades :”<

cout<<”\nHe eliminado el carácter:”<0) {d=p%10; inv=inv*10+d; p=p/10; } cout<<”\nEl número “ <0) { d=fact%10; if (d%2==0) {ndp++; } else { ndi++; } fact=fact/10; } cout<<”\nEl total de dígitos pares de “<) Permite realizar instrucciones conociendo el número de iteraciones. Sintaxis: for(inicializar;; contador) { ; } donde: 1. inicializar: indica valor donde inicia el bucle. 2. : se evalúa antes de cada iteración. Si es verdadera, se ejecuta el bloque de , en caso contrario se termina la estructura y se salta a la instrucción siguiente. 44 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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++) ; Observación. Se puede declarar una variable dentro de la inicialización: for (int i=valor_inicial; i<=valorfinal; i++) ; 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 { } o do {...} while; //for solamente condicionado for (;expresión;) {; } //for infinito for (;;) { 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;) { ; 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 45 Teodoro Luciano Córdova Neri y luego mostrar la suma acumulada. Solución //for_serie.cpp #include # 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/ “< “< 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<=10)) dosd++; else { if (mult>may) may=mult; tresd++; } } gotoxy(19,16);cout<<”En la tabla hay : “< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 = “< Teodoro Luciano Córdova Neri 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 # define linea “-----------------------------------------------------------” void main() { float pp,i,n,s_basico,bonif,dscto,acu_pg=0,p_sn,s_neto,s_n1,a_pgp=0,a_p=0,s_n2,a_ pgt=0,a_t,pt,s_n3,a_pga=0,a_a=0,pa, s_n4,a_pgs=0,a_s=0,ps,s_n5,a_pgc=0,a_ c=0,pc,s_n6,a_pgv=0,a_v=0,pv,s_n7,a_pgd=0,a_d=0,pd; char nomb[30],cod[10],r,cat,est_civ, c_pasw[10],clave[10];clrscr(); gotoxy(14,4); cout<<» BIENVENIDOS AL SISTEMA DE VALIDACIÓN DE DATOS»; gotoxy(7,5); cout<>n; for (i=0;i>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; 48 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 a_pgt=a_pgt+s_n2; a_t=a_t+1; if (a_t >0) pt=a_pgt/a_t; else pt=0; } else if (a_t >0) pt=a_pgt/a_t; else pt=0; if (cat==’A’) {s_n3=(s_basico+bonif)-dscto; a_pga=a_pga+s_n3; a_a=a_a+1; if (a_a >0) pa=a_pga/a_a; else pa=0; } else if (a_a >0) pa=a_pga/a_a; else pa=0; gotoxy(30,13),cout<<»[S] Soltero»; gotoxy(30,14),cout<<»[C] Casado»; gotoxy(30,15),cout<<»[V] Viudo»; gotoxy(30,16),cout<<”[D] Divorciado”; gotoxy(5,11),cout<<”Estado Civil :”;cin>>est_civ; if (est_civ==’S’) { s_n4=(s_basico+bonif)-dscto; a_pgs=a_pgs+s_n4; a_s=a_s+1; if (a_s >0) ps=a_pgs/a_s; else ps=0; } if (a_s >0) ps=a_pgs/a_s; else ps=0; if (est_civ==’C’) {s_n5=(s_basico+bonif)-dscto; a_pgc=a_pgc+s_n5; a_c=a_c+1; if (a_c >0) pc=a_pgc/a_c; else pc=0; } if (a_c >0) pc=a_pgc/a_c; else pc=0; if (est_civ==’V’) {s_n6=(s_basico+bonif)-dscto; a_pgv=a_pgv+s_n6; a_v=a_v+1; if (a_v >0) pv=a_pgv/a_v; else pv=0; } if (a_v >0) pv=a_pgv/a_v; else pv=0; if (est_civ==’D’) {s_n7=(s_basico+bonif)-dscto; 49 Teodoro Luciano Córdova Neri 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. “< que permita conocer: promedio de alumnos por sexo y de acuerdo a: talla, edad y peso. 50 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 Solución //pro_sexo.cpp #include 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 #:”<>edad; gotoxy(5,7),cout<<”Peso del alumno :”;cin>>peso; gotoxy(5,8),cout<<”Talla del alumno :”;cin>>talla; gotoxy(5,9),cout<<”Sexo [M/F] :”;gets(sexo); if (strcmp(sexo,”M”)==0 ||strcmp(sexo,”m”)==0) {a_m = a_m+1; a_edad_m =a_edad_m+edad; a_talla_m =a_talla_m+talla; a_peso_m =a_peso_m+peso; } else {a_f=a_f+1; a_edad_f=a_edad_f+edad; a_talla_f=a_talla_f+talla; a_peso_f=a_peso_f+peso; } clrscr(); } 51 Teodoro Luciano Córdova Neri //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 “< Solución //for_send_more.cpp #include #include void main() { int d,e,y,n,r,o,s,a=0; clrscr(); cout<<”\tPrograma que busca todas las soluciones de:SEND+MORE=MONEY: \n”; s=9; for(d=1;d<=9;d++){ for(e=1;e<=9;e++){ 52 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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”< Teodoro Luciano Córdova Neri cout<<”MORE = “<<”1”< 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; 54 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 } while (n<10 ||n>999); for(i=1;i<=n;i++) factorial=factorial*i; gotoxy(12,8);cout<<”el factorial e “< 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<=1;k--) {cout<”; 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. 55 Teodoro Luciano Córdova Neri Usar a = p*( 1 + r ) ^ n Donde p: cantidad invertida inicialmente r : tasa de interés n: cantidad de años a: cantidad en depósito al final de cada año Solución // for_banco.cpp #include # 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< 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<lt-1;i--) cout< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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< } 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.cpp void 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: “< 57 Teodoro Luciano Córdova Neri 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 void main() { int num,pos,neg,max,min,med; clrscr(); do {pos=0, neg=0; cout<<”Ingrese 5 números enteros no nulos”<>num; if (!num) cout<<”\aError. “; } while (!num); if (num>0) { pos++; if (pos==1) max=min=med=num; elseif (num>max) max=num; elseif (num1) {cout<<”Los números positivos ordenados son: “< 58 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 main() {int aa,mm,dd, h,m, a1,a2, correcto; clrscr(); cout<<”Hora y Fecha de sincronización”; do {correcto=1; cout<>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<>a1; cout<<”\tReloj 2: “; cin>>a2; if (abs(a1)>59||abs(a2)>59||a1*a1==0) { correcto=0; cout<<”\aUno de los adelantos es incorrecto\n”; } } while (!correcto); 59 Teodoro Luciano Córdova Neri 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< exacta: 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. 60 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 Solución //Prg_1.cpp. #include void main() {int num,k,num1,r,valor,num2,num3,num4,num5,num6,num7,num 8,num9,num10; char op; gotoxy(12,2),cout<<” CONVERSIÓN DE NÚMEROS A LETRAS”<>num; }while(num<-999999 || num>999999); k=0; num1=num; num3=num; num4=num; num5=num; num6=num; num7=num; do{ num=num/10 ; k++ ; } while(num!=0); valor=0; if(num1<0){ cout<<”Menos “; num1=num1*-1 ; } do { r=num1/pow10(k-1); if (valor==1) { r=r%10; } switch(r){ case 9: switch(k){ case 6: cout<<”Novecientos “;break; case 5:num9=num9%10000; if(num9==0) cout<<”Noventa “; else cout<<”Noventay “; break; case 4: num5=num5/10000; num5=num5%10; num6=num6/10000; if (num5==0 || num5!=1||num6==0){ cout<<”Nueve Mil “;}break; case 3: cout<<”Novecientos “;break; case 2: num8=num8%10; if(num8==0) cout<<”Noventa “; else cout<<”Noventay “; break; case 1:num1=num1%100; num1=num1/10; num3=num3/10; if(num1!=1 && num1!=0||num3==0) { cout<<”Nueve “;} break; } break; 61 Teodoro Luciano Córdova Neri case 8: switch(k) { case 6: cout<<”Ochocientos “;break; case 5:num9=num9%10000; if(num9==0) cout<<”Ochenta “; else cout<<”Ochentay “; break; case 4: num5=num5/10000; num5=num5%10; num6=num6/10000; if (num5==0 || num5!=1||num6==0){ cout<<”Ocho Mil “; } break; case 3: cout<<”Ochocientos “;break; case 2: num8=num8%10; if(num8==0) cout<<”Ochenta “; else cout<<”Ochentay “; break; case 1: num1=num1%100; num1=num1/10; num3=num3/10; if(num1!=1 && num1!=0||num3==0){ cout<<”Ocho “;} break; } break; case 7: switch(k){ case 6: cout<<”Setecientos “;break; case 5:num9=num9%10000; if(num9==0) cout<<”Setenta “; else cout<<”Setentay “; break; case 4: num5=num5/10000; num5=num5%10; num6=num6/10000; if (num5==0 || num5!=1||num6==0){ cout<<”Siete Mil “;}break; case 3: cout<<”Setecientos “;break; case 2: num8=num8%10; if(num8==0) cout<<”Setenta “; else cout<<”Setentay “; break; case 1: num1=num1%100; num1=num1/10; num3=num3/10; if(num1!=1 && num1!=0||num3==0){ 62 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 cout<<”Siete “;} break; } break; case 6: switch(k){ case 6: cout<<”Seiscientos “;break; case 5:num9=num9%10000; if(num9==0) cout<<”Sesenta “; else cout<<”Sesentay “; break; case 4: num5=num5/10000; num5=num5%10; num6=num6/10000; if (num5==0 || num5!=1||num6==0){ cout<<”Seis Mil “;}break; case 3: cout<<”Seiscientos “;break; case 2: num8=num8%10; if(num8==0) cout<<”Sesenta “; else cout<<”Sesentay “; break; case 1:num1=num1%100; num1=num1/10; num3=num3/10; if(num1!=1 && num1!=0||num3==0){ cout<<”Seis “;} break; } break; case 5: switch(k) { case 6: cout<<”Quinientos “;break; case 5:num9=num9%10000; if(num9==0) cout<<”Cincuenta “; else cout<<”Cincuentay “; break; case 4: num5=num5/10000; num5=num5%10; num6=num6/10000; if (num5==0 || num5!=1||num6==0){ cout<<”Cinco Mil “;}break; case 3: cout<<”Quinientos “;break; case 2: num8=num8%10; if (num8==0) cout<<”Cincuenta “; else cout<<”Cincuentay “; break; case 1: num1=num1%100; 63 Teodoro Luciano Córdova Neri num1=num1/10; num3=num3/10; if (num1!=1 && num1!=0||num3==0){ cout<<”Cinco “;} break; } break; case 4: switch(k) { case 6: cout<<”Cuatrocientos “;break; case 5:num9=num9%10000; if(num9==0) cout<<”Cuarenta “; else cout<<”cuarentay “; break; case 4: num5=num5/10000; num5=num5%10; num6=num6/10000; if (num5==0 || num5!=1||num6==0){ cout<<”Cuatro Mil “;}break; case 3: cout<<”Cuatrocientos “;break; case 2: num8=num8%10; if(num8==0) cout<<”Cuarenta “; else cout<<”cuarentay “; break; case 1:num1=num1%100; num1=num1/10; num3=num3/10; if(num1!=1 || num1!=0||num3==0){ cout<<”Cuatro “;} break; } break; case 3: switch(k) { case 6: cout<<”Trecientos “;break; case 5:num9=num9%10000; if(num9==0)cout<<”Treinta “; else cout<<”Treintay “; break; case 4: num5=num5/10000; num5=num5%10; num6=num6/10000; if (num5==0 || num5!=1||num6==0){ cout<<»Tres Mil «;}break; case 3: cout<<»Trecientos «;break; case 2: num8=num8%10; if(num8==0)cout<<”Treinta “; else cout<<”Treintay “; break; case 1:num1=num1%100; num1=num1/10; num3=num3/10; if(num1!=1 && num1!=0||num3==0){ cout<<»Tres «;} break; } break; 64 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 case 2: switch(k) { case 6: cout<<»Doscientos «;break; case 5:num9=num9%10000; if (num9==0) cout<<»Veinte «; else cout<<»Veinty «; break; case 4: num5=num5/10000; num5=num5%10; num6=num6/10000; if (num5==0 || num5!=1||num6==0){ cout<<»Dos Mil «;}break; case 3: cout<<»Doscientos «;break; case 2: num8=num8%10; if(num8==0) cout<<”Veinte “; else cout<<”Veinty “; break; case 1: num1=num1%100; num1=num1/10; num3=num3/10; if(num1!=1 && num1!=0||num3==0){ cout<<»Dos»;} break; } break; case 1: switch(k) { case 6: num10=num10%100000; if(num10==0)cout<<»Cien «; else cout<<»Ciento «;break; case 5: num4=num4/1000; num4=num4%10; switch(num4){ case 9:cout<<»Diecinueve Mil «; break; case 8:cout<<»Dieciocho Mil «; break; case 7:cout<<»Diecisiete Mil «;break; case 6:cout<<»Dieciseis Mil «; break; case 5:cout<<»Quince Mil «; break; case 4:cout<<»Catorce Mil «;break; case 3:cout<<»Trece Mil «; break; case 2:cout<<»Doce Mil «; break; case 1:cout<<»Once Mil «; break; case 0:cout<<»Diez Mil «; break; }break; case 4: num5=num5/10000; num5=num5%10; num6=num6/10000; if (num5==0 || num5!=1||num6==0){ cout<<»Un Mil «;}break; case 3: num7=num7%100; 65 Teodoro Luciano Córdova Neri if(num7==0)cout<<»Cien «; else cout<<»Ciento «; break; case 2: num2=num1%10; switch(num2){ case 9:cout<<»Diecinueve «; break; case 8:cout<<»Dieciocho «; break; case 7:cout<<»Diecisiete «;break; case 6:cout<<»Dieciseis «; break; case 5:cout<<»Quince «; break; case 4:cout<<»Catorce «;break; case 3:cout<<»Trece «; break; case 2:cout<<»Doce «; break; case 1:cout<<»Once «; break; case 0:cout<<»Diez «; break; } break; case 1:num1=num1%100; num1=num1/10; num3=num3/10; if(num1!=1 && num1!=0||num3==0){ cout<<»Uno «;} break; } break; case 0: switch(k) { case 6: break; case 5:break; case 4: break; case 3: break; case 2: num2=num1%10; switch(num2){ case 9 : cout<<»Nueve «;break; case 8 : cout<<»Ocho «;break; case 7 : cout<<»Siete «;break; case 6 : cout<<»Seis «;break; case 5 : cout<<»Cinco «;break; case 4 : cout<<»Cuatro «;break; case 3 : cout<<»Tres «;break; case 2 : cout<<»Dos «;break; case 1 : cout<<»Uno «;break; case 0 : break; } case 1: num3=num3*num3; if(num3==0){ cout<<»Cero «;} break; } break; } k--; valor=1 ; }while(k>0); gotoxy(20,8);cout<<”\nQuiere seguir en el programa(s/n): “; cin>>op;clrscr(); } while(op==’s’); getche();} 66 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 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 : «<>resp; } while( (resp == ‘S’)||(resp ==’s’)); getche(); } Problema 5. Suponiendo que un par de conejos tiene un par de crías cada mes y 67 Teodoro Luciano Córdova Neri 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.cpp Void main() {int mes1,mes2,mes_tot,meses; int numero_parejas; mes1=1; mes2=2; mes_tot=2; meses=1; while (meses<12) {mes_tot=mes1+mes2; mes1=mes2; mes2=mes_tot; meses=meses+1; } gotoxy(5,1);cout<<»CRIA DE CONEJOS”; gotoxy(5,2);cout<<»Total de perejas despues de un año :»<>numero_parejas; mes1=1; mes2=2; mes_tot=2; meses=1; while (mes_tot void main() { int anterior=1,nuevonum,actual=1,i=3,total=2; gotoxy(6,i+1);cout< 68 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 Problema 7. Diseñar un programa que permita calcular la suma acumulada de la serie: 1 1 1 1 1 + 2 + 2 + 4 + ........ + 2 2 1 2 3 4 n para un error (precisión) de 10-2. (señor lector, puede generalizar para lectura de cualquier grado de error). Solución //do_whi_serie.cpp #include # define linea “----------------------------------------------------” void main () { int n=1; float s=0.0,e; gotoxy(10,2);cout<<”Ingrese precisión(error) :”;cin>>e; cout< 69 Teodoro Luciano Córdova Neri 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 void main(){ int a,m,d,p,r,b=0,xxx,g; int i,j; cout<<” Día segun calendario Gregoriano:”<>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) ) 70 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 void main(){ int t,tt,ni,i; float n,max; char h[100]; textcolor(11) ; gotoxy(10,20) ;cout<<”È”; gotoxy(10,4) ;cout<<”É”; for (i=11 ;i <=69 ; i++) { gotoxy(i,4) ;cout<<”Í”; gotoxy(i,20) ;cout<<”Í”; } gotoxy(70,4) ;cout<<”»” gotoxy(70,20) ;cout<<”¼”; for(i=5;i<=19;i++) { gotoxy(10,i) ;cout<<”º”; gotoxy(70,i );cout<<”º”; } 71 Teodoro Luciano Córdova Neri gotoxy(18,2);cout<<”************* VIRUS INFORMÁTICO ************ “; time_t tiemp; time(&tiemp); gotoxy(30,22);cout<<”Fecha de Consultas: “<>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: “< U V W Pc1 12 10 05 Pc2 10 8 18 Pc3 14 12 12 Pc4 14 12 18 Pc5 08 05 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 void main(){ char secc; int nota,notamax=-1,nmax=-1,nu=0,nw=0,nv=0; int sumav=0,sumaw=0,nau=0,nav=0,naw=0,sumau=0; 72 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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=s umaw+nota; nw++; if(nota>=10) {naw++; } promw=float(sumaw)/nw; break; }// fin del case gotoxy(5,1);cout<<” El programa finaliza con nota =-10 “; gotoxy(5,2);cout<<” ingrese nota = “;cin>>nota; } //fin del while //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 = “< Teodoro Luciano Córdova Neri { pw=float(naw*100)/nw; } gotoxy(5,14);cout<<” Promedio de la sección W = “< 74 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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() 75 Teodoro Luciano Córdova Neri { 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< No esta registrado “; gotoxy(10,7);cout<<” Le quedan [ “<<(3-ner)<<” ] oportunidades”; gotoxy(7,8);cout< Bienvenido...”; } } //fin del del if ner<=3 else { gotoxy(10,2); cout<<»Sr.»<>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 “<d) { menor=d; } if (mayor Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 gotoxy(10,3);cout<<” RESULTADOS “; gotoxy(7,4);cout<>resp; if (resp==’n’) //depende de resp=n { clrscr();gotoxy(6,5);cout<gracias por hacer “< 77 Teodoro Luciano Córdova Neri 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. 78 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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<<” Validación de Datos de Usuario”; gotoxy(10,3);cout<<”Ingrese Nombre = “;gets(nombre); if(strcmp(strupr(nombre),”LUIS”)!=0) { gotoxy(7,5);cout< No esta registrado “; gotoxy(10,7);cout<<” Le quedan [ “<<(3-ner)<<” ] oportunidades”; gotoxy(7,8);cout< Bienvenido...”; } } //fin del del if ner<=3 else { gotoxy(10,2); cout<<»Sr.»<>n; }while(n<0 || n>50 ); 79 Teodoro Luciano Córdova Neri 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>resp; if (resp==’n’) //depende de resp=n {clrscr();gotoxy(6,5);cout<gracias por hacer “< 80 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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). Interface de validación (Fig. 1) Interface cuando existe error de datos (Fig. 2) 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 81 Teodoro Luciano Córdova Neri 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 “< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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. “<>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 = “< Promedios de Prácticas <=== “<6.5) {clrscr(); int exp,exf; float pf; gotoxy(10,2);cout<<” Alumno puede rendir Exámenes “; gotoxy(5,3);cout<>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 =”<10.0) {gotoxy(10,10); 83 Teodoro Luciano Córdova Neri cout<<” Promedio Final = “< 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 “<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ámenes else {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.5 else { clrscr(); gotoxy(10,8);cout<<” Error en el ingreso de prácticas...”; gotoxy(5,9); cout< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 } } else { clrscr(); gotoxy(20,12); cout<<”Sr. sus datos tienen error !!! “; gotoxy(12,13); cout< 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 #include #include #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<>opcp; 85 Teodoro Luciano Córdova Neri switch(opcp) { case ‘o’:case ‘O’:clrscr(); gotoxy(10,2);cout<<” OPERACIONES ARITMÉTICAS”; gotoxy(5,3);cout<>a; gotoxy(10,6); cout<<”ingrese segundo número= “;cin>>b; gotoxy(5,7);cout<>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 < “< no existe división “; getche(); exit(0); } } break;//fin fel if default: { gotoxy(3,11); cout<<”Operador<”<no esta disponible, hasta luego..”; getche();exit(0); } }//fin del case opera gotoxy(10,12); cout<<” Resultado de “< MI CUENTA EN BCP <== “; gotoxy(7,3);cout< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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< “; cin>>tpcuenta; if((tpcuenta==1)||(tpcuenta==2)) { clrscr(); gotoxy(15,1); gotoxy(10,2);cout<<” TIPO DE TRANSACCIONES “; gotoxy(6,3);cout< “; 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 “<>depos; if(depos==10 ||depos==100 ||depos==200) { saldoinic=saldoinic+depos; gotoxy(12,15);cout<<”Su saldo actual es “<>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 = “< Teodoro Luciano Córdova Neri case 4: gotoxy(8,11); Número de alumnos: 4 1 2 3 4 cout<<”Gracias por códigos 100 200 300 400 sus Transacciones... “; Notas 16 10 16 16 getche(); break; default : gotoxy(8,11); cout<<” Sr. el dato [“<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 nota b. 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). 88 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 //while_prg_03.cpp #include #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<>cod; }while(cod<1||cod>999); do {gotoxy(10,5);clreol();cout<<” Ingrese nota = “;cin>>nota; }while (nota<0 || nota>20); clrscr(); if (mayor=10) {aprob++; } else { desap++; } gotoxy(10,7);cout<<”Desea ingresar nuevo dato..? (s/n)”;cin>>resp; } clrscr(); gotoxy(10,3);cout<<” Mayor nota = “<0) {nt=notas%100; cod=codigos%1000;codigos=codigos/1000; notas=notas/100;pos=spos%10;spos=spos/10;gotoxy(18,15+i);cout< Teodoro Luciano Córdova Neri } i++; gotoxy(12,16+i);cout< de 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. 90 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 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. “<=3) {clrscr(); gotoxy(2,10);cout<<”Sr.” << clave <<”, debido que supero los 3 errores, no lo podemos atender, gracias..”;getche(); exit(0); } }while(strcmp(strupr(clave),”123”)!=0); do {clrscr(); gotoxy(12,2);cout<<”------------- MENU PRINCIPAL ---------------”; 91 Teodoro Luciano Córdova Neri 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 = “<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 # “<10){gotoxy(12,10);cout<<” Estado del # “< Aprobado”; gotoxy(12,12);cout<<” Desea Ud. continuar...?(S/N)==> “;cin>>op; } else {gotoxy(12,10);cout<<” Estado del # “< Desaprobado “; gotoxy(12,12);cout<<” Desea Ud. continuar...?(S/N)==>”;cin>>op;} } else {gotoxy(12,10);cout<<” Desaprobado,no puede rendir examenes”; gotoxy(12,12);cout<<” Desea Ud. continuar...?(S/N)==>”;cin>>op; } }while((op==’s’)||(op==’S’)); 92 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 = “<”;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 = “<”;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. 93 Teodoro Luciano Córdova Neri 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 inicializo con un valor grande 5000000 - MES: Almacena el mes con menores con menores lluvias en el sur - RNO,RSU,RCE: Regiones - PRORCE: Almacena el promedio anual de de las lluvias caidas en la región centro. // For_if_Lluvias_NCS.cpp # include 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 # “<>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 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 l++; //si uso for no iria l++ }clrscr(); prorce=float(arce)/12; gotoxy(10,6);cout<<”promedio de region centro = “<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 # 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 95 Teodoro Luciano Córdova Neri clrscr(); gotoxy(30,23);cout<<” Ud. realizará la consulta # “< “;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 Repetidos no_vec_sec_rep++; } else {tol_sec_no_rep=tol_sec_no_rep+dig*pow(10,no_vec_no_rep); sumanorep+=dig; //suma de 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 = «< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 gotoxy(5,8);cout<<» Secuencia de Dígitos = «< “;cin>>opc; }while((opc==’s’)||(opc==’S’)); if((opc==’n’)||(opc==’N’)) {clrscr(); gotoxy(20,12); cout<<” Ud.realizo “< 97 Teodoro Luciano Córdova Neri 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. 98 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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. 99 Teodoro Luciano Córdova Neri 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 // 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 # «< 100 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 if (strcmp(strupr(cod),”TCN”)!=0) {gotoxy(6,7); cout<<”Sr. el código ==> “< “<>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 “<d) {menor=d; } if (mayor “;cin>>resp; 101 Teodoro Luciano Córdova Neri nrovec=0;//actualizar } if(resp==’n’) { clrscr(); time_t t; time(&t); gotoxy(4,10);cout<<” Sr. Ud. realizó “< // defina otras librerias # define linea “-------------------------------------------” void marco(int x,int y,int ancho, int alto,int color) {int i,j; textcolor(color); for(i=0;i<=ancho;i++) {gotoxy(x+i,y);cprintf(“²”); gotoxy(x+i,y+alto);cprintf(“²”); } for(j=0;j<=alto;j++) {gotoxy(x,y+j);cprintf(“²”); gotoxy(x+ancho,y+j);cprintf(“²”); } textcolor(color); } void main() { int nproces=0,nrovec=0,pc1,pc2,pc3,pc4,min; // char nombre[10],clave[10], char nombre[10],resp; marco(6,2,60,20,10); gotoxy(14,4);cout<<” Sr. Ud solo dispone de 3 oportunidades “; do //bucle infinito mientras no edite tcn {clrscr(); nrovec++; marco(6,2,60,20,10); 102 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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-nrovec)<<» oportunidades :»; getche(); clrscr(); } else {textcolor(14); gotoxy(10,15);cprintf(« Sr. ==>»); gotoxy(18,15); cprintf(«%4s»,nombre); gotoxy(25,15); cprintf(“ <== registrado en el sistema,Bienvenido “); } } else {gotoxy(10,12); cout<<”FIN DE SESION, PUES SUPERO MAS DE “<<(nrovec-1)<<” INTENTENTOS “; getche(); exit (0); } } while(strcmp(strupr(nombre),”LUIS”)!=0); //while(!(cod==100)); textcolor(11);gotoxy(20,19);cprintf(“Total de errores cometidos = “); textcolor(11);gotoxy(50,19);cprintf(“ %i”,nrovec-1); getche(); clrscr(); do {nproces++; marco(6,2,60,20,10); textcolor(22);gotoxy( 15,10); cprintf(“ BIENVENIDOS AL SISTEMA DE 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,p4 textcolor(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); 103 Teodoro Luciano Córdova Neri 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. 104 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 En la siguiente gráfica, se obtiene resultados solicitados por el usuario. // Solucion while_if_do_pos_nega.cpp #include 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 “<>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 (num1) {cout<<”\n\t Los números positivos ordenados son: “< Teodoro Luciano Córdova Neri Estructuras de control: compendio de problemas 1. Secuenciales 2. Condicionales 3. Repetitivas 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) 106 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 serie 2.2. El resultado de 1), mostrarlo en forma Invertida 2.3. El total de cifras que tiene resultado 1). 2.4. Total de cifras Pares según resultado 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 107 Teodoro Luciano Córdova Neri 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 Distrito b) Promedio de edades de Pobladores en cada Departamento El 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 “ 108 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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. 109 Teodoro Luciano Córdova Neri 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. 110 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 111 Teodoro Luciano Córdova Neri 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 respectivo. El programa debe generar reportes para conocer: a). Suma acumulada de sueldo de empleados en el rango 100..1000 b). Suma acumulada de sueldo de empleados en el rango 1000..1999 c). Suma acumulada de sueldo de empleados en el rango 2000..3000. 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 la Condició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”. 112 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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: Formar intervalo: se trata de formar un intervalo I:[a,b], donde a 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ú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. 113 Teodoro Luciano Córdova Neri Número de Capicua (Palindró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 palindró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 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 114 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 invertida b) Conocer el número total de dígitos. c) Conocer el número total de dígitos pares.(ver figura.) d) Conocer el número total de dígitos impares(ver figura.) II. Si el número es impar, entonces el sistema confirma que el dato es un 115 Teodoro Luciano Córdova Neri 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 116 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 117 Teodoro Luciano Córdova Neri 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. 118 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 119 Teodoro Luciano Córdova Neri 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. 120 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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) 121 Teodoro Luciano Córdova Neri 122 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 CAPÍTULO III Estructura de datos Arrays 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. 123 Teodoro Luciano Córdova Neri 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] 124 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 [0] [1] 12 11 [2] [3] 09 15 [ 18 ] [ 19 ] índice ........ 11 08 02 12 Elementos individuales del vector y todos del mismo tipo Para recorrer sus elementos para lectura y/o escritura, se debe usar estructuras de control, tales como: for(i=0;i<20;i++), while(i<20), etc. 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]!=’.’ 125 Teodoro Luciano Córdova Neri 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 lista 2. Insertar elementos en alguna posición de la lista 3. Eliminar elementos 4. Ordenar elementos en forma ascendente o descendente 5. Búsqueda de un elemento 6. Fusión o intercalación de dos listas 7. 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<>n; for(i=0;i>nota[i]; gotoxy(30,8+i*2);cout<<”Ingrese sexo (M/F) = “; cin>>sexo[i]; } for(i=0;i 126 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 if((sexo[i]==’M’)||(sexo[i]==’m’)) { if(nota[i]>10) { gotoxy(2,15+i); cout<<”N[“<<(i+1)<<”]= “<>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 #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<>n; } while (!((n>=1) && (n<=max_n))); for (i=0; i>notas[i]; } 127 Teodoro Luciano Córdova Neri for (i=0; i # define max 10 void main(){ int i,j,n,aux,a[max]; clrscr();gotoxy(2,2); cout<<”Ingrese la longitud del vector : “; cin>>n; gotoxy(2,4);cout<<”Ingrese elmentos : “<>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[“< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 Solución //vectores_max_min.cpp #include //defina otras loibrerias #define max_elem 100 void main() { int A[max_elem],k,i,n,j,aux,maxb,minc,B[max_elem],C[max_elem],d=0; clrscr(); gotoxy(3,3);cout<<”Ingrese numero de elementos del vector A: “;cin>>n; gotoxy(4,5);cout<<”Ingrese elementos”; for(i=1;i<=n;i++) { gotoxy(5,6+i);cout<<”A[“<>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[“<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[“<>q; gotoxy(4,5);cout<<”Ingrese elementos:”; for(r=1;r<=q;r++) {gotoxy(5,6+r);cout<<”M[“<>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[«<0)||((M[r]%2)<0) ){x=x+1; N[x]=M[r];} for(r=1;r<=q2;r++) if((M[r]%2)==0){x=x+1; N[x]=M[r];} 129 Teodoro Luciano Córdova Neri 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[“< 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 eliminados b. Generara un reporte de los elementos del vector sin repetirse Solución // vector_Repetido.cpp #include // defina otras librerias # define max 100 void main(){int a[max],n,i,d,j,aux,vser[max],p;clrscr(); gotoxy(2,2);cout<<”Ingrese # de elementos del vector A: “;cin>>n; for (i=1;i<=n;i++) { gotoxy(2,3+i);cout<<”a[“<>a[i]; } //ORDENAMIENTO EN FORMA ASCENDENTE for (i=1;i<=n-1;i++) for(j=(i+1);j<=n;j++) if(a[i]>a[j]) { aux=a[i]; a[i]=a[j]; a[j]=aux; } /*inicializando*/ d=1;vser[1]=a[1]; 130 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 : “< 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 :”<1) { cout<<”\n “< 131 Teodoro Luciano Córdova Neri 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 #define max 200 void main() {char let[max],vlsrep[max],letra,aux; intcontA,k,contU,contN,contI,menor,cantL,p,i=0,j; k=0; contA=0; contU=0; contN=0; contI=0; gotoxy(3,2); cout<<»Finaliza la edicion de caracters al editar ‘ .’ «; gotoxy(3,3); cout<<» Ingreso de letras «; do { i++ ; gotoxy(3,3+i);cout <<” letra “ << (k+1) << “ = “; cin >>letra; let[k]=letra; if ((let[k]==’a’)||(let[k]==’A’)) contA+=1; switch (letra) { case ‘u’: case ‘U’: contU+=1; break; case ‘n’: case ‘N’: contN+=1; break; case ‘i’: case ‘I’: contI+=1; break; } k++; } while (letra!=’.’) ; cantL=k-1; // buscando cuantas veces se repite la palabra UNI if (contUlet[j]) { aux=let[i]; let[i]=let[j]; let[j]=aux; } } 132 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 p=0; for (i=0;i 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 Solución //vect_inse.cpp #define linea “-------------------------------” #define max_el 50 void main() { int a[max_el], n, i, dato; char opc,resp=’S’; while(resp==’S’ || resp==’s’) {clrscr(); 133 Teodoro Luciano Córdova Neri gotoxy(8,2);cout<<”Ingrese numero de elementos: “; cin>>n; for( i=1;i<=n;i++) {cout<<”\tA[“<>a[i]; } clrscr(); gotoxy(8,2);cout<<” Reporte de datos \n”; for (i=1; i<=n; i++) {cout<<”\tA[“< En una posicion “< Al final de la lista “< Si A esta ordenada “< ==> “;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 final for (i=n;i>=pos;i--) { a[i+1]=a[i]; a[pos]=dato; //Copia elemento n++; } cout<<”\nReporte del vector con elemento = “< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 } //Fin de switch } //Fin de else gotoxy(25,21);cout<<”Desea continuar..? ==>(S/N)”;cin>>resp;clrscr(); } if((resp==’n’) || (resp==’N’)) {clrscr();gotoxy(30,12); cout<<”Gracias por sus consultas “;getche(); exit(0); } } Problema 9. 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 //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<>n; } while (!((n>=1) && (n<=max_n))); fo r (i=0; i>notas[i]; } for(i=0; i Teodoro Luciano Córdova Neri { 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 “<>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[“< # define max 100 void main(){ int a[max],n,i,d,j,aux,vser[max],p; clrscr(); gotoxy(2,2);cout<<”Ingrese # de elementos del vector A: “; cin>>n; for (i=1;i<=n;i++){ gotoxy(2,3+i);cout<<”a[“<>a[i]; } //ORDENAMIENTO EN FORMA ASCENDENTE for (i=1;i<=n-1;i++) for(j=(i+1);j<=n;j++) if(a[i]>a[j]) {aux=a[i];a[i]=a[j];a[j]=aux;} d=1;vser[1]=a[1]; for(i=2;i<=n;i++) if(a[i]!= a[i-1]) { d++; vser[d]=a[i]; } p=n-d; gotoxy(2,10); 136 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 cout<<”El # de elementos eliminados es : “< # define linea “-----------------------------------------------------” # define max_el 60 void main(){ int a[max_el],b[max_el],n,x,i,p,c[max_el],max,min;clrscr(); do{ gotoxy(2,2);clreol(); cout<<”Ingrese #de elementos (<=100): “; cin>>n; }while(n<0 || n>50); for(i=1; i<=n; i++) { cout<<”A[“<>a[i];} clrscr(); gotoxy(2,2);cout<<” Elementos del vector A:”; gotoxy(2,3); cout<0) { p=p+1; b[p]=a[i]; } } gotoxy(2,7);cout<<”Vector que contiene numeros positivos pares e impares”; gotoxy(2,8); cout< Teodoro Luciano Córdova Neri {gotoxy(9*i,9); cout<<”B[“< for(i=2; i<=p; i++) { if(b[i] > max ) max=b[i]; } gotoxy(2,17);cout<<”El maximo positivo es : “< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 Solución //vector_fact_el. cpp #include//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 “<>n; }while(n>100 ||n<=0); gotoxy(1,5);cout<<”Ingrese “<>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[“< 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[“<>a[i]; } 139 Teodoro Luciano Córdova Neri 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[“< //defina otras librerias #define max 16 void main(){int i,j=0,k=0,v=0,n; float nota[max],suma,promg,sumaa,sumad,promd,proma; gotoxy(2,2); cout<<”Ingrese numero de alumnos”; cin>>n; for(i=1;i<=n;i++) {cout<<”\tNota [“<>nota[i]; } suma=0; for(i=1;i<=4;i++){suma=nota[i]+suma; } sumad=0; sumaa=0; for(i=1;i<=4;i++) 140 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 {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 = “< # define max_coef 50 void main( ) {int i,n;float poli[max_coef]={0},x,px=0,dx=0,d2x=0;; clrscr(); gotoxy(2,2);cout<<”Ingrese el grado n del polinomio gotoxy(2,3);cout<<”Ingrese el Valor de la variable x0 : “; cin>>x; gotoxy(2,4);cout<<”Ingrese el valor de los coeficientes :”<>poli[i]; } if (x==0) px=poli[0]; else {for(i=0; i<=n; i++) {px += poli[i]*pow(x,i); if (n>0) dx += poli[i]*i*pow(x,i-1); if (n>1) d2x += poli[i]*i*(i-1)*pow(x,i-2); : “; cin>>n; 141 Teodoro Luciano Córdova Neri } } cout<<”\nRESULTADOS “< 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<0){ Aux=Num; if (Num>=1000) Num/=1000; if (Num>0) { int a,b,c; c=Num%10;b=(Num%100c)/10;a=(Num-10*b-c)/100; if (a>0) if (b==0 && c==0) cout<0) if (b==1) cout< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 if (c>0) { //imprime las unidades if (b>1) cout<<»y «; if (b!=1) cout<=1000) cout<";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 nota b. 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: 143 Teodoro Luciano Córdova Neri 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 #define linea “_____________________” void main() 144 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 { 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<>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<>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 = “< Teodoro Luciano Córdova Neri for(j=1;j<=cont;j++) {codi=codigos%1000; codigos=codigos/1000; pos=ubica%10; ubica=ubica/10; gotoxy(9,7+j);cout<=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 = “< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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ón Diseñ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 #define linea “_____________________________________________” int n, i, j, k, aux, temporal, mayor; codigo[100], unidades[100]; char tipo[100], codigoProd[1], aux2[1], maximo[1], resp=’s’; void main (){gotoxy(6,2); cout<<” SISTEMA LOGISTICO PARA REGISTRAR PRODUCTOS “; 147 Teodoro Luciano Córdova Neri 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 cantidad for (i=1; i<=n; i++) { cout<>codigo[i]; //gotoxy(6,7 Valido que el tipo sea de una sola letra do { cout<<”\tIngrese tipo de producto (Letra) “ <1); // Se Agrego el caracter del Tipo de Producto a la variable ‘Tipo’ strcat(tipo,codigoProd); cout <<”\tIngrese total de unidades de producto “<>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] 148 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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<”; 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. 149 Teodoro Luciano Córdova Neri 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. Sintaxis Constantes: max_f 100, max_c 100 Tipo nombre_mat [ max_f ] [ max_c ] Donde: 1. Tipo es el tipo de datos que guarda la matriz. 2. nombre_mat es el identificador de la matriz. 3. max_f : cantidad máxima de elementos en las filas max_c : cantidad máxima de elementos en las columnas. Observaciones 1. Como todo índice de arreglos en C++ inicia en 0, entonces el número de elementos de arreglo bidimensional (puede generalizar para multidimensionales) queda denotado por (max_f +1) (max_c+1). 2. En general, se pude declarar arreglos multidimensionales, dependiendo del tipo de 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 150 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 void main() { int lista[ max_f ] [ max_c ] ; } Ejemplo 2. Inicializar los valores de una matriz para declarar una matriz lista de 5 x 3 elementos enteros. int Lista [ 4 ] [ 2 ] = { { 4, 3, 3 }, { 5, 4, 7 }, { 7, 7, 7 }, { 8, 4, 9 }, { 9, 2, 5 } } Esta inicializacion, es equivalente a mostrarlo en la siguiente tabla. Acceso a los elementos. Cada elemento de la matriz debe referenciarse mediante sus índices (subíndices) Así, Lista[ 3 ] [ 2 ] = 9 Lista[ 1 ] [ 1 ] = 4 Lista[ 4 ] [ 4 ] = 5 Aplicaciones Los arreglos bidimensionales son utilizados ampliamente para problemas del mundo real, tales como: control de productos en almacenes, distribuciones, evaluciones, etc. Problema 1. Una empresa importadora de vehículos tiene distribuido tres tipos de vehículos en tres almacenes diferentes, tal como se ilustra en la siguiente figura: Diseñar un programa que permita 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: 151 Teodoro Luciano Córdova Neri a. Total de vehículos por tipo b. Total de vehículos en cada almacén c. 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 maximo void main() {int almacen[max_vehic][max_almac],i,j,x=5,y=10,m,n; float suma=0,tv=0; clrscr(); //leer datos gotoxy(15,1);cout<<”Compania Importadora de Autos “; gotoxy(15,2);cout<<”------------------------”; do{ gotoxy(1,3);cout<<” Ingese total de Vehiculos: “; cin>>m; gotoxy(1,4);cout<<” Ingrese total de Almacen: “; cin>>n; }while(m<=0 || m>=10 && n<=0 || n>=10); gotoxy(1,5);cout<<”Ingrese vehiculos :”; for(i=1;i<=m;i++) for(j=1;j<=n;j++) { gotoxy(19+y*j,x+i*2);cout<<”al[“<>almacen[i][j]; }//Suma tipos de vehiculos ( filas) cout<<”\nTotal de Vehiculos por tipo”< 152 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 cout<<”\nTotal por Almacen:”< suma=0; 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 almacenes b. Total de vehículos por cada almacén c. Cantidad mayor de vehículos, por tipo, en uno de los almacenes d. 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 # define maxf 10 # define maxc 10 void main(){ time_t tiemp;time(&tiemp);int t,n,m,i,j,mayor,k,p, sump[maxf]; float a[maxf][maxc],cant_por_al[maxf],cant_tip[maxc],par[maxf],imp[maxf]; float totaltipos,totalalmac; int q=1, s=1,, x=5, y=10; gotoxy(6,2);cout<<”EMPRESA VENDEX S.A.:”; gotoxy(30,2);printf(“ Fecha de Consultas: %s\n”,ctime(&tiemp)); for(i=1;i<=77;i++) { gotoxy(i+1,3);cout<<’_’; //ASCII :alt +95} gotoxy(3,4);cout<<”ingrese total de tipos :”;cin>>n; gotoxy(3,5);cout<<”ingrese total de almacenes :”;cin>>m; for(i=1;i<=m;i++) for(j=1;j<=n;j++) { gotoxy(19+y*j,x+i*2);cout<<”al[“<>a[i][j]; } /*calculando por tipos */ cout<<”Total por tipo de vehiculos :”< Teodoro Luciano Córdova Neri cout<<”Total de tipo [“<mayor) mayor=a[i][j]; } } cout<<” La mayor cantidad de vehiculos es: “< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 cout<<”\n Elementos del vector sump[]”< #define maxf 50#define maxc 50 void main() { char nom[maxf][maxc],temp[maxf]; float temp1, notas[maxf][3], prom[maxf], min[maxf]; int i,j,n;clrscr(); gotoxy(8,2);cout<<”RELACION DE ALUMNOS Y RESPECTIVAS NOTAS”; gotoxy(6,3); cout<<”___________________________________”<>n; for(i=1;i<=n;i++) { gotoxy(2,6+i);cout<>nom[i]; cout<<” Ingrese sus 3 notas: “<>notas[i][j]; } clrscr(); } //Calculo de promedios for(i=1;i<=n;i++) 155 Teodoro Luciano Córdova Neri { prom[i]=0; min[i]=20; } for(i=1;i<=n;i++) for(j=1;j<=3;j++) {if (notas[i][j]=10) cout<<» Aprobado»; else cout<<» Desaprobado»;cout< 156 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 #define max 10 void main(){int empresa[max][max][max],d,s,o,dep,sec,i,j,k; char aux; float ac,prom; do{ cout<<»Ingrese numero de departamentos (menor que 10): «;cin>>d; }while(d>10); do{ cout<<»Ingrese numero de secciones por departamento «;cin>>s; }while(s>10); do{ cout<<»Ingrese numero de obreros por seccion (menor que 10): «;cin>>o; }while(s>10); for(i=0;i>empresa[i][j][k]; } } clrscr(); cout<<”Ingrese departamento que desea conocer el promedio: “;cin>>dep; do{cout<<”Desea conocer el promedio de todo el departamento o de alguna seccion en especial [Todo] [Especial]? “;cin>>aux; }while(aux!=’t’ && aux!=’e’ && aux!=’E’ && aux!=’T’); ac=0; if(aux==’e’ || aux==’E’) {cout<<»\nIngrese la seccion de la cual desea conocer el promedio: «;cin>>sec; 157 Teodoro Luciano Córdova Neri for(i=0;i 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 principal b. La suma de la fila ingresada por el usuario c. La suma de la columna ingresada por el usuario d. La matriz ordenada por columnas Solución /* matrices_ord.cpp */ #include void main() 158 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 { 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[“<>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<>i; for(j=1; j<=n;j++) { suma1=suma1+a[i][j]; } cout<<”\nLa suma de la fila es: “<>j; for(i=1; i<=m;i++) { suma2=suma2+a[i][j]; } cout<<”\nLa suma de la columna es: “< 159 Teodoro Luciano Córdova Neri 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 distritos. Solución //mat_EXAMEN2.cpp #include #include #define maxf 50 #define maxcol 50 int a[maxf][maxcol],ordt[maxf][maxcol],ordd[maxf][maxcol]; char nomt[10][10];char nomd[10][10]; int n,i,m,j,tpf[maxcol],tpd[maxf],tot, temp, x,v,k,d,o; void main(){clrscr(); cout<<” ingrese # numero de tipos “;cin>>n; cout<<” ingrese nombre de tipo “<>nomt[i]; } cout<<”\nIngrese #numero de distritos “;cin>>m; cout<<” ingrese nombre de distrito “<>nomd[i]; } clrscr(); gotoxy(30,2);cout<<” ingrese datos de la matriz”< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 } for(i=0;i>a[i][j]; } //calculando por tipos for(i = 0;i=ordt[k][j] ) { temp=ordt[k][j]; ordt[k][j]=ordt[k][i]; ordt[k][i]=temp; } } } //ord vertical for(k=0;k= ordd[i][k]) {temp=ordd[j][k]; ordd[j][k]=ordd[i][k]; ordd[i][k]=temp; 161 Teodoro Luciano Córdova Neri } } } clrscr();gotoxy(20,2);cout<<”proceso de ordenacion por tipos de la matriz”; for(i=0;ix) { x=a[i][j]; } cout<<”\nLa mayor cantidad ingresada es = “< Luego presione ENTER para mostrar las cantidades de matriz, ordenados en forma ascendente por distritos, así como la mayor cantidad dentro de la matriz. 162 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 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[“<>z[i][j];suma=suma+z[i][j]; } prom=suma/(m*n); gotoxy(1,9+n+i);cout<<” La Suma de los elementos es ==> “<”< 163 Teodoro Luciano Córdova Neri 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.cpp void main(){int z[10][10],i,x=6,y=11,j,m,n;float suma,suma1; clrscr();gotoxy(15,1);cout<<”Arreglo Bidimensional “; gotoxy(15,2);cout<<”-----------------------”; do{ gotoxy(3,3);cout<<”Ingrese numero de filas :”; cin>>m; gotoxy(3,4);cout<<”Ingrese numero de columnas :”; cin>>n; } while(m<=0 || m>=10 && n<=0 || n>=10); if (m==n) {gotoxy(4,5);cout<<”Ingrese valores:”; for(i=1;i<=m;i++) for(j=1;j<=n;j++) { gotoxy(18+y*j,x+i*2); cout<<”A[“<>z[i] [j]; } //diagonal principal suma=0; for(i=1;i<=m;i++) for(j=1;j<=n;j++) {if(i==j) { suma=suma+z[i][j]; } } cout<<”\nla suma de la diagonal principal es: “< 164 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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: “<>A[i][j]; } clrscr(); cout<<” Los datos de la La matriz original son:”; for(i=0;i<3;i++) {cout< 165 Teodoro Luciano Córdova Neri 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 filas b. La matriz ordenada por columnas c. La suma acumulada por filas y por columnas d. Mostrar el valor mínimo y máximo de cada fila Solución //mat_ord_fil.cpp #include const int max=100; void main() { int A[max][max], n,m,min,i,j;clrscr(); cout<<”Ingrese la dimension de la matriz (mxn): “<>m; cout<<” Ingrese numero de columnas : “; cin>>n; cout<>A[i][j];clrscr(); cout<<”Los datos de la matriz son:”< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 } } cout<<”La matriz ordenada por columnas:”< 167 Teodoro Luciano Córdova Neri 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 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[“<>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 :”< 168 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 cout<<”v[“< 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<>c; n=atoi(c); while((n<11)||((n%10)==0)) {cout<<”Error al ingresar los datos vuelva a intentarlo: “; cout<<”Ingrese el numero: “;cin>>c; n=atoi(c); } for(i=strlen(c)-1;i>=0;i--) {p++; b[p]=c[i]; } m=atoi(b); r=n; {j=-1; k=m; do { j++; d[j]=(k%10); k=k/10; } while(k>=10); d[j+1]=k; } for(i=2;i<=10000;i++) {j=-1; k=n; for(x=0;x<=strlen(c)-1;x++) {s[x]=0; } do{ j++; s[j]=(k%i); k=k/i; }while(k>=i); s[j+1]=k; if(((j+2)==strlen(c))&&(i!=10)) { w=0; 169 Teodoro Luciano Córdova Neri 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 : “< 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 “<>vuelos[0][i][j][k]; for(l=0;l>pasajeros[0][i][j][k][l]; } } } } system(“cls”); cout<<”\nRegistro de Llegadas : “; for(i=0;i<12;i++) { cout<<”\nMes “< 170 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 for(k=0;k<9;k++) { cout<<”Ingrese el n£mero de vuelos desde “<>vuelos[1][i][j][k]; for(l=0;l>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 “< 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 “< 171 Teodoro Luciano Córdova Neri 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 bajas b. 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ón Diseñ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. 172 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 Solución //matriz_notas_prac_02.cpp # include #define linea1 “____________________” #define linea”-------------------------------------------------------” #define maxal 100 void main() {int codigo,j,cod[maxal],menorpc1,menorpc2; int not[maxal][8],nota,i,sum,n,aux1,pos[maxal]; float prom[maxal]; char resp=’s’; // para la parte interactiva while(resp==’s’) {clrscr(); gotoxy(6,2);cout<<”SISTEMA DE CONSULTAS DE NOTAS “; for (i=1;i<=60;i++) {gotoxy(2+i,4);cout<<”²”; gotoxy(2+i,20);cout<<”²”; } do {gotoxy(12,6);clreol();cout<<”Ingrese cantidad de alumnos: “;cin>>n; }while(n<1 ||n>maxal); clrscr(); gotoxy(6,1);cout<<” Total de alumnos “<>codigo; }while(codigo<100 ||codigo>900); cod[i]=codigo; gotoxy(12,6+i); cout<<”Ingreso de notas “; gotoxy(10,8); cout<>nota; }while(nota<0 ||nota>20); not[i][j]=nota; } clrscr(); } for (int t=1;t<=60;t++) { gotoxy(2+t,4);cout<<”²”;gotoxy(2+t,22);cout<<»²»; } // buscando las dos notas mas bajas, creando el vector posicion y el vector promedio for(i=1;i<=n;i++) 173 Teodoro Luciano Córdova Neri { pos[i]=i;sum=0;menorpc1=21;menorpc2=21; for(j=1;j<=8;j++) { sum=sum+not[i][j]; if(not[i][j]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] 174 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 } gotoxy(6,16+i);cout<>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 # define linea “___________________________” #define taman 20 void main() { int matriz[taman][taman], espiral[taman][taman], temp[100],i,j,k,n; int farribaizq,farribader,cderechaarr,cderechaaba,fabajoder,fabajoizq, cizqaba; int cizqarr,contador, aux;; gotoxy(15,2);cout<<» MATRIZ ESPIRAL «;gotoxy(6,3);cout<>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>matriz[i][j]; x +=12; } y +=1; x = 10; } k = 0; for (i=0;i temp[i+1]) { aux=temp[i]; temp[i]=temp[i+1]; temp[i+1]=aux; } 175 Teodoro Luciano Córdova Neri } } k = 0; for (i=0;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< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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én 2. Almacenar en un vector Total para Producto Tipo[] los totales por producto 3. Mostrar en un vector los elementos todos tipos enteros tanto para Total en 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. 177 Teodoro Luciano Córdova Neri 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_almacen for(j=1;j<=cant_al;j++){ cout<<”\n\nEN EL ALMACEN “<>precios[i] [j]; suma_almacen += precios[i][j]; } total_almacen[j]=suma_almacen; } //Llenando los valores para el vector total_tipo for(i=1;i<=cant_tipo;i++) {suma_tipo=0; for(j=1;j<=cant_al;j++) suma_tipo += precios[i][j];total_tipo[i]=suma_tipo; } //Mostrando totales por almacen 178 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 cout<<”\n\nMostrando los totales por almacen..”<=500) entero=multiplicado/1000+1; else entero=multiplicado/1000; //k++; cant_al_Ent[j]=entero; cout<<”El elemento entero “<=500) entero=multiplicado/1000+1; else entero=multiplicado/1000; //l++; cant_tipo_Ent[i]=entero; cout<<”El elemento entero “< Teodoro Luciano Córdova Neri los elementos //repetidos en el vector eliminados_al z=0; eliminadoi=0; elementoi=1; for(i=1;i<=cant_al-1;i++){ for(k=i+1;k<=cant_al;k++){ if (cant_al_Ent[k]==cant_al_Ent[i]) {p=k; if(elementoi) { eliminados_al[++z]=cant_al_Ent[i]; eliminados_al[++z]=cant_al_ Ent[k]; elementoi=0; } Else eliminados_al[++z]=cant_al_Ent[k]; while (p<=cant_al) {cant_al_Ent[p]=cant_al_Ent[p+1]; p++; } cant_al--;k--;eliminadoi=1; } } if(eliminadoi) {l=i; while(l<=cant_al) {cant_al_Ent[l]=cant_al_Ent[l+1]; l++; } cant_al--;i--;eliminadoi=0; elementoi=1; } } //Eliminando elementos repetidos en cant_tipo_Ent y colocando las secuencias de //los elementos repetidos en el vector eliminados_tipo zz=0; eliminadoi=0; elementoi=1; for(i=1;i<=cant_tipo-1;i++){ for(k=i+1;k<=cant_tipo;k++){ if (cant_tipo_Ent[k]==cant_tipo_Ent[i]) {p=k; if(elementoi) { eliminados_tipo[++zz]=cant_tipo_Ent[i]; eliminados_tipo[++zz]=cant_ tipo_Ent[k]; elementoi=0; } else eliminados_tipo[++zz]=cant_tipo_Ent[k]; while (p<=cant_tipo) {cant_tipo_Ent[p]=cant_tipo_Ent[p+1]; 180 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 p++; } cant_tipo--; k--; eliminadoi=1; } } if(eliminadoi) {l=i; while(l<=cant_tipo) {cant_tipo_Ent[l]=cant_tipo_Ent[l+1]; l++; } cant_tipo--;i--;eliminadoi=0;elementoi=1; } } //Mostrando los elementos del vector entero cant_al_Ent sin repetidos cout<<”\n\nMostrando los elementos enteros sin repetir para el vector Total en Almancen.”; for(i=1;i<=cant_al;i++) cout<<”El elemento sin repetir “< 181 Teodoro Luciano Córdova Neri 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 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 # «<>x1; }while(x1<1 || x1>100); do{cout<<» y = «; cin>>y1; }while(y1<1 || y1>100); casa[i]=sqrt(pow(x1,2)+pow(y1,2)); // verificar mediante dx=pow((xx-x),2); dy=pow((yy-y),2);dxy=dx+dy; // dd=sqrt(dxy); 182 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 cout<<» \t\n La Distancia de la Casa [«<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[ “ < Compendio de problemas [0] [1] 12 11 [2] [3] 09 15 [ 18 ] [ 19 ] índice ........ 11 08 02 12 Bidimensionales Multidimensionales Para caso: secciones, alumnos y notas 183 Teodoro Luciano Córdova Neri 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 184 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 devuelve 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. 185 Teodoro Luciano Córdova Neri 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 notas (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 notas (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: desaprobado. 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. 186 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 Solución En la siguiente interface se ilustra la lectura de datos a vectores A y B, asimismo, en la figura siguiente, se ilustra lo solicitado. Problema 5. 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 ascendente. c. Total de productos por tipo y por almacén, respectivamente. d. Elementos de la matriz ordenados por filas en forma ascendente. e. Producto con menor y mayor cantidad de unidades y la ubicación respectiva. El programa debe ser interactivo con el usuario. 187 Teodoro Luciano Córdova Neri Problema 7. Diseñar un programa que permita realizar las operaciones combinadas 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 programa 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. 188 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 189 Teodoro Luciano Córdova Neri 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). 190 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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, nombre y edad, respectivamente. 2. Empleados por nombre y edad, ordenados en forma ascendente por edad. Asimismo, mostrar la posició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 resultados. 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 correspondiente y su posición respectiva. 191 Teodoro Luciano Córdova Neri 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 respectiva, 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. 192 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 diagonal Dados 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. 193 Teodoro Luciano Córdova Neri 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. 194 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 espiral Dados 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 195 Teodoro Luciano Córdova Neri 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. 196 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 1. Ingreso de Registros 2. Reporte Ordenado de Registros por Apellidos Permite ordenar los registros por apellidos en forma ascendente 3. Insertando Registros. El usuario ingresa el 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 197 Teodoro Luciano Córdova Neri 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. 198 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 Capítulo 4 Las cadenas de caracteres 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++ 199 Teodoro Luciano Córdova Neri 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 voidmain() { charcad; clrscr();gotoxy(2,2);cout<<”Ingrese una cadena :”;cin>>cad; gotoxy(2,4);cout<<”Salida de la cadena: “< 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ácter cout< 200 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 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 =”< 201 Teodoro Luciano Córdova Neri 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 void main(){char *cad1 = “Programacion estructurada”; int lon; lon=strlen(cad1); gotoxy(2,2);cout<<”longitud cadena=”< 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. 202 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 Solución //cadena5.cpp #include 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 : “< 203 Teodoro Luciano Córdova Neri 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 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:”< 4.4 Copia de cadenas: funciones stpcpy(), strcpy(), strncpy() Para el funcionamiento de estas funciones, se usa la librería: 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 204 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 cad1 b. Imprimir a partir del tercer carácter y hasta el final c. Imprimir solo los tres primeros caracteres Solución // cadena3.cpp #include void main() {char cad1[40]; char cad2[100]; gotoxy(2,2);cout<<”Ingrese una cadena : “;gets(cad2); strcpy(cad1,cad2); //copia cad2 en cad1 gotoxy(2,4);cout<<”Cadena completa :”< 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 voidmain() { char cad1[10], *cad2, *cad3; gotoxy(2,2); cout<<”ingrese cadena1 :”; gets(cad1); 205 Teodoro Luciano Córdova Neri cad2=cad1; //Asigna cad1 a cad2 gotoxy(2,4); cout<<”valor de cad2, copiado de cad1 :”< 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.cpp Intmain() { char cadena1[20],cadena2[20], *ptr, busca; cout<<”\nIngrese cadena :”;gets(cadena2);strcpy(cadena1, cadena2); cout<<”\nIngresecaracter a buscar :”;cin>>busca; ptr = strchr(cadena1, busca); //en ptr almacena toda la cadena a partir de busca cout<<”\ncadena resultante al especificar el carácter de búsqueda :”< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 if (ptr) cout<<”\nElcaracter “< 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 voidmain() { charcad[ ]=”universidad “; char *resp; gotoxy(2,2);cout<<”Cadena original: “< 207 Teodoro Luciano Córdova Neri 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.cpp voidmain() { char * cad1=”La universidad”; char * cad2=”La un “; int p; p=strspn(cad1,cad2); //p == 5 gotoxy(2,3); cout<<”la segunda cadena coincide hasta el valor de :”< 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.cpp voidmain() { char *cad1=”Los alumnos,estudian c, c++”; char *cad2=” , “ ; // character a identificar en cad1 int p; p=strcspn(cad1,cad2); //p == 11 cout<<”\nLa posición del carácter idéntico esta en=”< 208 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 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< 209 Teodoro Luciano Córdova Neri 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 Voidmain() {char *cadena1=” curso de BorlandC++5.0.2 “; char *cadena2=”s”; char *ptr; ptr = strpbrk(cadena1, cadena2); if (ptr) { cout< 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 voidmain(){ char codigo[10],pasw[5]; gotoxy(2,2);cout<<”Ingresecodig o :”; gets(codigo); gotoxy(2,3); cout<<”Ingresepasword :” ;gets(pasw); if(strcmp(codigo,”8712D”)==0&&strcmp(pasw,”tcn”)==0) 210 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 { 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 internacionales seleccionado en el sistema operativo. Estas funciones devuelven un valor entero i tal que: i>0 i<0 i==0 si cad1>cad22 si cad1 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(). 211 Teodoro Luciano Córdova Neri Aplicaciones int c; c=strcmp(“uni”,”UNI”); //devuelve un c>0 c=stricmp(“uni”,”UNI”); //devuelve un c==0 c=strcmpi(“fiis”,”uni”); //devuelve un c<0; c=strncmp(“uni”,”uni fiis”,3); //devuelve un c==0 Problema 1. 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 1 b. Cadena 2 es menor que cadena 1 c. Cadena 2 es igual a cadena 1 Solución //vect_cad_com.cpp #include int main(void) {// char *cad1 =”cordova”, *cad2=”CORD”; puede inicializar para comparar char cadena1[20],cadena2[20];intptr; gotoxy(2,2);cout<<”Ingrese cadena 1: “ ; gets(cadena1); gotoxy(2,3);cout<<”Ingrese cadena 2 : “ ; gets(cadena2); ptr = strcmpi(cadena2, cadena1); if (ptr> 0) { gotoxy(2,5); cout<<”cadena2 “< 212 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 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 * “< 213 Teodoro Luciano Córdova Neri 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 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 =”< 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 214 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 Solución //vect_strx_cad.cpp #include 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 :”< 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 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 :”< 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. 215 Teodoro Luciano Córdova Neri Solución //vect_str_str_cad.cpp #include void main() { char *cadena = “ lenguajes Algoritmicos, con diagrama de flujo de datos “; char *subcad = “con”; char *ptr; ptr=strstr(cadena, subcad);cout< 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 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); 216 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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) Teodoro Luciano Córdova Neri cout< 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.cpp voidmain() {char frase[80]; char *ptr; int abrir=0,cerrar=0; gotoxy(2,2);cout<<”Ingrese una frase :”;cin.getline(frase,sizeof(frase)); ptr = strchr(frase,’(‘); while (ptr!=NULL) {abrir++;ptr = strchr(ptr+1,’(‘);} ptr = strchr(frase,’)’); while (ptr!=NULL) {cerrar++;ptr = strchr(ptr+1,’)’); } if (abrir!=cerrar) {cout<<”Error en la frase”< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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: “< COMPENDIO DE PROBLEMAS 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. 219 Teodoro Luciano Córdova Neri 220 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 Capítulo 5 Programación modular 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 221 Teodoro Luciano Córdova Neri 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 } 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=”< 222 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 ................................ // 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) { ; < 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 223 Teodoro Luciano Córdova Neri 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 ”; ”. 224 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 ( ) { ; 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) { ; 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 225 Teodoro Luciano Córdova Neri #include void resta(int , int ); // Prototipo de funciones int multiplica(int, int); int num1, num2, resultado; void resta(int a, int b) { int restan; // variable local restan=a-b; gotoxy(3,7); cout<<”La resta de “<> 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 «< 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). 226 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 Ejemplo int multiplica(int valor1, int valor2) {int productol; // variable local producto = 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 *. 227 Teodoro Luciano Córdova Neri 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 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 “<=’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 = «< 228 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 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 = “< void lectura(int h,int m); void transformacion(char cad[1],int h); void Salida(int h,int m); void main(){ char cad[1]; int m,h;clrscr(); gotoxy(2,2);cout<<”Bienvenidos a conocer los formatos del Tiempo “; gotoxy(2,4);cout <<”Ingrese la hora : “;cin >>h; gotoxy(2,5);cout <<”Ingrese minutos : “;cin>>m; lectura(h,m); transformacion(cad,h); Salida(h,m);getch(); } 229 Teodoro Luciano Córdova Neri void lectura(int h,int m) {gotoxy(2,7);cout << “La Entrada es: “<< “ “<< 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 : “< 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 “<>r; m=r; // en m cargo el número de entrada nd=0;// inicializo contador de dígitos while(m>0) // descompongo el número m ingresado {d=m%10; nd=nd+1; m=m/10 } cout<<” El numero de entrada “< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 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 void leerd(); int proceso(); void reporte(); int pot,base,poten; 231 Teodoro Luciano Córdova Neri 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 “<>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 “< 232 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 a. Leer y mostrar los elementos de la matriz A b. Mostrar la suma acumulada de los elementos diagonales c. El resultado de parte b) sirve como parámetro de la función totald( ), que calcula el total de dígitos que tiene el resultado de la suma diagonal d. Leer los elementos de la matriz B y mostrar la suma de las dos matrices Solución // func_matriz.cpp #include # define max_el 50 int a[max_el][max_el], b[max_el][max_el], c[max_el][max_el] ,n,suma=0,d; void LeeMatriz ( int [max_el][max_el], int ); void imprimirm( int m[max_el][max_el], int r); int sumadiag( int m[max_el][max_el], int r); int totald(int ); int sumamatriz(int a[max_el][max_el],int b[max_el][max_el],int c[max_el][max_ el], int n); void LeeMatriz(int m[max_el][max_el], int r) { int i, j; for( i= 1 ;i<=r;i++) for (j= 1 ;j<=r;j++ ) { cout<<”m[“<>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[“<0) {d=dato%10; td++; dato=dato/10; } 233 Teodoro Luciano Córdova Neri cout<<”\nEl numero “<>n; LeeMatriz(a,n); cout<<”\nElementos de la matriz A: “< 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 234 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 # define max_l 50 void case1(); void case2(); void case3(); void case4(); void case5(); void case6(); void case7(); void case8(); int peru=0, m,n,i,j,t;char A[max_l][max_l][1]; void main() {clrscr(); /* Se usa la variable de estado «t» para que informe lo siguiente: Si t=0 no esta tratando de formar una palabra y Si t=1 se esta tratando de formar la palabra PERU*/ cout<<»\n\tIngrese la cantidad de filas : «; cin>>n; cout<<»\n\tIngrese la cantidad de columnas : «; cin>>m; cout<<»\n\tIngrese los datos de la matriz «; for(i=1;i<=n;i++){ for(j=1;j<=m;j++){ gotoxy(10+2*j,7+i); cin>>A[i][j]; } } /*Comparo con las letra “p” y dependiendeo del caso llamo a una funcion que cumple con los requerimientos*/ for(i=1;i<=n;i++){ for(j=1;j<=m;j++){ if((A[i][j-1][1]==’p’)||(A[i+3][j-1][1]==’P’)){ if(((i+3)<=n)&&((j-3)>0)) case1(); if(((i+3)<=n)&&((j+3)<=m)) case2(); if(((i-3)> 0)&&((j-3)> 0)) case3(); if((j+3)<=m) case4(); if((j-3)>0) case5(); if(((i-3)>0)&&((j+3)<=m)) case6(); if((i+3)<=n) case7(); if((i-3)>0) case8(); } } } gotoxy(4,13);cout<<”La palabra ‘PERU’, se repite “< Teodoro Luciano Córdova Neri i f ( ( A [ i + 3 ] [ j + 3 - 1 ] [1]==’u’)||(A[i+3][j+3-1][1]==’U’)){ peru=peru+1; } } }} void case3(){ i f ( ( A [ i - 1 ] [ j - 1 - 1 ] [1]==’e’)||(A[i-1][j-1-1][1]==’E’)){ i f ( ( A [ i - 2 ] [ j - 2 - 1 ] [1]==’r’)||(A[i-2][j-2-1][1]==’R’)){ i f ( ( A [ i - 3 ] [ j - 3 - 1 ] [1]==’u’)||(A[i-3][j-3-1][1]==’U’)){ peru=peru+1; } } } } void case4(){ if((A[i][j+1-1][1]==’e’)||(A[i] [j+1-1][1]==’E’)){ if((A[i][j+2-1][1]==’r’)||(A[i][j+2-1][1]==’R’)){ if((A[i][j+3-1][1]==’u’)||(A[i][j+3-1][1]==’U’)){ peru=peru+1; } } } } void case5(){ if((A[i][j-1-1][1]==’e’)||(A[i][j-1-1][1]==’E’)){ if((A[i][j-2-1][1]==’r’)||(A[i][j-2-1][1]==’R’)){ if((A[i][j-3-1][1]==’u’)||(A[i][j-3-1][1]==’U’)){ peru=peru+1; } } } } void case6(){ if((A[i-1][j+1-1][1]==’e’)||(A[i-1][j+1-1][1]==’E’)){ if((A[i-2][j+2-1][1]==’r’)||(A[i-2][j+2-1][1]==’R’)){ if((A[i-3][j+3-1][1]==’u’)||(A[i-3][j+3-1][1]==’U’)){ peru=peru+1; } } } } void case7(){ if((A[i+1][j-1][1]==’e’)||(A[i+1][j-1][1]==’E’)){ if((A[i+2][j-1][1]==’r’)||(A[i+2][j-1][1]==’R’)){ if((A[i+3][j-1][1]==’u’)||(A[i+3][j-1][1]==’U’)){ peru=peru+1; } } }} void case8(){ if((A[i-1][j-1][1]==’e’)||(A[i-1][j-1][1]==’E’)) { if((A[i-2][j-1][1]==’r’)||(A[i-2][j-1][1]==’R’)) { if((A[i-3][j-1][1]==’u’)||(A[i-3][j-1][1]==’U’)) 236 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 { 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.cpp void leerd(); void suma_r(); void imprimir(); int ldi,ldd,suma=0,rldi; void leerd() { gotoxy(2,4);cout<<”Ingrese lado izquierdo :”;cin>>ldi; gotoxy(2,5);cout<<”Ingrese lado derecho :”;cin>>ldd; } void suma_r() { rldi=ldi; while(ldi<=ldd) { suma=suma+ldi; ldi=ldi+1;} } void imprimir() {gotoxy(2,7);cout<<”La suma desde “< 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 void leerd (); int procesar(); void reporte(); int n,n1,n2,p;char num[3]; void leerd() 237 Teodoro Luciano Córdova Neri {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 numero n1=n/10; n2=n1%10;p=pow(n2,3); return p; } void reporte() { gotoxy(2,4);cout<<”El dígito “< 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 c. Elementos negativo b. Elementos nulos d. Total de elementos del vector Solución //func_pos_neg.cpp #include 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[«<>Vec[i]; } 238 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 } int contador (int n, int Vec[10]) { int i; for(i=1; i<=n; i++) { if (Vec[i]>0) { posit++; } else { if(Vec[i]==0) { nulos++; } else {negat++; } } } totalel=totalel+posit+nulos+negat;re turn 0; } void main() { marco(); gotoxy(12,5); cout<<”Ingrese el tamaño del vector:”; cin>>n; leer(n,Vec); contador(n,Vec); gotoxy(12,12);cout<<”Total positivos = “< #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<>a[i][j];cout< 239 Teodoro Luciano Córdova Neri } 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[“<>b[i][j];cout<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[“< 240 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 void Burbuja(int mat[30],int m) { int i,j,temp; for(i=0;imat[j]) {temp=mat[i];mat[i]=mat[j]; mat[j]=temp; } } void main() { int i,n,A[30],m_orden[30],resp[30]; bool clrscr(); cout<<”\n\tIngrese cantidad de numeros a Encryptar “;cin>>n; //en un arreglo se indican las posiciones: si es impar sera false //si es par sera true for(i=0;i>A[i]; if(A[i]%2!=0) //si es impar Orden[i]=false; else //si es impar Orden[i]=true;m_orden[i]=A[i];// }//hacemos marcar ubicación de números pares e impares gotoxy(2,8);cout<<”Impares : “; gotoxy(2,9);cout<<”Pares : “; for(i=0;i Orden[30]; 241 Teodoro Luciano Córdova Neri { 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 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 int buscando(int t); void main(){ int o,f,i,c,e,m,n,d,s,w,r,a,b; for(o=1;o<=9;o++) { for(f=0;f<=9;f++) { for(i=0;i<=9;i++) { for(c=0;c<=9;c++) { for(e=0;e<=9;e++) { for(m=1;m<=9;m++) { for(n=0;n<=9;n++) { for(d=0;d<=9;d++) { for(s=0;s<=9;s++) { for(w=1;w<=9;w++) { for(r=0;r<=9;r++) { a= o*10*10*10*10*10 + f*10*10*10*10 + f*10*10*10 + i*10*10 + c*10 + e ; b=m*10*10*10*10*10 + s*10*10*10*10 + w*10*10*10 + o*10*10 + r*10 + d ; 242 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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:”< 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 # define linea “-----------------------------” time_t tiemp;int monto,saldo,n; 243 Teodoro Luciano Córdova Neri 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 : “< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 gotoxy(35,3);cout<>Uid; gotoxy(4,7);cout<<”Ingrese Clave : “;cin>>Pwd; if (strcmp(Uid,”tcn”)==0 && strcmp(Pwd,”1234”)==0){ gotoxy(6,9);cout<<”Sr.”< float distanciaxy(float x1, float y1,float x2, float y2); float x1,y1,x2,y2; 245 Teodoro Luciano Córdova Neri float salida; float distanciaxy(float x1, float y1,float x2, float y2) { float resultado,intermedio; intermedio=pow(x1x2,2)+pow(y1-y2,2); resultado =sqrt(intermedio); return (resultado); } voidmain(){clrscr(); gotoxy(2,2);cout<<”DISTANCIA ENTRE DOS PUNTOS”; gotoxy(2,3);cout<<”PUNTO A(x1,y1)”; gotoxy(2,4);cout<<”Ingrese el valor de x1 :”;cin >>x1; gotoxy(2,5);cout<<”ingrese el valor de y1 :”;cin >>y1; gotoxy(2,7); cout<<”PUNTO B(x2,y2)”; gotoxy(2,9); cout<<”Ingrese el valor de x2 :”; cin >>x2; gotoxy(2,10);cout<<”Ingrese el valor de y2:”;cin >>y2; salida=distanciaxy(x1,y1,x2,y2); gotoxy(2,12); cout<<”La distancia es= “< 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 void entradas(int& a , int& b); void intercambia(int& var1 ,int& var2); void Ordena(int& n ,int& m); void imprimir(int res1,int res2 ); void main(){int a, b; gotoxy(5,2);cout<<”FUNCIONES QUE LLAMAN ABSTRACCION”; entradas(a, b); Ordena(a, b); imprimir(a, b); getche(); 246 A FUNCIONES: Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 } 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 :”< 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 void leercaracter(); void leercaracter() {char tecla; tecla=getch(); if(tecla!=13&&tecla!=27) {cout< Teodoro Luciano Córdova Neri 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/2 23 1 11 11 1 5 5 1 2 2 0 1 1 1 0 0 La representación binaria de 23 es 10111 Solución //func_rec_binar.cpp #include const int base = 2; void sist_binario(int n); void sist_binario(int n) { if (n > 0) {sist_binario(n/base); cout<>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 float pendiente(float p,float q,float r,float s); float recta(float a, float b,float c,float d,float e); float pendiente(float p, float q, float r,float s) { return((s-q)/(r-p)); // 1/3=0.33333 : 1,4=0.25 } float recta(float a, float b,float c,float d,float e) { if((a-b-c*(d-e))==0) // y-y1 = m(x-x1) { // a-b = c*(d-e) --> a-b-c*(d-e)=0 return(1); } 248 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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(“<>x2; gotoxy(2,10);cout<<”y2=”; cin>>y2; gotoxy(14,10);cout<<” Punto: B(“<>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(“< 249 Teodoro Luciano Córdova Neri 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 void f_base(unsigned int,int); char letra(int,int); void f_base(unsigned int n, int b) { unsigned int c, r; int i, j; char num[16]; for(i=0;i<16;i++) num[i]= ‘9’; i = 0; c = n/b; r = n%b; if (c > b){ num[i] = letra(b,r); i++; while (c > b) {n = c;c = n/b; r = n%b; num[i] = letra(b,r); I ++;} num[i] = letra(b,c); } else{ num[i] = letra(b,r); i++; num[i] = letra(b,c);} for(j=i;j>=0;j--)putch(num[j]); } char letra(int base,int numero) { char resp; switch (base) { case 2 : switch (numero) { case 0 : resp = ‘0’; break; case 1 : resp = ‘1’; break; } break; case 8 : switch (numero) { case 0 : resp = ‘0’; break; case 1 : resp = ‘1’; break; case 2 : resp = ‘2’; break; case 3 : resp = ‘3’; break; case 4 : resp = ‘4’; break; case 5 : resp = ‘5’; break; case 6 : resp = ‘6’; break; case 7 : resp = ‘7’; break; } break; case 16 :switch (numero) { case 0 : resp = ‘0’; break; case 1 : resp = ‘1’; break; case 2 : resp = ‘2’; break; case 3 : resp = ‘3’; break; case 4 : resp = ‘4’; break; case 5 : resp = ‘5’; break; case 6 : resp = ‘6’; break; case 7 : resp = ‘7’; break; 250 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 “<>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. 251 Teodoro Luciano Córdova Neri Solución //func_Facultad_cursos.cpp #include #include #include 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 : “<>n; s=0; cout<<”Ingrese las notas de los alumnos:\n”; for(j=1;j<=n;j++) {cout<<”Alumno “<>nota; s=s+nota;} prom=s/n; cout<<”\nEl promedio de este ciclo es:”<=5) { puts(curso); cout<<”\nEl curso tiene problemas”<>rpta; if ((rpta==’s’)||(rpta==’S’)) {getchar(); } } while((rpta==’s’)||(rpta== ’S’)); } void main() {calculo_promed(); } 252 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 centro : S/. 25 Al sur : S/.30 Al oriente: S/.22 El programa debe generar los siguientes reportes: a. Número total de pasajeros por servicio y monto total por cada servicio b. Número total de pasajeros y monto total c. Vendedor con mayor venta de pasajes d. Vendedor con mayor venta de pasajes por servicio e. Servicio que recaudó mayor cantidad de dinero y el vendedor respectivo Solución //func_Ventas_pasaj.cpp #include #define max 10 typedef char cadena[20]; int costo[4]={40,30,25,22}; cadena oficina[4]={“Norte”,”Sur”,”Centro”,”Oriente”}; int ganancia[4]={2,3,4,5}; void Leer_datos(int&,cadena[],int[max][4]); bool Ingreso_usuar_sistema(); int Sumar(int,int,int[max][4],bool); int Mayor(int,int,int[max][4],bool); void Comparar(int,int,int,cadena[],int[max][4],bool); void main() {cadena vendedor[max]; int numero_vendedor,ventas[max][4]; bool flag; int i,j,suma=0,suma_venta=0; clrscr(); flag=Ingreso_usuar_sistema(); Leer_datos(numero_vendedor,vendedor,ventas); if (flag) {clrscr(); cout<<”\n\t Numero de Pasajeros y monto total de cada servicio: \n”; for(i=0;i<4;i++) {cout<<”\n\t Pasajeros al “< Teodoro Luciano Córdova Neri {suma=suma+ventas[i][j]; suma_venta=suma_venta+ventas[i][j]*costo[j]; } cout<<”\t\ Pasajeros totales = “<>n; for (i=0;i>ve[i][j]; } } } bool Ingreso_usuar_sistema() {int clave,intentos=3; bool flag=false; do {clrscr();gotoxy(2,2);cout<<” MODULODE VALIDACION DE DATOS “; gotoxy(2,4);cout<<”Ingrese Clave : “;cin>>clave; if (clave==1234) flag=true; 254 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 else {gotoxy(4,6);intentos--; cout<<”Clave incorrecta, le quedan “< Teodoro Luciano Córdova Neri Vendedor “< } 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 #include #include 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[«<>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< 256 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 #include # define max_el 100 void LeerMatriz (int matriz[10][10], int f, int c); void ReporteMatriz(int matriz[10][10], int f, int c); void OrdenarMatriz(int matriz[10][10], int f, int c); void MostarDatosMatriz(int matriz[10][10], int f, int c); void OrdenarVector (int vector[10], int n); int genera[30][30], n, m; void LeerMatriz(int matriz[10][10], int f, int c) { int i, j; srand(10);//reinicializa el numero aleatorio for(i=1; i<= f; i++) { for(j=1; j<=c; j++) { matriz[i][j]=rand()%10; } cout<<”\n”; } getche(); } void OrdenarMatriz(int matriz[][10], int f, int c) { int vector[max_el ], i, j, k=1; // copiando elementos de la matriz en un vector for(i=1; i<= f; i++) for(j=1; j<= c; j++) { vector[k]=matriz[i][j]; k++; } //Ordenar el Vector OrdenarVector(vector, k); //Pasar los datos ordenados del vector a la Matriz k=1; for(i=1; i<= f; i++) for(j=1; j<= c; j++) matriz[i][j]=vector[k]; k++;} } void MostarDatosMatriz(int matriz[10][10], int f, int c) { int i, j;srand(10);//reinicializa el numero aleatorio for(i=1; i<= f; i++) { for(j=1; j<=c; j++) cout< vector[j+1]) { aux=vector[j]; vector[j]=vector[j+1]; vector[j+1]=aux; } }}} void main() 257 Teodoro Luciano Córdova Neri { 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 # define linea “-----------------------------------------” # define max_el 100 void cantidad_num(); int divisores();int datos[max_el], n ,i,j; void cantidad_num () {gotoxy(2,4);cout<<”Ingrese n:”; do { cin>>n;gotoxy(2,4);cout<<”Numero fuera de rango, vuelva a Ingresar: “;clreol(); }while(n<0||n>100); gotoxy(2,6);cout<<”Ud.ha ingresado correctamente, gracias”; } int divisores(){gotoxy(2,9);cout<<”Ingrese “< 258 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 for(i=1;i<=n;i++){cout<<”\nNumero[“<>datos[i]; for(j=1;j<=datos[i];j++) {if (datos[i]%j==0) {cout<<”El numero “<< datos[i]<<” tiene como divisores a “< 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 si n = 0 n(n-1) si n ≠ 0 Caso base Caso recursivo 259 Teodoro Luciano Córdova Neri Que permite ejecutarse de la siguiente manera: Ilustracion analítica de la descomposición de n=5 factorial(5) = 5 * (factorial(4)) = 5 * ( 4 * (factorial(3))) = 5 * ( 4 * ( 3 * (factorial(2)))) = 5 * ( 4 * ( 3 * ( 2 * (factorial(1))))) = 5 * ( 4 * ( 3 * ( 2 * ( 1 * (factorial(0)))))) = 5 * ( 4 * ( 3 * ( 2 * ( 1 * 1)))) = 5 * ( 4 * ( 3 * ( 2 * 1))) = 5 * ( 4 * ( 3 * 2)) = 5 * ( 4 * 6) = 5 * 24 =120 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=3 return 3*factoria(2) return 2*factorial(1) return 1*factorial(0) //como n es cero , no vuelve a llamar En general para n se tiene la siguiente 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 # define linea “------------------” int resp;int n,i=0; void recursiva(int i); void recursiva(int i) { if(i<=n) { recursiva(i+1); cout< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 {gotoxy(4,2);cout<<”RECURSIVIDAD DESCENDENTE”; gotoxy(2,3);cout<>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 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 = “< int contador(char letra,char[]); int contador(char letra, char cad[]) {if (cad[0]==’\0’) return 0; else if(letra==cad[0]) return 1 + contador(letra,&cad[1]) ; 261 n!= { 1 si n = 0 n(n-1) si n ≠ 0 Caso base Caso recursivo Teodoro Luciano Córdova Neri 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 “< 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 Cálculo de la potencia ab: ab = { 1 si b = 0 a(ab-1) si b > 0 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 float potencia( float base, int expon ); float potencia( float base, int expon ) { if(exp == 0 ) return(1); return( base*potencia(base,expon-1)); } void main(){ int base, exp; gotoxy(2,2);cout<<”FUNCION RECURSIVA POTENCIA”; gotoxy(2,4);cout<<”Ingrese base :”;cin>>base; 262 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 gotoxy(2,5);cout<<”Ingrese exponente :” ;cin>>expon; gotoxy(2,7); cout<<”El numero “< a “< 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 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 “< const int longi =50; // Tamaño del vector typedef int lista[longi]; void buscar(lista Ordenado, int Primero, int Ultimo, int Item, int &Dato); void buscar(lista Ordenado, int Primero, int Ultimo, int Item, int &Dato) {int Mitad; if (Primero > Ultimo) { Dato = 0; } 263 Teodoro Luciano Córdova Neri 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 “< 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 “< 264 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 Solución //func_rec_c++.cpp #include void rotaciones(char s[],int n);void permutaciones(char s[],int n); void main() { cout<<”\n Permutaciones de la palabra NUI”< Compendio de problemas 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. 265 Teodoro Luciano Córdova Neri 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 respectivos. 2. Subprograma que permita hacer reporte de datos de alumnos incluyendo la ubicación inicial. 3. Subprograma que permita hacer reporte 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 tambié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. 266 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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, 267 Teodoro Luciano Córdova Neri 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: Código Apellidos Asignatura Sección Práctica 1 Práctica 2 Práctica 3 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: Código Apellidos Asignatura Sección Práctica 1 Práctica 2 Práctica 3 Menor Promedio 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. 268 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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: Código Apellidos Asignatura Sección Práctica 1 Práctica 2 Práctica 3 Menor Promedio 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 269 Teodoro Luciano Córdova Neri ingreso del registro. En la siguiente figura se ilustra el proceso de entrada de datos al sistema. OrdenarNombresAsc(). Es un procedimiento que permite ordenar datos de alumnos por nombre y en forma ascendente. Usando el Procedimiento Reportes(), se genera el reporte respectivo. BuscarNombre(). Es un procedimiento que permite al usuario realizar 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 procedimiento que permite generar un reporte de alumnos ordenados en forma ascendente, tal como se ilustra en la siguiente figura. InsertarDatos(). Es un procedimiento que permite insertar nuevo registro (lo importante es mostrar 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. 270 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 Eliminación(). Es un procedimiento que permite eliminar registros que tienen igual código. Ver figuras adjuntas. 271 Teodoro Luciano Córdova Neri 272 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 Capítulo 6 Registros (struct) 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. 273 Teodoro Luciano Córdova Neri 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. 274 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 Empleado Código nombre ‘89760K’ ‘Ana’ Tipos de datos: cadena(har) apellidos ‘Salas’ Entero(int) edad 30 sueldo 1209,4 sexo ‘F’ 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; 275 Teodoro Luciano Córdova Neri 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 { } 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 276 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 # 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[“<>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< Teodoro Luciano Córdova Neri gotoxy(2,8); cout<<” Codigo Nombre Edad”< gotoxy(2,9); cout< 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ácticas b. Promedio final c. Condición de alumno: aprobado o desaprobado. Si promedio final es mayor a 10.5 alumno APROBADO, sino DESAPROBADO d. Cantidad de alumnos aprobados y alumnos desaprobados 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 [“<>datos[i].codigo; gotoxy(5,6);cout<<” Edad : “ ;cin>>datos[i].edad; 278 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 do{gotoxy(5,7);clreol();cout<<” Examen Parcial: “;cin>>datos[i].ex1; }while(datos[i].ex1<0 || datos[i].ex1>20); do{ gotoxy(5,8);clreol();cout<<” Examen Final: “;cin>>datos[i].ex2; }while(datos[i].ex2<0 || datos[i].ex2>20); do{ gotoxy(5,9);clreol();cout<<” Practica 1 : “;cin>>dates[i].p1; }while(dates[i].p1<0 || dates[i].p1>20); do{ gotoxy(5,10);clreol();cout<<” Practica 2 : “;cin>>dates[i].p2; }while(dates[i].p2<0 || dates[i].p2>20); do{gotoxy(5,11);clreol(); cout<<” Practica 3 : “;cin>>dates[i].p3; }while(dates[i].p3<0 || dates[i].p3>20); clrscr(); dates[i].pp=(dates[i].p1+datos[i].p2+datos[i].p3)/3; datos[i].pf=(datos[i].ex1 + datos[i].ex2 + datos[i].pp)/3; } // buscando alumnos aprobados y desaprobados clrscr(); for(i=1; i<=n; i++) {if(dates[i].pf>10.5) { aprob++; } else{ desap++; } } gotoxy(2,13); cout<<”=> Total de Alumnos Aprobados: “< Total de Alumnos Desaprobados: “<10.5) { gotoxy(68,3+i); cout<<»\»APROBO\»»< 279 Teodoro Luciano Córdova Neri 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 funciones void 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 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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;i0) { 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< 281 Teodoro Luciano Córdova Neri 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 nombres 2. Para cursos: leer nombre de cursos 3. 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 struct cursos {char nombre_curso[30]; int numero_practica; float practica[max_al],pp,ep,ef,es,pf; }; struct alumnos {char codigo[8],apellido[30],nombre[30]; int numero_curso; cursos curso[max_al]; //anida la estructura: curso }alumno[max_al]; void main() {int cantidad,i,j,k,l,m,aux; char *op; clrscr(); 282 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 cout<<”\n\n\tIngrese numero de Alumnos :”; cin>>cantidad; cout<<”\n\t Ingreso de datos de los alumnos : \n”; for(i=0;i>alumno[i].numero_curso; for(j=0;j>alumno[i].curso[j].numero_practica; for(k=0;k>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=6.1) {op=”N”;cout<<”\n\t\t\t\tDesea dar Sustitutorio(S/N) :”; cin>>op; } if ((op[0]==’s’)||(op[0]==’S’)) {cout<<”\n\t\t\t\tIngresar nota sustitutoria :”;cin>>alumno[i].curso[j].es; if (alumno[i].curso[j].ep>alumno[i].curso[j].ef) alumno[i].curso[j].ef=alumno[i].curso[j].es; else alumno[i].curso[j].ep=alumno[i].curso[j].es; alumno[i].curso[j].pf=(alumno[i].curso[j].ep+alumno[i].curso[j].ef+alumno[i]. curso[j].pp)/3; } 283 Teodoro Luciano Córdova Neri } } clrscr(); cout<<”REPORTES DE ALUMNOS POR APELLIDOS, NUMERO DE CURSOS, ESTADO Y NOTA FINAL”<=10.0) cout<<” Aprobo con “< 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 284 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 # define linea “----------------------------------------------------------” void ingresa(); void imprime(); int mayoredad(); // functions prototipos int i, mayor,cmy=0,n; struct alumno {char nombre[20]; int edad;} lista[100]; void main(){ clrscr();cout<<”\n\tINGRESO DE ALUMNOS :”; cout<<”\n\t”<>n; ingresa();imprime(); mayoredad(); cout<<”\n\tAlumno de mayor edad es :”<>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 “< 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: 285 Teodoro Luciano Córdova Neri < 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 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 :»< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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<<” “;cin>>opc;clrscr(); }while((opc!=1)&&(opc!=2)&&(opc!=3)&&(opc!=4)&&(opc!=5)&&(opc!=6)&&(op c!=7)&&(opc!=8)&&(opc!=9)); switch(opc) { clrscr();case 1:{marco(); gotoxy(25,5);cout<<” CREANDO EL ARCHIVO...... “; gotoxy(16,7);cout<<”Ingrese nombre de Achivo : “;gets(arch); gotoxy(16,8);cout<<”Ingrese 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 “< Teodoro Luciano Córdova Neri 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 #: “<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 :”<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 :”< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 {gotoxy(14,20+i);cout<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 :”< Por Edad»; gotoxy(14,10);cout<<”< 2 > Por Código”; 289 Teodoro Luciano Córdova Neri 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: “<>edadal;clrscr(); for(i=1;i<=n;i++) { if(lista[i].edad==edadal) { gotoxy(25,17);cout<<”SISTEMA DE CONSULTAS POR EDAD”; gotoxy(14,19);cout<<”Codigo”; gotoxy(28,19);cout<<”Apellid os”; gotoxy(50,19);cout<<”Nombres”; gotoxy(65,19);cout<<”Edad”gotoxy(14,20+i);cout<>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 : “< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 {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 “<>rpta1; } break; } while(rpta1==’n’);clrscr(); } break; case 9:{marco(); for(e=1;e<=50;e++) { gotoxy(12+e,8);cout<<”_”; gotoxy(12+e,10);cout<<”_”;} 291 Teodoro Luciano Córdova Neri 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; #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 prototipo void marco() {int i; time_t t; t = time(&t); gotoxy(20,3);cout<<»La fecha y hora actual es :»< 1”; do { gotoxy(12,8); cout<<”Ingrese Codigo : “; cin>>alumno[i].codigo; 292 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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)< “< Teodoro Luciano Córdova Neri for(j=0;jmayor) {mayor=alumno[j].edad; pos=j; } gotoxy(14,10); cout<<”El alumno de Sistemas con Edad Mayor es : “<mayor) { mayor=alumno[j].edad; pos=j; } gotoxy(14,13);cout<<”El alumno de Industriales con Edad Mayor es : “<mayor) { mayor=alumno[j].edad; pos=j; } gotoxy(14,16); cout<<”El alumno de Mecánica con Edad Mayor es : “< 294 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 preguntar al usuario “Desea continuar?.....(S/N)—>. Solución //struct_vendedor_mat.cpp #include # 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;ia[j]) {aux=a[i]; a[i]=a[j]; a[j]=aux; 295 Teodoro Luciano Córdova Neri }} 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<>r; for(i=0;i>data[i].vendedor; data[i].cant=0; } for(i=0;i>x[i][j]; orden[k]=x[i][j]; monto[k]=x[i][j]*precio[j]; k++; ta[i]+=x[i][j]; // Calculo de los Totales en los Distritos recau[i]+=x[i][j]*precio[j]; comision[i]+=x[i][j]*precio[j]*porce[j]; data[i].cant+=x[i][j]; tb[j]+=x[i][j]; // Cálculo de los Totales de las Marcas de tipos 296 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 297 Teodoro Luciano Córdova Neri C”;break; case 3 : cout<<”\t\t”<”;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. 298 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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. Compendio de problemas 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 edad b. Alumnos ordenados por apellidos en forma ascendente c. El alumno(s) de mayor edad, alumno(s) de menor edad d. Total de alumnos y el promedio de edades Problema 2. 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 precio b. Listado de productos ordenados en forma ascendente por precio c. 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 puntaje b. Listado de alumnos por apellidos y ordenados por sexo en forma ascendente c. Total de alumnos indicando “promovidos” cuando su puntaje es mayor que 20 y la cantidad de repitentes, cuando su puntaje es menor que 20 299 Teodoro Luciano Córdova Neri 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 definir la cantidad de registros. En la siguiente figura se ilustra la ejecución de este módulo, donde para iniciar se 300 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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. 301 Teodoro Luciano Córdova Neri 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 apellidos 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”. 302 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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, 303 Teodoro Luciano Córdova Neri 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 sueldo b. Listado de empleados por código, apellidos, sueldo ordenados en forma ascendente por apellidos c. Total de empleados y el Promedio de sueldo respectivo 304 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 desaprobados d. 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 respectivo b. 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 edad b. Alumnos ordenados por apellidos en forma ascendente c. El alumno(s) de mayor edad, alumno(s) de menor edad d. Total de alumnos y el promedio de edades Problema 12. 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: 305 Teodoro Luciano Córdova Neri a. Listado de productos por código, nombre, fecha de fabricación y precio b. Listado de productos ordenados en forma ascendente por precio c. 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 puntaje b. Listado de alumnos por apellidos y ordenados por sexo en forma ascendente c. Total de alumnos indicando “Promovidos” cuando su puntaje es mayor que 20 y la cantidad de Repitentes, cuando su puntaje es menor que 20. 306 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 Capítulo 7 Archivos (file) 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 307 Teodoro Luciano Córdova Neri 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 momentos 7.3 Archivos (FILE) Es una estructura de datos para el procesamiento de registros, es decir, está compuesto por un conjunto de registros con igual cantidad de campos (ver figura). Recuerde que los registros se inician con el índice 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. 308 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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. 309 Teodoro Luciano Córdova Neri 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. 310 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 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: 311 Teodoro Luciano Córdova Neri fopen(nomb_archivo,”modo”): Donde: nomb_archivo: es una cadena que indica ruta y nombre de archivo modo : modo de acceso al archivo que se abrirá o se creará Modo de apertura (archivos de texto) texto) Modo de apertura (archivos binarios) “r” “rb” “w” “wb” “a” “ab” “r+” “rb+” “w+” “wb+” “a+” “ab+” Descripción Apertura en modo de sólo lectura. El archivo debe existir. Apertura en modo de sólo escritura. Si el archivo existe, se reescribirá (pierde el contenido anterior).Si archivo no existe, lo crea Apertura en modo de agregar. Si el archivo existe, los datos se agregan al final del archivo en caso contrario el archivo se crea. Apertura en modo de lectura/escritura. El archivo debe existir. Apertura en modo de lectura/escritura. Si el archivo existe, se reescribirá. Apertura en modo de lectura/agregar. Si el archivo no existe lo crea. 7.12 Validar la apertura de un archivo Se debe crear el 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 312 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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. Sintaxis Donde: fwrite(&var_reg, sizeof(var_reg), 1, alias1); & : dirección de memoria var_reg : es una variable registro 1 : se procesará en cada operación 1 registro alias1 : es una variable lógica para relacionar con archivo físico La 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, 313 Teodoro Luciano Córdova Neri por lo se debe asegurar que se encuentre en la posición deseada antes de realizar cualquier operación. Sintaxis fseek(alias, direcc_fisica, Punto_de_referencia); Donde: Alias: variable lógica direcc_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)) {; 7.21 Cambio de nombre de archivo rename() Cambia nombre cuando un archivo esta cerrado. Sintaxis 314 } Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 sistema Se dispone al usuario de un conjunto de alternativas que puede realizar con el sistema de mantenimiento: alternativas que se implementan mediante el siguiente 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”; 315 Teodoro Luciano Córdova Neri 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 <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 completo fwrite(&f1, sizeof(f1), 1, falumno); fclose(falumno); // Cierra el archivo cout << «\n\n\n\r ALUMNO REGISTRADO !!!\n»;´ getch(); return; } Al ejecutar el archivo se ha creado con el nombre de Alumno.dat y su contenido se puede mostrar 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: 316 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 void IngresarCurso() { int cod_cur; system(“cls”); cout<<”\n\rINGRESAR REGISTROS DEL CURSO”; fcurso=fopen(“CURSO. DAT”,”rb+”); if(fcurso == NULL) { fcurso = fopen(“CURSO. DAT”,”wb”); } cout << “\n\n\n\r Codigo del Curso : “; cin >>cod_cur; fread(&f2,sizeof(f2),1,fcurso); while(!feof(fcurso)) { if(f2.cod_cur == cod_cur) {cout << “\n\n\n\r Registro DE CURSO YA EXISTE ...!!!”; fclose(fcurso); getch(); return; } fread(&f2,sizeof(f2),1,fcurso); } f2.cod_cur = cod_cur; cout<< “\n\rNombre del Curso : “; gets(f2.nomb_cur); cout<< “\n\rCreditos:”;cin>>f2.cred; fwrite(&f2,sizeof(f2),1, fcurso); fclose(fcurso); // Cierra el archivo cout << “\n\n\n\r CURSO REGISTRADO !!!\n”; getch(); return; } Alternativa 3. 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: “; 317 Teodoro Luciano Córdova Neri cin>>f3.ep; //scanf(“%d”,®.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”<>>”; getch(); return; } cout <<”\n\r _________________________________________________”; cout << “\n\r CODIGO NOMBRE APELLIDO”; cout <<”\n\r ___________________________________________________”; fread(&f1, sizeof(f1), 1, falumno); while(!feof(falumno)) { printf(“\n\r %12d \t%15s %-5s”,f1.cod_al, f1.apell_al, f1.nomb_al); fread(&f1, sizeof(f1), 1, falumno); } fclose(falumno); // Cierra el archivo cout<<”\ 318 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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”; } 319 Teodoro Luciano Córdova Neri fclose(falumno); Eliminar(); getch(); return; } fread(&f1, sizeof(f1), 1, falumno); } cout << “\n\rNo se encuentra ese registro !!!\n”; fclose(falumno); // Cierra el archivo Eliminar(); getch(); return; } void Eliminar() { //Variable para controlar el archivo temporal FILE *Temporal; falumno = fopen(“ALUMNO.DAT”,”rb”); // Valida la existencia del archivo if(falumno == NULL) { cout << “\n\n\n\rNo existe el archivo !!!\n”; getch(); return; } // Crea el archivo Temporal.DAT Temporal = fopen(“TEMPORAL.DAT”,”wb”); fread(&f1, sizeof(f1), 1, falumno); while(!feof(falumno)) { if(f1.cod_al != 0) fwrite(&f1,sizeof(f1),1,Temporal); fread(&f1, sizeof(f1), 1, falumno); //Lee el siguiente elemento del archivo } fclose(falumno); fclose(Temporal); remove(“ALUMNO.DAT”); rename(“TEMPORAL.DAT”, “ALUMNO.DAT”); getch(); return; } Compendio de problemas 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: 320 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 200 Ciclos Promedio 2005-1 12.3 2006-1 5.5 2005-2 11.4 2006-2 2005-3 15.8 2006-3 Ciclos Promedio Ciclos Ciclos Promedio Ciclos Promedio 2007-1 10.2 12.5 2007-2 3.4 6.7 2007-3 11.2 Ciclos Promedio 2005-1 11 2006-1 Promedio 4.4 2007-1 12.4 2005-2 11.4 2006-2 12.2 2007-2 17.5 2005-3 12 2006-3 11.3 2007-3 11.5 Problema 2. Usando archivos con 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. 321 Teodoro Luciano Córdova Neri 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. 322 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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. 323 Teodoro Luciano Córdova Neri 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, 324 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 325 Teodoro Luciano Córdova Neri 326 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 Capítulo 8 Programación dinámica (punteros) 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 327 Teodoro Luciano Córdova Neri 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 variable puntero valor guarda dirección X *P 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 entero char *nombre ; // nombre es un puntero a carácter float *a,*b ; //a y b son punteros a reales } Notaciones: Las siguientes sintaxis void 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. 328 *P &Q Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 8.4 INICIALIZACIÓN DE UN PUNTERO int x =20 ;int p= & x ; * p; 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: Un objeto individual T x; Valor 0 = puntero nulo Null=0 Declaración e inicialización Declaración e inicialización en una misma línea desdobladas T* ptr; T* ptr = &x; ptr = &x; T* ptr; T* ptr = 0; ptr = 0; T* ptr; T* ptr = NULL; 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; 329 Teodoro Luciano Córdova Neri 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.cpp void main() { int suma; int *a; int *b ; a = new int; b = new int; gotoxy(10,2); cout<<” Ingrese valor de *a = “;cin>>*a; gotoxy(10,3); cout<<” Ingrese valor de *b = “;cin>>*b; suma=*a+*b; gotoxy(10,5);cout<<” La suma de *a+*b es = “< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 = “<>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 = “<0) { inv=10*inv+n%10; n=n/10; } return inv; } void main() { clrscr(); int *a,*b; int q;char *cod, *clave; char resp=’s’; do { gotoxy(10,2);cout<<”VALIDANDO DATOS DE USUARIO “;clrscr(); cod=new char[5]; clave=new char[5]; a=new int; b=new int; gotoxy(10,4);cout<<”Ingrese codigo = “; cin>>cod; 331 Teodoro Luciano Córdova Neri 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 = “<”; 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). 332 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 #include #include #include #include # 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< 333 Teodoro Luciano Córdova Neri 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 334 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 #include #include #include #include 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 = “< 335 Teodoro Luciano Córdova Neri {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 = “< 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.cpp typedefstruct alum // defino estructura de la pila {int nota; struct alum *sigte; }nodo; voidmain() {nodo *p; nodo *q; nodo *r; //declaro 3 punteros p=new nodo; // asigno memoria para cada puntero q=new nodo; r=new nodo; system(“title Cordova Neri T. : pila_2010_3_Nodos.cpp”); gotoxy(12,2); cout<<” ==> CREANDO PILA <== “; gotoxy(10,4); cout<<”Ingrese Nota de Primer Nodo : “;cin>> p->nota; p->sigte=q; gotoxy(10,5); cout<<”Ingrese Nota de Segundo Nodo : “;cin>>q->nota; q->sigte=r; gotoxy(10,6); cout<<”Ingrese Nota de Tercer Nodo : “;cin>>r->nota; r->sigte=NULL; //reporte 336 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 gotoxy(10,11); cout<< “Pila:”; gotoxy (18,11); cout<nota<<” => “<nota<<” => “<nota; // eliminando nodos delete [] 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 intn,j, i, aprob=0, desap=0,de=0,ap=0,notas[100], notasde[100],aux; int datos[100]; typedefstructnotaslaumnos// MODELO { int nota; // DATO DE USUARIO structnotaslaumnos *sgte;//ENLACE DE SIGUIENTE NODO }nodo; //VAR REGISTRO nodo *crear_nodo(int valor) //creo nodo y le asigno datos { nodo *r; // r toma dirección de memoria r = new nodo; // r recibe espacio de memoria r->nota=valor;//llenar campo del nodo r->sgte=NULL;//termina de definir el nodo return(r);//returne la dirección de r 337 Teodoro Luciano Córdova Neri } voidmarco() { int i; time_t t; t = time(&t); gotoxy(12,3);cout<<”Fecha y hora actual : “< Creando Lista (*PILA) <--- “; } voidcrear_lista(nodo *&p)// creo procedimiento para ir llamando a nodo { marco(); intnota,i; nodo *r; p=NULL;//inicializo do{ gotoxy(16,7);cout<<”Ingrese numero de nodos: “;cin>>n; }while (n<0 ||n>100); for(i=1;i<=n;i++) { do {gotoxy(18,i+8);cout<<”Nota “<>nota; }while(nota<0||nota>20); r=crear_nodo(nota);//llamar a función y asigno nota // preguntamos: existe pila o no if (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 procedimiento voidaprob_desap(nodo *&p)// recorrer la pila { marco(); nodo *aux;// crear var puntero para obtener copia aux=new nodo;// su espacio de memoria aux=p; //hacer copia de p en aux while(aux!=NULL)//recorre la lista mientras no este al final de ultimo nodo { if(aux->nota >10)// ingrese a dato de cada nodo {ap++;//aprob++; notas[ap]=aux->nota;//copia nota en vector } 338 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 else {de++;//desap++; notasde[de]=aux->nota; } aux=aux->sgte;// pasar al nuevo nodo } //fin del while gotoxy(13,n+10);cout<<”Total Aprobados: “< “<nota; aux=aux->sgte; //paso a siguiente nodo } getch(); } voidbuscar_nota(nodo *&p)// procedimiento para buscar { intnotas,nn=0; marco(); nodo *aux;// para obtener copia aux=new nodo;// su espacio de memoria aux=p; //hacer copia de p en aux gotoxy(13,15);cout<<”Ingrese Nota a Buscar = “;cin>>notas; while(aux!=NULL)//recorre la lista {if(aux->nota==notas) { nn++; } 339 Teodoro Luciano Córdova Neri aux=aux->sgte;// pasar al nuevo nodo } //fin del while gotoxy(13,16);cout<<”Total de Notas Encontradas = “< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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[“<>nota; 341 Teodoro Luciano Córdova Neri r = crear_nodo(nota); // r recibe la dirección de la función if (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 aux intap=0,de=0,notas[100],notasde[100],i; while(aux!=NULL)//recorre la lista mientras no esté al final de ultimo nodo { if(aux->nota >10)// ingrese a dato de cada nodo { ap++; notas[ap]=aux->nota;//copia nota en vector } else { de++; notasde[de]=aux->nota; } aux=aux->sgte;// pasar al nuevo nodo } //fin del while gotoxy(13,6);cout<<”Total Aprobados: “< Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 while(p!=NULL) { q=p->sgte; while(q!=NULL) { if(q->nota < p->nota) { aux=q->nota; q->nota=p->nota; p->nota=aux; } q=q->sgte; } gotoxy(10,11); cout<< “Notas : “; gotoxy (20+8*i,11); cout<< “ => “ << p->nota; p=p->sgte; i++; } free(q); free(p); return; } voidOrdenarDescend(nodo *p) { caratulmarco(); nodo *q;intaux,i=0; q = new nodo; q=p; gotoxy(20,5);cout<<” Reporte de Notas”; gotoxy(4,6); cout<<”__________________________________________________” ; gotoxy(10,9);cout<<” Notas ordenadas de forma Descendente “; while(p!=NULL) { q=p->sgte; while(q!=NULL) { if(q->nota > p->nota) {aux=q->nota;q->nota=p->nota; p->nota=aux; } q=q->sgte; } gotoxy(10,11); cout<< “Notas : “; gotoxy (20+8*i,11); cout<< “ => “ << p->nota; p=p->sgte; i++; } free(q); free(p); return; } void Eliminar(nodo *p) { caratulmarco();int dato; nodo *q; gotoxy(20,5);cout<<” Modulo de Eliminacion “; gotoxy(15,6); cout<<”__________________________________________________” ; gotoxy(10,11);cout<<” Ingrese Nota a eliminar = “;cin>>dato; q = new nodo; q=p; 343 Teodoro Luciano Córdova Neri 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 “<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++; 344 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 if(p->nota==dato) {gotoxy(10,12);cout<<” La Nota se encuentra en la posición : “<sgte; } gotoxy(10,12);cout<<” La Nota no existe”; getche(); return; } voidMostrarLista(nodo *p) { caratulmarco(); int i; gotoxy(20,5);cout<<” PILA(LIFO) FORMADA “; gotoxy(10,6);cout<<”________________________________________” ; while(p!=NULL) { gotoxy(12,11); cout<< “ Pila : “; gotoxy (20+8*i,11); cout<< “ => “ << p->nota; p=p->sgte; i++; } return; } void main() { nodo *lista; bool log=true; caratula(); caratulmarco(); do{caratulmarco(); switch(Menu(lista)) { case 1: clrscr();//caratula(); crea_lista(lista); getche();clrscr(); break; case 2: clrscr();caratulmarco();aprob_desap(lista);getche();clrscr(); break; case 3:clrscr();caratulmarco();OrdenarAscend(lista);getche();clrscr(); break; case 4: clrscr();caratulmarco();;OrdenarDescend(lista); getche();clrscr(); break; case 5: clrscr();caratulmarco();Eliminar(lista); getche();clrscr(); break; case 6: clrscr();caratulmarco();BuscarXPos(lista); getche();clrscr(); break; case 7: clrscr();caratulmarco();BuscarXVal(lista); getche();clrscr(); break; case 8: clrscr();caratulmarco();MostrarLista(lista);getche();clrscr(); 345 Teodoro Luciano Córdova Neri 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.cpp struct ALUM { char alum_pri_nomb[12]; float prom;int cred; } alumnos; FILE *falumnos; void crea_alumnos() {int l,i=0,j; char resp=’S’,cod[12];clrscr(); gotoxy(10,2); cout<<”....CreandoArchivo ALUMNOS.txt.”; gotoxy(10,4); 346 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 cout<<” Nombre Promedio Creditos “; gotoxy(5,5); cout<<”_______________ ____________”; while(resp==’S’||resp==’s’) {i++; falumnos=fopen(“ALUMNOS. txt”,”a+”); if(falumnos == NULL) { f a l u m n o s = f o p e n ( “A L U M N O S . txt”,”a+”);} gotoxy(12,5+i);gets(cod) ;fread(&al umnos,sizeof(alumnos),1,falumnos); while(!feof(falumnos)) {if(strcmpi(alumnos.alum_pri_ nomb,cod)==0) { gotoxy(26,16); fclose(falumnos); cout<<” Nombre ya existe..!!!” ; getche();return; } fread(&alumnos,sizeof(alumnos),1,falumnos); } strcpy(alumnos.alum_pri_nomb,cod); do{ gotoxy(26,5+i);clreol();cin>>alumnos.prom; }while(alumnos.prom<0 || alumnos.prom>20); gotoxy(45,5+i);cin>>alumnos.cred; gotoxy(4,16);cprintf(“Desea ingresar nuevo alumnos..?==> “);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.cpp struct ALUM {char nomb[12]; float prom; int cred; }f1; typedef struct pila_trabajadores { float prom; char nombres[20]; int cred; 347 Teodoro Luciano Córdova Neri struct pila_trabajadores *sigte; }nodo; //crear una funcion que “jale” registros del Archivo externo nodo *cargar_Al(char nombres[20],float prom,int creditos) { nodo *aux;aux=new nodo; strcpy(aux->nombres,nombres); aux->prom=prom; aux->cred=creditos; aux->sigte=NULL; return(aux); } void main() { FILE *ftrabajador; char resp; Do {clrscr(); system(“title programa--- pila_jala_arch_Alumn.cpp “); struct ALUM f1; int tot_reg,i=0; nodo *aux; ftrabajador=fopen(“ALUMNOS.txt”,”r+”); fread(&f1,sizeof(f1),1,ftrabajador); while(!feof(ftrabajador)) { i++; fread(&f1,sizeof(f1),1,ftrabajador); } fclose(ftrabajador); i= i-1; tot_reg=i; i=0; ftrabajador=fopen(“ALUMNOS.txt”,”r+”); gotoxy(7,2);cout<<”Cargando data del Archivo “ “ALUMNOS.TXT” “ Espere.......”; gotoxy(9,4); cout<<” # “<nombres<prom<cred; aux=aux->sigte; } gotoxy(10,15); cout<<”Total de registros = “<” ;cin>>resp; } while(resp==’S’ ||resp==’s’); } 348 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 archivos 2. Programa 2. Usa archivos + pilas (LIFO) Se entiende que los campos claves no deben repetirse en las tablas, luego realice las siguientes consultas usando las 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 349 Teodoro Luciano Córdova Neri clico (hasta 3), luego puedepasar al segundo año y repite lo mismo del primer ciclo. Ejemplo: Códigos 100 200 Ciclos Promedio 2005-1 12.3 2005-2 11.4 2005-3 15.8 Ciclos Promedio 2005-1 11 2005-2 11.4 2005-3 12 Ciclos Promedio 2006-1 5.5 2006-2 12.5 2006-3 6.7 Ciclos Promedio 2006-1 4.4 2006-2 12.2 2006-3 11.3 Ciclos Promedio 2007-1 10.2 2007-2 3.4 2007-3 11.2 Ciclos Promedio 2007-1 12.4 2007-2 17.5 2007-3 11.5 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: 350 LISTADO GENERAL DE NOTAS -----------------------------------------------------------------Código Notas Condición ------------------------------------------------------------------cod01 17 Aprobado cod02 08 Desaprobado cod03 14 Aprobado . . Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 . cod45 cod15 . 06 06 Desaprobado 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. DOCENTE DIARIO CODDOC 5C NOMDOC 30C CATEGORIA int. D001 D002 D003 Luis Vera Ana García Juan Lopez CURSO CODDOC CODCUR HORAS FECHA 1 3 2 D001 D001 D002 D002 D003 D003 C001 C004 C003 C001 C005 C003 5C 5C DOUBLE 10C 4 5 3 4 3 2 11/10/10 15/10/10 17/11/10 21/11/10 23/11/10 25/11/10 CODCUR5C NOMCUR 15C C001 C002 C003 C004 Matemática I Análisis II Fisca I Química Luego mostrar resultados de acuerdo al siguiente formulario: 351 Teodoro Luciano Córdova Neri RECORD DE HORAS DICTADAS Có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 Total horas Total pago xxxxxxxxxxx “ => 999,999. => 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 Cód_al Apellidos CURSOS.DAT Nombres Cod._cur. Descripción Área acad. 100 Salas Juan 124 Matemáticas Básicas 200 Solís Pedro 760 Compiladores Sistemas 300 Céspedes María 195 Numéricos Básicas 400 Carrasco Noemí 511 Costos Gestión Código 100 200 300 400 100 Cod._cur. 124 760 124 124 760 N1 14 13 11 10 08 N2 11 14 11 10 10 N3 10 05 14 13 14 pp ¿? NOTAS_ALUMNOS.DAT Se pide: a. 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. 352 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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. 353 Teodoro Luciano Córdova Neri 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. 354 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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. 355 Teodoro Luciano Córdova Neri Interface de validación de usuario: Usar las interfaces del problema 2 del capítulo VII de Archivo 356 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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... 357 Teodoro Luciano Córdova Neri 358 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 Índice temático Anidamiento de registros..............................................................276 ANSI C.............................................................................................. XV Argumento.......................................................................................225 Arrays bidimensionales.................................................................149 Arreglos unidimensionales............................................................191 Cadenas de caracteres....................................................................199 Cin.getline........................................................................201, 216, 218 Conversión a mayúscula y minúscula.........................................215 Colas (FIFO).....................................................................................351 Estructura repetitiva.............................................................29, 37, 44 Estructura selectivas condicionales................................................16 Estructura selectiva compuesta.......................................................18 Funciones.........................................................................................221 Funciones para invertir cadenas...................................................214 Funciones para la comparación de cadenas................................210 Identificadores.....................................................................................4 Inclusión de una cadena en otra...................................................215 Lenguaje de programación procedural...............................................XV Lenguaje orientado a objetos.......................................................... XV Lenguajes de máquina.........................................................................3 Operaciones con vectores...............................................................126 Parámetro.................................................................................225, 227 Programación dinámica (punteros)..............................................327 Recursividad directa e indirecta...................................................259 Registros...........................................................................................273 Rewind..............................................................................................314 Tipos de datos......................................................................................5 Transformación de cadenas...........................................................213 Variables locales y globales............................................................226 359 Teodoro Luciano Córdova Neri 360 Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 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 361 Teodoro Luciano Córdova Neri 362

Lenguaje_de_programacion_Borland

Recommend Documents