You are on page 1of 102

Programación I

Relación de Ejercicios y Soluciones
UNIVERSIDAD DE MÁLAGA Dpto. Lenguajes y CC. Computación E.T.S.I. Telecomunicación

Sonido e Imagen

Índice
Tema 2: Conceptos Básicos de Programación Tema 3: Diseño Descendente. Subprogramas Tema 4: Tipos de Datos Estructurados Tema 5: Búsqueda y Ordenación 1 26 39 94

Este obra está bajo una licencia Reconocimiento-NoComercial-CompartirIgual 3.0 Unported de Creative Commons: No se permite un uso comercial de la obra original ni de las posibles obras derivadas, la distribución de las cuales se debe hacer con una licencia igual a la que regula la obra original. Para ver una copia de esta licencia, visite http://creativecommons.org/licenses/by-nc-sa/3.0/deed.es_ES o envie una carta a Creative Commons, 171 Second Street, Suite 300, San Francisco, California 94105, USA. Nota: en la solución a los ejercicios, se ha utilizado el tipo array de TR1, que ha sido incorporado a la biblioteca de C++ en el estándar de 2011. Si su biblioteca estándar no contiene la definición del tipo array, puede descargarla desde la siguiente dirección: http://www.lcc.uma.es/%7Evicente/docencia/cpplibs/array_tr1.zip

Tema 2: Conceptos Básicos de Programación
1. El siguiente programa escrito en C++ calcula la cantidad bruta y neta a pagar por un trabajo realizado en función de las horas y días trabajados. Contiene errores, encuéntrelos y corríjalos.
# include < iostream > using namespace std ; const tasa : 25.0; const PRECIO_HORA = 60.0; int main () { double horas , dias , total , neto ; cout < < " Introduzca las horas trabajadas : " ; cin < < horas ; cout < < " Introduzca los dias trabajados : " ; cin > > dias ; horas * dias * PRECIO_HORA = total ; neto = total - TASA ; cout > > " El valor total a pagar es : " > > total > > endl ; cout < < " El valor neto a pagar es : " < < NETO < < endl ; }

1

§

Solución

¦

# include < iostream > using namespace std ; //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const double TASA = 25.0; const double PRECIO_HORA = 60.0; //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { double horas , dias , total , neto ; cout < < " Introduzca las horas trabajadas : " ; cin > > horas ; cout < < " Introduzca los dias trabajados : " ; cin > > dias ; total = horas * dias * PRECIO_HORA ; neto = total - TASA ; cout < < " El valor total a pagar es : " < < total < < endl ; cout < < " El valor neto a pagar es : " < < neto < < endl ; }

¤

¥

2. Desarrolle un programa que lea dos números de tipo int de teclado y posteriormente los escriba en pantalla. Ejecútelo introduciendo dos números de tipo int válidos (por ejemplo 1234 y 5678). Posteriormente ejecútelo introduciendo por teclado un primer número de tipo int (por ejemplo 1234) e introduciendo por teclado un segundo dato que no pertenezca al tipo int (por ejemplo hola). Finalmente ejecútelo introduciendo por teclado un primer dato que no pertenezca al tipo int (por ejemplo hola). Evalúe las diferencias entre ambas ejecuciones del mismo programa. § Solución ¤

¦

# include < iostream > using namespace std ; int main () { int dato1 , dato2 ; cout < < " Introduzca un número entero : " ; cin > > dato1 ; cout < < " Introduzca otro número entero : " ; cin > > dato2 ; cout < < " El valor del primer número introducido es : " < < dato1 < < endl ; cout < < " El valor del segundo número introducido es : " < < dato2 < < endl ; } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // Cuando s e i n t r o d u c e por t e c l a d o un v a l o r adecuado a l t i p o de l a // v a r i a b l e que s e e s t á l e y e n d o , l a l e c t u r a s e hace c o r r e c t a m e n t e . // Sin embargo , s i s e i n t r o d u c e por t e c l a d o un v a l o r NO adecuado a l // t i p o de l a v a r i a b l e que s e e s t á l e y e n d o , e n t o n c e s l a o p e r a c i ó n de // l e c t u r a f a l l a , l a v a r i a b l e mantiene e l v a l o r que t u v i e s e // a n t e r i o r m e n t e ( en e s t e c a s o como l a v a r i a b l e no ha s i d o // i n i c i a l i z a d a , t e n d r á un v a l o r INESPECIFICADO) , y e l f l u j o de // e n t r a d a (CIN) s e pondrá en modo erróneo , por l o que c u a l q u i e r o t r a // o p e r a c i ó n de e n t r a d a que s e r e a l i c e p o s t e r i o r m e n t e también f a l l a r á .

¥

3. Desarrolle un programa que sólo declare variables de tipo int. El programa deberá leer dos números enteros desde el teclado, posteriormente los sumará, almacenando el resultado en una variable, y finalmente escribirá por pantalla el resultado de la suma. Ejecute dicho programa introduciendo como datos de entrada los siguientes números y analice los resultados obtenidos.
a ) -20 y 30. b ) 20 y -30. c ) 147483647 y 2000000000. d ) 200000000 y 2000000000. e ) 1 y 2147483647. f ) 1 y 3000000000.

§

Solución

# include < iostream > using namespace std ; int main () {

¤

2

¦

} //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // El t i p o INT s e r e p r e s e n t a con 32 b i t s en l a s máquinas a c t u a l e s , por // l o que e l menor número que puede r e p r e s e n t a r e s e l − 2147483648 // ( − 2^31) y e l mayor número que puede r e p r e s e n t a r e s 2147483647 // (2^31 − 1). Por l o t a n t o en l o s p r i m e r o s c a s o s , t a n t o l o s números // l e í d o s como e l r e s u l t a d o de l a o p e r a c i ó n pueden s e r r e p r e s e n t a d o s // por e l t i p o INT , s i n embargo en e l c u a r t o y q u i n t o c a s o s e l // r e s u l t a d o de l a o p e r a c i ó n (2200000000 y 2147483648) no puede s e r // r e p r e s e n t a d o , y en e l s e x t o caso , i n c l u s o e l segundo número l e í d o // (3000000000) tampoco puede s e r r e p r e s e n t a d o por e l t i p o INT .

int dato_1 , dato_2 ; cout < < " Introduzca el primer número entero : " ; cin > > dato_1 ; cout < < " Introduzca el segundo número entero : " ; cin > > dato_2 ; int suma = dato_1 + dato_2 ; cout < < " El valor resultado es : " < < suma < < endl ;

¥

4. Codifique el siguiente programa, ejecútelo y analice el resultado obtenido.
# include < iostream > using namespace std ; int main () { bool ok = (3.0 * (0.1 / 3.0)) = = ((3.0 * 0.1) / 3.0); cout < < " Resultado de (3.0 * (0.1 / 3.0)) == ((3.0 * 0.1) / 3.0): " < < boolalpha < < ok < < endl ; }

§

Solución

¦

# include < iostream > using namespace std ; int main () { bool ok = (3.0 * (0.1 / 3.0)) = = ((3.0 * 0.1) / 3.0); cout < < " Resultado de (3.0 * (0.1 / 3.0)) == ((3.0 * 0.1) / 3.0): " < < boolalpha < < ok < < endl ; } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // El t i p o DOUBLE u t i l i z a una r e p r e s e n t a c i ó n INEXACTA y FINITA , por l o // que s e p r o d u c e p é r d i d a de p r e c i s i ó n en l a s o p e r a c i o n e s de coma // f l o t a n t e , de t a l forma que p o d r í a s u c e d e r que dos v a l o r e s que // matemáticamente son i g u a l e s sean c o m p u t a c i o n a l m e n t e l i g e r a m e n t e // d i f e r e n t e s ( un v a l o r d e c i m a l muy pequeño ) y por l o t a n t o l a // comparación de i g u a l d a d (==) e n t r e números r e a l e s no p r o d u z c a // l o s r e s u l t a d o s e s p e r a d o s . Por l o t a n t o , l o s números r e a l e s nunca s e // d e b e r í a n d e b e r í a n comparar por i g u a l d a d , s i n o mediante una // o p e r a c i ó n s i m i l a r a : ( a b s ( x−y ) < 1e − 9) , que s i m p l e m e n t e comprueba // s i dos números r e a l e s e s t á n l o s s u f i c i e n t e m e n t e c e r c a n o s . // // En e s t e e j e m p l o c o n c r e t o , e l r e s u l t a d o matemático d e b e r í a s e r TRUE, // p e r o a l r e a l i z a r s e en e l ordenador , donde e l número de d í g i t o s d e c i m a l e s // e s l i m i t a d o , l a o p e r a c i ó n 0 . 1 /3 . 0 p r o d u c e como r e s u l t a d o 0 . 0 3 3 3 3 3 p e r i ó d i c o // que a l m u l t i p l i c a r s e por 3 . 0 da como r e s u l t a d o de l a primera s u b e x p r e s i ó n // 0 . 0 9 9 9 9 9 p e r i ó d i c o , m i e n t r a s que en l a segunda s u b e x p r e s i ó n , 3 . 0 ∗ 0 . 1 da // como r e s u l t a d o 0 . 3 , que a l d i v i d i r s e e n t r e 3 . 0 e l r e s u l t a d o f i n a l e s 0 . 1 , // que e s d i f e r e n t e de 0 . 0 9 9 9 9 9 p e r i ó d i c o , por l o que e l r e s u l t a d o de l a // comparación f i n a l e s FALSE

¤

¥

5. Desarrolle un programa que declare tres variables de tipo double (a, b y c). El programa deberá leer tres números reales desde el teclado, y posteriormente escribirá true si el resultado de multiplicar los dos primeros números es igual al tercero (a * b == c), y escribirá false en caso contrario. Ejecute dicho programa introduciendo como datos de entrada los siguientes números y analice los resultados obtenidos. Los siguientes resultados han sido realizados en una máquina de 32 bits, en una máquina de 64 bits, el resultado de la última ejecución es true (en vez de false como aparece en el enunciado).

3

a: 1, b: 1, c: 1 ⇒ true a: 2, b: 2, c: 4 ⇒ true a: 3, b: 3, c: 9 ⇒ true

a: 3, b: 0.1, c: 0.3 ⇒ false a: 2, b: 0.2, c: 0.4 ⇒ true a: 3, b: 0.3, c: 0.9 ⇒ false

a: 0.1, b: 0.1, c: 0.01 ⇒ false a: 0.2, b: 0.2, c: 0.04 ⇒ false a: 0.3, b: 0.3, c: 0.09 ⇒ false

§

Solución

¦

# include < iostream > using namespace std ; int main () { double a , b , c ; cout < < " Introduce 3 números reales : " ; cin > > a > > b > > c ; bool cmp = ( a * b = = c ); cout < < a < < " * " < < b < < " == " < < c < < " " < < boolalpha < < cmp < < endl ; } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // El t i p o DOUBLE u t i l i z a una r e p r e s e n t a c i ó n INEXACTA y FINITA , por l o // que s e p r o d u c e p é r d i d a de p r e c i s i ó n en l a s o p e r a c i o n e s de coma // f l o t a n t e , de t a l forma que p o d r í a s u c e d e r que dos v a l o r e s que // matemáticamente son i g u a l e s sean c o m p u t a c i o n a l m e n t e l i g e r a m e n t e // d i f e r e n t e s ( un v a l o r d e c i m a l muy pequeño ) y por l o t a n t o l a // comparación de i g u a l d a d (==) e n t r e números r e a l e s no p r o d u z c a // l o s r e s u l t a d o s e s p e r a d o s . Por l o t a n t o , l o s números r e a l e s nunca s e // d e b e r í a n d e b e r í a n comparar por i g u a l d a d , s i n o mediante una // o p e r a c i ó n s i m i l a r a : a b s ( x−y ) < 1e −9

¤

¥

6. Desarrolle un programa que lea de teclado dos números enteros y los almacene en dos variables de tipo int. Posteriormente deberá intercambiar los valores almacenados en dichas variables, y finalmente deberá escribir el valor almacenado en cada una de ellas. § Solución ¤

¦

# include < iostream > using namespace std ; int main () { cout < < " Introduzca dos números naturales : " ; int dato1 , dato2 ; cin > > dato1 > > dato2 ; int aux = dato1 ; dato1 = dato2 ; dato2 = aux ; cout < < " Valor almacenado en Dato1 : " < < dato1 < < endl ; cout < < " Valor almacenado en Dato2 : " < < dato2 < < endl ; }

¥

7. Desarrolle un programa que lea de teclado una determinada cantidad de euros, calcule y escriba su equivalente en pesetas, considerando que 1 C son 166.386 pts. § Solución ¤

¦

# include < iostream > using namespace std ; //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const double EUR_PTS = 166.386; //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { cout < < " Introduzca la cantidad de euros : " ; double euros ; cin > > euros ; double pts = euros * EUR_PTS ; cout < < euros < < " euros son " < < pts < < " pts " < < endl ; }

¥

4

8. Desarrolle un programa que calcule y escriba la media aritmética de 3 números enteros leídos de teclado. § Solución ¤

¦

# include < iostream > using namespace std ; //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int N_VALORES = 3; //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { cout < < " Introduzca 3 números enteros : " ; int n1 , n2 , n3 ; cin > > n1 > > n2 > > n3 ; double media = double ( n1 + n2 + n3 ) / double ( N_VALORES ); cout < < " Media " < < media < < endl ; }

¥

9. Desarrolle un programa que lea de teclado un número entero, y escriba true si el número leído es par, y false en caso contrario. § Solución ¤

¦

# include < iostream > using namespace std ; int main () { cout < < " Introduzca un número natural : " ; int dato ; cin > > dato ; bool es_par = ( dato % 2 = = 0 ); cout < < " El número " < < dato < < " es par ? " < < boolalpha < < es_par < < endl ; }

¥

10. Desarrolle un programa que lea de teclado una letra minúscula (supondremos que la entrada de datos es correcta), y escriba la letra mayúscula correspondiente a la letra minúscula leída previamente. § Solución ¤

¦

# include < iostream > using namespace std ; int main () { cout < < " Introduzca una letra minúscula : " ; char l et ra _ mi nu s cu la ; cin > > l et ra _ mi nu s cu la ; char l et ra _ ma yu s cu la = char ( int ( ' A ' ) + ( int ( le t ra _ mi nu s cu la ) - int ( ' a ' )) ); cout < < le t ra _m i nu sc u la < < " -> " < < le tr a _m ay u sc u la < < endl ; }

¥

11. Desarrolle un programa que lea de teclado tres dígitos como caracteres y los almacene en tres variables de tipo char (supondremos que la entrada de datos es correcta), y calcule el valor numérico correpondiente a dichos dígitos leídos y lo almacene en una variable de tipo int. Finalmente mostrará en pantalla el valor calculado. Por ejemplo, si lee los siguientes tres caracteres ’3’, ’4’, y ’5’, deberá calcular el valor numérico correspondiente 345. § Solución ¤

¦

# include < iostream > using namespace std ; int main () { char d1 , d2 , d3 ; cout < < " Introduzca tres dígitos : " ; cin > > d1 > > d2 > > d3 ; int num = ( int ( d1 ) - int ( ' 0 ' )) * 100 + ( int ( d2 ) - int ( ' 0 ' )) * 10 + ( int ( d3 ) - int ( ' 0 ' )); cout < < " valor númerico : " < < num < < endl ; }

¥

5

12. Desarrolle un programa que lea de teclado un numero entero de tres dígitos y lo almacene en una variable de tipo int (supondremos que la entrada de datos es correcta), y desglose el número leído en los tres dígitos (como caracteres) que lo componen y los almacene en tres variables de tipo char. Finalmente mostrará en pantalla el desglose de los dígitos. Por ejemplo, si lee el número 345, deberá desglosarlo en los siguientes tres caracteres ’3’, ’4’, y ’5’. § Solución ¤

¦

# include < iostream > using namespace std ; int main () { int num ; cout < < " Introduzca un número entero : " ; cin > > num ; char d1 = char ( (( num / 100) % 10) + int ( ' 0 ' ) ); char d2 = char ( (( num / 10) % 10) + int ( ' 0 ' ) ); char d3 = char ( (( num / 1) % 10) + int ( ' 0 ' ) ); cout < < " Digito 1: " < < d1 < < endl ; cout < < " Digito 2: " < < d2 < < endl ; cout < < " Digito 3: " < < d3 < < endl ; }

¥

13. Desarrolle un programa que lea de teclado una cierta cantidad de segundos y muestre su equivalente en semanas, días, horas, minutos y segundos, según el formato de los siguientes ejemplos: 2178585 segundos equivalen a [ 3] semanas, 4 dias, 05:09:45

9127145 segundos equivalen a [ 15] semanas, 0 dias, 15:19:05 § Solución ¤

¦

# include < iostream > # include < iomanip > using namespace std ; //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int SEG_MIN = 60; const int MIN_HORA = 60; const int HORAS_DIA = 24; const int DIAS_SEMANA = 7; //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int SEG_HORA = SEG_MIN * MIN_HORA ; const int SEG_DIA = SEG_HORA * HORAS_DIA ; const int SEG_SEMANA = SEG_DIA * DIAS_SEMANA ; //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { cout < < " Introduzca los segundos : " ; int s e g u n d o s _ t o t a l e s ; cin > > s e g u n d o s _ t o t a l e s ; //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int semanas = s e g u n d o s _ t o t a l e s / SEG_SEMANA ; int resto = s e g u n d o s _ t o t a l e s % SEG_SEMANA ; //−−−−−−−−−−−−− int dias = resto / SEG_DIA ; resto = resto % SEG_DIA ; //−−−−−−−−−−−−− int horas = resto / SEG_HORA ; resto = resto % SEG_HORA ; //−−−−−−−−−−−−− int minutos = resto / SEG_MIN ; int segundos = resto % SEG_MIN ; //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− cout < < s e g u n d o s _ t o t a l e s < < " segundos equivalen a " < < " [ " < < setfill ( ' ' ) < < setw (3) < < semanas < < " ] semanas , " < < dias < < " dias " < < setfill ( ' 0 ' ) < < setw (2) < < horas < < " : " < < setfill ( ' 0 ' ) < < setw (2) < < minutos < < " : " < < setfill ( ' 0 ' ) < < setw (2) < < segundos < < " : " < < endl ; }

¥

6

