0
Problemas resueltos de capítulos 1 a 6
Veamos ahora algunos ejemplos que utilicen los conocimientos que ya tenemos sobre C++.
Pero antes introduciremos, sin explicarlo en profundidad, dos elementos que nos permitirán que nuestros programas se comuniquen con nosotros. Se trata de la salida estándar, cout y de la entrada estándar cin. Estos objetos nos permiten enviar a la pantalla o leer desde el teclado cualquier variable o constante, incluidos literales. Lo veremos más detalladamente en un capítulo dedicado a ellos, de momento sólo nos interesa cómo usarlos para mostrar o leer cadenas de caracteres y variables.
| Nota: en realidad cout es un objeto de la clase ostream, y cin un objeto de la clase istream pero los conceptos de clase y objeto quedarán mucho más claros en capítulos posteriores. |
El uso es muy simple:
|
#include <iostream>
using namespace std;
cout << <variable|constante> [<< <variable|constante>...];
cin >> <variable> [>> <variable>...]; |
Veamos un ejemplo:
|
#include <iostream>
using namespace std;
int main()
{
int a;
cin >> a;
cout << "la variable a vale " << a;
return 0;
} |
Un método muy útil para cout es endl, que hará que la siguiente salida se imprima en una nueva línea.
| cout << "hola" << endl; |
Otro método, este para cin es get(), que sirve para leer un carácter, pero que nos puede servir para detener la ejecución de un programa.
Esto es especialmente útil cuando trabajamos con compiladores como Dev-C++, que crea programas de consola. Cuando se ejecutan los programas desde el compilador, al terminar se cierra la ventana automáticamente, impidiendo ver los resultados. Usando get() podemos detener la ejecución del programa hasta que se pulse una tecla.
A veces, sobre todo después de una lectura mediante cin, pueden quedar caracteres pendientes de leer. En ese caso hay que usar más de una línea cin.get().
|
#include <iostream>
using namespace std;
int main()
{
int a;
cin >> a;
cout << "la variable a vale " << a;
cin.get();
cin.get();
return 0;
} |
Las líneas #include <iostream> y using namespace std; son necesarias porque las declaraciones que permiten el uso de cout y cin están en una biblioteca externa. Con estos elementos ya podemos incluir algunos ejemplos.
Te aconsejo que intentes resolver los ejemplos antes de ver la solución, o al menos piensa unos minutos sobre ellos.
Ejemplo 6.1
Primero haremos uno fácil. Escribir un programa que muestre una lista de números del 1 al 20, indicando a la derecha de cada uno si es divisible por 3 o no.
|
// Este programa muestra una lista de números,
// indicando para cada uno si es o no múltiplo de 3.
// 11/09/2000 Salvador Pozo
#include <iostream> // biblioteca para uso de cout
using namespace std;
int main() // función principal
{
int i; // variable para bucle
for(i = 1; i <= 20; i++) // bucle for de 1 a 20
{
cout << i; // muestra el número
if(i % 3 == 0) cout << " es múltiplo de 3"; // resto==0
else cout << " no es múltiplo de 3"; // resto != 0
cout << endl; // cambio de línea
}
return 0;
} |
El enunciado es el típico de un problema que puede ser solucionado con un bucle for. Observa el uso de los comentarios, y acostúmbrate a incluirlos en todos tus programas. Acostúmbrate también a escribir el código al mismo tiempo que los comentarios. Si lo dejas para cuando has terminado el programa, probablemente sea demasiado tarde, y la mayoría de las veces no lo harás. ;-)
También es una buena costumbre incluir al principio del programa un comentario extenso que incluya el enunciado del problema, añadiendo también el nombre del autor y la fecha en que se escribió.
Además, cuando hagas revisiones, actualizaciones o correcciones deberías incluir una explicación de cada una de ellas y la fecha en que se hicieron.
Una buena documentación te ahorrará mucho tiempo y te evitará muchos dolores de cabeza.
Ejemplo 6.2
Escribir el programa anterior, pero usando una función para verificar si el número es divisible por tres, y un bucle de tipo while.
|
// Este programa muestra una lista de números,
// indicando para cada uno si es o no múltiplo de 3.
// 11/09/2000 Salvador Pozo
#include <iostream> // biblioteca para uso de cout
using namespace std;
// Prototipos:
bool MultiploDeTres(int n);
int main() // función principal
{
int i = 1; // variable para bucle
while(i <= 20) // bucle hasta i igual a 20
{
cout << i; // muestra el número
if(MultiploDeTres(i)) cout << " es múltiplo de 3";
else cout << " no es múltiplo de 3";
cout << endl; // cambio de línea
i++;
}
return 0;
}
// Función que devuelve verdadero si el parámetro 'n' en
// múltiplo de tres y falso si no lo es
bool MultiploDeTres(int n)
{
if(n % 3) return false; else return true;
} |
Comprueba cómo hemos declarado el prototipo de la función MultiploDeTres. Además, al declarar la variable i le hemos dado un valor inicial 1. Observa que al incluir la función, con el nombre adecuado, el código queda mucho más legible, de hecho prácticamente sobra el comentario.
Por último, fíjate en que la definición de la función va precedida de un comentario que explica lo que hace. Esto también es muy recomendable.
Ejemplo 6.3
Escribir un programa que muestre una salida de 20 líneas de este tipo:
|
1
1 2
1 2 3
1 2 3 4
... |
|
// Este programa muestra una lista de números
// de este tipo:
// 1
// 1 2
// 1 2 3
// ...
// 11/09/2000 Salvador Pozo
#include <iostream> // biblioteca para uso de cout
using namespace std;
int main() // función principal
{
int i, j; // variables para bucles
for(i = 1; i <= 20; i++) // bucle hasta i igual a 20
{
for(j = 1; j <= i; j++) // bucle desde 1 a i
cout << j << " "; // muestra el número
cout << endl; // cambio de línea
}
return 0;
} |
Este ejemplo ilustra el uso de bucles anidados. El bucle interior, que usa j como variable toma valores entre 1 e i. El bucle exterior incluye, además del bucle interior, la orden de cambio de línea, de no ser así, la salida no tendría la forma deseada. Además, después de cada número se imprime un espacio en blanco, de otro modo los números aparecerían amontonados.
Ejemplo 6.4
Escribir un programa que muestre una salida con la siguiente secuencia numérica:
| 1, 5, 3, 7, 5, 9, 7, ..., 23 |
La secuencia debe detenerse al llegar al 23.
El enunciado es rebuscado, pero ilustra el uso de los bucles do..while.
La secuencia se obtiene partiendo de 1 y sumando y restando 4 y 2, alternativamente. Veamos cómo resolverlo:
|
// Programa que genera la secuencia:
// 1, 5, 3, 7, 5, 9, 7, ..., 23
// 11/09/2000 Salvador Pozo
#include <iostream> // biblioteca para uso de cout
using namespace std;
int main() // función principal
{
int i = 1; // variable para bucles
bool sumar = true; // Siguiente operación es suma o resta
bool terminado = false; // Condición de fin
do { // Hacer
cout << i; // muestra el valor en pantalla
terminado = (i == 23); // Actualiza condición de fin
// Puntuación, separadores
if(terminado) cout << "."; else cout << ", ";
// Calcula siguiente elemento
if(sumar) i += 4; else i -= 2;
sumar = !sumar; // Cambia la siguiente operación
} while(!terminado); // ... mientras no se termine
cout << endl; // Cambio de línea
return 0;
} |
Ejemplo 6.5
Escribir un programa que pida varios números, hasta que el quiera terminar, y los descomponga en factores primos.
No seremos especialmente espléndidos en la optimización, por ejemplo, no es probable que valga la pena probar únicamente con números primos para los divisores, podemos probar con algunos que no lo sean, al menos en este ejercicio no será una gran diferencia.
Piensa un momento en cómo resolverlo e inténtalo, después puedes continuar leyendo.
Lo primero que se nos ocurre, al menos a mi, cuando nos dicen que el programa debe ejecutarse mientras el quiera, es implementar un bucle do..while, la condición de salida será que responda de un modo determinado a cierta pregunta.
En cada iteración del bucle pediremos el número a descomponer y comprobaremos si es divisible entre los números entre 2 y el propio número.
No podemos empezar 1, ya que sabemos que todos los números son divisibles por 1 infinitas veces, por eso empezamos por el 2.
Pero si probamos con todos los números, estaremos intentando dividir por todos los pares entre 2 y el número, y sabremos de antemano que ninguno de ellos es un factor, ya que sólo el 2 es primo y par a la vez, por lo tanto, podemos probar con 2, 3 y a partir de ahí incrementar los factores de dos e dos.
Por otra parte, tampoco necesitamos llegar hasta el factor igual al número, en realidad sólo necesitamos alcanzar la raíz cuadrada del número, ya que ninguno de los números primos entre ese valor y número puede ser un factor de número.
Supongamos que tenemos en número 'n', y que la raíz cuadrada de 'n' es 'r'. Si existe un número 'x' mayor que 'r' que es un factor primo de 'n', por fuerza debe existir un número 'h', menor que 'r', que multiplicado por 'x' sea 'n'. Pero ya hemos probado todos los números por debajo de 'r', de modo que si existe ese número 'h' ya lo hemos extraído como factor de 'n', y si hemos llegado a 'r' sin encontrarlo, es que tampoco existe 'x'.
Por ejemplo, el número 257. Su raíz cuadrada es (aproximada), 16. Es decir, deberíamos probar con 2, 3, 5, 7, 11 y 13 (nuestro programa probará con 2, 3, 5, 7, 9, 11, 13 y 15, pero bueno). Ninguno de esos valores es un factor de 257. El siguiente valor primo a probar sería 17, pero sabemos que el resultado de dividir 257 por 17 es menor que 17, puesto que la raíz cuadrada de 257 es 16.031. Sin embargo ya hemos probado con todos los primos menores de 17, con resultado negativo, así que podemos decir que 17 no es factor de 257, ni tampoco, por la misma razón, ningún número mayor que él.
Ya tenemos dos buenas optimizaciones, veamos cómo queda el programa:
|
// Programa que descompone números en factores primos
// 26/07/2003 Salvador Pozo
#include <iostream> // biblioteca para uso de cout
using namespace std;
int main()
{
int numero;
int factor;
char resp[12];
do {
cout << "Introduce un número entero: ";
cin >> numero;
factor = 2;
while(numero >= factor*factor) {
if(!(numero % factor)) {
cout << factor << " * ";
numero = numero / factor;
continue;
}
if(factor == 2) factor++;
else factor += 2;
}
cout << numero << endl;
cout << "Descomponer otro número?: ";
cin >> resp;
} while(resp[0] == 's' || resp[0] == 'S');
return 0;
} |
Vemos claramente el bucle do..while, que termina leyendo una cadena y repitiendo el bucle si empieza por 's' o 'S'.
En cada iteración se lee un numero, y se empieza con el factor 2. Ahora entramos en otro bucle, este while, que se repite mientras el factor sea menor que la raíz cuadrada de numero (o mientras numero sea mayor o igual al factor al cuadrado).
Dentro de ese bucle, si numero es divisible entre factor, mostramos el factor, actualizamos el valor de numero, dividiéndolo por factor, y repetimos el bucle. Debemos probar de nuevo con factor, ya que puede ser factor primo varias veces. Para salir del bucle sin ejecutar el resto de las sentencias usamos la sentencia continue.
Si factor no es un factor primo de numero, calculamos el siguiente valor de factor, que será 3 si factor es 2, y factor + 2 en otro caso.
Cuando hemos acabado el bucle while, el valor de numero será el del último factor.
Puedes intentar modificar este programa para que muestre los factores repetidos en forma exponencial, en lugar de repetitiva, así, los factores de 256, en lugar de ser: "2 * 2 * 2 * 2 * 2 * 2 * 2 * 2", serían "28".
Ir al Principio
Comentarios