EJEMPLOS DE EJERCICIOS RESUELTOS

Veamos algunos ejemplos que utilicen los que ya sabemos de C++.

Pero antes introduciremos, sin explicarlo en profundidad, dos elementos que nos permitirn
que nuestros programas se comuniquen con nosotros. Se trata de la salida estndar, "cout" y
de la entrada estndar "cin". Estos elementos nos permiten enviar a la pantalla o leer desde
el teclado cualquier variable o constante, incluidos literales. Lo veremos ms
detalladamente en un captulo dedicado a ellos, de momento slo nos interesa cmo 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 quedarn mucho ms claros en captulos
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 mtodo muy til para "cout" es "endl", que har que la siguiente salida se imprima en
una nueva lnea.
cout << "hola" << endl;

Otro mtodo, este para "cin" es get(), que sirve para leer un carcter, pero que nos puede
servir para detener la ejecucin 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 automticamente, impidiendo ver los resultados. Usando get() podemos
detener la ejecucin del programa hasta que se pulse una tecla.
A veces, sobre todo despus de una lectura mediante cin, pueden quedar caracteres
pendiente de leer. En ese caso hay que usar ms de una lnea 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 lneas "#include <iostream>" y "using namespace std;" son necesarias porque las
declaraciones que permiten el acceso a "cout" y "cin" estn en una librera externa. Con
estos elementos ya podemos incluir algunos ejemplos.
Te aconsejo que intentes resolver los ejemplos antes de ver la solucin, o al menos piensa
unos minutos sobre ellos.

Ejemplo 1
Primero haremos uno fcil. Escribir un programa que muestre una lista de nmeros del 1 al
20, indicando a la derecha de cada uno si es divisible por 3 o no.
// Este programa muestra una lista de nmeros,
// indicando para cada uno si es o no mltiplo de 3.
// 11/09/2000 Salvador Pozo
#include <iostream> // librera para uso de cout
using namespace std;
int main() // funcin principal
{
int i; // variable para bucle
for(i =
{
cout
if(i
else
cout
}

1; i <= 20; i++) // bucle for de 1 a 20

<< i; // muestra el nmero
% 3 == 0) cout << " es mltiplo de 3"; // resto==0
cout << " no es mltiplo de 3"; // resto != 0
<< endl; // cambio de lnea

cin.get();
return 0;
}

El enunciado es el tpico de un problema que puede ser solucionado con un bucle "for".
Observa el uso de los comentarios, y acostmbrate a incluirlos en todos tus programas.
Acostmbrate tambin a escribir el cdigo al mismo tiempo que los comentarios. Si lo
dejas para cuando has terminado el cdigo, probablemente sea demasiado tarde, y la
mayora de las veces no lo hars. ;-)
Tambin es una buena costumbre incluir al principio del programa un comentario extenso
que incluya el enunciado del problema, aadiendo tambin el nombre del autor y la fecha
en que se escribi. Adems, cuando hagas revisiones, actualizaciones o correcciones
deberas incluir una explicacin de cada una de ellas y la fecha en que se hicieron.
Una buena documentacin te ahorrar mucho tiempo y te evitar muchos dolores de
cabeza.

Ejemplo 2
Escribir el programa anterior, pero usando una funcin para verificar si el nmero es
divisible por tres, y un bucle de tipo "while".
// Este programa muestra una lista de nmeros,
// indicando para cada uno si es o no mltiplo de 3.
// 11/09/2000 Salvador Pozo
#include <iostream> // librera para uso de cout
using namespace std;
// Prototipos:
bool MultiploDeTres(int n);
int main() // funcin principal
{
int i = 1; // variable para bucle
while(i <= 20) // bucle hasta i igual a 20
{
cout << i; // muestra el nmero
if(MultiploDeTres(i)) cout << " es mltiplo de 3";
else cout << " no es mltiplo de 3";
cout << endl; // cambio de lnea
i++;
}
cin.get();
return 0;
}
// Funcin que devuelve verdadero si el parmetro 'n' en
// mltiplo de tres y falso si no lo es
bool MultiploDeTres(int n)
{
if(n % 3) return false; else return true;
}

Comprueba cmo hemos declarado el prototipo de la funcin "MultiploDeTres". Adems,

al declarar la variable i le hemos dado un valor inicial 1. Observa que al incluir la funcin,
con el nombre adecuado, el cdigo queda mucho ms legible, de hecho prcticamente sobra
el comentario. Por ltimo, fjate en que la definicin de la funcin va precedida de un
comentario que explica lo que hace. Esto tambin es muy recomendable.