y posteriormente imprima en pantalla la información desglosada. 8. y false en caso contrario: a ) x ∈ {3. según el siguiente ejemplo para el número 7362: Provincia: 7 Numero de operacion: 36 Digito de control: 2 Correcto: true En caso de que el número tenga exactamente cuatro dígitos. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int provincia = codigo / BASE_PROV . donde cada código consta de cuatro dígitos: El primer dígito representa a una provincia. 7. 7} b ) x ∈ {1. cin > > codigo . 6. int operacion = ( codigo % BASE_PROV ) / BASE_OP . El último dígito es un dígito de control. const int BASE_OP = 10.14. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int LIMITE = 10000. 8. y el dígito de control sea correcto (si su valor coincide con el resto de dividir entre 10 el resultado de multiplicar el número de operación por el código de la provincia). Una empresa maneja códigos numéricos. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−− cout < < " Provincia : " < < provincia < < endl . Por ejemplo. bool correcto = (( codigo > = BASE_PROV ) & & ( codigo < LIMITE ) & & ( control = = ( operacion * provincia % 10 ))). lo almacene en una variable de tipo entero (int). 5. 4. cout < < " Correcto : " < < boolalpha < < correcto < < endl . Los dos siguientes dígitos indican el número de la operación. 7. 9} d ) x ∈ {2. 9} e ) x ∈ {3. 6. 7. const int BASE_PROV = 1000. Se desea obtener un programa que lea de teclado un número de cuatro dígitos (el código de provincia es distinto de cero). //−−−−−−−−−−−−−−−−−−−−−−−−−−−−− } ¤ ¥ Estructuras de Control 15. Codifique un programa que lea de teclado dos números enteros (x e y) y un carácter (c). cout < < " Número de operación : " < < operacion < < endl . y escriba true si cumplen las siguientes propiedades. 3. int control = ( codigo % BASE_PROV ) % BASE_OP . y false en otro caso. 2. 9} c ) x ∈ {1. 8. 4. 3. el apartado Correcto: escribirá true. 7. 6. cout < < " Dígito de control : " < < control < < endl . y ∈ {6. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { cout < < " Introduzca el código numérico de 4 dígitos : " . 5. int codigo . para el número 6257: Provincia: 6 Numero de operacion: 25 Digito de control: 7 Correcto: false § Solución ¦ # include < iostream > using namespace std . 9}. 8. 5. 3} f ) Ni x ni y sean mayores que 10 g ) x no sea múltiplo de y 7 .

6 . } else if ( nota > = 9. bool prop_d = ( x = = 2) | | ( x > = 5 & & x < = 9). 8 . 5 . 7 . cin > > c . char c . 7 .0) & & ( nota < = 10. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− bool prop_a = ( x > = 3 & & x < = 7). cout < < " ( h ) ' " < < c < < " ' es una letra mayuscula : " < < prop_h < < endl . 7 }: " < < prop_a < < endl . 8 . 8 . bool prop_i = ( c > = ' A ' & & c < = ' Z ' ) | | ( c > = ' a ' & & c < = ' z ' ). cout < < " ( g ) " < < x < < " no sea multiplo de " < < y < < " : " < < prop_g < < endl . cout < < " Introduzca dos numeros naturales : " . 2 . cout < < " ( b ) " < < x < < " pertenece a { 1 . 6 . } else if ( nota > = 10. cout < < " Introduzca un caracter : " . bool prop_b = ( x > = 1 & & x < = 3) | | ( x > = 7 & & x < = 9). 5 . " < < y < < " pertenece a { 6 . bool prop_e = (( x > = 3 & & x < = 9 & & x ! = 5 & & x ! = 7) & & (( y > = 6 & & y < = 8) | | y = = 3)). int main () { double nota . cout < < " ( d ) " < < x < < " pertenece a { 2 . 3 . cout < < " ( j ) ' " < < c < < " ' es un alfanumerico : " < < prop_j < < endl . 9 }: " < < prop_d < < endl .0) { 8 . 3 . 4 . } ¥ 16. if ( ! (( nota > = 0.9) { cout < < " Matrícula de Honor " < < endl . 7 . 5 . bool prop_f = ( x < = 10 & & y < = 10). 9 }: " < < prop_b < < endl . 9 } . cin > > nota . bool prop_c = ( x > = 1 & & x < = 9) & & ( x % 2 = = 1). cout < < " ( f ) Ni " < < x < < " ni " < < y < < " sean mayores que 10: " < < prop_f < < endl .0))) { cout < < " Error : 0 <= n <= 10 " < < endl . 6 .0 .1 e . cout < < " Introduzca la Nota : " . y . bool prop_g = ! ( y ! = 0 & & x % y = = 0). 4 . 3 }: " < < prop_e < < endl . cout < < " ( i ) ' " < < c < < " ' es una letra : " < < prop_i < < endl . bool prop_j = (( c > = ' A ' & & c < = ' Z ' ) ||(c >= 'a ' && c <= 'z ') | | ( c > = ' 0 ' & & c < = ' 9 ' )). bool prop_h = ( c > = ' A ' & & c < = ' Z ' ). 9 }: " < < prop_c < < endl . cout < < " ( c ) " < < x < < " pertenece a { 1 .h ) c es una letra mayúscula i ) c es una letra j ) c es un alfanumérico (letra o dígito) § Solución ¤ ¦ # include < iostream > using namespace std . Diseñe un programa que lea de teclado un número real (n) comprendido entre 0 y 10 e imprima la nota asociada según el siguiente esquema: n = 10 9 ≤ n < 10 7≤n<9 5≤n<7 0≤n<5 En otro caso § −→ −→ −→ −→ −→ −→ Matrícula de Honor Sobresaliente Notable Aprobado Suspenso Error ¤ Solución # include < iostream > using namespace std . int main () { int x . cin > > x > > y . cout < < " ( e ) " < < x < < " pertenece a { 3 . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− cout < < boolalpha . 7 . cout < < " ( a ) " < < x < < " pertenece a { 3 . 8 .

} if ( d > mayor ) { mayor = d . cont_2 = aux . 9 .0) { cout < < " Aprobado " < < endl . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const double GASTOS_FIJOS = 1. if ( b > mayor ) { mayor = b . 0. d . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { cout < < " Introduzca los dos últimos valores del contador : " . 0. 0. Diseñe un programa que lea de teclado cuatro números enteros y escriba en pantalla el mayor de los cuatro. cin > > cont_1 > > cont_2 . const double PRECIO_3 = 0. } else { cout < < " Suspenso " < < endl .0.0) { cout < < " Notable " < < endl .35. § Solución ¤ # include < iostream > using namespace std . } cout < < " Mayor : " < < mayor < < endl . } if ( c > mayor ) { mayor = c .cont_1 . } int consumo = cont_2 . const int UMBRAL_2 = 150. const int UMBRAL_1 = 100. c .50. El recibo de la electricidad se elabora de la siguiente forma para una determinada cantidad de Kw consumidos: 1 C de gastos fijos.50 C/Kw para los primeros 100 Kw consumidos. cout < < " Introduzca cuatro números : " . cont_1 = cont_2 . } ¥ 18. const double PRECIO_1 = 0. int mayor = a . if ( cont_1 > cont_2 ) { int aux = cont_1 .25 C/Kw para el resto de Kw consumidos.25. § Solución ¤ ¦ # include < iostream > using namespace std . } else if ( nota > = 5. Elabore un programa que lea de teclado dos números.¦ } cout < < " Sobresaliente " < < endl . const double PRECIO_2 = 0. cont_2 . } else if ( nota > = 7. que representan los dos últimos valores del contador de electricidad (al restarlos obtendremos el consumo en Kw) y calcule e imprima en pantalla el importe total a pagar en función del consumo realizado. int main () { int a . b . int cont_1 . } ¥ 17. cin > > a > > b > > c > > d .35 C/Kw para los siguientes 150 Kw consumidos.

-. cin > > op .= UMBRAL_2 . } else { cout < < " Operando 1: " . if ( resto < = UMBRAL_2 ) { importe + = resto * PRECIO_2 . break . switch ( op ) { case ' + ' : res = op1 + op2 . } else { importe + = UMBRAL_2 * PRECIO_2 . int resto = consumo . Para ello deberá tener las siguientes características: Solo efectuará operaciones con dos operandos (binarias)./). case ' .UMBRAL_1 . int op2 . } ¤ 10 . break . " < < " Importe : " < < importe < < " Eur " < < endl . Operaciones permitidas: (+. Ejemplo: Operacion : * Operando 1 : 24 Operando 2 : 3 Resultado : 72 § Solución # include < iostream > using namespace std . } else { importe + = UMBRAL_1 * PRECIO_1 . Codifique un programa que se comporte como una calculadora simple. } break .¦ } double importe = GASTOS_FIJOS . if ( ! ( op = = ' + ' | | op = = ' . Se trabajará con operandos enteros. break . int op1 . int main () { cout < < " Operación : " . } else { res = 0.*. Si el operador no se corresponde con alguno de los indicados se emitirá un mensaje de error. if ( consumo < = UMBRAL_1 ) { importe + = consumo * PRECIO_1 . cout < < " Error . Leerá en primer lugar la operación a realizar. char op .' | | op = = ' * ' | | op = = ' / ' )) { cout < < " ERROR : Operación no válida " < < endl . importe + = resto * PRECIO_3 .op2 . case ' * ' : res = op1 * op2 . cout < < " Operando 2: " . case ' / ' : if ( op2 ! = 0) { res = op1 / op2 . } } cout < < " Consumo : " < < consumo < < " Kw . ¥ 19. cin > > op1 . resto . y a continuación los dos operandos numéricos. cin > > op2 . int res = 0.' : res = op1 . división por cero " < < endl .

cin > > op . ¥ 20. case ' . } else { res = 0. Calculador repetitivo. Modifique el problema anterior para que se repita un número indefinido de veces.¦ } } cout < < " Resultado : " < < res < < endl . cout < < " Operación : " . cin > > op2 . cout < < " Error . } break . división por cero " < < endl . } } ¤ ¥ 21. int res = 0. cout < < " Operando 2: " . El calculador dejará de trabajar cuando se introduzca como código de operación el símbolo &. Por ejemplo. cin > > op1 . int op1 .' | | op = = ' * ' | | op = = ' / ' )) { cout < < " ERROR : Operación no válida " < < endl . while ( op ! = ' & ' ) { if ( ! ( op = = ' + ' | | op = = ' . } else { cout < < " Operando 1: " . Ejemplo: Operacion : * Operando 1 : 13 Operando 2 : 10 Resultado : 130 Operacion : u ERROR!!!! Operacion : + Operando 1 : 12 Operando 2 : 3 Resultado : 15 Operacion : & FIN DEL PROGRAMA § Solución ¦ # include < iostream > using namespace std . cin > > op . } cout < < " Resultado : " < < res < < endl . escribirá: ***** 11 . int op2 . switch ( op ) { case ' + ' : res = op1 + op2 .op2 . para un número leído con valor 5. case ' / ' : if ( op2 ! = 0) { res = op1 / op2 . break . break .' : res = op1 . Diseñe un programa que lea un número entero de teclado y escriba una línea con tantos asteriscos (*) como indique el número leído. case ' * ' : res = op1 * op2 . } cout < < " Operación : " . int main () { char op . break .

+ + i ) { cout < < SIMBOLO . i < n . cout < < " Introduzca un número : " . para un número leído con valor 5. int main () { int n . const char SIMBOLO = ' * ' . + + i ) { if (( j = = 0) | | ( j = = n . cout < < " Introduzca un número : " . cin > > n . for ( int j = 0. j < n . } else { cout < < " " . i < n .1) | | ( i = = 0) | | ( i = = n . + + j ) { for ( int i = 0. } ¤ 12 . Diseñe un programa que lea un número entero de teclado y escriba un cuadrado (relleno) con tantos asteriscos (*) de lado como indique el número leído. cout < < " Introduzca un número : " . para un número leído con valor 5. j < n . cin > > n . escribirá: ***** * * * * * * ***** § Solución # include < iostream > using namespace std . int main () { int n . for ( int i = 0. + + i ) { cout < < SIMBOLO . escribirá: ***** ***** ***** ***** ***** § Solución ¦ # include < iostream > using namespace std . } cout < < endl .§ Solución ¦ # include < iostream > using namespace std . int main () { int n . const char SIMBOLO = ' * ' . for ( int j = 0.1)) { cout < < SIMBOLO . + + j ) { for ( int i = 0. i < n . Por ejemplo. } cout < < endl . const char SIMBOLO = ' * ' . Diseñe un programa que lea un número entero de teclado y escriba un cuadrado (hueco) con tantos asteriscos (*) de lado como indique el número leído. } ¤ ¥ 22. Por ejemplo. } } ¤ ¥ 23. cin > > n .

} } cout < < endl .1) | | ( i = = 0) | | ( i = = j )) { cout < < SIMBOLO . Por ejemplo. i < = j . para un número leído con valor 5. + + i ) { cout < < SIMBOLO . j < n .¦ } } } cout < < endl . cout < < " Introduzca un número : " . ¥ 24. escribirá: 13 . j < n . para un número leído con valor 5. cout < < " Introduzca un número : " . } } ¤ ¥ 25. Por ejemplo. for ( int j = 0. const char SIMBOLO = ' * ' . escribirá: * ** *** **** ***** § Solución ¦ # include < iostream > using namespace std . const char SIMBOLO = ' * ' . Diseñe un programa que lea un número entero de teclado y escriba un triángulo rectángulo (hueco) con tantos asteriscos (*) de base y altura como indique el número leído. + + j ) { for ( int i = 0. Por ejemplo. int main () { int n . } cout < < endl . int main () { int n . Diseñe un programa que lea un número entero de teclado y escriba un triángulo (relleno) con tantos asteriscos (*) de altura como indique el número leído. + + i ) { if (( j = = 0) | | ( j = = n . i < = j . para un número leído con valor 5. } else { cout < < " " . escribirá: * ** * * * * ***** § Solución ¦ # include < iostream > using namespace std . cin > > n . Diseñe un programa que lea un número entero de teclado y escriba un triángulo rectángulo (relleno) con tantos asteriscos (*) de base y altura como indique el número leído. cin > > n . + + j ) { for ( int i = 0. } } ¤ ¥ 26. for ( int j = 0.

1. cin > > n . } cout < < endl .j . int main () { int n .1) | | ( i = = 0) | | ( i = = 2 * j )) { cout < < SIMBOLO . cout < < " Introduzca un número : " . } for ( int i = 0. cin > > n . + + i ) { if (( j = = 0) | | ( j = = n . Por ejemplo. } } ¤ ¥ 27. escribirá: * * * * * * * ********* § Solución ¦ # include < iostream > using namespace std . } } ¤ ¥ 28. Diseñe un programa que lea un número entero de teclado y escriba un rombo (relleno) con asteriscos (*).1. } for ( int i = 0.* *** ***** ******* ********* § Solución ¦ # include < iostream > using namespace std .j . for ( int j = 0. + + i ) { cout < < SIMBOLO . const char SIMBOLO = ' * ' . } } cout < < endl . for ( int j = 0. + + i ) { cout < < " " . const char SIMBOLO = ' * ' . + + j ) { for ( int i = 0. i < n . j < n . + + j ) { for ( int i = 0. i < n . int main () { int n . i < 2 * j + 1. j < n . Diseñe un programa que lea un número entero de teclado y escriba un triángulo (hueco) con tantos asteriscos (*) de altura como indique el número leído. } else { cout < < " " . para un número leído con valor 5. según el siguiente ejemplo para un número leído con valor 5: * *** ***** ******* ********* ******* 14 . + + i ) { cout < < " " . i < 2 * j + 1. cout < < " Introduzca un número : " .

//−−−−−−−−−−−−−−−−−−−−−−−−−−−−− for ( int j = 0. cout < < " Introduzca un número : " . i < 2 * j + 1. } } ¤ 15 .1. i < 2 * j + 1. + + i ) { if (( j = = 0) | | ( i = = 0) | | ( i = = 2 * j )) { cout < < SIMBOLO . i < n .j .2. i < n . + + j ) { for ( int i = 0. } else { cout < < " " . } cout < < endl . } for ( int i = 0. const char SIMBOLO = ' * ' . + + j ) { for ( int i = 0.1. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−− } ¤ { { { { ¥ 29. + + i ) cout < < SIMBOLO . j < n . + + i ) cout < < " " . int main () { int n . + + i ) cout < < SIMBOLO . según el siguiente ejemplo para un número leído con valor 5: * * * * * * * * * * * * * * * * § Solución # include < iostream > using namespace std .. cin > > n . + + i ) cout < < " " . cout < < " Introduzca un número : " . } cout < < endl .j . j > = 0. . j < n . Diseñe un programa que lea un número entero de teclado y escriba un rombo (hueco) con asteriscos (*). cin > > n .1. } for ( int i = 0. } for ( int i = 0. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−− for ( int j = 0.j . i < n . const char SIMBOLO = ' * ' . int main () { int n .j ) { for ( int i = 0. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−− for ( int j = n .***** *** * § Solución ¦ # include < iostream > using namespace std . + + i ) { cout < < " " . i < 2 * j + 1.

+ + i ) { total = total + m .. + + i ) { total = total * b . int main () { int m . . Diseñe un programa que lea de teclado un número entero (x) y escriba en pantalla el resultado de calcular el factorial de x. teniendo en cuenta que no se permite utilizar la operación de multiplicar (*).1. 16 . cout < < " Introduce un número natural : " . int main () { int x . i < n . n . 4! = 1 × 2 × 3 × 4 § Solución ¤ # include < iostream > using namespace std . } cout < < " Resultado : " < < total < < endl .j ) { for ( int i = 0. Por ejemplo. + + i ) { cout < < " " . cout < < " Introduce dos números naturales : " . } for ( int i = 0. for ( int i = 0. } ¥ 31. Diseñe un programa que lea de teclado dos números enteros y escriba en pantalla el resultado de multiplicar ambos números.j . Por ejemplo. por lo que se deberá realizar mediante sumas sucesivas. int total = 0. } ¥ 32. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−− ¥ 30. 23 = 2 × 2 × 2 § Solución ¤ ¦ # include < iostream > using namespace std . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−− for ( int j = n . e . for ( int i = 0.2. } else { cout < < " " . } cout < < " Resultado : " < < total < < endl . j > = 0. i < 2 * j + 1. + + i ) { if (( j = = 0) | | ( i = = 0) | | ( i = = 2 * j )) { cout < < SIMBOLO . int main () { int b . int total = 1. cout < < " Introduce la base y el exponente : " . cin > > b > > e . cin > > m > > n . } } cout < < endl . mediante multiplicaciones sucesivas. Por ejemplo. Diseñe un programa que lea de teclado dos números enteros (x e y ) y escriba en pantalla el resultado de calcular la potencia de x elevado a y (xy ). i < n .¦ } cout < < endl . 2 × 3 = 2 + 2 + 2 § Solución ¤ ¦ # include < iostream > using namespace std . i < e .

i < = x . int main () { bool es_primo = false .= divisor . } cout < < " El número " < < num < < " es primo : " < < boolalpha < < es_primo < < endl . § Solución ¤ ¦ # include < iostream > using namespace std . while ( resto > = divisor ) { resto . } cout < < " Resultado : " < < total < < endl . 7 ÷ 2 =⇒ 7 − 2 = 5 . + + i ) { total = total * i . divisor . for ( int i = 2. } ¥ 35. y false en caso contrario. int total = 1. int cociente = 0. cin > > num . Diseñe un programa que lea de teclado dos números enteros y escriba en pantalla el cociente y resto de la división de ambos números. } cout < < " Cociente : " < < cociente < < " Resto : " < < resto < < endl .¦ } cin > > x . 5 − 2 = 3 . int main () 17 . } es_primo = ( divisor = = num ). 3 − 2 = 1 =⇒ Cociente = 3 . por lo que se deberá realizar mediante restas sucesivas.’) encontradas. int main () { int dividendo .’). y el número de caracteres leídos. § Solución ¤ # include < iostream > using namespace std . Nota: considere el concepto de búffer de entrada. cout < < " Introduzca un número natural : " . Diseñe un programa que lea un número entero de teclado y escriba true si el número es primo. y que al final muestre como salida el número de comas (’. if ( num > 1) { divisor = 2. Resto = 1 § Solución ¤ ¦ # include < iostream > using namespace std . int num . Por ejemplo. } } ¥ 34. cin > > dividendo > > divisor . teniendo en cuenta que no se permite utilizar las operaciones de división y resto (/. if ( divisor = = 0) { cout < < " El divisor no puede ser cero " < < endl . cout < < " Introduce dividendo y divisor : " . %). + + cociente . ¥ 33. divisor . while (( num % divisor ) ! = 0) { + + divisor . Desarrolle un programa que lea de teclado una secuencia de caracteres (carácter a carácter) hasta leer un punto (’. } else { int resto = dividendo .

Cuenta de comas : " < < cnt_cm < < endl . char act . cout < < " Introduzca N números ( siendo N el primero ): " . ' ) { if ( ant2 = = ' a ' & & ant1 = = ' b ' & & act = = ' c ' ) { ok = true . ' : " . ¥ 36. } ant2 = ant1 . while ( act ! = ' . get ( act ).1. } cout < < " La secuencia ' abc ' " . ' ) { + + cnt_cm . 18 . } ¥ 37. suma + = num . char c . } cout < < " aparece en la frase de entrada " < < endl . for ( int i = 0. } cin . Nota: considere el concepto de búffer de entrada. // c u e n t a de comas cout < < " Introduzca una frase hasta ' .’). int main () { bool ok = false . get ( c ). cout < < " Introduzca una frase hasta ' . cin > > n . } else { int mayor = n . // l e e un c a r á c t e r while ( c ! = ' . cin . el menor y la media aritmética de una colección de N números leídos por el teclado donde N es el primero de los números. + + i ) { int num .{ ¦ } int cnt_ct = 0. } else { cout < < " NO " . § Solución ¤ ¦ # include < iostream > using namespace std . § Solución ¤ # include < iostream > using namespace std . int main () { int n . Desarrolle un programa que determine si la secuencia "abc" aparece en una sucesión de caracteres leídos de teclado cuyo final viene dado por un punto (’. get ( c ). // c u e n t a de c a r a c t e r e s int cnt_cm = 0. char ant1 = ' ' . cin . if ( ok ) { cout < < " SI " . ' ) { + + cnt_ct . int menor = n . cin > > num . // l e e un c a r á c t e r } cout < < " Cuenta de caracteres : " < < cnt_ct < < " . ' : " . if ( c = = ' . get ( act ). i < n . ant1 = act . cin . int suma = n . if ( n = = 0) { cout < < " Error " < < endl . Desarrolle un programa que encuentre el mayor. char ant2 = ' ' .

} ¥ 39. endl . } cout < < " Primera ocurrencia : " < < pri_oc < < endl . ( num < menor ) { = num . si el octavo número de la lista es el único 12. en otro caso. lim_sup . § Solución ¤ ¦ # include < iostream > using namespace std . El objetivo del programa es acertar el número pensado por el usuario. int pri_oc = 0. int main () { int lim_inf . un número como límite superior y piensa un número dentro de ese rango. 19 . if ( lim_inf > lim_sup ) { cout < < " Error : límites errúneos " < < endl . Desarrolle un programa para el siguiente juego: el usuario introduce un número como límite inferior. } ult_oc = pos . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { int pos = 0. entonces el programa terminará satisfactoriamente. ¥ 38. § Solución ¤ # include < iostream > using namespace std . } cin > > n . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int NUMERO = 12. double ( n ). cin > > lim_inf . endl . cin > > lim_sup . si la respuesta es > o < el programa propondrá otro número hasta que finalmente acierte el número pensado por el usuario. Si el número 12 no está en la secuencia. cout < < " Introduzca una secuencia de números terminada en cero (0): " . cout < < " Introduce el límite superior : " . Desarrolle un programa que lea una secuencia de números enteros terminada en 0. y que encuentre y escriba en la pantalla la posición de la primera y de la última ocurrencia del número 12 dentro de la secuencia. el programa debería escribir 0. cout < < " Introduce el límite inferior : " . endl . Para ello el programa propone un número y el usuario responde con >. cin > > n . if ( n = = NUMERO ) { if ( pri_oc = = 0) { pri_oc = pos . Si la respuesta es =. while ( n ! = 0) { + + pos . < o =. int ult_oc = 0. menor o igual respectivamente al numero propuesto por el programa. cout < < " Ultima ocurrencia : " < < ult_oc < < endl .¦ } } } double media = double ( suma ) / cout < < " Mayor : " < < mayor < < cout < < " Menor : " < < menor < < cout < < " Media : " < < media < < if ( num > mayor } else if menor } mayor ) { = num . que significan que el número pensado es mayor. int n . Por ejemplo. entonces 8 sería la primera y la última posición de las ocurrencias de 12.

case ' = ' : break . y a partir de éstos. } else { cout < < " Has introducido datos erróneos " < < endl . cin . for ( int i = 2. const int FIB_1 = 1. cout < < " >> ¿Es el número " < < num < < " ? " . // e l i m i n a ENTER d e l BÚFFER_ENTRADA de pausa int num . } ¥ El Búffer de Entrada y el Búffer de Salida de Datos 41. get ( cod ). break . // e l i m i n a ENTER d e l BÚFFER_ENTRADA de lim_sup cin . } else { int fib_n1 = FIB_0 . } } while (( cod ! = ' = ' ) & & ( lim_inf < = lim_sup )).1. cada número de la secuencia se calcula realizando la suma de los dos anteriores. Codifique el siguiente programa # include < iostream > using namespace std . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int FIB_0 = 0. case ' > ' : lim_inf = num + 1. do { num = ( lim_inf + lim_sup ) / 2. } } ¥ 40. cin > > n . cout < < " Introduzca N : " . 20 .¦ } } else { cout < < " Piense un número dentro del rango [ " < < lim_inf < < " -" < < lim_sup < < " ] y pulse ENTER " . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { int n . § Solución ¤ ¦ # include < iostream > using namespace std . cin > > cod . Los dos primeros números de esta serie son el cero y el uno. i < = n . switch ( cod ) { case ' < ' : lim_sup = num . break . fib_n1 = fib_n . char cod . Desarrolle un programa que lea un número N por teclado y calcule el n-ésimo número de la serie de Fibonacci. if ( n = = 0) { fib_n = FIB_0 . fib_n = fib_n1 + fib_n2 . fib_n = FIB_1 . + + i ) { int fib_n2 = fib_n1 . if ( cod = = ' = ' ) { cout < < " El número pensado es el " < < num < < endl . default : cout < < " Código Erroneo " < < endl . get ( cod ). int fib_n . } } cout < < " Fibonacci ( " < < n < < " ): " < < fib_n < < endl .

e l i m i n á n d o s e // l o s c a r a c t e r e s 1 y 2 d e l b u f f e r ( e l c a r á c t e r [ENTER] permanece en // e l b u f f e r ) // // P o s t e r i o r m e n t e e l programa muestra e l mensaje [ I n t r o d u z c a o t r o // numero : ] e n t o n c e s l a s e n t e n c i a [ c i n >> dato_2 ] a c c e d e a l // BUFFER −DE − ENTRADA para l e e r o t r o d a t o . evalúe las diferencias y relaciónelas con el concepto de búffer de entrada. número 34 y pulse ENTER. e l i m i n á n d o s e l o s c a r a c t e r e s 1 y 2 d e l b u f f e r ( l o s // c a r a c t e r e s [ ESPACIO ] 3 4 [ENTER] permanecen en e l b u f f e r ) // // P o s t e r i o r m e n t e e l programa muestra e l mensaje " I n t r o d u z c a o t r o // numero : " e n t o n c e s l a s e n t e n c i a [ c i n >> dato_2 ] a c c e d e a l // BUFFER −DE − ENTRADA para l e e r o t r o d a t o . posteriormente introduzca el número 34 y pulse ENTER. Como e l b u f f e r e s t á v a c i o . l a l e c t u r a s a l t a l o s espacios/ENTER i n i c i a l e s . compárela con la ejecución anterior. e l i m i n a n d o s e l o s c a r a c t e r e s 3 y // 4 d e l b u f f e r ( e l c a r a c t e r [ENTER] permanece en e l b u f f e r ) // // F in alm en te muestra en p a n t a l l a l o s v a l o r e s de ambas v a r i a b l e s 12 y 34 // //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // SEGUNDA EJECUCIÓN //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // // El programa muestra e l mensaje " I n t r o d u z c a un numero : " e n t o n c e s l a // s e n t e n c i a [ c i n >> dato_1 ] a c c e d e a l BUFFER −DE − ENTRADA para l e e r un // d a t o . por l o que e l programa s e d e s p i e r t a y a s i g n a r á e l v a l o r // numerico 34 a l a v a r i a b l e [ dato_2 ] . y por l o t a n t o . El u s u a r i o t e c l e a 3 4 [ENTER] que s e almacenará nuevamente en // e l b u f f e r . cin > > dato_2 . Como e l b u f f e r NO e s t á // v a c i o . por l o que // e l i m i n a r á e l c a r a c t e r [ENTER] d e l b u f f e r ( quedaba a l l í de l a // l e c t u r a a n t e r i o r ) . compruebe la salida del programa. Como e l b u f f e r e s t á v a c i o . } Ejecútelo introduciendo el número 12 y pulse ENTER. por l o que e l b u f f e r s e queda v a c i o y por l o // t a n t o l a s e n t e n c i a de l e c t u r a e s p e r a r á a que haya a l g ú n d a t o en e l // b u f f e r . por l o que e l // programa s e d e s p i e r t a y a s i g n a r á e l v a l o r numerico 12 a l a v a r i a b l e // [ dato_1 ] . por l o que e l i m i n a r á e l // c a r a c t e r [ ESPACIO ] d e l b u f f e r y a s i g n a r á e l v a l o r numérico 34 a l a // v a r i a b l e [ dato_2 ] ( quedaban en e l b u f f e r de l a l e c t u r a a n t e r i o r ) . cout < < " Los numeros leidos son : " < < dato_1 < < ' ' < < dato_2 < < endl . por l o que e l programa s e d e s p i e r t a y // a s i g n a r á e l v a l o r numerico 12 a l a v a r i a b l e [ dato_1 ] . int dato_1 .int main () { cout < < " Introduzca un numero : " . vuélvalo a ejecutar introduciendo el número 12. Como e l b u f f e r NO e s t á // v a c i o . int dato_2 . // e l i m i n a n d o s e l o s c a r a c t e r e s 3 y 4 d e l b u f f e r ( e l c a r a c t e r [ENTER] // permanece en e l b u f f e r ) // // F in alm en te muestra en p a n t a l l a l o s v a l o r e s de ambas v a r i a b l e s 12 y 34 // //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− ¥ 21 . El u s u a r i o t e c l e a // 1 2 [ESPACIO ] 3 4 [ENTER] que s e almacenará en e l b u f f e r . pulse ESPACIO. d i c h a s e n t e n c i a e s p e r a r á a que // haya a l g ú n d a t o en e l b u f f e r . A continuación. § Solución ¤ ¦ //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // PRIMERA EJECUCIÓN //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // // El programa muestra e l mensaje [ I n t r o d u z c a un numero : ] e n t o n c e s l a // s e n t e n c i a [ c i n >> dato_1 ] a c c e d e a l BUFFER −DE − ENTRADA para l e e r un // d a t o . cout < < " Introduzca otro numero : " . cin > > dato_1 . compruebe la salida del programa. d i c h a s e n t e n c i a e s p e r a r á a que // haya a l g ú n d a t o en e l b u f f e r . l a s e n t e n c i a de l e c t u r a no e s p e r a r á . El u s u a r i o t e c l e a 1 2 [ENTER] que s e // almacenará en e l b u f f e r . l a // l e c t u r a s a l t a l o s espacios/ENTER i n i c i a l e s .

g e t ( c ) . Codifique el siguiente programa # include < iostream > # include < iomanip > using namespace std . cout < < " El numero leido es : " < < num < < endl . Pulse varios espacios. § Solución ¤ //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // NOTA INFORMATIVA: //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // Para s i m p l i f i c a r l a e x p l i c a c i ó n p o s t e r i o r . Pulse varios espacios.42. varios espacios y ENTER. cin . ENTER. el número 9876. el número 9876. int num = 123456. // [$] [9876] [#] [ ok ] // c i n . varios espacios. el número 9876 y ENTER. varios espacios. la letra x. char c = ' # ' . su c o d i g o ASCII : 10 [ 0 x0a ] //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // INSTRUCCIÓN BUFFER NUM C CIN //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // [ __$___9876$ ] [123456] [#] [ ok ] // c i n >> num . Pulse varios espacios. s e u t i l i z a r á e l s í m b o l o // [_] para d e n o t a r e l c a r á c t e r [ ESPACIO ] ( ASCII 3 2 ) . y analice las salidas correspondientes: Pulse varios espacios. cin > > num . la letra w y ENTER. // [] [9876] [$] [ ok ] //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // SEGUNDA EJECUCIÓN //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // $ . g e t ( c ) . } else { cout < < " El separador es : ' " < < c < < " ' " < < endl . if ( c < ' ' ) { cout < < " El separador ( cod ASCII ) es : " < < int ( c ) < < endl . } } Ejecútelo para las siguientes entradas de datos. ENTER. get ( c ). la letra w y ENTER. su c o d i g o ASCII : 32 [ 0 x20 ] //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // INSTRUCCIÓN BUFFER NUM C CIN //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // [__$___9876__$ ] [ 1 2 3 4 5 6 ] [#] [ ok ] // c i n >> num . // [ _$ ] [9876] [_] [ ok ] 22 . y e l s í m b o l o [ $ ] // para d e n o t a r e l c a r á c t e r [ENTER] ( ASCII 10) // //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // PRIMERA EJECUCIÓN //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // $ . int main () { cout < < " Introduzca un numero : " . /t2_ej_04 // I n t r o d u z c a un numero : __$ // ___9876$ // El numero l e i d o e s : 9876 // El c a r a c t e r s e p a r a d o r e s : ' // ' . /t2_ej_04 // I n t r o d u z c a un numero : __$ // ___9876__$ // El numero l e i d o e s : 9876 // El c a r a c t e r s e p a r a d o r e s : ' ' . el número 9876. // [__$] [9876] [#] [ ok ] // c i n .

Desarrolle un programa que lea una palabra de cuatro letras minúsculas y a continuación la escriba en mayúsculas. /t2_ej_04 // I n t r o d u z c a un numero : ___9876w$ // El numero l e i d o e s : 9876 // El c a r a c t e r s e p a r a d o r e s : ' w ' . // [ x9876w$ ] [123456] [#] [ fail ] // c i n . cout < < " La palabra [ " < < l1 < < l2 < < l3 < < l4 < < " ] " < < " transformada es [ " < < n1 < < n2 < < n3 < < n4 < < " ] " < < endl . } ¥ 44. get ( l3 ). // l e e un c a r á c t e r cin . // l e e un c a r á c t e r cin . /t2_ej_04 // I n t r o d u z c a un numero : ___x9876w$ // El numero l e i d o e s : 123456 // El c a r a c t e r s e p a r a d o r e s : ' # ' . y posteriormente escriba dicha palabra de manera que cada letra se encuentre codificada sustituyéndola por aquel carácter que le sigue en la tabla de código ASCII. l4 . Nota: considere el concepto de búffer de entrada. l2 . // [ x9876w$ ] [123456] [#] [ fail ] //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− ¥ 43. get ( l2 ). get ( l1 ). § Solución ¤ ¦ # include < iostream > using namespace std . // s a l t a l o s e s p a c i o s i n i c i a l e s cin . // l e e un c a r á c t e r cin . // l e e un c a r á c t e r cin . Desarrolle un programa que lea una palabra de cuatro letras por teclado. // [ w$ ] [9876] [#] [ ok ] // c i n . char l1 . su c o d i g o ASCII : 119 [ 0 x77 ] //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // INSTRUCCIÓN BUFFER NUM C CIN //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // [ ___9876w$ ] [123456] [#] [ ok ] // c i n >> num . Nota: considere el concepto de búffer de entrada. l3 .¦ //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // TERCERA EJECUCIÓN //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // $ . g e t ( c ) . cin > > ws . cin > > ws . get ( l1 ). // l e e un c a r á c t e r char n1 = char ( l1 + 1). § Solución ¤ # include < iostream > using namespace std . int main () { cout < < " Introduzca una palabra de 4 letras minúsculas : " . char n4 = char ( l4 + 1). int main () { cout < < " Introduzca una palabra de 4 letras : " . l2 . get ( l2 ). char n2 = char ( l2 + 1). // s a l t a l o s e s p a c i o s i n i c i a l e s cin . get ( l4 ). char n3 = char ( l3 + 1). su c o d i g o ASCII : 35 [ 0 x23 ] //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // INSTRUCCIÓN BUFFER NUM C CIN //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // [ ___x9876w$ ] [123456] [#] [ ok ] // c i n >> num . l4 . // l e e un c a r á c t e r 23 . // [$] [9876] [w] [ ok ] //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // CUARTA EJECUCIÓN //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // $ . l3 . g e t ( c ) . char l1 .

} ¥ 47. cin > > ws .' 0 ' ). // s a l t a l o s e s p a c i o s i n i c i a l e s cin . const int UNIDADES = 1. int main () { cout < < " Introduzca 4 dígitos : " .' 0 ' ). 24 . // l e e un c a r á c t e r cin . // l e e un c a r á c t e r cin . int n4 = ( d4 . Nota: considere el concepto de búffer de entrada. int n2 = ( d2 . § Solución ¤ ¦ # include < iostream > using namespace std . cin . cout < < " La palabra [ " < < l1 < < l2 < < l3 < < l4 < < " ] " < < " transformada es [ " < < n1 < < n2 < < n3 < < n4 < < " ] " < < endl . // l e e un c a r á c t e r while ( c ! = ' \ n ' ) { if ( c > = ' a ' & & c < = ' z ' ) { c = char ( ' A ' + ( c . cout < < " El número [ " < < d1 < < d2 < < d3 < < d4 < < " ] " < < " al cuadrado es [ " < < cuadrado < < " ] " < < endl .' 0 ' ). get ( d1 ). get ( d3 ). cin . int main () { cout < < " Introduzca una frase hasta ' ENTER ' : " . } ¥ 46. // l e e un c a r á c t e r int n1 = ( d1 . y posteriormente muestre dicho valor. d3 . § Solución ¤ ¦ # include < iostream > using namespace std . Nota: considere el concepto de búffer de entrada. int n3 = ( d3 . almacene su valor numérico en una variable entero.¦ } cin . d2 .' a ' )).' a ' )). get ( d4 ).' 0 ' ). // l e e un c a r á c t e r char n1 = char ( ' A ' + ( l1 . char n2 = char ( ' A ' + ( l2 . get ( l4 ). int cuadrado = valor * valor . } cout < < c .' a ' )).' a ' )). char c . char n3 = char ( ' A ' + ( l3 . char n4 = char ( ' A ' + ( l4 . get ( d2 ). Desarrolle un programa que lea una secuencia de dígitos (caracteres) hasta que lea algo distinto de dígito. const int DECENAS = 10. get ( l3 ). get ( c ). // l e e un c a r á c t e r } cout < < endl . y posteriormente muestre el resultado de elevar al cuadrado dicho valor. Desarrolle un programa que lea cuatro dígitos (caracteres). Desarrolle un programa que lea una palabra formada por letras minúsculas hasta leer ENTER (’\n’) y a continuación la escriba en mayúsculas. char d1 . get ( c ). // l e e un c a r á c t e r cin . // l e e un c a r á c t e r cin . calcule y almacene su valor numérico en una variable entero. const int CENTENAS = 100. int valor = n1 * U_MILLAR + n2 * CENTENAS + n3 * DECENAS + n4 * UNIDADES . ¥ 45. Nota: considere el concepto de búffer de entrada. const int U_MILLAR = 1000.' a ' )). d4 .

numero = numero * 10 + n . while ( c > = ' 0 ' & & c < = ' 9 ' ) { int n = ( c .§ Solución ¦ # include < iostream > using namespace std . // l e e un c a r á c t e r int numero = 0. char c . get ( c ). cin .' 0 ' ). cin > > ws . cin . } ¤ ¥ 25 . // l e e un c a r á c t e r } cout < < " Valor numérico : " < < numero < < endl . get ( c ). int main () { cout < < " Introduzca un número y pulse ENTER : " .

ya que [ dos ] e s un p r o c e d i m i e n t o . c ) fin = uno(c. bool fin. ∗ /} // Es c o r r e c t a . r e c i b e como primer // parametro por r e f e r e n c i a una v a r i a b l e [ i n t ] . // que no e s adecuada para e l paso por r e f e r e n c i a ( s o l o e s adecuada // una v a r i a b l e para e l paso por r e f e r e n c i a ) .*/} // C u a l e s de l a s s i g u i e n t e s l l a m a d a s a subprogramas en e l // c u e r p o d e l programa p r i n c i p a l son v a l i d a s ? // //−−−−−−−−−−−−−−−−−− // ( a ) i f ( uno ( a . ya que [ uno ] e s una f u n c i ó n que d e v u e l v e [ b o o l ] . . . ya que [ uno ] e s una f u n c i ó n que d e v u e l v e [ b o o l ] .b)) {/*. // por l o que puede s e r u t i l i z a d a en l a a s i g n a c i o n a una v a r i a b l e // de t i p o [ b o o l ] . que no e s adecuado como c o n d i c i o n de l a s e n t e n c i a [ i f ] //−−−−−−−−−−−−−−−−−− 26 . Dadas las siguientes declaraciones en un determinado programa: // – Prototipos –– bool uno (int x.. y como segundo // parametro por v a l o r una e x p r e s i ó n de t i p o [ i n t ] //−−−−−−−−−−−−−−−−−− // ( c ) f i n = uno ( c . . // – Principal –––– int main () { int a. e ) dos(a.. b. ya que [ dos ] e s un p r o c e d i m i e n t o . ya que [ dos ] e s un p r o c e d i m i e n t o . Subprogramas 1. //−−−−−−−−−−−−−−−−−− // ( e ) dos ( a . por l o que d e b e // s e r u t i l i z a d a como s e n t e n c i a i n d e p e n d i e n t e . b + 3 ) . r e c i b e como primer // parametro por r e f e r e n c i a una v a r i a b l e [ i n t ] . y l a l l a m a d a a l a f u n c i o n [ t r e s ] e s c o r r e c t a // p o r q u e s e u t i l i z a su v a l o r [ i n t ] como parametro a l a l l a m a d a a // [ dos ] . // Es c o r r e c t a . y r e c i b e como parametro por v a l o r una v a r i a b l e de t i p o // [ int ] //−−−−−−−−−−−−−−−−−− // ( f ) dos ( t r e s ( b ) .tres(a)). // Es c o r r e c t a . // por l o que puede s e r u t i l i z a d a en l a c o n d i c i o n de l a s e n t e n c i a // [ i f ] . b + 3). ∗ /} // Es erronea .*/} b ) dos(a. y como segundo // parametro por v a l o r e l v a l o r d e v u e l t o por l a f u n c i o n [ t r e s ] que // e s de t i p o [ i n t ] . c.c). ambos de t i p o [ i n t ] //−−−−−−−−−−−−−−−−−− // ( d ) f i n = dos ( c . ya que [ t r e s ] e s una f u n c i o n que d e v u e l v e un v a l o r // [ i n t ] . ya que [ dos ] e s un p r o c e d i m i e n t o .. int y).Tema 3: Diseño Descendente.. } ¿ Cuáles de las siguientes llamadas a subprogramas en el cuerpo del programa principal son válidas ? a ) if (uno(a. § Solución h ) b = tres(dos(a. 5). void dos (int& x. t r e s ( a ) ) . ¤ f ) dos(tres(b). por l o que d e b e // s e r u t i l i z a d a como s e n t e n c i a i n d e p e n d i e n t e .5)). por l o que no puede // s e r u t i l i z a d a en l a a s i g n a c i o n a ninguna v a r i a b l e . int tres (int x). por l o que d e b e // s e r u t i l i z a d a como s e n t e n c i a i n d e p e n d i e n t e . // Es erronea . y r e c i b e como p a r a m e t r o s por v a l o r una v a r i a b l e // y una c o n s t a n t e . p e r o r e c i b e como primer // parametro por r e f e r e n c i a e l v a l o r d e v u e l t o por l a f u n c i o n [ t r e s ] . c). g ) if (tres(a)) {/*. b ) ) {/ ∗ . 5 ) . 5). c ) . // Es erronea . // Es c o r r e c t a . y r e c i b e como p a ra m e t r o s por v a l o r dos v a r i a b l e s [ i n t ] //−−−−−−−−−−−−−−−−−− // ( b ) dos ( a . . d ) fin = dos(c. 5 ) . //−−−−−−−−−−−−−−−−−− // ( g ) i f ( t r e s ( a ) ) {/ ∗ . i ) dos(4. int y).

f < nf . Escribe un programa que imprima una pirámide de dígitos como la de la figura. // Es erronea . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void esc_caracter ( int n . nf ). cout < < endl . que no e s adecuado como a s i g n a c i o n de una v a r i a b l e // [ b o o l ] . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { cout < < " Introduzca numero de filas : " .f .¦ // ( h ) b = t r e s ( dos ( a . cin > > n_filas . // Es erronea . Por ejemplo si N = 5 debería dibujarse: * *** ***** ******* ********* § Solución ¦ # include < iostream > # include < cassert > using namespace std . c ) . esc_triangulo ( n_filas ). tomando como entrada el número de filas de la misma (se supone menor de 10). int n_filas . que no e s // adecuada para e l paso por r e f e r e n c i a ( s o l o e s adecuada una v a r i a b l e // para e l paso por r e f e r e n c i a ) . + + f ) { esc_fila (f . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void esc_fila ( int f . ademas r e c i b e como parametro por v a l o r e l v a l o r d e v u e l t o // por e l p r o c e d i m i e n t o [ dos ] que no d e v u e l v e ningun v a l o r . esc_caracter (2 * f + 1 . ya que [ dos ] e s un p r o c e d i m i e n t o . p e r o r e c i b e como primer // parametro por r e f e r e n c i a una c o n s t a n t e [ i n t ] . 1 121 12321 1234321 123454321 § Solución # include < iostream > ¤ 27 .1 . esc_caracter ( nf . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void esc_triangulo ( int nf ) { for ( int f = 0. ¥ 2. char simb ) { for ( int i = 0. const char SIMBOLO = ' * ' . por l o que d e b e // s e r u t i l i z a d a como s e n t e n c i a i n d e p e n d i e n t e . //−−−−−−−−−−−−−−−−−− // ( i ) dos ( 4 . i < n . ' ' ). } ¤ ¥ 3. 5 ) ) . SIMBOLO ). Escribe un programa que lea un número entero N por teclado y dibuje un triángulo de asteriscos con altura N . + + i ) { cout < < simb . ya que [ t r e s ] e s una f u n c i o n que d e v u e l v e un v a l o r // [ i n t ] . int nf ) { assert ( f < nf ).

i ) { cout < < i . + + f ) { esc_fila (f .... cout < < endl . nf ). ' ' ). + + i ) { cout < < i . i < = n ...... esc_caracter ( nf -f .. int nf ) { assert ( f < = nf ).. } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void e sc _d e sc en d en te ( int n ) { for ( int i = n . 1 232 34543 4567654 567898765 67890109876 7890123210987 890123454321098 90123456765432109 0123456789876543210 123456789010987654321 .. } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { cout < < " Introduzca numero de filas : " . esc_ ascend ente ( f ).. § Solución # include < iostream > # include < cassert > using namespace std . char simb ) { for ( int i = 0. i < n . if ( n_filas < MAX_FILAS ) { esc_triangulo ( n_filas ). } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void esc_triangulo ( int nf ) { for ( int f = 1. + + i ) { cout < < simb . f < = nf .. int n_filas . e sc _d e sc e nd en t e ( f .¦ # include < cassert > using namespace std . } } ¥ 4. cin > > n_filas ... . ¤ 28 ...1). } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void e sc_asc endent e ( int n ) { for ( int i = 1... //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void esc_caracter ( int n . Diseña un programa que lea de teclado un número entero n mayor que cero y muestre las n primeras filas del siguiente triángulo. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int MAX_FILAS = 10. i > = 1. } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void esc_fila ( int f .....

i > = b . nf ). esc_triangulo ( n_filas ). . cout < < endl . § Solución ¤ # include < iostream > # include < cassert > using namespace std . const double LIMITE = 1 e . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { cout < < " Introduzca numero de filas : " . esc_ ascend ente (f . i < = b .1). } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void esc_fila ( int f . cin > > n_filas . ' ' ). f ). } ¥ 5. + + f ) { esc_fila (f . esc_caracter ( nf -f . 2 * f . double res = 1. for ( int i = a . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− 29 . + + i ) { cout < < ( i %10).0001. f < = nf .4. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void esc_triangulo ( int nf ) { for ( int f = 1. int n_filas . int nf ) { assert ( f < = nf ). } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void e sc_asc endent e ( int a . e sc _d e sc e nd en t e (2 * f . int b ) { for ( int i = a . for ( int i = 0. int b ) { assert ( a < = b ).. + + i ) { cout < < simb . } return res . char simb ) { for ( int i = 0. utilizando la serie de Taylor: X2 X3 X4 S =1+X + + + + ··· 2! 3! 4! Nota: No se añadirán más sumandos cuando se calcule uno con valor menor que 0.¦ //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void esc_caracter ( int n . Escribe un programa que calcule el valor de S para un número real X (0 ≤ X ≤ 1) dado por teclado.i ) { cout < < ( i %10). i < n . int exp ) { assert ( base > = 0 & & base < = 1). i < exp . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int L I M I T E _ F A C T O R I A L _ U N S I G N E D = 14.2 . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− double potencia ( double base . + + i ) { res * = base . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void e sc _d e sc en d en te ( int a .

} //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { cout < < " Introduzca el valor de X [0. } else { cout < < " Serie : " < < serie ( x ) < < endl . } return res . } while ( term > = LIMITE ). Valor de X fuera de rango " < < endl . + + i ) { res * = base . return res . int exp ) { assert ( base > = 0 & & base < = 1). //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− double potencia ( double base . if ( ! ( x > = 0 & & x < = 1)) { cout < < " Error . int limite ) { assert ( limite < = L I M I T E _ F A C T O R I A L _ U N S I G N E D ). term = termino (x .1]: " . res + = term . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− double serie ( double x ) { assert ( x > = 0 & & x < = 1). for ( int i = 2. int i = 0. + + i ) { res * = i . i ). double x . for ( int i = inicio .¦ int factorial ( int n ) { assert ( n < L I M I T E _ F A C T O R I A L _ U N S I G N E D ). i < exp . } } ¥ 6. int i ) { return potencia (x . int res = 1. do { ++i. i + = 2) { 30 . } return res . int res = 1. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int producto ( int inicio .. double term . cin > > x . § Solución ¤ # include < iostream > # include < cassert > using namespace std . utilizando la siguiente serie: S=X+ 1·3 X 5 1·3·5 X 7 1 X3 + + + ··· 2 3 2·4 5 2·4·6 7 Nota: No se añadirán más de 10 sumandos. const int MAX_ITER = 10. double res = 1. i < = n . for ( int i = 0. i < limite . i ) / double ( factorial ( i )). Escribe un programa que calcule el valor de S para un número real X (0 ≤ X ≤ 1) dado por teclado. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− double termino ( double x . double res = 1. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int L I M I T E _ F A C T O R I A L _ U N S I G N E D = 14.

i < = n / 2. Diseña un programa que encuentre el primer número perfecto mayor que 28. return i . } } res * = i . cout < < " Serie : " < < s < < endl . Valor de X fuera de rango " < < endl .¦ } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− double termino ( double x . i < MAX_ITER . Por ejemplo. cin > > x . + + i ) { if ( n % i = = 0) { suma + = i . Un número es perfecto si coincide con la suma de sus divisores (salvo él mismo). } assert ( es_perfecto ( i )).. } else { double s = serie ( x ). } return res . double res = x . 28 es perfecto ya que 28 = 1 + 2 + 4 + 7 + 14 § Solución ¤ # include < iostream > # include < cassert > using namespace std . i )) * potencia (x . } return res . for ( int i = 1. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int p ri me r _p e rf ec t o () { int i = PRIMER_NUMERO . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− double serie ( double x ) { assert ( x > = 0 & & x < = 1). 2 * i + 1). i )) / double ( producto (2 . if ( ! ( x > = 0 & & x < = 1)) { cout < < " Error . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline bool es_perfecto ( int n ) { return n = = s uma_di visore s ( n ). //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int PRIMER_NUMERO = 29. ¥ 7. for ( int i = 1. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int suma_d ivisor es ( int n ) { int suma = 0. + + i ) { res + = termino (x . while ( ! es_perfecto ( i )) { ++i. i ) / double ( i )). } } return suma . int i ) { return ( double ( producto (1 . double x . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { cout < < " Introduzca el valor de X [0. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− 31 .1]: " .

for ( int i = n . } } } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { cout < < " Introduzca un intervalo : " . int & m ) { if ( n > m ) { int aux = n . m . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline bool son_amigos ( int a .¦ int main () { cout < < " Primer perfecto mayor que " < < PRIMER_NUMERO < < " : " < < p r im er _ pe rf e ct o () < < endl . } ¥ 8. + + i ) { for ( int j = i + 1. } } return suma . Diseña un programa que tenga como entrada dos números enteros n y m y que muestre en la pantalla todas las parejas de números amigos que existan en el intervalo determinado por n y m. 32 . } ¥ ¤ Otra solución alternativa # include < iostream > # include < cassert > using namespace std . j )) { cout < < " Amigos : " < < i < < " . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void ordenar ( int & n . j < = m . + + j ) { if ( son_amigos (i . int n . m = aux . cin > > n > > m . § Solución ¤ ¦ § # include < iostream > # include < cassert > using namespace std . m ). " < < j < < endl . } assert ( n < = m ). Dos números a y b se dice que son amigos si la suma de los divisores de a (salvo él mismo) coincide con b y viceversa. i < = n / 2. + + i ) { if ( n % i = = 0) { suma + = i . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int suma_d ivisor es ( int n ) { int suma = 0. int m ) { ordenar (n . i mp ri m ir _ am ig o s (n . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void i mp ri m ir _a m ig os ( int n . m ). i < m . n = m. int b ) { return (( a = = suma _divis ores ( b )) & & ( b = = suma_d ivisor es ( a ))). for ( int i = 1. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int suma_d ivisor es ( int n ) { int suma = 0.

cin > > n > > m .¦ } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline bool son_amigos ( int a . int b ) { return (( a = = suma _divis ores ( b )) & & ( b = = suma_d ivisor es ( a ))). assert ( ! ok | | son_amigos (a . § Solución ¤ # include < iostream > using namespace std . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− bool es_primo ( int n ) { int i . m ). ¥ 9. siendo N un número que se introduce por teclado. m = aux . " < < j < < endl . for ( int i = n . int n . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void ordenar ( int & n . n = m. i mp ri m ir _ am ig o s (n . int & m ) { if ( n > m ) { int aux = n . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void i mp ri m ir _a m ig os ( int n . Diseña un programa que calcule e imprima en pantalla los N primeros números primos. m . i < m . + + i ) { // v a c i o } return ( i = = n / 2 + 1). for ( i = 2. if ( amigos & & ( i < j ) & & ( j < m )) { cout < < " Amigos : " < < i < < " . ( i < = n / 2) & & ( n % i ! = 0). numero_amigo (i . int m ) { ordenar (n . int j . i < = n / 2. bool & ok ) { b = su ma_div isores ( a ). j . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void numero_amigo ( int a . ok = ( a = = s uma_di visore s ( b )). int & b . b )). } assert ( n < = m ). m ). + + i ) { bool amigos . } for ( int i = 1. } } return suma . } } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { cout < < " Introduzca un intervalo : " . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void i mp ri m ir _p r im os ( int n ) { int cnt = 0. amigos ). int i = 0. + + i ) { if ( n % i = = 0) { suma + = i . while ( cnt < n ) { 33 .

//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int FIB_0 = 0. " . cout < < " Introduzca N : " .¦ } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { int n . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int FIB_0 = 0. siendo N un número que se introduce por teclado. i mp ri m ir _ pr im o s ( n ). cout < < " Introduzca N : " . i < = n . const int FIB_1 = 1. + + i ) { int fib_n2 = fib_n1 . + + i ) { cout < < fibonacci ( i ) < < " . Diseña un programa que calcule e imprima en pantalla los N primeros términos de la sucesión de Fibonacci. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void i m p r i m i r _ f i b o n a c c i ( int n ) { if ( n > 0) { 34 . } ++i. · · · § Solución ¤ ¦ § # include < iostream > using namespace std . " . cout < < i < < " . 3. fib_n = FIB_1 . 13. fib_n = fib_n1 + fib_n2 . for ( int i = 2. ¥ 10. Ej: 0. 1. } else { int fib_n1 = FIB_0 . } cout < < endl . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int fibonacci ( int n ) { int fib_n . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void i m p r i m i r _ f i b o n a c c i ( int n ) { for ( int i = 0. 8. i < n . const int FIB_1 = 1. 2. i m p r i m i r _ f i b o n a c c i ( n ). cin > > n . if ( n = = 0) { fib_n = FIB_0 . 21. } } return fib_n . } } cout < < endl . } ¥ ¤ Otra solución alternativa # include < iostream > using namespace std . 5. fib_n1 = fib_n . 1. if ( es_primo ( i )) { + + cnt . cin > > n . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { int n .

fib_n1 = fib_n .¦ } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { int n . for ( int i = 2. if ( dig = = 0) { cout < < " Error .1) < < endl . Si i es mayor que el número de dígitos de N . Escriba un programa que tome como entrada desde teclado dos números enteros (mayores que cero) N e i. } return resto % 10. § Solución ¤ ¦ # include < iostream > using namespace std . " . 5 + 8 = 13 35 . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { cout < < " Introduzca número : " . " . cout < < fib_n < < " . for ( int j = 0. cout < < " Introduzca N : " . 4 Para el número : 6582 La salida es : 6 + 2 = 8. i < n . ¥ 11. e imprima en pantalla el dígito que ocupa la posición i-ésima del número N . Por ejemplo : Para el número : 2354869 La salida es: 2 + 9 = 11. int num . ( resto > 0) & & ( j < i ). } cout < < endl . + + i ) { int fib_n2 = fib_n1 . + + j ) { resto / = 10. int i ) { int resto = n . y para i = 6. } } ¥ 12. 5 + 8 = 13. int dig . } cout < < FIB_0 < < " . } if ( n > 1) { cout < < FIB_1 < < " . dígito erróneo " < < endl . int fib_n = FIB_1 . el resultado es 0. cin > > n . 3 + 6 = 9. Por ejemplo. cin > > dig . Escribe un programa que acepte como entrada desde teclado un número entero mayor que cero y dé como salida el resultado de sumar dos a dos los dígitos que aparecen en posiciones simétricas respecto al dígito central dentro del número dado como entrada. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // El í n d i c e d e l primer d í g i t o e s e l c e r o //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int digito ( int n . " . el resultado es el dígito 6. se escribirá en pantalla 0. i m p r i m i r _ f i b o n a c c i ( n ). para N = 25064 e i = 2. fib_n = fib_n1 + fib_n2 . cout < < " Introduzca dígito : " . cin > > num . dig . } else { cout < < " Valor del dígito : " < < digito ( num . } int fib_n1 = FIB_0 .

} ¤ ¥ 13.’). nd . for ( int i = 0. Ejemplos: Para la sucesión de entrada: 001001101. § Solución ¤ # include < iostream > using namespace std . ( resto > 0) & & ( j < i ). int i = 1. + + j ) { resto / = 10.§ Solución ¦ # include < iostream > using namespace std .1). int num . } return i . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− 36 . cout < < di < < " + " < < df < < " = " < < ( di + df ) < < " . i m p r i m i r _ s u m a _ d i g i t o s ( num ). imprimirá 5. int df = digito (n . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { cout < < " Introduzca número : " . } cout < < endl . int i ) { int resto = n . for ( int j = 0. " . i ). } cnt = 0. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int n_digitos ( int n ) { int resto = n . de longitud indeterminada. } if ( nd %2 ! = 0) { cout < < digito (n . } return resto % 10. cin > > num . nd / 2). La sucesión se lee desde el teclado. construir un programa que permita calcular el tamaño de la mayor subsucesión ordenada de menor a mayor. int & mayor ) { if ( cnt > mayor ) { mayor = cnt . + + i ) { int di = digito (n . y el final viene dado por el carácter punto (’. while ( resto > 9) { ++i. char act ) { return ( act < ant ). } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void fin_sec_ord ( int & cnt .i . imprimirá 4. Para la sucesión de entrada: 0100101111. resto / = 10. i < nd / 2. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline bool es_fin_sec ( char ant . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void i m p r i m i r _ s u m a _ d i g i t o s ( int n ) { int nd = n_digitos ( n ). de caracteres ceros y unos. Dada una sucesión. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int digito ( int n .

15 es una montaña de anchura 5. Nota: el cero (0) terminador no forma parte de la secuencia.ah−1 < ah > ah+1 > · · · an Definimos la anchura de una montaña como el número de enteros que la forman. −1.ah−1 > ah < ah+1 < · · · an Por ejemplo 24. char ant = ' 0 ' .. Por ejemplo para la secuencia: 40 35 30 25 20 22 23 34 50 65 21 13 4 0 producirá como mayor montaña 9 y como mayor valle 10. return mayor . mayor ). int act ) { 37 . si existe un h tal que : 1 ≤ h ≤ n y además a1 < . int ant1 .. } + + cnt . char & act ) { ant = act . 15. while ( act ! = ' . ' ) { if ( es_fin_sec ( ant . an de enteros forma una montaña. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { cout < < " Introduzca sucesión de ceros y unos hasta punto : " . } ¥ 14. mayor ). 6..¦ void leer ( char & ant . Dada una secuencia de números enteros terminada en cero (0) y separados por espacios en blanco. 40 35 30 25 20 22 23 34 50 65 21 13 4 0 montaña valle § Solución montaña valle ¤ # include < iostream > using namespace std . diseña un programa que calcule la anchura de la montaña y el valle más largos. act )) { fin_sec_ord ( cnt . Decimos que una sucesión a1 . leer ( ant . 50 sería un valle. act ). que como mínimo contiene una montaña y un valle (suponemos que la secuencia de enteros de entrada es una secuencia correcta de montañas y valles). // v a l o r f i c t i c i o char act = ' 0 ' . } fin_sec_ord ( cnt . int cnt = 0. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline bool es_fin_mont ( int ant2 . cin > > act . a2 .. · · · . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int leer_sucesion () { int mayor = 0. 21. Definimos un valle de la misma forma que una montaña pero cambiando el signo de las desigualdades de la definición anterior: a1 > . int lng = leer_sucesion (). Por ejemplo la sucesión −7. act ). // v a l o r f i c t i c i o leer ( ant . 6. cout < < " Mayor subsucesión ordenada : " < < lng < < endl . 13.

cout < < " Mayor Valle : " < < vm < < endl . ant1 . int & mayor ) { if ( cnt > mayor ) { mayor = cnt . leer ( ant2 . act )) { fin_sec ( mont_cnt . // v a l o r f i c t i c i o leer ( ant2 . int & vall_mayor ) { mont_mayor = 0. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer_sucesion ( int & mont_mayor . leer_sucesion ( mm . act ). int ant1 . vall_mayor ). vall_mayor ). act )) { fin_sec ( vall_cnt . int & ant1 . + + vall_cnt . mont_mayor ). } cnt = 1. while ( act ! = 0) { if ( es_fin_mont ( ant2 . cin > > act . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { cout < < " Introduzca sucesión de enteros hasta cero : " . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline bool es_fin_vall ( int ant2 . cout < < " Mayor Montaña : " < < mm < < endl .¦ return ( ant1 < ant2 ) & & ( ant1 < act ). int mont_cnt = 0. ant1 . mont_mayor ). int mm . } fin_sec ( mont_cnt . act ). vall_mayor = 0. } else if ( es_fin_vall ( ant2 . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void fin_sec ( int & cnt . fin_sec ( vall_cnt . ant1 . int vall_cnt = 0. } ¥ 38 . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer ( int & ant2 . // v a l o r f i c t i c i o int ant1 = 0. ant1 = act . vm ). int act ) { return ( ant1 > ant2 ) & & ( ant1 > act ). int ant2 = 0. // v a l o r f i c t i c i o int act = 0. } + + mont_cnt . vm . ant1 . int & act ) { ant2 = ant1 .

Compárese con la solución del ejercicio 34 de este mismo tema. const Complejo & c2 ) { Complejo res . real ) . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− Complejo multiplicar ( const Complejo & c1 . real ) + sq ( c2 . real * c2 . res . § Solución ¤ # include < iostream > using namespace std . return res . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− struct Complejo { double real . Para realizar operaciones con números complejos. img )) / ( sq ( c2 .c2 . podemos definir el siguiente tipo: struct Complejo { double real. multiplicación y división de números complejos definidos con el tipo anterior. img = c1 . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− bool iguales ( double x . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const double E R RO R _P RE C IS IO N = 1 e . return res .( c1 . img = ( c1 . real = ( c1 . img * c2 . const Complejo & c2 ) { Complejo res . img . real + c2 . res . img * c2 . real .ER R OR _ PR EC I SI ON < = cmp ) & & ( cmp < = E R RO R _P RE C IS IO N ). real = (( c1 . así como el programa para probar adecuadamente su funcionamiento. return res . real * c2 . img * c2 . img ). real = c1 . res .( c1 . real = c1 . real * c2 . res . real . img + c2 .c2 . const Complejo & c2 ) { Complejo res . real ). }. res . img . img )) / ( sq ( c2 . real * c2 . res . img )). img ) + ( c1 . 39 . img = img . double img. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− Complejo restar ( const Complejo & c1 . return res . img )). return ( . res . real ) . double y ) { double cmp = x . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− Complejo sumar ( const Complejo & c1 . img . real ) + sq ( c2 . const Complejo & c2 ) { Complejo res . res .10. res . img = c1 .Tema 4: Tipos de Datos Estructurados 1.y . double img ) { Complejo res . real = real . real ) + ( c1 . img * c2 . Escribe subprogramas que realicen las operaciones de suma. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− Complejo dividir ( const Complejo & c1 . double img . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline double sq ( double x ) { return x * x . }. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− Complejo crear ( double real . real . img = (( c1 . resta. res .

c2 ). cin > > c . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void prueba_suma ( const Complejo & c1 . cout < < endl . cout < < " = " . cout < < " / " . c2 ). restar ( c0 . c2 ). c2 ))) { cout < < " Error en operaciones de suma/resta " < < endl . cout < < " . escribir ( c1 ). c2 .return res . const Complejo & c2 ) { Complejo c0 = multiplicar ( c1 . escribir ( c2 ). real . real < < " . c2 ))) { cout < < " Error en operaciones de mult/div " < < endl . " < < c . if ( distintos ( c1 . cout < < " = " . cout < < endl . escribir ( c2 ). escribir ( c1 ). escribir ( c1 ). escribir ( c0 ). real > > c . c2 . img ). } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline void escribir ( const Complejo & c ) { cout < < " ( " < < c . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void prueba_mult ( const Complejo & c1 . img ): " . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void prueba_resta ( const Complejo & c1 . cout < < " + " ." . cout < < endl . img . 40 . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void prueba_div ( const Complejo & c1 . if ( distintos ( c1 . escribir ( c1 ). } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− bool iguales ( const Complejo & c1 . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− bool distintos ( const Complejo & c1 . escribir ( c2 ). c2 ). const Complejo & c2 ) { Complejo c0 = sumar ( c1 . escribir ( c0 ). sumar ( c0 . real ) & & iguales ( c1 . escribir ( c0 ). const Complejo & c2 ) { return ! iguales ( c1 . const Complejo & c2 ) { Complejo c0 = dividir ( c1 . const Complejo & c2 ) { return iguales ( c1 . c2 ). dividir ( c0 . const Complejo & c2 ) { Complejo c0 = restar ( c1 . cout < < " = " . escribir ( c2 ). c2 ))) { cout < < " Error en operaciones de suma/resta " < < endl . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer ( Complejo & c ) { cout < < " Introduzca un número complejo ( real . img . img < < " ) " . if ( distintos ( c1 . cout < < " * " .

//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− } cout < < " = " . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void escribir ( const Vector & v ) { for ( int i = 0. c2 ).¦ } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { Complejo c1 . c2 ). size ()). size ())) & & ( x ! = v [ i ] )) { ++i. if ( i > = int ( v . using namespace std :: tr1 . ¤ 41 . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int NELMS = 5. int i = buscar (v . escribir ( c0 ). } ¥ 2. int x ) { int i = 0. leer ( c2 ). } return i . c2 ). while (( i < int ( v . x ). size ()) < < " números : " . prueba_div ( c1 . if ( distintos ( c1 . multiplicar ( c0 . i < int ( v . Además. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { Vector v . size ()). //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− prueba_suma ( c1 . typedef array < int . NELMS > Vector . for ( int i = 0. cout < < endl . leer ( v ). leer ( c1 ). int x). c2 ))) { cout < < " Error en operaciones de mult/div " < < endl . cin > > x . Si el elemento no se encuentra en el array. prueba_resta ( c1 . Diseñe una función para buscar la posición que ocupa un elemento dado (x) en un array de enteros. int buscar (const Vector& v. size ())) { cout < < " El elemento " < < x < < " no se encuentra en la lista " < < endl . + + i ) { cin > > v [ i ] . i < int ( v . entonces devolverá un valor fuera del rango válido para ese array. + + i ) { cout < < v [ i ] < < ' ' . int x . c2 ). } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer ( Vector & v ) { cout < < " Introduzca " < < int ( v . § Solución # include < iostream > # include < tr1/array > using namespace std . } cout < < endl . prueba_mult ( c1 . diseñe el programa y los subprogramas necesarios para probar adecuadamente su funcionamiento. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int buscar ( const Vector & v . cout < < " Introduzca elemento a buscar : " . c2 .

} ¤ ¥ 4. cout < < " Lista : " . § Solución # include < iostream > # include < tr1/array > ¤ 42 . § Solución ¦ # include < iostream > # include < tr1/array > using namespace std . int buscar_menor (const Vector& v). for ( int i = pos_menor + 1.¦ } } else { cout < < " El elemento " < < x < < " se encuentra en la posición " < < i < < " en la lista " < < endl . Diseñe una función para buscar la posición del menor elemento de un array de enteros. } cout < < endl . } } return pos_menor . size ()). } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer ( Vector & v ) { cout < < " Introduzca " < < int ( v . i < int ( v . + + i ) { cout < < v [ i ] < < ' ' . + + i ) { cin > > v [ i ] . + + i ) { if ( v [ i ] < v [ pos_menor ] ) { pos_menor = i . leer ( v ). size ()). diseñe el programa y los subprogramas necesarios para probar adecuadamente su funcionamiento. Diseñe una función para buscar el menor elemento de un array de enteros. i < int ( v . Además. } cout < < " Lista : " . int buscar_pos_menor (const Vector& v). ¥ 3. typedef array < int . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int NELMS = 5. escribir ( v ). } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void escribir ( const Vector & v ) { for ( int i = 0. diseñe el programa y los subprogramas necesarios para probar adecuadamente su funcionamiento. escribir ( v ). //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int b u s c a r _ p o s _ m e n o r ( const Vector & v ) { int pos_menor = 0. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { Vector v . cout < < " El menor elemento se encuentra en la posición " < < i < < " en la lista " < < endl . using namespace std :: tr1 . Además. size ()) < < " números : " . for ( int i = 0. size ()). int i = b u s c a r _ p o s _ m e n o r ( v ). i < int ( v . NELMS > Vector .

} } return pos_menor . diseñe el programa y los subprogramas necesarios para probar adecuadamente su funcionamiento. } cout < < endl . typedef array < int . } if ( i + int ( patron . cout < < " Lista : " . ¤ 43 . Diseñe una función para buscar la posición que ocupa un patrón dado en una cadena de caracteres. + + i ) { cin > > v [ i ] . i < int ( v . while (( i + int ( patron . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int buscar ( const string & cadena . int menor = buscar_menor ( v ). size ()) < = int ( cadena . for ( int i = 0.¦ using namespace std . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline int buscar_menor ( const Vector & v ) { int pos_menor = b u s c a r _ p o s _ m e n o r ( v ). //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int NELMS = 5. size ())) & & ( patron ! = cadena . leer ( v ). //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int b u s c a r _ p o s _ m e n o r ( const Vector & v ) { int pos_menor = 0. size ()). } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void escribir ( const Vector & v ) { for ( int i = 0. size ()) > int ( cadena . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer ( Vector & v ) { cout < < " Introduzca " < < int ( v . const string& patron). } return i . NELMS > Vector . i < int ( v . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { Vector v . for ( int i = pos_menor + 1. escribir ( v ). using namespace std :: tr1 . size ()). substr (i . int ( patron . } ¥ 5. Si el patrón no se encuentra en la cadena. const string & patron ) { int i = 0. int buscar (const string& cadena. + + i ) { cout < < v [ i ] < < ' ' . i < int ( v . size ()) < < " números : " . size ())) { i = int ( cadena . return v [ pos_menor ] . size ())))) { ++i. size ()). cout < < " El menor elemento de la lista es " < < menor < < endl . entonces devolverá un valor fuera del rango válido para esa cadena. Además. § Solución # include < iostream > # include < string > using namespace std . size ()). + + i ) { if ( v [ i ] < v [ pos_menor ] ) { pos_menor = i .

} return i . i ) + nuevo . cout < < " Introduzca el nuevo valor : " . size ())) { if ( i + int ( patron . size ())) & & ( patron ! = cadena . substr (i . patron ). while (( i + int ( patron . int ( cadena . 0 . i + int ( nuevo . const string& patron. getline ( cin . if ( i > = int ( cad . size ()). nv ). getline ( cin . getline ( cin . pat ). } ¥ 6. string cad .¦ } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { cout < < " Introduzca una cadena : " . string pat . while ( i < int ( cadena . size ()) > int ( cadena . Diseñe un procedimiento para reemplazar en una cadena todas las ocurrencias de un patrón por otro valor. § Solución # include < iostream > # include < string > using namespace std . int i = buscar ( cad . substr ( i + int ( patron . string nv .( i + int ( patron . getline ( cin . patron ). const string & nuevo ) { int i = buscar ( cadena . const string& nuevo). ¤ 44 . int ini . size ())))) { ++i. } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { cout < < " Introduzca una cadena : " . string pat . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void reemplazar ( string & cadena . const string & patron . const string & patron ) { int i = ini . pat ). i ) + nuevo + cadena . size ()) . pat ). cad ). size ())))). size ()) . string cad . size ()) . cad ). } if ( i + int ( patron . void reemplazar (string& cadena. size ())) { i = int ( cadena . } else { cadena = cadena . size ())) { cout < < " El patrón [ " < < pat < < " ] no se encuentra en la cadena " < < endl . substr (0 . substr (0 . } i = buscar ( cadena . cout < < " Introduzca un patrón a buscar : " . cout < < " Introduzca un patrón a reemplazar : " . } else { cout < < " El patrón [ " < < pat < < " ] se encuentra en la posición " < < i < < " en la cadena " < < endl . size ())) { cadena = ( cadena . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int buscar ( const string & cadena . int ( patron . getline ( cin . size ()) < int ( cadena . } cout < < " Cadena : " < < cad < < endl . size ()) < = int ( cadena . diseñe el programa y los subprogramas necesarios para probar adecuadamente su funcionamiento. Además.

//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int MAX = 20. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− typedef array < int . size ())) & & ( v1 [ i ] = = v2 [ i ] )) { ++i. la función devolvería true. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // IGUALDAD //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− bool iguales ( const Vector & v1 . int i2i ) { assert ( i2i < int ( v2 . 3. size ()). int i1 = 0. + + i1 . while (( i < int ( v . 6. if ( int ( v1 . const Vector& v2). while (( i1 < int ( v1 . bool iguales_relativos (const Vector& v1. nv ). if ( int ( v1 . bool ok = false . MAX > Vector . const Vector & v2 ) { bool ok = false .¦ } reemplazar ( cad . using namespace std :: tr1 . 3 ] § Solución # include < iostream > # include < cassert > # include < tr1/array > using namespace std . a ) Diseña una función booleana que reciba dos arrays de números enteros. const Vector& v2). v1: [ 1. b ) Diseña una función booleana que reciba dos arrays de números enteros. bool iguales (const Vector& v1. size ()) = = int ( v2 . ¥ 7. 9. pat . Diseñe el programa y los subprogramas necesarios para probar adecuadamente el funcionamiento de los siguientes apartados. size ())) { int i2 = i2i . int x ) { int i = 0. size ()) = = int ( v2 . suponiendo que el primer elemento sigue al último. size ())). Por ejemplo. size ())) & & ( v1 [ i1 ] = = v2 [ i2 ] )) { i2 = ( i2 + 1) % int ( v2 . y devuelva true si ambos contienen los mismos elementos y en el mismo orden relativo. y false en otro caso. size ())). } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− bool i g u a l e s _ r e l a t i v o s ( const Vector & v1 . size ())) & & ( x ! = v [ i ] )) { ++i. cout < < " Salida : " < < cad < < endl . } return i . } ok = ( i > = int ( v1 . 9. 6 ] v2: [ 4. Podemos suponer que cada elemento del array aparece a lo sumo una vez. 1. 4. } return ok . si la entrada fuese la siguiente. const Vector & v2 . size ())) { int i = 0. while (( i < int ( v1 . } ¤ 45 . y devuelva true si son iguales y false en otro caso. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // IGUALDAD RELATIVA //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int buscar ( const Vector & v .

do { cout < < " Opcion ? " . for ( int i = 0... i < int ( v . leer ( v1 ). } else { cout < < " Los vectores NO son iguales " < < endl . v2 ." < < endl . cout < < " x : Fin " < < endl . size ())) & & i g u a l e s _ r e l a t i v o s ( v1 . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void c h e c k _ i g u a l d a d _ r e l a t i v a () { Vector v1 . cout < < " . + + i ) { cout < < " ' " < < v [ i ] < < " ' " .. } while ( ! (( op > = ' a ' & & op < = ' b ' ) | | op = = ' x ' )).. size ())) { if ( int ( v1 . 46 . leer ( v2 )... v2 )) { cout < < " Los vectores son iguales " < < endl . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // MENU //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− char menu () { char op . ' \ n ' ). ignore (1000 .. v2 . cout < < " a : Igualdad " < < endl .. size ()))..." < < endl . size ()) < < " números : " . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void escribir ( const Vector & v ) { cout < < " [ " . i < int ( v .. ok = ( i2 < int ( v2 . v2 . cin > > op .. cout < < endl .. } cout < < " ] " < < endl . if ( iguales ( v1 .} //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− bool i g u a l e s _ r e l a t i v o s ( const Vector & v1 .... } return ok .. ok = ( i1 > = int ( v1 .. cout < < " . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void c heck_i gualda d () { Vector v1 ...... size ()). cout < < " b : Iguales Orden Relativo " < < endl . size ())...... } else { int i2 = buscar ( v2 . return op .. const Vector & v2 ) { bool ok = false ... size ()) = = 0) { ok = true . + + i ) { cin > > v [ i ] . } } return ok . cin . v1 [ 0 ] )...... } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // LEER ESCRIBIR //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer ( Vector & v ) { cout < < " Introduzca " < < int ( v . for ( int i = 0. cout < < endl . if ( int ( v1 . i2 ). leer ( v1 ). size ()) = = int ( v2 .

+ + i ) { cout < < v [ i ] < < ' ' . if ( b > res ) { res = b . case ' b ' : c h e c k _ i g u a l d a d _ r e l a t i v a (). Obtenga una función que tomando como parámetro dicho array. + + i ) { cin > > v [ i ] . if ( i g u a l e s _ r e l a t i v o s ( v1 . 47 . } return mayor ( v [ 0 ] . i < int ( v . § Solución ¤ # include < iostream > # include < tr1/array > using namespace std . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer ( Vector & v ) { cout < < " Introduzca " < < int ( v . size ()). Además. break . break .¦ } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { char op . } leer ( v2 ). do { op = menu (). int b ) { int res = a . NELMS > Vector . diseñe el programa y los subprogramas necesarios para probar adecuadamente su funcionamiento. switch ( op ) { case ' a ' : chec k_igua ldad (). for ( int i = 0. while ( v [ 0 ] = = v [ i ] ) { ++i. } else { cout < < " Los vectores NO son iguales relativos " < < endl . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void escribir ( const Vector & v ) { for ( int i = 0. v2 )) { cout < < " Los vectores son iguales relativos " < < endl . using namespace std :: tr1 . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int NELMS = 5. typedef array < int . i < int ( v . } return b . } ¥ 8. } } while ( op ! = ' x ' ). //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int mayor ( int a . size ()) < < " números : " . v [ i ] ). devuelva un elemento del array que sea mayor que el mínimo de éste. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // Busca un e l e m e n t o que s e a mayor que e l mínimo d e l a r r a y // Al menos hay dos e l e m e n t o s i g u a l e s // Al menos hay dos e l e m e n t o s d i s t i n t o s int b u s c a r _ p r o p i e d a d ( const Vector & v ) { int i = 1. size ()). Se dispone de un array de 10 números enteros en el que al menos hay dos números que son iguales y dos que son distintos.

} //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− bool iguales ( const string & s1 . " Julio " . " Octubre " . N_MESES > MesStr . diciembre }.5 .8 . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int N_MESES = 12. } return res . N_MESES > MesOk . noviembre . cout < < " El elemento " < < e < < " es mayor que el mínimo de la lista " < < endl . " Abril " . julio . " Agosto " . int e = b u s c a r _ p r o p i e d a d ( v ). mostrará la siguiente salida: Enero: 12. if ( int ( s1 .8 Mes: Enero Temperatura: 12. typedef array < string . const MesStr MES_STR = {{ " Enero " . " Marzo " . " Junio " . El programa deberá utilizar un tipo enumerado para representar los meses del año y considerar que las temperaturas de los meses se pueden introducir en cualquier orden.. const string & s2 ) { bool res = false . Diseñe un programa que lea por teclado las temperaturas medias de los doce meses del año y calcule la temperatura media anual. typedef array < bool . agosto .5 Febrero: 13. escribir ( v ). //−−−−−−−−− typedef array < double .5 Marzo: 15. size ()) = = int ( s2 . septiembre . Como salida deberá imprimir la temperatura de cada mes y la temperatura media anual.3 § Solución # include < iostream > # include < string > # include < tr1/array > using namespace std . mayo .. " Febrero " . octubre . Por ejemplo. ¥ 9. if ( c > = ' A ' & & c < = ' Z ' ) { res = char ( ' a ' + ( c .. N_MESES > MesTmp . junio . } } cout < < endl . marzo . Temperatura media anual: 17. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline char minuscula ( char c ) { char res = c . " Septiembre " . " Mayo " .¦ } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { Vector v . //−−−−−−−−− enum Mes { enero . cout < < " Lista : " . febrero . leer ( v ). size ())) { ¤ 48 . " Noviembre " .. " Diciembre " }}.' A ' )). using namespace std :: tr1 .5 Mes: Febrero Temperatura: 13. para la siguiente entrada: Mes: Marzo Temperatura: 15. abril .

Introduzca Mes : " . while (( i < int ( s1 . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline void escribir ( Mes m ) { cout < < MES_STR [ int ( m ) ] . la temperatura para ese mes ya existe " < < endl . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer_tmp ( double & tmp ) { cout < < " Temperatura : " . size ())) & & ! iguales (x . str )). i < int ( v . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline void leer ( Mes & m ) { string str . + + i ) { v [ i ] = false . while (( i < int ( v . size ())) & & ( minuscula ( s1 [ i ] ) = = minuscula ( s2 [ i ] ))) { ++i. size ()). } return i . cin > > tmp . leer ( m ). while ( nmes ! = int ( v . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void init ( MesOk & v ) { for ( int i = 0. } return res . size ())) { Mes m . cin > > str . const string & x ) { int i = 0. + + nmes . leer_mes ( m ). init ( mok ). if ( mok [ int ( m ) ] ) { cout < < " Error . MesOk mok . while ( m > diciembre ) { cout < < " Error . leer ( m ). 49 . m = Mes ( buscar ( MES_STR . } } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− double medi a_tmp_ anyo ( const MesTmp & v ) { double suma = 0. v [ i ] )) { ++i. } else { mok [ int ( m ) ] = true . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer_tmp_anyo ( MesTmp & v ) { int nmes = 0. int i = 0. } res = ( i > = int ( s1 . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer_mes ( Mes & m ) { cout < < " Mes : " .} //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int buscar ( const MesStr & v . leer_tmp ( v [ int ( m ) ] ). size ())).

cin > > num . size ()). + + i ) { suma + = v [ i ] . size ())) { + + v [ num ] . 50 . + + i ) { escribir ( Mes ( i )). el 5 y 9 dos veces. i < int ( v . i < int ( v . + + i ) { v [ i ] = 0. size ()). typedef array < int . while ( num > = 0 & & num < int ( v . y la lista está formada por: 6 4 4 1 9 7 5 6 4 2 3 9 5 6 4 el programa mostrará: 0 1 2 3 4 5 6 7 8 9 * * * **** ** *** * ** Esto indica que el 0 y el 8 no aparecen ninguna vez. ¥ 10. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void ini ( Vector & v ) { for ( int i = 0. Por ejemplo. i < int ( v . 2. cout < < " Introduzca números ( hasta negativo ): " . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { MesTmp vt . cout < < " Temperatura media anual : " < < media < < endl . el 1. double media = med ia_tmp _anyo ( vt ). leer_tmp_anyo ( vt ). 3 y 7 aparecen una vez. escr_tmp_anyo ( vt ). Escriba un programa que lea una lista de números comprendidos entre 0 y 9 (la lista acabará cuando se lea un número negativo. } for ( int i = 0. etc. using namespace std :: tr1 . Diseñe un programa que muestra la frecuencia con que aparecen en una lista dada los distintos valores que la pudieran formar. } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer ( Vector & v ) { ini ( v ). size ()). //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int MAX = 10. y a priori no se puede determinar cuantos números contiene) e imprima por pantalla una gráfica como la anterior. § Solución ¤ # include < iostream > # include < tr1/array > using namespace std . } return suma / double ( v . size ()). si los valores de una lista pueden estar comprendidos entre 0 y 9. cout < < " : " < < v [ i ] < < endl . int num .¦ } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void escr_tmp_anyo ( const MesTmp & v ) { for ( int i = 0. MAX > Vector .

size ()). + + i ) { cout < < " * " . cin > > num . i m p r i m i r _ a s t e r i s c o s ( v [ i ] ). Un histograma es una gráfica que muestra la frecuencia con que aparecen en una lista dada los distintos valores que la pudieran formar. cout < < endl . size ()). } } cin > > num . i < n . MAX > Vector . Escriba un programa que lea una lista de números comprendidos entre 0 y 9 (la lista acabará cuando se lea un número negativo. si los valores de una lista pueden estar comprendidos entre 0 y 9. i < int ( v . y a priori no se puede determinar cuantos números contiene) e imprima por pantalla un histograma vertical como el anterior. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void ini ( Vector & v ) { for ( int i = 0. etc. + + i ) { cout < < i < < " " . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { Vector v . § Solución ¤ # include < iostream > # include < tr1/array > using namespace std . 3 y 7 aparecen una vez. y la lista está formada por: 6 4 4 1 9 7 5 6 4 2 3 9 5 6 4 su histograma vertical será: * * * * * * * * * * * * * * * ------------------0 1 2 3 4 5 6 7 8 9 Esto indica que el 0 y el 8 no aparecen ninguna vez.¦ } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void i m p r i m i r _ a s t e r i s c o s ( int n ) { for ( int i = 0. el 1. el 5 y 9 dos veces. int num . i < int ( v . cout < < " Introduzca números ( hasta negativo ): " . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void grafica ( const Vector & v ) { for ( int i = 0. } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer ( Vector & v ) { ini ( v ). leer ( v ). 51 . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int MAX = 10. ¥ 11. using namespace std :: tr1 . typedef array < int . size ())) { + + v [ num ] . grafica ( v ). 2. while ( num > = 0 & & num < int ( v . + + i ) { v [ i ] = 0. Por ejemplo.

} cout < < endl . } } return mayor . f ). } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void i mprimi r_line a ( int n ) { for ( int i = 0. int fila ) { for ( int i = 0. en posiciones 1 10 52 .. . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { Vector v . encuentre el valor máximo y lo imprima junto con el número de veces que aparece. i < n . + + i ) { if ( v [ i ] > mayor ) { mayor = v [ i ] . f > 0. size ()). en posicion 7 52 aparece 1 vez. para la siguiente entrada: 7 10 143 10 52 143 72 10 143 7 producirá la siguiente salida: 143 aparece 3 veces. } impr imir_l inea (2 * int ( v . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void histograma ( const Vector & v ) { int mayor = buscar_mayor ( v ). histograma ( v ). size ()). en posicion 5 10 aparece 3 veces. El proceso se repite con el resto de la sucesión hasta que no quede ningún elemento por tratar. } else { cout < < " " . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void i m p r i m i r _ a s t e r i s c o s ( const Vector & v . } } cin > > num . i < int ( v . en posiciones 2 4 8 7 aparece 2 veces. } cout < < endl . leer ( v ). ¥ 12. y las posiciones en que este ocurre. Por ejemplo. i < n . size ())). + + i ) { if ( v [ i ] > = fila ) { cout < < " * " . for ( int i = 1. } } cout < < endl . i m p r i m i r _ i n d i c e s ( int ( v . Escribe un programa que lea una sucesión de 10 números enteros. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void i m p r i m i r _ i n d i c e s ( int n ) { for ( int i = 0. + + i ) { cout < < i < < " " .¦ } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int buscar_mayor ( const Vector & v ) { int mayor = v [ 0 ] .1). + + i ) { cout < < " -" .f ) { i m p r i m i r _ a s t e r i s c o s (v . en posiciones 3 6 9 72 aparece 1 vez. for ( int f = mayor . size ()) . i < int ( v .

Valido & x . ¤ 53 . size ())) { for ( int i = pos_mayor + 1. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int b u s c a r _ p o s _ m a y o r ( const Vector & v . size ())) & & ( ! x [ i ] )) { ++i. } } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void p rocesa r_mayo r ( const Vector & v . for ( int i = 0. + + i ) { if (( x [ i ] ) & & ( v [ i ] > v [ pos_mayor ] )) { pos_mayor = i . num ). } return i . cout < < num < < " aparece " < < n_veces . i < int ( v . + + i ) { if ( v [ i ] = = num ) { x [ i ] = false . size ()). int num ) { int n_veces = frecuencia (v . size ()). if ( n_veces = = 1) { cout < < " vez . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int MAX = 10. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int frecuencia ( const Vector & v . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void e s c r i b i r _ p o s i c i o n e s ( const Vector & v . i < int ( v . size ()). typedef array < int . + + i ) { if ( v [ i ] = = num ) { cout < < ( i + 1) < < ' ' . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void anular ( const Vector & v . typedef array < bool . const Valido & x ) { int pos_mayor = b u s c a r _ p r i m e r _ v a l i d o ( x ). MAX > Vector .§ Solución # include < iostream > # include < tr1/array > using namespace std . int num ) { for ( int i = 0. } } return cnt . Valido & x . + + i ) { if ( v [ i ] = = num ) { + + cnt . en posición " . + + i ) { x [ i ] = true . } } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int b u s c a r _ p r i m e r _ v a l i d o ( const Valido & x ) { int i = 0. int num ) { for ( int i = 0. while (( i < int ( x . if ( pos_mayor < int ( v . i < int ( x . int num ) { int cnt = 0. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void ini ( Valido & x ) { for ( int i = 0. using namespace std :: tr1 . i < int ( v . size ()). size ()). } } } return pos_mayor . MAX > Valido . i < int ( v .

i = b u s c a r _ p o s _ m a y o r (v . for ( int i = pos_menor + 1. size ()) < < " números : " . x ). size ())) { proc esar_m ayor (v . x . while ( i < int ( v . + + i ) { cin > > v [ i ] . using namespace std :: tr1 . en posiciones " . } } else { cout < < " veces . + + v . El número de elementos de la sucesión puede ser menor que M . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int b u s c a r _ p o s _ m e n o r ( const Vector & v ) { int pos_menor = 0. § Solución ¤ # include < iostream > # include < cassert > # include < tr1/array > using namespace std . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer ( Vector & v ) { cout < < " Introduzca " < < int ( v . }. struct Vector { int nelms . elm [ v . } e s c r i b i r _ p o s i c i o n e s (v . int x ) { if ( v . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int MAX = 10. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void ini ( Vector & v ) { v . x ). ini ( x ). int i = b u s c a r _ p o s _ m a y o r (v . y calcule la media de los M mayores números de la sucesión. siendo M una constante. v [ i ] ). size ())) { v .¦ } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void estadisticas ( const Vector & v ) { Valido x . x . anular (v . nelms = 0. en cuyo caso calculará la media de los números introducidos. num ). nelms . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { Vector v . nelms < int ( v . MAX > Datos . i < int ( v . for ( int i = 0. estadisticas ( v ). Diseñe un programa que lea de teclado una sucesión indefinida de números enteros distintos acabada en 0. Datos elm . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void anyadir ( Vector & v . leer ( v ). + + i ) { 54 . ¥ 13. nelms . elm . nelms ] = x . size ()). cout < < endl . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− typedef array < int . num ). i < v .

nelms ). Si en el momento de la inserción el número de elementos válidos coincide con el número total de elementos del array. size ())) { anyadir (v . ¤ 55 . nelms . x ). cout < < " Media de los " < < v . } return double ( suma ) / double ( v . int x). num ). } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer ( Vector & v ) { //−−−−−−−−−− ini ( v ). void insertar (Vector& v. v . elm [ i ] = x . MAX> Datos. leer ( v ). //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int MAX = 20. nelms < int ( v .¦ } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void insertar ( Vector & v . using namespace std :: tr1 . const int MAX = 20. for ( int i = 0. Datos elm. el elemento de mayor valor desaparecerá. if ( v . de forma que dicho vector continúe estando ordenado. while ( num ! = 0) { insertar (v . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− double media ( const Vector & v ) { int suma = 0. elm [ i ] < v . elm [ pos_menor ] ) { pos_menor = i . nelms < < " mayores : " < < media ( v ) < < endl . Escribe un procedimiento que pueda insertar el valor de una variable x en un vector v ordenado de forma creciente. typedef array<char. elm . int x ) { if ( v . struct Vector { int nelms. } else { int i = b u s c a r _ p o s _ m e n o r ( v ). § Solución # include < iostream > # include < cassert > # include < tr1/array > using namespace std . } } return pos_menor . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { Vector v . }. } ¥ 14. El vector tendrá un número de elementos válidos que podrá ser menor que el número total de elementos del array. cin > > num . diseñe el programa y los subprogramas necesarios para probar adecuadamente su funcionamiento. + + i ) { suma + = v . Además. elm [ i ] . i < v . //−−−−−−−−−− cout < < " Introduzca una secuencia de números terminada en cero (0): " . cin > > num . int num .

+ + i ) { int x . Datos elm . size ()) < < " ) del vector : " . size ())) { + + v . i < v . cin > > n_elms . while (( i < v . //−−−−−−−−−− cout < < " Introduzca el número de elementos ( menor o igual que " < < int ( v . x ). } return i . if ( pos < int ( v . . size ()). elm [ i ] < < " " . nelms . x ).i ) { v . size ())) { abrir_hueco (v . MAX > Datos . nelms = 0. if ( n_elms > int ( v .. elm . i < n_elms . }. } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void escribir ( const Vector & v ) { cout < < " [ " . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void abrir_hueco ( Vector & v . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // INSERTAR //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int b us ca r _p o si ci o n ( const Vector & v . i > pos . } for ( int i = v . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // LEER ESCRIBIR //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer ( Vector & v ) { //−−−−−−−−−− ini ( v ).//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− typedef array < int . int n_elms . elm [ pos ] = x . elm [ i . pos ). nelms . nelms < int ( v . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void insertar ( Vector & v . elm . elm [ i ] = v . for ( int i = 0. elm [ i ] )) { ++i. struct Vector { int nelms . nelms . + + i ) { cout < < v . for ( int i = 0. elm . } cout < < " ] " < < endl . size ())) { n_elms = int ( v . elm . int x ) { int i = 0. int x ) { int pos = bu s ca r_ p os ic i on (v . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // INICIALIZAR VECTOR //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void ini ( Vector & v ) { v . int pos ) { if ( v . } cout < < " Introduzca " < < n_elms < < " numeros : " . } 56 . v .1. elm .1 ] . cin > > x . nelms ) & & ( x > v . insertar (v .

nelms ) | | ( i1 < v1 . + + i3 ) { if (( i2 > = v2 . for ( int i3 = 0. elm [ i3 ] = v1 . elm [ i1 ] < = v2 . Vector& v3). i3 < v3 . nelms = v1 . elm [ i ] < = v . } } ¥ 15. nelms + v2 . nelms . using namespace std :: tr1 . void mezclar (const Vector& v1. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− typedef array < int . leer ( v ). size ()). nelms & & v1 . § Solución # include < iostream > # include < cassert > # include < tr1/array > using namespace std . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int MAX = 20. elm [ i + 1 ] )) { ++i. nelms . } else { v3 . nelms . Datos elm . el vector no se ha ordenado correctamente " < < endl . Diseña un procedimiento que tome como parámetros de entrada dos vectores ordenados (posiblemente incompletos) y devuelva en un tercer parámetro de salida el resultado de realizar la mezcla ordenada de ambos. elm . } } ¤ 57 .1). Además. escribir ( v ). elm . struct Vector { int nelms . } ok = ( i > = v . nelms = = 0) { ok = true . size ())) { v3 . elm [ i2 ] )) { v3 . } int i1 = 0. + + i1 . int i2 = 0.1) & & ( v . } else { cout < < " Error . + + i2 . Vector & v3 ) { v3 . nelms > int ( v3 . nelms = int ( v3 . } else { int i = 0. if ( esta_ordenado ( v )) { cout < < " Vector ordenado : " < < endl . escribir ( v ). if ( v3 . diseñe el programa y los subprogramas necesarios para probar adecuadamente su funcionamiento. nelms . elm [ i3 ] = v2 . MAX > Datos . const Vector& v2. de tal forma que este vector resultado (posiblemente incompleto) también esté ordenado. if ( v . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { Vector v . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // MEZCLA ORDENADA //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // v1 y v2 e s t á n o r d e n a d o s void mezcla ( const Vector & v1 . const Vector & v2 . }. elm [ i2 ] . } return ok .¦ //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− bool esta_ordenado ( const Vector & v ) { bool ok . elm [ i1 ] . while (( i < v .

leer ( v2 ). size ()). en otros montones de 7. size ())) { v . elm [ i ] < = v . cin > > v . nelms < < " números : " . } cout < < " ] " < < endl . if ( esta_ordenado ( v1 ) & & esta_ordenado ( v2 )) { mezcla ( v1 . 8. v3 . } else { cout < < " Error . if ( v . } else { int i = 0. } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void escribir ( const Vector & v ) { cout < < " [ " . elm . } } ¥ 16. for ( int i = 0. El lote de montones se puede reorganizar así: se toma una carta de cada montón (con lo que desaparecerán los montones con una sóla carta). } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // LEER ESCRIBIR //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer ( Vector & v ) { cout < < " Introduzca el número de elementos ( menor o igual que " < < int ( v . elm [ i ] . partiendo de la situación [ 5 7 3 ]. i < v . elm . Un determinado juego de cartas consiste en lo siguiente: consideremos un mazo de N cartas. nelms . Por ejemplo. while (( i < v . otro de 2 cartas.. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { Vector v1 . siendo N un número triangular. 1 y 5 cartas.1) & & ( v . } return ok . size ()) < < " ) del vector : " . + k para algún k ∈ N. i < v . cada uno de ellos con una cantidad arbitraria de cartas. otro de k − 1 cartas y. cout < < " Introduzca ORDENADOS los elementos de los vectores " < < endl . v3 ). elm . elm [ i + 1 ] )) { ++i. nelms > int ( v .. N = 1 + 2 + 3 + .1)..¦ } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− bool esta_ordenado ( const Vector & v ) { bool ok . escribir ( v3 ). nelms . + + i ) { cout < < " ' " < < v . y con todas ellas se forma uno nuevo. los vectores no estan ordenados " < < endl . esto es. leer ( v1 ). for ( int i = 0. nelms . nelms = = 0) { ok = true . que se agrega al final de la lista de montones. v2 . Por ejemplo.. } ok = ( i > = v . if ( v . la operación descrita transforma los montones de 1. Se reparte la totalidad de las N cartas en un número arbitrario de montones. elm [ i ] < < " ' " . nelms = int ( v . 4 y 4 respectivamente: [ 1 8 1 5 ]⇒[ 0 7 0 4 4 ]⇒[ 7 4 4 ] El desarrollo del juego consiste en llevar a cabo la reorganización descrita anteriormente cuantas veces sea necesario hasta que haya un montón de 1 carta. otro de k cartas. } cout < < " Introduzca " < < v .. finalmente. v2 . nelms . + + i ) { cin > > v . las reorganizaciones sucesivas evolucionan como sigue: 58 . nelms . cout < < " Mezcla ordenada : " .

} } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void compactar ( Vector & v ) { int j = 0. i < v . nelms . ++j. El número montones máximo k no podrá ser mayor de 15. const int MAX = 15. elm [ i ] . } } v . size ())) { v . nelms = j . nelms . El programa comprobará que los valores iniciales de los montones se corresponden con un número triangular (un número N es triangular si √ −1+ 1+8N ∈ N). 59 . elm [ i ] . elm . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− typedef array < int . MAX > Datos . compactar ( v ). } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void anyadir ( Vector & v . y deberá mostrar por pantalla existe un k ∈ N tal que N = (1 + k )k/2. nelms . i < v .[ [ [ [ [ [ [ 5 4 3 2 1 2 1 7 6 5 4 3 1 2 3 2 1 1 2 3 3 ] 3 2 3 4 4 4 ] 4 5 5 5 5 ] ] ] ] ] Realice un programa que lea de teclado el número de montones inicial y el número inicial de cartas de cada montón.10. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void reorganizar ( Vector & v ) { int nuevo_monton = v . elm [ v .1. }. struct Vector { int nelms . + + v . int x ) { if ( v . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const double E R RO R _P RE C IS IO N = 1 e . nelms ] = x . + + i ) { if ( v . elm [ i ] = v . for ( int i = 0. es decir. } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // REORGANIZAR //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void decrementar ( Vector & v ) { for ( int i = 0. elm [ j ] = v . si k = 2 la evolución de los montones hasta finalizar el juego. nelms . + + i ) { v . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // VECTOR //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void ini ( Vector & v ) { v . nelms = 0. elm [ i ] > 0) { v . using namespace std :: tr1 . nelms < int ( v . decrementar ( v ). Datos elm . § Solución ¤ # include < iostream > # include < cassert > # include < cmath > # include < tr1/array > using namespace std .

} for ( int i = 0.0. // } // } // v . x ). int x .anyadir (v . elm [ i ] > 1) { // v .1 + sqrt (1 + 8 * suma )) / 2. ++i ) { // i f ( v . nelms . elm [ j ] = v . } return suma . // } // //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // v o i d r e o r g a n i z a r ( Vector& v ) // { // i n t nuevo_monton = v . // f o r ( i n t i = 0 .double ( int ( k )) < ER RO R _P RE C IS IO N ). if ( n_elms > int ( v . size ()) < < " ): " . elm [ i ] − 1 . i < v . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− bool es_ascendente ( const Vector & v ) { int i = 0. size ()). anyadir (v . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // OTRA POSIBILIDAD //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // v o i d decrementar_compactar ( Vector& v ) // { // i n t j = 0 . elm . return ( k . elm . nelms ). for ( int i = 0. i < v . nelms ) & & ( v . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void escribir ( const Vector & v ) { cout < < " [ " . cin > > x . nelms = j . + + i ) { suma + = v . //−−−−−−−−−− cout < < " Introduzca el número de montones ( menor o igual que " < < int ( v . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // LEER ESCRIBIR //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer ( Vector & v ) { //−−−−−−−−−− ini ( v ). double k = ( . } return ( i > = v . + + i ) { cout < < " Introduzca el número de cartas del monton " < < ( i + 1) < < " : " . i < n_elms . elm . // decrementar_compactar ( v ) . nuevo_monton ) . nelms . 60 . size ())) { n_elms = int ( v . nuevo_monton ). while (( i < v . elm [ i ] . // ++j . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− bool es_triangular ( const Vector & v ) { int suma = sumar ( v ). // a n y a d i r ( v . nelms . cin > > n_elms . elm [ i ] = = ( i + 1))) { ++i. int n_elms . // } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int sumar ( const Vector & v ) { int suma = 0.

} return res . reorganizar ( v ). leer ( v ). ' ): " . + + i ) { v [ i ] = 0.’).¦ } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // JUEGO //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void juego () { Vector v . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void ini ( Cnt & v ) { for ( int i = 0. char c . cin > > ws . nelms . Diseñe un programa para contar y mostrar el número total de ocurrencias (frecuencia) de cada letra minúscula en una secuencia de caracteres leída por teclado hasta el carácter punto (’. cout < < " Introduzca un texto hasta punto ( ' . using namespace std :: tr1 . ¥ 17. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // c o n v i e r t e de l e t r a a í n d i c e int letra_idx ( char letra ) { int res = N_LETRAS . if ( letra > = ' a ' & & letra < = ' z ' ) { res = ( letra . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { juego (). //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int N_LETRAS = ( ' z ' . if ( ! es_triangular ( v )) { cout < < " Error . typedef array < int . cin . + + i ) { cout < < v . N_LETRAS > Cnt . } else { while ( ! es_ascendente ( v )) { escribir ( v ). size ()). elm [ i ] < < " " . } cout < < " ] " < < endl . i < int ( v . § Solución ¤ # include < iostream > # include < string > # include < tr1/array > using namespace std . i < v . } escribir ( v ). } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void e s t a d i s t i c a s _ t e x t o ( Cnt & cnt ) { ini ( cnt ).' a ' ). ' ) { 61 . el número no es triangular " < < endl . } for ( int i = 0. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // c o n v i e r t e de í n d i c e a l e t r a inline char idx_letra ( int idx ) { return char ( ' a ' + idx ). while ( c ! = ' . get ( c ).' a ' ) + 1.

} cout < < endl .' a ' ). + + i ) { if ( i %5 = = 0) { cout < < endl . if ( letra > = ' a ' & & letra < = ' z ' ) { res = ( letra . c < int ( fr [ f ] . ¥ 18. N_LETRAS > FrecLetra . § Solución ¤ # include < iostream > # include < iomanip > # include < string > # include < tr1/array > using namespace std . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const string FIN_SEC = " fin " . size ()). } cout < < idx_letra ( i ) < < " : " < < cnt [ i ] . size ()). } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // c o n v i e r t e de í n d i c e a l e t r a inline char idx_letra ( int idx ) { return char ( ' a ' + idx ). } int idx = letra_idx ( c ). } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { Cnt cnt . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // c o n v i e r t e de l e t r a a í n d i c e inline int letra_idx ( char letra ) { int res = N_LETRAS . N_LETRAS > Frec2Letras . } cin . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void init ( Frec2Letras & fr ) { for ( int f = 0. + + f ) { for ( int c = 0. m o s t r a r _ e s t a d i s t i c a s ( cnt ). realice el cálculo de la frecuencia con que aparece cada palabra de dos letras minúsculas en el texto. get ( c ). Frec2Letras & fr ) { if ( int ( s .int ( ' a ' ) + 1. + + c ) { fr [ f ] [ c ] = 0. } return res . using namespace std :: tr1 . if ( idx < int ( cnt . f < int ( fr . } else { cout < < " \ t " . e s t a d i s t i c a s _ t e x t o ( cnt ).¦ } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void m o s t r a r _ e s t a d i s t i c a s ( const Cnt & cnt ) { for ( int i = 0. size ()). size ()) = = 2) { 62 . imprimiendo en pantalla el resultado. const int N_LETRAS = int ( ' z ' ) . typedef array < FrecLetra . typedef array < int . size ())) { + + cnt [ idx ] . i < int ( cnt . Diseñe un programa que tomando como entrada un texto. } } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void i nc_fre cuenci a ( const string & s .

Además. for ( int f = 0. while ( palabra ! = FIN_SEC ){ inc_ frecue ncia ( palabra . f < i n t ( f r . e s c r i b i r _ f r e c u e n c i a s ( fr ). // } // } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void e s c r i b i r _ f r e c u e n c i a s ( const Frec2Letras & fr ) { cout < < " Frecuencias de las palabras de 2 letras : " < < endl . s i z e ( ) ) . // } // c o u t << e n d l . size ())) & & ( idx_1 < int ( fr [ idx_0 ] . c < i n t ( f r [ f ] .¦ } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void f r e c u e n c i a _ p a l a b r a s ( Frec2Letras & fr ) { string palabra . MAXCOL > Fila . ++c ) { // c o u t << s e t w ( 2 ) << f r [ f ] [ c ] << " " . + + f ) { for ( int c = 0. } } } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { Frec2Letras fr . } ¥ 19. // f o r ( i n t f = 0 . using namespace std :: tr1 . Escribe una función que encuentre el elemento mayor de un array de dos dimensiones dado. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int MAXCOL = 7. f r e c u e n c i a _ p a l a b r a s ( fr ). ++f ) { // c o u t << " " << i d x _ l e t r a ( f ) << " : " . § Solución ¤ # include < iostream > # include < iomanip > # include < tr1/array > using namespace std . init ( fr ). size ()). + + c ) { if ( fr [ f ] [ c ] > 0) { cout < < idx_letra ( f ) < < idx_letra ( c ) < < " : " < < fr [ f ] [ c ] < < endl . typedef array < Fila . cin > > palabra . size ()). } int idx_0 = letra_idx ( s [ 0 ] ). //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int buscar_mayor ( const Matriz & m ) { 63 . // f o r ( i n t c = 0 . fr ). cin > > palabra . c < i n t ( f r [ 0 ] . int idx_1 = letra_idx ( s [ 1 ] ). s i z e ( ) ) . if (( idx_0 < int ( fr . typedef array < int . f < int ( fr . ++c ) { // c o u t << s e t w ( 2 ) << i d x _ l e t r a ( c ) << " " . // } // c o u t << e n d l . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // v o i d e s c r i b i r _ f r e c u e n c i a s ( c o n s t F r e c 2 L e t r a s& f r ) // { // c o u t << " ". // f o r ( i n t c = 0 . s i z e ( ) ) . c < int ( fr [ f ] . const int MAXFIL = 5. cout < < " Introduzca el texto en minúsculas hasta ( fin ) " < < endl . MAXFIL > Matriz . diseñe el programa y los subprogramas necesarios para probar adecuadamente su funcionamiento. size ()))) { + + fr [ idx_0 ] [ idx_1 ] .

using namespace std :: tr1 . + + c ) { ok = m [ f ] [ c ] = = m [ c ] [ f ] . Un array bidimensional a de M filas y M columnas es simétrico si sus elementos satisfacen la condición a[i][j ] = a[j ][i] para todo i. const int MAXFIL = MAXCOL . Escribe una función que determine si un array de ese tipo es simétrico. typedef array < int . typedef array < Fila . + + c ) { cin > > m [ f ] [ c ] . ok & & c < f . + + f ) { for ( int c = 0. ok & & f < int ( m . } } return ok . j . size ()). Además. size ()). size ()). //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− bool es_simetrica ( const Matriz & m ) { bool ok = true . size ()). for ( int f = 0. } } } return mayor . escribir ( m ). size ()). ¥ 20. f < int ( m . c < int ( m [ f ] . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer ( Matriz & m ) { cout < < " Introduzca " < < int ( m . leer ( m ). for ( int f = 0. size ()) < < " números " < < endl . f < int ( m . f < int ( m . size ()). + + f ) { for ( int c = 0. + + f ) { for ( int c = 0. MAXFIL > Matriz . size ()) < < " filas de " < < int ( m [ 0 ] . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int MAXCOL = 5. } } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { Matriz m . + + c ) { if ( m [ f ] [ c ] > mayor ) { mayor = m [ f ] [ c ] . + + c ) { cout < < setw (3) < < m [ f ] [ c ] < < ' ' . c < int ( m [ f ] . size ()). + + f ) { for ( int c = 0. f < int ( m . MAXCOL > Fila . size ()). } cout < < endl . diseñe el programa y los subprogramas necesarios para probar adecuadamente su funcionamiento. c < int ( m [ f ] . c < int ( m [ f ] . + + c ) { 64 . for ( int f = 0. int mayor = buscar_mayor ( m ). + + f ) { for ( int c = 0.¦ } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void escribir ( const Matriz & m ) { for ( int f = 0. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void escribir ( const Matriz & m ) { for ( int f = 0. } int mayor = m [ 0 ] [ 0 ] . § Solución ¤ # include < iostream > # include < iomanip > # include < tr1/array > using namespace std . size ()). cout < < " El número " < < mayor < < " es el mayor elemento de la matriz " < < endl .

¦ } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer ( Matriz & m ) { cout < < " Introduzca " < < int ( m . N ) que no existe porque nos saldríamos del tablero por abajo. } cout < < endl . Diseñe un procedimiento que dada una constante N devuelve como parámetro un tablero N-goro con sus casillas rellenas con el número correspondiente al momento en que se visitan. if ( es_simetrica ( m )) { cout < < " SI " . es decir. f < int ( m . ¤ 65 . size ()) < < " números " < < endl . Por ejemplo. } } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { Matriz m . leer ( m ). N + 1) que no existe porque nos hemos salido por la derecha. for ( int f = 0. la (0. Si se continúa con este proceso se termina visitando todas las casillas del tablero. + + c ) { cin > > m [ f ] [ c ] . Empezamos por la casilla (0. la (1. size ()). Pero la siguiente casilla sería la (1. using namespace std :: tr1 . hasta alcanzar la casilla (N − 1. De nuevo nos movemos hacia la derecha y hacia abajo. Ahora seguimos moviéndonos hacia la derecha y hacia abajo. escribir ( m ). N − 1). + + f ) { for ( int c = 0. N ). La siguiente casilla sería la (N. En estos casos siempre se pasa a la casilla equivalente en la primera fila. 0). La siguiente casilla a visitar sería la (N. Un tablero n-goro es un tablero con N × (N + 1) casillas de la forma: 0 0 1 ··· N −1 1 ··· ··· ··· ··· ··· N −1 N ··· ··· ··· ··· Una propiedad interesante es que se pueden visitar todas sus casillas haciendo el siguiente recorrido por diagonales. 0) y recorremos la diagonal principal hacia la derecha y hacia abajo hasta llegar a la casilla (N − 1. } cout < < setw (3) < < m [ f ] [ c ] < < ' ' . size ()) < < " filas de " < < int ( m [ 0 ] . el tablero a devolver sería: 0 1 2 3 0 1 6 11 16 1 17 2 7 12 2 13 18 3 8 3 9 14 19 4 4 5 10 15 20 § Solución # include < iostream > # include < iomanip > # include < tr1/array > using namespace std . En estos casos se continúa por la casilla equivalente de la primera columna. así como el programa y los subprogramas necesarios para probar adecuadamente su funcionamiento. N − 1). es decir. } cout < < " es simétrica " < < endl . N − 2). ¥ 21. c < int ( m [ f ] . N − 1). cout < < " La matriz " < < endl . size ()). } else { cout < < " NO " . pero como nos saldríamos por abajo pasamos a la casilla equivalente de la primera fila (0. si N es 4.

X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X Diseñe un procedimiento recorrido. typedef array < Fila . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { Matriz m . El subprograma recorrido toma como parámetros una zona de ese tipo. f = ( f + 1) %int ( m . 4). un valor n y una determinada coordenada (fila y columna de una celda visitable) y determine la celda en la que nos encontraremos tras realizar n movimientos por la zona partiendo de la coordenada dada. c = ( c + 1) %int ( m [ 0 ] . size ()). 0) y tras realizar 14 movimientos. Si por el contrario pretendemos realizar 19 o más movimientos. f < int ( m . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void crear_ngoro ( Matriz & m ) { int f = 0. en donde las celdas no visitables se marcan con una X y las visitables se dejan en blanco. const int MAXCOL = MAXFIL + 1. Se dispone de una determinada zona cuadrangular dividida en celdas (8 × 8). escribir ( m ). + + f ) { for ( int c = 0. c < int ( m [ f ] . size ()). teniendo en cuenta: Un movimiento consiste en un desplazamiento horizontal o vertical desde una celda a una celda vecina visitable. considerando la zona de la figura anterior. + + c ) { cout < < setw (3) < < m [ f ] [ c ] < < ' ' . } ¥ 22. typedef array < int . teniendo en cuenta sólo vecindad horizontal y vertical (una celda que está en un borde o bordes de la cuadrícula tiene como vecinas a las celdas del borde o bordes opuestos). nos encontraremos en la celda (0. el programa y los subprogramas necesarios para probar adecuadamente su funcionamiento. por algunas de las cuales se puede circular y por otras no. int c = 0. } cout < < endl . MAXFIL > Matriz . se dará como resultado la celda última en la que nos encontramos. Un ejemplo se muestra en la figura siguiente. Cada celda tiene 4 celdas vecinas posibles. i < = int ( m . crear_ngoro ( m ). size ()). 2). Si no se puede seguir avanzando sin haber alcanzado los n pasos pedidos. MAXCOL > Fila . for ( int i = 1. + + i ) { m[f][c] = i. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void escribir ( const Matriz & m ) { for ( int f = 0. partiendo de la celda (1. size ()). 66 . size ()). nos encontraremos en la celda (5.¦ //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int MAXFIL = 4. size () * m [ 0 ] . sin considerar la celda de la que se proviene. Sólo existirá un camino posible partiendo de la celda dada. Así por ejemplo.

{{ ' ' . ' X ' . ' X ' . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer ( Coord & c ) { cin > > c . f + MAXFIL . int n . Coord & c ) { bool ok = true .1) % MAXFIL . c ). ' ' . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void recorrido ( Matriz & m . ' X ' . ok & & i < n . const int MAXCOL = MAXFIL . f < < " . ' ' . ok ). + + i ) { mover (m . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void mover ( const Matriz & m . ' X ' . c = ci . c < < " ) " . Coord & c ) { assert ( m [ c . ' ' .f][c. ' ' . ' ' . f ] [ cd ] = = ' ' ) { c . {{ ' X ' . struct Coord { int f . m[c. f ] [ ci ] = = ' ' ) { c . ' ' . ' X ' }} . ' X ' . // Decremento ok = true . ' X ' . // Decremento int cd = ( c . ' ' }} . f > > c . ' X ' . ' ' . if ( m [ fd ] [ c . ' ' . ' X ' . ' X ' . ' X ' . c . c ] = = ' ' ) { c . ' ' . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void huella ( Matriz & m . '. ' X ' . ' X ' . " < < c . Coord & c . c ] = = ' ' ) { c . ' X ' . ' ' . c ] = = ' ' ). typedef array < char . } else if ( m [ c . ' ' . ' X ' }} . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const Matriz ZONA = {{ {{ ' X ' . ' X ' . // Incremento int fd = ( c . }. ' X ' }} . ' X ' . ' X ' . c ). ' X ' }} . ' X ' }} . ' X ' . ' X ' . {{ ' X ' . ' X ' .1) % MAXCOL . } else if ( m [ c . c + MAXCOL . {{ ' X ' . MAXCOL > Fila . ' X ' . ' X ' . ' ' . } else { ok = false . using namespace std :: tr1 . ' ' . } else if ( m [ fi ] [ c . bool & ok ) { int fi = ( c . ' X ' . ' ' . ' ' . MAXFIL > Matriz . ' ' . // Incremento int ci = ( c . } } } ¤ circular circular circular circular de de de de fila columna fila columna 67 . int c . ' X ' . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void escribir ( const Coord & c ) { cout < < " ( " < < c . ' X ' . f = fi . c = cd . typedef array < Fila . ' X ' }} .§ Solución # include < iostream > # include < tr1/array > # include < cassert > using namespace std . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int MAXFIL = 8. ' X ' . {{ ' X ' . huella (m . ' X ' . c + 1) % MAXCOL . f ] [ c . ' X ' . ' X ' . ' ' . c . ' X ' . ' X ' . {{ ' ' .c] = '. f = fd . f + 1) % MAXFIL . {{ ' X ' . ' X ' }} }}. for ( int i = 0. if ( ok ) { huella (m . ' X ' .

' X ' . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline bool distintos ( const Coord & c1 . ' X ' }} }}. ' X ' . struct Coord { int f . f < int ( m . {{ ' X ' . ' X ' . typedef array < char . 68 . using namespace std :: tr1 . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { check (). c ). ' X ' . + + c ) { cout < < m [ f ] [ c ] . f ) & & ( c1 . escribir ( c ). ' X ' . ' ' . recorrido (m . ' ' . Coord c . ' X ' . + + f ) { for ( int c = 0. size ()). cout < < endl . {{ ' X ' . int c . ' X ' . ' X ' }} . ' ' . cout < < " Introduzca Coordenada de inicio ( fila y columna ): " . ' X ' . typedef array < Fila . ' X ' . leer ( c ). ' X ' . ' ' . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline bool iguales ( const Coord & c1 . ' X ' }} . int n . ' X ' . MAXCOL > Fila . ' X ' .¦ § //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void escribir ( const Matriz & m ) { for ( int f = 0. ' ' . ' X ' . } ¥ ¤ Otra solución alternativa # include < iostream > # include < tr1/array > using namespace std . ' X ' . ' X ' }} . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const Matriz ZONA = {{ {{ ' X ' . const int MAXCOL = MAXFIL . c < int ( m [ f ] . ' X ' . c2 ). f = = c2 . ' ' . ' X ' . ' ' . }. } cout < < endl . ' ' . ' ' . ' ' . ' X ' . ' X ' . ' ' }} . ' ' . ' X ' . ' ' . ' X ' . c ). {{ ' ' . ' ' . ' ' . ' X ' . const Coord & c2 ) { return ( c1 . ' X ' . {{ ' X ' . ' ' . ' X ' . cout < < " Posición final : " . ' X ' . cout < < " Introduzca número de pasos : " . ' X ' . ' X ' . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void check () { Matriz m = ZONA . ' ' . MAXFIL > Matriz . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int MAXFIL = 8. ' X ' . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline int vabs ( int x ) { int res . n . ' X ' . {{ ' ' . {{ ' X ' . escribir ( m ). size ()). cin > > n . ' X ' . ' ' . ' X ' . ' X ' . const Coord & c2 ) { return ! iguales ( c1 . ' X ' }} . {{ ' X ' . c = = c2 . ' X ' }} . ' X ' }} . escribir ( m ).

+ + f ) { if ( x < 0) { res = int ( . c = ( c . ini ( ant ). ok & & i < n . ! ok & & ff < = + 1. f = ff . f = ( c . cc . bool ok = true . c < < " ) " . Coord & c ) { Coord ant . f ] [ c . + + i ) { mover (m . 69 . int cc . f = MAXFIL . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void escribir ( const Matriz & m ) { for ( int f = 0. cc . ant = act .} //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void ini ( Coord & c ) { c . ok ). n . int ff . Coord & act . int ff . } else { res = int ( x ). } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void paso ( const Coord & c . f < < " . paso ( act . for ( int ff = . cin > > ff > > cc . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void asg ( Coord & c . c + MAXCOL + cc ) % MAXCOL . + + ff ) { for ( int cc = . ! ok & & cc < = + 1. if ( distintos (n . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void escribir ( const Coord & c ) { cout < < " ( " < < c . act = n . Coord & n ) { n . ant . n ). size ()). f + MAXFIL + ff ) % MAXFIL . + + cc ) { if ( vabs ( ff ) + vabs ( cc ) = = 1) { Coord n . " < < c . c ] = = ' ' ). int cc ) { c . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer ( Coord & c ) { int ff . c . n )) { ok = true . asg (c . f < int ( m . ff . Coord & ant . int n . for ( int i = 0. ff . ant ) & & es_visitable (m .x ). c . } return res . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline bool es_visitable ( const Matriz & m . bool & ok ) { ok = false . cc ). c = MAXCOL .1. c . c = cc .1. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void mover ( const Matriz & m . const Coord & c ) { return ( m [ c . } } } } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void recorrido ( const Matriz & m .

int n_col . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− double s u m a _ f i l a _ p o r _ c o l ( const Matriz & x . n_fil > > m . MAX > Fila . recorrido ( ZONA . } cout < < endl . cout < < " Escribe valores fila a fila : " < < endl . n_col . typedef array < Fila . cout < < " Introduzca Coordenada de inicio : " . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer_matriz ( Matriz & m ) { cout < < " Dimensiones ?: " . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { check (). ¥ 23. size ()). struct Matriz { int n_fil . n_col . escribir ( c ). Diseñe un programa que lea dos matrices de números reales de tamaño máximo 10 × 10 (aunque podrán tener un tamaño menor) y muestre el resultado de multiplicar ambas matrices. n_fil . + + c ) { cout < < m [ f ] [ c ] . }. f < m . cout < < " Introduzca número de pasos : " . cin > > m . datos [ f ] [ c ] < < " " . int n . MAX > Tabla . Las matrices se almacenarán en arrays incompletos de dos dimensiones. } } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void e sc ri b ir _m a tr iz ( const Matriz & m ) { for ( int f = 0. + + f ) { for ( int c = 0. cout < < " Posición final : " . cout < < endl . n . const Matriz & y . leer ( c ). n_col . c < int ( m [ f ] . c < m . } cout < < endl . int c ) { 70 . for ( int f = 0. } for ( int c = 0. + + f ) { for ( int c = 0. // −− C o n s t a n t e s −−−−−−− const int MAX = 10. § Solución ¤ # include < iostream > # include < tr1/array > # include < cassert > using namespace std . Tabla datos . // −− Tipos −−−−−−−−−−−− typedef array < double . + + c ) { cout < < m . n_fil . cin > > n . c ). int f . + + c ) { cin > > m . using namespace std :: tr1 . f < m . Coord c .¦ } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void check () { escribir ( ZONA ). c < m . datos [ f ] [ c ] .

+ + f ) { for ( int c = 0. // PRECOND m . " < < endl . while (( i < int ( s . a . for ( int k = 0. f . El texto contiene un número indefinido de palabras en letras minúsculas y termina con la palabra fin. } cin > > palabra . c . n_fil ). //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int buscar ( const string & s . const Matriz & b ) { assert ( a . Cada palabra tiene un número indefinido pero limitado de caracteres (todos alfabéticos minúsculas). } return i . leer_matriz ( b ). Dichas iniciales serán las letras que componen la primera palabra del texto. b . } else { mult_matriz (c . leer_matriz ( a ). f < m . + + k ) { suma + = x . palabra [ 0 ] ) < int ( patron . e sc ri b ir _m a tr iz ( c ). c ). n_col . cin > > palabra . ¥ 24.¦ } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void mult_matriz ( Matriz & m . § Solución # include < iostream > # include < string > using namespace std . datos [ f ] [ k ] * y . n_fil ). // PRECOND double suma = 0. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− ¤ 71 . k < x . } } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { Matriz a . char x ) { int i = 0. n_col ! = b . n_col . size ())) & & ( x ! = s [ i ] )) { ++i. if ( a . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const string FIN_SEC = " fin " . while ( palabra ! = FIN_SEC ){ if ( buscar ( patron . n_fil = a . const Matriz & a . n_fil . + + c ) { m . c < m . datos [ f ] [ c ] = s u m a _ f i l a _ p o r _ c o l (a . for ( int f = 0. n_col . El carácter separador de palabras es el espacio en blanco. datos [ k ] [ c ] . b ). m . n_col = = y . } return suma . Diseñe un programa que tomando como entrada un texto. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void i m p r i m i r _ p a l a b r a s ( const string & patron ) { string palabra . size ())) { cout < < palabra < < " " . } cout < < endl . realice el listado por pantalla de todas las palabras del texto que comiencen por ciertas iniciales.b . n_col = b . } } assert ( x . n_fil ) { cout < < " No se puede multiplicar .0. n_fil . n_col = = b .

Diseñe un programa que lea de teclado un patrón (una cadena de caracteres) y un texto. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void ini ( Vector & v ) { v . while (( i < v . Nota: En el texto aparecerán un número máximo de 20 palabras distintas. Por ejemplo. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int buscar ( const Vector & v . En la salida no habrá palabras repetidas. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const string FIN_SEC = " fin " . const string & x ) { if (( buscar (v .¦ int main () { cout < < " Introduzca el texto en minúsculas hasta ( fin ) con " < < " el patrón de iniciales al principio . typedef array < string . " < < endl . elm [ v . const string & patron ) { int i = 0. if ( patron ! = FIN_SEC ){ i m p r i m i r _ p a l a b r a s ( patron ). using namespace std :: tr1 . struct Vector { int nelms . nelms ) & & ( v . cin > > patron . § Solución # include < iostream > # include < string > # include < tr1/array > using namespace std . Datos elm . Cada palabra tiene un número indefinido pero limitado de caracteres (todos alfabéticos minúsculas). size ()))) { v . int ( patron . El carácter separador de palabras es el espacio en blanco. x ) > = v . nelms < int ( v . size ())) & & ( patron ! = cadena . nelms ] = x . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int buscar ( const string & cadena . substr (i . size ())))) { ++i. size ()) < = int ( cadena . elm [ i ] )) { ++i. } } ¥ 25. }. const string & x ) { int i = 0. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void anyadir ( Vector & v . nelms = 0. ¤ 72 . nelms ) & & ( x ! = v . const int MAX_PAL = 20. elm . string patron . while (( i + int ( patron . + + v . nelms . y dé como resultado las palabras del texto que contengan a dicho patrón. para la entrada: Patron : re Texto: creo que iremos a la direccion que nos dieron aunque pienso que dicha direccion no es correcta fin mostrará como salida: creo iremos direccion correcta El texto contiene un número indefinido de palabras en letras minúsculas y termina con la palabra fin. } return i . MAX_PAL > Datos .

const string & patron ) { return buscar ( palabra . string palabra . N_LETRAS > Frecuencia . } return i . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void e s c r i b i r _ p a l a b r a s ( const Vector & v ) { for ( int i = 0. size ()).int ( ' a ' ) + 1. cin > > palabra . elm [ i ] < < " " . El texto contiene un número indefinido de palabras en letras minúsculas y termina con la palabra fin. ¥ 26. palabra ). + + i ) { cout < < v . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { Vector v . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const string FIN_SEC = " fin " . v ). patron )) { anyadir (v . § Solución # include < iostream > # include < string > # include < tr1/array > using namespace std . Vector & v ) { cout < < " Introduzca el texto en minúsculas hasta ( fin ) " < < endl . El carácter separador de palabras es el espacio en blanco. const int N_LETRAS = int ( ' z ' ) . Una palabra w es un anagrama de la palabra v . size ())) { i = int ( cadena . if ( patron ! = FIN_SEC ){ leer_palabras ( patron . } cin > > palabra . Diseña un programa que lea un texto y determine de cuantas palabras leídas es anagrama la primera dentro de dicho texto. si podemos obtener w cambiando el orden de las letras de v . while ( palabra ! = FIN_SEC ){ if ( contiene ( palabra . size ()) > int ( cadena . Cada palabra tiene un número indefinido pero limitado de caracteres (todos alfabéticos minúsculas). cin > > patron . i < v . } } } if ( i + int ( patron . patron ) < int ( palabra . cout < < " Introduzca el patrón en minúsculas : " .¦ } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline bool contiene ( const string & palabra . e s c r i b i r _ p a l a b r a s ( v ). //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // c o n v i e r t e de l e t r a a í n d i c e int letra_idx ( char letra ) { int res = N_LETRAS . string patron . vaca lo es de cava. Por ejemplo. if ( letra > = ' a ' & & letra < = ' z ' ) { ¤ 73 . ini ( v ). size ()). } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer_palabras ( const string & patron . } cout < < endl . nelms . using namespace std :: tr1 . typedef array < int .

+ + i ) { int idx = letra_idx ( s [ i ] ). } } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− bool es_anagrama ( const string & palabra . " < < endl . Frecuencia & f ) { init ( f ). while ( palabra ! = FIN_SEC ){ if ( es_anagrama ( palabra . frecuencia ( palabra . } cin > > palabra . if ( int ( palabra . patron )) { + + contador . res = f1 = = f2 . size ())) { + + f [ idx ] . size ())) { res = false .int ( ' a ' ). i < int ( s . if ( idx < int ( f . f2 . } else { Frecuencia f1 . int contador = 0. si u contiene perla las palabras parle. cout < < " Introduzca el texto en mínusculas hasta ( fin ) con " < < " el anagrama a comprobar al principio . if ( patron ! = FIN_SEC ){ contador = c o n t a r _ a n a g r a m a s ( patron ). f2 ). ¦ } ¥ 27. size ()). } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { string patron . si u se puede obtener a partir de v después de un cambio de orden de las letras que mantenga inalterado el orden relativo de las consonantes. 74 . } return contador . } return res . size ()) ! = int ( patron . cin > > patron . f1 ). res = int ( letra ) . " < < endl . Diremos que u está asociada a v por vocales fantasmas. aperl. string palabra . } return res . Sean u y v dos palabras formadas por letras minúsculas. Por ejemplo. const string & patron ) { bool res . + + i ) { f [ i ] = 0.} //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void init ( Frecuencia & f ) { for ( int i = 0. frecuencia ( patron . for ( int i = 0. } cout < < " En este texto hay " < < contador < < " anagramas como <" < < patron < < " >. size ()). } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int c o n t a r _ a n a g r a m a s ( const string & patron ) { int contador = 0. cin > > palabra . i < int ( f . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void frecuencia ( const string & s .

pearl.int ( ' a ' ) + 1. + + i ) { f [ i ] = 0. i < int ( s . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // c o n v i e r t e de l e t r a a í n d i c e inline int letra_idx ( char letra ) { int res = N_LETRAS . N_LETRAS > Frecuencia . size ()). } } ¤ 75 . typedef array < int . if ( idx < int ( f .int ( ' a ' ). + + i ) { int idx = letra_idx ( s [ i ] ). size ())) { + + f [ idx ] . lepra no lo está. Frecuencia & f ) { init ( f ). if ( letra > = ' a ' & & letra < = ' z ' ) { res = int ( letra ) . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const string FIN_SEC = " fin " . } } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void c o p i a r _ c o n s o n a n t e s ( const string & palabra . En cambio. i < int ( f . prale. Cada palabra tiene un número indefinido pero limitado de caracteres (todos alfabéticos minúsculas). } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline bool es_vocal ( char letra ) { return (( letra = = ' a ' ) | | ( letra = = ' e ' ) | | ( letra = = ' i ' ) | | ( letra = = ' o ' ) | | ( letra = = ' u ' )). § Solución # include < iostream > # include < string > # include < tr1/array > using namespace std . for ( int i = 0. + + i ) { if ( es_consonante ( palabra [ i ] )) { consonantes + = palabra [ i ] . El texto contiene un número indefinido de palabras en letras minúsculas y termina con la palabra fin. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline bool es_consonante ( char letra ) { return es_minuscula ( letra ) & & ! es_vocal ( letra ). size ()). } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline bool es_minuscula ( char letra ) { return ( letra > = ' a ' & & letra < = ' z ' ). } return res . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void frecuencia ( const string & s . string & consonantes ) { consonantes = " " . using namespace std :: tr1 . ya que no conserva el orden relativo de las consonantes. i < int ( palabra . Diseña un programa que lea desde teclado un texto y calcule el número de palabras leídas asociadas por vocales fantasmas a la primera del mismo. for ( int i = 0. size ()). paerl. · · · están asociadas a u por vocales fantasmas. El carácter separador de palabras es el espacio en blanco. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void init ( Frecuencia & f ) { for ( int i = 0. const int N_LETRAS = int ( ' z ' ) .

f2 . } } return res . } else { Frecuencia f1 . const string & patron ) { bool res . cout < < " Introduzca el texto en minúsculas hasta ( fin ) con " < < " el patrón a comprobar al principio . int contador = 0. Aquellas letras que no se repitan no aparecerán en la salida. Por ejemplo para la secuencia de entrada: abeaddglake. patron )) { + + contador . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { string patron . frecuencia ( patron . } return contador . mostrará la siguiente salida: Distancia entre a: 4 Distancia entre d: 0 Distancia entre e: 7 § Solución # include < iostream > # include < string > ¤ 76 . c o p i a r _ c o n s o n a n t e s ( palabra . f2 ). " < < endl . if ( patron ! = FIN_SEC ){ contador = c o n t a r _ a s o c _ v o c _ f a n t ( patron ). c2 . Diseñe un programa que lea una secuencia de caracteres terminada en punto (’. c2 ). if ( res ) { string c1 . c1 ).} //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− bool asoc_voc_fant ( const string & palabra . " < < endl . } cout < < " En este texto hay " < < contador < < " asociaciones por vocales fantasmas con <" < < patron < < " >. size ()) ! = int ( patron . size ())) { res = false . c o p i a r _ c o n s o n a n t e s ( patron . while ( palabra ! = FIN_SEC ){ if ( asoc_voc_fant ( palabra . cin > > palabra . } cin > > palabra . frecuencia ( palabra . if ( int ( palabra . res = f1 = = f2 . cin > > patron .’) y muestre por pantalla la máxima distancia entre cada par de letras minúsculas repetidas. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int c o n t a r _ a s o c _ v o c _ f a n t ( const string & patron ) { int contador = 0. f1 ). string palabra . ¦ } ¥ 28. La distancia entre dos letras en un texto es el número de letras que aparecen en el texto entre las dos letras indicadas. res = c1 = = c2 .

max_dist = . letra_idx ( c )). using namespace std :: tr1 .cnt [ idx ] . } return res . v [ i ] . max_dist > = 0) { cout < < " Distancia entre " < < idx_letra ( i ) < < " : " < < cnt [ i ] . cin . N_LETRAS > Cnt . } } cnt [ idx ] .' a ' ) + 1. procesar ( cnt .' a ' ). max_dist ) { cnt [ idx ] . cout < < " Introduzca un texto hasta punto ( ' . int pos . if ( letra > = ' a ' & & letra < = ' z ' ) { res = ( letra . get ( c ). } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void e s t a d i s t i c a s _ t e x t o ( Cnt & cnt ) { int pos = 0. typedef array < Estd . ' ) { + + pos . cin . ult_pos ) . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void procesar ( Cnt & cnt . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void m o s t r a r _ e s t a d i s t i c a s ( const Cnt & cnt ) { for ( int i = 0. while ( c ! = ' . get ( c ). ult_pos = 0.# include < tr1/array > using namespace std . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int N_LETRAS = ( ' z ' . size ()). max_dist = dist . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // c o n v i e r t e de l e t r a a í n d i c e int letra_idx ( char letra ) { int res = N_LETRAS . ult_pos ! = 0) { int dist = int ( pos . max_dist < < endl . size ())) { if ( cnt [ idx ] .1. + + i ) { if ( cnt [ i ] .1. cin > > ws . ' ): " . ult_pos = pos . char c . int ult_pos . struct Estd { int max_dist . int idx ) { if ( idx < int ( cnt . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void ini ( Cnt & v ) { for ( int i = 0. if ( dist > cnt [ idx ] . + + i ) { v [ i ] . size ()). } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // c o n v i e r t e de í n d i c e a l e t r a inline char idx_letra ( int idx ) { return char ( ' a ' + idx ). ini ( cnt ). } } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () 77 . i < int ( v . pos . }. i < int ( cnt .

{ ¦ } Cnt cnt . palabra )) { ++i. const string & x . nelms ] . ¤ 78 . nelms ] .1. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int buscar ( const Vector & v . v . + + v . MAX_PAL > Datos . en el que sabemos que hay un máximo de 20 palabras distintas. m o s t r a r _ e s t a d i s t i c a s ( cnt ). struct Distancia { string palabra . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void ini ( Vector & v ) { v . nelms < int ( v . v . int pos . const int MAX_PAL = 20. while (( i < v . Cada palabra tiene un número indefinido pero limitado de caracteres (todos alfabéticos minúsculas). para el siguiente texto de entrada: la casa roja de la esquina es la casa de juan fin mostrará la salida: Distancia entre la: 3 Distancia entre casa: 6 Distancia entre de: 5 El texto contiene un número indefinido de palabras en letras minúsculas y termina con la palabra fin. y muestre por pantalla la MÁXIMA distancia entre cada par de palabras repetidas. int max_dist . elm [ i ] . elm [ v . const string & x ) { int i = 0. nelms . int pos ) { if ( v . e s t a d i s t i c a s _ t e x t o ( cnt ). } return i . typedef array < Distancia . palabra ). } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void procesar ( Vector & v . elm [ v . }. nelms = 0. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void anyadir ( Vector & v . Datos elm . § Solución # include < iostream > # include < string > # include < tr1/array > using namespace std . const string & palabra ) { int i = buscar (v . palabra = x . Diseñe un programa que lea un texto de longitud INDEFINIDA. }. size ())) { v . nelms ) & & ( x ! = v . int ult_pos . using namespace std :: tr1 . elm . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const string FIN_SEC = " fin " . ¥ 29. ult_pos = pos . max_dist = . Por ejemplo. elm [ v . La distancia entre dos palabras en un texto es el número de palabras que aparecen en el texto entre las dos palabras indicadas. nelms ] . struct Vector { int nelms . El carácter separador de palabras es el espacio en blanco.

Forman un círculo y sacan de un sombrero un número n y un nombre de uno de los soldados que forman el círculo. La función devuelve el índice en el array donde se encuentra el soldado elegido para escapar. M> Soldados. cin > > palabra . elm [ i ] . cin > > palabra . pero hay sólo un caballo para escapar y pedir dichos refuerzos. Al soldado que ocupa la última posición del array le sigue en el círculo (según las agujas del reloj) el que se encuentra en la primera posición del array. while ( palabra ! = FIN_SEC ){ + + pos . Los soldados llegan a un acuerdo para determinar quien va a escapar y pedir ayuda. § Solución < cassert > < iostream > < string > < tr1/array > # include # include # include # include ¤ 79 . nelms . int escapa (const Soldados& nom_soldados. ult_pos = pos . palabra ). cout < < " Introduzca el texto en minúsculas hasta ( fin ) " < < endl . elm [ i ] . El proceso continúa de forma que cada vez que la cuenta llega a n se saca un soldado del círculo. El número n para realizar la cuenta según el proceso indicado. max_dist = dist .1. nelms ) { int dist = int ( pos . El significado de cada parámetro es el siguiente: nom_soldados es un array de cadenas de caracteres con los nombres de los M soldados que forman el círculo y en el orden en que se encuentran en el mismo. } if ( i < v . en el sentido de las agujas del reloj. pos ). La cuenta empieza de nuevo con el siguiente soldado (el que sigue al eliminado según el sentido de las agujas del reloj). e s t a d i s t i c a s _ t e x t o ( v ). elm [ i ] . palabra . Empezando por el soldado cuyo nombre se ha sacado cuentan. procesar (v . max_dist < < endl . Un grupo de M soldados (M es una constante) está rodeado por el enemigo y no hay posibilidad de victoria sin refuerzos. } v . elm [ i ] . } else { anyadir (v . elm [ i ] . ini ( v ). pr_sol es nombre del soldado que se escoge inicialmente del sombrero. ult_pos ) . Diseña un subprograma (y programa para prueba) con la siguiente cabecera que realiza el proceso anterior: typedef array<string. max_dist > = 0) { cout < < " Distancia entre " < < v . int n. m o s t r a r _ e s t a d i s t i c a s ( v ).¦ } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void e s t a d i s t i c a s _ t e x t o ( Vector & v ) { int pos = 0. } ¥ 30. Una vez que un soldado se saca del círculo ya no se vuelve a contar. } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void m o s t r a r _ e s t a d i s t i c a s ( const Vector & v ) { for ( int i = 0. if ( dist > v . elm [ i ] . + + i ) { if ( v . El soldado que queda al final es el que coge el caballo y escapa.v . pos . n soldados y sacan fuera del círculo al soldado encontrado en el lugar n-ésimo. max_dist ) { v . palabra < < " : " < < v . } } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { Vector v . elm [ i ] . string palabra . const string& pr_sol). i < v .

int n . ini_validos ( v ). size ()). size ())) & & ( x ! = s [ i ] )) { ++i. } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int cnt_validos ( const Validos & v ) { int cnt = 0. size ()). while (( i < int ( s . int & i ) { for ( int k = 0. 80 . size ())) { for ( int k = 0. } return i . + + i ) { if ( v [ i ] ) { + + cnt . + + i ) { v [ i ] = true . liberar (v . int n .1. } } return cnt . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void siguiente ( const Validos & v . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void l ib er a r_ so l da do ( Validos & v . int & i ) { siguiente_n (v . for ( int i = 0. n . k < n . cout < < " Sale : " < < nombres [ i ] < < endl . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void ini_validos ( Validos & v ) { for ( int i = 0. } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void liberar ( Validos & v . typedef array < bool . N_SOLDADOS > Soldados . const string & pr_sol ) { Validos v . i ). k < int ( nombres . i ). if ( i < int ( nombres . typedef array < string . i ). i ). int i = buscar ( nombres . i ). i < int ( v . N_SOLDADOS > Validos . } return i . int & i ) { assert ( cnt_validos ( v ) > 0). int n . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int escapa ( const Soldados & nombres . } while ( ! v [ i ] ). v [ i ] = false . int i ) { assert ( v [ i ] ). } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void siguiente_n ( const Validos & v . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int buscar ( const Soldados & s . + + k ) { siguiente (v . pr_sol ). const string & x ) { int i = 0. n . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int N_SOLDADOS = 5. using namespace std :: tr1 . i < int ( v . size ()). } siguiente (v . do { i = ( i + 1) %int ( v .using namespace std . + + k ) { l ib er a r_ s ol da d o (v . size ()) .

int n = leer_numero (). una entrada de la forma: Introduzca la clave: ixmrklstnuzbowfaqejdcpvhyg [las 26 letras minúsculas] Introduzca el texto: milk. string pr_sol . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const int N_LETRAS = ( ' z ' . cin > > nombre . + + i ) { cout < < " Nombre " < < i < < " : " .) que representa un mensaje codificado. § Solución ¤ # include < iostream > # include < string > # include < tr1/array > using namespace std . y así sucesivamente. por lo que el ejemplo anterior debería dar como salida: cafe. cin > > num . if ( i_esc < int ( nombres .} //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer_nombres ( Soldados & nombres ) { cout < < " Introduzca nombres de los soldados " < < endl . size ())) { cout < < " El soldado que escapa es : " < < nombres [ i_esc ] < < endl . La clave consiste en una sucesión de las 26 letras minúsculas del alfabeto. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // c o n v i e r t e de l e t r a a í n d i c e int letra_idx ( char letra ) 81 . i < int ( nombres ..Por ejemplo. } else { cout < < " Error : " < < pr_sol < < endl . la letra ’m’ se corresponde con la letra ’c’. n . } ¦ ¥ 31. int num . cin > > nombres [ i ] . leer_nombre ( pr_sol )..' a ' ) + 1. typedef array < char . for ( int i = 0. etc. y lo decodifique según la clave leída. } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int leer_numero () { cout < < " Introduzca un número : " . int i_esc = escapa ( nombres . return num . la segunda con la letra ’b’. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void circulo () { Soldados nombres . Diseñe un programa que permita leer una clave y una secuencia de caracteres terminada en punto (. de tal forma que la letra ’i’ se corresponde con la letra ’a’. leer_nombres ( nombres ). } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer_nombre ( string & nombre ) { cout < < " Introduzca el nombre del primer soldado : " . la letra ’x’ se corresponde con la letra ’b’. size ()).. N_LETRAS > Clave . Los signos de puntuación y dígitos que aparezcan en el mensaje deben escribirse como tales. pr_sol ). using namespace std :: tr1 . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { circulo (). las cuales se hacen corresponder la primera letra de la clave con la letra ’a’.

{

} //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // c o n v i e r t e de í n d i c e a l e t r a inline char idx_letra ( int idx ) { return char ( ' a ' + idx ); } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void init ( Clave & c ) { for ( int i = 0; i < int ( c . size ()); + + i ) { c[i] = ' '; } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // Ejemplo : i x m r k l s t n u z b o w f a q e j d c p v h y g //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer_clave ( bool & ok , Clave & clave_cifrado , Clave & c l a v e _ d e s c i f r a d o ) { ok = true ; init ( clave_cifrado ); init ( c l a v e _ d e s c i f r a d o ); cout < < " Introduzca la clave : " ; int i_letra = 0; while ( ok & & i_letra < N_LETRAS ) { char letra ; cin > > letra ; int idx = letra_idx ( letra ); if (( idx < N_LETRAS ) & & ( c l a v e _ d e s c i f r a d o [ idx ] = = ' ' )) { c l a v e _ d e s c i f r a d o [ idx ] = idx_letra ( i_letra ); clave_cifrado [ i_letra ] = letra ; + + i_letra ; } else { ok = false ; } } cin . ignore (1000 , ' \ n ' ); } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void transformar ( const Clave & clave ) { cout < < " Introduzca el texto : " ; char c ; cin > > ws ; cin . get ( c ); while ( c ! = ' . ' ) { if ( c > = ' a ' & & c < = ' z ' ) { c = clave [ letra_idx ( c ) ] ; } cout < < c ; cin . get ( c ); } cout < < c < < endl ; cin . ignore (1000 , ' \ n ' ); } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− char menu () { char op ; cout < < endl ; cout < < " - - - - - - - - - - - - - - - - - - - " < < endl ; cout < < " c : Cifrar " < < endl ; cout < < " d : Descifrar " < < endl ; cout < < " x : Fin " < < endl ; cout < < " - - - - - - - - - - - - - - - - - - - " < < endl ; cout < < endl ; do { cout < < " Opcion ? " ;

int res = N_LETRAS ; if ( letra > = ' a ' & & letra < = ' z ' ) { res = ( letra - ' a ' ); } return res ;

82

¦

} //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { bool ok ; Clave cc , cd ; leer_clave ( ok , cc , cd ); if ( ! ok ) { cout < < " clave errónea " < < endl ; } else { char op ; do { op = menu (); switch ( op ) { case ' c ' : transformar ( cc ); break ; case ' d ' : transformar ( cd ); break ; } } while ( op ! = ' x ' ); } }

cin > > op ; } while ( op ! = ' c ' & & op ! = ' d ' & & op ! = ' x ' ); cin . ignore (1000 , ' \ n ' ); return op ;

¥

32. Se deberá realizar un programa que lea una cadena de caracteres que será utilizada como clave de cifrado, y posteriormente, se leerá un texto de “longitud indefinida” hasta un carácter punto (’.’) el cual deberá ser cifrado y mostrado por pantalla. El cifrado se realizará de la siguiente manera: Sólo se cifrarán las letras minúsculas. Cada carácter de la clave (se supone que sólo esta formada por letras minúsculas) se corresponde con un valor numérico que representa un incremento igual a la distancia alfabética de dicha letra respecto a la letra ’a’. Por ejemplo al carácter ’a’ de la clave le corresponde un incremento de 0, al carácter ’b’ un incremento de 1, a ’c’ de 2, y así sucesivamente. A cada carácter del texto a cifrar se le asocia para realizar el cifrado la letra de la clave correspondiente a su posición (el primer carácter ocupa la posición 0) módulo el número de caracteres de la clave. Nota: módulo significa el resto de la división. Cada carácter del texto a cifrar será cifrado mediante un incremento circular (el siguiente a la ’z’ es la ’a’) correspondiente a la letra de la clave asociada. Por ejemplo, para la clave abx y el texto de entrada hola y adios. mostrará como resultado hpia z xdjls. como se indica en el siguiente esquema:
abxa b xabxa hola y adios. ------------hpia z xdjls. ------------|||| | ||||| |||| | ||||+--> |||| | |||+---> |||| | ||+----> |||| | |+-----> |||| | +------> |||| +--------> |||+----------> ||+-----------> |+------------> +------------->

s o i d a y a l o h

+ + + + + + + + + +

0 = s 23 = l 1 = j 0 = d 23 = x 1 = z 0 = a 23 = i 1 = p 0 = h

§

Solución

# include < cassert > # include < iostream >

¤

83

# include < string > using namespace std ; //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− bool es_minuscula ( char c ) { return (( c > = ' a ' ) & & ( c < = ' z ' )); } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void sig_circular ( int & i , int limite ) { assert ( i < limite ); ++i; // i = ( i + 1) % l i m i t e ; if ( i = = limite ) { // i = 0; // } // } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void inc_circular ( int & x , int inc , int min , int max ) { assert (( x > = min ) & & ( x < = max ) & & ( inc < max - min + 1)); x = x + inc ; // x = ( ( ( ( x+i n c )−min) %(max−min+1))+min ) ; if ( x > max ) { // x = min + x - max - 1; // } // } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void cifrar ( char & c , char cl ) { assert ( es_minuscula ( c ) & & es_minuscula ( cl )); const int inc = ( cl - ' a ' ); int x = c ; inc_circular (x , inc , int ( ' a ' ) , int ( ' z ' )); c = char ( x ); } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void cifrar_texto ( const string & clave ) { assert ( int ( clave . size ()) > 0); int i = 0; cout < < " Texto : " ; cin > > ws ; char c ; cin . get ( c ); cout < < " Resultado : " ; while ( c ! = ' . ' ) { if ( es_minuscula ( c )) { cifrar (c , clave [ i ] ); sig_circular (i , int ( clave . size ())); } cout < < c ; cin . get ( c ); } cout < < c ; } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { string clave ; cout < < " Clave : " ; cin > > clave ; cifrar_texto ( clave ); cout < < endl ;

¦

}

¥

33. Un importante vulcanólogo, con objeto de estudiar las consecuencias destructoras de un volcán en una determinada área, pretende desarrollar un sistema informático que le ayude en su tarea. Para ello, nos pide que realicemos el siguiente subprograma junto con el programa necesario para realizar la prueba.
const int N_FILAS = 10; const int N_COLUMNAS = 12; typedef array<int, N_COLUMNAS> FilaSup; typedef array<FilaSup, N_FILAS> Superficie; typedef array<char, N_COLUMNAS> FilaLava;

84

Así mismo. const Coord & c ) { if ( v . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− struct Coord { int fil . struct Vector { Datos elm . nelms < int ( v . y la mostrará en el array bidimensional de salida (lava). El subprograma predecirá el recorrido que realiza la lava. typedef array < FilaSup . y el espacio en blanco (’ ’) representa que la lava no ha pasado por dicho punto. nelms . int nelms . const int MAX_COORD = N_FILAS * N_COLUMNAS * 2. recibe un punto (fila y columna) de dicho plano donde surge el cráter de un volcán. // −− Tipos −−−−−−−−−−−− typedef array < int . void flujo_lava (const Superficie& sup. size ())) { v . El cual recibe un array bidimensional (sup) que representa el plano de la zona a estudiar. 2) sup 0 1 2 3 4 § 0 4 5 7 5 4 1 7 6 7 6 6 2 8 9 8 8 6 3 7 9 8 6 9 4 6 7 7 8 5 Solución 0 ∗ ∗ ∗ ∗ lava 1 ∗ ∗ ∗ 2 3 4 0 1 2 3 4 ∗ # include < cassert > # include < iostream > # include < tr1/array > using namespace std . Los puntos circundantes de uno dado serán el superior. }. elm [ v .typedef array<FilaLava. int fila. } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void nueva_coord ( Vector & v . donde cada elemento contiene un número entero que representa la altura de ese punto respecto al nivel del mar. MAX_COORD > Datos . inferior. elm . donde el asterisco (’*’) representa que la lava ha pasado por ese punto. nelms = 0. Coord & c ) ¤ 85 . N_COLUMNAS > FilaSup . typedef array < FilaLava . El flujo de lava se desplaza según el siguiente esquema a partir del cráter: Desde un determinado punto. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline void ini ( Vector & v ) { v . nelms ] = c . para un cráter del volcán en el punto (2. N_FILAS > LavaSup . izquierdo y derecho (no se considerarán los diagonales). siempre se mueve hacia los puntos circundantes que se encuentran a menor altura. Por ejemplo. N_FILAS > Superficie . int col . const int N_COLUMNAS = 12. Así sucesivamente se repite el proceso para todos los puntos donde haya alcanzado el flujo de lava. N_FILAS> LavaSup. typedef array < Coord . using namespace std :: tr1 . N_COLUMNAS > FilaLava . LavaSup& lava). // −− C o n s t a n t e s −−−−−−− const int N_FILAS = 10. } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void anyadir ( Vector & v . int columna. + + v . typedef array < char . }.

const Coord & act . size ()). const Coord & nueva ) { return ( es_valida ( sup . fil ] [ c . c = v .{ } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void ini ( LavaSup & lava ) { for ( int f = 0. col ] )). cc . } } } } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void asg ( Coord & c . int ff . + + f ) { for ( int c = 0. } val = int ( x ). col ] = = ' ' )). paso ( act . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline int vabs ( int x ) { int res . cc < = + 1. col < int ( sup [ c . fil . + + c ) { lava [ f ] [ c ] = ' ' . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void paso ( const Coord & c . nelms . size ())) & & ( c . const LavaSup & lava . fil ] . lava . act . + + ff ) { for ( int cc = . size ())) & & ( lava [ c . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline void inc ( int & val . if ( x < 0) { res = int ( . n )) { anyadir (v . Vector & v ) { for ( int ff = . if ( x < 0) { x = MAX_COORD . . c < int ( lava [ f ] . fil ] [ nueva . } } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline bool es_valida ( const Superficie & sup . + + cc ) { if ( vabs ( ff ) + vabs ( cc ) = = 1) { Coord n . f < int ( lava . int cc ) { assert ( v . size ()). 86 . inc ( n . nelms > 0). } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline bool es_menor ( const Superficie & sup . n ). fil < int ( sup . if ( es_menor ( sup .v . } else { res = int ( x ). inc ( n . nelms ] . int i ) { int x = int ( val ) + i . fil ] [ act .. ff < = + 1. const Coord & act .1. cc ). Coord & n ) { n = c. lava . int ff . elm [ v . n ).x ). } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void p r o c e s a r _ v e c i n o s ( const Superficie & sup . const Coord & c ) { return (( c . ff . col . col ] < sup [ act .1. const LavaSup & lava . ff ). nueva ) & & ( sup [ nueva . const LavaSup & lava . int cc . } return res .

8 }} }}. 9 . 4 . 6 . {{ 4 . 4 }} . lava ). } c . 3 . 7 . 6 }} . size ()) + 2). 5 . 7 .' . 9 . 9 . int col . 3 . ini ( lava ). 8 . fil ] [ pos . pos ). 7 . 9 . 8 . 7 . for ( int f = 0. {{ 7 . col ] = ' * ' . 4 . 6 . 1 . size ()) + 2). 7 . 7 . 4 . imprimir ( lava ). {{ 4 . p r o c e s a r _ v e c i no s ( sup . 7 . 6 . {{ 5 . while ( v . 7 . 6 . 6 . + + c ) { cout < < lava [ f ] [ c ] . Coord pos . 8 . 8 . if ( es_valida ( sup . 7 . 9 . 7 . fil . 8 }} . 5 . 8 . + + f ) { cout < < " | " . ¥ 34. 6 . f . 4 }} . ini ( v ). 6 . 6 . 5 . 9 . col ). 7 . + + i ) { cout < < ' . 6 . fil ] [ pos . } } } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void linea ( int n ) { for ( int i = 0. int f . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const Superficie ALTURAS = {{ {{ 4 . 9 . podemos definir el siguiente tipo: struct Complejo { double real. 6 . 7 . 8 . 6 . 7 . 9 . } cout < < " | " < < endl . 6 . 6 . 87 . {{ 4 . size ()). 8 . 6 . 8 . 6 . 9 . v ). 9 . 0 }} . 7 . cin > > f > > c . flujo_lava ( ALTURAS . c < int ( lava [ f ] . asg ( pos . 9 }} . LavaSup lava . 6 . if ( lava [ pos . 6 }} . 7 . 6 . 7 . c . lava . pos )) { anyadir (v . 8 . 7 . pos ). } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void imprimir ( const LavaSup & lava ) { linea ( int ( lava [ 0 ] . 8 . 7 . 5 . Para realizar operaciones con números complejos. {{ 5 . 6 . col ] = = ' ' ) { lava [ pos . 6 . for ( int c = 0. 4 . int fil . 9 . 9 . 5 . 6 . {{ 4 . 9 . 8 . 5 . c . 6 . 6 . 4 . 8 . f < int ( lava . 6 . 8 . 5 . c . } cout < < endl . fil = ff . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int main () { cout < < " Introduzca las coordenadas del cráter : " . 8 . 3 . lava . 8 .¦ } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void flujo_lava ( const Superficie & sup . 5 . }. 7 . 7 . LavaSup & lava ) { Vector v . 9 }} . pos . 8 . 8 . {{ 7 . col = cc . 6 . 8 . 7 . 4 . 4 . 9 . 6 . 4 }} . i < n . {{ 5 . } linea ( int ( lava [ 0 ] . size ()). 8 . nelms > 0) { nueva_coord (v . 7 . double img. 2 .

real ) . real = (( c1 . res . img ). real + c2 . res . así como el programa para probar adecuadamente su funcionamiento. //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline double sq ( double x ) { return x * x . double img . res . }. img . Compárese con la solución del ejercicio 1 del tema 4. resta. res . real ) & & iguales ( c1 . return res . return ( . img )). real . c2 . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− Complejo operator/ ( const Complejo & c1 . img * c2 . real ).( c1 . const Complejo & c2 ) { Complejo res . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− Complejo operator . res . res . const Complejo & c2 ) { return iguales ( c1 . const Complejo & c2 ) { Complejo res . real = ( c1 . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− bool operator = = ( const Complejo & c1 . res . img * c2 . real ) . real = real . const Complejo & c2 ) { Complejo res . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− 88 . real = c1 . img = c1 . res . real ) + sq ( c2 . return res .y . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− Complejo operator + ( const Complejo & c1 . img * c2 .c2 . return res . real .( const Complejo & c1 . img . real ) + ( c1 . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− bool iguales ( double x . img * c2 . img )). img = ( c1 . real * c2 . c2 . real = c1 . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− Complejo crear ( double real .Escribe subprogramas (sobrecargando los operadores necesarios) que realicen las operaciones de suma.( c1 . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− Complejo operator * ( const Complejo & c1 . img .ER R OR _ PR EC I SI ON < = cmp ) & & ( cmp < = E R RO R _P RE C IS IO N ). const Complejo & c2 ) { Complejo res . img + c2 . real * c2 . img = img . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− struct Complejo { double real . img . img = c1 . double img ) { Complejo res . § Solución ¤ # include < iostream > using namespace std . real * c2 . return res .c2 . real * c2 . img ). double y ) { double cmp = x . real . multiplicación y división de números complejos definidos con el tipo anterior. img )) / ( sq ( c2 . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− const double E R RO R _P RE C IS IO N = 1 e . img ) + ( c1 . real . res . return res . res . real ) + sq ( c2 . img )) / ( sq ( c2 . img = (( c1 .10.

real < < " . const Complejo & c2 ) { Complejo c0 = c1 * c2 . cout < < " = " . escribir ( c2 ). escribir ( c2 ). img ): " . cout < < endl . cout < < endl . cout < < " = " . cout < < " * " . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void prueba_suma ( const Complejo & c1 . cout < < " = " . cout < < " / " . cout < < " = " . escribir ( c0 ).bool operator ! = ( const Complejo & c1 .c2 ) { cout < < " Error en operaciones de suma/resta " < < endl . escribir ( c1 ). } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void prueba_resta ( const Complejo & c1 . escribir ( c2 ). } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void prueba_mult ( const Complejo & c1 .c2 . const Complejo & c2 ) { Complejo c0 = c1 / c2 . " < < c . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− 89 . const Complejo & c2 ) { Complejo c0 = c1 + c2 . escribir ( c1 ). if ( c1 ! = c0 . const Complejo & c2 ) { return ! ( c1 = = c2 ). img . if ( c1 ! = c0 / c2 ) { cout < < " Error en operaciones de mult/div " < < endl . if ( c1 ! = c0 * c2 ) { cout < < " Error en operaciones de mult/div " < < endl . escribir ( c0 )." . escribir ( c0 ). escribir ( c2 ). img < < " ) " . escribir ( c1 ). cout < < " + " . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline void escribir ( const Complejo & c ) { cout < < " ( " < < c . escribir ( c1 ). cout < < " . cout < < endl . cin > > c . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void prueba_div ( const Complejo & c1 . cout < < endl . const Complejo & c2 ) { Complejo c0 = c1 . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void leer ( Complejo & c ) { cout < < " Introduzca un número complejo ( real . escribir ( c0 ). real > > c . if ( c1 ! = c0 + c2 ) { cout < < " Error en operaciones de suma/resta " < < endl .

n_pers = 0. cin > > dir . Personas pers . c ) Borrar una persona a partir de su nombre. } //−−−−−−−−−−−−−−−−−−−−−−−−−−− 90 . Número. // −− S u b a l g o r i t m o s −−−− void Inicializar ( Agenda & ag ) { ag . prueba_resta ( c1 . string piso . § Solución ¤ # include < iostream > # include < string > # include < cassert > # include < tr1/array > using namespace std . cin > > dir . cin > > dir . AG_LLENA .¦ int main () { Complejo c1 . }. Dirección. Piso. piso . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− } ¥ 35. d ) Modificar los datos de una persona a partir de su nombre. prueba_div ( c1 . c2 ). c2 ). Teléfono. c2 ). leer ( c2 ). num . string cp . Calle. string tel . string calle . Código Postal y Ciudad. }. // −− Tipos −−−−−−−−−−−− typedef array < Persona . c2 ). MAX_PERSONAS > Personas . e ) Listar el contenido completo de la agenda. prueba_mult ( c1 . c2 . cin > > dir . string ciudad . // −− C o n s t a n t e s −−−−−−− const int MAX_PERSONAS = 50. using namespace std :: tr1 . leer ( c1 ). }. Diseñe un programa para gestionar una agenda personal. NO_ENCONTRADO . ciudad . enum Cod_Error { OK . //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− prueba_suma ( c1 . } // −− S u b a l g o r i t m o s −−−− void L eer_Di reccio n ( Direccion & dir ) { cin > > dir . cp . donde la información que se almacena de cada persona es la siguiente: Nombre. YA_EXISTE }. struct Agenda { int n_pers . struct Persona { string nombre . // −− Tipos −−−−−−−−−−−− struct Direccion { int num . calle . La agenda permitirá realizar las siguientes operaciones: a ) Añadir los datos de una persona b ) Acceder a los datos de una persona a partir de su nombre. Direccion direccion .

pers [ i ] . ciudad < < " " . } // −− S u b a l g o r i t m o s −−−− // Busca una Persona en l a Agenda // D e v u e l v e su p o s i c i o n s i s e e n c u e n t r a . const Persona & per ) { ag . cout < < dir . Eliminar ( ag . pers .. pers [ pos ] = ag .ag . cout < < dir . Agenda & ag . while (( i < ag . tel < < " " . n_pers . } else { ok = OK . nombre )) { ++i. int pos ) { ag . if ( i > = ag . calle < < " " .1 ] . nombre < < " " . n_pers ) & & ( nombre ! = ag . } return i . n_pers ) { ok = YA_EXISTE . Leer _Direc cion ( per . tel . pers [ ag .void Leer_Persona ( Persona & per ) { cin > > per . } //−−−−−−−−−−−−−−−−−−−−−−−−−−− void E s c r i b i r _ P e r s o n a ( const Persona & per ) { cout < < per . i ). } // −− S u b a l g o r i t m o s −−−− void A ny ad i r_ Pe r so na ( const Persona & per . Anyadir ( ag . } else { ok = OK . } //−−−−−−−−−−−−−−−−−−−−−−−−−−− void Eliminar ( Agenda & ag . 91 . per ). Agenda & ag . cout < < endl . ag ). cp < < " " . E s c r i b i r _ D i r e c c i o n ( per . + + ag . Cod_Error & ok ) { int i = Busca r_Pers ona ( per . piso < < " " . o b i e n >= ag . ag ). cout < < dir . if ( i < ag . direccion ). nombre . n_pers ] = per . n_pers en o t r o c a s o int Buscar _Perso na ( const string & nombre . n_pers = = int ( ag . pers [ ag . num < < " " . cin > > per . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−− void B orrar_ Person a ( const string & nombre . } //−−−−−−−−−−−−−−−−−−−−−−−−−−− void Anyadir ( Agenda & ag . } } // −− S u b a l g o r i t m o s −−−− void M o d i f i c a r _ P e r s o n a ( const string & nombre . size ())) { ok = AG_LLENA . Agenda & ag . nombre . n_pers . cout < < dir . cout < < per . n_pers ) { ok = NO_ENCONTRADO . const Persona & nuevo . } else if ( ag . n_pers . } // −− S u b a l g o r i t m o s −−−− void E s c r i b i r _ D i r e c c i o n ( const Direccion & dir ) { cout < < dir . . const Agenda & ag ) { int i = 0. Cod_Error & ok ) { int i = Busca r_Pers ona ( nombre . direccion ). ag ). Cod_Error & ok ) { int i = Busca r_Pers ona ( nombre .

case YA_EXISTE : cout < < " La persona ya se encuentra en la agenda " < < endl . . Cod_Error & ok ) { int i = Busca r_Pers ona ( nombre .} //−−−−−−−−−−−−−−−−−−−−−−−−−−− void I m p r i m i r _ P e r s o n a ( const string & nombre . pers [ i ] ). i ).Modificar Persona " < < endl . cout < < " x . cout < < endl . cout < < " e .Buscar Persona " < < endl . A ny ad i r_ P er so n a ( nuevo .Borrar Persona " < < endl .Imprimir Agenda " < < endl . } 92 . cout < < " b . cin > > opcion . . ok ). cout < < " d . case AG_LLENA : cout < < " Agenda llena " < < endl . } } // −− P r i n c i p a l −−−−−−−− int main () { Agenda ag . Cod_Error & ok ) { for ( int i = 0. E s c r i b i r _ P e r s o n a ( ag . + + i ) { E s c r i b i r _ P e r s o n a ( ag . break . break . break . string nombre . } else { ok = OK . } ok = OK . } } // −− S u b a l g o r i t m o s −−−− void I mp ri m ir _A g en da ( const Agenda & ag . . do { opcion = Menu ().Anadir Persona " < < endl . return opcion . n_pers ) { ok = NO_ENCONTRADO . Cod_Error ok . case NO_ENCONTRADO : cout < < " La persona no se encuentra en la agenda " < < endl . } // −− S u b a l g o r i t m o s −−−− void E s c r i b i r _ C o d _ E r r o r ( Cod_Error cod ) { switch ( cod ) { case OK : cout < < " Operacion correcta " < < endl . Persona per . i < ag . n_pers ) { ok = NO_ENCONTRADO . } while ( ! ((( opcion > = ' a ' ) & & ( opcion < = ' e ' )) | | ( opcion = = ' x ' ))). .Salir " < < endl . cout < < " a . cout < < " c . . const Agenda & ag . do { cout < < " Introduzca Opcion : " . char opcion . pers [ i ] ). Inicializar ( ag ). ag ). ag . . } else { Eliminar ( ag . n_pers . } //−−−−−−−−−−−−−−−−−−−−−−−−−−− char Menu () { char opcion . if ( i > = ag . switch ( opcion ) { case ' a ' : if ( i > = ag . break .

tel . } } while ( opcion ! = ' x ' ). calle . I m p r i m i r _ P e r s o n a ( nombre . ok ). ag .¦ } cout < < " Introduzca los datos de la Persona " < < endl . per . num . case ' c ' : cout < < " Introduzca Nombre " < < endl . E s c r i b i r _ C o d _ E r r o r ( ok ). ¥ 93 . E s c r i b i r _ C o d _ E r r o r ( ok ). ok ). ok ). break . ag . ok ). E s c r i b i r _ C o d _ E r r o r ( ok ). ag . E s c r i b i r _ C o d _ E r r o r ( ok ). E s c r i b i r _ C o d _ E r r o r ( ok ). break . M o d i f i c a r _ P e r s o n a ( nombre . cod_postal . ok ). tel . Leer_Persona ( per ). A ny ad i r_ P er so n a ( per . Borr ar_Per sona ( nombre . calle . piso . break . cout < < " Nuevos datos de la Persona " < < endl . Leer_Persona ( per ). ciudad ) " < < endl . break . cin > > nombre . break . case ' e ' : I mp ri m ir _ Ag en d a ( ag . cout < < " ( nombre . num . case ' b ' : cout < < " Introduzca Nombre " < < endl . cout < < " ( nombre . case ' d ' : cout < < " Introduzca Nombre " < < endl . ciudad ) " < < endl . ag . cin > > nombre . cin > > nombre . piso . cod_postal .

AG_LLENA . Piso. Teléfono. cin > > dir . // −− C o n s t a n t e s −−−−−−− const int MAX_PERSONAS = 50. struct Agenda { int n_pers . n_pers = 0. calle < < " " . // −− S u b a l g o r i t m o s −−−− void Inicializar ( Agenda & ag ) { ag . y permitirá realizar las siguientes operaciones: a ) Añadir los datos de una persona b ) Acceder a los datos de una persona a partir de su nombre. enum Cod_Error { OK . }. string calle . d ) Modificar los datos de una persona a partir de su nombre. donde la información que se almacena de cada persona es la siguiente: Nombre. num . ciudad . string cp . }. string piso . cin > > per . Dirección. Diseñe un programa para gestionar una agenda personal. calle . }. e ) Listar el contenido completo de la agenda. nombre . tel . // −− Tipos −−−−−−−−−−−− struct Direccion { int num . } // −− S u b a l g o r i t m o s −−−− void L eer_Di reccio n ( Direccion & dir ) { cin > > dir . cin > > dir . NO_ENCONTRADO . cin > > dir . string ciudad . direccion ). Personas pers . MAX_PERSONAS > Personas . c ) Borrar una persona a partir de su nombre. string tel . Número. Código Postal y Ciudad. // −− Tipos −−−−−−−−−−−− typedef array < Persona . La agenda se encontrará ordenada según el nombre de la persona. Leer _Direc cion ( per . YA_EXISTE }. struct Persona { string nombre . Calle. } //−−−−−−−−−−−−−−−−−−−−−−−−−−− void Leer_Persona ( Persona & per ) { cin > > per . Direccion direccion .Tema 5: Búsqueda y Ordenación 1. cin > > dir . § Solución ¤ # include < iostream > # include < string > # include < cassert > # include < tr1/array > using namespace std . piso . cp . using namespace std :: tr1 . 94 . } // −− S u b a l g o r i t m o s −−−− void E s c r i b i r _ D i r e c c i o n ( const Direccion & dir ) { cout < < dir .

Agenda & ag . } //−−−−−−−−−−−−−−−−−−−−−−−−−−− void Cerrar_Hueco ( Agenda & ag . cp < < " " . if (( pos < ag . n_pers . } if ( i > = f ) { m = ag . n_pers ) & & ( per . const Persona & per ) { for ( int i = ag . i > pos . dir . nombre < < " " . n_pers . int f = ag . tel < < " " . + + ag . n_pers = = int ( ag . while (( i < ag . pers [ i . . nombre )) { if ( nombre < ag . direccion ). n_pers en o t r o c a s o int Buscar _Perso na ( const string & nombre .. Cod_Error & ok ) { int pos = Bu s ca r_ P os ic i on ( per . pers [ pos ] . } else { i = m + 1. } //−−−−−−−−−−−−−−−−−−−−−−−−−−− void Abrir_Hueco ( Agenda & ag . pers [ i ] . ciudad < < " " . o b i e n >= ag . pers [ m ] . Abrir_Hueco ( ag . + + i ) { ag .i ) { ag . n_pers . per ). for ( int i = pos . nombre )) { ++i. while (( i < f ) & & ( nombre ! = ag . } return m . pers [ i + 1 ] . n_pers . } // −− S u b a l g o r i t m o s −−−− // Busca una Persona en l a Agenda Ordenada // D e v u e l v e su p o s i c i o n s i s e e n c u e n t r a . 95 . size ())) { ok = AG_LLENA . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−− cout cout cout cout << << << << dir . n_pers . } ag .. } // −− S u b a l g o r i t m o s −−−− int B us ca r _P o si ci o n ( const string & nombre . cout < < per . nombre )) { ok = YA_EXISTE . num < < " " . pos . nombre = = ag . } else { ok = OK . ag ). const Agenda & ag ) { int i = 0. pers . int pos . E s c r i b i r _ D i r e c c i o n ( per . nombre . int m = ( i + f ) / 2. nombre ) { f = m. } else if ( ag . pers [ i ] = ag . } m = ( i + f ) / 2. pers [ m ] . } } // −− S u b a l g o r i t m o s −−−− void A ny ad i r_ Pe r so na ( const Persona & per . pers [ i ] = ag . i < ag . n_pers .1 ] . cout < < endl .ag . dir . dir . const Agenda & ag ) { int i = 0. n_pers ) & & ( nombre > = ag . int pos ) { . } return i . pers [ pos ] = per .} //−−−−−−−−−−−−−−−−−−−−−−−−−−− void E s c r i b i r _ P e r s o n a ( const Persona & per ) { cout < < per . piso < < " " .

A ny ad i r_ P er so n a ( nuevo . 96 . Cod_Error & ok ) { int i = Busca r_Pers ona ( nombre . ag . case AG_LLENA : cout < < " Agenda llena " < < endl . E s c r i b i r _ P e r s o n a ( ag . case YA_EXISTE : cout < < " La persona ya se encuentra en la agenda " < < endl . . Cerrar_Hueco ( ag . cout < < " c . return opcion . } while ( ! ((( opcion > = ' a ' ) & & ( opcion < = ' e ' )) | | ( opcion = = ' x ' ))).Anadir Persona " < < endl . case NO_ENCONTRADO : cout < < " La persona no se encuentra en la agenda " < < endl . Agenda & ag . } // −− S u b a l g o r i t m o s −−−− void E s c r i b i r _ C o d _ E r r o r ( Cod_Error cod ) { switch ( cod ) { case OK : cout < < " Operacion correcta " < < endl . ok ).Modificar Persona " < < endl . } } // −− S u b a l g o r i t m o s −−−− void M o d i f i c a r _ P e r s o n a ( const string & nombre . n_pers ) { ok = NO_ENCONTRADO . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−− void I m p r i m i r _ P e r s o n a ( const string & nombre . const Persona & nuevo . cout < < " e . break . + + i ) { E s c r i b i r _ P e r s o n a ( ag . } else { ok = OK . if ( i > = ag .Borrar Persona " < < endl . do { cout < < " Introduzca Opcion : " . ag ). cout < < " b . pers [ i ] ). break . break . cout < < " d .Salir " < < endl . cout < < endl . Cod_Error & ok ) { int i = Busca r_Pers ona ( nombre . ag ). if ( i > = ag . Agenda & ag . } else { ok = OK . break . Cod_Error & ok ) { for ( int i = 0. Cerrar_Hueco ( ag . } // −− S u b a l g o r i t m o s −−−− char Menu () { char opcion . n_pers ) { ok = NO_ENCONTRADO . } else { ok = OK . ag ). . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−− void I mp ri m ir _A g en da ( const Agenda & ag . pers [ i ] ).Buscar Persona " < < endl . . cout < < " x . Cod_Error & ok ) { int i = Busca r_Pers ona ( nombre . i < ag . const Agenda & ag . . cout < < " a . if ( i > = ag .void B orrar_ Person a ( const string & nombre . . } ok = OK . i ). cin > > opcion . . i ). n_pers ) { ok = NO_ENCONTRADO .Imprimir Agenda " < < endl . n_pers .

cod_postal . para ello.567. E s c r i b i r _ C o d _ E r r o r ( ok ). c ) Diseñe el programa principal y los subprogramas necesarios para comprobar el funcionamiento adecuado de los subprogramas anteriores. Inicializar ( ag ). E s c r i b i r _ C o d _ E r r o r ( ok ). cin > > nombre . break . ag . switch ( opcion ) { case ' a ' : cout < < " Introduzca los datos de la Persona " < < endl . entonces se considera el orden creciente por fecha de nacimiento. ok ). ag . case ' b ' : cout < < " Introduzca Nombre " < < endl . case ' d ' : cout < < " Introduzca Nombre " < < endl . tel . per .¦ } } // −− P r i n c i p a l −−−−−−−− int main () { Agenda ag . A ny ad i r_ P er so n a ( per . ciudad ) " < < endl . Dado una estructura de datos que puede contener hasta un número máximo de 50 personas. Leer_Persona ( per ). break . case ' e ' : I mp ri m ir _ Ag en d a ( ag . cout < < " ( nombre . como su fecha de nacimiento.567 ··· Lucas 23/11/1989 952.456 Lucas 25/08/1992 952. cout < < " Nuevos datos de la Persona " < < endl . break . string nombre . cin > > nombre . piso . diseñe un subprograma para realizar la búsqueda binaria de una persona en la estructura de datos.135. break . ok ).234. case ' c ' : cout < < " Introduzca Nombre " < < endl . ciudad ) " < < endl . num . ok ). num . El criterio de ordenación es en orden creciente por nombre de la persona. ok ). Borr ar_Per sona ( nombre . tel . b ) Dada la estructura de datos ordenada según el criterio de ordenación del apartado anterior. el subprograma recibirá tanto el nombre de la persona.987.123. Antonio 15/05/1997 952. ag . break . char opcion . } ¥ 2. donde cada persona contiene su nombre. Persona per . y en caso de nombres iguales. cin > > nombre .654 ··· María 13/01/1994 952.711 Lucas 14/08/1992 952. do { opcion = Menu (). piso .235. ok ). calle . E s c r i b i r _ C o d _ E r r o r ( ok ). cout < < " ( nombre . calle . Cod_Error ok . la fecha de nacimiento y su teléfono: a ) Diseñe un subprograma para ordenar dicha estructura de datos.234 § Solución # include < iostream > ¤ 97 .246 Lucas 17/03/1992 952. E s c r i b i r _ C o d _ E r r o r ( ok ). E s c r i b i r _ C o d _ E r r o r ( ok ). cod_postal . M o d i f i c a r _ P e r s o n a ( nombre . I m p r i m i r _ P e r s o n a ( nombre . } } while ( opcion ! = ' x ' ). Leer_Persona ( per ). ag .

} //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void Crear_Clave ( Clave & clave . } //−−−−−−−−−−−−−−−−−−−−−−−−−−− void E s c r i b i r _ P e r s o n a ( const Persona & per ) { cout < < per . anyo < < " " . using namespace std :: tr1 . YA_EXISTE }. AG_LLENA . }. fnac ). struct Clave { string nombre . }. nombre . cin > > per . // −− Tipos −−−−−−−−−−−− struct Fecha { int dia . struct Persona { string nombre . NO_ENCONTRADO . anyo . Leer_Fecha ( clave . enum Cod_Error { OK . nombre < < " " . MAX_PERSONAS > Personas . }.# include < iomanip > # include < string > # include < cassert > # include < tr1/array > using namespace std . cout < < setfill ( ' 0 ' ) < < setw (2) < < f . tel . dia < < " / " . // −− C o n s t a n t e s −−−−−−− const int MAX_PERSONAS = 50. Escr ibir_F echa ( per . string tel . fnac ). Fecha fnac . // −− Tipos −−−−−−−−−−−− typedef array < Persona . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void Leer_Clave ( Clave & clave ) { cin > > clave . int anyo . } // −− S u b a l g o r i t m o s −−−− void Leer_Fecha ( Fecha & f ) { cin > > f . int mes . cin > > f . const Persona & per ) 98 . cin > > f . Personas pers . nombre . mes . Leer_Fecha ( per . cout < < per . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void E scribi r_Fech a ( const Fecha & f ) { cout < < setfill ( ' 0 ' ) < < setw (2) < < f . mes < < " / " . // −− S u b a l g o r i t m o s −−−− void Inicializar ( Agenda & ag ) { ag . }. } //−−−−−−−−−−−−−−−−−−−−−−−−−−− void Leer_Persona ( Persona & per ) { cin > > per . tel < < " " . cout < < setfill ( ' 0 ' ) < < setw (4) < < f . n_pers = 0. cout < < endl . struct Agenda { int n_pers . dia . fnac ). Fecha fnac .

nombre ) | | (( p1 . p1 ). fnac = per . const Persona & p2 ) { return ( p1 . f2 ). mes < f2 . mes = = f2 . anyo < f2 . dia < f2 . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline bool es_igual ( const Clave & p1 . } inline bool es_mayor ( const Persona & p1 . mes ) & & ( f1 . tel = = p2 . nombre = = p2 . p2 ). } inline bool es _menor _igual ( const Persona & p1 .{ } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // COMPARACIÓN //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline bool es_igual ( const Fecha & f1 . p1 ). dia = = f2 . fnac . fnac ) & & ( p1 . nombre ) & & es_menor ( p1 . anyo ) | | (( f1 . 99 . } inline bool es_distinto ( const Persona & p1 . const Fecha & f2 ) { return ( f1 . dia ))))). p2 . p2 ). const Persona & p2 ) { return (( p1 . p2 . const Fecha & f2 ) { return es_menor ( f2 . mes = = f2 . clave . tel ). nombre < p2 . const Persona & p2 ) { return ! es_menor ( p1 . anyo = = f2 . fnac . anyo ) & & (( f1 . mes ) | | (( f1 . const Fecha & f2 ) { return ! es_igual ( f1 . const Persona & p2 ) { return ! es_igual ( p1 . } inline bool es _mayor _igual ( const Fecha & f1 . } inline bool es _mayor _igual ( const Persona & p1 . } inline bool es _menor _igual ( const Fecha & f1 . nombre ) & & es_igual ( p1 . } inline bool es_menor ( const Clave & p1 . const Fecha & f2 ) { return ! es_menor ( f1 . fnac ). p2 ). anyo = = f2 . nombre = = p2 . f1 ). nombre = = p2 . fnac . mes ) & & ( f1 . } inline bool es_distinto ( const Clave & p1 . nombre . nombre ) & & es_igual ( p1 . anyo ) & & ( f1 . const Persona & p2 ) { clave . const Persona & p2 ) { return ! es_menor ( p2 . fnac ))). const Fecha & f2 ) { return ! es_menor ( f2 . } inline bool es_mayor ( const Fecha & f1 . } inline bool es_distinto ( const Fecha & f1 . nombre = per . p2 . const Persona & p2 ) { return es_menor ( p2 . const Persona & p2 ) { return ! es_igual ( p1 . f2 ). const Fecha & f2 ) { return (( f1 . } inline bool es_menor ( const Persona & p1 . const Persona & p2 ) { return ( p1 . f1 ). } inline bool es_menor ( const Fecha & f1 . dia ). fnac . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− inline bool es_igual ( const Persona & p1 .

pers . } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // BUSCAR PERSONA CON ORDENACIÓN //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // Busca una Persona en l a Agenda Ordenada // D e v u e l v e su p o s i c i ó n s i s e e n c u e n t r a . n_pers ] = per . nombre ) | | (( p1 . } //−−−−−−−−−−−−−−−−−−−−−−−−−−− void Anyadir ( Agenda & ag . ag ). nombre = = p2 . n_pers ) { ok = YA_EXISTE . fnac ))). p2 . n_pers ) & & es_distinto ( clave . while (( i < ag . } else { i = m + 1. const Agenda & ag ) { int i = 0. pers [ ag . nombre < p2 . n_pers . per ). nombre > p2 . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void A ny ad i r_ Pe r so na ( const Persona & per . } inline bool es _mayor _igual ( const Clave & p1 . } return (( p1 . n_pers en o t r o c a s o int B u s c a r _ P e r s o n a _ B i n a r i a ( const Clave & clave . Agenda & ag . o b i e n >= ag . } else { ok = OK . } if ( i > = f ) { m = ag . p2 . } inline bool es _menor _igual ( const Clave & p1 . nombre ) & & es_mayor ( p1 . nombre = = p2 . Crear_Clave ( clave . const Persona & p2 ) { return (( p1 . const Agenda & ag ) { int i = 0. pers [ m ] )) { f = m. const Persona & per ) { ag . while (( i < f ) & & es_distinto ( clave . o b i e n >= ag . + + ag . fnac . n_pers . fnac . p2 ).} inline bool es_mayor ( const Clave & p1 . ag . n_pers en o t r o c a s o int Buscar _Perso na ( const Clave & clave . } else if ( ag . Cod_Error & ok ) { Clave clave . int m = ( i + f ) / 2. fnac ))). n_pers . per ). int f = ag . pers [ i ] )) { ++i. } return i . nombre ) & & es_menor ( p1 . pers [ m ] )) { if ( es_menor ( clave . const Persona & p2 ) { return ! es_mayor ( p1 . p2 ). n_pers = = int ( ag . Anyadir ( ag . } m = ( i + f ) / 2. int i = Busca r_Pers ona ( clave . ag . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // ANYADIR PERSONA SIN ORDENACIÓN //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // Busca una Persona en l a Agenda // D e v u e l v e su p o s i c i ó n s i s e e n c u e n t r a . const Persona & p2 ) { return ! es_menor ( p1 . nombre ) | | (( p1 . if ( i < ag . size ())) { ok = AG_LLENA . ag . } return m . 100 .

. } } //−−−−−−−−−−−−−−−−−−−−−−−−−−− void I mp ri m ir _A g en da ( const Agenda & ag . int npers = ag .. } } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− // ORDENACIÓN //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− int B us ca r _P o si ci o n ( const Clave & clave . while (( i < ag . Agenda & ag ) { Clave clave . pers [ i ] ). n_pers = 1. ag . cout < < " b . ag . } else { cout < < " Estado : Desordenado " < < endl . if ( ord ) { cout < < " Estado : Ordenado " < < endl . ag ). 101 . n_pers ) { ok = NO_ENCONTRADO . } else { ok = OK . pers [ i ] = ag . const Agenda & ag ) { int i = 0. n_pers . const Agenda & ag . } return i .//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void I m p r i m i r _ P e r s o n a _ O r d ( const Clave & clave . pers [ ag . . E s c r i b i r _ P e r s o n a ( ag . n_pers < npers ) { Persona per = ag . Anyadir_Ord ( ag . Cod_Error & ok ) { ok = OK . . i > pos . cout < < " c . int pos . pers [ i . pers [ i ] )) { ++i. } cout < < " a . pos . n_pers . + + i ) { E s c r i b i r _ P e r s o n a ( ag . cout < < " d . A n y a d i r _ P e r s o n a _ O r d ( per .Anadir Persona " < < endl . + + ag .Imprimir Agenda " < < endl . per ). } ok = OK . pers [ i ] ). while ( ag .Ordenar " < < endl . } //−−−−−−−−−−−−−−−−−−−−−−−−−−− void Anyadir_Ord ( Agenda & ag . int pos = Bu s ca r_ P os ic i on ( clave . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void A n y a d i r _ P e r s o n a _ O r d ( const Persona & per . Cod_Error & ok ) { for ( int i = 0.i ) { ag . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− char Menu ( bool ord ) { char opcion . . . n_pers ] . n_pers ) & & es_may or_igu al ( clave . } ag . pers [ pos ] = per . cout < < endl . Crear_Clave ( clave . ag ).1 ] . n_pers . if ( i > = ag . } //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− void O rdenar _Agend a ( Agenda & ag . ag ). per ). const Persona & per ) { for ( int i = ag . Cod_Error & ok ) { int i = B u s c a r _ P e r s o n a _ B i n a r i a ( clave .Buscar Persona " < < endl . i < ag . n_pers .

ordenada = true . mes . } } // −− P r i n c i p a l −−−−−−−− int main () { bool ordenada = true . ag . anyo " < < endl . ¥ 102 . tel ) " < < endl . case ' b ' : if ( ordenada ) { cout < < " Introduzca Nombre . A ny ad i r_ P er so n a ( nuevo . E s c r i b i r _ C o d _ E r r o r ( ok ). Clave clave . Agenda ag . I m p r i m i r _ P e r s o n a _ O r d ( clave . E s c r i b i r _ C o d _ E r r o r ( ok ). } else { cout < < " Error . case AG_LLENA : cout < < " Agenda llena " < < endl . break . cin > > opcion .Salir " < < endl . } while ( ! ((( opcion > = ' a ' ) & & ( opcion < = ' d ' )) | | ( opcion = = ' x ' ))). ag . case ' c ' : Orde nar_Ag enda ( ag . break . ok ). switch ( opcion ) { case ' a ' : cout < < " Introduzca los datos de la Persona " < < endl . dia .¦ } // −− S u b a l g o r i t m o s −−−− void E s c r i b i r _ C o d _ E r r o r ( Cod_Error cod ) { switch ( cod ) { case OK : cout < < " Operación correcta " < < endl . break . ok ). case NO_ENCONTRADO : cout < < " La persona no se encuentra en la agenda " < < endl . char opcion . Persona nuevo . ok ). Leer_Persona ( nuevo ). . } } while ( opcion ! = ' x ' ). } cout < < " x . E s c r i b i r _ C o d _ E r r o r ( ok ). do { cout < < " Introduzca Opción : " . case ' d ' : I mp ri m ir _ Ag en d a ( ag . return opcion . case YA_EXISTE : cout < < " La persona ya se encuentra en la agenda " < < endl . } break . dia . cout < < " ( nombre . Leer_Clave ( clave ). break . break . ordenada = false . mes . do { opcion = Menu ( ordenada ). break . Inicializar ( ag ). E s c r i b i r _ C o d _ E r r o r ( ok ). break . anyo . la agenda no esta ordenada " < < endl . ok ). Cod_Error ok .