Ejemplo 3
Escribir un programa que muestre una salida de 20 lneas de este tipo:
1
1 2
1 2 3
1 2 3 4
...

//
//
//
//
//
//

Este programa muestra una lista de nmeros

de este tipo:
1
1 2
1 2 3
...

// 11/09/2000 Salvador Pozo

#include <iostream> // librera para uso de cout
using namespace std;
int main() // funcin principal
{
int i, j; // variables para bucles
for(i = 1;
{
for(j =
cout
cout <<
}
cin.get();
return 0;
}

i <= 20; i++) // bucle hasta i igual a 20

1; j <= i; j++) // bucle desde 1 a i
<< j << " "; // muestra el nmero
endl; // cambio de lnea

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, adems del bucle interior, la orden de
cambio de lnea, de no ser as, la salida no tendra la forma deseada. Adems, despus de
cada nmero se imprime un espacio en blanco, de otro modo los nmeros apareceran
amontonados.

Ejemplo 4
Escribir un programa que muestre una salida con la siguiente secuencia numrica: 1, 5, 3, 7,
5, 9, 7, ..., 23La 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 cmo resolverlo:

// Programa que genera la secuencia:

// 1, 5, 3, 7, 5, 9, 7, ..., 23
// 11/09/2000 Salvador Pozo
#include <iostream> // librera para uso de cout
using namespace std;
int main() // funcin principal
{
int i = 1; // variable para bucles
bool sumar = true; // Siguiente operacin es suma o resta
bool terminado = false; // Condicin de fin
do { // Hacer
cout << i; // muestra el valor en pantalla
terminado = (i == 23); // Actualiza condicin de fin
// Puntuacin, separadores
if(terminado) cout << "."; else cout << ", ";
// Calcula siguiente elemento
if(sumar) i += 4; else i -= 2;
sumar = !sumar; // Cambia la siguiente operacin
} while(!terminado); // ... mientras no se termine
cout << endl; // Cambio de lnea
cin.get();
return 0;
}

Ejemplo 5

Escribir un programa que pida varios nmeros, hasta que el usuario quiera terminar, y los
descomponga en factores primos.
No seremos especialmente esplndidos en la optimizacin, por ejemplo, no es probable que
valga la pena probar nicamente con nmeros 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 cmo resolverlo e intntalo, despus puedes continuar leyendo.
Lo primero que se nos ocurre, al menos a mi, cuando nos dicen que el programa debe
ejecutarse mientras el usuario quiera, es implementar un bucle "do..while", la condicin de
salida ser que usuario responda de un modo determinado a cierta pregunta.
En cada iteracin del bucle pediremos el nmero a descomponer y comprobaremos si es
divisible entre los nmeros entre 2 y el propio nmero.
No podemos empezar 1, ya que sabemos que todos los nmeros son divisibles entre 1
infinitas veces, por eso empezamos por el 2.
Pero si probamos con todos los nmeros, estaremos intentando dividir por todos los pares
entre 2 y el nmero, y sabremos de antemano que ninguno de ellos es un factor, ya que slo
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 nmero, en realidad slo
necesitamos alcanzar la raz cuadrada del nmero, ya que ninguno de los nmeros primos
entre ese valor y nmero puede ser un factor de nmero.
Supongamos que tenemos en nmero 'n', y que la raz cuadrada de 'n' es 'r'. Si existe un
nmero 'x' mayor que 'r' que es un factor primo de 'n', por fuerza debe existir un nmero 'h',
menor que 'r', que multiplicado por 'x' sea 'n'. Pero ya hemos probado todos los nmeros por
debajo de 'r', de modo que si existe ese nmero 'h' ya lo hemos extrado como factor de 'n',
y si hemos llegado a 'r' sin encontrarlo, es que tampoco existe 'x'.
Por ejemplo, el nmero 257. Su raz cuadrada es (aproximada), 16. Es decir, deberamos
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 sera
17, pero sabemos que el resultado de dividir 257 por 17 es menor que 17, puesto que la raz
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 razn, ningn nmero mayor que l.

Ya tenemos dos buenas optimizaciones, veamos cmo queda el programa:

// Programa que descompone nmeros en factores primos

// 26/07/2003 Salvador Pozo
#include <iostream> // librera para uso de cout
using namespace std;
int main()
{
int numero;
int factor;
char resp[12];
do {
cout << "Introduce un nmero 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 nmero?: ";
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 iteracin 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 raz 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, dividindolo 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 nmero, 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", seran "28".